@appchy/jarvis 0.1.83 → 0.1.85

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/report.py

@@ -1,13 +1,10 @@
-import re
-import subprocess
 import sys
 from pathlib import Path
 
-from .tree import find_work_root, rel
-from .frontmatter import _eol, read_item, split_frontmatter, write_item
+from .tree import find_work_root
 from .model import Task, _ordered, scan, scan_shipped
 from .lint import lint_warnings
-from .generate import _regen_readme, _sync, settle_epic_tier
+from .generate import _regen_readme, settle_epic_tier
 from .align import (_align_acceptance, _align_agents, _align_citations,
                     _align_definitions, _align_domains, _align_hosts,
                     _align_ledger_index, _align_retired, _align_single_feature,
@@ -192,52 +189,3 @@ def cmd_align(args) -> int:
     print(f"\n  {len(warns)} warning(s) · {len(errors)} error(s){tail} · exit 0   "
           f"(report-only — the flip to blocking is its own task)")
     return 0
-def cmd_migrate_owner(args) -> int:
-    """Mechanical, one-way: `product:` becomes `owner:`, and the retired `infra`
-    sentinel becomes the `operations` domain. Skips files with uncommitted
-    changes unless --force: the tree is shared, and silently rewriting another
-    session's open edit is how a rename eats work that was never committed."""
-    root = find_work_root()
-    repo = root.parent
-    dirty = set()
-    try:
-        out = subprocess.run(["git", "status", "--porcelain"], cwd=repo,
-                             capture_output=True, text=True, check=True).stdout
-        for line in out.splitlines():
-            if len(line) > 3:
-                dirty.add((repo / line[3:].strip().strip('"')).resolve())
-    except Exception:
-        pass  # not a git repo, or git unavailable — migrate everything
-
-    def _is_dirty(md: Path) -> bool:
-        """Git reports an untracked DIRECTORY as the directory, not its files, so
-        a plain membership test misses `work/.../new-task/task.md` inside a folder
-        another session just created. Match the path or any parent."""
-        p = md.resolve()
-        return any(d == p or d in p.parents for d in dirty)
-
-    changed, skipped = [], []
-    for md in sorted(root.rglob("task.md")):
-        text = read_item(md)
-        fm, body = split_frontmatter(text)
-        if fm is None or not re.search(r"^product:", fm, re.MULTILINE):
-            continue
-        if _is_dirty(md) and not args.get("force"):
-            skipped.append(rel(md, root))
-            continue
-        # Only the KEY is rewritten — the value and its spacing are untouched, so
-        # 105 files change one word each instead of churning frontmatter layout.
-        new_fm = re.sub(r"^product:", "owner:", fm, flags=re.MULTILINE)
-        eol = _eol(text)
-        write_item(md, f"---{eol}{new_fm}{eol}---{eol}{body}")
-        changed.append(rel(md, root))
-
-    print(f"renamed product: -> owner: in {len(changed)} task.md")
-    if skipped:
-        print(f"SKIPPED {len(skipped)} with uncommitted changes (another session "
-              f"may be editing them) — rerun after they land, or pass --force:")
-        for f in skipped:
-            print(f"  {f}")
-    if changed:
-        _sync(root)
-    return 0

package/harness/harness/safety.py

@@ -106,10 +106,21 @@ def cmd_id_new(args) -> int:
     # Walk forward rather than retrying the same number: a loser in the race wants
     # the NEXT number, and a leftover lock from a crashed session must not wedge the
     # allocator forever.
+    #
+    # THE SCAN IS REPEATED UNDER THE CLAIM, and that is what makes the lock work at
+    # all. The scan above is slow and happens outside it; the lock is released the
+    # moment the heading is written. So a second session that scanned before the
+    # first one wrote, and claimed after it released, found the number free twice
+    # and both wrote the same `### D-nn`. Re-deriving here costs one extra tree read
+    # on the one command that allocates, and it is the only moment at which the
+    # question "is this number still free" can be asked and acted on atomically.
     for candidate in range(n, n + 1000):
-        if _claim(root, candidate):
+        if not _claim(root, candidate):
+            continue
+        if candidate >= _next_free(root):
             n = candidate
             break
+        _release(root, candidate)
     else:                                             # pragma: no cover — defensive
         die("could not claim an id after 1000 attempts — check .work/ids/")
 

package/harness/harness/shard.py

@@ -14,6 +14,12 @@ from pathlib import Path
 from typing import NamedTuple
 
 
+#: Where runners drop their shards, from `coverage.shard` — set by `config.apply()`,
+#: the same way `coverage.VERIFY` is. A module global rather than an import, because
+#: this module is imported by three readers and importing config from here would
+#: close a cycle.
+DIR = ".work/coverage"
+
 #: Precedence when several sites claim one criterion — the SAME rank both
 #: reporters already apply within a single runner. Anything unrecognised ranks
 #: below `passed`, so a shard that learns a new status can never silently
@@ -72,7 +78,7 @@ def _load_run(repo: Path) -> Run:
     runners separately is exactly the drift this module ended.
     """
     read = Run({}, {}, [], [], [])
-    d = repo / ".work" / "coverage"
+    d = repo / DIR
     if not d.is_dir():
         return read
     for p in sorted(d.glob("*.json")):

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`.
@@ -56,9 +56,15 @@ def read_claim(folder: Path):
     try:
         data = json.loads(p.read_text())
         expires = datetime.fromisoformat(str(data["expires"]))
-    except (OSError, ValueError, KeyError, json.JSONDecodeError):
-        return None
-    if expires <= _now():
+        # TypeError is in the list because the comparison below throws it, not the
+        # parse: a claim written without a timezone reads fine and then cannot be
+        # compared against an aware `now`. That raised out of a function whose whole
+        # contract is that an unreadable claim reads as absent — so a single
+        # malformed `.claim` took down every command that asks who holds an item,
+        # which is the fail-closed lock this was written to avoid being.
+        if expires <= _now():
+            return None
+    except (OSError, TypeError, ValueError, KeyError, json.JSONDecodeError):
         return None
     return data
 
@@ -225,7 +231,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,13 +10,13 @@ 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
 from .generate import _sync
 from .gate import delivery_gate, report_gate
-from .autonomy import derive_tier
+from .autonomy import _open_questions, derive_tier
 from . import events
 
 #: Where this repo keeps approved plan files, from `plans.dir` in config. None means
@@ -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":
@@ -276,14 +276,20 @@ def cmd_move(args) -> int:
     to = args["status"]
     if to not in BUCKETS:
         die(f"status must be one of {', '.join(BUCKETS)}")
-    if to == BLOCKED:
-        die(f"`move {name} blocked` is not how a task blocks — a blocked task "
-            f"without a recorded question is one nobody can unblock. Use "
-            f"`jarvis work ask {name} --question \"…\"`.")
 
     task = locate(root, name)
     if not task:
-        die(f"no task named '{name}' found")
+        die(missing(root, name))
+    # The rule is right and the test used to be the wrong one: it asked whether you
+    # had just called `ask`, rather than whether the item has a question nobody has
+    # answered. So a task carrying its question in its own frontmatter — showing in
+    # `needs` at that moment — could not be put back into `blocked/` after somebody
+    # moved it out, which is exactly what a session does when it picks one up and
+    # finds the question still open.
+    if to == BLOCKED and not _open_questions(task):
+        die(f"`move {name} blocked` is not how a task blocks — a blocked task "
+            f"without a recorded question is one nobody can unblock. Use "
+            f"`jarvis work ask {name} --question \"…\"`.")
     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 +314,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 +382,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 +398,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 +439,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 +463,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