@appchy/jarvis 0.1.119 → 0.1.121

package/harness/harness/git.py

@@ -502,6 +502,109 @@ def changed(repo) -> tuple:
     return paths, untracked
 
 
+#: The buckets a task folder sits in. A path's item is the segment AFTER one of
+#: these, which is how a file is traced back to the work it belongs to without a
+#: registry that could disagree with the tree.
+_BUCKETS = ("queue", "in-progress", "blocked", "complete")
+
+
+def dirty(repo) -> frozenset:
+    """What is already uncommitted under the configured paths, right now.
+
+    Taken before a command runs so the commit afterwards can tell what that command
+    wrote from what was lying there when it started. Cheap — one `git status`.
+    """
+    if not is_repo(repo):
+        return frozenset()
+    return frozenset(changed(repo)[0])
+
+
+def item_of(path: str) -> str:
+    """The work item a path belongs to, or "" for anything that is not a task file.
+
+    Governance docs, a version.md and an epic.md all answer "" — they belong to the
+    tree rather than to one item, so nothing can claim to have authored them by
+    holding something.
+    """
+    parts = Path(path).parts
+    for i, part in enumerate(parts[:-1]):
+        # A cut holds buckets and the item is the folder inside one. The backlog
+        # holds no buckets at either tier — it is `backlog/<epic>/<item>/` — so the
+        # item sits one deeper, and reading it as a bucket would name the epic.
+        step = 2 if part == "backlog" else (1 if part in _BUCKETS else 0)
+        if step and i + step < len(parts) - 1:
+            return parts[i + step]
+    return ""
+
+
+def authored(paths, before, item: str) -> tuple:
+    """Split what is uncommitted into (mine, theirs).
+
+    MINE is what this command wrote — anything that became dirty while it ran — plus
+    everything under the item it acted on, because a session that holds an item and
+    hand-edits its brief did author that, whenever it typed it.
+
+    THEIRS is the rest, and it is left alone. It used to be committed too, under
+    whoever ran next: the pathspec took the whole of `work/`, so a peer's
+    half-written prose landed inside somebody else's commit, stamped with their
+    session and their item. That made the record assert two things that were not
+    true — who wrote it, and what it was work on — and both are read downstream to
+    answer who is on an item.
+
+    What this deliberately does NOT do is narrow the pathspec to the command's own
+    writes alone. A brief edited by hand before the command that files it would then
+    never be committed by anything, which is the hole that made the sweep the right
+    answer in the first place.
+    """
+    mine, theirs = [], []
+    for p in paths:
+        if p not in before or (item and item_of(p) == item):
+            mine.append(p)
+        else:
+            theirs.append(p)
+    return mine, theirs
+
+
+def _left_alone(theirs) -> str:
+    """What to say about work this commit did not take.
+
+    Named file by file with the item each belongs to, because "some files were left"
+    is not something a session can act on and this is meant to be resolved in the
+    turn it appears, not noted. A session reading it either commits them — they are
+    often its own, typed before the command that triggered this — or leaves them to
+    the session working that item, which is now a decision somebody makes rather
+    than one the pathspec made for them.
+    """
+    if not theirs:
+        return ""
+    lines = []
+    for p in sorted(theirs)[:10]:
+        owner = item_of(p)
+        lines.append(f"    {p}" + (f"   ({owner})" if owner else "   (no item — a hand edit)"))
+    more = len(theirs) - len(lines)
+    if more > 0:
+        lines.append(f"    … and {more} more")
+    return ("left uncommitted — this write did not author them, so it did not take "
+            "them:\n" + "\n".join(lines) + "\n  Commit them yourself if they are "
+            "yours; if another session is working that item, they are that session's "
+            "to land.")
+
+
+def has_commit(repo, sha: str) -> bool:
+    """Is `sha` still a commit this repo holds?
+
+    A push that rebases rewrites the commits it moves, so a sha a gate run recorded
+    can stop existing while the code it measured is untouched. Everything that reads
+    a recorded sha needs to tell that apart from the code having changed: they are
+    opposite situations and the first one cannot be diagnosed from a hash a reader
+    cannot open.
+    """
+    if not sha or sha == "no-git":
+        return False
+    code, _, _ = _git(repo, "cat-file", "-e", f"{sha}^{{commit}}")
+    return code == 0
+
+
 def only_board_moved(repo, sha: str) -> bool:
     """Is everything between `sha` and HEAD a board file?
 
@@ -572,12 +675,17 @@ def moved_only_elsewhere(repo, sha: str, root, regions: list) -> bool:
     return moved
 
 
-def land(repo, item: str, rows: list) -> tuple:
-    """Commit what changed and push it. Returns (committed, pushed, note).
+def land(repo, item: str, rows: list, before=frozenset()) -> tuple:
+    """Commit what this command wrote and push it. Returns (committed, pushed, note).
+
+    `before` is what was already uncommitted when the command started, so the commit
+    can take what it authored and leave what it did not — see `authored`. Passing
+    nothing keeps the old behaviour of taking everything, which is right for a caller
+    that has no earlier moment to compare against.
 
-    `note` is what to tell the caller — empty when everything landed. A push that
-    cannot land is NOT a failure of the write: the change is committed, which is
-    what makes it unloseable, and the note says how to send it.
+    `note` is what to tell the caller — empty when everything landed and nothing was
+    left behind. A push that cannot land is NOT a failure of the write: the change is
+    committed, which is what makes it unloseable, and the note says how to send it.
     """
     # Asked FIRST, and not after `changed`: a directory that is not a repo makes
     # `git status` fail, `changed` return nothing, and the write look like a no-op
