@appchy/jarvis 0.1.129 → 0.1.130

package/harness/test_work.py

@@ -2807,60 +2807,162 @@ def test_a_tier_floor_is_derived_from_the_owner_and_cannot_be_lowered():
         pass
 
 
+def _next_as(who, **args):
+    """Run `next` as one instance, and leave nothing of that identity behind."""
+    os.environ["WORK_INSTANCE"] = who
+    try:
+        shift.cmd_next(args)
+    finally:
+        os.environ.pop("WORK_INSTANCE", None)
+        peers._RUNNING.clear()
+
+
+def _taken_by(root) -> dict:
+    """Who took what, read the way every reader of the board now reads it."""
+    from harness import holders
+    return {h["session"]: name
+            for name, found in holders.to_holders_by_item(events.read(root)).items()
+            for h in found}
+
+
 def test_next_takes_one_task_and_a_second_instance_never_gets_the_same_one():
-    with tempfile.TemporaryDirectory() as tmp:
+    with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as reg:
         v = _tree(tmp)
         e = _epic(v, "an-epic")
         _task(e / "queue", "alpha", fm="priority: P0\ntier: 1\ncode: [web]\n")
         _task(e / "queue", "beta", fm="priority: P0\ntier: 1\ncode: [tools]\n")
-        with _work_dir(tmp) as root:
-            os.environ["WORK_INSTANCE"] = "one"
-            shift.cmd_next({})
-            os.environ["WORK_INSTANCE"] = "two"
-            shift.cmd_next({})
-            os.environ.pop("WORK_INSTANCE")
+        try:
+            os.environ["WORK_SESSIONS_DIR"] = reg
+            with _work_dir(tmp) as root:
+                _next_as("one")
+                _next_as("two")
+                taken = _taken_by(root)
+                assert set(taken) == {"one", "two"}, taken
+                assert taken["one"] != taken["two"], "two instances took the same task"
+        finally:
+            os.environ.pop("WORK_SESSIONS_DIR", None)
 
-            held = {}
-            for t in model.scan(root)["versions"][0].all_tasks():
-                c = shift.read_claim(t.folder)
-                if c:
-                    held[c["instance"]] = t.name
-            assert set(held) == {"one", "two"}, held
-            assert held["one"] != held["two"], "two instances took the same task"
 
+def test_the_loop_holds_back_from_an_area_somebody_may_still_be_working():
+    # Two runs on one seam is how parallel work produces two answers to one design
+    # question. There is no lease any more: who holds an area is read from the commits
+    # that took its items, and an area is free once everyone holding it has ENDED —
+    # which is a thing only a session the list could have named can be said to be.
+    first = "11111111-1111-4111-8111-111111111111"
+    second = "22222222-2222-4222-8222-222222222222"
+    with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as reg:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "queue", "alpha", fm="priority: P0\ntier: 1\ncode: [web]\n")
+        _task(e / "queue", "beta", fm="priority: P1\ntier: 1\ncode: [web]\n")
+        registry = Path(reg) / "1.json"
+        try:
+            os.environ["WORK_SESSIONS_DIR"] = reg
+            with _work_dir(tmp) as root:
+                registry.write_text(json.dumps(
+                    {"sessionId": first, "name": "repo-a1", "pid": os.getpid()}))
+                _next_as(first)
+                _next_as(second)
+                assert _taken_by(root) == {first: "alpha"}, \
+                    "the second run took an area a running session holds"
+
+                # The first session ends. Nothing had to expire and nobody had to drop
+                # anything: its area is free the moment it is no longer running.
+                registry.write_text(json.dumps(
+                    {"sessionId": first, "name": "repo-a1", "pid": 2 ** 22}))
+                _next_as(second)
+                assert _taken_by(root) == {first: "alpha", second: "beta"}, \
+                    "an area stayed held after everyone holding it had ended"
+        finally:
+            os.environ.pop("WORK_SESSIONS_DIR", None)
+            peers._RUNNING.clear()
 
