@appchy/jarvis 0.1.89 → 0.1.91

package/dist/data/mcp.mjs

@@ -1651,14 +1651,14 @@ function planScope(ctx, req) {
     anticipated,
     editCodeNodes,
     governance,
-    obligations: toObligations(governance, anticipated),
+    obligations: toObligations(governance, anticipated, testsCovering),
     references,
     testsCovering,
     blastRadius,
     lowConfidence
   };
 }
-function toObligations(governance, existing = []) {
+function toObligations(governance, existing = [], keep = []) {
   const rules = governance.map((g) => {
     const full = g.body !== void 0;
     return {
@@ -1668,13 +1668,19 @@ function toObligations(governance, existing = []) {
       statement: full ? `Its full text is here. Say how the plan satisfies it, or why it does not apply.` : `Not read yet \u2014 only its title arrived. Read it, then say how the plan satisfies it.`
     };
   });
+  const preserved = keep.map((c) => ({
+    type: "keep",
+    id: c.line === void 0 ? c.file : `${c.file}:${c.line}`,
+    statement: `Passes over this code today. It must still pass \u2014 and it must not be the thing the plan changes to make it.`
+  }));
   return [
     ...rules,
     ...existing.map((e) => ({
       type: "existing",
       id: e.line === void 0 ? e.file : `${e.file}:${e.line}`,
       statement: `Already in the tree and close to what was described. Reuse it, or say why the plan builds alongside it.`
-    }))
+    })),
+    ...preserved
   ];
 }
 function isCodeHit(hit) {
@@ -2304,7 +2310,8 @@ async function scope(ctx, req) {
   const topGov = plan.governance.filter((g) => g.body === void 0).slice(0, 3).map((g) => g.id).join(", ");
   const unread = plan.obligations.filter((o) => o.type === "governance" && !o.full).length;
   const reuse = plan.obligations.filter((o) => o.type === "existing").length;
-  const summary = plan.lowConfidence ? `Low-confidence (build-new) scope for "${req.task}": no code strongly matched \u2014 ${plan.anticipated.length} integration point(s) to READ, not edit; ${plan.governance.length} concept-matched governance. Lead with search + read.` : `Scoped "${req.task}": ${plan.editSet.length} edit target(s), ${plan.governance.length} governance, ${plan.testsCovering.length} covering test(s), blast radius ${plan.blastRadius.total} (${confidence})${topFiles ? ` \u2014 ${topFiles}` : ""}.${rules.ids > 0 && topGov ? ` ${rules.full} rule(s) came back in full; NEXT: read ${topGov} for the ${rules.ids} that did not,` : rules.full > 0 ? ` All ${rules.full} governing rule(s) came back in FULL \u2014 read them here, not with map_read;` : " NEXT:"} then check the edit-set with map_scope {edits} before you commit.${plan.obligations.length > 0 ? ` ${plan.obligations.length} obligation(s) outstanding${unread > 0 ? `, ${unread} rule(s) not yet read` : ""}${reuse > 0 ? `, ${reuse} thing(s) that already exist` : ""} \u2014 see \`obligations\`.` : ""}`;
+  const keep = plan.obligations.filter((o) => o.type === "keep").length;
+  const summary = plan.lowConfidence ? `Low-confidence (build-new) scope for "${req.task}": no code strongly matched \u2014 ${plan.anticipated.length} integration point(s) to READ, not edit; ${plan.governance.length} concept-matched governance. Lead with search + read.` : `Scoped "${req.task}": ${plan.editSet.length} edit target(s), ${plan.governance.length} governance, ${plan.testsCovering.length} covering test(s), blast radius ${plan.blastRadius.total} (${confidence})${topFiles ? ` \u2014 ${topFiles}` : ""}.${rules.ids > 0 && topGov ? ` ${rules.full} rule(s) came back in full; NEXT: read ${topGov} for the ${rules.ids} that did not,` : rules.full > 0 ? ` All ${rules.full} governing rule(s) came back in FULL \u2014 read them here, not with map_read;` : " NEXT:"} then check the edit-set with map_scope {edits} before you commit.${plan.obligations.length > 0 ? ` ${plan.obligations.length} obligation(s) outstanding${unread > 0 ? `, ${unread} rule(s) not yet read` : ""}${reuse > 0 ? `, ${reuse} thing(s) that already exist` : ""}${keep > 0 ? `, ${keep} that must keep passing` : ""} \u2014 see \`obligations\`.` : ""}`;
   return {
     summary,
     task: req.task,

package/harness/assets/epic-template.md

@@ -27,6 +27,14 @@ continues: {{CONTINUES}}
      epic with no `covers:` is a lint: work that moves no stated criterion is
      work nobody can tell is finished.
 
+     `one_goal:` is the epic's answer to the THIN-epic check, and it is a
+     sentence rather than a flag. An epic under the task floor is usually a topic
+     wearing an epic costume — but not always, and where the goal genuinely needs
+     only these slices, saying so in writing is the exemption. An empty one
+     exempts nothing, the same way `owner:` does: a field that can be silenced by
+     writing anything in it is not a check. The task tier carries the same field
+     for the same reason, about its WIDTH rather than its size.
+
      `owner:` is the ONE exemption from that, and it is not an escape hatch.
      Some epics genuinely move no product criterion — a trailer, a test harness,
      a migration — because nothing a user can do changes. Those answer to an

package/harness/harness/lint.py

@@ -174,16 +174,24 @@ def _shape_lint(root: Path, s: dict) -> list:
     #      epic for the same reason rule 3 does: a want nobody has planned has no
     #      slices yet, and "fold it into an epic that fits" is advice about work
     #      being cut, not about a note somebody parked.
+    #
+    #      The exemption is DECLARED, the same way a task declares its width is
+    #      deliberate. This message used to end "unless §Plan names the slices not
+    #      yet cut" — an escape nothing implemented, so the only way to satisfy it
+    #      was to stop reading the warning. A tool that promises an exemption it
+    #      does not honour teaches people to ignore every warning beside it, which
+    #      costs more than the thin epic ever did.
     for e in [e for v in s["versions"] for e in v.epics]:
         if not e.planned or e.done_tier:
             continue
         n = len(e.all_tasks())
-        if n < EPIC_TASK_FLOOR:
+        if n < EPIC_TASK_FLOOR and not e.one_goal:
             warns.append(
                 f"epic {e.name}: {n} task(s) — an epic is the goal you plan "
                 f"TOGETHER, and under {EPIC_TASK_FLOOR} there is no together. "
                 f"Fold {'it' if n == 1 else 'them'} into an existing epic that "
-                f"fits, unless §Plan names the slices not yet cut")
+                f"fits — or, if this goal genuinely needs only these, say why in "
+                f"`one_goal:`")
 
     # 3b — a task inside an epic carrying its own plan.md. The design is settled
     #      ONCE in `epic.md` §Plan; a second design doc per task is the

package/harness/harness/model.py

@@ -148,6 +148,13 @@ class Epic:
         # the tree disagrees with — the folder's home is the only statement of it.
         self.done_tier = folder.parent.name == DONE_TIER
         self.covers = as_list(self.fm.get("covers"))
+        # The same declared exemption a task carries for its WIDTH, at the tier
+        # above and for its SIZE. One field name across both rather than a second
+        # vocabulary: in each case the claim is that the shape was chosen and the
+        # sentence is what makes it reviewable. Empty exempts nothing, exactly as
+        # `owner:` and the task's own do — a field that can be silenced by writing
+        # anything in it is not a check.
+        self.one_goal = str(self.fm.get("one_goal", "")).strip()
         # Same vocabulary as a task's `owner:` — a bare `<feature>` or a bare
         # org-domain. It exists on an epic for one reason: an epic owned by a
         # DOMAIN has no `AC-nn` layer to qualify against, because a domain hosts

package/harness/test_work.py

@@ -453,12 +453,13 @@ def _task(folder: Path, name: str, body: str = "# T\n", fm: str = "priority: P1\
 
 
 def _epic(folder: Path, name: str, covers: str = "[lesson/AC-01]",
-          owner: str = ""):
+          owner: str = "", one_goal: str = ""):
     d = folder / name
     d.mkdir(parents=True)
     own = f"owner: {owner}\n" if owner else ""
+    goal = f"one_goal: {one_goal}\n" if one_goal else ""
     (d / "epic.md").write_text(
-        f"---\ntype: epic\ncreated: 2026-08-01\ncovers: {covers}\n{own}---\n\n# {name}\n")
+        f"---\ntype: epic\ncreated: 2026-08-01\ncovers: {covers}\n{own}{goal}---\n\n# {name}\n")
     return d
 
 
@@ -857,6 +858,32 @@ def test_an_empty_one_goal_exempts_nothing():
         assert any("wide: spans 3 code regions" in x for x in _warns(Path(tmp)))
 
 
+def test_a_thin_epic_that_says_its_size_is_deliberate_is_not_flagged():
+    """The message used to end "unless §Plan names the slices not yet cut" — an
+    escape nothing implemented, so the only way to satisfy it was to stop reading
+    the warning. The exemption is a SENTENCE now, the same shape a task uses for
+    its width, so one vocabulary covers both tiers."""
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "thin", one_goal="the two slices are the whole of it; there "
+                  "is no third thing this goal needs")
+        _task(e / "queue", "one")
+        # Specific to the FLOOR message: the same epic trips other lints in a bare
+        # fixture tree, and a substring match on its name would pass or fail on one
+        # of those instead of on the thing under test.
+        assert not any("epic thin: 1 task(s)" in x for x in _warns(Path(tmp)))
+
+
+def test_an_empty_one_goal_exempts_no_thin_epic_either():
+    """Checked the way the task's own is, or the field becomes a way to silence
+    the lint by writing nothing at all in it."""
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "thin", one_goal=" ")
+        _task(e / "queue", "one")
+        assert any("epic thin: 1 task(s)" in x for x in _warns(Path(tmp)))
+
+
 def test_a_backlog_epic_is_not_asked_what_it_covers():
     """A captured want has no criteria yet — they are chosen when it is PLANNED,
     and asking first only produces a guess the planning session argues with."""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "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/anthropic": "1.0.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/types": "1.0.0",
     "@jarvis/rpc": "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/ui": "0.1.0"
+    "@jarvis/data": "0.1.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",