@appchy/jarvis 0.1.48 → 0.1.49

package/dist/bin.js

@@ -9788,7 +9788,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 = "5b34716";
+var SHA = "f529917";
 var BUILT = "2026-09-08";
 var BUILD = SHA ?? "source";
 var BUILD_LABEL = `${SHA ? `${VERSION2} (${SHA}${BUILT ? ` ${BUILT}` : ""})` : `${VERSION2} (source)`}${IS_DEV ? " \u2014 development build" : ""}`;

package/harness/harness/lint.py

@@ -107,11 +107,22 @@ def _shape_lint(root: Path, s: dict) -> list:
 
     # 2 — a task spanning too many code regions is a version wearing a task
     #     costume: it cannot land as one coherent end-to-end slice.
+    #     ONE class is exempt and it is DECLARED rather than inferred: a task
+    #     carrying `one_goal:` has said in writing why its width is right, and
+    #     the sentence is the exemption. Some architectures have shapes that are
+    #     genuinely one goal across three regions — measured in `../mixbrix`
+    #     2026-09-09, six tasks read *work out a measurement (`dsp`), expose it
+    #     (`cli`), draw it (`daw`)* and five more *a node behaviour needing the
+    #     document, the engine and an atom* — and splitting those to satisfy a
+    #     counter produces three tasks nobody can finish alone. It is checked the
+    #     way `owner:` is: an EMPTY `one_goal:` exempts nothing, so the field
+    #     cannot be used to silence this without saying something.
     for t in active:
-        if len(t.code) >= TASK_REGION_CAP:
+        if len(t.code) >= TASK_REGION_CAP and not t.one_goal:
             warns.append(f"{t.name}: spans {len(t.code)} code regions "
                          f"({', '.join(t.code)}) — a task is ONE goal; at "
-                         f"{TASK_REGION_CAP}+ it is an epic, not a task")
+                         f"{TASK_REGION_CAP}+ it is an epic, not a task. If the "
+                         f"width IS one goal, say why in `one_goal:`")
 
     # 3 — an epic with no `covers:` moves no stated acceptance criterion, so
     #     nobody can tell when it is finished. Released epics have no epic.md
@@ -125,7 +136,17 @@ def _shape_lint(root: Path, s: dict) -> list:
     #     an `owner:` that resolves to nothing exempts nothing, so the field
     #     cannot be used to silence this by writing anything in it. An epic
     #     owned by a FEATURE is not exempt: it has criteria available.
-    for e in [e for v in s["versions"] for e in v.epics] + s["backlog_epics"]:
+    #
+    #     A BACKLOG epic is skipped entirely, and that is a second real class
+    #     rather than a loophole: it is a captured WANT, written down so it is not
+    #     lost, and which promises it moves is chosen when somebody PLANS it.
+    #     Asking first means guessing, and the guess is what the planning session
+    #     then argues with. Two in `../mixbrix` say so in their own text — *"NOT
+    #     PLANNED. This is a captured want, not a design."* `planned` cannot
+    #     express this: it means `epic.md` EXISTS (the release-archive flag), so it
+    #     is true of every backlog epic and the only way to reach the exemption
+    #     would be deleting the file holding the want.
+    for e in [e for v in s["versions"] for e in v.epics]:
         if not e.planned:
             continue
         if not e.covers:
@@ -149,8 +170,11 @@ def _shape_lint(root: Path, s: dict) -> list:
     #      the design happens ONCE for a whole goal; at one or two tasks there is
     #      no "whole goal", and the board fills with topics wearing epic costumes.
     #      Skip a DONE epic (`<v>/complete/`) — it is history, and an epic that
-    #      shipped two tasks was never the failure this catches.
-    for e in [e for v in s["versions"] for e in v.epics] + s["backlog_epics"]:
+    #      shipped two tasks was never the failure this catches. Skip a BACKLOG
+    #      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.
+    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())

package/harness/harness/model.py

@@ -70,6 +70,10 @@ class Task:
         self.priority = str(self.fm.get("priority", "P2")).strip()
         self.depends_on = as_list(self.fm.get("depends_on"))
         self.code = as_list(self.fm.get("code"))
