@appchy/jarvis 0.1.45 → 0.1.46

package/harness/harness/gate.py

@@ -132,8 +132,29 @@ def _elapsed(data) -> int:
         return 0
 
 
+#: How much of a failing gate's output is kept, per gate. A gate that fails is
+#: usually failing for something in its last few dozen lines, and the whole of a
+#: test run or a bundle build is megabytes — this is the amount that answers "why"
+#: without turning the run file into a log archive or a caller's context into one.
+_LOG_LINES = 40
+_LOG_CHARS = 4000
+
+
 def run_verify(root, names=None, progress=None) -> tuple:
-    """Run the configured verify commands. Returns (results, ok).
+    """Run the configured verify commands. Returns (results, ok), where a result is
+    (name, status, said, log).
+
+    **A gate that FAILS keeps its output; one that passes keeps none.** For a long
+    time only `said` survived — the last line, cut at 160 characters — and every
+    other byte the gate produced was captured and dropped on the floor. That is why
+    `build` could fail under `jarvis work verify`, pass when run by hand, and stay
+    undiagnosed across three sessions: the evidence was destroyed at the moment it
+    was produced, so the only way to learn anything was to run the thing again by
+    hand and hope it failed the same way. A gate nobody can diagnose is a gate
+    somebody eventually waives.
+
+    Passing gates keep nothing on purpose. Their output is noise, it is the common
+    case, and storing it would put megabytes through a file rewritten on every tick.
 
     A SKIP is reported separately and never counts as a pass — "there was no lint
     configured" and "lint passed" are different facts, and collapsing them is how a
@@ -153,30 +174,50 @@ def run_verify(root, names=None, progress=None) -> tuple:
         try:
             argv = shlex.split(cmd)
         except ValueError as e:
-            results.append((name, "SKIP", f"unparseable command: {e}"))
+            results.append((name, "SKIP", f"unparseable command: {e}", ""))
             continue
         if not argv:
-            results.append((name, "SKIP", "empty command"))
+            results.append((name, "SKIP", "empty command", ""))
             continue
         try:
             proc = subprocess.run(argv, cwd=repo, capture_output=True, text=True,
                                   timeout=1800)
         except FileNotFoundError:
-            results.append((name, "SKIP", f"{argv[0]}: not found"))
+            results.append((name, "SKIP", f"{argv[0]}: not found", ""))
             continue
         except subprocess.TimeoutExpired:
-            results.append((name, "FAIL", "timed out after 30m"))
+            results.append((name, "FAIL", "timed out after 30m", ""))
             continue
         except OSError as e:
-            results.append((name, "SKIP", str(e)))
+            results.append((name, "SKIP", str(e), ""))
             continue
         tail = (proc.stderr or proc.stdout or "").strip().splitlines()
-        results.append((name, "PASS" if proc.returncode == 0 else "FAIL",
-                        tail[-1][:160] if tail else f"exit {proc.returncode}"))
+        failed = proc.returncode != 0
+        results.append((name, "FAIL" if failed else "PASS",
+                        tail[-1][:160] if tail else f"exit {proc.returncode}",
+                        # BOTH streams, in that order: a build writes its diagnosis
+                        # to stderr and its progress to stdout, and a tool suite does
+                        # the opposite. Reading one of them is how a failure comes
+                        # back as "exit 1" with nothing attached.
+                        _keep(proc.stdout, proc.stderr) if failed else ""))
     ok = bool(results) and all(r[1] == "PASS" for r in results)
     return results, ok
 
 
+def _keep(stdout: str, stderr: str) -> str:
+    """The tail of what a failing gate said, capped by lines and then by characters.
+
+    Both caps are needed and neither is enough alone: a Next.js build prints few,
+    enormous lines while a test suite prints thousands of short ones, so a line
+    budget alone lets one through and a character budget alone cuts the other to a
+    fragment of its last line.
+    """
+    text = "\n".join(part.strip() for part in (stdout, stderr) if part.strip())
+    lines = text.splitlines()[-_LOG_LINES:]
+    kept = "\n".join(lines)
+    return kept if len(kept) <= _LOG_CHARS else "…" + kept[-_LOG_CHARS:]
+
+
 def _record(root, name, results, ok, sha) -> bool:
     """Write the outcome onto the task. False when there is no such task."""
     task = locate(root, name)
