@appchy/jarvis 0.1.86 → 0.1.87

package/dist/bin.js

@@ -10114,7 +10114,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 = "5acb5ea";
+var SHA = "bf7fe32";
 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/coverage.py

@@ -99,7 +99,7 @@ def cmd_coverage(args) -> int:
     # had already looked at as behaviour nobody had written.
     rows, totals = [], {"declared": 0, "built": 0, "provable": 0, "proven": 0,
                         "failed": 0, "todo": 0, "gap": 0, "ahead": 0,
-                        "unlevelled": 0}
+                        "unlevelled": 0, "eyes": 0}
     mismatched = []
 
     for md in sorted(scan_features(root)):
@@ -124,14 +124,27 @@ def cmd_coverage(args) -> int:
         # number that can only go up by deleting the promise. It comes out of the
         # ratio and is reported beside it, exactly as the unbuilt roadmap is.
         eyes = {ac for ac in built if levels[ac][0] == "eyes-on"}
+        # A criterion that declares NO level is not run-provable either — it is
+        # UNKNOWN, and the two are not the same thing. It used to fall through to
+        # the denominator, so an unannotated promise was silently assumed to be one
+        # a run could settle, and the ratio quietly counted an unanswered question
+        # as a question with an answer. Whichever way that assumption goes it is a
+        # guess, and a guess inside the one number this repo is judged by is worth
+        # more than the tidiness of a default. It comes out and is NAMED, the way
+        # every other set-aside here is, so the number that remains is only what
+        # somebody actually declared could be settled by a run.
+        unknown = {ac for ac in built if levels[ac][0] is None}
         # The two ways the spec and the evidence disagree, and they point opposite
         # ways. `gap` is a promise claimed with nothing to show. `ahead` is a
         # promise a passing test already keeps while the spec still says nobody
         # built it — the doc trailing the code, which no report used to count.
-        gap = built - passed - failed - todo - eyes
+        # An `unknown` is neither: until it says what would settle it, there is no
+        # bar to find it short of, and reporting it twice buries the one fix that
+        # unblocks it.
+        gap = built - passed - failed - todo - eyes - unknown
         ahead = passed - built
-        provable = built - eyes
-        proven = (built & passed) - eyes
+        provable = built - eyes - unknown
+        proven = (built & passed) - eyes - unknown
         for ac in sorted(declared):
             level = levels[ac][0]
             complaint = _wrong_level(level, runners.get(f"{name}/{ac}", set())) if level else None
@@ -146,7 +159,15 @@ def cmd_coverage(args) -> int:
         totals["todo"] += len(built & todo)
         totals["gap"] += len(gap)
         totals["ahead"] += len(ahead)