@@ -590,6 +698,9 @@ def land(repo, item: str, rows: list) -> tuple:
     # network must not be able to stall every other board write on this machine.
     with _hold(repo):
         paths, untracked = changed(repo)
+        paths, theirs = authored(paths, before, item)
+        untracked = [p for p in untracked if p in set(paths)]
+        carried = _left_alone(theirs)
         if not paths:
             # Nothing to commit is usually the ordinary answer — a read, or a write
             # that changed nothing — and says nothing. Two cases are not ordinary.
@@ -610,7 +721,7 @@ def land(repo, item: str, rows: list) -> tuple:
                 return False, False, (
                     "carried by a board write that committed a moment earlier — the "
                     "change is in git, under that commit's item rather than this one")
-            return False, False, ""
+            return False, False, carried
 
         if untracked:
             code, _, err = _locking(repo, "add", "--", *untracked)
@@ -626,9 +737,11 @@ def land(repo, item: str, rows: list) -> tuple:
             return False, False, f"could not commit the board write: {_tail(err)}"
 
     if not GIT.get("push"):
-        return True, False, ""
+        return True, False, carried
     pushed, why = _push(repo)
-    return True, pushed, why
+    # Both can be true at once: a push that did not land AND work left for somebody
+    # else. Neither is allowed to hide the other.
+    return True, pushed, SEP.join(x for x in (why, carried) if x) if (why and carried) else (why or carried)
 
 
 def _push(repo) -> tuple:

package/harness/presets/appchy/PRESET.md

@@ -441,7 +441,7 @@ the only way forward has hit a real gap: **park a question, do not shell out.**
 | Create a task | `jarvis work new <name> --epic <e> [--priority] [--depends] [--owner] [--code] [--covers]` | either — `work_create` is the tool |
 | List | `jarvis work list` | either — `work_list` is the tool |
 | Pick up / complete | `jarvis work move <name> in-progress\|complete --delivered "…" --not-included "…"` | either — `work_take` / `work_complete` |
-| Prove it | `jarvis work verify --task <name>` (blocks) · `--async` (what the tool uses) | either — `work_verify` |
+| Prove it | `jarvis work verify <name>` (blocks) · `--start` (what the tool uses) · `--status` (asks, starts nothing) | either — `work_verify` |
 | Record an approved plan | `jarvis work plan <name> [--file <path>]` | either |
 | Hand off | `jarvis work handoff <name>`, then fill it | either — **no tool yet**; the prose is judgement |
 | Open the NEXT session | `jarvis work kickoff <name>` — never hand-write the prompt | either — `work_wrap` embeds it |

package/harness/test_work.py