-def test_a_claim_on_a_shared_code_region_blocks_the_second_instance():
-    # Two instances editing one seam is how parallel work produces two different
-    # answers to the same design question. The overlap `work.py code` already
-    # computed is what refuses it.
-    with tempfile.TemporaryDirectory() as tmp:
+
+def test_a_run_this_machine_cannot_see_holds_its_area_rather_than_freeing_it():
+    # A shift that names itself is never on the session list, so its absence from it
+    # proves nothing. Reading that as ended would hand its area to a second run while
+    # it may still be working — and all this decides is the loop holding back, which
+    # is never the expensive mistake.
+    second = "22222222-2222-4222-8222-222222222222"
+    with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as reg:
         v = _tree(tmp)
         e = _epic(v, "an-epic")
         _task(e / "queue", "alpha", fm="priority: P0\ntier: 1\ncode: [web]\n")
         _task(e / "queue", "beta", fm="priority: P1\ntier: 1\ncode: [web]\n")
-        with _work_dir(tmp) as root:
-            os.environ["WORK_INSTANCE"] = "one"
-            shift.cmd_next({})
-            os.environ["WORK_INSTANCE"] = "two"
-            shift.cmd_next({})
-            os.environ.pop("WORK_INSTANCE")
-            claims = [c["instance"] for c, _ in shift._live_claims(model.scan(root))]
-            assert claims == ["one"], f"the second instance took a conflicting seam: {claims}"
+        try:
+            os.environ["WORK_SESSIONS_DIR"] = reg
+            with _work_dir(tmp) as root:
+                _next_as("nightly-shift")
+                _next_as(second)
+                assert _taken_by(root) == {"nightly-shift": "alpha"}, \
+                    "a run nothing here can see had its area taken from under it"
+        finally:
+            os.environ.pop("WORK_SESSIONS_DIR", None)
+            peers._RUNNING.clear()
 
 
-def test_an_expired_lease_is_reaped_so_a_crashed_instance_frees_its_work():
-    with tempfile.TemporaryDirectory() as tmp:
+def test_an_instance_resumes_its_own_take_rather_than_taking_more():
+    # One instance, one task. What it resumes is the take recorded under the name it is
+    # known by — so a name given as a flag has to be the name the take is recorded
+    # under, or the run would read its own take as somebody else's and move on.
+    with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as reg:
         v = _tree(tmp)
         e = _epic(v, "an-epic")
