@appchy/jarvis 0.1.80 → 0.1.81

package/dist/bin.js

@@ -10110,7 +10110,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 = "959c0ae";
+var SHA = "fa00fb0";
 var BUILT = "2026-09-11";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = `${SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`}${IS_DEV ? " \u2014 development build" : ""}`;

package/harness/harness/gate.py

@@ -624,7 +624,12 @@ def gate(root, task, accept: str = "", owner: str = "") -> list:
         # The harness names the files and stops there: committing somebody's source
         # is a far larger claim on their repo than committing the board, and a board
         # write deliberately leaves a session's own code alone (founder, 2026-09-10).
-        loose = git.uncommitted_code(root.parent) if git.enabled() else []
+        #
+        # Scoped to what this task is answerable for, because a checkout is shared
+        # and the unscoped version means nobody completes anything until everybody
+        # commits. Unclaimed paths, and a task that declares no regions, stay strict.
+        loose = (git.uncommitted_mine(root.parent, root, list(task.code or []))
+                 if git.enabled() else [])
         if loose:
             shown = ", ".join(loose[:5])
             more = f" and {len(loose) - 5} more" if len(loose) > 5 else ""

package/harness/harness/git.py

@@ -136,6 +136,44 @@ def uncommitted_code(repo) -> list:
     return sorted(found)
 
 
+def uncommitted_mine(repo, root, regions: list) -> list:
+    """Of the uncommitted code, what THIS task is answerable for.
+
+    **`moved_only_elsewhere` already decided this question for commits**, and the
+    two have to agree. That one says a commit outside your `code:` regions does not
+    invalidate your evidence, because a suite failure over there only warns — and
+    holding that while letting a merely DIRTY file over there refuse you is the same
+    inconsistency, read one step earlier.
+
+    It is not hypothetical. A session finishing harness work was blocked by a peer's
+    19 uncommitted UI files in a shared checkout, none of them in the region its
+    task declared. In a checkout two people share, the unscoped rule means nobody
+    can complete anything until everybody commits.
+
+    **Unclaimed is always yours, and that is the whole safety of it.**
+    `system_for_path` answers `None` both for a file nothing declares and for a repo
+    whose systems declare nothing, and from here the two are indistinguishable.
+    Reading either as *not my business* would make the check vacuous in exactly the
+    repos that never filled in `paths:`. A task that declares no `code:` of its own
+    is answerable for all of it, for the same reason: it has not said what it
+    touches, so it cannot say a file is somebody else's.
+    """
+    loose = uncommitted_code(repo)
+    if not loose or not regions:
+        return loose
+    from .registry import scan_systems, system_for_path
+    systems = scan_systems(root)
+    if not systems:
+        return loose
+    mine = {r for r in regions if r}
+    kept = []
+    for name in loose:
+        owner = system_for_path(root, name, systems)
+        if owner is None or (mine & set(owner.code)):
+            kept.append(name)
+    return kept
+
+
 def machine() -> str:
     """Which machine acted. `WORK_MACHINE` where something knows a better name for
     this box than its hostname — a daemon that already has an identity for it —

package/harness/test_work.py

@@ -3634,6 +3634,95 @@ def test_partly_committed_code_is_still_uncommitted_code():
             config.apply(config.DEFAULTS)
 
 
+def test_a_peers_uncommitted_work_in_another_system_does_not_block_you():
+    # The mirror of `moved_only_elsewhere`, and it has to agree with it: if a
+    # COMMIT outside your regions cannot invalidate your evidence, a merely DIRTY
+    # file outside them cannot refuse you either. Holding both at once is the
+    # inconsistency, read one step earlier.
+    #
+    # Measured rather than imagined: the session that built the unscoped version
+    # was blocked by a peer's 19 uncommitted UI files, none in the region its task
+    # declared. In a shared checkout that rule means nobody completes anything
+    # until everybody commits.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            arch = repo / "work" / "architecture"
+            arch.mkdir(parents=True, exist_ok=True)
+            (arch / "board.md").write_text(
+                "---\ntype: system\ncode: [data]\npaths: [packages/board]\n"
+                "depends_on: []\n---\n\n# Board\n")
+            (arch / "screen.md").write_text(
+                "---\ntype: system\ncode: [web]\npaths: [apps/web]\n"
+                "depends_on: []\n---\n\n# Screen\n")
+            for f in ("packages/board/store.ts", "apps/web/page.tsx", "scripts/loose.py"):
+                (repo / f).parent.mkdir(parents=True, exist_ok=True)
+                (repo / f).write_text("first\n")
+            _provable_task(repo)  # commits the board AND the code above
+
+            root = repo / "work"
+            # The task says what it touches, which is what earns it the narrowing.
+            brief = root / "versions" / "01-a-cut" / "an-epic" / "in-progress" / "alpha" / "task.md"
+            brief.write_text(brief.read_text().replace(
+                "priority: P0", "priority: P0\ncode: [data]"))
+            _git(repo, "add", "-A")
+            _git(repo, "commit", "-qm", "alpha declares its region")
+
+            with _work_dir(str(root)) as work_root:
+                old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+                try:
+                    assert gate.cmd_verify({"task": "alpha"}) == 0
+
+                    # A PEER IS MID-EDIT IN ANOTHER SYSTEM. You can still finish.
+                    (repo / "apps/web/page.tsx").write_text("a peer, mid-thought\n")
+                    assert gate.gate(work_root, model.locate(work_root, "alpha")) == []
+
+                    # YOUR OWN REGION, UNCOMMITTED. That is the thing this catches.
+                    (repo / "packages/board/store.ts").write_text("the fix, uncommitted\n")
+                    reasons = gate.gate(work_root, model.locate(work_root, "alpha"))
+                    assert any("packages/board/store.ts" in r for r in reasons), reasons
+                    assert not any("apps/web/page.tsx" in r for r in reasons), reasons
+
+                    # A PATH NOTHING CLAIMS IS ALWAYS YOURS. The safety property: a
+                    # repo that never filled in `paths:` must not get a gate that
+                    # passes everything, which is worse than the noise it replaces.
+                    _git(repo, "checkout", "--", "packages/board/store.ts")
+                    (repo / "scripts/loose.py").write_text("claimed by no system\n")
+                    reasons = gate.gate(work_root, model.locate(work_root, "alpha"))
+                    assert any("scripts/loose.py" in r for r in reasons), reasons
+                finally:
+                    gate.VERIFY = old
+        finally:
+            config.apply(config.DEFAULTS)
+
+
+def test_a_task_that_declares_no_region_is_answerable_for_all_of_it():
+    # It has not said what it touches, so it cannot say a file is somebody else's.
+    # The same reading `moved_only_elsewhere` gives an empty `regions`.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            arch = repo / "work" / "architecture"
+            arch.mkdir(parents=True, exist_ok=True)
+            (arch / "screen.md").write_text(
+                "---\ntype: system\ncode: [web]\npaths: [apps/web]\n"
+                "depends_on: []\n---\n\n# Screen\n")
+            (repo / "apps/web").mkdir(parents=True)
+            (repo / "apps/web/page.tsx").write_text("first\n")
+            _provable_task(repo)
+            with _work_dir(str(repo / "work")) as root:
+                old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+                try:
+                    assert gate.cmd_verify({"task": "alpha"}) == 0
+                    (repo / "apps/web/page.tsx").write_text("changed\n")
+                    reasons = gate.gate(root, model.locate(root, "alpha"))
+                    assert any("apps/web/page.tsx" in r for r in reasons), reasons
+                finally:
+                    gate.VERIFY = old
+        finally:
+            config.apply(config.DEFAULTS)
+
+
 def test_a_repo_that_never_asked_for_git_completes_exactly_as_before():
     # The harness is shared with repos that opted out of all of this. Refusing on
     # their working tree would be a new claim on somebody who asked for none.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.80",
+  "version": "0.1.81",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -57,15 +57,15 @@
     "typescript": "^5.7.0",
     "vitest": "^2.1.0",
     "@jarvis/agents": "1.0.0",
-    "@jarvis/board": "0.1.0",
     "@jarvis/anthropic": "1.0.0",
+    "@jarvis/board": "0.1.0",
     "@jarvis/data": "0.1.0",
     "@jarvis/errors": "1.0.0",
     "@jarvis/logger": "1.0.0",
     "@jarvis/rpc": "1.0.0",
     "@jarvis/types": "1.0.0",
-    "@jarvis/ui": "0.1.0",
     "@jarvis/typescript-config": "1.0.0",
+    "@jarvis/ui": "0.1.0",
     "@jarvis/vitest-config": "1.0.0"
   },
   "scripts": {