@appchy/jarvis 0.1.82 → 0.1.84

package/harness/harness/architecture.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from . import ids
 from .tree import BACKLOG_END, BACKLOG_START, assets_dir, die, find_work_root, rel
-from .model import locate
+from .model import locate, missing
 from .registry import (DOMAIN_ORDER, _citation_counts, definition_sites,
                        domains_for_owner, hosts, locate_domain, locate_system,
                        scan_systems, systems_for_code)
@@ -248,7 +248,7 @@ def cmd_rules(args) -> int:
         die("usage: jarvis work rules --task <name>")
     t = locate(root, name)
     if not t:
-        die(f"no task named '{name}'")
+        die(missing(root, name))
     systems = systems_for_code(root, t.code) if t.code else []
     domains = domains_for_owner(root, t.owner)
     if not systems and not domains:

package/harness/harness/autonomy.py

@@ -28,7 +28,7 @@ from datetime import date
 from .tree import (BLOCKED, BUCKETS, DEFAULT_AUTONOMY_CEILING, TIER3_OWNERS,
                    TIER_MEANING, TIERS, die, find_work_root, rel)
 from .frontmatter import as_list, parse_frontmatter, rewrite_file
-from .model import locate, record_session, scan
+from .model import locate, missing, record_session, scan
 from .generate import _sync
 from . import events, links
 
@@ -129,7 +129,7 @@ def cmd_ask(args) -> int:
             "[--owner founder] [--durable]")
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     if task.in_backlog:
         die(f"'{name}' is in backlog — a backlog task has no status to park. "
             f"Pull it into a version first.")
@@ -195,7 +195,7 @@ def cmd_answer(args) -> int:
         die("usage: jarvis work answer <task> --choose \"…\"")
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     open_qs = _open_questions(task)
     if not open_qs:
         die(f"'{name}' has no open question — nothing to answer")

package/harness/harness/gate.py

@@ -33,7 +33,7 @@ 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
+from .model import locate, missing
 from .shard import _load_run
 from . import events, git, peers
 from .autonomy import tier_of
@@ -277,7 +277,7 @@ def _execute(root, name) -> tuple:
     _write_run(root, data)
 
     if name and not _record(root, name, results, ok, sha):
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     return results, ok, sha
 
 
@@ -530,7 +530,7 @@ def cmd_observed(args) -> int:
         die(f"--ac must look like 'AC-01' (got '{ac}')")
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     entry = f"{date.today().isoformat()}  {ac}  {saw}"
     md = task.folder / "task.md"
 

package/harness/harness/kickoff.py

