@appchy/jarvis 0.1.122 → 0.1.124

package/harness/test_work.py

@@ -3566,6 +3566,32 @@ def test_a_slot_the_harness_cannot_write_is_not_reported_as_somebody_elses_run()
                 gate.VERIFY = old
 
 
+def test_a_session_is_named_for_the_work_not_for_its_title():
+    # The founder could see only prompts: a picker shows each session's FIRST prompt,
+    # which for a jarvis-started run is the whole kickoff block, so four sessions read
+    # as four walls of near-identical text. The name field existed and carried the
+    # TITLE — a 90-character sentence that truncates to the half saying nothing, and
+    # that nobody can type. It is also what `ListAgents` lists and `SendMessage`
+    # addresses, so it has to be a word a person can say out loud.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "in-progress", "a-verify-says-whether-you-are-queued",
+              body="# The verify lock refuses cleanly but cannot say you are queued, "
+                   "or that you were displaced\n")
+        with _work_dir(tmp) as root:
+            task = model.locate(root, "a-verify-says-whether-you-are-queued")
+            assert kickoff.session_name(task) == "a-verify-says-whether-you-are-queued"
+            # The title is what it must NOT be, and the title is the long one.
+            assert len(task.title) > 60, task.title
+            assert task.title not in kickoff.session_name(task)
+
+            # A second run on the same item leads with the number, because that is the
+            # column a picker never truncates.
+            task.sessions.append("2026-09-12  aaaa")
+            assert kickoff.session_name(task) == "2 · a-verify-says-whether-you-are-queued"
+
+
 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
@@ -5041,6 +5067,139 @@ def test_a_refusal_about_a_shared_tree_names_who_else_is_in_it():
             peers._RUNNING.clear()
 
 