@@ -3248,13 +3248,101 @@ def test_starting_while_a_run_is_live_names_whose_it_is_rather_than_attaching():
                                        "machine": "here", "started": gate._now().isoformat(),
                                        "gates": ["tests"], "current": "tests", "done": [],
                                        "finished": None, "read": False})
-                out = _said(lambda: gate.cmd_verify({"task": "beta", "async": True}))
-                assert out["state"] == "running", out
+                out = _said(lambda: gate.cmd_verify({"task": "beta", "start": True}))
+                # `busy` and not `running`: the slot is taken and it is somebody
+                # else's. Reporting both as `running` is how a session read a held
+                # checkout as its own gates making progress.
+                assert out["state"] == "busy", out
+                assert out["run"]["task"] == "alpha", out
                 assert "alpha" in out["message"], out["message"]
+                # Not a queue, and it says so rather than letting a refused caller
+                # believe a call is coming.
+                assert "Nothing is holding your place" in out["message"], out["message"]
             finally:
                 gate.VERIFY = old
 
 
+def test_a_held_slot_never_reports_as_the_callers_own_progress():
+    # The measured half of this: asking for progress answered `18s, 0 of 9` and then
+    # `322s, 8 of 9` two minutes apart, for two different runs, and a caller could
+    # tell neither a fresh start from somebody else's long one nor whether its own
+    # request had taken effect. Every gate-shaped field describes the CALLER's item,
+    # so on a slot that is not theirs they are empty and the run sits on its own.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "in-progress", "alpha", body="# T\n")
+        _task(e / "in-progress", "beta", body="# T\n")
+        with _work_dir(tmp) as root:
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true", "lint": "true"}
+            try:
+                gate._write_run(root, {"task": "alpha", "pid": os.getpid(),
+                                       "machine": "here", "session": peers.me(),
+                                       "started": gate._now().isoformat(),
+                                       "gates": ["lint", "tests"], "current": "tests",
+                                       "done": ["lint"], "finished": None, "read": False})
+                out = _said(lambda: gate.cmd_verify({"task": "beta", "status": True}))
+                assert out["state"] == "busy", out
+                assert out["gate"] == "" and out["done"] == [] and out["gates"] == [], \
+                    "another item's progress was reported as this caller's"
+                assert out["elapsedSeconds"] == 0 and out["passed"] is False, out
+                # …and what IS true about the checkout is said, in one place.
+                assert out["run"]["task"] == "alpha", out
+                assert out["run"]["gate"] == "tests" and out["run"]["done"] == ["lint"], out
+                assert "'beta'" in out["message"], out["message"]
+
+                # The same run, asked about by the item it IS proving, is progress.
+                mine = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                assert mine["state"] == "running", mine
+                assert mine["done"] == ["lint"], mine
+            finally:
+                gate.VERIFY = old
+
+
+def test_a_refused_verify_names_a_reachable_holder_when_there_is_one():
+    # The sibling refusal's join, made for the completion gate, applied to the one
+    # mechanism in this epic that actually refuses: the id was always in the run file
+    # and led nowhere, so the only move left was to ask again on a timer.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "in-progress", "alpha", body="# T\n")
+        with _work_dir(tmp) as root, tempfile.TemporaryDirectory() as sess:
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+            keep = os.environ.get(peers.SESSIONS)
+            os.environ[peers.SESSIONS] = sess
+            peers._RUNNING.clear()
+            try:
+                Path(sess, "1.json").write_text(json.dumps(
+                    {"sessionId": "aaaabbbb-0000-0000-0000-000000000000",
+                     "name": "jarvis-22", "pid": os.getpid(), "cwd": str(root.parent)}))
+                gate._write_run(root, {
+                    "task": "alpha", "pid": os.getpid(), "machine": peers.here(),
+                    "session": "aaaabbbb-0000-0000-0000-000000000000",
+                    "started": gate._now().isoformat(), "gates": ["tests"],
+                    "current": "tests", "done": [], "finished": None, "read": False})
+                said = gate._busy(gate.live_run(root))
+                assert "jarvis-22" in said, said
+                assert "SendMessage" in said, said
+                # How far through, because "started 190s ago" cannot answer whether
+                # this is nearly over or has just begun.
+                assert "gate 1 of 1" in said, said
+
+                # A run that recorded no session says nothing about who — an
+                # enrichment we can lose, never a guess we invent.
+                gate._write_run(root, {**gate.read_run(root), "session": ""})
+                quiet = gate._busy(gate.live_run(root))
+                assert "jarvis-22" not in quiet and "started by" not in quiet, quiet
+                assert "corrupt each other" in quiet, quiet
+            finally:
+                gate.VERIFY = old
+                peers._RUNNING.clear()
+                if keep is None:
+                    os.environ.pop(peers.SESSIONS, None)
+                else:
+                    os.environ[peers.SESSIONS] = keep
+
+
 def test_a_finished_run_for_another_task_is_not_handed_over_as_this_ones():
     # The wrong-verdict half. A result proven for one item says nothing about
     # another, and reporting it would put a green gate on work nobody ran.
