@appchy/jarvis 0.1.93 → 0.1.95

package/dist/bin.js

@@ -10154,7 +10154,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 = "8d91a7c";
+var SHA = "20f7aad";
 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/config.py

@@ -1001,6 +1001,19 @@ def session_pointers(cfg: dict, repo=None) -> list:
                    f"always high. Until it fires or the user asks, keep working"
                    + (f"; then run `{cfg['wrap']['command']}`." if cfg["wrap"]["command"]
                       else "."))
+    # Said whether or not a threshold is configured, because neither half of it
+    # depends on one. The second sentence is the one that changes how a turn ENDS:
+    # the founder's standing complaint was never that the leftovers were hidden, it
+    # was that a session's own closing prose does not say what is actually finished
+    # — so the machine-derived version is on screen already, and re-narrating it in
+    # paragraphs competes with it rather than adding to it.
+    if cfg["hooks"]["stop"]["enabled"]:
+        out.append("the same hook wraps you EARLY when an item you took reaches "
+                   "complete — that is the end of the work, not a warning about "
+                   "room. At the end of every turn it also shows the person the "
+                   "derived standing: the item, its bucket, its criteria and what "
+                   "the completion gate would still refuse on. Do not restate any "
+                   "of that in prose — say what you decided and what you need.")
     return out
 
 
@@ -1090,8 +1103,13 @@ def _session_state(cfg: dict, repo) -> Path:
     """Where per-machine, per-session markers live — beside the coverage shard, which
     is already the gitignored root for facts that are about this checkout and not
     about the repo. One reader, because the hook that replays these has the default
-    baked in and a second answer here would silently stop matching it."""
-    return repo / Path(cfg["coverage"]["shard"]).parent
+    baked in and a second answer here would silently stop matching it.
+
+    WHICH directory that is comes from `shard.state_root`, shared with the check that
+    decides whether a file is somebody's uncommitted work — the two have to name the
+    same place, or the harness reports its own markers as a person's."""
+    from .shard import state_root
+    return repo / state_root(cfg["coverage"]["shard"])
 def _remember_systems(cfg: dict, repo, session, systems, off=False) -> None:
     """Leave this repo's file-to-system declarations where the caller can replay them.
 
@@ -1263,7 +1281,10 @@ def cmd_remind(cfg: dict, args=None, repo=None) -> int:
     if full and _first_time(cfg, repo, session):
         why.append(f"Context is {percent:.0f}% full ({used:,} of {window:,} tokens; "
                    f"the threshold is {at}%).")
-    if not lines and not why and not extra:
+    # `full` earns a headline of its own even once the note is spent: the window
+    # keeps filling after the one turn that was allowed to interrupt, and a person
+    # who saw 50% once and nothing at 90% was told less as it got worse.
+    if not lines and not why and not full and not extra:
         return 0
 
     # Null when the repo names none, and then the reminder says to wrap without naming
@@ -1364,6 +1385,12 @@ def _standing_lines(where) -> list:
                    f"{shown}{more}")
     for cut in where.cuts:
         out.append(f"cut {cut} — every task complete, not released")
+    # Said LAST and only beside something else. A repo git cannot read has nothing
+    # actionable to say about commits, so on its own this would be a line every turn
+    # that nobody can act on — while next to work in flight it is the difference
+    # between "your code is committed" and "nobody checked".
+    if where.loose is None and out:
+        out.append("code in git: cannot tell — git did not answer in this directory")
     return out
 
 

package/harness/harness/git.py

@@ -123,9 +123,20 @@ def uncommitted_code(repo) -> list:
     this check's business.
 
     Claims and the run file are excluded for the reason they are never committed —
-    they are one machine's coordination, true for minutes.
+    they are one machine's coordination, true for minutes. **So is the harness's own
+    scratch root**, and that exclusion was missing: the coverage shards, the id
+    allocator and the session markers are all written by the harness itself, and in
+    a repo that had not gitignored them by hand this named them as somebody's
+    unsaved work — then refused every completion, because a verify run drops a shard
+    and the gate reads this. A check that accuses a person of leaving behind a file
+    the harness just wrote is one nobody can act on.
     """
+    from .shard import DIR, state_root
+
     board = [r.rstrip("/") for r in (GIT.get("paths") or [])]
+    scratch = state_root(DIR)
+    if scratch:
+        board.append(scratch)
     code, out, _ = _git(repo, "status", "--porcelain", "-z",
                         "--untracked-files=all", "--no-renames")
     if code != 0:

