@appchy/jarvis 0.1.66 → 0.1.68

package/dist/bin.js

@@ -10115,7 +10115,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 = "e0c2058";
+var SHA = "ac6ee80";
 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/architecture.py

@@ -85,6 +85,17 @@ second copy of it here is a second copy to drift.
 """
 
 
+#: Where a repo's `work.config.json` says its schema lives. The package is published,
+#: so a CDN already serves it and there is nothing to host — and it is the same line in
+#: every repo, which a path into anybody's node_modules could never be.
+_WORK_CONFIG = (
+    "{\n"
+    '  "$schema": "https://cdn.jsdelivr.net/npm/@appchy/jarvis/harness/schema/'
+    'work.config.schema.json"\n'
+    "}\n"
+)
+
+
 def cmd_init(args) -> int:
     """Scaffold a work tree: the board, the roadmap, and the nine org-domains.
 
@@ -128,6 +139,19 @@ def cmd_init(args) -> int:
         write(root / name / "README.md",
               _charter(name, name.replace("-", " ").capitalize()))
 
+    # The repo's own config, which `init` did not use to write — so every repo that
+    # adopted the harness hand-copied one from a sibling, and copied whatever that
+    # sibling's `$schema` happened to point at. Three of them ended up naming a path
+    # inside a plugin that no longer exists, and a dangling `$schema` is not an error
+    # anywhere, so nothing said so.
+    #
+    # Only the pointer is written. Everything else in this file is a choice about the
+    # repo — its ledger letter, its verify commands, its instruction preset — and a
+    # scaffold that guesses those is a scaffold somebody has to undo. The schema tells
+    # the editor what the rest may say, which is exactly what a first-time adopter has
+    # no way to know.
+    write(project / ".claude" / "work.config.json", _WORK_CONFIG)
+
     print(f"initialised {rel(root, root) or 'work/'} at {root}")
     if made:
         print(f"  created {len(made)}: {', '.join(made)}")

package/harness/harness/safety.py

@@ -285,12 +285,46 @@ def cmd_doctor(args) -> int:
             from .align import _foreign_qualifier
             foreign = _foreign_qualifier()
             other = re.compile(r"\b([A-Z][A-Z0-9]{0,3})-\d+\b")
+            # A LEDGER declares itself by defining entries: `### J-52 — …`, `## S-1. …`.
+            # Prose never does. That distinction is the whole check — without it the
+            # pattern above reads `SHA-256`, `JP-8000` and `AUTO-3` as citations, which
+            # on one audio repo was 53 of its reported strays and no configuration
+            # could have silenced them honestly: there is no repo called SHA, and
+            # calling SHA a ledger to go green is the lie the check exists to prevent.
+            #
+            # Definitions are looked for in the board AND in the standards file the
+            # spine names, because a repo's second ledger usually lives there rather
+            # than under `work/`. An unconfigured install is still caught, which is what
+            # this check is FOR: its rules are headings, so its prefix is declared here
+            # and reported as unmatched.
+            # The separator is load-bearing, not decoration. Every ledger in every repo
+            # here writes `### J-52 — Title` or `## S-1. Title`; a heading that merely
+            # TALKS about an id writes `### AUTO-4 ARRIVED AS A DERIVATION`, with a
+            # bare space. Without this, one such heading in one brief was enough to
+            # promote a synth's model number to a ledger.
+            defines = re.compile(r"^#{1,6}\s+([A-Z][A-Z0-9]{0,3})-\d+(?:\.|\s+[\u2014\u2013-])")
             allowed = {cfg["ids"]["prefix"], *cfg["ids"]["recognised"], "AC", "B"}
+
+            board = list(root.rglob("*.md"))
+            spine = cfg.get("spine", {}).get("standards")
+            elsewhere = [repo / spine] if spine and (repo / spine).is_file() else []
+
+            declared, lines_by_doc = set(), {}
+            for md in board + elsewhere:
+                lines = md.read_text(errors="ignore").splitlines()
+                if md in board:
+                    lines_by_doc[md] = lines
+                for line in lines:
+                    d = defines.match(line)
+                    if d:
+                        declared.add(d.group(1))
+
             stray = {}
-            for md in root.rglob("*.md"):
-                for line in md.read_text(errors="ignore").splitlines():
+            for lines in lines_by_doc.values():
+                for line in lines:
                     for m in other.finditer(line):
-                        if m.group(1) in allowed or foreign.search(line[:m.start()]):
+                        if (m.group(1) in allowed or m.group(1) not in declared
+                                or foreign.search(line[:m.start()])):
                             continue
                         stray.setdefault(m.group(1), 0)
                         stray[m.group(1)] += 1
