@appchy/jarvis 0.1.73 → 0.1.74

package/dist/bin.js

@@ -10109,7 +10109,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 = "9e5b550";
+var SHA = "9566241";
 var BUILT = "2026-09-10";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = `${SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`}${IS_DEV ? " \u2014 development build" : ""}`;

package/harness/harness/migrate.py

@@ -51,11 +51,26 @@ def _uncommitted(repo: Path, work: Path) -> list:
     return sorted(dirty)
 
 
+def _archived_cuts(root: Path) -> list:
+    """Cuts sitting in the archive's former home, `work/archive/versions/<cut>/`.
+
+    Every repo that ever archived a cut has these, and the layout change made them
+    UNREACHABLE: `locate_version` looks in `versions/` and `versions/archive/`, so
+    `path` and `where` answer "no version named that" for a record the repo still
+    holds. jarvis had archived nothing, which is why the first migration never met
+    this and three siblings each have seven to eleven of them.
+    """
+    old = root / "archive" / "versions"
+    if not old.is_dir():
+        return []
+    return sorted(p for p in old.iterdir() if (p / "version.md").is_file())
+
+
 def cmd_migrate(args) -> int:
-    """`work/backlog/` moves inside `versions/`, and `versions/archive/` is made.
+    """`work/backlog/` and the archive both move inside `versions/`.
 
-    Both halves of one layout: backlog and archive are states a cut's work is in,
-    so they belong beside the cuts rather than in a directory of their own.
+    One layout: backlog and archive are states a cut's work is in, so they belong
+    beside the cuts rather than in directories of their own.
     """
     root = find_work_root()
     repo = root.parent
@@ -64,18 +79,26 @@ def cmd_migrate(args) -> int:
     old = root / "backlog"
     new = backlog_dir(root)
     archive = archive_dir(root)
+    cuts = _archived_cuts(root)
 
-    # The one hard refusal. Both present means somebody has already started this,
-    # or a repo has grown a second backlog — and merging two trees is a judgement
-    # about which copy of a task is real, which is not a call a migration makes.
+    # The hard refusals. Two of anything means somebody has already started this,
+    # or a repo has grown a second copy — and merging two trees is a judgement
+    # about which copy is real, which is not a call a migration makes.
     if old.is_dir() and new.is_dir():
         die(f"both {rel(old, root)} and {rel(new, root)} exist — this repo has two "
             f"backlogs and only a person can say which task is the real one. "
             f"Merge them by hand, then run this again.")
+    clashes = [c.name for c in cuts if (archive / c.name).exists()]
+    if clashes:
+        die(f"{len(clashes)} cut(s) are archived in both places: "
+            f"{', '.join(clashes)}. Which record is the real one is yours to say — "
+            f"merge them by hand, then run this again.")
 
     todo = []
     if old.is_dir():
         todo.append("the backlog moves inside versions/")
+    if cuts:
+        todo.append(f"{len(cuts)} archived cut(s) move inside versions/")
     if not archive.is_dir():
         todo.append("versions/archive/ is created")
     if not todo:
@@ -88,6 +111,8 @@ def cmd_migrate(args) -> int:
             print(f"  {line}")
         if old.is_dir():
             print(f"  {sum(1 for _ in old.rglob('task.md'))} task(s) would move")
+        for c in cuts:
+            print(f"  archived: {c.name}")
         return 0
 
     dirty = _uncommitted(repo, root)
@@ -124,6 +149,31 @@ def cmd_migrate(args) -> int:
         (archive / ".gitkeep").write_text("")
         print(f"created {rel(archive, root)}")
 
+    if cuts:
+        # One block for every cut. Each carries a whole released version's worth of
+        # documents, and the links between them are the reason this is worth doing
+        # properly rather than with a `mv`.
+        with links.repairing(repo) as moved:
+            for c in cuts:
+                moved[c.resolve()] = (archive / c.name).resolve()
+                shutil.move(str(c), str(archive / c.name))
+        print(f"moved {len(cuts)} archived cut(s) -> {rel(archive, root)}")
+
+        # What is left under the old archive is NOT the harness's. One repo keeps
+        # an `archive/backlog/` of its own there; moving it would be a guess about
+        # somebody else's records, and deleting the directory would take it with.
+        stale_home = root / "archive"
+        leftover = sorted(p.name for p in stale_home.iterdir()) if stale_home.is_dir() else []
+        leftover = [n for n in leftover if n != "versions"]
+        versions_dir = stale_home / "versions"
+        if versions_dir.is_dir() and not any(versions_dir.iterdir()):
+            versions_dir.rmdir()
+        if leftover:
+            print(f"  {rel(stale_home, root)} still holds {', '.join(leftover)} — "
+                  f"the harness does not own those, so they were left alone")
+        elif stale_home.is_dir() and not any(stale_home.iterdir()):
+            stale_home.rmdir()
+
     print("done — commit this, then every machine working this repo needs a CLI "
           "new enough to read it")
     return 0

package/harness/test_work.py

@@ -5520,6 +5520,32 @@ def test_migrate_moves_the_backlog_inside_versions_and_repairs_what_pointed_at_i
             f"a link outside work/ was left pointing at {href}"
 
 
+def test_migrate_brings_already_archived_cuts_to_where_lookups_look():
+    # The layout change moved where `archive` WRITES without moving what it had
+    # already written, and `locate_version` only reads the new place — so every
+    # cut a repo had archived answered "no version named that". jarvis had
+    # archived none, which is why this survived the first migration.
+    with tempfile.TemporaryDirectory() as tmp:
+        _tree(tmp)
+        root = Path(tmp)
+        (root / "versions" / "backlog").rmdir()
+        (root / "backlog").mkdir()
+        old = root / "archive" / "versions" / "09-shipped"
+        old.mkdir(parents=True)
+        (old / "version.md").write_text(
+            "---\ncreated: 2026-01-01\norder: 9\noutcome: x\nreleased: 2026-02-01\n"
+            "---\n\n# Shipped\n")
+        # Something the harness does not own, in the same directory.
+        (root / "archive" / "backlog" / "an-old-idea").mkdir(parents=True)
+
+        assert _migrate(tmp) == 0
+        assert (root / "versions" / "archive" / "09-shipped" / "version.md").is_file()
+        assert model.locate_version(root, "09-shipped") is not None, \
+            "an archived cut is still not lookupable after migrating"
+        assert (root / "archive" / "backlog" / "an-old-idea").is_dir(), \
+            "the migration moved records the harness does not own"
+
+
 def test_migrate_says_nothing_to_do_on_a_repo_already_migrated():
     # Nobody remembers which repos have been through it, so the safe answer to
     # running it twice has to be "nothing", not a second move or an error.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.73",
+  "version": "0.1.74",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -56,17 +56,17 @@
     "tsup": "^8.5.1",
     "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/types": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
     "@jarvis/ui": "0.1.0",
     "@jarvis/vitest-config": "1.0.0",
-    "@jarvis/anthropic": "1.0.0",
-    "@jarvis/logger": "1.0.0"
+    "@jarvis/agents": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",