@@ -184,7 +225,7 @@ def _record(root, name, results, ok, sha) -> bool:
         return False
     entry = (f"{date.today().isoformat()}  {'pass' if ok else 'FAIL'}  "
              f"{sha[:12] or 'no-git'}  "
-             + " ".join(f"{n}={s}" for n, s, _ in results))
+             + " ".join(f"{n}={s}" for n, s, *_ in results))
 
     def mutate(d):
         d["verified"] = as_list(d.get("verified")) + [entry]
@@ -192,7 +233,7 @@ def _record(root, name, results, ok, sha) -> bool:
 
     rewrite_file(task.folder / "task.md", mutate)
     events.append(root, "verified", name, ok=ok, sha=sha[:12] or None,
-                  results={n: s for n, s, _ in results})
+                  results={n: s for n, s, *_ in results})
     return True
 
 
@@ -224,14 +265,15 @@ def _execute(root, name) -> tuple:
 
     def progress(gate, so_far):
         data["current"] = gate
-        data["done"] = [n for n, _, _ in so_far]
+        data["done"] = [n for n, *_ in so_far]
         _write_run(root, data)
 
     results, ok = run_verify(root, progress=progress)
     sha = _head(root.parent)
-    data.update(current="", done=[n for n, _, _ in results],
+    data.update(current="", done=[n for n, *_ in results],
                 finished=_now().isoformat(), passed=ok, sha=sha,
-                results=[{"name": n, "status": s, "said": d} for n, s, d in results])
+                results=[{"name": n, "status": s, "said": d, "log": g}
+                         for n, s, d, g in results])
     _write_run(root, data)
 
     if name and not _record(root, name, results, ok, sha):
@@ -240,11 +282,19 @@ def _execute(root, name) -> tuple:
 
 
 def _print_report(results, sha) -> None:
-    for n, status, detail in results:
+    for n, status, detail, *_ in results:
         mark = {"PASS": "✓", "FAIL": "✗"}.get(status, "·")
         print(f"  {mark} {status:5} {n:14} {detail}")
     print(f"\n  {sum(1 for r in results if r[1] == 'PASS')}/{len(results)} passed"
           + (f" · at {sha[:8]}" if sha else ""))
+    # What the failing gates actually said, after the table rather than inside it —
+    # the table is a shape somebody scans, and a gate's output is paragraphs. Only
+    # failures print: on a green run this adds nothing at all.
+    for n, status, _, log in ((r + ("",))[:4] for r in results):
+        if status == "FAIL" and log:
+            print(f"\n  ── {n} ──")
+            for line in log.splitlines():
+                print(f"  {line}")
 
 
 def _busy(running) -> str:
@@ -272,8 +322,27 @@ def _describe(data) -> str:
         return f"All {len(results)} gates passed{f' at {sha}' if sha else ''}."
     head = (f"{len(failed)} of {len(results)} gates did not pass"
             f"{f' at {sha}' if sha else ''} — fix these, then ask again:")
-    return "\n".join([head] + [f"  {r.get('name')}: {r.get('said') or 'no output'}"
-                               for r in failed])
+    return "\n".join([head] + [_failure(r) for r in failed])
+
+
+#: How many of a failing gate's kept lines reach a CALLER, as opposed to the run
+#: file. Deliberately smaller: a caller pays for these in context on every failed
+#: verify, and the point here is to say enough that the next step is obvious without
+#: re-running anything. The rest is in the run file for whoever needs the whole of it.
+_SAID_LINES = 10
+
+
+def _failure(row) -> str:
+    """One failing gate, as much as a caller needs to act without re-running it.
+
+    A caller told only `build: exit 1` has to leave the surface and run the build
+    itself to learn anything — which is the loop this exists to end, and the reason
+    three sessions in a row recorded `build` as "not diagnosed here".
+    """
+    name, said = row.get("name"), row.get("said") or "no output"
+    log = (row.get("log") or "").splitlines()[-_SAID_LINES:]
+    body = "".join(f"\n      {line}" for line in log)
+    return f"  {name}: {said}{body}"
 
 
 def _still_current(repo, sha: str) -> bool:

package/harness/harness/git.py