@@ -23,7 +23,7 @@ assuming a fresh session infers it.
 """
 from pathlib import Path
 
-from .model import locate
+from .model import locate, missing
 from .tree import cli, die, find_work_root, rel
 
 #: `graph.mcp`, `session.mcp`, `session.tool`, `spine.*`, `instructions.skill` —
@@ -182,7 +182,7 @@ def cmd_kickoff(args) -> int:
     root = find_work_root()
     task = locate(root, args["name"])
     if not task:
-        die(f"no task named '{args['name']}' found")
+        die(missing(root, args["name"]))
     prompt = build_prompt(task, root, args.get("next"), args.get("watch"))
 
     # `--prompt-only` is the pipe. Everything else this command prints is

package/harness/harness/model.py

@@ -3,7 +3,7 @@ import re
 from datetime import date
 from pathlib import Path
 
-from .tree import backlog_dir, BUCKETS, DONE_TIER, PRIORITIES, RESERVED_MD
+from .tree import backlog_dir, BUCKETS, cli, DONE_TIER, PRIORITIES, RESERVED_MD
 from .frontmatter import as_list, parse_frontmatter, read_item, rewrite_file, title_of
 
 
@@ -298,8 +298,22 @@ def scan(root: Path) -> dict:
 
     return {"versions": versions, "backlog": backlog,
             "backlog_epics": backlog_epics}
-def locate(root: Path, name: str):
-    """Find a task by name anywhere. Returns a Task or None."""
+def locate(root: Path, name: str, filed: bool = False):
+    """Find a task by name. LIVE work by default; `filed=True` also searches the
+    cuts that have left the board.
+
+    `locate_version` has always searched all three homes, and says why: off the
+    board is not gone, and `path` keeps answering. That was never true of the work
+    INSIDE a cut — filing `00-somebody-new-can-start` made six tasks unresolvable
+    in one command, and between them they are named in 55 commit trailers, which
+    is the record a board write leaves.
+
+    **It is a parameter rather than the new default, and that is the whole care
+    here.** `locate` is also how every WRITE resolves its target, and what a
+    release delivered is a matter of record — a task inside a shipped cut must not
+    become movable. So reads opt in, and writes stay on live work and refuse by
+    saying where the work went rather than claiming it never existed.
+    """
     s = scan(root)
     for v in s["versions"]:
         for t in v.all_tasks():
@@ -308,7 +322,63 @@ def locate(root: Path, name: str):
     for t in s["backlog"]:
         if t.name == name:
             return t
+    if filed:
+        for v in scan_filed(root):
+            for t in v.all_tasks():
+                if t.name == name:
+                    return t
     return None
+
+
+def scan_filed(root: Path) -> list:
+    """Every cut that has LEFT the board — both `versions/complete/` and
+    `versions/archive/`.
+
+    Deliberately not `scan_shipped`, which reads `complete/` alone because it
+    answers "what has this repo delivered". A cut in `archive/` delivered nothing:
+    it left because its work moved elsewhere and there was no outcome it could
+    honestly claim. Two different questions, so two functions rather than one with
+    a flag that makes every caller state which meaning it wanted.
+    """
+    out = []
+    for home in ("complete", "archive"):
+        base = root / "versions" / home
+        if not base.is_dir():
+            continue
+        out += [Version(v) for v in sorted(base.iterdir())
+                if v.is_dir() and (v / "version.md").is_file()]
+    return out
+
+
+def filed_home(root: Path, name: str) -> str:
+    """Where a name went, as a sentence to append to a refusal — or `""`.
+
+    "no task named 'x' found" is the least useful true thing to say about work that
+    shipped last Thursday, and it is what every write said the moment a cut was
+    filed. The lookup that fails looks once more, in the cuts that left the board,
+    so the refusal can name the release instead of denying the work ever existed.
+    """
+    for v in scan_filed(root):
+        for t in v.all_tasks():
+            if t.name == name:
+                return (f" — it shipped in '{v.name}'"
+                        + (f" on {v.released}" if v.released else "")
+                        + ", and what a release delivered is a matter of record. "
+                        + f"Read it with `{cli()} path {name}`.")
+        for e in v.epics:
+            if e.name == name:
+                return (f" — that epic shipped in '{v.name}'"
+                        + (f" on {v.released}" if v.released else "") + ".")
+    return ""
+
+
+def missing(root: Path, name: str, noun: str = "task") -> str:
+    """The refusal for a name that does not resolve, saying where it went if it did.
+
+    One wording in one place: thirteen sites said "no task named 'x' found" and
+    every one of them was wrong in the same new way once cuts started being filed.
+    """
+    return f"no {noun} named '{name}' found{filed_home(root, name)}"
 def locate_version(root: Path, name: str):
     """Find a version by name. Looks in BOTH homes a cut leaves the board for —
     `versions/complete/` and `versions/archive/` — so a finished cut stays
@@ -347,9 +417,13 @@ def scan_shipped(root: Path) -> list:
     cuts.sort(key=lambda v: (v.order, v.name))
     cuts.sort(key=lambda v: v.released or "", reverse=True)
     return cuts