package/harness/harness/shard.py

@@ -20,6 +20,26 @@ from typing import NamedTuple
 #: close a cycle.
 DIR = ".work/coverage"
 
+def state_root(configured: str) -> str:
+    """The directory this checkout's own scratch hangs off, repo-relative.
+
+    The shards, the session markers and the id allocator all live under it, and
+    four docstrings in this harness call it gitignored on purpose — while nothing
+    made it so. So it is DERIVED from where shards are configured to land rather
+    than named again wherever somebody needs it: a repo that moved its shards moved
+    this, and a second spelling would stop matching without saying so.
+
+    Falls back to the configured directory itself when that is one segment deep.
+    The parent of `coverage` is the repo, and a check that excluded the repo would
+    be vacuous rather than wrong-looking — which is the failure that cannot be seen
+    from its output.
+    """
+    d = str(configured or "").replace("\\", "/").strip("/")
+    if not d:
+        return ""
+    return d.rsplit("/", 1)[0] if "/" in d else d
+
+
 #: Precedence when several sites claim one criterion — the SAME rank both
 #: reporters already apply within a single runner. Anything unrecognised ranks
 #: below `passed`, so a shard that learns a new status can never silently

package/harness/harness/wrap.py

@@ -20,7 +20,7 @@ say what's actually completed or not and where are we standing"_. So the bottom
 derived — the bucket, the criteria, what the completion gate would still refuse on — and
 the prose is left to say whatever it says.
 """
-from datetime import date, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import NamedTuple
 
@@ -44,14 +44,12 @@ class Standing(NamedTuple):
     held: list
     #: Names taken here and moved to complete.
     finished: list
-    #: Paths outside the board that are not in git.
+    #: Paths outside the board that are not in git — None when git could not answer,
+    #: which is not the same as none of them.
     loose: list
     #: Cuts whose every task is complete and which nobody has released.
     cuts: list
 
-    def anything(self) -> bool:
-        return bool(self.held or self.finished or self.loose or self.cuts)
-
 
 #: How far back to read the board's own history when working out what THIS session
 #: took. A session does not outlive a few days, and the log it is read out of grows
@@ -88,16 +86,24 @@ def standing(session: str, repo: Path) -> Standing:
     # tree is kept; whether a session's code reached git is a question about the
     # repo, and it is the one worth answering in a repo that has not switched the
     # board's own commits on.
-    loose = git.uncommitted_code(repo)
+    #
+    # None when git cannot answer, which is NOT the same as nothing outstanding —
+    # the list comes back empty from a repo git cannot read, and an empty list here
+    # would read as "your code is safe". The caller says which it got.
+    loose = git.uncommitted_code(repo) if git.is_repo(repo) else None
     root, _, _ = locate_work_root()
     if not root or not root.is_dir():
         return Standing(held=[], finished=[], loose=loose, cuts=[])
 
-    since = (date.today() - timedelta(days=_WINDOW_DAYS)).isoformat()
-    mine = {}
-    for e in read_events(root, since=since):
-        if e.get("event") == "moved" and e.get("by") == session and e.get("name"):
-            mine[e["name"]] = e.get("to")
+    # UTC, because that is the clock the rows are on: git anchors a plain date to
+    # UTC midnight and the file backend compares it as text against a UTC
+    # timestamp, so a local date would move the window by this machine's offset.
+    since = (datetime.now(timezone.utc).date()
+             - timedelta(days=_WINDOW_DAYS)).isoformat()
+    # Where it went is deliberately not kept: the bucket the item is in NOW is the
+    # status, and a remembered destination would be a second answer to it.
+    mine = {e["name"] for e in read_events(root, since=since)
+            if e.get("event") == "moved" and e.get("by") == session and e.get("name")}
 
     held, finished = [], []
     for name in mine:
@@ -144,8 +150,7 @@ def _uncommitted(repo) -> list:
     comes back empty from a repo git cannot read — and reporting that as "nothing
     uncommitted" is the one wrong answer this section must not give.
     """
-    code, _, _ = git._git(repo, "rev-parse", "--git-dir")
-    if code != 0:
+    if not git.is_repo(repo):
         return ["  code in git: cannot tell — this is not a git repo, or git did not "
                 "answer. Check it yourself before you walk away."]
     # One reader for what is outside the board, shared with the end-of-turn line and
@@ -189,10 +194,12 @@ def _in_flight(root) -> list:
     # The ratio, because "move what finished" needs to know which of these is
     # anywhere near finished, and the criteria are the only answer to that which
     # does not depend on somebody's recollection.