@@ -298,15 +332,16 @@ def cmd_doctor(args) -> int:
                 top = ", ".join(f"{k}-nn x{v}" for k, v in
                                 sorted(stray.items(), key=lambda kv: -kv[1])[:4])
                 warn("ids", f"{sum(stray.values())} id(s) match no configured prefix "
-                            f"({top}). Three readings, and they are far apart. If one "
-                            f"of those IS this repo's ledger letter, set ids.prefix "
-                            f"— every check is reading the wrong dialect until you "
-                            f"do. If this repo keeps a SECOND ledger of its own "
-                            f"— standards beside rules, say — add its letter to "
-                            f"ids.recognised: it is read as native and never "
-                            f"generated. If they are a sibling repo's ids discussed "
-                            f"in prose, add that repo to ids.foreign, which excuses "
-                            f"them where the repo is named alongside.")
+                            f"({top}). Each of those prefixes DEFINES entries "
+                            f"somewhere in this repo, so they are ledgers rather than "
+                            f"prose, and three readings remain. If one IS this repo's "
+                            f"ledger letter, set ids.prefix — every check is reading "
+                            f"the wrong dialect until you do. If this repo keeps a "
+                            f"SECOND ledger of its own — standards beside rules, say "
+                            f"— add its letter to ids.recognised: it is read as native "
+                            f"and never generated. If a sibling repo's ledger is "
+                            f"quoted here in full, add that repo to ids.foreign, which "
+                            f"excuses it where the repo is named alongside.")
             else:
                 ok("ids", f"every id matches a configured prefix")
 

package/harness/schema/work.config.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/appchy-ai/plugins/work.config.schema.json",
+  "$id": "https://cdn.jsdelivr.net/npm/@appchy/jarvis/harness/schema/work.config.schema.json",
   "title": "work.config.json",
   "description": "Per-repo configuration for the `work` harness, committed at .claude/work.config.json. This is the ONLY configuration path: Claude Code has deliberately ignored `pluginConfigs` in project settings since v2.1.207, because a cloned repo could otherwise inject values into hook commands and MCP configs. Treat it as a security surface — a value that reaches a shell command is the same injection wearing different clothes.",
   "type": "object",

package/harness/test_work.py

@@ -1778,6 +1778,41 @@ def test_doctor_passes_a_degraded_but_legal_install_and_fails_a_real_break():
         assert f"{tree.cli()} init" in out.getvalue()
 
 
+def test_doctor_reads_a_ledger_as_an_id_and_leaves_prose_alone():
+    import io, contextlib
+    with tempfile.TemporaryDirectory() as tmp:
+        root = _initialised(tmp)
+
+        # Prose that merely LOOKS like a citation. A hash algorithm, a synth's model
+        # number, and a heading that talks about an id rather than defining one — all
+        # measured on a real audio repo, where they were 53 reported strays that no
+        # configuration could have silenced honestly.
+        (root / "product" / "notes.md").write_text(
+            "# Notes\n\n"
+            "An identical SHA-256 over 10,000 bytes, and the JP-8000 supersaw.\n\n"
+            "### AUTO-4 ARRIVED AS A DERIVATION RATHER THAN A TOLERANCE\n\n"
+            "Their `AUTO-1..4` clause families.\n"
+        )
+        with contextlib.redirect_stdout(io.StringIO()) as out:
+            assert safety.cmd_doctor({"project_root": tmp}) == 0
+        said = out.getvalue()
+        for prose in ("SHA-nn", "JP-nn", "AUTO-nn"):
+            assert prose not in said, f"{prose} is prose, not a citation"
+        assert "every id matches a configured prefix" in said
+
+        # An UNCONFIGURED install is the thing this check exists to catch, and it still
+        # is: a ledger declares itself by DEFINING entries, and those are headings.
+        (root / "architecture" / "camera.md").write_text(
+            "---\ntype: system\n---\n\n# Camera\n\n"
+            "### Q-1 — The camera never settles a shot alone\n\n"
+            "### Q-2 — A frame is stamped once\n"
+        )
+        with contextlib.redirect_stdout(io.StringIO()) as out:
+            assert safety.cmd_doctor({"project_root": tmp}) == 0
+        said = out.getvalue()
+        assert "Q-nn" in said, "an unconfigured ledger must still be reported"
+
+
 def test_align_does_not_read_the_harnesss_own_modules_or_suite():
     # AC-07, moved here from `config-seam`: the shipped suite's fixture ids must not
     # resolve against a CONSUMER's ledger. "The payload lives in the plugin cache so
@@ -1893,6 +1928,30 @@ def test_init_scaffolds_the_whole_tree_and_is_idempotent_and_non_destructive():
         assert (root / "design" / "README.md").is_file(), "init did not backfill"
 
 
+def test_init_writes_a_config_whose_schema_pointer_exists_and_never_replaces_one():
+    with tempfile.TemporaryDirectory() as tmp:
+        _initialised(tmp)
+        cfg = Path(tmp) / ".claude" / "work.config.json"
+        assert cfg.is_file(), "a repo adopting the harness had to hand-copy this file"
+
+        # It parses, and the only thing scaffolded is the pointer — everything else in
+        # this file is a choice about the repo, and a guess is something to undo.
+        body = json.loads(cfg.read_text())
+        assert list(body) == ["$schema"]
+        assert body["$schema"].endswith("/harness/schema/work.config.schema.json")
+
+        # The pointer names the package, not a path inside anybody's plugin or
+        # node_modules — the failure this replaces was three repos naming a path that
+        # had been deleted, which no editor reports.
+        assert "@appchy/jarvis" in body["$schema"]
+        assert "plugins" not in body["$schema"]
+
+        # A repo that has already configured itself keeps what it wrote.
+        cfg.write_text('{"ids": {"prefix": "Z"}}')
+        assert architecture.cmd_init({"project_root": tmp}) == 0
+        assert json.loads(cfg.read_text()) == {"ids": {"prefix": "Z"}}
+
+
 def test_domain_new_pulls_a_shipped_charter_and_still_works_for_an_unknown_name():
     import os
     with tempfile.TemporaryDirectory() as tmp:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",