@appchy/jarvis 0.1.104 → 0.1.105

package/dist/bin.js

@@ -10260,7 +10260,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 = "9f128de";
+var SHA = "1bf7cfd";
 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/drift.py

@@ -80,6 +80,26 @@ def _roots(owner: str) -> list:
     return ["", here, "work", "apps/cli"]
 
 
+def _moved_to(path: str, by_base: dict) -> str:
+    """Where this file went, or "" when that cannot be said with confidence.
+
+    **A basename alone is far too weak to propose a move from.** `epic.md` matches
+    seventeen files here, `task.md` hundreds — and picking the first of them named a
+    completely unrelated epic's plan as the new home of a released one, which a
+    reader who trusts it would have edited their brief to point at. Worse than
+    silence. So a candidate must also carry the named path's own parent directory,
+    and if more than one still qualifies, none is offered: "seventeen candidates" is
+    not an answer, and neither is the first of them sorted. Reported by jarvis-14
+    after `check` did exactly this on their sweep item, 2026-09-12.
+    """
+    parts = Path(path).parts
+    if len(parts) < 2:
+        return ""  # a bare filename names no place it could have moved FROM
+    tail = str(Path(*parts[-2:]))
+    fits = [c for c in by_base.get(parts[-1], []) if c == tail or c.endswith("/" + tail)]
+    return fits[0] if len(fits) == 1 else ""
+
+
 def _resolve(path: str, owner: str, tracked: set) -> str:
     for root in _roots(owner):
         candidate = str(Path(root) / path) if root else path
@@ -95,21 +115,51 @@ def _resolve(path: str, owner: str, tracked: set) -> str:
 BUILT = {"dist", "build", ".next", "out", "node_modules", ".data", ".work"}
 
 
-def _unjudgeable(path: str) -> bool:
+def _siblings(repo: Path) -> set:
+    """Repos sitting beside this one. A brief writes `gotcha/apps/web/src/...` or
+    "gotcha's `apps/backoffice/src/lib/experiment.ts`" as often as it writes
+    `../gotcha/...`, and none of those are this checkout's to judge — but only the
+    `../` spelling announces itself. Found by hand-checking a random twelve of this
+    checker's own findings, where two of the twelve were a neighbour's file.
+    """
+    try:
+        return {d.name for d in repo.parent.iterdir()
+                if d.is_dir() and (d / ".git").exists() and d.name != repo.name}
+    except OSError:
+        return set()
+
+
+def _unjudgeable(path: str, siblings=frozenset()) -> bool:
     """Paths this cannot have an opinion about, kept apart from paths it says are
     fine — silence here means *not my question*, not *checked and good*.
 
-    Two kinds. Build output, which git never tracks and which is present anyway on
-    any machine that has built. And anything climbing out of the repo: a brief that
-    names `../docdoc/.claude/skills/work/SKILL.md` is talking about a sibling repo,
-    whose contents this checkout cannot see and must not pronounce on.
+    Three kinds. Build output, which git never tracks and which is present anyway on
+    any machine that has built. Anything climbing out of the repo with `../`. And
+    anything rooted at a sibling repo's name, which is the same thing said without
+    the `../` and is otherwise indistinguishable from one of ours.
     """
-    return path.startswith("../") or bool(BUILT & set(Path(path).parts))
+    parts = Path(path).parts
+    if path.startswith("../") or (BUILT & set(parts)):
+        return True
+    return bool(parts) and parts[0] in siblings
+
+
+#: A sentence asserting that the path is NOT there. The absence is then the claim,
+#: and flagging it pushes somebody into deleting the most informative half of a
+#: correct statement — J-41's `enforced_by` reads "`apps/ws/src/storage.ts` does not
+#: exist", which is the rule's whole point. Reported by jarvis-14, 2026-09-12.
+ABSENT = re.compile(
+    r"\b(does not exist|no longer exists?|never existed|is gone|was (deleted|removed)|"
+    r"deleted|removed|retired|there is no such|nothing (at|called)|no longer there)\b", re.I)
 
 
 def named_paths(text: str):
