@stylusnexus/work-plan 2026.6.21 → 2026.6.22

package/README.md

@@ -115,6 +115,8 @@ flowchart TB
 
 > **`brief` and `orient` annotate blocked issues with `⊘ blocked by #N`** — read-only, surfaced from GitHub's native dependency edges, nothing is written back. Cross-repo blockers show as `owner/repo#N`; same-repo duplicates of manually-declared blockers are deduplicated.
 
+> **A manual `blockers:` entry can be a free-text note, not just an issue number.** Normally a blocker is an issue number (`- 5550` or `- "#5550"`), which the VS Code dependency graph draws as a `blocks` edge. But it can also be prose (e.g. `- "gated on the cost go/no-go verdict"`) for when the blocker isn't a single issue. Free-text blockers still mark the track blocked and render as prose in `brief`/`orient` and the detail panel — but they don't draw a graph edge, so prefer an issue number when there is one.
+
 > **GitHub access is read-only by default, with three explicit, opt-in write actions.** Issue *data* always comes from read-only `gh` calls (`gh issue list`, `gh issue view`), and every routine write (frontmatter, status table, session log) goes to your local markdown files only. The three GitHub-*mutating* actions are all opt-in and gated: `plan-status --issues` **creates** a GitHub issue per partial plan (`gh issue create`, prompts before opening); `close-issue` (#305) **closes** an issue via `gh issue close` — for the common case where a PR merged to `dev` left its issue OPEN (GitHub auto-closes only from the default branch), with the VS Code viewer firing a mandatory "Close on GitHub? — cannot be undone" modal on every close; and `in-progress` (#271) **adds or removes** the `work-plan:in-progress` label on an issue, public-repo gated via the confirm-token flow. Nothing else touches GitHub state.
 
 ## Shared tracks
@@ -565,7 +567,7 @@ Every write verb the VS Code extension drives runs **without a TTY** — explici
 
 **The Plans view can write to plan-doc frontmatter — and only frontmatter.** Right-click a plan in the viewer → **Confirm Verdict…** / **Clear Confirmation** (writes `verdict_override`), **Acknowledge & Save to Doc** / **Clear Saved Acknowledgment** (writes `acknowledged`), or **Stamp Baseline — Watch for Drift** / **Clear Baseline** (writes `verdict_baseline`) drives the matching CLI write behind a mandatory modal that names the exact file and states the write touches only the doc's YAML frontmatter — never its prose body, checkboxes, or declared-file manifest. These are the only viewer-initiated writes to a plan doc, each touches one frontmatter key and nothing else, and on a public repo each additionally passes through the public-repo confirm modal above. The default **Acknowledge (stop flagging)** remains per-machine and writes nothing to git; **Acknowledge & Save to Doc** is the opt-in durable, shared variant. Everything else the Plans view does (scan, local acknowledge) remains read-only on git.
 
-Archived shipped plans (`plan-archive` / `plan-status --archive-shipped`) move into `archive/shipped/` and drop out of the live verdict buckets; the viewer surfaces them in a collapsed **"Archived (N)"** node per repo. Right-click a shipped plan → **Archive Plan…**, or a repo → **Archive shipped plans…**.
+Archived shipped plans (`plan-archive` / `plan-status --archive-shipped`) move into `archive/shipped/` and drop out of the live verdict buckets; the viewer surfaces them in a collapsed **"Archived (N)"** node per repo. Right-click a shipped plan → **Archive Plan…**, multi-select several (Cmd/Ctrl/Shift-click) → **Archive Plan…** to archive the batch behind one confirm, or a repo → **Archive shipped plans…** to sweep them all.
 
 ## Version
 

package/VERSION

@@ -1 +1 @@
-2026.06.21+4cab67a
+2026.06.22+f62c4cc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stylusnexus/work-plan",
-  "version": "2026.6.21",
+  "version": "2026.6.22",
   "description": "Track-aware daily work planning over GitHub issues. Shared tracks (git-synced .work-plan/ in each repo), AI clustering (group/auto-triage), VS Code viewer, Claude Code + Codex plugins. Pure Python stdlib.",
   "bin": {
     "work-plan": "bin/work-plan"

package/skills/work-plan/commands/plan_status.py

@@ -6,7 +6,7 @@ Manifest-less (prose) docs are flagged 👻 for the Phase 1b LLM pass.
 """
 import json
 import sys
-from datetime import date
+from datetime import date, timedelta
 from pathlib import Path
 
 from lib import config as config_mod
@@ -120,13 +120,41 @@ def _declared_paths_on_disk(decls, repo_root) -> list:
     return out
 
 
-def _evaluate(doc, repo_root, today, dead_days, stall_days) -> dict:
+def _committed_since_from_map(last_dates, plan_date, repo_root):
+    """`committed_since(rel)` served from the batched date map (#391), mirroring
+    manifest.score_manifest's default: with no plan date, degrade to a filesystem
+    existence check; otherwise "committed on/after plan_date" is `last-commit-date
+    >= plan_date - 1 day` (the same 1-day window `path_committed_since` widens to,
+    so same-day Modify commits still count)."""
+    if plan_date is None:
+        return lambda rel: (Path(repo_root) / rel).exists()
+    cutoff = plan_date - timedelta(days=1)
+
+    def committed_since(rel):
+        dt = last_dates.get(rel)
+        return dt is not None and dt.date() >= cutoff
+
+    return committed_since
+
+
+def _evaluate(doc, repo_root, today, dead_days, stall_days, last_dates=None) -> dict:
     text = _read(doc.path)
     decls = manifest.parse_declared_paths(text)
     pdate = manifest.plan_date_from_filename(doc.path.name)
-    score = manifest.score_manifest(decls, repo_root, pdate)
+    # `last_dates` is the batched {path: datetime} map precomputed in run() (#391)
+    # over every doc rel AND every declared path — one chunked git walk for the
+    # whole repo. When present, serve score_manifest's per-Modify-path
+    # `committed_since` (the real O(n) cost — 1434 git spawns on CritForge), the
+    # doc's own last-commit date, and the partial-staleness clock from it: zero
+    # git spawns in this loop. When absent (direct callers / tests), fall back to
+    # the per-path git calls so behavior is unchanged.
+    cs = _committed_since_from_map(last_dates, pdate, repo_root) if last_dates is not None else None
+    score = manifest.score_manifest(decls, repo_root, pdate, committed_since=cs)
     done, total_chk = manifest.count_checkboxes(text)
-    last_dt = git_state.path_last_commit_date(doc.rel, repo_root)
+    if last_dates is not None:
+        last_dt = last_dates.get(doc.rel)
+    else:
+        last_dt = git_state.path_last_commit_date(doc.rel, repo_root)
     last_d = last_dt.date() if last_dt else None
     if decls and manifest.out_of_tree_ratio(decls, repo_root) >= verdict_mod.FOREIGN_RATIO:
         v = verdict_mod.Verdict(
@@ -151,7 +179,11 @@ def _evaluate(doc, repo_root, today, dead_days, stall_days) -> dict:
     if v.label == "partial":
         on_disk = _declared_paths_on_disk(decls, repo_root)
         if on_disk:
-            manifest_dt = git_state.paths_last_commit_date(on_disk, repo_root)
+            if last_dates is not None:
+                ds = [last_dates[p] for p in on_disk if p in last_dates]
+                manifest_dt = max(ds) if ds else None
+            else:
+                manifest_dt = git_state.paths_last_commit_date(on_disk, repo_root)
             if manifest_dt is None:
                 stalled = True  # present on disk but never committed
             else:
@@ -462,7 +494,22 @@ def run(args: list) -> int:
         docs = [d for d in docs if d.kind == type_filter]
 
     stall_days = _resolve_stall_days(flags)
-    rows = [_evaluate(d, repo_root, today, dead_days, stall_days) for d in docs]
+    # Batch EVERY git date the scan needs — each doc's own rel plus every declared
+    # path (Modify paths drive score_manifest's committed_since, the real O(n)
+    # cost) — into one chunked git walk (#391), instead of a subprocess per path.
+    # This is what hung the Plans view on large repos (CritForge: 391 docs +
+    # 1434 declared paths = ~1800 git spawns → ~40s, now a handful of walks).
+    batch_paths = set()
+    for d in docs:
+        batch_paths.add(d.rel)
+        try:
+            for dp in manifest.parse_declared_paths(_read(d.path)):
+                batch_paths.add(dp.path)
+        except OSError:
+            pass
+    last_dates = git_state.paths_last_commit_dates(sorted(batch_paths), repo_root)
+    rows = [_evaluate(d, repo_root, today, dead_days, stall_days, last_dates)
+            for d in docs]
 
     if flags.get("--llm"):
         if flags.get("--apply"):

package/skills/work-plan/lib/blockers.py

@@ -0,0 +1,40 @@
+"""Track blocker normalization — the Python sibling of the viewer's blockerIssue().
+
+A `blockers:` frontmatter entry is usually an issue number, but it may also be a
+free-text note (e.g. "gated on the cost go/no-go verdict, needs #5548 telemetry").
+Consumers that render a blocker with a leading `#` must funnel it through
+`blocker_display` first, or a prose blocker prints as `#<sentence>`; the next-up
+gate must funnel it through `blocker_issue`, or a string-form ref ("5550") never
+matches the integer issue number it should exclude.
+"""
+
+import re
+
+_ISSUE_REF = re.compile(r"^\s*#?(\d+)\s*$")
+
+
+def blocker_issue(value):
+    """The issue number a blocker refers to, or None for free-text.
+
+    Mirrors the viewer's `blockerIssue`: a bare int, "5550", or "#5550" resolves
+    to the number; anything else (prose, even when it embeds a `#5550`) is
+    free-text. A leading-zero string like "007" is treated as free-text rather
+    than silently coerced to 7. `bool` is rejected (it is an int subclass).
+    """
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str):
+        m = _ISSUE_REF.match(value)
+        if m is not None:
+            digits = m.group(1)
+            if str(int(digits)) == digits:  # reject leading-zero "007"
+                return int(digits)
+    return None
+
+
+def blocker_display(value):
+    """How to show a blocker: `#N` for an issue ref, the prose itself otherwise."""
+    n = blocker_issue(value)
+    return f"#{n}" if n is not None else str(value)

package/skills/work-plan/lib/git_state.py

@@ -254,6 +254,92 @@ def paths_last_commit_date(rel_paths, repo_path: Path) -> Optional[datetime]:
         return None
 
 
+# A `%cI` commit line ("2026-06-19T10:00:00-07:00") vs a path line, so the
+# batched walk below can tell which is which without a sentinel (plan/spec doc
+# paths never look like an ISO timestamp).
+_ISO_DT_RE = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}")
+
+
+def _is_inrepo_rel(p: str) -> bool:
+    """True if `p` is a repo-relative path that stays inside the repo — safe to
+    pass to `git log -- <p>`. Rejects empty, absolute (`/…`), home (`~…`),
+    backslash, and any `..` that escapes the root (a foreign plan's off-tree
+    declared path). git would exit 128 on those, poisoning the batch."""
+    if not p or p[0] in "/~" or "\\" in p:
+        return False
+    depth = 0
+    for part in p.split("/"):
+        if part in ("", "."):
+            continue
+        if part == "..":
+            depth -= 1
+            if depth < 0:
+                return False
+        else:
+            depth += 1
+    return True
+
+
+def paths_last_commit_dates(rel_paths, repo_path: Path) -> dict:
+    """Most-recent commit datetime touching EACH of `rel_paths`, in a SINGLE
+    `git log` walk (#391) — vs one `path_last_commit_date` subprocess per path,
+    whose spawn overhead makes a many-doc scan O(docs) in process startups.
+
+    Returns {rel_path: datetime} for paths with at least one commit; a path
+    never committed is omitted. `git log` walks newest-first, so the first
+    commit that touches a path is its last touch. Never raises (None/bad-repo/
+    git-error all yield the partial-or-empty map).
+    """
+    out: dict = {}
+    if not rel_paths or not repo_path or not Path(repo_path).exists():
+        return out
+    # Drop off-tree paths (absolute, ~, ..-escape) BEFORE the git call: an
+    # out-of-repo pathspec makes `git log -- <…>` exit 128, which would poison
+    # the WHOLE chunk and silently lose every other path in it. Such paths can't
+    # have a commit in this repo anyway, so omitting them is correct (#391).
+    paths = [p for p in dict.fromkeys(rel_paths) if _is_inrepo_rel(p)]
+    if not paths:
+        return out
+    # Chunk the pathspec so a many-doc repo (1000s of declared paths) can't blow
+    # past the OS arg-length limit; each chunk is one `git log` walk.
+    for i in range(0, len(paths), _BATCH_CHUNK):
+        _collect_last_dates(paths[i:i + _BATCH_CHUNK], repo_path, out)
+    return out
+
+
+_BATCH_CHUNK = 400
+
+
+def _collect_last_dates(paths, repo_path, out: dict) -> None:
+    """One `git log --name-only` walk over `paths`; record each path's newest
+    commit datetime into `out`. core.quotePath=false → non-ASCII paths print raw
+    so they match the rel strings exactly."""
+    remaining = set(paths)
+    proc = _git(repo_path, "-c", "core.quotePath=false",
+                "log", "--format=%cI", "--name-only", "--", *paths)
+    if proc is None or proc.returncode != 0:
+        return
+    cur = None
+    for line in proc.stdout.splitlines():
+        if not line:
+            continue
+        if _ISO_DT_RE.match(line):
+            cur = line
+            continue
+        if cur and line in remaining:
+            try:
+                # %cI carries a numeric tz offset (often negative, e.g. -07:00).
+                # Parse it, then drop tzinfo for a consistent NAIVE datetime — so
+                # callers can compare/max() across paths (a +offset and a -offset
+                # mix would otherwise be aware-vs-naive). .date() is unchanged.
+                out[line] = datetime.fromisoformat(cur).replace(tzinfo=None)
+            except ValueError:
+                pass
+            remaining.discard(line)
+            if not remaining:
+                break
+
+
 def path_committed_since(rel_path: str, since: date, repo_path: Path) -> bool:
     """True if `rel_path` has any commit on/around `since` or later (a datetime.date).
 

package/skills/work-plan/lib/next_up.py

@@ -40,6 +40,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Iterable, Optional
 
+from lib.blockers import blocker_issue
 from lib.github_state import extract_priority, short_milestone
 
 PRIORITY_RANK = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
@@ -151,7 +152,10 @@ def suggest_next_up(
         List of issue numbers, highest-ranked first. Empty if nothing
         qualifies (e.g., everything closed or blocked).
     """
-    blockers = set(blocker_nums or [])
+    # Normalize blockers to issue numbers: a string-form ref ("5550"/"#5550")
+    # must still exclude issue 5550, and a free-text blocker resolves to None
+    # (dropped) so it harmlessly gates nothing.
+    blockers = {n for n in (blocker_issue(b) for b in (blocker_nums or [])) if n is not None}
     in_progress = set(in_progress_nums or [])
     # Resolve order: None → default preset; unknown names in list → skipped.
     effective_order = order if order is not None else PRESETS[DEFAULT_PRESET]

package/skills/work-plan/lib/render.py

@@ -1,5 +1,7 @@
 """Compose terminal output strings."""
 
+from lib.blockers import blocker_display
+
 
 def time_aware_framing(gap_seconds: int, current_hour: int, handoff_today: bool = True) -> str:
     """Adapt framing to gap-since-last-activity + hour."""
@@ -66,7 +68,9 @@ def render_track_row(t: dict) -> str:
     if t["blockers"]:
         for b in t["blockers"]:
             reason = b.get("reason", "manually flagged")
-            lines.append(f"    Blocker:    #{b['number']} — {reason}")
+            # blocker_display: `#N` for an issue ref, the prose verbatim for a
+            # free-text blocker (a raw `#{number}` would print `#<sentence>`).
+            lines.append(f"    Blocker:    {blocker_display(b['number'])} — {reason}")
     else:
         lines.append("    Blockers:   none")
 

package/skills/work-plan/tests/test_blockers.py

@@ -0,0 +1,47 @@
+"""Tests for lib.blockers — blocker_issue / blocker_display normalization."""
+
+import unittest
+
+from lib.blockers import blocker_issue, blocker_display
+
+
+class TestBlockerIssue(unittest.TestCase):
+    def test_bare_int_is_its_own_ref(self):
+        self.assertEqual(blocker_issue(5550), 5550)
+
+    def test_pure_id_strings_resolve(self):
+        self.assertEqual(blocker_issue("5550"), 5550)
+        self.assertEqual(blocker_issue("#5550"), 5550)
+        self.assertEqual(blocker_issue("  #5550 "), 5550)
+
+    def test_prose_is_free_text_even_with_embedded_ref(self):
+        # Must NOT extract 5550 — it's an active next_up item being described.
+        self.assertIsNone(
+            blocker_issue("#5550 selective routing is gated on the verdict, needs #5548")
+        )
+        self.assertIsNone(blocker_issue("waiting on design review"))
+
+    def test_leading_zero_is_free_text(self):
+        # "007" must not silently become issue 7.
+        self.assertIsNone(blocker_issue("007"))
+
+    def test_bool_and_empty_are_free_text(self):
+        self.assertIsNone(blocker_issue(True))
+        self.assertIsNone(blocker_issue(""))
+        self.assertIsNone(blocker_issue("#"))
+
+
+class TestBlockerDisplay(unittest.TestCase):
+    def test_issue_ref_gets_hash_prefix(self):
+        self.assertEqual(blocker_display(5550), "#5550")
+        self.assertEqual(blocker_display("#5550"), "#5550")
+        self.assertEqual(blocker_display("5550"), "#5550")
+
+    def test_free_text_shown_verbatim_without_hash(self):
+        prose = "gated on the cost go/no-go verdict"
+        self.assertEqual(blocker_display(prose), prose)
+        self.assertNotIn("#", blocker_display(prose))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_paths_last_commit_dates.py

@@ -0,0 +1,144 @@
+"""Batched last-commit-date lookup (#391): one `git log` walk yields the latest
+commit datetime per path, replacing N per-path subprocess spawns. Offline —
+`_git` is mocked, no real git invoked."""
+import io
+import json as _json
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib import git_state
+from commands import plan_status
+
+
+class _FakeProc:
+    def __init__(self, stdout, returncode=0):
+        self.stdout = stdout
+        self.returncode = returncode
+        self.stderr = ""
+
+
+# `git log --format=%cI --name-only` over three paths, newest-first. a.md last
+# touched in the newest commit; b.md too; c.md only in the older commit.
+LOG = (
+    "2026-06-19T10:00:00-07:00\n"
+    "\n"
+    "docs/plans/a.md\n"
+    "docs/plans/b.md\n"
+    "2026-06-10T09:00:00-07:00\n"
+    "\n"
+    "docs/plans/a.md\n"
+    "docs/plans/c.md\n"
+)
+
+
+class PathsLastCommitDatesTest(unittest.TestCase):
+    def test_single_call_maps_each_path_to_its_latest(self):
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", return_value=_FakeProc(LOG)) as g:
+            res = git_state.paths_last_commit_dates(
+                ["docs/plans/a.md", "docs/plans/b.md", "docs/plans/c.md"],
+                Path("/repo"))
+        g.assert_called_once()                       # ONE git spawn, not three
+        self.assertEqual(res["docs/plans/a.md"].date().isoformat(), "2026-06-19")
+        self.assertEqual(res["docs/plans/b.md"].date().isoformat(), "2026-06-19")
+        self.assertEqual(res["docs/plans/c.md"].date().isoformat(), "2026-06-10")
+
+    def test_batched_call_uses_name_only_walk(self):
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", return_value=_FakeProc(LOG)) as g:
+            git_state.paths_last_commit_dates(["docs/plans/a.md"], Path("/repo"))
+        args = g.call_args.args
+        self.assertIn("--name-only", args)
+        self.assertIn("log", args)
+        self.assertIn("docs/plans/a.md", args)       # path passed through
+
+    def test_uncommitted_path_omitted(self):
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", return_value=_FakeProc(LOG)):
+            res = git_state.paths_last_commit_dates(
+                ["docs/plans/a.md", "docs/plans/never.md"], Path("/repo"))
+        self.assertIn("docs/plans/a.md", res)
+        self.assertNotIn("docs/plans/never.md", res)  # no commit → omitted
+
+    def test_empty_input_no_git_call(self):
+        with mock.patch("lib.git_state._git") as g:
+            self.assertEqual(git_state.paths_last_commit_dates([], Path("/repo")), {})
+        g.assert_not_called()
+
+    def test_git_failure_returns_empty(self):
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", return_value=_FakeProc("", returncode=128)):
+            self.assertEqual(
+                git_state.paths_last_commit_dates(["docs/plans/a.md"], Path("/repo")), {})
+
+    def test_offtree_paths_filtered_before_git(self):
+        # An off-tree pathspec (../, absolute, ~) makes `git log` exit 128 and
+        # poison the whole chunk; they must be dropped before the call (#391).
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", return_value=_FakeProc(LOG)) as g:
+            res = git_state.paths_last_commit_dates(
+                ["docs/plans/a.md", "../escape.md", "/abs/x.md", "~/h.md",
+                 "a/../../b.md"], Path("/repo"))
+        passed = g.call_args.args
+        self.assertIn("docs/plans/a.md", passed)
+        for bad in ("../escape.md", "/abs/x.md", "~/h.md", "a/../../b.md"):
+            self.assertNotIn(bad, passed)        # never reaches git
+        self.assertIn("docs/plans/a.md", res)
+
+    def test_all_offtree_no_git_call(self):
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git") as g:
+            self.assertEqual(
+                git_state.paths_last_commit_dates(["../x", "/y"], Path("/repo")), {})
+        g.assert_not_called()
+
+    def test_none_proc_returns_empty(self):
+        with mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state._git", return_value=None):
+            self.assertEqual(
+                git_state.paths_last_commit_dates(["docs/plans/a.md"], Path("/repo")), {})
+
+
+class PlanStatusBatchesTest(unittest.TestCase):
+    """run() must use the ONE batched call, not a per-doc git spawn (#391)."""
+
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/plans").mkdir(parents=True)
+        # A Modify path is what drove the per-path committed_since git spawns.
+        (root / "docs/plans/a.md").write_text(
+            "# A\n\n- Create: `src/a.ts`\n- Modify: `src/x.ts`\n")
+        (root / "docs/plans/b.md").write_text("# B\n\n- Create: `src/b.ts`\n")
+        return root
+
+    def test_run_batches_one_call_no_per_doc_spawn(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            with mock.patch("commands.plan_status.Path.cwd", return_value=root), \
+                 mock.patch("commands.plan_status.git_state.paths_last_commit_dates",
+                            return_value={}) as batch, \
+                 mock.patch("commands.plan_status.git_state.path_last_commit_date") as per, \
+                 mock.patch("commands.plan_status.git_state.paths_last_commit_date") as per_multi:
+                buf = io.StringIO()
+                with redirect_stdout(buf):
+                    rc = plan_status.run(["--json"])
+            self.assertEqual(rc, 0)
+            batch.assert_called_once()      # one git walk for all docs + declared paths
+            per.assert_not_called()         # no per-doc last-commit spawn
+            per_multi.assert_not_called()   # no per-partial staleness spawn
+            # committed_since is served from the injected map (run() passes a
+            # closure to score_manifest), so its per-Modify-path git fallback
+            # never runs — that was the real O(n) cost.
+            docs = _json.loads(buf.getvalue())["docs"]
+            self.assertEqual(len(docs), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_plan_status_archive.py

@@ -25,9 +25,17 @@ class ArchiveTest(unittest.TestCase):
         return root
 
     def _run(self, root, args, mv_ok=True):
-        # stale last-commit (well beyond DEAD_DAYS) so the absent-file plan is dead
+        # stale last-commit (well beyond DEAD_DAYS) so the absent-file plan is dead.
+        # run() now reads the batched paths_last_commit_dates map (#391); mock its
+        # .get to return the stale date for every doc (path_last_commit_date is the
+        # fallback path, mocked too).
+        stale = datetime(2026, 1, 1)
+        batched = mock.MagicMock()
+        batched.get.return_value = stale
         with mock.patch("commands.plan_status.git_state.path_last_commit_date",
-                        return_value=datetime(2026, 1, 1)), \
+                        return_value=stale), \
+             mock.patch("commands.plan_status.git_state.paths_last_commit_dates",
+                        return_value=batched), \
              mock.patch("commands.plan_status.Path.cwd", return_value=root), \
              mock.patch("commands.plan_status.git_state.git_mv",
                         return_value=mv_ok) as mv, \