@@ -34,9 +34,10 @@ paths say.
 
 **What a commit contains, exactly.** Only the configured paths, committed with a
 pathspec, so a session's unrelated staged code is neither swept in nor disturbed.
-One thing does move: if a push is rejected and the retry rebases, an autostash
-restores the session's own edits as working-tree changes rather than staged ones.
-The content survives; the staging does not.
+**And the retry never touches the working tree.** A rejected push rebases onto the
+new tip with autostash explicitly OFF, so git declines to rebase over uncommitted
+work rather than moving it aside; the board commit stays local and `sync` sends it.
+Nothing here stashes, resets or restores a session's own edits.
 """
 import contextlib
 import json
@@ -539,7 +540,9 @@ def _push(repo) -> tuple:
 
     A rebase that hits a conflict is aborted rather than left half-done: a session
     dropped into a conflicted rebase it did not ask for cannot get on with its work,
-    and the commit is already safe.
+    and the commit is already safe. For the same reason it rebases with autostash
+    OFF, so a tree with uncommitted work in it stops the rebase instead of having
+    that work moved aside — the push waits, and nothing of the session's own moves.
     """
     remote = GIT["remote"]
     why = ""
@@ -557,16 +560,18 @@ def _push(repo) -> tuple:
             break
         if attempt == _ATTEMPTS - 1:
             break
-        _, pre, _ = _git(repo, "rev-parse", "HEAD")
-        code, _, rebase_err = _git(repo, "-c", "rebase.autoStash=true", "pull",
+        # `autoStash=false` is SET rather than left unsaid, because unsaid means
+        # whatever the machine's own git config says — and a machine that turned
+        # autostash on globally would go on moving a session's edits aside, which
+        # is the behaviour this explicitly refuses. A dirty tree makes git decline
+        # the rebase, and declining is the whole point: the board commit is already
+        # made and safe, so the only thing left to lose here is the session's own
+        # uncommitted work, and nothing may move that without being asked.
+        code, _, rebase_err = _git(repo, "-c", "rebase.autoStash=false", "pull",
                                    "--rebase", remote, timeout=_NET_TIMEOUT)
         if code != 0:
             _git(repo, "rebase", "--abort")
-            why = f"the branch moved and the rebase onto it did not apply: {_tail(rebase_err)}"
-            break
-        stranded = _unstash(repo, pre.strip())
-        if stranded:
-            why = stranded
+            why = _why_no_rebase(rebase_err)
             break
     from .tree import cli
 
@@ -574,34 +579,20 @@ def _push(repo) -> tuple:
                    f"`{cli()} sync` sends it when you can reach {remote}.")
 
 
-def _unstash(repo, pre: str) -> str:
-    """Undo a pull whose autostash could not be put back. Returns why-not, or "".
-
-    `pull --rebase` exits **0** when the rebase itself lands and only the autostash
-    pop conflicts, so without this the caller reads success: the push goes out and
-    the session is told the write was pushed, while its working tree is left holding
-    conflict markers it did not ask for and its own uncommitted edits sit in a stash
-    nobody mentioned. Going back to where the pull started puts those edits back
-    where their author left them, which is the same promise the abort above makes.
+def _why_no_rebase(err: str) -> str:
+    """Why the rebase onto the moved branch did not run, in the caller's terms.
 
