@appchy/jarvis 0.1.116 → 0.1.117

package/dist/bin.js

@@ -10284,7 +10284,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 = "6a8647e";
+var SHA = "d379214";
 var BUILT = "2026-09-12";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = `${SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`}${IS_DEV ? " \u2014 development build" : ""}`;

package/harness/harness/links.py

@@ -199,13 +199,22 @@ def repairing(repo: Path, indent: str = "  "):
 _ITEM_FILES = ("task.md", "epic.md", "version.md")
 
 
-def _index(base: Path) -> dict:
+def _prose(text: str) -> str:
+    """`text` with inline code spans blanked, offsets preserved.
+
+    Blanked rather than removed so a position found here is the same position in the
+    real text — which is what lets the WRITE path edit exactly the links the READ path
+    found, and nothing else.
+    """
+    return CODE_SPAN.sub(lambda m: " " * len(m.group(0)), text)
+
+
+def _index(docs) -> dict:
     """Board item folders by name. A name with two homes is left out rather than guessed."""
     homes: dict = {}
-    for doc in base.rglob("*.md"):
-        if SKIP & set(doc.parts) or doc.name not in _ITEM_FILES:
-            continue
-        homes.setdefault(doc.parent.name, set()).add(doc.parent.resolve())
+    for doc in docs:
+        if doc.name in _ITEM_FILES:
+            homes.setdefault(doc.parent.name, set()).add(doc.parent.resolve())
     return {name: next(iter(dirs)) for name, dirs in homes.items() if len(dirs) == 1}
 
 
@@ -261,15 +270,15 @@ def dangling(base: Path) -> list:
     before-state to be repaired by identity, so it is settled from its own text or
     not at all.
     """
-    index = _index(base)
+    docs = sorted(_docs(base))
+    index = _index(docs)
     out = []
-    for doc in sorted(_docs(base)):
+    for doc in docs:
         try:
             text = doc.read_text(errors="ignore")
         except OSError:
             continue
-        text = CODE_SPAN.sub("", text)
-        for href in dict.fromkeys(m.group(1) for m in LINK.finditer(text)):
+        for href in dict.fromkeys(m.group(1) for m in LINK.finditer(_prose(text))):
             if "://" in href or href.startswith(("#", "mailto:", "/")):
                 continue
             if (doc.parent / href.split("#")[0]).exists():
@@ -281,9 +290,12 @@ def dangling(base: Path) -> list:
 def repair_dangling(base: Path, apply: bool = False) -> tuple:
     """Point every settled broken link at what it names. Returns (fixed, stuck).
 
-    Rewrites on the link's own syntax, never on the bare path, so a path that also
-    appears in a sentence is left alone — the same anchoring `repair()` uses, for the
-    same reason.
+    **Edits by position, never by `str.replace`.** The same href can appear twice in
+    one file — once as the broken link and once inside a code span quoting it, which
+    is exactly what a brief warning about the mistake looks like. A blanket replace
+    rewrites the quotation too, so the document that documents the error silently
+    stops showing it. Only the positions the read path found, which is prose, are
+    touched.
     """
     fixed, stuck = 0, []
     edits: dict = {}
@@ -296,12 +308,19 @@ def repair_dangling(base: Path, apply: bool = False) -> tuple:
         if new == href:
             stuck.append((doc, href))
             continue
-        edits.setdefault(doc, []).append((href, new))
+        edits.setdefault(doc, {})[href] = new
         fixed += 1
     if apply:
-        for doc, pairs in edits.items():
+        for doc, mapping in edits.items():
             text = doc.read_text(errors="ignore")
-            for href, new in pairs:
-                text = text.replace(f"]({href})", f"]({new})")
-            doc.write_text(text)
+            pieces, last = [], 0
+            for m in LINK.finditer(_prose(text)):
+                replacement = mapping.get(m.group(1))
+                if replacement is None:
+                    continue
+                pieces.append(text[last:m.start(1)])
+                pieces.append(replacement)
+                last = m.end(1)
+            pieces.append(text[last:])
+            doc.write_text("".join(pieces))
     return fixed, stuck

package/harness/harness/report.py

@@ -170,6 +170,14 @@ def misalignments(root: Path) -> list:
 #: `handoff.md` that `archive` stripped, is an accurate record of a world that is
 #: gone. Demanding those resolve would make the gate unsatisfiable for a reason
 #: nobody could act on.
+#:
+#: **`--fix` deliberately does not honour this, and the asymmetry is the point.** The
+#: exemption says a shipped cut cannot be REQUIRED to resolve, not that it should be
+#: left broken where it can be mended. A repair only ever moves a link onto the file
+#: it already named — `repair_dangling` refuses anything two candidates answer — so a
+#: shipped plan still points at the same document, which is what `links.repairing`
+#: does to archived docs on every folder move anyway. What survives untouched is the
+#: set that cannot be settled, which is where the record actually lives.
 _SHIPPED = ("versions/complete/", "archive/")
 
 

package/harness/test_work.py

@@ -2106,6 +2106,30 @@ def test_a_standing_broken_link_is_settled_by_depth_or_by_board_name():
         assert links.dangling(base) == []
 
 
+def test_repairing_a_link_never_touches_the_same_href_quoted_in_prose():
+    # A brief warning about a mistake quotes the wrong path in backticks AND may hold
+    # the real broken link further down. `str.replace` over the raw text rewrites the
+    # quotation too, so the document that documents the error silently stops showing
+    # it — the read path stripped code spans and the write path did not. Reproduced
+    # before it was fixed.
+    from harness import links
+    with tempfile.TemporaryDirectory() as tmp:
+        base = Path(tmp) / "work"
+        (base / "product").mkdir(parents=True)
+        (base / "product" / "board.md").write_text("# board\n")
+        doc = base / "notes" / "deep" / "doc.md"
+        doc.parent.mkdir(parents=True)
+        doc.write_text(
+            "Getting the depth wrong looks like `[board](../product/board.md)`.\n\n"
+            "A real one: [board](../product/board.md).\n")
+
+        fixed, stuck = links.repair_dangling(base, apply=True)
+        body = doc.read_text()
+        assert (fixed, stuck) == (1, [])
+        assert "`[board](../product/board.md)`" in body, "the quotation was rewritten"
+        assert "A real one: [board](../../product/board.md)." in body, body
+
+
 def test_a_broken_link_two_resolvers_disagree_about_is_left_for_a_person():
     # A link repaired to the wrong real file is worse than one that is visibly
     # broken: nothing afterwards can tell it was ever wrong.
@@ -4984,6 +5008,19 @@ def test_a_write_aimed_at_another_branch_is_refused():
         raise AssertionError("a write with --branch must be refused")
 
 
+def test_links_is_refused_a_branch_because_fix_writes_this_one():
+    # It reports far more often than it fixes, which is what made listing it as a read
+    # look right. `--fix` writes, and it writes to the tree that is CHECKED OUT — so
+    # being listed would have let `links --fix --branch other` past this gate and
+    # edited the wrong branch while the caller believed otherwise.
+    try:
+        entry._reads_only("links", {"branch": "theirs"})
+    except SystemExit as e:
+        assert e.code != 0
+    else:
+        raise AssertionError("`links` must not accept --branch: --fix writes")
+
+
 def test_a_read_may_name_a_branch():
     # The same gate must not refuse the commands the flag exists for.
     entry._reads_only("list", {"branch": "theirs"})

package/harness/work.py

@@ -351,9 +351,15 @@ def _say(note: str) -> None:
 #: Commands that only LOOK. `--branch` is meaningful on these and refused on every
 #: other, which is the safe default: a command added later is covered without anyone
 #: remembering to come back here.
+#:
+#: `links` is deliberately NOT here even though it usually only reports. `--fix`
+#: writes, and it writes to the tree that is checked out — so listing it would let
+#: `links --fix --branch other` past the refusal and edit this branch while the caller
+#: believed they were touching another. It reads the working tree in both modes, so
+#: `--branch` could never have meant anything for it.
 _READS = {"list", "find", "path", "code", "where", "rules", "status", "digest",
           "log", "needs", "align", "coverage", "readme", "config", "context",
-          "doctor", "kickoff", "remind", "applies", "wrap", "links"}
+          "doctor", "kickoff", "remind", "applies", "wrap"}
 
 
 def _reads_only(cmd: str, flags: dict) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.116",
+  "version": "0.1.117",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -56,14 +56,14 @@
     "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/errors": "1.0.0",
     "@jarvis/types": "1.0.0",
+    "@jarvis/agents": "1.0.0",
+    "@jarvis/anthropic": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
     "@jarvis/ui": "0.1.0",
     "@jarvis/vitest-config": "1.0.0"