@appchy/jarvis 0.1.73 → 0.1.75

package/harness/harness/align.py

@@ -17,6 +17,10 @@ from .lint import _feature_ac_ids, feature_ac_levels
 #: exists to remove.
 FOREIGN_REPOS: tuple = ()
 
+#: This repo's own standards file, relative to the repo root. Set from config
+#: (`spine.standards`); empty when a repo keeps no second ledger.
+STANDARDS: str = ""
+
 #: Directories under `work/` that are NOT durable governance. `product/` and
 #: `architecture/` are handled on their own (they are the two sides the
 #: single-feature check compares); the rest here hold work-in-flight or history,
@@ -156,6 +160,29 @@ def _foreign_qualifier() -> re.Pattern:
         return re.compile(r"(?!)")
     alt = "|".join(re.escape(r) for r in FOREIGN_REPOS)
     return re.compile(rf"(?:{alt})\s*[:=]?\s*[`*\[(\"']{{0,3}}$", re.IGNORECASE)
+def _standards_ids(root: Path) -> set:
+    """Ids this repo declares in its standards file, which does not live under `work/`.
+
+    Without this the check walked the board alone and reported every one of them as
+    resolving to nothing: twenty in this repo, twelve in a sibling, all false, all
+    cited by live briefs that were reading the rules correctly. They resolve
+    perfectly — they are declared at the repo root, in the file the config already
+    names.
+
+    Twenty false errors on top of three real warnings is worse than a wrong number:
+    it is how somebody learns the report is noise and stops reading the part that
+    was telling them something.
+
+    `doctor`'s id check reaches for the same pointer, so the two cannot disagree
+    about what counts as declared here.
+    """
+    from . import config  # deferred — `config.apply` imports this module
+    if not STANDARDS:
+        return set()
+    named = config.standards_index({"spine": {"standards": STANDARDS}}, root.parent)
+    return {ids.normalise(i) for i, _ in named}
+
+
 def _align_citations(root: Path) -> list:
     """A cited id that resolves to nothing."""
     out = []
@@ -165,6 +192,7 @@ def _align_citations(root: Path) -> list:
     defined = set(definition_sites(root))
     for _, _, rules, _ in hosts(root):
         defined |= set(rules)
+    defined |= _standards_ids(root)
     foreign = _foreign_qualifier()
     dangling: dict = {}
     for p in live_surfaces(root):

package/harness/harness/config.py

@@ -623,6 +623,7 @@ def apply(cfg: dict) -> None:
     kickoff.SPINE = [s for s in ([cfg["spine"]["standards"]] if cfg["spine"]["standards"]
                                  else []) + list(cfg["spine"]["conventions"]) if s]
     align.FOREIGN_REPOS = tuple(cfg["ids"]["foreign"])
+    align.STANDARDS = cfg["spine"]["standards"] or ""
     registry.DOMAIN_ORDER = tuple(cfg["domains"]["order"])
     # From the SHIPPED set each time, never from whatever the last `apply` left
     # behind. Unioning into the live value made a second call in one process keep the

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

@@ -284,6 +284,29 @@ def test_a_doc_narrating_a_retirement_is_not_a_dangling_citation():
         assert not [f for f in align._align_citations(root) if f[1] == "dangling-citation"]
 
 
+def test_a_standard_declared_at_the_repo_root_is_not_a_dangling_citation():
+    # `align` walked `work/` alone, so every id declared in the standards file at
+    # the repo ROOT read as resolving to nothing — twenty here, twelve in a
+    # sibling, all false and all cited by briefs that were reading the rules
+    # correctly. Twenty false errors on three real warnings is how somebody
+    # learns the report is noise.
+    with tempfile.TemporaryDirectory() as tmp:
+        root = _citing_repo(tmp, "Written to `S-1`, and also `S-9`.\n")
+        (Path(tmp) / "STANDARDS.md").write_text(
+            "# Standards\n\n## S-1. Function signatures\n\ntext\n")
+        ids.configure("D", ("S",))
+        align.STANDARDS = "STANDARDS.md"
+        try:
+            found = [m for sev, c, m in align._align_citations(root)
+                     if c == "dangling-citation"]
+        finally:
+            align.STANDARDS = ""
+        assert not any("S-1" in m for m in found), found
+        # And the guard: a standards-shaped id the file does not declare is still
+        # reported, or this would be an amnesty rather than a lookup.
+        assert any("S-9" in m for m in found), found
+
+
 def test_a_real_dangling_id_still_reports_in_a_file_that_retires_another():
     # The guard on the check above: file-scoped narration must not become a
     # blanket amnesty for every id the document happens to mention.
@@ -5482,6 +5505,30 @@ def test_an_epic_move_snapshots_the_repo_once_not_once_per_task():
         assert len(calls) == 1, f"scanned the repo {len(calls)} times for 3 tasks"
 
 
+def test_the_config_is_found_from_a_subdirectory_of_the_repo():
+    # The tree search walks up for a `work/`; the config search stopped at the cwd.
+    # So standing one directory inside a repo found no config and every check ran
+    # in the shipped dialect against the right tree — `align` from the root
+    # reported twenty citations and from `apps/cli/` reported thirteen entirely
+    # different ones. One tree, two answers, decided by where you stood.
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = Path(tmp) / "repo"
+        (repo / "work" / "versions").mkdir(parents=True)
+        deep = repo / "src" / "deep"
+        deep.mkdir(parents=True)
+
+        was = Path.cwd()
+        env = {k: os.environ.pop(k) for k in ("CLAUDE_PROJECT_DIR", "WORK_DIR")
+               if k in os.environ}
+        os.chdir(deep)
+        try:
+            assert entry._project_root({}) == repo.resolve(), \
+                "the config search stopped at the cwd instead of finding the repo"
+        finally:
+            os.chdir(was)
+            os.environ.update(env)
+
+
 def _migrate(tmp: str, **flags):
     """`migrate` against a fixture, with WORK_DIR pointing at it."""
     from harness import migrate as migrate_mod
@@ -5520,6 +5567,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/harness/work.py

@@ -193,7 +193,16 @@ def parse_argv(argv):
 def _project_root(flags) -> Path:
     """The repo the harness is acting on. `--project` wins, then the env, then the
     cwd — the same precedence `find_work_root` uses, so config and tree can never
-    disagree about which repo this is."""
+    disagree about which repo this is.
+
+    The last step WALKS UP, and that is the half this claimed and did not do. The
+    tree search walks up for a `work/`; this stopped at the cwd, so standing one
+    directory into a repo found no config and every check ran in the shipped
+    dialect against the right tree. Measured here: `align` from the root reported
+    twenty citations, and from `apps/cli/` reported thirteen entirely different
+    ones, having stopped recognising this repo's own ids altogether. One tree, two
+    answers, decided by where the caller happened to be standing.
+    """
     import os
     p = flags.get("project") or os.environ.get("CLAUDE_PROJECT_DIR")
     if p:
@@ -201,7 +210,8 @@ def _project_root(flags) -> Path:
     wd = os.environ.get("WORK_DIR")
     if wd:
         return Path(wd).resolve().parent
-    return Path.cwd().resolve()
+    root, _, cur = locate_work_root()
+    return root.parent if root else cur
 
 
 def main() -> int:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "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/board": "0.1.0",
+    "@jarvis/anthropic": "1.0.0",
     "@jarvis/data": "0.1.0",
+    "@jarvis/board": "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/typescript-config": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",