-        d = _task(e / "in-progress", "alpha")
-        (d / ".claim").write_text(json.dumps(
-            {"instance": "dead", "taken": "2020-01-01T00:00:00+00:00",
-             "expires": "2020-01-01T04:00:00+00:00"}))
-        assert shift.read_claim(d) is None
-        # An unparseable lease is also absent — a lock nobody can read must not be
-        # able to strand work forever.
-        (d / ".claim").write_text("{not json")
-        assert shift.read_claim(d) is None
+        _task(e / "queue", "alpha", fm="priority: P0\ntier: 1\ncode: [web]\n")
+        _task(e / "queue", "beta", fm="priority: P1\ntier: 1\ncode: [tools]\n")
+        try:
+            os.environ["WORK_SESSIONS_DIR"] = reg
+            with _work_dir(tmp) as root:
+                for _ in range(2):
+                    try:
+                        shift.cmd_next({"instance": "nightly-shift"})
+                    finally:
+                        os.environ.pop("WORK_INSTANCE", None)
+                assert _taken_by(root) == {"nightly-shift": "alpha"}, \
+                    "it took a second task instead of resuming its first"
+        finally:
+            os.environ.pop("WORK_SESSIONS_DIR", None)
+            peers._RUNNING.clear()
+
+
+def test_status_names_who_took_each_item_from_the_commits_not_a_lease():
+    # One answer to who is on an item. `status` read a lease first and the history only
+    # when there was none, so the one screen a shift is read from and the board could
+    # name different people. It reads the takes now, the way every other door does.
+    import contextlib
+    import io
+    running = "11111111-1111-4111-8111-111111111111"
+    gone = "33333333-3333-4333-8333-333333333333"
+    with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as reg:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        for name in ("alpha", "beta", "gamma"):
+            _task(e / "in-progress", name, fm="priority: P1\ntier: 1\n")
+        (Path(reg) / "1.json").write_text(json.dumps(
+            {"sessionId": running, "name": "repo-a1", "pid": os.getpid()}))
+        try:
+            os.environ["WORK_SESSIONS_DIR"] = reg
+            with _work_dir(tmp) as root:
+                for who, name in ((running, "alpha"), (gone, "beta")):
+                    os.environ["WORK_INSTANCE"] = who
+                    events.append(root, "moved", name, **{"from": "queue", "to": "in-progress"})
+                os.environ["WORK_INSTANCE"] = "44444444-4444-4444-8444-444444444444"
+                out = io.StringIO()
+                with contextlib.redirect_stdout(out):
+                    shift.cmd_status({})
+                said = out.getvalue()
+                # The same derivation answers the note a person gets before moving it.
+                assert "repo-a1" in shift.somebody_else(root, "alpha")
+                assert shift.somebody_else(root, "beta") == "", \
+                    "a take whose run has ended is not somebody still on it"
+            assert "repo-a1" in said and "still running" in said, said
+            assert "ENDED" in said, "a take whose run has ended has to say so"
+            assert "never taken" in said, "and an item nobody took has to say that"
+            assert "lease" not in said
+        finally:
+            for key in ("WORK_SESSIONS_DIR", "WORK_INSTANCE"):
+                os.environ.pop(key, None)
+            peers._RUNNING.clear()
 
 
 def test_a_task_above_the_ceiling_is_never_taken_unattended():
@@ -3086,9 +3188,6 @@ def test_a_passing_verify_run_is_recorded_and_clears_that_gate():
                 # moment its last task lands, so the folder is already elsewhere.
                 done = model.locate(root, "alpha")
                 assert done.status == "complete"
-                # The lease does not survive the work: `status` would otherwise
-                # report a live instance on a finished task.
-                assert not (done.folder / ".claim").exists()
             finally:
                 gate.VERIFY = old
 
@@ -3712,8 +3811,7 @@ def test_a_failing_run_is_described_by_what_the_gate_said():
     assert "abcdef12" in said
 
 
-def test_coordination_files_never_enter_a_commit():
-    assert git.CLAIM in git.LOCAL
+def test_a_verify_run_never_enters_a_commit():
     assert gate.RUN in git.LOCAL
 
 
@@ -3909,7 +4007,7 @@ def test_the_autonomy_ceiling_is_validated_and_never_silently_wrong():
     for bad in (4, -1, "2", True, None):
         try:
             config._validate({**config.DEFAULTS,
-                              "autonomy": {"ceiling": bad, "lease_minutes": 240}})
+                              "autonomy": {"ceiling": bad}})
             assert False, f"expected a refusal for {bad!r}"
         except config.ConfigError:
             pass
@@ -4614,28 +4712,37 @@ def test_the_record_round_trips_out_of_the_commits():
             config.apply(config.DEFAULTS)
 
 
-def test_a_hold_never_enters_git():
-    # A claim belongs to a machine and a moment. A replicated one is two endpoints
-    # holding the same item with neither knowing — which is why holds are filtered
-    # out of the commit whatever `git.paths` says, and dropped from the record.
+def test_migrate_sweeps_the_lease_files_the_deleted_lease_left_behind():
+    # Nothing reads a `.claim` any more and git no longer filters one out of a commit,
+    # so a leftover would ride into the next board write in its folder. The migration a
+    # repo already runs for layout changes is where it goes — and the file it removes,
+    # being untracked, must not be what stops it running.
+    from harness import migrate
     with tempfile.TemporaryDirectory() as tmp:
