Skip to content

flurdy/agent-skills / skills/next

Rank ready beads across validated workspace stores or one local store. List read-only, or claim one selected bead, show its details, and continue into its work.

tests/test_next_select.py

View on GitHub
from __future__ import annotations

import json
import shutil
import subprocess
import unittest
from pathlib import Path

from workspace_fixture import SKILL_DIR, WorkspaceFixture, issue

SCRIPT = SKILL_DIR / "scripts" / "next-select"

FAKE_HANDOFF_LIST = """#!/usr/bin/env bash
set -euo pipefail
echo "---HANDOFF-CWD---"
pwd -P
echo "---HANDOFF-ARGS---"
printf '%s\\n' "$@"
"""


class NextSelectTest(WorkspaceFixture):
    def run_select(
        self, directory: Path, *arguments: str, script: Path = SCRIPT
    ) -> subprocess.CompletedProcess[str]:
        return self.run_script(script, directory, *arguments, check=False)

    def colliding_workspace(self) -> Path:
        return self.create_workspace(
            root_data={"ready": [issue("root-task", 3, "task", "2026-01-04T00:00:00Z")]},
            repositories={
                "repo-a": {
                    "ready": [issue("dup-1", 2, "task", "2026-01-02T00:00:00Z")],
                    "other": [issue("only-a", 2, "task", "2026-01-01T00:00:00Z")],
                },
                "repo-b": {
                    "ready": [issue("dup-1", 1, "bug", "2026-01-01T00:00:00Z")]
                },
            },
        )

    def update_calls(self) -> list[dict[str, object]]:
        return [
            call for call in self.recorded_calls() if call["arguments"][0] == "update"
        ]

    def comment_add_calls(self) -> list[dict[str, object]]:
        return [
            call
            for call in self.recorded_calls()
            if call["arguments"][:2] == ["comments", "add"]
        ]

    def test_priority_first_picker_rejects_old_index_and_claims_displayed_row(self) -> None:
        workspace = self.create_workspace(
            root_data={"ready": [issue("p1-task", 1, "task", "2026-01-02T00:00:00Z")]},
            repositories={"repo-a": {"ready": [
                issue("p2-bug", 2, "bug", "2026-01-01T00:00:00Z")]}},
        )
        result = self.run_select(workspace, "resolve", "1", "--expect-id", "p1-task")
        self.assertEqual(result.returncode, 0, result.stdout)
        self.assertEqual(json.loads(result.stdout)["repository"], "workspace")
        stale = self.run_select(workspace, "start", "1", "--expect-id", "p2-bug")
        self.assertEqual(stale.returncode, 6)
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])
        started = self.run_select(workspace, "start", "1", "--expect-id", "p1-task")
        self.assertEqual(started.returncode, 0, started.stdout)
        self.assertEqual(len(self.update_calls()), 1)
        self.assertEqual(self.update_calls()[0]["arguments"][1], "p1-task")

    def test_invalid_read_budget_fails_before_any_read_or_claim(self) -> None:
        workspace = self.colliding_workspace()
        for value in ("", "0", "121", "1.5", "nan", "private-invalid-value"):
            self.environment["NEXT_BEADS_READ_TIMEOUT_SECONDS"] = value
            for command in ("resolve", "start", "handoff", "stores"):
                with self.subTest(value=value, command=command):
                    arguments = (command,) if command == "stores" else (command, "repo-a:dup-1")
                    result = self.run_select(workspace, *arguments)
                    self.assertEqual(result.returncode, 2)
                    self.assertIn("NEXT_BEADS_READ_TIMEOUT_SECONDS", result.stderr)
                    self.assertNotIn("private-invalid-value", result.stderr)
            result = self.run_script(SKILL_DIR / "scripts" / "next-bd", workspace, "--json", check=False)
            self.assertNotEqual(result.returncode, 0)
            self.assertIn("NEXT_BEADS_READ_TIMEOUT_SECONDS", result.stderr)
        self.assertEqual(self.recorded_calls(), [])

    def test_real_subprocess_read_timeouts_fail_closed(self) -> None:
        workspace = self.create_workspace(
            root_data={"ready": [issue("task-1", 2, "task", "2026-01-01T00:00:00Z")],
                       "delays": {"probe": 1.5, "show": 1.5}})
        self.environment["NEXT_BEADS_READ_TIMEOUT_SECONDS"] = "1"
        for directory, selector in ((workspace, "workspace:task-1"),
                                    (workspace, "task-1")):
            # Remove the manifest for the second iteration to exercise local show.
            if selector == "task-1":
                (workspace / "workspace.json").unlink()
            result = self.run_select(directory, "start", selector)
            self.assertEqual(result.returncode, 5)
            self.assertIn("deadline 1s", json.loads(result.stdout)["failures"][0]["error"])
        self.assertEqual(len(self.recorded_calls()), 2)
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])

    def test_reads_reuse_exact_owner_but_each_start_resolves_once(self) -> None:
        workspace = self.colliding_workspace()
        resolved = json.loads(self.run_select(workspace, "resolve", "repo-a:dup-1").stdout)
        for _ in range(2):
            subprocess.run(["bd", "-C", resolved["directory"], "show", resolved["id"], "--json", "--readonly"],
                           env=self.environment, check=True, capture_output=True, text=True)
        self.assertEqual(sum("--id" in call["arguments"] for call in self.recorded_calls()), 1)
        for selector in ("repo-a:dup-1", "repo-b:dup-1"):
            before = len(self.recorded_calls())
            self.assertEqual(self.run_select(workspace, "start", selector).returncode, 0)
            calls = self.recorded_calls()[before:]
            self.assertEqual(sum("--id" in call["arguments"] for call in calls), 1)
            self.assertIn("--id", calls[0]["arguments"])
            self.assertEqual(calls[0]["directory"], calls[-2]["directory"])

    def test_prior_success_never_bypasses_later_unavailable_resolution(self) -> None:
        workspace = self.colliding_workspace()
        self.assertEqual(self.run_select(workspace, "resolve", "repo-a:dup-1").returncode, 0)
        fixture = self.base / "sources" / "repo-a" / ".beads" / "fixture.json"
        payload = json.loads(fixture.read_text())
        payload["faults"] = {"probe": "error"}
        fixture.write_text(json.dumps(payload))
        for command in ("resolve", "start"):
            result = self.run_select(workspace, command, "repo-a:dup-1")
            self.assertEqual(result.returncode, 5)
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])

    def test_changed_topology_store_or_context_requires_new_resolution(self) -> None:
        workspace = self.colliding_workspace()
        selector = "repo-a:dup-1"
        self.assertEqual(self.run_select(workspace, "resolve", selector).returncode, 0)
        self.declare_tracking(workspace, **{"repo-a": "workspace"})
        self.assertEqual(self.run_select(workspace, "start", selector).returncode, 5)
        self.declare_tracking(workspace, **{"repo-a": "local"})
        member = self.base / "sources" / "repo-a"
        shutil.rmtree(member / ".beads")
        self.assertEqual(self.run_select(workspace, "start", selector).returncode, 5)
        local = self.base / "unrelated"
        self.create_store(local)
        self.environment["PI_SESSION_ID"] = "new-session"
        self.assertEqual(self.run_select(local, "start", selector).returncode, 4)
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])

    def test_invented_resolution_cannot_be_passed_to_start(self) -> None:
        workspace = self.colliding_workspace()
        result = self.run_select(workspace, "start", "repo-a:dup-1", "--resolved-directory", str(workspace))
        self.assertEqual(result.returncode, 2)
        self.assertEqual(self.recorded_calls(), [])

    def test_index_selection_resolves_the_owning_store(self) -> None:
        workspace = self.colliding_workspace()

        result = self.run_select(workspace, "resolve", "1")

        self.assertEqual(result.returncode, 0)
        resolved = json.loads(result.stdout)
        self.assertEqual(resolved["status"], "resolved")
        self.assertEqual(resolved["repository"], "repo-b")
        self.assertEqual(resolved["repository_path"], "repos/repo-b")
        self.assertEqual(
            Path(resolved["directory"]),
            (self.base / "sources" / "repo-b").resolve(),
        )
        self.assertEqual(self.update_calls(), [])

    def test_out_of_range_index_resolves_to_nothing(self) -> None:
        workspace = self.colliding_workspace()

        result = self.run_select(workspace, "resolve", "99")

        self.assertEqual(result.returncode, 4)
        self.assertEqual(json.loads(result.stdout)["status"], "not-found")
        self.assertEqual(self.update_calls(), [])

    def test_colliding_bare_id_is_rejected_before_mutation(self) -> None:
        workspace = self.colliding_workspace()

        for command in ("resolve", "start"):
            result = self.run_select(workspace, command, "dup-1")

            self.assertEqual(result.returncode, 3)
            rejected = json.loads(result.stdout)
            self.assertEqual(rejected["status"], "ambiguous")
            self.assertEqual(
                sorted(match["selector"] for match in rejected["matches"]),
                ["repo-a:dup-1", "repo-b:dup-1"],
            )
        self.assertEqual(self.update_calls(), [])

    def test_qualified_selector_starts_only_in_the_owning_store(self) -> None:
        workspace = self.colliding_workspace()

        result = self.run_select(workspace, "start", "repo-b:dup-1")

        self.assertEqual(result.returncode, 0)
        self.assertEqual(
            [
                (Path(str(call["directory"])), call["arguments"])
                for call in self.update_calls()
            ],
            [
                (
                    (self.base / "sources" / "repo-b").resolve(),
                    ["update", "dup-1", "--status=in_progress"],
                )
            ],
        )

    def test_start_records_one_idempotent_claim_in_the_owning_store(self) -> None:
        workspace = self.colliding_workspace()
        self.environment["PI_SESSION_ID"] = "pi-session-123"

        first = self.run_select(workspace, "start", "repo-b:dup-1")
        retry = self.run_select(workspace, "start", "repo-b:dup-1")

        self.assertEqual(first.returncode, 0)
        self.assertEqual(retry.returncode, 0)
        additions = self.comment_add_calls()
        self.assertEqual(len(additions), 1)
        self.assertEqual(
            Path(str(additions[0]["directory"])),
            (self.base / "sources" / "repo-b").resolve(),
        )
        arguments = additions[0]["arguments"]
        self.assertEqual(arguments[2], "dup-1")
        comment = str(arguments[3])
        self.assertIn("agent-claim:v1", comment)
        self.assertIn("session_id: pi-session-123", comment)
        self.assertIn(
            f"owning_store: {(self.base / 'sources' / 'repo-b').resolve()}",
            comment,
        )
        self.assertRegex(
            comment,
            r"claimed_at_utc: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z",
        )
        self.assertIn("Session activity is unverified.", comment)

    def test_new_session_records_a_distinct_claim_on_an_in_progress_issue(self) -> None:
        workspace = self.create_workspace(
            root_data={
                "ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")]
            }
        )
        self.environment["PI_SESSION_ID"] = "pi-session-one"
        self.assertEqual(
            self.run_select(workspace, "start", "root-task").returncode, 0
        )
        self.environment["PI_SESSION_ID"] = "pi-session-two"

        second = self.run_select(workspace, "start", "root-task")

        self.assertEqual(second.returncode, 0)
        comments = [str(call["arguments"][3]) for call in self.comment_add_calls()]
        self.assertEqual(len(comments), 2)
        self.assertIn("session_id: pi-session-one", comments[0])
        self.assertIn("session_id: pi-session-two", comments[1])

    def test_failed_update_reuses_the_attribution_on_retry(self) -> None:
        workspace = self.create_workspace(
            root_data={
                "ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")],
                "faults": {"update": "error"},
            }
        )
        self.environment["PI_SESSION_ID"] = "pi-retry-session"

        failed = self.run_select(workspace, "start", "root-task")
        fixture = workspace / ".beads" / "fixture.json"
        payload = json.loads(fixture.read_text(encoding="utf-8"))
        payload["faults"] = {}
        fixture.write_text(json.dumps(payload), encoding="utf-8")
        retry = self.run_select(workspace, "start", "root-task")

        self.assertEqual(failed.returncode, 9)
        self.assertEqual(retry.returncode, 0)
        self.assertEqual(len(self.comment_add_calls()), 1)
        updated = json.loads(fixture.read_text(encoding="utf-8"))
        self.assertEqual([item["id"] for item in updated["in_progress"]], ["root-task"])

    def test_ambiguous_comment_write_is_reconciled_without_a_duplicate(self) -> None:
        workspace = self.create_workspace(
            root_data={
                "ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")],
                "faults": {"comments-add": "after-write-error"},
            }
        )
        self.environment["PI_SESSION_ID"] = "pi-ambiguous-session"

        failed = self.run_select(workspace, "start", "root-task")
        fixture = workspace / ".beads" / "fixture.json"
        payload = json.loads(fixture.read_text(encoding="utf-8"))
        payload["faults"] = {}
        fixture.write_text(json.dumps(payload), encoding="utf-8")
        retry = self.run_select(workspace, "start", "root-task")

        self.assertEqual(failed.returncode, 9)
        self.assertEqual(retry.returncode, 0)
        self.assertEqual(len(self.comment_add_calls()), 1)
        updated = json.loads(fixture.read_text(encoding="utf-8"))
        self.assertEqual(len(updated["comments"]), 1)
        self.assertEqual([item["id"] for item in updated["in_progress"]], ["root-task"])

    def test_concurrent_retries_are_serialized(self) -> None:
        workspace = self.create_workspace(
            root_data={
                "ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")],
                "delays": {"comments": 0.2},
            }
        )
        self.environment["PI_SESSION_ID"] = "pi-concurrent-session"
        command = [str(SCRIPT), "start", "root-task"]

        first = subprocess.Popen(
            command,
            cwd=workspace,
            env=self.environment,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
        )
        second = subprocess.Popen(
            command,
            cwd=workspace,
            env=self.environment,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
        )
        first.communicate(timeout=10)
        second.communicate(timeout=10)

        self.assertEqual(first.returncode, 0)
        self.assertEqual(second.returncode, 0)
        self.assertEqual(len(self.comment_add_calls()), 1)

    def test_unreadable_claim_history_fails_without_risking_a_duplicate(self) -> None:
        workspace = self.create_workspace(
            root_data={
                "ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")],
                "faults": {"comments": "invalid-json"},
            }
        )

        result = self.run_select(workspace, "start", "root-task")

        self.assertNotEqual(result.returncode, 0)
        self.assertIn("invalid comment JSON", result.stderr)
        self.assertEqual(self.comment_add_calls(), [])
        payload = json.loads(
            (workspace / ".beads" / "fixture.json").read_text(encoding="utf-8")
        )
        self.assertEqual(payload["in_progress"], [])

    def test_unqualified_id_outside_the_ready_list_resolves_to_its_owner(self) -> None:
        workspace = self.colliding_workspace()

        result = self.run_select(workspace, "resolve", "only-a")

        self.assertEqual(result.returncode, 0)
        self.assertEqual(json.loads(result.stdout)["repository"], "repo-a")

    def test_qualifier_that_does_not_own_the_bead_is_rejected(self) -> None:
        workspace = self.colliding_workspace()

        for selector in ("repo-b:only-a", "nosuch:dup-1"):
            result = self.run_select(workspace, "start", selector)

            self.assertEqual(result.returncode, 4)
            rejected = json.loads(result.stdout)
            self.assertEqual(rejected["status"], "not-found")
            self.assertEqual(rejected["selector"], selector)
        self.assertEqual(self.update_calls(), [])

    def test_index_whose_bead_moved_is_rejected_before_mutation(self) -> None:
        workspace = self.colliding_workspace()

        result = self.run_select(workspace, "start", "1", "--expect-id", "root-task")

        self.assertEqual(result.returncode, 6)
        stale = json.loads(result.stdout)
        self.assertEqual(stale["status"], "stale")
        self.assertEqual(stale["expected"], "root-task")
        self.assertEqual(stale["actual"], "dup-1")
        self.assertEqual(self.update_calls(), [])

    def test_bare_id_probe_failure_is_unavailable_before_mutation(self) -> None:
        workspace = self.create_workspace(
            repositories={
                "healthy": {
                    "other": [issue("healthy-only", 2, "task", "2026-01-01T00:00:00Z")]
                },
                "broken": {"faults": {"probe": "error"}},
            }
        )

        result = self.run_select(workspace, "start", "healthy-only")

        self.assertEqual(result.returncode, 5)
        unavailable = json.loads(result.stdout)
        self.assertEqual(unavailable["status"], "unavailable")
        self.assertEqual(unavailable["matches"][0]["selector"], "healthy:healthy-only")
        self.assertEqual(unavailable["failures"][0]["repository"], "broken")
        self.assertIn("simulated probe failure", unavailable["failures"][0]["error"])
        self.assertNotIn("hint", unavailable["failures"][0])
        self.assertEqual(self.update_calls(), [])

    def test_storeless_member_hint_preserves_unavailable_and_does_not_write(self) -> None:
        workspace = self.create_workspace(
            root_data={"ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")]},
            repositories={"storeless": {}},
        )
        member = self.base / "sources" / "storeless"
        shutil.rmtree(member / ".beads")
        manifest = workspace / "workspace.json"
        original_manifest = manifest.read_bytes()
        fixture = workspace / ".beads" / "fixture.json"
        original_fixture = fixture.read_bytes()

        for command in ("resolve", "handoff", "start"):
            for selector in ("root-task", "storeless:root-task"):
                with self.subTest(command=command, selector=selector):
                    result = self.run_select(workspace, command, selector)
                    self.assertEqual(result.returncode, 5)
                    payload = json.loads(result.stdout)
                    self.assertEqual(payload["status"], "unavailable")
                    self.assertEqual(payload["selector"], selector)
                    if selector == "root-task":
                        self.assertEqual(payload["matches"], [{
                            "repository": "workspace", "repository_path": ".",
                            "selector": "workspace:root-task",
                        }])
                    failure = payload["failures"][0]
                    self.assertEqual(failure["repository"], "storeless")
                    self.assertEqual(failure["error"], "missing .beads store")
                    self.assertIn("hint", failure)
                    self.assertIn("beadsStore is omitted", failure["hint"])
                    self.assertIn('"beadsStore": "workspace"', failure["hint"])
                    self.assertIn("Confirm tracking policy", failure["hint"])
                    self.assertIn("restore its local store", failure["hint"])
                    self.assertIn("does not prove ownership", failure["hint"])
                    self.assertNotIn("owner", payload)
                    self.assertNotIn("owner_selector", payload)

        qualified = self.run_select(workspace, "resolve", "workspace:root-task")
        self.assertEqual(qualified.returncode, 0)
        self.assertEqual(json.loads(qualified.stdout)["directory"], str(workspace.resolve()))
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])
        self.assertFalse(any(Path(call["directory"]) == member.resolve() for call in self.recorded_calls()))
        self.assertEqual(manifest.read_bytes(), original_manifest)
        self.assertEqual(fixture.read_bytes(), original_fixture)
        self.assertFalse((member / ".beads").exists())

    def test_explicit_local_missing_store_gets_no_workspace_ownership_hint(self) -> None:
        workspace = self.create_workspace(
            root_data={"ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")]},
            repositories={"independent": {}},
        )
        self.declare_tracking(workspace, independent="local")
        shutil.rmtree(self.base / "sources" / "independent" / ".beads")

        result = self.run_select(workspace, "start", "root-task")

        self.assertEqual(result.returncode, 5)
        payload = json.loads(result.stdout)
        self.assertEqual(payload["matches"][0]["selector"], "workspace:root-task")
        self.assertEqual(payload["failures"], [{
            "repository": "independent", "repository_path": "repos/independent",
            "error": "missing .beads store",
        }])
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])

    def test_unusable_store_entries_get_no_ownership_hint(self) -> None:
        workspace = self.create_workspace(
            root_data={"ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")]},
            repositories={"broken": {}},
        )
        beads = self.base / "sources" / "broken" / ".beads"
        shutil.rmtree(beads)
        for kind in ("file", "dangling-symlink"):
            with self.subTest(kind=kind):
                if kind == "file":
                    beads.write_text("not a store", encoding="utf-8")
                else:
                    beads.symlink_to(self.base / "absent")
                result = self.run_select(workspace, "start", "root-task")
                self.assertEqual(result.returncode, 5)
                failure = json.loads(result.stdout)["failures"][0]
                self.assertIn("unusable .beads store", failure["error"])
                self.assertNotIn("hint", failure)
                beads.unlink()
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])

    def test_storeless_hint_does_not_override_known_ambiguity(self) -> None:
        duplicate = issue("dup-1", 2, "task", "2026-01-01T00:00:00Z")
        workspace = self.create_workspace(
            root_data={"ready": [duplicate]},
            repositories={"independent": {"ready": [duplicate]}, "storeless": {}},
        )
        shutil.rmtree(self.base / "sources" / "storeless" / ".beads")

        result = self.run_select(workspace, "start", "dup-1")

        self.assertEqual(result.returncode, 3)
        payload = json.loads(result.stdout)
        self.assertEqual(payload["status"], "ambiguous")
        self.assertEqual({row["selector"] for row in payload["matches"]}, {"workspace:dup-1", "independent:dup-1"})
        self.assertIn("hint", payload["failures"][0])
        self.assertEqual(self.update_calls(), [])
        self.assertEqual(self.comment_add_calls(), [])

    def test_local_missing_store_gets_no_workspace_hint(self) -> None:
        local = self.base / "local"
        self.create_store(local)
        shutil.rmtree(local / ".beads")

        result = self.run_select(local, "resolve", "local:root-task")

        self.assertEqual(result.returncode, 5)
        self.assertEqual(json.loads(result.stdout)["failures"], [{
            "repository": "local", "repository_path": ".", "error": "missing .beads store",
        }])
        self.assertEqual(self.recorded_calls(), [])

    def test_qualified_and_index_selection_keep_healthy_source_usable(self) -> None:
        workspace = self.create_workspace(
            root_data={
                "ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")]
            },
            repositories={
                "healthy": {
                    "other": [issue("healthy-only", 2, "task", "2026-01-01T00:00:00Z")]
                },
                "broken": {
                    "faults": {"ready": "error", "probe": "error"}
                },
            },
        )

        qualified = self.run_select(workspace, "start", "healthy:healthy-only")
        indexed = self.run_select(
            workspace, "start", "1", "--expect-id", "root-task"
        )

        self.assertEqual(qualified.returncode, 0)
        self.assertEqual(indexed.returncode, 0)
        self.assertEqual(
            [Path(str(call["directory"])) for call in self.update_calls()],
            [(self.base / "sources" / "healthy").resolve(), workspace.resolve()],
        )

    def test_qualified_source_probe_failure_is_unavailable(self) -> None:
        workspace = self.create_workspace(
            repositories={"broken": {"faults": {"probe": "invalid-json"}}}
        )

        result = self.run_select(workspace, "start", "broken:any-id")

        self.assertEqual(result.returncode, 5)
        unavailable = json.loads(result.stdout)
        self.assertEqual(unavailable["status"], "unavailable")
        self.assertEqual(unavailable["failures"][0]["repository"], "broken")
        self.assertIn("invalid bd JSON", unavailable["failures"][0]["error"])
        self.assertEqual(self.update_calls(), [])

    def test_handoff_lookup_runs_in_the_owning_repository(self) -> None:
        workspace = self.colliding_workspace()
        skills_root = self.base / "skills"
        shutil.copytree(SKILL_DIR, skills_root / "next")
        handoff_list = skills_root / "handoffs" / "scripts" / "list.sh"
        handoff_list.parent.mkdir(parents=True)
        handoff_list.write_text(FAKE_HANDOFF_LIST, encoding="utf-8")
        handoff_list.chmod(0o755)

        result = self.run_select(
            workspace,
            "handoff",
            "repo-b:dup-1",
            "--check-branches",
            script=skills_root / "next" / "scripts" / "next-select",
        )

        self.assertEqual(result.returncode, 0)
        cwd_line, arguments = result.stdout.split("---HANDOFF-ARGS---")
        self.assertEqual(
            Path(cwd_line.splitlines()[1]),
            (self.base / "sources" / "repo-b").resolve(),
        )
        self.assertEqual(arguments.split(), ["--bead", "dup-1", "--check-branches"])
        self.assertEqual(self.update_calls(), [])

    def test_local_mode_keeps_shorthand_and_store_fallback_behavior(self) -> None:
        local = self.base / "local-compat"
        self.create_store(
            local, ready=[issue("local-task", 2, "task", "2026-01-01T00:00:00Z")]
        )

        shorthand = self.run_select(local, "resolve", "task")
        self.assertEqual(shorthand.returncode, 0)
        self.assertEqual(json.loads(shorthand.stdout)["id"], "task")

        beads_target = self.base / "local-beads"
        shutil.move(local / ".beads", beads_target)
        (local / ".beads").symlink_to(beads_target, target_is_directory=True)
        candidates = self.run_script(
            SKILL_DIR / "scripts" / "next-bd", local, "--json"
        )
        symlinked = self.run_select(local, "resolve", "task")
        self.assertEqual([item["id"] for item in json.loads(candidates.stdout)], ["local-task"])
        self.assertEqual(symlinked.returncode, 0)

        (local / ".beads").unlink()
        missing = self.run_select(local, "resolve", "local-task")
        self.assertEqual(missing.returncode, 5)
        self.assertEqual(json.loads(missing.stdout)["status"], "unavailable")
        self.assertEqual(self.update_calls(), [])

    def test_stores_lists_every_registered_store_with_usability(self) -> None:
        workspace = self.create_workspace(
            root_data={"ready": [issue("root-task", 3, "task", "2026-01-04T00:00:00Z")]},
            repositories={
                "repo-a": {"ready": [issue("a-1", 2, "task", "2026-01-02T00:00:00Z")]},
                "repo-b": {},
            },
        )
        shutil.rmtree(self.base / "sources" / "repo-b" / ".beads")

        result = self.run_select(workspace, "stores")

        self.assertEqual(result.returncode, 0)
        listing = json.loads(result.stdout)
        self.assertEqual(listing["workspace"], True)
        self.assertEqual(
            [(store["repository"], store["repository_path"], store["usable"]) for store in listing["stores"]],
            [
                ("workspace", ".", True),
                ("repo-a", "repos/repo-a", True),
                ("repo-b", "repos/repo-b", False),
            ],
        )
        self.assertEqual(listing["stores"][2]["error"], "missing .beads store")
        self.assertNotIn("hint", listing["stores"][2])
        self.assertEqual(
            Path(listing["stores"][1]["directory"]),
            (self.base / "sources" / "repo-a").resolve(),
        )
        self.assertEqual(self.recorded_calls(), [])

    def delegated_workspace(self, **root_data) -> Path:
        workspace = self.create_workspace(
            root_data=root_data or {"ready": [issue("root-task", 2, "task", "2026-01-01T00:00:00Z")]},
            repositories={"delegated": {}, "independent": {}},
        )
        self.declare_tracking(workspace, delegated="workspace")
        shutil.rmtree(self.base / "sources" / "delegated" / ".beads")
        return workspace

    def test_stores_exposes_workspace_owner_without_changing_local_rows(self) -> None:
        workspace = self.delegated_workspace()
        listing = json.loads(self.run_select(workspace, "stores").stdout)
        stores = {row["repository"]: row for row in listing["stores"]}
        delegated = stores["delegated"]
        self.assertEqual(delegated["owner"], "workspace")
        self.assertEqual(delegated["directory"], str(workspace.resolve()))
        self.assertEqual(delegated["repository_directory"], str((self.base / "sources" / "delegated").resolve()))
        self.assertTrue(delegated["usable"])
        self.assertIsNone(delegated["error"])
        self.assertEqual(set(stores["independent"]), {"repository", "repository_path", "directory", "usable", "error"})
        self.assertEqual(self.recorded_calls(), [])

    def test_bare_root_id_probes_store_once_and_starts_only_in_root(self) -> None:
        workspace = self.delegated_workspace()
        result = self.run_select(workspace, "resolve", "root-task")
        self.assertEqual(result.returncode, 0)
        self.assertEqual(json.loads(result.stdout)["repository"], "workspace")
        calls = self.recorded_calls()
        self.assertEqual(len(calls), 2)
        self.assertEqual(sum(Path(call["directory"]) == workspace.resolve() for call in calls), 1)
        started = self.run_select(workspace, "start", "workspace:root-task")
        self.assertEqual(started.returncode, 0)
        self.assertEqual([call["directory"] for call in self.update_calls()], [str(workspace.resolve())])
        self.assertFalse(any(Path(call["directory"]).name == "delegated" for call in self.recorded_calls()))

    def test_qualified_workspace_member_returns_owner_hint_without_redirecting(self) -> None:
        workspace = self.delegated_workspace()
        for command in ("resolve", "start"):
            result = self.run_select(workspace, command, "delegated:root-task")
            self.assertEqual(result.returncode, 4)
            payload = json.loads(result.stdout)
            self.assertEqual(payload["status"], "not-found")
            self.assertEqual(payload["owner"], "workspace")
            self.assertEqual(payload["owner_selector"], "workspace:root-task")
        self.assertEqual(self.recorded_calls(), [])

    def test_malformed_declaration_is_unavailable_before_mutation(self) -> None:
        workspace = self.delegated_workspace()
        self.declare_tracking(workspace, delegated=None)
        for selector in ("root-task", "delegated:root-task"):
            result = self.run_select(workspace, "start", selector)
            self.assertEqual(result.returncode, 5)
            payload = json.loads(result.stdout)
            self.assertEqual(payload["status"], "unavailable")
            self.assertEqual(payload["failures"][0]["repository"], "delegated")
            self.assertIn("invalid beadsStore declaration", payload["failures"][0]["error"])
            self.assertNotIn("hint", payload["failures"][0])
        listing = json.loads(self.run_select(workspace, "stores").stdout)
        self.assertFalse(listing["stores"][1]["usable"])
        self.assertEqual(self.update_calls(), [])

    def test_conflicting_workspace_member_keeps_bare_resolution_unavailable(self) -> None:
        workspace = self.delegated_workspace()
        (self.base / "sources" / "delegated" / ".beads").mkdir()
        for selector in ("root-task", "delegated:root-task"):
            result = self.run_select(workspace, "start", selector)
            self.assertEqual(result.returncode, 5)
            payload = json.loads(result.stdout)
            self.assertEqual(payload["status"], "unavailable")
            self.assertIn("unexpected .beads", payload["failures"][0]["error"])
            self.assertNotIn("hint", payload["failures"][0])
        self.assertEqual(self.update_calls(), [])
        self.assertFalse(any(Path(call["directory"]).name == "delegated" for call in self.recorded_calls()))

    def test_real_duplicate_ids_remain_ambiguous_without_component_aliases(self) -> None:
        duplicate = issue("duplicate", 2, "task", "2026-01-01T00:00:00Z")
        workspace = self.delegated_workspace(ready=[duplicate])
        fixture = self.base / "sources" / "independent" / ".beads" / "fixture.json"
        data = json.loads(fixture.read_text(encoding="utf-8"))
        data["ready"] = [duplicate]
        fixture.write_text(json.dumps(data), encoding="utf-8")
        result = self.run_select(workspace, "start", "duplicate")
        self.assertEqual(result.returncode, 3)
        self.assertEqual(
            {row["selector"] for row in json.loads(result.stdout)["matches"]},
            {"workspace:duplicate", "independent:duplicate"},
        )
        self.assertEqual(self.update_calls(), [])

    def test_workspace_probe_failure_is_not_reported_as_absence(self) -> None:
        workspace = self.delegated_workspace(faults={"probe": "invalid-json"})
        result = self.run_select(workspace, "start", "root-task")
        self.assertEqual(result.returncode, 5)
        self.assertEqual(json.loads(result.stdout)["failures"][0]["repository"], "workspace")
        self.assertEqual(self.update_calls(), [])

    def test_stores_in_local_mode_reports_only_the_current_store(self) -> None:
        local = self.base / "local"
        self.create_store(local)

        listing = json.loads(self.run_select(local, "stores").stdout)

        self.assertEqual(listing["workspace"], False)
        self.assertEqual(
            [(store["repository"], store["usable"]) for store in listing["stores"]],
            [("local", True)],
        )
        self.assertEqual(Path(listing["stores"][0]["directory"]), local.resolve())

    def test_selector_is_required_except_for_stores(self) -> None:
        local = self.base / "local"
        self.create_store(local)

        self.assertEqual(self.run_select(local, "resolve").returncode, 2)
        self.assertEqual(self.run_select(local, "stores", "extra").returncode, 2)
        self.assertEqual(self.recorded_calls(), [])

    def test_local_mode_routes_to_the_current_store(self) -> None:
        local = self.base / "local"
        self.create_store(
            local, ready=[issue("local-task", 2, "task", "2026-01-01T00:00:00Z")]
        )

        resolved = json.loads(self.run_select(local, "resolve", "local-task").stdout)
        self.assertEqual(resolved["workspace"], False)
        self.assertEqual(resolved["repository"], "local")
        self.assertEqual(Path(resolved["directory"]), local.resolve())

        self.assertEqual(self.run_select(local, "start", "1").returncode, 0)
        self.assertEqual(
            [Path(str(call["directory"])) for call in self.update_calls()],
            [local.resolve()],
        )


if __name__ == "__main__":
    unittest.main()
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall