@appchy/jarvis 0.1.77 → 0.1.78

package/harness/harness/gate.py

@@ -384,12 +384,19 @@ def _results_out(data) -> list:
             for r in (data.get("results") or [])]
 
 
-def _verify_async(root, name) -> int:
-    """Start the gates, or say where the run already in flight has got to.
-
-    One call with three answers, because a verify takes minutes and a relayed tool
-    call cannot. Which answer comes back is never the caller's to choose: it is
-    whatever is true about this checkout right now.
+def _verify_report(root, name) -> int:
+    """Say where the run stands. **Never starts one.**
+
+    ASKING AND STARTING ARE TWO OPERATIONS, and they used to be one call whose
+    meaning depended on timing: it attached when a run was in flight and started
+    one when none was. So a session checking whether the gates had finished set a
+    four-minute build going by asking — which is how a repo with a shared build
+    directory raced itself, and the resulting corruption was read as a flaky gate
+    for three sessions.
+
+    The split is on this side rather than the other because THIS is the call that
+    gets repeated. Polling is the loop; starting happens once and is said out
+    loud. A caller that repeats itself must be unable to cause anything.
     """
     running = live_run(root)
     if running:
@@ -424,6 +431,31 @@ def _verify_async(root, name) -> int:
              "done": done.get("done") or [], "passed": bool(done.get("passed")),
              "commit": done.get("sha") or "", "results": _results_out(done)})
 
+    return _answer(
+        "idle",
+        f"No gates have run for '{name or 'no task'}' at this commit. Start them "
+        f"explicitly — asking never starts a run.",
+        {"gates": sorted(VERIFY)})
+
+
+def _verify_start(root, name) -> int:
+    """Start the gates in the background. **Never reports on somebody else's run.**
+
+    Refuses when a run is in flight rather than quietly attaching to it. Attaching
+    is what let one call report a run started for a DIFFERENT task, whose verdict
+    would then have been read against this one's commit — measured 2026-09-09.
+    A refusal that names the task holding the checkout is the honest answer, and
+    the report door is one call away.
+    """
+    running = live_run(root)
+    if running:
+        return _answer(
+            "running", _busy(running),
+            {"gate": running.get("current") or "starting",
+             "elapsedSeconds": _elapsed(running),
+             "gates": running.get("gates") or [], "done": running.get("done") or [],
+             "results": _results_out(running)})
+
     child = subprocess.Popen(
         [sys.executable, os.path.abspath(sys.argv[0]), "verify", "--task", name,
          "--detached"],
@@ -432,17 +464,24 @@ def _verify_async(root, name) -> int:
     return _answer(
         "started",
         f"Gates started ({len(VERIFY)}): {', '.join(sorted(VERIFY))}. They take "
-        f"minutes, not seconds — ask again for progress, and again for the result.",
+        f"minutes, not seconds — ask for progress, which never starts another.",
         {"gates": sorted(VERIFY)})
 
 
 def cmd_verify(args) -> int:
     """Execute the verify commands and RECORD the result against the task.
 
-    Three doors onto one run. Blocking is the person's and is unchanged. `--async`
-    is the tool surface's, because a call that takes 174 seconds cannot be a relayed
-    round trip. `--detached` is the child the second one starts and is nobody's to
-    type.
+    Four doors, and **asking is not one of the ones that starts anything.**
+    Blocking is the person's: typing the command is the explicit act, so it runs
+    the gates and prints the table. `--async` starts a background run for the tool
+    surface, because a call that takes 174 seconds cannot be a relayed round trip.
+    `--status` only reports, and is what a caller waiting for a result uses.
+    `--detached` is the child `--async` spawns and is nobody's to type.
+
+    The two used to be one call that started or attached depending on timing, and
+    the ambiguity cost more than it saved: a session polling for a result started
+    the run it was waiting for, and one call attached to a run belonging to
+    another task and would have reported that verdict here.
     """
     root = find_work_root()
     name = (args.get("task") or "").strip()
@@ -456,16 +495,17 @@ def cmd_verify(args) -> int:
         _execute(root, name)
         return 0
 
+    if args.get("status"):
+        return _verify_report(root, name)
+
+    if args.get("async"):
+        return _verify_start(root, name)
+
     running = live_run(root)
     if running:
-        if args.get("async"):
-            return _verify_async(root, name)
         print(f"error: {_busy(running)}", file=sys.stderr)
         return 1
 
-    if args.get("async"):
-        return _verify_async(root, name)
-
     results, ok, sha = _execute(root, name)
     _print_report(results, sha)
     if name:

package/harness/test_work.py

@@ -2799,6 +2799,83 @@ def test_a_verify_run_is_visible_to_the_next_caller():
                 gate.VERIFY = old
 
 
+def _said(capsys_free_call) -> dict:
+    """The JSON one of the async doors printed, as a dict."""
+    import io
+    from contextlib import redirect_stdout
+
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        capsys_free_call()
+    for line in reversed(buf.getvalue().splitlines()):
+        if line.strip().startswith("{"):
+            return json.loads(line)
+    raise AssertionError(f"no JSON on stdout: {buf.getvalue()!r}")
+
+
+def test_asking_where_the_gates_stand_never_starts_them():
+    # Asking and starting used to be ONE call whose meaning depended on timing, so a
+    # session polling for a result set off the four-minute run it was waiting for.
+    # Polling is the loop and starting happens once, so the repeatable call is the
+    # one that has to be unable to cause anything.
+    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"}
+            try:
+                out = _said(lambda: gate.cmd_verify({"task": "alpha", "status": True}))
+                assert out["state"] == "idle", out
+                # The real assertion: nothing ran, and nothing is running.
+                assert gate.read_run(root) is None, "asking wrote a run file"
+                assert gate.live_run(root) is None
+            finally:
+                gate.VERIFY = old
+
+
+def test_starting_while_a_run_is_live_names_whose_it_is_rather_than_attaching():
+    # Attaching is what let one call report a run started for a DIFFERENT task,
+    # whose verdict would then have been read against this one's commit.
+    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:
+                gate._write_run(root, {"task": "alpha", "pid": os.getpid(),
+                                       "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
+                assert "alpha" in out["message"], out["message"]
+            finally:
+                gate.VERIFY = old
+
+
+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.
+    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:
+                gate.cmd_verify({"task": "alpha"})
+                assert gate.read_run(root)["passed"] is True
+                out = _said(lambda: gate.cmd_verify({"task": "beta", "status": True}))
+                assert out["state"] == "idle", out
+                assert out["passed"] is False, out
+            finally:
+                gate.VERIFY = old
+
+
 def test_a_second_verify_is_refused_while_one_is_running():
     with tempfile.TemporaryDirectory() as tmp:
         v = _tree(tmp)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.77",
+  "version": "0.1.78",
   "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/anthropic": "1.0.0",
+    "@jarvis/board": "0.1.0",
     "@jarvis/data": "0.1.0",
     "@jarvis/errors": "1.0.0",
-    "@jarvis/board": "0.1.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/anthropic": "1.0.0",
-    "@jarvis/vitest-config": "1.0.0"
+    "@jarvis/vitest-config": "1.0.0",
+    "@jarvis/ui": "0.1.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",