-def locate_epic(root: Path, name: str):
+def locate_epic(root: Path, name: str, filed: bool = False):
     """Find an epic by name anywhere — in a version or in the backlog. Names are
-    globally unique across tasks, epics and versions, so a name alone resolves."""
+    globally unique across tasks, epics and versions, so a name alone resolves.
+
+    `filed=True` reaches the cuts that have left the board, for the reason
+    `locate` takes the same parameter: a grouping that shipped is still a name
+    people cite, and `release` removes only the plan doc, never the folder."""
     s = scan(root)
     for v in s["versions"]:
         for e in v.epics:
@@ -358,6 +432,11 @@ def locate_epic(root: Path, name: str):
     for e in s["backlog_epics"]:
         if e.name == name:
             return e
+    if filed:
+        for v in scan_filed(root):
+            for e in v.epics:
+                if e.name == name:
+                    return e
     return None
 def epic_home(root: Path, epic: "Epic") -> str:
     """A human-readable home for an epic — `version '<v>'` or `backlog`."""

package/harness/harness/shift.py

@@ -25,7 +25,7 @@ from pathlib import Path
 
 from .tree import BLOCKED, BUCKETS, die, find_work_root, rel
 from .frontmatter import rewrite_file
-from .model import locate, record_session, scan
+from .model import locate, missing, record_session, scan
 from .generate import _sync
 from . import autonomy, events, links, peers
 # The ceiling is read through the MODULE, never bound in with `from … import`.
@@ -225,7 +225,7 @@ def cmd_drop(args) -> int:
     root = find_work_root()
     task = locate(root, args["name"])
     if not task:
-        die(f"no task named '{args['name']}' found")
+        die(missing(root, args["name"]))
     p = task.folder / CLAIM
     if p.is_file():
         p.unlink()

package/harness/harness/task.py

@@ -10,7 +10,7 @@ from . import peers, tree
 from . import links
 from .tree import BLOCKED, BUCKETS, die, find_work_root, rel
 from .frontmatter import as_list, parse_frontmatter, read_item, rewrite_file, split_frontmatter
-from .model import current_session_id, locate, locate_epic, locate_version, record_session, scan
+from .model import current_session_id, locate, locate_epic, locate_version, missing, record_session, scan
 from .registry import code_vocabulary
 from .scaffold import _check_kebab, _check_owner_ref, _check_priority, _check_unused, _scaffold_handoff, _scaffold_task
 from .epic import _bucketed, cmd_epic_move, epic_for_task
@@ -160,7 +160,7 @@ def cmd_place(args) -> int:
 
     task = locate(root, name)
     if not task:
-        die(f"no task or epic named '{name}' found")
+        die(missing(root, name, "task or epic"))
     if task.version == version.name:
         die(f"'{name}' is already in version '{version_name}'")
     if task.status == "complete":
@@ -236,7 +236,7 @@ def _to_backlog(root, name: str, args) -> int:
 
     task = locate(root, name)
     if not task:
-        die(f"no task or epic named '{name}' found")
+        die(missing(root, name, "task or epic"))
     if task.in_backlog:
         die(f"'{name}' is already in the backlog")
     if task.status == "complete":
@@ -283,7 +283,7 @@ def cmd_move(args) -> int:
 
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     if task.in_backlog:
         die(f"'{name}' is in backlog — pull it into a version first "
             f"(jarvis work place {name} --version <v>)")
@@ -308,13 +308,13 @@ def cmd_move(args) -> int:
     delivered = (args.get("delivered") or "").strip()
     not_included = (args.get("not-included") or args.get("not_included") or "").strip()
     if to == "complete":
-        missing = delivery_gate(delivered, not_included)
-        if missing:
+        unmet = delivery_gate(delivered, not_included)
+        if unmet:
             print(f"error: '{name}' cannot complete — the delivery line is "
                   f"incomplete:", file=sys.stderr)
-            for m in missing:
+            for m in unmet:
                 print(f"       · {m}", file=sys.stderr)
-            events.append(root, "gate-refused", name, why="; ".join(missing)[:300])
+            events.append(root, "gate-refused", name, why="; ".join(unmet)[:300])
             return 1
         if not report_gate(root, task, (args.get("accept") or "").strip(),
                            (args.get("owner") or "").strip()):
@@ -376,7 +376,7 @@ def cmd_handoff(args) -> int:
     name = args["name"]
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     if task.in_backlog or task.status == "queue":
         die(f"'{name}' is queued/backlog — handoff is for in-progress work "
             f"(pick it up first: jarvis work move {name} in-progress)")
@@ -392,7 +392,7 @@ def cmd_session(args) -> int:
     root = find_work_root()
     task = locate(root, args["name"])
     if not task:
-        die(f"no task named '{args['name']}' found")
+        die(missing(root, args["name"]))
     given = (args.get("id") or "").strip()
     label = None
     if given:
@@ -433,7 +433,7 @@ def cmd_plan(args) -> int:
     name = args["name"]
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
     if not args.get("file") and not PLANS_DIR:
         die("no `plans.dir` configured — pass `--file <path>`, or set "
             "`plans.dir` in .claude/work.config.json if this repo keeps a "
@@ -457,13 +457,19 @@ def cmd_plan(args) -> int:
     print(f"recorded plan '{path}' on '{task.name}'")
     return 0
 def cmd_path(args) -> int:
+    """Resolve any name to its folder — including work in a cut that has shipped.
+
+    This is the READ door, so it opts into the filed cuts at every tier.
+    `locate_version` already did; the two below did not, which is how filing one
+    cut made six tasks unresolvable while the cut holding them still answered.
+    """
     root = find_work_root()
     name = args["name"]
-    task = locate(root, name)
+    task = locate(root, name, filed=True)
     if task:
         print(task.folder)
         return 0
-    epic = locate_epic(root, name)
+    epic = locate_epic(root, name, filed=True)
     if epic:
         print(epic.folder)
         return 0

package/harness/test_work.py

@@ -2770,6 +2770,91 @@ def test_a_formatter_cannot_quietly_break_the_scaffolding_templates():
         f"reformatted them: {offenders[:5]}")
 
 
+def _filed_cut(tmp: str, home: str = "complete", released: str = "2026-09-11"):
+    """A cut that has LEFT the board, with one epic and one completed task in it."""
+    root = Path(tmp)
+    v = root / "versions" / home / "00-shipped"
+    task = v / "an-epic" / "complete" / "the-work"
+    task.mkdir(parents=True)
+    (root / "versions").mkdir(parents=True, exist_ok=True)
+    (root / "versions" / "backlog").mkdir(exist_ok=True)
+    (root / "README.md").write_text(f"# Work\n\n{tree.BACKLOG_START}\n{tree.BACKLOG_END}\n")
+    rel = f"released: {released}\n" if released else ""
+    (v / "version.md").write_text(
+        f"---\ncreated: 2026-08-01\norder: 0\noutcome: x\n{rel}archived: 2026-09-11\n---\n\n# Shipped\n")
+    (task / "task.md").write_text("---\npriority: P0\n---\n\n# The work\n")
+    return v
+
+
+def test_work_inside_a_filed_cut_still_answers_to_its_name():
+    """`locate_version` always searched all three homes — off the board is not gone,
+    and `path` keeps answering. The work INSIDE a cut never did.
+
+    Filing one cut made six tasks unresolvable in a single command, and between
+    them they were named in 55 commit trailers, which is the record a board write
+    leaves. Both homes, because a cut leaves the board for two different reasons.
+    """
+    for home in ("complete", "archive"):
+        with tempfile.TemporaryDirectory() as tmp:
+            _filed_cut(tmp, home)
+            with _work_dir(tmp) as root:
+                # Live resolution still sees only live work — `list`, the README
+                # and every lint depend on that and must not start seeing shipped
+                # work because reads were widened.
+                assert model.locate(root, "the-work") is None
+                assert model.locate_epic(root, "an-epic") is None
+                assert model.scan(root)["versions"] == []
+
+                found = model.locate(root, "the-work", filed=True)
+                assert found and found.name == "the-work", home
+                epic = model.locate_epic(root, "an-epic", filed=True)
+                assert epic and epic.name == "an-epic", home
+                assert model.locate_version(root, "00-shipped")
+
+
+def test_a_write_naming_shipped_work_says_where_it_went():
+    """The refusal is the point. Every write said "no task named 'x' found" the
+    moment a cut was filed — the least useful true thing to say about work that
+    shipped last Thursday, and indistinguishable from a typo."""
+    with tempfile.TemporaryDirectory() as tmp:
+        _filed_cut(tmp)
+        with _work_dir(tmp) as root:
+            said = model.missing(root, "the-work")
+            assert "shipped in '00-shipped'" in said, said
+            assert "2026-09-11" in said, said
+            # A name that genuinely does not exist keeps the plain answer: a
+            # suggestion appended to a typo is noise.
+            assert model.missing(root, "no-such-thing") == \
+                "no task named 'no-such-thing' found"
+
+
+def test_shipped_work_cannot_be_moved_however_it_is_named():
+    """Reads were widened; writes were not, and that is the whole care taken here.
+    What a release delivered is a matter of record."""
+    with tempfile.TemporaryDirectory() as tmp:
+        v = _filed_cut(tmp)
+        with _work_dir(tmp):
+            try:
+                task.cmd_move({"name": "the-work", "status": "in-progress"})
+                assert False, "shipped work must not be movable"
+            except SystemExit:
+                pass
+            assert (v / "an-epic" / "complete" / "the-work").is_dir()
+            assert not (v / "an-epic" / "in-progress").exists()
+
+
+def test_a_cut_in_the_archive_is_not_counted_as_delivered():
+    """`scan_filed` and `scan_shipped` answer different questions. A cut in
+    `archive/` left the board because its work moved and there was no outcome it
+    could honestly claim — counting it as delivered would be the lie archiving
+    exists to avoid."""
+    with tempfile.TemporaryDirectory() as tmp:
+        _filed_cut(tmp, "archive", released="")
+        with _work_dir(tmp) as root:
+            assert [v.name for v in model.scan_filed(root)] == ["00-shipped"]
+            assert model.scan_shipped(root) == []
+
+
 def test_the_completion_gate_refuses_and_says_which_gate_held():
     with tempfile.TemporaryDirectory() as tmp:
         v = _tree(tmp)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appchy/jarvis",
-  "version": "0.1.82",
+  "version": "0.1.84",
   "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/board": "0.1.0",
     "@jarvis/agents": "1.0.0",
+    "@jarvis/data": "0.1.0",
     "@jarvis/errors": "1.0.0",
+    "@jarvis/anthropic": "1.0.0",
+    "@jarvis/board": "0.1.0",
     "@jarvis/logger": "1.0.0",
     "@jarvis/rpc": "1.0.0",
-    "@jarvis/types": "1.0.0",
-    "@jarvis/data": "0.1.0",
     "@jarvis/typescript-config": "1.0.0",
-    "@jarvis/ui": "0.1.0",
-    "@jarvis/vitest-config": "1.0.0"
+    "@jarvis/types": "1.0.0",
+    "@jarvis/vitest-config": "1.0.0",
+    "@jarvis/ui": "0.1.0"
   },
   "scripts": {
     "dev": "tsx watch src/bin.ts start --foreground",