+def test_both_readers_of_the_session_registry_agree_about_every_case():
+    # One directory, two readers, two languages — the harness here and the board's
+    # TypeScript, which reads it directly rather than paying a subprocess on every
+    # board list. That is exactly where one session comes to be described two ways,
+    # so the cases live in a file both suites load and both assert the same answer
+    # from. The TypeScript half of this is in packages/board/src/board.test.ts; a
+    # drift between them goes red in both rather than being reconciled by hand.
+    cases = json.loads((Path(__file__).parent / "harness" / "peers.cases.json")
+                       .read_text(encoding="utf-8"))["cases"]
+    assert cases, "the shared cases file has to actually hold cases"
+    for case in cases:
+        with tempfile.TemporaryDirectory() as tmp:
+            try:
+                reg = Path(tmp) / "sessions"
+                if case["sessions"] is not None:
+                    reg.mkdir()
+                    for entry in case["sessions"]:
+                        if "raw" in entry:
+                            (reg / entry["file"]).write_text(entry["raw"])
+                            continue
+                        body = {k: v for k, v in entry.items() if k != "file"}
+                        # A pid is a marker rather than a number: only the running
+                        # process is a pid a test can be sure is alive.
+                        body["pid"] = os.getpid() if body["pid"] == "self" else 2 ** 22
+                        (reg / entry["file"]).write_text(json.dumps(body))
+                os.environ["WORK_SESSIONS_DIR"] = str(reg)
+                peers._RUNNING.clear()
+                assert peers.reach(case["ask"]) == case["expect"], case["name"]
+            finally:
+                os.environ.pop("WORK_SESSIONS_DIR", None)
+                peers._RUNNING.clear()
+
+
+def test_a_session_running_twice_is_never_resolved_to_one_of_its_names():
+    # Opening a jarvis-started session in a second local client starts a SECOND
+    # process on the same id rather than attaching to the first, so both are alive
+    # and both append to one transcript. This used to key one entry per id while
+    # walking sorted filenames, so the later name silently won and which one that
+    # was depended on how two pids happened to sort. Measured on a real machine,
+    # five of seventeen live ids were doubled and the winner flipped pair to pair.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            here = Path(tmp) / "repo"
+            here.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()
+
+            # The real pair, with the filenames from the sighting: the low pid sorts
+            # LAST lexically, so whichever half a reader picked was arbitrary.
+            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),
+                     "entrypoint": door, "pid": os.getpid()}))
+
+            said = peers.describe("forked-4444", "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
+            assert "an editor" in said and "a terminal" in said, \
+                "which half is which is published on disk — it costs nothing to say"
+
+            # The checkout line counts SESSIONS, and says why it has more names.
+            line = peers.sharing(here)
+            assert "1 other session is" in line, "two processes are still one session"
+            assert "jarvis-9a" in line and "the harness stops" in line
+            assert "two processes sharing a transcript" in line
+
+            # And one process on an id is untouched — the ordinary case must read
+            # exactly as it did before any of this.
+            (reg / "20558.json").unlink()
+            peers._RUNNING.clear()
+            alone = peers.describe("forked-4444", "this-box")
+            assert "still running" in alone and "the harness stops" in alone
+            assert "processes" not in alone
+        finally:
+            for key in ("WORK_INSTANCE", "WORK_MACHINE", "WORK_SESSIONS_DIR"):
+                os.environ.pop(key, None)
+            peers._RUNNING.clear()
+
+
+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
+    # overwrote the other. It says who, what they are on, and how to reach them —
+    # and says NOTHING when you are alone, because every session in every repo
+    # running this harness reads it forever.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            here = Path(tmp) / "repo"
+            here.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, door="cli"):
+                (reg / f"{n}.json").write_text(json.dumps(
+                    {"sessionId": run, "name": name, "cwd": str(cwd),
+                     "entrypoint": door, "pid": os.getpid()}))
+
+            publish(1, "mine-0000", "repo-me", here)
+            assert peers.briefing(here, [], "main") == "", \
+                "alone in the checkout is silence, not a line saying so"
+
+            publish(2, "peer-1111", "repo-a8", here)
+            peers._RUNNING.clear()
+            rows = [{"by": "peer-1111", "name": "make-the-thing", "event": "moved"}]
+            said = peers.briefing(here, rows, "main")
+            assert "repo-a8" in said, "who"
+            assert "make-the-thing" in said, "on what"
+            assert "branch main" in said, "on which branch"
+            assert "SendMessage" in said, "and how to reach them"
+            assert "repo-me" not in said, "never about yourself"
+            assert "jarvis work peers" in said, "and a way to ask again"
+
+            # A peer holding nothing is still a peer worth knowing about — it is the
+            # session about to take the work you were going to.
+            peers._RUNNING.clear()
+            nothing = peers.briefing(here, [], "main")
+            assert "repo-a8" in nothing and "holding nothing" in nothing
+        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/harness/work.py

@@ -89,6 +89,9 @@ 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
     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
+                                       again, because the answer is stale as it prints
     method                             the METHOD in full — how work is done here. The session
                                        block names it; this is the body, on request.
     verify <name> [--start | --status]  RUN verify.* (shell=False) and record the result.
@@ -155,6 +158,7 @@ from harness.config import (DEFAULTS, ConfigError, apply, cmd_applies, cmd_confi
                             cmd_context, cmd_method, cmd_remind, resolve)
 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.gate import cmd_observed, cmd_verify
 from harness.kickoff import cmd_kickoff
@@ -173,7 +177,7 @@ SUBCOMMANDS = (
     "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",
-    "observed", "log", "digest", "sync", "check", "links",
+    "observed", "log", "digest", "sync", "check", "links", "peers",
 )
 
 
@@ -366,7 +370,7 @@ def _say(note: str) -> None:
 #: `--branch` could never have meant anything for it.
 _READS = {"list", "find", "path", "code", "where", "rules", "status", "digest",
           "log", "needs", "align", "coverage", "readme", "config", "context",
-          "doctor", "kickoff", "remind", "applies", "wrap"}
+          "doctor", "kickoff", "remind", "applies", "wrap", "peers"}
 
 
 def _reads_only(cmd: str, flags: dict) -> None:
@@ -546,6 +550,8 @@ def dispatch(cmd, pos, flags, cfg) -> int:
         return cmd_next(flags)
     if cmd == "status":
         return cmd_status(flags)
+    if cmd == "peers":
+        return cmd_peers(flags)
     if cmd == "drop":
         if not pos:
             die("usage: jarvis work drop <name> [--why \"…\"]")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.122",
+  "version": "0.1.124",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",