-        try:
-            repo = _git_repo(tmp)
-            folder = repo / "work" / "versions" / "v" / "e" / "in-progress" / "held"
-            folder.mkdir(parents=True)
-            (folder / "task.md").write_text("---\npriority: P0\n---\n\n# H\n")
-            (folder / ".claim").write_text('{"instance": "someone"}\n')
-            _board_write(repo, "held", [{"event": "moved", "name": "held"}])
-            listed = _git(repo, "ls-files").stdout
-            assert "held/task.md" in listed
-            assert ".claim" not in listed, "a claim must never be committed"
-
-            events._PENDING.clear()
-            events.append(repo / "work", "claimed", "held", expires="2030-01-01")
-            assert events.pending() == [], "a hold is not board history"
-            events._PENDING.clear()
-        finally:
-            config.apply(config.DEFAULTS)
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        held = _task(e / "in-progress", "alpha")
+        (held / ".claim").write_text('{"instance": "someone"}\n')
+        with _work_dir(tmp):
+            migrate.cmd_migrate({"dry-run": True})
+            assert (held / ".claim").exists(), "a dry run changes nothing"
+            migrate.cmd_migrate({})
+            assert not (held / ".claim").exists(), "the leftover was left to be committed"
+            assert (held / "task.md").exists(), "and nothing but the leftover was removed"
+
+    # A repo still on its old backlog gets both at once — and the backlog moves first,
+    # carrying any leftover inside it to a path the sweep never listed.
+    import shutil
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp) / "work"
+        _tree(str(root))
+        shutil.rmtree(root / "versions" / "backlog")
+        later = _task(root / "backlog" / "an-epic", "later")
+        (later / ".claim").write_text('{"instance": "someone"}\n')
+        with _work_dir(str(root)):
+            migrate.cmd_migrate({})
+        assert not (root / "backlog").exists(), "the old backlog did not move"
+        assert not list(root.rglob(".claim")), "a leftover the backlog carried was not swept"
 
 
 def test_a_commit_leaves_a_sessions_own_code_alone():
@@ -4965,23 +5072,28 @@ def test_a_held_task_names_a_session_you_can_actually_reach():
             os.environ["WORK_SESSIONS_DIR"] = tmp
             # A registry that exists and holds exactly one running session. The pid
             # is this test's own, because the check is whether the process is there.
+            # Shaped like the ids the registry publishes, because only an id of that
+            # shape can be declared ended by its absence from it.
+            theirs = "11111111-1111-4111-8111-111111111111"
+            alive = "22222222-2222-4222-8222-222222222222"
+            ghost = "33333333-3333-4333-8333-333333333333"
             (Path(tmp) / "1.json").write_text(json.dumps(
-                {"sessionId": "alive-2222", "name": "repo-a8", "pid": os.getpid()}))
+                {"sessionId": alive, "name": "repo-a8", "pid": os.getpid()}))
             # …and one entry a hard kill left behind. It must not read as running.
             (Path(tmp) / "2.json").write_text(json.dumps(
-                {"sessionId": "ghost-3333", "name": "repo-b7", "pid": 2 ** 22}))
+                {"sessionId": ghost, "name": "repo-b7", "pid": 2 ** 22}))
 
             assert "this session" in peers.describe("mine-0000")
 
-            away = peers.describe("theirs-1111", "other-box")
+            away = peers.describe(theirs, "other-box")
             assert "another machine" in away and "SendMessage" not in away, \
                 "a name you cannot deliver to is worse than saying you cannot"
 
-            live = peers.describe("alive-2222", "this-box")
+            live = peers.describe(alive, "this-box")
             assert "repo-a8" in live and "SendMessage" in live, \
                 "a running peer is reachable — hand over the address, not a prefix"
 
-            for gone in ("theirs-1111", "ghost-3333"):
+            for gone in (theirs, ghost):
                 ended = peers.describe(gone, "this-box")
                 assert "ENDED" in ended and "SendMessage" not in ended, \
                     "a session that is not running cannot be messaged — say so"
