@appchy/jarvis 0.1.84 → 0.1.86

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

@@ -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
 

package/harness/harness/task.py

@@ -16,7 +16,7 @@ from .scaffold import _check_kebab, _check_owner_ref, _check_priority, _check_un
 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
@@ -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(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>)")

package/harness/schema/work.config.schema.json

@@ -330,7 +330,7 @@
         "shard": {
           "type": "string",
           "default": ".work/coverage",
-          "description": "Where runners drop coverage shards. Gitignored on purpose — evidence is a fresh run, not a file somebody checked in."
+          "description": "Where runners drop coverage shards, repo-relative. Gitignored on purpose — evidence is a fresh run, not a file somebody checked in."
         }
       }
     },