@@ -3271,8 +3359,193 @@ def test_a_finished_run_for_another_task_is_not_handed_over_as_this_ones():
                 out = _said(lambda: gate.cmd_verify({"task": "beta", "status": True}))
                 assert out["state"] == "idle", out
                 assert out["passed"] is False, out
+                # …and it says WHICH kind of nothing this is. "No gates have run"
+                # covering both "nobody ran anything" and "the last run proved
+                # somebody else's item" is what a caller cannot act on.
+                assert out["reason"] == "other", out
+                assert "'alpha'" in out["message"], out["message"]
+            finally:
+                gate.VERIFY = old
+
+
+def test_a_run_that_stopped_without_recording_says_so_rather_than_reading_as_never_run():
+    # The half nobody could prove. A run whose process is gone leaves a file every
+    # door correctly treats as absent, and the next start OVERWRITES it — so the
+    # session that lost four minutes of gates learned it only by noticing the slot
+    # now named somebody else's item. Reported from the receiving end, 2026-09-12.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "in-progress", "alpha", body="# T\n")
+        _task(e / "in-progress", "beta", body="# T\n")
+        with _work_dir(tmp) as root:
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+            try:
+                dead = {"task": "alpha", "pid": 2 ** 31 - 1, "machine": "here",
+                        "session": "aaaabbbb-0000-0000-0000-000000000000",
+                        "started": gate._now().isoformat(),
+                        "gates": ["lint", "tests"], "current": "tests",
+                        "done": ["lint"], "finished": None, "read": False}
+                gate._write_run(root, dead)
+                out = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                assert out["state"] == "idle" and out["reason"] == "lost", out
+                assert "gate 2 of 2" in out["message"], out["message"]
+                assert "without recording" in out["message"], out["message"]
+
+                # And it survives the run that replaces it, which is the case that
+                # actually happened: the slot is claimed by another item, and the
+                # session whose gates vanished is still told — being behind a
+                # stranger's run and having lost your own are two facts, and the
+                # only thing it had to go on was the slot naming somebody else.
+                gate._write_run(root, gate._begin(root, "beta", os.getpid()))
+                assert gate.read_run(root)["lost"]["task"] == "alpha", gate.read_run(root)
+                still = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                assert still["state"] == "busy" and still["reason"] == "lost", still
+                assert still["run"]["task"] == "beta", still
+                assert "without recording" in still["message"], still["message"]
+
+                # A run that FINISHED is not a lost one, however long ago it was.
+                gate._write_run(root, {**dead, "finished": gate._now().isoformat(),
+                                       "passed": True, "sha": "", "results": []})
+                done = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                assert done["state"] == "finished", done
+            finally:
+                gate.VERIFY = old
+
+
+def test_a_result_the_code_moved_past_names_both_commits():
+    # `moved` and `no gates have run` were one sentence, and this is the mode that
+    # cost the most: a gate run only counted if nobody committed for four minutes,
+    # and three sessions were committing every few minutes. The result was recorded
+    # against a HEAD that no longer existed and read as never having run.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            ran = _git(repo, "rev-parse", "HEAD").stdout.strip()
+            (repo / "src.txt").write_text("the code moved\n")
+            _git(repo, "add", "-A"); _git(repo, "commit", "-qm", "somebody committed")
+            head = _git(repo, "rev-parse", "HEAD").stdout.strip()
+
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+            with _work_dir(str(repo / "work")) as root:
+                try:
+                    gate._write_run(root, {
+                        "task": "alpha", "pid": os.getpid(), "machine": "here",
+                        "session": "", "started": gate._now().isoformat(),
+                        "head": ran, "gates": ["tests"], "current": "",
+                        "done": ["tests"], "finished": gate._now().isoformat(),
+                        "passed": True, "sha": ran, "read": False,
+                        "results": [{"name": "tests", "status": "PASS", "said": ""}]})
+                    out = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                    assert out["reason"] == "moved", out
+                    assert ran[:12] in out["message"], out["message"]
+                    assert head[:12] in out["message"], out["message"]
+                    assert out["passed"] is False, "a stale green must not read as proven"
+
+                    # A commit a push rebased away is a DIFFERENT answer: the code it
+                    # measured may be identical, and naming a hash nobody can open is
+                    # worse than saying it is gone.
+                    gate._write_run(root, {**gate.read_run(root), "read": False,
+                                           "sha": "0" * 40, "head": "0" * 40})
+                    gone = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                    assert gone["reason"] == "gone", gone
+                    assert "rebased" in gone["message"], gone["message"]
+                finally:
+                    gate.VERIFY = old
+        finally:
+            config.apply(config.DEFAULTS)
+
+
+def test_the_slot_is_held_from_before_the_child_starts():
+    # The check-then-spawn this replaces left the slot unheld for the whole of a
+    # Python interpreter's startup — hundreds of milliseconds, not an instant — so
+    # two sessions polling one board could both walk through it and the second run's
+    # build would delete the artifact the first one's log check was about to read.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "in-progress", "alpha", body="# T\n")
+        with _work_dir(tmp) as root:
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+            spawned = []
+            real = gate.subprocess.Popen
+            try:
+                # The claim has to be in place BEFORE anything is spawned, or a lost
+                # race still leaves a child running gates nothing is tracking. Only
+                # the verify child is intercepted — everything else here, `git`
+                # included, still runs for real.
+                class Sham:
+                    pid = os.getpid()
+
+                def watch(argv, **kw):
+                    if "--detached" not in argv:
+                        return real(argv, **kw)
+                    spawned.append(gate.live_run(root))
+                    return Sham()
+                gate.subprocess.Popen = watch
+                out = _said(lambda: gate.cmd_verify({"task": "alpha", "start": True}))
+                assert out["state"] == "started", out
+                assert spawned and spawned[0] and spawned[0]["task"] == "alpha", \
+                    "the slot was open while the child was being spawned"
+
+                # A second start over a live claim is refused, and starts nothing.
+                spawned.clear()
+                again = _said(lambda: gate.cmd_verify({"task": "alpha", "start": True}))
+                assert again["state"] == "busy", again
+                assert spawned == [], "a refused start spawned a run anyway"
+
+                # A slot whose process is gone is taken over rather than waited for:
+                # a lock that outlives its holder strands every future verify.
+                gate._write_run(root, {**gate.read_run(root), "pid": 2 ** 31 - 1})
+                free = _said(lambda: gate.cmd_verify({"task": "alpha", "start": True}))
+                assert free["state"] == "started", free
+            finally:
+                gate.subprocess.Popen = real
+                gate.VERIFY = old
+
+
+def test_a_pid_somebody_else_owns_is_alive_not_dead():
+    # Two readings of one pid: `peers._live` treats a kernel refusal as alive and
+    # this treated it as dead, so a run owned by another user read as over and a
+    # second run could start over a live one. One question, one answer.
+    real = gate.os.kill
+    try:
+        def refuse(pid, sig):
+            raise PermissionError(1, "Operation not permitted")
+        gate.os.kill = refuse
+        assert gate._alive(4242) is True
+    finally:
+        gate.os.kill = real
+    # pid 0 asks about the whole process group and a negative one about another
+    # group, so either would answer "alive" about something that is not this run.
+    assert gate._alive(0) is False and gate._alive(-1) is False
+
+
+def test_the_doors_that_start_are_told_apart_from_the_one_that_asks():
+    # `--async` only ever started a run, and it READ like "ask me in the background":
+    # a session polling with it set a fresh nine-gate run going every time the
+    # previous one ended. The parser turns any `--word` into a flag, so an unread one
+    # fell through to the BLOCKING door — the caller waiting minutes for a run it
+    # never asked to start. A typo and a renamed flag both say so now.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        _epic(v, "an-epic")
+        with _work_dir(tmp):
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+            try:
+                for flag in ("async", "stat", "wait"):
+                    try:
+                        gate.cmd_verify({"task": "alpha", flag: True})
+                    except SystemExit as e:
+                        assert e.code, f"--{flag} exited 0"
+                    else:
+                        raise AssertionError(f"--{flag} was accepted and ignored")
             finally:
                 gate.VERIFY = old
