@appchy/jarvis 0.1.118 → 0.1.120

package/dist/bin.js

@@ -10284,7 +10284,7 @@ import { createRequire as createRequire2 } from "module";
 var _require = createRequire2(import.meta.url);
 var VERSION2 = _require("../package.json").version ?? "0.0.0";
 var IS_DEV = String(_require("../package.json").name ?? "").endsWith("-dev");
-var SHA = "1dfb739";
+var SHA = "9022153";
 var BUILT = "2026-09-12";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = `${SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`}${IS_DEV ? " \u2014 development build" : ""}`;

package/harness/harness/git.py

@@ -502,6 +502,94 @@ 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 only_board_moved(repo, sha: str) -> bool:
     """Is everything between `sha` and HEAD a board file?
 
@@ -572,12 +660,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 +683,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 +706,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 +722,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/test_work.py

@@ -3832,6 +3832,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
@@ -5008,6 +5093,26 @@ def test_a_write_aimed_at_another_branch_is_refused():
         raise AssertionError("a write with --branch must be refused")
 
 
+def test_verify_takes_the_name_the_way_every_other_verb_does():
+    # `move <name>`, `observed <task>`, `path <name>` all take a bare word, so that is
+    # what people type for verify — and it read only `--task`. The positional landed
+    # in `pos`, nothing looked at it, and nine gates ran against `""` for minutes and
+    # recorded a result no item could claim. Observed live in `work/.verify` on
+    # 2026-09-12 while a real run was in flight.
+    seen = {}
+    real = entry.cmd_verify
+    try:
+        entry.cmd_verify = lambda flags: seen.update(flags) or 0
+        entry.dispatch("verify", ["an-item"], {}, {})
+        assert seen.get("task") == "an-item", seen
+        # An explicit flag still wins, so nothing changes for the tool surface.
+        seen.clear()
+        entry.dispatch("verify", ["positional"], {"task": "explicit"}, {})
+        assert seen.get("task") == "explicit", seen
+    finally:
+        entry.cmd_verify = real
+
+
 def test_links_is_refused_a_branch_because_fix_writes_this_one():
     # It reports far more often than it fixes, which is what made listing it as a read
     # look right. `--fix` writes, and it writes to the tree that is CHECKED OUT — so

package/harness/work.py

@@ -297,6 +297,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 +314,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()
@@ -555,6 +559,13 @@ def dispatch(cmd, pos, flags, cfg) -> int:
     if cmd == "needs":
         return cmd_needs(flags)
     if cmd == "verify":
+        # A bare name is what the rest of this CLI takes — `move <name>`,
+        # `observed <task>`, `path <name>` — so it is what people type here too, and
+        # this read only `--task`. The positional went into `pos` and nothing looked
+        # at it: nine gates ran against an empty task name, for minutes, and recorded
+        # a result no item could claim. That reports identically to never having run.
+        if pos and not flags.get("task"):
+            flags = {**flags, "task": pos[0]}
         return cmd_verify(flags)
     if cmd == "observed":
         if not pos:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.118",
+  "version": "0.1.120",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -61,8 +61,8 @@
     "@jarvis/board": "0.1.0",
     "@jarvis/data": "0.1.0",
     "@jarvis/errors": "1.0.0",
-    "@jarvis/rpc": "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",