-    """Every path a document names, with the line it is on. Deduplicated per line so
-    one path written twice in a sentence is one finding, not two."""
+    """Every path a document names, with the line it is on and that line's text.
+
+    Deduplicated per line so one path written twice in a sentence is one finding.
+    The line rides along because whether a path is a CLAIM depends on the sentence
+    around it: a brief saying a file does not exist is right, not stale.
+    """
     seen = set()
     for n, line in enumerate(text.splitlines(), 1):
         for m in NAMED.finditer(line):
@@ -117,7 +167,7 @@ def named_paths(text: str):
             if key in seen:
                 continue
             seen.add(key)
-            yield m.group(1), n
+            yield m.group(1), n, line
 
 
 def drift(repo: Path, docs, tracked=None) -> list:
@@ -130,6 +180,7 @@ def drift(repo: Path, docs, tracked=None) -> list:
     that question.
     """
     tracked = _tracked(repo) if tracked is None else tracked
+    siblings = _siblings(Path(repo))
     by_base = defaultdict(list)
     for t in tracked:
         by_base[Path(t).name].append(t)
@@ -141,16 +192,15 @@ def drift(repo: Path, docs, tracked=None) -> list:
             text = (repo / rel).read_text(errors="ignore")
         except OSError:
             continue
-        for path, line in named_paths(text):
-            if "/" not in path or _unjudgeable(path):
+        for path, line, text_of_line in named_paths(text):
+            if "/" not in path or _unjudgeable(path, siblings):
                 continue  # no location to check, or not this repo's to answer for
             if _resolve(path, rel, tracked):
                 continue
-            elsewhere = sorted(by_base.get(Path(path).name, []))
-            if elsewhere:
-                found.append((rel, line, path, "moved", elsewhere[0]))
-            else:
-                found.append((rel, line, path, "gone", ""))
+            if ABSENT.search(text_of_line):
+                continue  # the sentence says it is not there; that is the claim, not a stale one
+            where = _moved_to(path, by_base)
+            found.append((rel, line, path, "moved" if where else "gone", where))
     return found
 
 

package/harness/test_work.py

@@ -7501,9 +7501,11 @@ def test_a_brief_naming_a_file_that_is_gone_is_reported():
         assert [(f[2], f[3]) for f in found] == [("src/vanished.ts", "gone")]
 
 
-def test_a_file_that_merely_moved_is_reported_as_moved_and_says_where():
-    # A link to fix, not a brief to rethink — burying one in the other makes the
-    # rarer and more important finding invisible.
+def test_a_basename_match_under_a_different_parent_is_gone_not_moved():
+    # This test used to assert the opposite, and asserted a bug: a file sharing only
+    # its name with something elsewhere is not evidence of where it went. Proposing
+    # a destination from that is a guess a reader would act on. Only a candidate
+    # carrying the named path's own parent earns the word "moved".
     from harness.drift import drift
     with tempfile.TemporaryDirectory() as tmp:
         repo = _git_repo(tmp, push=False)
@@ -7516,8 +7518,8 @@ def test_a_file_that_merely_moved_is_reported_as_moved_and_says_where():
 
         found = drift(repo, ["work/brief.md"])
         assert len(found) == 1
-        assert found[0][3] == "moved"
-        assert found[0][4] == "packages/deep/moved.ts"
+        assert found[0][3] == "gone"
+        assert found[0][4] == ""
 
 
 def test_a_path_written_the_way_a_writer_means_it_is_not_a_finding():
@@ -7671,6 +7673,89 @@ def test_the_check_reads_the_epic_plan_too_not_only_the_brief():
         assert [f[2] for f in found] == ["src/long-gone.ts"]
 
 
+def test_a_bare_basename_never_proposes_a_destination():
+    # `epic.md` matches seventeen files here and `task.md` hundreds. Picking the
+    # first of them named an unrelated epic's plan as the new home of a released
+    # one — which a reader who trusted it would have edited their brief to point at.
+    # Worse than silence. Reported by jarvis-14 after `check` did exactly this.
+    from harness.drift import drift
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = _git_repo(tmp, push=False)
+        for d in ("alpha", "beta"):
+            (repo / "epics" / d).mkdir(parents=True, exist_ok=True)
+            (repo / "epics" / d / "epic.md").write_text("# an epic\n")
+        brief = repo / "work" / "brief.md"
+        brief.parent.mkdir(parents=True, exist_ok=True)
+        brief.write_text("the released `released-cut/epic.md`\n")
+        _git(repo, "add", "-A"); _git(repo, "commit", "-m", "seed")
+
+        found = drift(repo, ["work/brief.md"])
+        assert [(f[2], f[3], f[4]) for f in found] == [("released-cut/epic.md", "gone", "")]
+
+
+def test_several_candidates_suppress_the_suggestion_rather_than_picking_one():
+    from harness.drift import drift
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = _git_repo(tmp, push=False)
+        for d in ("one", "two"):
+            (repo / d / "clients").mkdir(parents=True, exist_ok=True)
+            (repo / d / "clients" / "reach.ts").write_text("export const a = 1;\n")
+        brief = repo / "work" / "brief.md"
+        brief.parent.mkdir(parents=True, exist_ok=True)
+        brief.write_text("see `src/clients/reach.ts`\n")
+        _git(repo, "add", "-A"); _git(repo, "commit", "-m", "seed")
+
+        found = drift(repo, ["work/brief.md"])
+        assert found[0][3] == "gone" and found[0][4] == ""
+
+
+def test_one_candidate_carrying_the_named_directory_is_a_confident_move():
+    from harness.drift import drift
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = _git_repo(tmp, push=False)
+        (repo / "packages" / "data" / "src" / "mcp" / "tools").mkdir(parents=True)
+        (repo / "packages" / "data" / "src" / "mcp" / "tools" / "schema.ts").write_text("x\n")
+        brief = repo / "work" / "brief.md"
+        brief.parent.mkdir(parents=True, exist_ok=True)
+        brief.write_text("see `packages/data/src/tools/schema.ts`\n")
+        _git(repo, "add", "-A"); _git(repo, "commit", "-m", "seed")
+
+        found = drift(repo, ["work/brief.md"])
+        assert found[0][3] == "moved"
+        assert found[0][4] == "packages/data/src/mcp/tools/schema.ts"
+
+
+def test_a_sentence_saying_the_file_is_not_there_is_a_claim_not_a_stale_one():
+    # J-41's enforced_by reads "`apps/ws/src/storage.ts` does not exist" — the
+    # absence IS the rule. Flagging it pushes somebody into deleting the most
+    # informative half of a correct statement.
+    from harness.drift import drift
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = _git_repo(tmp, push=False)
+        brief = repo / "work" / "brief.md"
+        brief.parent.mkdir(parents=True, exist_ok=True)
+        brief.write_text("the only resolver, and `apps/ws/src/storage.ts` does not exist\n"
+                         "`packages/old/gone.ts` was deleted on purpose\n")
+        _git(repo, "add", "-A"); _git(repo, "commit", "-m", "seed")
+
+        assert drift(repo, ["work/brief.md"]) == []
+
+
+def test_a_sibling_repos_path_is_not_this_checkouts_to_judge_however_it_is_spelled():
+    # `../gotcha/x.ts` announces itself; `gotcha/x.ts` does not, and is how a brief
+    # usually writes it. Two of a random twelve findings were a neighbour's file.
+    from harness.drift import drift
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = _git_repo(tmp, push=False)          # lands at <tmp>/repo
+        (repo.parent / "gotcha" / ".git").mkdir(parents=True)   # beside it
+        brief = repo / "work" / "brief.md"
+        brief.parent.mkdir(parents=True, exist_ok=True)
+        brief.write_text("gotcha's `gotcha/apps/web/src/rate-limit.ts` and ours `src/mine.ts`\n")
+        _git(repo, "add", "-A"); _git(repo, "commit", "-m", "seed")
+
+        assert [f[2] for f in drift(repo, ["work/brief.md"])] == ["src/mine.ts"]
+
+
 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.104",
+  "version": "0.1.105",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -61,9 +61,9 @@
     "@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/logger": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
     "@jarvis/ui": "0.1.0",
     "@jarvis/vitest-config": "1.0.0"