+    # The help names each door by whether it STARTS, which is the only distinction
+    # that matters when one of them costs four minutes.
+    help_ = entry.__doc__ or ""
+    assert "--start" in help_ and "--status   only SAYS" in help_, help_
 
 
 def test_a_second_verify_is_refused_while_one_is_running():
@@ -3832,6 +4105,91 @@ def _board_write(repo, item, rows):
     return git.land(repo, item, rows)
 
 
+def test_a_write_does_not_commit_prose_another_session_left_in_the_tree():
+    # The defect, reproduced: two sessions in one checkout, each with an uncommitted
+    # edit, and one of them runs a board command. The pathspec used to take the whole
+    # of `work/`, so the peer's prose landed inside this commit — stamped with this
+    # session and this item, which are both wrong, and both are read downstream to
+    # answer who is on what.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            versions = repo / "work" / "versions" / "01-a-cut" / "an-epic"
+            mine = versions / "in-progress" / "mine"
+            theirs = versions / "in-progress" / "theirs"
+            for folder in (mine, theirs):
+                folder.mkdir(parents=True, exist_ok=True)
+                (folder / "task.md").write_text("# a brief\n")
+            _git(repo, "add", "-A")
+            _git(repo, "commit", "-qm", "two items")
+
+            # Both sessions type prose. Neither has committed; only one runs a command.
+            (mine / "task.md").write_text("# a brief\n\nwhat I wrote.\n")
+            (theirs / "task.md").write_text("# a brief\n\nwhat THEY wrote.\n")
+
+            before = git.dirty(repo)
+            committed, _, note = git.land(
+                repo, "mine", [{"event": "moved", "name": "mine", "to": "complete"}],
+                before)
+            assert committed, "the board write must still land"
+
+            body = _git(repo, "show", "--stat", "--format=%B", "HEAD").stdout
+            assert "mine/task.md" in body, body
+            # The whole point: their file is not in this commit, and is still dirty.
+            assert "theirs/task.md" not in body, body
+            assert "theirs/task.md" in _git(repo, "status", "--porcelain").stdout
+
+            # And the session is told, by name, so it resolves it in this turn rather
+            # than discovering it by reading a trailer later.
+            assert "theirs/task.md" in note, note
+            assert "theirs" in note, note
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_a_write_still_commits_prose_this_session_typed_into_its_own_brief():
+    # The other half, and the reason this is not just a narrower pathspec: a session
+    # hand-edits the brief of the item it holds and then files it. That prose was
+    # authored here, whenever it was typed, and a commit that left it behind would
+    # recreate the hole the sweep was built to close — work in no commit at all.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            folder = repo / "work" / "versions" / "01-a-cut" / "an-epic" / "in-progress" / "mine"
+            folder.mkdir(parents=True, exist_ok=True)
+            (folder / "task.md").write_text("# a brief\n")
+            _git(repo, "add", "-A")
+            _git(repo, "commit", "-qm", "an item")
+
+            # Typed BEFORE the command runs — so it is in `before`, and only the
+            # item it belongs to makes it this session's.
+            (folder / "task.md").write_text("# a brief\n\nwhat I wrote by hand.\n")
+            before = git.dirty(repo)
+
+            committed, _, note = git.land(
+                repo, "mine", [{"event": "moved", "name": "mine", "to": "complete"}],
+                before)
+            assert committed
+            assert "mine/task.md" in _git(repo, "show", "--stat", "--format=%B", "HEAD").stdout
+            assert not _git(repo, "status", "--porcelain").stdout.strip(), "nothing left behind"
+            assert note == "", note
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_a_path_says_which_item_it_belongs_to_and_governance_says_none():
+    # What decides authorship, so it is worth pinning: a task file answers its item,
+    # and a governance doc answers nothing rather than being claimed by whoever holds
+    # an item at the time.
+    assert git.item_of("work/versions/01-a-cut/an-epic/in-progress/alpha/task.md") == "alpha"
+    assert git.item_of("work/versions/01-a-cut/an-epic/queue/beta/handoff.md") == "beta"
+    assert git.item_of("work/backlog/an-epic/gamma/task.md") == "gamma"
+    assert git.item_of("work/architecture/data.md") == ""
+    assert git.item_of("work/versions/01-a-cut/an-epic/epic.md") == ""
+
+
 def test_git_is_off_by_default_so_a_shared_consumer_is_untouched():
     # The harness is shared with repos that never asked for any of this. A default
     # that committed on their behalf would be the same class of surprise as a hook

