@appchy/jarvis 0.1.94 → 0.1.96

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 = "7b77d4e";
+var SHA = "db0cbed";
 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

@@ -1385,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/epic.py

@@ -212,13 +212,81 @@ def cmd_epic_move(args) -> int:
           f"with {len(moved)} task(s)")
     _sync(root)
     return 0
+#: Headings whose content is a STATEMENT ABOUT THE WORLD rather than a plan for one
+#: piece of work — the parts of an epic that can outlive it, and therefore the parts
+#: worth naming before they are deleted. Slice ordering, as-found and running logs are
+#: deliberately absent: those are supposed to die with the epic.
+_DURABLE_SECTIONS = ("## Governance this implies", "## Non-goals", "### Settled",
+                     "### Forward-compat")
+
+
+def _cost_of_removing(version, root) -> list:
+    """What this release is about to delete, as lines a person can act on.
+
+    **Said BEFORE the unlink, because the advice that follows a release is useless
+    after it.** `release` has always printed _"promote still-load-bearing decisions
+    to the domain that owns them"_ — and printed it after the files holding those
+    decisions had already left the tree. Measured 2026-09-11 on `01-one-board`: twelve
+    plans, 450,405 bytes, about a hundred durable statements with no owner file, and
+    the recovery commit had to be worked out by hand afterwards from `git log
+    --diff-filter=D`.
+
+    So this names the size, the sections that can outlive the plan, and the commit
+    where the text still lives. It does not judge whether a statement is durable —
+    that is the judgement a lint cannot make, and claiming it would be worse than
+    saying nothing.
+    """
+    plans = [e for e in version.epics if e.planned]
+    if not plans:
+        return []
+    out, total = [], 0
+    for e in plans:
+        try:
+            text = e.md.read_text()
+        except OSError:                               # pragma: no cover — defensive
+            continue
+        total += len(text.encode())
+        held = [h.split("## ")[-1].split("### ")[-1]
+                for h in _DURABLE_SECTIONS if h in text]
+        note = f" — holds §{', §'.join(held)}" if held else ""
+        out.append(f"          {e.name}  {len(text.encode()):,} bytes{note}")
+    head = _still_holds(root)
+    return ([f"\n        DELETING {len(plans)} epic plan(s), {total:,} bytes. Anything "
+             f"durable in them must already be in the file that owns it — after this "
+             f"they are in git only, and nobody reads git for a decision:"]
+            + out
+            + ([f"          the text stays recoverable at {head}"] if head else [])
+            + ["          `git show <commit>:<path>` — and `jarvis work align` reports "
+               "what cites a file that is gone"])
+
+
+def _still_holds(root) -> str:
+    """The commit whose tree still contains these plans, or empty when git cannot say.
+
+    HEAD is the right answer, and it is worth being precise about why: the unlink has
+    not happened yet and the board write commits after it, so at the moment this
+    prints, the newest commit in the history is one that still holds every file about
+    to go. Through the same seam every other git question goes through — a second way
+    of asking would eventually give a second answer.
+    """
+    from . import git
+    code, out, _ = git._git(root.parent, "rev-parse", "--short", "HEAD")
+    return out.strip() if code == 0 else ""
+
+
 def cmd_epic_release(root, version) -> int:
     """Remove every `epic.md` in a released version, and report it.
 
     An epic is TEMPORARY by definition: it is the plan-it-together doc, and how
     the work was planned stops being true the moment it ships. The folder stays
     as the grouping of what shipped — that record is worth keeping — and git
-    holds the plan. Called from `cmd_release`, never on its own."""
+    holds the plan. Called from `cmd_release`, never on its own.
+
+    It says what it is deleting FIRST. The cost of a release is not the stamp, it is
+    the plans that go with it, and a person deciding needs that in front of them
+    while the files still exist."""
+    for line in _cost_of_removing(version, root):
+        print(line)
     removed = []
     for e in version.epics:
         # An epic with no plan doc is already in the shape this produces — a folder

package/harness/harness/version.py

@@ -198,7 +198,12 @@ def cmd_release(args) -> int:
     # how the work was planned stops being true once it ships.
     cmd_epic_release(root, version)
     print("\nDistill before archiving:")
-    print("  1. Promote still-load-bearing decisions to the domain or system that owns them")
+    # Points at the commit the deletion just named, because this instruction used to
+    # send a reader to files the same command had already removed — and the one time
+    # it mattered, the recovery commit had to be reconstructed afterwards with
+    # `git log --diff-filter=D`.
+    print("  1. Promote still-load-bearing decisions to the domain or system that owns "
+          "them — read them from the commit named above; they are no longer in the tree")
     print(f"  2. Repoint any inbound deep-links to those {ids.LEDGER}-nn entries")
     print(f"  3. {cli()} archive {name}   (strips each task to task.md, and "
           f"files a RELEASED cut under versions/complete/)")

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

@@ -7288,6 +7288,81 @@ def test_the_stop_hook_being_switched_off_silences_the_standing_too():
 
 
 
+def test_a_release_says_what_it_is_deleting_before_it_deletes_it():
+    # `release` has always printed "promote still-load-bearing decisions to the
+    # domain that owns them" — AFTER unlinking the files holding those decisions.
+    # Measured on 01-one-board: twelve plans, 450,405 bytes, about a hundred durable
+    # statements with no owner file, and the recovery commit reconstructed afterwards
+    # by hand with `git log --diff-filter=D`. The cost of a release is the plans that
+    # go with it, so it is named while they still exist.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            v = repo / "work" / "versions" / "09-a-cut"
+            (v / "an-epic" / "complete" / "only-task").mkdir(parents=True)
+            (v / "version.md").write_text(
+                "---\ncreated: 2026-09-01\norder: 9\noutcome: a user can do it\n"
+                "---\n\n# A cut\n")
+            (v / "an-epic" / "epic.md").write_text(
+                "---\ntype: epic\nowner: quality\n---\n\n# An epic\n\n## Plan\n\n"
+                "Slice ordering, which is supposed to die with this file.\n\n"
+                "## Governance this implies\n\n- quality/README.md — a rule is owed\n")
+            (v / "an-epic" / "complete" / "only-task" / "task.md").write_text(
+                "---\npriority: P0\ncompleted: 2026-09-02\n---\n\n# Only task\n\n"
+                "## Acceptance criteria\n\n- [x] it works\n")
+            _git(repo, "add", "-A")
+            _git(repo, "commit", "-qm", "the board")
+            head = _git(repo, "rev-parse", "--short", "HEAD").stdout.strip()
+
+            with _work_dir(str(repo / "work")):
+                said = _capture_stdout(lambda: version.cmd_release({"name": "09-a-cut"}))
+
+            # The cost, in front of the person, in units they can weigh.
+            assert "DELETING 1 epic plan(s)" in said, said
+            assert "bytes" in said
+            # WHICH sections can outlive the plan — and not the ones that cannot.
+            assert "§Governance this implies" in said, said
+            assert "§Plan" not in said, "slice ordering is supposed to die with the epic"
+            # Where it went, named at the moment it goes rather than reconstructed later.
+            assert head and head in said, f"expected the recovery commit {head}: {said}"
+
+            # And the claim is true: the plan is out of the tree and in that commit.
+            assert not (v / "an-epic" / "epic.md").exists()
+            kept = _git(repo, "show", f"{head}:work/versions/09-a-cut/an-epic/epic.md")
+            assert "a rule is owed" in kept.stdout, kept.stderr
+
+            # The instruction that follows no longer sends a reader to a deleted file.
+            assert "no longer in the tree" in said, said
+        finally:
+            events._PENDING.clear()
+            config.apply(config.DEFAULTS)
+
+
+def test_a_release_with_no_plans_left_says_nothing_about_deleting_any():
+    # Silence where there is no cost. An epic with no plan doc is already in the
+    # shape release produces, and announcing a deletion of nothing would train the
+    # reader to skip the announcement that matters.
+    with tempfile.TemporaryDirectory() as tmp:
+        try:
+            repo = _git_repo(tmp, push=False)
+            v = repo / "work" / "versions" / "09-a-cut"
+            (v / "an-epic" / "complete" / "only-task").mkdir(parents=True)
+            (v / "version.md").write_text(
+                "---\ncreated: 2026-09-01\norder: 9\noutcome: a user can do it\n"
+                "---\n\n# A cut\n")
+            (v / "an-epic" / "complete" / "only-task" / "task.md").write_text(
+                "---\npriority: P0\ncompleted: 2026-09-02\n---\n\n# Only task\n\n"
+                "## Acceptance criteria\n\n- [x] it works\n")
+            _git(repo, "add", "-A")
+            _git(repo, "commit", "-qm", "the board")
+            with _work_dir(str(repo / "work")):
+                said = _capture_stdout(lambda: version.cmd_release({"name": "09-a-cut"}))
+            assert "DELETING" not in said, said
+        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.94",
+  "version": "0.1.96",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -58,13 +58,13 @@
     "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/data": "0.1.0",
     "@jarvis/ui": "0.1.0",
     "@jarvis/vitest-config": "1.0.0"
   },