@appchy/jarvis 0.1.70 → 0.1.72

package/harness/harness/links.py

@@ -94,7 +94,10 @@ def repair(before: dict, moves: dict) -> tuple:
             continue
 
         text = original = now.read_text(errors="ignore")
-        for href, target, existed in links:
+        # One entry per distinct link: a href repeated in a file is rewritten
+        # everywhere by the first replace, and counting the rest as failures
+        # reports a repair that worked as one that did not.
+        for href, target, existed in dict.fromkeys(links):
             if not existed:
                 continue
             want = _after(target, moves)

package/harness/harness/model.py

@@ -310,11 +310,11 @@ def locate(root: Path, name: str):
             return t
     return None
 def locate_version(root: Path, name: str):
-    """Find a version by name. Looks in `archive/versions/` too, so a released
+    """Find a version by name. Looks in `versions/archive/` too, so a finished
     cut stays LOOKUPABLE after it leaves the board — `path` and `where` keep
     answering, while `scan` (and therefore `list`, the README and every lint)
     sees only live work. Archived is off the board, not gone."""
-    for base in ("versions", "archive/versions"):
+    for base in ("versions", "versions/archive"):
         folder = root / base / name
         if (folder / "version.md").is_file():
             return Version(folder)

package/harness/harness/task.py

@@ -334,7 +334,19 @@ def cmd_move(args) -> int:
     if dest.exists():
         die(f"{rel(dest, root)} already exists")
     dest.parent.mkdir(parents=True, exist_ok=True)
+
+    # The bucket is part of every path that names this task, so a status change
+    # moves the folder and breaks whatever pointed at it — and `move` fires on every
+    # pickup and every completion, far more often than `place`. One audited board
+    # had 16 of its 37 broken links from a bucket change alone.
+    before = links.snapshot(root.parent)
+    moved_from = task.folder.resolve()
     shutil.move(str(task.folder), str(dest))
+    repaired, unresolved = links.repair(before, {moved_from: dest.resolve()})
+    if repaired:
+        print(f"  repaired {repaired} link(s) that pointed at it")
+    for line in unresolved:
+        print(f"  COULD NOT PLACE  {line}")
 
     def mutate(d):
         d["updated"] = date.today().isoformat()

package/harness/harness/version.py

@@ -5,13 +5,13 @@ from datetime import date
 from pathlib import Path
 
 from . import ids
-from .tree import DONE_TIER, VERSION_FM_ORDER, cli, die, find_work_root, rel
+from .tree import archive_dir, DONE_TIER, VERSION_FM_ORDER, cli, die, find_work_root, rel
 from .frontmatter import rewrite_file
 from .model import _is_epic_dir, locate_version, scan
 from .scaffold import _check_unused, _check_version_name, _scaffold_version
 from .epic import cmd_epic_release
 from .generate import _sync
-from . import events
+from . import events, links
 
 
 def cmd_version_new(args) -> int:
@@ -231,8 +231,17 @@ def cmd_archive(args) -> int:
     version = locate_version(root, name)
     if not version:
         die(f"no version named '{name}'")
-    if not version.released:
-        die(f"version '{name}' is not released — release it before archiving")
+    # A cut whose work all moved elsewhere has nothing left to deliver and no
+    # outcome it honestly met, so releasing it would be a lie — and until now
+    # archiving it was refused, which left it in the live list looking open. One
+    # repo had two such cuts holding 87 completed tasks between them. What is
+    # actually being asked is whether anything is still owed, so ask that.
+    open_work = [t for t in version.all_tasks() if t.status != "complete"]
+    if not version.released and open_work:
+        die(f"version '{name}' is not released and still holds "
+            f"{len(open_work)} unfinished task(s) — release it, or move that work "
+            f"somewhere it can be finished. A cut leaves the board when nothing is "
+            f"owed on it, not when somebody stops looking at it.")
     if version.fm.get("archived"):
         die(f"version '{name}' is already archived ({version.fm['archived']})")
 
@@ -267,7 +276,7 @@ def cmd_archive(args) -> int:
             removed += 1
 
     if dry:
-        dest = root / "archive" / "versions" / name
+        dest = archive_dir(root) / name
         print(f"  stamp   archived: on {rel(version.md, root)}")
         print(f"  move    {rel(version.folder, root)} -> {rel(dest, root)}")
         print(f"\n  {removed} file(s)/dir(s) would be stripped. "
@@ -291,11 +300,18 @@ def cmd_archive(args) -> int:
     # past 60 completed tasks to find the 6 that were actually moving. The
     # record is preserved verbatim in `archive/versions/<v>/`, where `path` and
     # `where` still resolve it — it is just no longer in the way.
-    dest = _contained(root / "archive" / "versions" / name, root)
+    dest = _contained(archive_dir(root) / name, root)
     if dest.exists():
         die(f"{rel(dest, root)} already exists")
     dest.parent.mkdir(parents=True, exist_ok=True)
+    before = links.snapshot(root.parent)
+    moved_from = version.folder.resolve()
     shutil.move(str(_contained(version.folder, root)), str(dest))
+    repaired, unresolved = links.repair(before, {moved_from: dest.resolve()})
+    if repaired:
+        print(f"        repaired {repaired} link(s) that pointed into it")
+    for line in unresolved:
+        print(f"        COULD NOT PLACE  {line}")
 
     where = f" — full docs in git history @ {sha}" if sha else ""
     events.append(root, "archived", name, stripped=removed)

package/harness/test_work.py

@@ -953,7 +953,7 @@ def test_archive_moves_the_version_off_the_board_but_keeps_it_lookupable():
             os.environ.pop("WORK_DIR")
 
         assert not (root / "versions" / "26-cut").exists()
-        dest = root / "archive" / "versions" / "26-cut"
+        dest = root / "versions" / "archive" / "26-cut"
         assert (dest / "version.md").is_file()
         # stripped to task.md, and the epic grouping survives the move
         assert (dest / "an-epic" / "complete" / "shipped-thing" / "task.md").is_file()
@@ -1778,6 +1778,45 @@ def test_doctor_passes_a_degraded_but_legal_install_and_fails_a_real_break():
         assert f"{tree.cli()} init" in out.getvalue()
 
 
+def test_a_finished_cut_leaves_the_board_without_pretending_it_shipped():
+    # A cut whose work all moved elsewhere met no outcome, so releasing it is a lie
+    # — and archiving used to be refused without a release, which left it in the
+    # live list looking open. One repo had two such cuts holding 87 done tasks.
+    import io, contextlib, os
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp, name="01-spent")
+        root = Path(tmp)
+        e = _epic(v, "an-epic")
+        (e / "complete").mkdir()
+        _task(e / "complete", "shipped-this")
+
+        os.environ["WORK_DIR"] = tmp
+        try:
+            with contextlib.redirect_stdout(io.StringIO()):
+                assert version.cmd_archive({"name": "01-spent"}) == 0
+            assert (root / "versions" / "archive" / "01-spent").is_dir(), \
+                "archive lives inside versions/, beside the cuts"
+            assert not (root / "versions" / "01-spent").exists()
+
+            # Still owed work is the thing that actually blocks it, not the absence
+            # of a release stamp.
+            v2 = root / "versions" / "02-busy"
+            v2.mkdir()
+            (v2 / "version.md").write_text(
+                "---\ncreated: 2026-08-01\norder: 02\noutcome: b\n---\n\n# 02-busy\n")
+            e2 = _epic(v2, "another-epic")
+            (e2 / "queue").mkdir()
+            _task(e2 / "queue", "still-owed")
+            with contextlib.redirect_stdout(io.StringIO()):
+                try:
+                    version.cmd_archive({"name": "02-busy"})
+                    raise AssertionError("archived a cut that still owes work")
+                except SystemExit:
+                    pass
+        finally:
+            os.environ.pop("WORK_DIR", None)
+
+
 def test_links_are_repaired_by_what_they_pointed_at_not_by_what_they_say():
     from harness import links
     with tempfile.TemporaryDirectory() as tmp:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.70",
+  "version": "0.1.72",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -57,16 +57,16 @@
     "typescript": "^5.7.0",
     "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/logger": "1.0.0",
     "@jarvis/rpc": "1.0.0",
-    "@jarvis/board": "0.1.0",
     "@jarvis/typescript-config": "1.0.0",
-    "@jarvis/types": "1.0.0",
     "@jarvis/ui": "0.1.0",
-    "@jarvis/vitest-config": "1.0.0"
+    "@jarvis/vitest-config": "1.0.0",
+    "@jarvis/anthropic": "1.0.0",
+    "@jarvis/types": "1.0.0",
+    "@jarvis/errors": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",