@@ -4990,7 +5102,7 @@ def test_a_held_task_names_a_session_you_can_actually_reach():
             # that everyone is dead. It must fall back to what it always said.
             os.environ["WORK_SESSIONS_DIR"] = str(Path(tmp) / "nothing-here")
             assert peers.running() is None
-            unknown = peers.describe("theirs-1111", "this-box")
+            unknown = peers.describe(theirs, "this-box")
             assert "SendMessage" in unknown and "ENDED" not in unknown, \
                 "a client that publishes nothing must not make every peer look dead"
         finally:
@@ -5120,13 +5232,14 @@ def test_a_session_running_twice_is_never_resolved_to_one_of_its_names():
 
             # The real pair, with the filenames from the sighting: the low pid sorts
             # LAST lexically, so whichever half a reader picked was arbitrary.
+            forked = "44444444-4444-4444-8444-444444444444"
             for pid, name, door in ((20558, "jarvis-9a", "claude-vscode"),
                                     (15750, "the harness stops", "cli")):
                 (reg / f"{pid}.json").write_text(json.dumps(
-                    {"sessionId": "forked-4444", "name": name, "cwd": str(here),
+                    {"sessionId": forked, "name": name, "cwd": str(here),
                      "entrypoint": door, "pid": os.getpid()}))
 
-            said = peers.describe("forked-4444", "this-box")
+            said = peers.describe(forked, "this-box")
             assert "jarvis-9a" in said and "the harness stops" in said, \
                 "a reader that cannot pick has to be handed both, not one of them"
             assert "2 processes on ONE session" in said
@@ -5143,15 +5256,46 @@ def test_a_session_running_twice_is_never_resolved_to_one_of_its_names():
             # exactly as it did before any of this.
             (reg / "20558.json").unlink()
             peers._RUNNING.clear()
-            alone = peers.describe("forked-4444", "this-box")
+            alone = peers.describe(forked, "this-box")
             assert "still running" in alone and "the harness stops" in alone
             assert "processes" not in alone
+
+            # A shift that names itself was never going to be on that list, so its
+            # absence proves nothing — and the line must not promise an address a
+            # named shift or a script cannot be messaged at.
+            shift_line = peers.describe("nightly-shift", "this-box")
+            assert "ENDED" not in shift_line and "SendMessage" not in shift_line
+            assert "cannot be told" in shift_line
         finally:
             for key in ("WORK_INSTANCE", "WORK_MACHINE", "WORK_SESSIONS_DIR"):
                 os.environ.pop(key, None)
             peers._RUNNING.clear()
 
 
+def test_both_readers_of_the_board_history_agree_about_who_holds_each_item():
+    # Who is on an item is derived twice — here from what `git._events` parses, and by
+    # the board from what `board.git.ts` reads — and the two had already come to name
+    # different holders: a take on an item already in progress records a run and no
+    # event, which the board counted and this reader threw away. The TypeScript half
+    # asserting these same commits is in packages/board/src/board.test.ts.
+    from harness import holders
+    cases = json.loads((Path(__file__).parent / "harness" / "holders.cases.json")
+                       .read_text(encoding="utf-8"))["cases"]
+    assert cases, "the shared cases file has to actually hold cases"
+    for case in cases:
+        rows = []
+        for commit in case["commits"]:
+            record = "\x1f".join((commit["sha"], commit["when"], commit["author"],
+                                  commit["message"]))
+            rows.extend(git._events(record, eventless=True))
+        # An item nobody took reads as having no holders, however a reader represents
+        # that — so an empty list and an absent key compare the same.
+        got = {name: [{"session": h["session"], "machine": h["machine"],
+                       "tookOverFrom": h.get("took_over_from")} for h in found]
+               for name, found in holders.to_holders_by_item(rows).items() if found}
+        assert got == case["expect"], case["name"]
+
+
 def test_a_session_starts_knowing_who_else_is_in_the_checkout():
     # A session started blind: the one block it cannot skip said nothing about
     # another session, so two runs picked up overlapping work and found out when one
@@ -5223,21 +5367,6 @@ def test_how_long_ago_is_said_in_the_unit_that_changes_the_decision():
         assert shift._ago(broken) == "at an unrecorded time"
 
 
-def test_a_claim_records_which_machine_took_it():
-    # A claim never enters git, so the pairing of session-to-machine exists nowhere
-    # else. Without it every hold reads as local and half of them are lies.
-    with tempfile.TemporaryDirectory() as tmp:
-        os.environ["WORK_MACHINE"] = "the-box-that-took-it"
-        try:
-            folder = Path(tmp)
-            claim = shift._write_claim(folder, "some-session")
-            assert claim["machine"] == "the-box-that-took-it"
-            assert json.loads((folder / ".claim").read_text())["machine"] \
-                == "the-box-that-took-it"
-        finally:
-            os.environ.pop("WORK_MACHINE", None)
-
-
 def test_the_board_moving_under_you_says_what_moved_and_who_moved_it():
     # The question at this moment is not "did a fetch happen" — a session can see
     # that. It is whether the plan it is holding is still the plan, and who to ask.
@@ -5246,11 +5375,14 @@ def test_the_board_moving_under_you_says_what_moved_and_who_moved_it():
             os.environ["WORK_INSTANCE"] = "mine-0000"
             os.environ["WORK_MACHINE"] = "this-box"
             os.environ["WORK_SESSIONS_DIR"] = tmp
+            # Shaped like the ids the registry publishes, because only an id of that
+            # shape can be declared ended by its absence from it.
+            theirs = "11111111-1111-4111-8111-111111111111"
             (Path(tmp) / "1.json").write_text(json.dumps(
-                {"sessionId": "theirs-1111", "name": "repo-c4", "pid": os.getpid()}))
+                {"sessionId": theirs, "name": "repo-c4", "pid": os.getpid()}))
             note = peers.arrivals([
-                {"name": "the-plan-changed", "by": "theirs-1111", "machine": "this-box"},
-                {"name": "and-this-one", "by": "theirs-1111", "machine": "this-box"},
+                {"name": "the-plan-changed", "by": theirs, "machine": "this-box"},
+                {"name": "and-this-one", "by": theirs, "machine": "this-box"},
             ])
             assert "the-plan-changed" in note and "and-this-one" in note
             assert "SendMessage" in note, "naming who moved it is the point of saying it"
