@appchy/jarvis 0.1.74 → 0.1.76

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/presets/appchy/PRESET.md

@@ -159,6 +159,14 @@ preference — `jarvis work where` resolves it. Tiny mechanics need no sign-off.
    from `jarvis work code <region>` overlap and the feature graph, not a lint. A cheap reshape happens in
    the plan; a real trade-off routes through `AskUserQuestion` and lands as a new rule.
 
+**A completed brief records what was BELIEVED then; it is not a statement about now.** Anything under
+`complete/` or in a released cut describes the world its author was working in, and the tools it
+asserts have moved since. Quote one only with its date attached, and check any claim about how a
+command behaves against the command before planning on it. Three such claims were found false in one
+evening across two repos — each specific, plausible, recently dated, and sitting in a file whose whole
+job is to be trusted. Nothing catches this class: the sentence points at no file, so no link check
+goes red, and the tree does not know it is a claim.
+
 The completion gate enforces all three: a task that changed behaviour is not complete until every
 `AC-nn` it targeted has passing evidence, `<feature>.md` (+ its `state:`), the durable rules and any
 touched briefs match what was actually built. `map_scope {edits}` over the edit set flags governance the

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

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.74",
+  "version": "0.1.76",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -56,6 +56,7 @@
     "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",
@@ -65,8 +66,7 @@
     "@jarvis/types": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
     "@jarvis/ui": "0.1.0",
-    "@jarvis/vitest-config": "1.0.0",
-    "@jarvis/agents": "1.0.0"
+    "@jarvis/vitest-config": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",