@appchy/jarvis 0.1.101 → 0.1.102

package/dist/bin.js

@@ -10260,7 +10260,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 = "1a10c0d";
+var SHA = "2ef6df4";
 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

@@ -677,13 +677,22 @@ def gate(root, task, accept: str = "", owner: str = "") -> list:
         if loose:
             shown = ", ".join(loose[:5])
             more = f" and {len(loose) - 5} more" if len(loose) > 5 else ""
+            # WHO ELSE IS HERE, on the one refusal most likely to be about somebody
+            # else's file. A shared checkout is normal now, and the advice above
+            # ("commit them, or stash what is not this task's") is advice about
+            # another session's unsaved work — so a session that acts on it alone
+            # destroys work nobody can recover. Naming the peers turns "go and find
+            # out who exists" into one message. It cannot say WHICH of them touched
+            # a file: git does not record that and neither does anything else here.
+            others = peers.sharing(root.parent)
             reasons.append(
                 f"{len(loose)} uncommitted change(s) outside the board — the gates "
                 f"ran against this working tree, so completing now would record "
                 f"shipped for code no commit contains: {shown}{more}. Commit them "
                 f"(or stash or gitignore what is not this task's), then re-run "
                 f"`jarvis work verify --task {task.name}` — committing moves HEAD, "
-                f"so the evidence has to be taken on the tree that shipped.")
+                f"so the evidence has to be taken on the tree that shipped."
+                + (f" {others}" if others else ""))
     else:
         reasons.append("no `verify` commands configured — an unconfigured repo "
                        "cannot prove anything, so nothing in it can complete. Set "

package/harness/harness/peers.py

@@ -60,9 +60,14 @@ DEFAULT_SESSIONS = "~/.claude/sessions"
 _RUNNING = {}
 
 
-def running():
-    """Every agent session live on THIS machine as `{session id: name}`, or `None`
-    when nothing here publishes that at all.
+def _live():
+    """Every agent session live on THIS machine, keyed by session id, as the client
+    published it — or `None` when nothing here publishes that at all.
+
+    The whole entry rather than one field of it, because two questions are asked of
+    this directory now: who is running, and who is running IN THIS CHECKOUT. They
+    want the same scan, the same pid check and the same cache, and reading the
+    directory twice would let one answer be true while the other was stale.
 
     The `None` is the whole point and must not be flattened into an empty dict. No
     directory means *this client does not say*, which is where Codex and Gemini sit
@@ -119,11 +124,82 @@ def running():
             continue
         except PermissionError:
             pass  # alive and owned by somebody else, which is still alive
-        out[run] = str(entry.get("name", "")).strip()
+        out[run] = entry
     _RUNNING[key] = out
     return out
 
 
+def running():
+    """Every agent session live on THIS machine as `{session id: name}`.
+
+    `None` and `{}` stay as far apart here as they are in `_live`: no directory
+    means *this client does not say*, and an empty mapping means something
+    published a list this session was not on.
+    """
+    live = _live()
+    if live is None:
+        return None
+    return {run: str(entry.get("name", "")).strip() for run, entry in live.items()}
+
+
+def _inside(where: str, root) -> bool:
+    """Is `where` the same place as `root`, or somewhere under it?
+
+    Both sides are resolved because a session publishes the path it was started
+    with and macOS hands out two names for the same directory — `/tmp/x` and
+    `/private/tmp/x` — so comparing the strings reports two sessions in one
+    checkout as being in different ones.
+    """
+    if not where:
+        return False
+    try:
+        here_ = Path(where).resolve()
+        there = Path(root).resolve()
+    except (OSError, ValueError):
+        return False
+    return here_ == there or there in here_.parents
+
+
+def sharing(root) -> str:
+    """The OTHER live sessions working inside `root`, as one line, or `""`.
+
+    Empty when nothing publishes a session list, when this session is the only one
+    here, or when the peers here publish no name — in each case there is nobody a
+    reader could go and talk to, and a line saying so is noise on a message that is
+    already refusing something.
+
+    **It names who is here, never who touched what.** Git cannot attribute an
+    uncommitted file to a session; nothing on this machine can. So the line says
+    which sessions share this checkout and leaves the asking to the person or the
+    agent, which is the honest half and the one that was missing — the cost being
+    paid today is not that the answer is unknowable, it is that a session refused
+    for somebody else's file has to go and find out who else exists before it can
+    even ask.
+    """
+    live = _live()
+    if not live:
+        return ""
+    mine = me()
+    names = []
+    for run, entry in live.items():
+        if run == mine or not _inside(str(entry.get("cwd", "")), root):
+            continue
+        name = str(entry.get("name", "")).strip()
+        # A session with no published name cannot be addressed, so naming it would
+        # send a reader looking for something `SendMessage` will not take.
+        if name:
+            names.append(name)
+    names.sort()
+    if not names:
+        return ""
+    shown = ", ".join(f"`{n}`" for n in names)
+    one = len(names) == 1
+    return (f"{len(names)} other session{'' if one else 's'} "
+            f"{'is' if one else 'are'} live in this checkout — {shown}. "
+            f"`SendMessage` reaches {'it' if one else 'them'}; ask before you stash "
+            f"or commit anything you did not write.")
+
+
 def describe(instance: str, host: str = "") -> str:
     """`instance` (and the machine it sits on) as a line that says what to do next.
 

package/harness/test_work.py

@@ -4400,6 +4400,75 @@ def test_a_held_task_names_a_session_you_can_actually_reach():
                 os.environ.pop(key, None)
 
 
+def test_a_refusal_about_a_shared_tree_names_who_else_is_in_it():
+    # The completion gate refuses on uncommitted code and then advises stashing it
+    # — which, in a checkout several sessions share, is advice about somebody
+    # else's unsaved work. A session acting on it alone destroys work with no
+    # reflog entry. So the refusal names the peers; finding out who exists was the
+    # cost being paid, not the answer being unknowable.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            here = Path(tmp) / "repo"
+            (here / "src").mkdir(parents=True)
+            elsewhere = Path(tmp) / "other-repo"
+            elsewhere.mkdir()
+            reg = Path(tmp) / "sessions"
+            reg.mkdir()
+            os.environ["WORK_INSTANCE"] = "mine-0000"
+            os.environ["WORK_MACHINE"] = "this-box"
+            os.environ["WORK_SESSIONS_DIR"] = str(reg)
+            peers._RUNNING.clear()
+
+            def publish(n, run, name, cwd, pid=None):
+                (reg / f"{n}.json").write_text(json.dumps(
+                    {"sessionId": run, "name": name, "cwd": str(cwd),
+                     "pid": os.getpid() if pid is None else pid}))
+
+            # Me, so I am never named to myself; a peer deeper inside the same
+            # checkout, because a session started in a subdirectory shares the tree
+            # exactly as much; a session in a different repo; a dead one; and one
+            # live here that publishes no name, which cannot be addressed.
+            publish(1, "mine-0000", "repo-me", here / "src")
+            publish(2, "peer-1111", "repo-a8", here / "src")
+            publish(3, "away-2222", "repo-zz", elsewhere)
+            publish(4, "ghost-3333", "repo-b7", here, pid=2 ** 22)
+            publish(5, "mute-4444", "", here)
+
+            line = peers.sharing(here)
+            assert "repo-a8" in line, "a live peer in this checkout has to be named"
+            assert "1 other session is" in line, \
+                "me, another repo, a ghost and an unaddressable one are all not peers here"
+            for absent in ("repo-me", "repo-zz", "repo-b7"):
+                assert absent not in line, f"{absent} is not somebody to ask"
+
+            # A second live peer makes it plural, and they are named in a stable
+            # order — a message that reshuffles reads as new information.
+            publish(6, "peer-5555", "repo-c9", here)
+            peers._RUNNING.clear()
+            both = peers.sharing(here)
+            assert "2 other sessions are" in both and both.index("repo-a8") < both.index("repo-c9")
+
+            # A checkout nobody else is in is SILENCE, not a line saying so: this
+            # rides on a message that is already refusing something.
+            empty = Path(tmp) / "nobody-here"
+            empty.mkdir()
+            peers._RUNNING.clear()
+            assert peers.sharing(empty) == ""
+            # …and `elsewhere` is not silent, because a session really is in it.
+            # The scoping is by checkout, not by "anywhere but mine".
+            assert "repo-zz" in peers.sharing(elsewhere)
+
+            # And a client that publishes nothing at all must not read as an empty
+            # room — it is the same `None` that stops every peer looking dead.
+            os.environ["WORK_SESSIONS_DIR"] = str(Path(tmp) / "nothing-here")
+            peers._RUNNING.clear()
+            assert peers.running() is None and peers.sharing(here) == ""
+        finally:
+            for key in ("WORK_INSTANCE", "WORK_MACHINE", "WORK_SESSIONS_DIR"):
+                os.environ.pop(key, None)
+            peers._RUNNING.clear()
+
+
 def test_how_long_ago_is_said_in_the_unit_that_changes_the_decision():
     # The question this answers is *is anybody on this*, and the reader is deciding
     # whether to take the work. "6h ago" settles that; a timestamp makes them do

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.101",
+  "version": "0.1.102",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -57,16 +57,16 @@
     "typescript": "^5.7.0",
     "vitest": "^2.1.0",
     "@jarvis/agents": "1.0.0",
-    "@jarvis/data": "0.1.0",
-    "@jarvis/anthropic": "1.0.0",
     "@jarvis/board": "0.1.0",
+    "@jarvis/anthropic": "1.0.0",
     "@jarvis/errors": "1.0.0",
     "@jarvis/logger": "1.0.0",
+    "@jarvis/data": "0.1.0",
     "@jarvis/rpc": "1.0.0",
     "@jarvis/types": "1.0.0",
-    "@jarvis/ui": "0.1.0",
+    "@jarvis/typescript-config": "1.0.0",
     "@jarvis/vitest-config": "1.0.0",
-    "@jarvis/typescript-config": "1.0.0"
+    "@jarvis/ui": "0.1.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",