@@ -5258,9 +5390,11 @@ def test_the_board_moving_under_you_says_what_moved_and_who_moved_it():
             # The same board move, made by somebody who has since finished. Still
             # worth reporting — the plan did change under you — but there is nobody
             # left to ask about it, and saying otherwise sends the reader nowhere.
+            left = "99999999-9999-4999-8999-999999999999"
             gone = peers.arrivals([
-                {"name": "the-plan-changed", "by": "left-9999", "machine": "this-box"}])
+                {"name": "the-plan-changed", "by": left, "machine": "this-box"}])
             assert "the-plan-changed" in gone and "SendMessage" not in gone
+            assert "ENDED" in gone, "finished is a claim the list can make about a session"
             # Your OWN commits coming back round are not news, and a line that fires
             # on every pull is one people stop reading.
             assert peers.arrivals([{"name": "x", "by": "mine-0000",
@@ -6506,7 +6640,7 @@ def test_every_shipped_default_is_mechanics_or_nothing():
     # fact about somebody's setup and ships as null.
     allowed = {
         "ids.prefix", "domains.order", "product.tiers",
-        "autonomy.ceiling", "autonomy.lease_minutes", "git.remote", "git.paths",
+        "autonomy.ceiling", "git.remote", "git.paths",
         "coverage.shard", "hooks.session_start.enabled", "hooks.stop.enabled",
         # On by default like its two siblings, and for their reason: a hook the
         # harness ships is its own mechanics, not a fact about somebody's setup.
@@ -7566,19 +7700,6 @@ def test_every_event_the_harness_records_is_one_the_record_knows():
         f"recorded but not in KINDS, so it never reaches a digest: {sorted(called - set(events.KINDS))}"
 
 
-def test_a_claim_nobody_can_read_reads_as_absent_rather_than_raising():
-    # `read_claim` promises an unreadable claim reads as absent, and the comparison
-    # threw rather than the parse: a `.claim` written without a timezone parsed
-    # fine and then could not be compared against an aware now. One malformed file
-    # took down every command that asks who is holding an item.
-    with tempfile.TemporaryDirectory() as tmp:
-        folder = Path(tmp) / "a-task"
-        folder.mkdir()
-        (folder / shift.CLAIM).write_text(json.dumps(
-            {"instance": "someone", "expires": "2099-01-01T00:00:00"}))
-        assert shift.read_claim(folder) is None
-
-
 def test_the_lowest_tier_the_vocabulary_defines_can_actually_be_set():
     # `TIERS` and `TIER_MEANING` both define tier 0 and the method's own table
     # documents it — reversible and local, a typo, a comment, a test name — and it

package/harness/work.py

@@ -100,7 +100,7 @@ Subcommands:
 The unattended loop — a schedule calls `next`, and the rest exists so a run that
 cannot finish has somewhere to put the reason instead of stalling or guessing:
 
-    next [--instance <id>] [--peek]    take ONE task and claim it; prints the read order
+    next [--instance <id>] [--peek]    take ONE task; prints the read order
     status                             what shipped · what waits on you · what is at risk
     peers                              who else is working this checkout, and on what.
                                        The session block says it at startup; this asks
@@ -119,7 +119,6 @@ cannot finish has somewhere to put the reason instead of stalling or guessing:
                                        park a question, move on — exits 0, never blocks
     needs                              every open question, oldest first
     answer <task> --choose "…"         resolve it and put the task back to work
-    drop <name> [--why "…"]            give a claim back
     log [--since DATE] [--task <n>] · digest [--since DATE]
     sync                               pull the board fresh; send anything unpushed
 
@@ -172,7 +171,7 @@ from harness.config import (DEFAULTS, ConfigError, apply, cmd_applies, cmd_confi
 from harness.safety import cmd_doctor, cmd_id_new
 from harness.autonomy import cmd_answer, cmd_ask, cmd_digest, cmd_log, cmd_needs
 from harness.peers import cmd_peers
-from harness.shift import cmd_drop, cmd_next, cmd_status
+from harness.shift import cmd_next, cmd_status
 from harness.gate import cmd_observed, cmd_verify
 from harness.kickoff import cmd_kickoff
 from harness.git import cmd_sync
@@ -189,7 +188,7 @@ SUBCOMMANDS = (
     "epic-new", "feature-new", "version-new", "place", "handoff", "release", "archive",
     "find", "list", "readme", "move", "plan", "session", "kickoff", "path", "code",
     "domain-new", "system-new", "where", "rules", "align", "wrap", "coverage",
-    "migrate", "next", "status", "drop", "ask", "answer", "needs", "verify",
+    "migrate", "next", "status", "ask", "answer", "needs", "verify",
     "observed", "log", "digest", "sync", "check", "links", "peers",
 )
 
@@ -568,10 +567,6 @@ def dispatch(cmd, pos, flags, cfg) -> int:
         return cmd_status(flags)
     if cmd == "peers":
         return cmd_peers(flags)
-    if cmd == "drop":
-        if not pos:
-            die("usage: jarvis work drop <name> [--why \"…\"]")
-        return cmd_drop({"name": pos[0], **flags})
     if cmd == "ask":
         if not pos:
             die("usage: jarvis work ask <task> --question \"…\" "

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.129",
+  "version": "0.1.130",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -65,8 +65,8 @@
     "@jarvis/rpc": "1.0.0",
     "@jarvis/types": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
-    "@jarvis/ui": "0.1.0",
-    "@jarvis/vitest-config": "1.0.0"
+    "@jarvis/vitest-config": "1.0.0",
+    "@jarvis/ui": "0.1.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",