flurdy/agent-skills / skills/next
next
VerifiedRank 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.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 50.1 KB |
| pi/index.ts | script | 2.5 KB |
| pi/lease-selection.ts | script | 16.9 KB |
| references/dolt-recovery.md | markdown | 7.7 KB |
| references/source-scope.md | markdown | 12.5 KB |
| scripts/bd-showexecutable | script | 1.1 KB |
| scripts/collect.pyexecutable | script | 25.5 KB |
| scripts/next-bdexecutable | script | 16.5 KB |
| scripts/next-selectexecutable | script | 21.3 KB |
| tests/lease-extension.test.mjs | script | 7.4 KB |
| tests/lease-kernel.test.mjs | script | 3.7 KB |
| tests/lease-selection.test.mjs | script | 20.1 KB |
| tests/test_defer_dates.py | script | 6.8 KB |
| tests/test_dolt_recovery_contract.py | script | 3.3 KB |
| tests/test_machine_routing.py | script | 10.1 KB |
| tests/test_next_bd.py | script | 43.8 KB |
| tests/test_next_select.py | script | 36.2 KB |
| tests/test_ownership_contract.py | script | 2.8 KB |
| tests/test_read_deadlines.py | script | 8.2 KB |
| tests/test_related.py | script | 11.4 KB |
| tests/test_source_scope.py | script | 10.1 KB |
| tests/workspace_fixture.py | script | 10.8 KB |
tests/test_next_select.py
View on GitHubfrom __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()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| 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: 198k | Updated | Claude CodeCodex | Verified | Install |
| 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: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| 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: 194k | Updated | Claude CodeCodex | Verified | Install |