@appchy/jarvis 0.1.44 → 0.1.46

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 ----------------------------------
 
 
@@ -5067,7 +5172,18 @@ if __name__ == "__main__":
         raise SystemExit(f"collector missed {len(missed)} test(s) — is this block still "
                          f"the last thing in the file? {sorted(missed)}")
 
+    # The id vocabulary is MUTABLE GLOBAL STATE — `config.apply` rebinds `ids.LEDGER` and the
+    # patterns built from it — and any test that runs a command through `work.main` applies the
+    # AMBIENT repo's config as a side effect. Claude Code sets `CLAUDE_PROJECT_DIR` on everything
+    # it spawns, so the suite found a real config there and ran the rest of its cases in that
+    # repo's dialect, while fixtures written from the shipped default stopped matching. The gate
+    # therefore passed from a terminal and failed under `jarvis work verify` — the same tree, two
+    # answers, decided by who called it.
+    #
+    # So each test starts from a STATED vocabulary rather than whatever the one before it left
+    # behind. Cases that exercise a different prefix still set their own; they just no longer leak.
     for fn in tests:
+        config.apply(config.DEFAULTS)
         fn()
         print(f"ok  {fn.__name__}")
     print(f"\n{len(tests)} passed")

package/package.json

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

package/dist/data/rerankers.mjs

@@ -1,52 +0,0 @@
-import "./chunk-AKQQC5IT.mjs";
-import "./chunk-7REP35VA.mjs";
-import "./chunk-RRJ6KKYL.mjs";
-import {
-  reranker
-} from "./chunk-AYOJSS2F.mjs";
-import "./chunk-YWSWQEJN.mjs";
-
-// ../../packages/data/src/rerankers/local.ts
-function localReranker(options = {}) {
-  const model = options.model ?? "Xenova/ms-marco-MiniLM-L-6-v2";
-  const dtype = options.dtype ?? "q8";
-  const pkg = "@huggingface/transformers";
-  let ready;
-  const load = async () => {
-    if (!ready) {
-      const mod = await import(pkg).catch(() => {
-        throw new Error(
-          "localReranker needs '@huggingface/transformers' \u2014 run `pnpm add @huggingface/transformers` (optional dep)."
-        );
-      });
-      ready = Promise.all([
-        mod.AutoTokenizer.from_pretrained(model),
-        mod.AutoModelForSequenceClassification.from_pretrained(model, { dtype })
-      ]).then(([tokenizer, m]) => ({ tokenizer, model: m }));
-    }
-    return ready;
-  };
-  return reranker({
-    name: `local-rerank:${model}`,
-    family: "localReranker",
-    ...options.limit !== void 0 ? { limit: options.limit } : {},
-    rerank: async (query, hits, opts) => {
-      if (hits.length === 0) return hits;
-      const { tokenizer, model: m } = await load();
-      const inputs = tokenizer(new Array(hits.length).fill(query), {
-        text_pair: hits.map((h) => h.text),
-        padding: true,
-        truncation: true
-      });
-      const { logits } = await m(inputs);
-      const scores = logits.sigmoid().tolist();
-      const scored = hits.map((hit, i) => ({ ...hit, score: scores[i]?.[0] ?? 0 }));
-      scored.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-      const topN = opts?.topN;
-      return typeof topN === "number" ? scored.slice(0, topN) : scored;
-    }
-  });
-}
-export {
-  localReranker
-};