-    named = "\n      ".join(
-        f"{t.name} — {t.title}"
-        + (f"  [{total - len(unchecked)}/{total} criteria]" if total else "")
-        for t in live for unchecked, total in [gate.criteria(t)])
+    rows = []
+    for t in live:
+        unchecked, total = gate.criteria(t)
+        ratio = f"  [{total - len(unchecked)}/{total} criteria]" if total else ""
+        rows.append(f"{t.name} — {t.title}{ratio}")
+    named = "\n      ".join(rows)
     return [f"  in progress: {len(live)} item(s). Move what finished, park what did "
             f"not — the bucket IS the status:\n      {named}"]
 

package/harness/test_work.py

@@ -3,6 +3,7 @@
 B-/AC- id bookkeeping, no stories.md) and the version/epic/task reshape — the
 three-tier scan, the version gate, and the four shape lints."""
 
+import copy
 import importlib.util
 import json
 import os
@@ -27,7 +28,7 @@ from harness.ids import LEDGER as L  # noqa: E402 — fixtures render in the rep
 from harness import (align, architecture, autonomy, branches, config, coverage, epic,  # noqa: E402
                      events, extend, frontmatter, gate, generate, git, ids, kickoff,
                      lint, model, peers, registry, report, safety, scaffold,
-                     shard, shift, task, tree, version)
+                     shard, shift, task, tree, version, wrap)
 
 # `parse_argv` is the ENTRY's own concern, so it is loaded from work.py by path
 # rather than re-homed into a module just to make a test tidier.
@@ -7021,6 +7022,272 @@ def test_asking_where_the_gates_stand_never_commits_the_board():
             config.apply(config.DEFAULTS)
 
 
+# --- where the work stands, at the end of a turn ------------------------------
+# The stop judge answered one question — is this session nearly full — and a
+# session that finished early was told nothing, so the founder asked instead, at
+# the end of nearly every session. Measured on this machine before it was
+# changed: 18 of the last 32 sessions in this repo crossed the threshold and were
+# reminded, 14 ended under it and heard nothing, six of those within 60k tokens
+# of the line. What they asked for is not the leftovers count but the bottom
+# line — "doesn't really say what's actually completed or not and where are we
+# standing" — so every case below asserts a DERIVED fact and none of them
+# asserts prose.
+
+
+def _stop_repo(tmp, bucket="queue", criteria="- [x] the first thing\n- [ ] the second thing\n"):
+    """A git-mode repo with one cut, one epic and one item in `bucket`."""
+    repo = _git_repo(tmp, push=False)
+    e = repo / "work" / "versions" / "01-a-cut" / "an-epic"
+    (e / bucket / "alpha").mkdir(parents=True)
+    (e / "epic.md").write_text("---\ntype: epic\n---\n\n# E\n")
+    (e.parent / "version.md").write_text(
+        "---\ncreated: 2026-08-01\norder: 1\noutcome: x\n---\n\n# Cut\n")
+    (e / bucket / "alpha" / "task.md").write_text(
+        "---\npriority: P0\n---\n\n# Alpha\n\n## Acceptance criteria\n\n" + criteria)
+    _git(repo, "add", "-A")
+    _git(repo, "commit", "-qm", "the board so far")
+    return repo
+
+
+def _stop_cfg(**wrap):
+    cfg = copy.deepcopy(config.DEFAULTS)
+    cfg["wrap"].update(wrap)
+    cfg["git"] = {"commit": True, "push": False, "remote": "origin", "paths": ["work"]}
+    return cfg
+
+
+def _remind(repo, cfg, session=None, used=0) -> dict:
+    """What the stop judge printed, parsed — or None when it said nothing at all."""
+    args = {}
+    if session:
+        args["session"] = session
+    if used:
+        args["used"] = used
+    with _work_dir(str(repo / "work")):
+        out = _capture_stdout(lambda: config.cmd_remind(cfg, args, repo))
+    return json.loads(out) if out.strip() else None
+
+
+def _moved_by(repo, name, to, session, folder_from=None, folder_to=None):
+    """Land a real board commit for a move, trailered with `session`.
+
+    The trailer is what says WHOSE move it was, so the id has to arrive the way the
+    seam reads it — off the environment — rather than as an argument no caller
+    passes.
+    """
+    keep = os.environ.get("CLAUDE_CODE_SESSION_ID")
+    instance = os.environ.pop("WORK_INSTANCE", None)
+    os.environ["CLAUDE_CODE_SESSION_ID"] = session
+    try:
+        if folder_from and folder_to:
+            folder_to.parent.mkdir(parents=True, exist_ok=True)
+            shutil.move(str(folder_from), str(folder_to))
+        _board_write(repo, name, [{"event": "moved", "name": name, "to": to}])
+    finally:
+        if keep is None:
+            os.environ.pop("CLAUDE_CODE_SESSION_ID", None)
+        else:
+            os.environ["CLAUDE_CODE_SESSION_ID"] = keep
+        if instance is not None:
+            os.environ["WORK_INSTANCE"] = instance
+
+
+def test_the_line_says_where_the_item_this_session_took_actually_stands():
+    # The bottom line, derived: which item, which bucket, and how much of it is
+    # actually done. A session's own summary is the thing that cannot answer this
+    # — it is written by the same run whose progress is in question.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            e = repo / "work" / "versions" / "01-a-cut" / "an-epic"
+            _moved_by(repo, "alpha", "in-progress", "sid-mine",
+                      folder_from=e / "queue" / "alpha",
+                      folder_to=e / "in-progress" / "alpha")
+            said = _remind(repo, _stop_cfg(), session="sid-mine")
+            assert said, "an item taken here and unfinished must be said"
+            assert "alpha" in said["headline"]
+            assert "in-progress" in said["headline"]
+            assert "1/2 criteria" in said["headline"], said["headline"]
+            # Nothing has earned resuming the run: delivering a note continues the
+            # conversation, so an unfinished item is the person's to read, not a
+            # reason to set the session working again.
+            assert "note" not in said, said
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_an_item_another_session_took_is_never_called_yours():
+    # The one lie that would make the whole line ignorable. An item's `sessions:`
+    # list names every run that ever touched it — including one that only wrote its
+    # brief — so the moved TRAILER is read instead, which names the run that put it
+    # in the bucket it is in.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            e = repo / "work" / "versions" / "01-a-cut" / "an-epic"
+            _moved_by(repo, "alpha", "in-progress", "sid-somebody-else",
+                      folder_from=e / "queue" / "alpha",
+                      folder_to=e / "in-progress" / "alpha")
+            said = _remind(repo, _stop_cfg(), session="sid-mine")
+            assert not said or "alpha" not in said["headline"], said
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_code_left_out_of_git_is_named_with_no_measurement_at_all():
+    # Whatever the context level, including none: the usage number used to be the
+    # only question asked, so a client that could not read its own transcript got
+    # silence — while the sharpest thing a machine can say needs no measurement.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            (repo / "src").mkdir()
+            (repo / "src" / "shipped.ts").write_text("export const it = 1;\n")
+            said = _remind(repo, _stop_cfg(), session="sid-mine", used=0)
+            assert said, "uncommitted code is knowable with no measurement"
+            assert "NOT IN GIT" in said["headline"]
+            assert "src/shipped.ts" in said["headline"]
+            assert "note" not in said, "the person reads this; the run is not resumed"
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_a_cut_with_every_task_complete_says_it_is_finishable():
+    # `planned` is what a finished cut reads as, because status is derived from
+    # tasks in flight and there are none. Whoever is standing there at the end of a
+    # turn is the person who can close it.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp, bucket="complete")
+            said = _remind(repo, _stop_cfg(), session="sid-mine")
+            assert said, "a finishable cut must be said"
+            assert "01-a-cut" in said["headline"]
+            assert "not released" in said["headline"], said["headline"]
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_a_session_that_left_nothing_behind_is_told_nothing():
+    # Silence has to keep meaning clean. A line that also appears when there is
+    # nothing to say is one nobody can read anything out of.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            assert _remind(repo, _stop_cfg(), session="sid-mine", used=1000) is None
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_finishing_the_work_wraps_the_session_early_and_only_once():
+    # The gap the measurement found: a session that finishes with room to spare
+    # crosses no threshold, so it was never asked to close itself out. Completing
+    # what it took is the one end-of-work signal that is certain rather than
+    # guessed at — and it is spent after one turn, because delivering a note
+    # resumes the run.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            e = _provable_task(repo)
+            old, gate.VERIFY = gate.VERIFY, {"tests": "true"}
+            try:
+                with _work_dir(str(repo / "work")):
+                    assert gate.cmd_verify({"task": "alpha"}) == 0
+                _moved_by(repo, "alpha", "complete", "sid-mine",
+                          folder_from=e / "in-progress" / "alpha",
+                          folder_to=e / "complete" / "alpha")
+                said = _remind(repo, _stop_cfg(), session="sid-mine", used=1000)
+                assert said, "finishing the work must reach the session"
+                assert "note" in said, said
+                assert "complete" in said["note"]
+                assert "Context is" not in said["note"], \
+                    "this is the end of the work, not the end of the room"
+                assert "alpha — complete" in said["headline"], said["headline"]
+
+                again = _remind(repo, _stop_cfg(), session="sid-mine", used=1000)
+                assert again and "note" not in again, \
+                    "a note every turn is a session that never gets to stop"
+                assert "alpha — complete" in again["headline"], \
+                    "the fact holds, so the person keeps being able to read it"
+            finally:
+                gate.VERIFY = old
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_running_out_of_room_and_finishing_the_work_do_not_sound_the_same():
+    # Two triggers, one message, and a reader who has to know which one fired:
+    # "you are running out of room" and "the work you took is done" call for
+    # different next moves.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            cfg = _stop_cfg(at_percent=50, context_tokens=1000,
+                            command="/wrap-it-up")
+            said = _remind(repo, cfg, session="sid-full", used=800)
+            assert said and "note" in said
+            assert "80% of context used" in said["headline"]
+            assert "Context is 80% full" in said["note"]
+            assert "/wrap-it-up" in said["headline"]
+
+            # Spent, and the headline still says it — the window keeps filling, and
+            # somebody who saw 50% once and nothing at 80% was told less as it got
+            # worse.
+            again = _remind(repo, cfg, session="sid-full", used=900)
+            assert again and "note" not in again
+            assert "90% of context used" in again["headline"]
+
+            # Below the line it says nothing about room at all.
+            quiet = _remind(repo, cfg, session="sid-roomy", used=100)
+            assert quiet is None, quiet
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_the_harness_own_scratch_is_never_somebody_elses_unsaved_work():
+    # Four docstrings in this harness call `.work/` gitignored on purpose and
+    # nothing made it so. In a repo that had not added the line by hand, the
+    # harness reported its OWN session markers and coverage shards as a person's
+    # uncommitted work — and then refused every completion, because a verify run
+    # drops a shard and the completion gate reads this same list.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            (repo / ".work" / "coverage").mkdir(parents=True)
+            (repo / ".work" / "coverage" / "vitest-w-s.json").write_text("{}\n")
+            assert git.uncommitted_code(repo) == [], git.uncommitted_code(repo)
+
+            # Derived from where shards are configured to land, never a spelling of
+            # its own: a repo that moves them moves what counts as scratch.
+            config.apply({**_stop_cfg(), "coverage": {"shard": "tmp/evidence/shards"}})
+            assert git.uncommitted_code(repo) == [".work/coverage/vitest-w-s.json"]
+        finally:
+            config.apply(config.DEFAULTS)
+
+
+def test_the_stop_hook_being_switched_off_silences_the_standing_too():
+    # One switch for the whole hook, and it has to cover what was added to it —
+    # a repo that switched this off would otherwise find half of it back.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _stop_repo(tmp)
+            (repo / "src").mkdir()
+            (repo / "src" / "shipped.ts").write_text("export const it = 1;\n")
+            cfg = _stop_cfg()
+            cfg["hooks"]["stop"] = {"enabled": False, "extend": []}
+            assert _remind(repo, cfg, session="sid-mine", used=999999) is None
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+
 if __name__ == "__main__":
     tests = [v for k, v in sorted(globals().items())
              if k.startswith("test_") and callable(v)]

package/harness/work.py

@@ -64,9 +64,10 @@ Subcommands:
     config set <key> <value> [--json]      write one dotted key, validated first
     config unset <key>                     drop an override, back to the default
     context [--project <dir>]      the SessionStart pointers, all config-derived
-    remind --used <tokens> [--session <id>]   wrap up yet? one JSON object, or
-                                   nothing. Takes a MEASUREMENT: how full a
-                                   session is, is its client's to answer
+    remind [--used <tokens>] [--session <id>]  where the work stands, and whether
+                                   to wrap up. One JSON object, or nothing. The
+                                   measurement is OPTIONAL and is its client's to
+                                   answer; the tree and git need none
     applies --file <path> [--session <id>]    what a session must be told now that
                                    it is about to write this file — the judgements
                                    no gate catches, and which system it is in

package/package.json

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