@appchy/jarvis 0.1.95 → 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 = "20f7aad";
+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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.95",
+  "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"
   },