-        totals["unlevelled"] += sum(1 for ac in declared if levels[ac][0] is None)
+        # BUILT ones only. A level on behaviour nobody has written is a prediction,
+        # which is why `lint` exempts the unbuilt too — counting them here would
+        # report a number nobody can act on beside one they can.
+        totals["unlevelled"] += len(unknown)
+        # COUNTED, not derived. It used to be read back as `built - provable`,
+        # which held while `eyes` was the only thing coming out of the ratio and
+        # silently absorbed the unlevelled the moment they came out too — reporting
+        # "settled by eyes" over criteria nobody had looked at.
+        totals["eyes"] += len(eyes)
         # The column is the ratio's own denominator, so it counts what the ratio
         # divides by and not everything ticked.
         rows.append((name, len(provable), len(proven), len(eyes),
@@ -193,10 +214,20 @@ def cmd_coverage(args) -> int:
     # Every count the tail reports is DERIVED from the three the loop kept, because
     # a total that can be worked out and is stored anyway is a total that can
     # disagree with the ones it was worked out from.
-    eyes, unbuilt = t["built"] - t["provable"], t["declared"] - t["built"]
+    eyes, unbuilt = t["eyes"], t["declared"] - t["built"]
     rate = f"{100 * t['proven'] // t['provable']}%" if t["provable"] else "—"
-    print(f"\n  BUILT COVERAGE  {t['proven']}/{t['provable']} = {rate} "
-          f"— of the RUN-PROVABLE promises this app keeps, how many a run proves\n"
+    # THE CAVEAT RIDES THE HEADLINE, never a paragraph below it. Criteria with no
+    # level come out of both halves of this ratio, so every one of them makes the
+    # number look BETTER — and a figure that improves when somebody fails to
+    # annotate is one an unattended run can raise by doing nothing. It cannot be
+    # fixed by putting them back: in counts them as run-provable, out counts them
+    # as impossible, and both are guesses at the question the level exists to
+    # answer. So the ratio stays over what is actually known and refuses to be read
+    # alone while anything is unknown.
+    incomplete = (f" · INCOMPLETE: {t['unlevelled']} unlevelled, in neither half"
+                  if t["unlevelled"] else "")
+    print(f"\n  BUILT COVERAGE  {t['proven']}/{t['provable']} = {rate}{incomplete}\n"
+          f"  — of the RUN-PROVABLE promises this app keeps, how many a run proves\n"
           f"  {t['gap']} claimed with nothing to show · {t['todo']} declared-but-unwritten · "
           f"{t['failed']} failing\n")
     print(f"  Settled by eyes, not by a run: {eyes}. A look is a level, not an\n"
@@ -222,7 +253,11 @@ def cmd_coverage(args) -> int:
             print(f"    {complaint}")
         print()
     if t["unlevelled"]:
-        print(f"  {t['unlevelled']} criteria declare no level, so nothing can check the test that\n"
-              "  claims them — and they count as run-provable by default, which for a\n"
-              "  look is the wrong default.\n")
+        print(f"  {t['unlevelled']} BUILT criterion(s) declare no level, so nothing can check the\n"
+              "  test that claims them. They are OUT of the ratio above rather than\n"
+              "  counted as run-provable: until a criterion says what could settle it,\n"
+              "  neither answer is knowable, and a guess belongs outside the number.\n"
+              "  Annotate each with one of e2e / integration / unit / eyes-on to bring\n"
+              "  it back in — and a task may not complete while a criterion it covers\n"
+              "  is still unlevelled.\n")
     return 0

package/harness/harness/gate.py

@@ -33,7 +33,8 @@ from pathlib import Path
 
 from .tree import die, find_work_root
 from .frontmatter import as_list, parse_frontmatter, rewrite_file, split_frontmatter
-from .model import locate, missing
+from .lint import AC_LEVELS, feature_ac_levels
+from .model import locate, locate_feature, missing
 from .shard import _load_run
 from . import events, git, peers
 from .autonomy import tier_of
@@ -510,6 +511,7 @@ def cmd_verify(args) -> int:
     _print_report(results, sha)
     if name:
         print(f"  recorded on '{name}'")
+        _warn_unlevelled(root, name)
     return 0 if ok else 1
 
 
@@ -565,6 +567,32 @@ def _last_verify(task) -> tuple:
     return passed, sha, when
 
 
+def _warn_unlevelled(root, name: str) -> None:
+    """Say at VERIFY what will REFUSE at complete — the same fact, twice, early.
+
+    Warning here and refusing there is deliberate and is not the warn-instead-of-
+    refuse pattern the module docstring argues against: nothing is decided on this
+    warning, and skipping it changes no outcome. It exists because the refusal is
+    cheap to satisfy and expensive to meet for the first time at the finish line —
+    an unattended run that learns at `complete` has already spent the work, while
+    one that learns at `verify` can annotate the spec inside the same shift.
+    """
+    task = locate(root, name)
+    if not task or not task.covers:
+        return
+    feature = (task.owner or "").split("/")[-1]
+    md = locate_feature(root, feature)
+    if not md:
+        return
+    levels = feature_ac_levels(md.read_text())
+    unlevelled = [ac for ac in task.covers
+                  if ac in levels and levels[ac][0] is None]
+    if unlevelled:
+        print(f"\n  WARN  {', '.join(unlevelled)} declare no level — `complete` will "
+              f"refuse\n        until each says what could settle it. Annotate them in "
+              f"`product/{feature}.md`\n        with one of {', '.join(AC_LEVELS)}.")
+
+
 def gate(root, task, accept: str = "", owner: str = "") -> list:
     """Every reason this task may NOT be called complete. Empty means it may.
 
@@ -652,8 +680,28 @@ def gate(root, task, accept: str = "", owner: str = "") -> list:
         proven = _load_run(root.parent).proven
         seen = _observed_acs(task)
         feature = (task.owner or "").split("/")[-1]
+        # WHAT COULD SETTLE IT, before whether anything did. A criterion with no
+        # declared level is not a criterion a run can be judged against: `coverage`
+        # cannot say whether a passing test is the right KIND of evidence for it,
+        # and `_wrong_level` — the check that catches a unit test claiming what only
+        # a person can see — has nothing to compare. So the two questions are asked
+        # in order, and the second is not worth asking first: "no evidence" on an
+        # unlevelled criterion is unanswerable rather than false, and reporting it
+        # as a gap sends somebody looking for a test when the missing thing is the
+        # bar. Scoped to what this task COVERS, never the whole feature file: a task
+        # is answerable for the promises it took, and refusing on a neighbour's
+        # would make the board incompletable by anyone but the last person to touch
+        # the spec.
+        levels = feature_ac_levels(md.read_text()) if (
+            md := locate_feature(root, feature)) else {}
         for ac in task.covers:
             cid = f"{feature}/{ac}" if feature else ac
+            if ac in levels and levels[ac][0] is None:
+                reasons.append(
+                    f"{ac} declares no level, so nothing can check the test that "
+                    f"claims it — annotate it in `product/{feature}.md` with one of "
+                    f"{', '.join(AC_LEVELS)}")
+                continue
             if proven.get(cid) == "passed" or ac in seen:
                 continue
             reasons.append(f"{ac} has no evidence — no passing coverage binding "

package/harness/harness/shard.py

@@ -41,8 +41,8 @@ class Run(NamedTuple):
     runners: dict
     #: The shard filenames actually read.
     shards: list
-    #: Source paths named by a shard that is no longer in the tree. Their claims
-    #: are not in `proven`.
+    #: Source paths from a shard NONE of whose sources are still in the tree.
+    #: Their claims are not in `proven`.
     stale: list
     #: Shards that never say what they ran. Their claims ARE in `proven` — there
     #: is nothing to check them against — and they are named so a reader knows it.
@@ -62,7 +62,7 @@ def _load_run(repo: Path) -> Run:
     `playwright.json`. A criterion bound at both levels reported whichever
     runner sorted last, which is the one thing this file exists not to do.
 
-    A SHARD OUTLIVES THE TEST THAT WROTE IT, so one whose `source` is no longer
+    A SHARD OUTLIVES THE TESTS THAT WROTE IT, so one none of whose `sources` are
     in the tree is set aside rather than read. It is a result about code this
     checkout does not have, and nothing rewrites it: a renamed or deleted spec
     would otherwise go on claiming `passed` forever, which is the same fault a
@@ -86,14 +86,26 @@ def _load_run(repo: Path) -> Run:
             data = json.loads(p.read_text())
         except Exception:
             continue
-        source = data.get("source")
-        if not isinstance(source, str) or source == "":
-            # COUNTED, AND NAMED. A runner that does not write a source cannot be
+        # A LIST, because one shard is one RUN and a run covers many files. It was
+        # a single `source` string, which no writer ever managed to fill: a vitest
+        # workspace has no one file to name, so every shard fell through to
+        # `unattributed` and the check has never once run. A field only a
+        # single-file runner could satisfy is a field that reads as absent for
+        # everybody else.
+        sources = data.get("sources")
+        sources = [s for s in sources if isinstance(s, str) and s] if isinstance(sources, list) else []
+        if not sources:
+            # COUNTED, AND NAMED. A runner that does not write its sources cannot be
             # checked, and dropping it would throw away real evidence to punish a
             # writer. Saying so is what lets somebody fix the writer.
             read.unattributed.append(p.name)
-        elif not (repo / source).exists():
-            read.stale.append(source)
+        elif not any((repo / s).exists() for s in sources):
+            # EVERY source gone, not merely one. A run spanning ten files where one
+            # was deleted still proved the other nine, and setting the whole shard
+            # aside would discard them to punish a rename. Only when nothing it ran
+            # is still in the tree is the shard a result about code this checkout
+            # does not have.
+            read.stale.extend(sources)
             continue
         read.shards.append(p.name)
         runner = data.get("runner") or "unknown"

package/harness/test_work.py

@@ -27,7 +27,7 @@ from harness.ids import LEDGER as L  # noqa: E402 — fixtures render in the rep
 from harness import (align, architecture, autonomy, branches, config, coverage, epic,  # noqa: E402
                      events, extend, frontmatter, gate, generate, git, ids, kickoff,
                      lint, model, peers, registry, report, safety, scaffold,
-                     shift, task, tree, version)
+                     shard, shift, task, tree, version)
 
 # `parse_argv` is the ENTRY's own concern, so it is loaded from work.py by path
 # rather than re-homed into a module just to make a test tidier.
@@ -1119,11 +1119,15 @@ def _shards(tmp: str, **byname: dict) -> Path:
 
 def _ran(repo: Path, name: str, source: str, covered: dict) -> Path:
     """One shard that names the file it ran. Returns that file's path so a test
-    can create it, or rename it away."""
+    can create it, or rename it away.
+
+    `sources` is a LIST on the shard — one run covers many files — and this helper
+    writes a single-entry one, which is the case these tests exercise: with one
+    source, "none of them survive" and "that one is gone" are the same event."""
     d = repo / ".work" / "coverage"
     d.mkdir(parents=True, exist_ok=True)
     (d / f"{name}.json").write_text(
-        json.dumps({"runner": "vitest", "source": source, "covered": covered}))
+        json.dumps({"runner": "vitest", "sources": [source], "covered": covered}))
     return repo / source
 
 
@@ -3263,6 +3267,59 @@ def test_a_promised_criterion_needs_evidence_a_run_or_a_person_produced():
             assert not any("AC-01" in r for r in reasons), reasons
 
 
+def test_a_criterion_with_no_level_is_refused_before_it_is_asked_for_evidence():
+    # The two questions in order. "No evidence" on a criterion that never said what
+    # could settle it is unanswerable rather than false, and reporting it as a gap
+    # sends somebody hunting for a test when the missing thing is the bar.
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "an-epic")
+        _task(e / "in-progress", "alpha",
+              fm="priority: P1\ntier: 1\nowner: lesson\ncovers: [AC-01]\n",
+              body="# T\n")
+        with _work_dir(tmp) as root:
+            spec = root / "product" / "lesson.md"
+            spec.parent.mkdir(parents=True, exist_ok=True)
+            spec.write_text("---\ntype: feature\nstate: building\n---\n\n"
+                            "# Lesson\n\n- [x] AC-01: the card renders\n")
+            reasons = gate.gate(root, model.locate(root, "alpha"))
+            assert any("AC-01 declares no level" in r for r in reasons), reasons
+            assert not any("has no evidence" in r for r in reasons), reasons
+
+            # Annotated, and the gate moves on to the question it was blocking.
+            spec.write_text("---\ntype: feature\nstate: building\n---\n\n"
+                            "# Lesson\n\n- [x] AC-01 (unit): the card renders\n")
+            reasons = gate.gate(root, model.locate(root, "alpha"))
+            assert not any("declares no level" in r for r in reasons), reasons
+            assert any("AC-01 has no evidence" in r for r in reasons), reasons
+
+
+def test_a_run_still_counts_when_one_of_its_files_was_deleted():
+    # `sources` is a LIST because one run covers many files. Setting the whole
+    # shard aside because a single spec was renamed would discard the other nine
+    # files' real results to punish the rename.
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = Path(tmp)
+        d = repo / ".work" / "coverage"
+        d.mkdir(parents=True)
+        (repo / "kept.test.ts").write_text("//")
+        (d / "vitest-pkg.json").write_text(json.dumps({
+            "runner": "vitest",
+            "sources": ["kept.test.ts", "gone.test.ts"],
+            "covered": {"lesson/AC-01": {"status": "passed"}},
+        }))
+        read = shard._load_run(repo)
+        assert read.proven.get("lesson/AC-01") == "passed", read.proven
+        assert read.unattributed == [], read.unattributed
+
+        # Every source gone is a different event: the result is about code this
+        # checkout does not have, so it is set aside rather than believed.
+        (repo / "kept.test.ts").unlink()
+        gone = shard._load_run(repo)
+        assert gone.proven == {}, gone.proven
+        assert sorted(gone.stale) == ["gone.test.ts", "kept.test.ts"], gone.stale
+
+
 def test_the_event_log_is_history_and_nothing_reads_it_for_state():
     # The line that must not blur. If a check ever needs a fact from the log, that
     # fact belongs in the tree instead — otherwise this becomes the central ledger
@@ -6382,7 +6439,7 @@ def _coverage_fixture(tmp: str, body: str, shard: dict = None) -> Path:
         d = root.parent / ".work" / "coverage"
         d.mkdir(parents=True)
         (d / "vitest.json").write_text(json.dumps(
-            {"source": "pkg/x.test.ts", "runner": "vitest", "covered": shard}))
+            {"sources": ["pkg/x.test.ts"], "runner": "vitest", "covered": shard}))
     return root
 
 
@@ -6719,7 +6776,7 @@ def test_a_repo_that_moves_its_coverage_shard_is_actually_read_there():
             elsewhere = root.parent / "build" / "evidence"
             elsewhere.mkdir(parents=True)
             (elsewhere / "vitest.json").write_text(json.dumps(
-                {"source": "pkg/x.test.ts", "runner": "vitest",
+                {"sources": ["pkg/x.test.ts"], "runner": "vitest",
                  "covered": {"viewer/AC-01": {"status": "passed"}}}))
 
             config.apply({**config.DEFAULTS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.86",
+  "version": "0.1.87",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -56,17 +56,17 @@
     "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/logger": "1.0.0",
+    "@jarvis/errors": "1.0.0",
     "@jarvis/rpc": "1.0.0",
-    "@jarvis/anthropic": "1.0.0",
-    "@jarvis/typescript-config": "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/errors": "1.0.0",
-    "@jarvis/board": "0.1.0"
+    "@jarvis/agents": "1.0.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",