package/harness/work.py

@@ -91,10 +91,13 @@ cannot finish has somewhere to put the reason instead of stalling or guessing:
     status                             what shipped · what waits on you · what is at risk
     method                             the METHOD in full — how work is done here. The session
                                        block names it; this is the body, on request.
-    verify [--task <name>] [--async]   RUN verify.* (shell=False) and record the result;
-                                       --async starts them and returns, then reports
-                                       progress and finally the result. One at a time
-                                       per checkout: two corrupt each other.
+    verify <name> [--start | --status]  RUN verify.* (shell=False) and record the result.
+                                       Which door you pick decides whether a run STARTS:
+                                         (no flag)  starts them here and waits for the table
+                                         --start    starts them in the background, answers at once
+                                         --status   only SAYS where the run stands — starts nothing
+                                       One run at a time per checkout: two corrupt each
+                                       other. Refused while one is going, and told whose.
     observed <task> --ac AC-01 --saw "…"   an eyes-on, for what a test cannot prove
     ask <task> --question "…" [--options "a | b"] [--owner who] [--durable]
                                        park a question, move on — exits 0, never blocks
@@ -297,6 +300,10 @@ def main() -> int:
     root = locate_work_root()[0]
     repo = root.parent if root else _project_root(flags)
     _say(git.refresh(repo))