-    The board commit is never at risk — it was made before any of this, and it is
-    inside `pre`. It stays committed and unpushed, which is what `sync` is for.
+    The common case is not a conflict at all: the branch moved while the session had
+    uncommitted work open, and git declines to rebase over it. That reads as a scary
+    failure and is an ordinary one, so it is named separately and says what to do —
+    the board commit is already in git, and only the push is waiting.
     """
-    _, unmerged, _ = _git(repo, "diff", "--name-only", "--diff-filter=U")
-    if not unmerged.strip() or not pre:
-        return ""
-    clash = "the branch moved, and your uncommitted edits clash with what was on it"
-    # Every step is checked before the next one claims it happened. Saying "your
-    # working tree is as you left it" over a reset that did not run would be the
-    # same false report this whole function exists to stop.
-    code, _, err = _locking(repo, "reset", "--hard", pre)
-    if code != 0:
-        return (f"{clash}, and the tree could not be put back ({_tail(err)}) — "
-                f"your edits are in `git stash`, and the rebase is half-applied")
-    code, _, err = _locking(repo, "stash", "pop")
-    if code != 0:
-        return f"{clash} — nothing was rebased, and your edits are in `git stash` ({_tail(err)})"
-    return f"{clash} — nothing was rebased and your working tree is as you left it"
+    if re.search(r"unstaged changes|uncommitted changes|cannot pull with rebase|"
+                 r"cannot rebase.*(dirty|unstaged)", err, re.I):
+        return ("the branch moved, and your own uncommitted edits are in the way of "
+                "rebasing onto it — nothing was moved or stashed; commit them and the "
+                "next board write pushes both")
+    return f"the branch moved and the rebase onto it did not apply: {_tail(err)}"
 
 
 def _message(item: str, rows: list) -> tuple:

package/harness/test_work.py

@@ -2386,6 +2386,72 @@ def test_a_failing_verify_run_cannot_be_recorded_as_evidence():
                 gate.VERIFY = old
 
 
+def test_a_failing_gate_keeps_what_it_said_and_a_passing_one_keeps_nothing():
+    # Only `said` used to survive — the last line, cut at 160 characters — and every
+    # other byte the gate produced was captured and dropped. That is why `build`
+    # could fail under the gate, pass by hand, and stay undiagnosed across three
+    # sessions: the evidence was destroyed at the moment it was produced.
+    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 = {
+                # Both streams, because a build diagnoses on stderr and a test suite
+                # on stdout, and reading one of them is how a failure comes back as
+                # `exit 1` with nothing attached.
+                "noisy": "sh -c 'echo the-reason-on-stdout; "
+                         "echo the-reason-on-stderr >&2; exit 3'",
+                "quiet": "sh -c 'echo nothing-worth-keeping; exit 0'",
+            }
+            try:
+                assert gate.cmd_verify({"task": "alpha"}) == 1
+                rows = {r["name"]: r for r in gate.read_run(root)["results"]}
+                assert "the-reason-on-stdout" in rows["noisy"]["log"], \
+                    "a failing gate keeps what it wrote to stdout"
+                assert "the-reason-on-stderr" in rows["noisy"]["log"], \
+                    "and to stderr, which is where a build puts its diagnosis"
+                assert rows["quiet"]["log"] == "", \
+                    "a passing gate keeps nothing — it is noise, and it is the common case"
+            finally:
+                gate.VERIFY = old
+
+
+def test_what_a_failing_gate_said_reaches_the_caller_not_only_the_run_file():
+    # A caller told `build: exit 1` has to leave the surface and run the build itself
+    # to learn anything, which is the loop this ends. The tool door is the one that
+    # matters: it is what an agent sees, and it is the door the completion gate is
+    # reached through.
+    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 = {"boom": "sh -c 'echo a-line-that-explains-it >&2; exit 1'"}
+            try:
+                gate.cmd_verify({"task": "alpha"})
+                said = gate._describe(gate.read_run(root))
+                assert "a-line-that-explains-it" in said, \
+                    "the caller is told WHY, not only that something failed"
+            finally:
+                gate.VERIFY = old
+
+
+def test_a_gates_kept_output_is_capped_by_lines_and_by_characters():
+    # Both caps are load-bearing and neither is enough alone: a bundle build prints
+    # few enormous lines while a test suite prints thousands of short ones, so a line
+    # budget alone lets the first through and a character budget alone cuts the
+    # second to a fragment of its last line.
+    many = gate._keep("\n".join(str(n) for n in range(500)), "")
+    assert len(many.splitlines()) <= gate._LOG_LINES
+    assert "499" in many, "and it keeps the END, which is where a failure explains itself"
+    huge = gate._keep("x" * 50_000, "")
+    assert len(huge) <= gate._LOG_CHARS + 1, "the ellipsis is the one extra character"
+    assert huge.startswith("…"), "a cut is visible rather than silent"
+
+
 def test_a_verify_run_is_visible_to_the_next_caller():
     # The whole point of the run file. A blocking run that recorded nothing would be
     # invisible to whoever asked next, and the overlap that corrupts a result is
@@ -4929,11 +4995,13 @@ def test_a_backslash_in_a_title_scaffolds_and_leaves_the_repo_usable():
             assert "A \\n in a title" in (Path(tmp) / "README.md").read_text()
 
 
-def test_a_push_whose_autostash_conflicts_is_reported_and_the_tree_restored():
-    # `pull --rebase` exits 0 when the rebase lands and only the autostash pop
-    # conflicts, so the push went out and the caller was told the write was pushed —
-    # while the session's working tree was left holding conflict markers and its own
-    # edits sat in a stash nobody mentioned.
+def test_a_push_needing_a_rebase_over_a_dirty_tree_waits_rather_than_moving_it():
+    # The retry used to rebase with `rebase.autoStash=true`, which moved the session's
+    # own uncommitted edits aside to make room and put them back afterwards. Removed
+    # deliberately (founder, 2026-09-08): the board commit is already safe by this
+    # point, so the only thing left for the retry to lose is work nobody asked it to
+    # touch. Now git declines the rebase, the push waits for `sync`, and the tree is
+    # exactly as its author left it.
     with tempfile.TemporaryDirectory() as tmp:
         try:
             repo = _git_repo(tmp)
@@ -4960,22 +5028,59 @@ def test_a_push_whose_autostash_conflicts_is_reported_and_the_tree_restored():
                 repo, "ours", [{"event": "created", "name": "ours"}])
 
             assert committed, "the board commit is made before any of this and is safe"
-            assert not pushed, f"a push that left a conflict behind is not a push: {note}"
-            assert "NOT pushed" in note and "clash" in note, \
-                f"the caller has to be told what actually happened: {note}"
+            assert not pushed, f"the branch moved and the rebase could not run: {note}"
+            assert "NOT pushed" in note and "sync" in note, \
+                f"the caller is told the write is safe and how to send it: {note}"
+            assert "uncommitted" in note, \
+                f"and told WHY it could not push, in terms it can act on: {note}"
             assert (repo / "src" / "app.ts").read_text() == "mine, not yet committed\n", \
-                "the session's edits are put back where their author left them"
+                "the session's own edits are untouched — not stashed, not restored"
             assert "<<<<<<<" not in (repo / "src" / "app.ts").read_text()
             assert not _git(repo, "diff", "--name-only", "--diff-filter=U").stdout.strip(), \
                 "no half-done merge is left in the index"
             assert not _git(repo, "stash", "list").stdout.strip(), \
-                "and nothing is stranded in a stash nobody will look in"
+                "and nothing was ever put in a stash to begin with"
             assert "ours.md" in _git(repo, "log", "-1", "--name-only",
                                      "--format=").stdout
         finally:
             config.apply(config.DEFAULTS)
 
 
+def test_a_push_needing_a_rebase_over_a_clean_tree_still_lands():
+    # Removing the autostash must not cost the ordinary case. With nothing
+    # uncommitted there is nothing in the rebase's way, so a board write racing
+    # another machine still rebases onto the new tip and pushes on the retry.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp)
+            (repo / "src").mkdir(exist_ok=True)
+            (repo / "src" / "app.ts").write_text("original\n")
+            _git(repo, "add", "-A")
+            _git(repo, "commit", "-qm", "code")
+            _git(repo, "push", "-q", "origin", "HEAD:main")
+
+            import subprocess
+            other = repo.parent / "other"
+            subprocess.run(["git", "clone", "-q", str(repo.parent / "origin.git"),
+                            str(other)], check=True, capture_output=True)
+            for k, val in (("user.email", "o@o"), ("user.name", "O")):
+                _git(other, "config", k, val)
+            (other / "src" / "app.ts").write_text("theirs\n")
+            _git(other, "commit", "-qam", "theirs")
+            _git(other, "push", "-q", "origin", "HEAD:main")
+
+            (repo / "work" / "ours.md").write_text("ours\n")
+            committed, pushed, note = _board_write(
+                repo, "ours", [{"event": "created", "name": "ours"}])
+
+            assert committed and pushed, \
+                f"a clean tree rebases onto the moved branch and lands: {note}"
+            assert "theirs\n" == (repo / "src" / "app.ts").read_text(), \
+                "and the session ends up on top of what the other machine pushed"
+        finally:
+            config.apply(config.DEFAULTS)
+
+
 # --- what a session is told before it starts ----------------------------------
 
 

package/package.json

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