+        # A task may DECLARE that its width is deliberate, with the reason.
+        # Read as a string rather than a flag: the region cap is answered by
+        # an argument, not by a `true` somebody typed to silence it.
+        self.one_goal = str(self.fm.get("one_goal", "")).strip()
         self.covers = as_list(self.fm.get("covers"))
         # `owner:` is canonical; `product:` is the pre-domain spelling still on
         # disk while the rename lands. One reader, so no consumer has to know.

package/harness/harness/tree.py

@@ -105,6 +105,13 @@ EPIC_FM_ORDER = ("created", "updated", "covers", "continues")
 # that cheap are exactly what a line budget deletes. What actually goes wrong —
 # a brief quietly becoming a competing plan — is caught by the artifact lint,
 # which looks for the FILES, not the size.
+# A task may ANSWER this rather than obey it, since 2026-09-09 (founder call):
+# `one_goal: "<why>"` in its frontmatter says the width is deliberate and states
+# the reason, and the lint then leaves it alone. The cap stayed at 3 rather than
+# moving to 4 on purpose — raising it silences the check everywhere and records
+# nothing, where a declared reason is readable by the next person and still lets
+# the warning bite for a task that has not thought about it. An EMPTY `one_goal:`
+# exempts nothing, the same way a dangling `owner:` exempts no epic.
 TASK_REGION_CAP = 3
 # The other end of the same rule, added 2026-08-02 (founder call), and it names a
 # measured failure too: the backlog had reached 14 epics of which NINE held two

package/harness/test_work.py

@@ -801,6 +801,64 @@ def test_shape_lint_flags_a_task_spanning_three_code_regions():
         assert not any("narrow: spans" in x for x in w)
 
 
+def test_a_task_that_says_its_width_is_deliberate_is_not_flagged():
+    """Some architectures have shapes that genuinely are one goal across three
+    regions. The exemption is a SENTENCE, so the reason is readable rather than a
+    flag somebody set."""
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "e")
+        _task(e / "queue", "wide", fm="priority: P1\ncode: [lesson, tools, web]\n"
+              "one_goal: the measurement, the verb that exposes it and the "
+              "drawing are one thing a person asks for\n")
+        assert not any("wide: spans" in x for x in _warns(Path(tmp)))
+
+
+def test_an_empty_one_goal_exempts_nothing():
+    """Checked the way `owner:` is. Otherwise the field is a way to silence the
+    lint by writing nothing at all in it."""
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _tree(tmp)
+        e = _epic(v, "e")
+        _task(e / "queue", "wide",
+              fm="priority: P1\ncode: [lesson, tools, web]\none_goal:\n")
+        assert any("wide: spans 3 code regions" 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."""
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        _tree(tmp)
+        _epic(root / "backlog", "you-reach-it-from-your-phone", covers="[]")
+        assert not any("you-reach-it-from-your-phone: no covers:"
+                       in w for w in _warns(root))
+
+
+def test_a_backlog_epic_is_not_held_to_the_task_floor():
+    """Same reason: a want nobody has planned has no slices, so "fold it into an
+    epic that fits" is advice about work being cut rather than a parked note."""
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        _tree(tmp)
+        _epic(root / "backlog", "it-sings-what-you-write", covers="[]")
+        assert not any("it-sings-what-you-write: 0 task(s)"
+                       in w for w in _warns(root))
+
+
+def test_a_version_epic_is_still_held_to_both():
+    """The narrowing is to the BACKLOG, not to the rules. An epic pulled into a
+    cut answers for its criteria and its slices as it always did."""
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        v = _tree(tmp)
+        _epic(v, "in-a-cut", covers="[]")
+        w = _warns(root)
+        assert any("in-a-cut: no covers:" in x for x in w), w
+        assert any("in-a-cut: 0 task(s)" in x for x in w), w
+
+
 def test_shape_lint_flags_a_thin_epic_below_the_task_floor():
     # The other end of the region cap: a one- or two-task epic is a topic wearing
     # an epic costume, and its epic.md degenerates into a second copy of the brief.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "description": "Jarvis — local AI coding assistant CLI",
   "private": false,
   "type": "module",
@@ -51,10 +51,10 @@
     "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/rpc": "1.0.0",
-    "@jarvis/board": "0.1.0",
     "@jarvis/types": "1.0.0",
     "@jarvis/typescript-config": "1.0.0",
     "@jarvis/vitest-config": "1.0.0"