+    # What was already uncommitted before this command ran. The commit afterwards
+    # takes what it wrote and leaves what it found, so a peer's half-written prose
+    # is no longer committed under this session's name and this command's item.
+    before = git.dirty(repo)
     try:
         return dispatch(cmd, pos, flags, cfg)
     finally:
@@ -310,7 +317,7 @@ def main() -> int:
         # with neither names NO item, rather than putting a command name where four
         # other slices expect an item.
         item = rows[0]["name"] if rows else (pos[0] if pos else "")
-        committed, pushed, note = git.land(repo, item, rows)
+        committed, pushed, note = git.land(repo, item, rows, before)
         if committed:
             where = f" and pushed to {git.GIT['remote']}" if pushed else ""
             sys.stdout.flush()
@@ -322,7 +329,7 @@ def _writes(cmd: str, flags: dict) -> bool:
     """Does THIS invocation change the board?
 
     The command name answers it for all but one. `verify` writes the result of a run
-    it EXECUTES, and two of its four doors execute nothing: `--async` starts a
+    it EXECUTES, and two of its four doors execute nothing: `--start` starts a
     detached child that commits its own result, and `--status` only reports. Both
     write to `work/.verify`, which is gitignored, so neither has anything of its own
     to land — and both were driving a commit that swept up whatever the person had
@@ -332,7 +339,7 @@ def _writes(cmd: str, flags: dict) -> bool:
     """
     if cmd not in git.WRITES:
         return False
-    if cmd == "verify" and (flags.get("async") or flags.get("status")):
+    if cmd == "verify" and (flags.get("start") or flags.get("status")):
         return False
     return True
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.119",
+  "version": "0.1.121",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -63,10 +63,10 @@
     "@jarvis/errors": "1.0.0",
     "@jarvis/logger": "1.0.0",
     "@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/types": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",