@mjasnikovs/pi-task 0.18.40 → 0.18.42

package/README.md

@@ -63,7 +63,7 @@ A whole plan — `/task-auto` splits it into an ordered task list and runs each
 | `/task-resume [id]` | Resume the most recent (or named) unfinished task. |
 | `/task-cancel` | Cancel the running task (soft-terminal — still resumable). |
 | `/task-auto <feature>` | Plan a feature into a task list and run each title through `/task` in order (resumable). |
-| `/task-auto-resume` | Resume the active `/task-auto` run at the next unfinished task. |
+| `/task-auto-resume [--unattended]` | Resume the active `/task-auto` run at the next unfinished task. `--unattended` is the boot-hook form: in-flight runs only. |
 | `/task-auto-cancel` | Stop the `/task-auto` loop after the current task (still resumable). |
 | `/task-config` | Toggle pi-task settings in an editor dialog: remote server, compress reasoning, auto-commit, orientation, verify work, enforce guidelines, command timeout, stream watchdog, and the extension whitelist for child sessions. |
 | `/remote` | Show the QR code & URLs for the web view (`/remote stop` to stop). Answer grill questions, start tasks, and watch progress from your phone. |
@@ -100,6 +100,7 @@ A real feature is usually several tasks, not one. `/task-auto` is a thin planner
 - **Clarify first.** It asks the few clarifying questions whose answers change how the feature splits, then decomposes the answers into an ordered list of task titles written to `.pi-tasks/TASK_AUTO_NNNN.md`.
 - **Sequential, blocking.** Each title runs through `/task` to a spec, the spec is implemented, and the loop waits for that to finish before starting the next title. No overlap.
 - **Crash- and cancel-safe.** Progress is the markdown checkboxes in the AUTO file. `/task-auto-resume` (no id) automatically picks up the active run at the first unchecked title. If a title's `/task` run fails, the loop stops and leaves the run resumable.
+- **Restart-safe, unattended.** `/task-auto-resume --unattended` is the same resume with no human in the loop — for a boot hook or a container entrypoint. It continues **in-flight** runs only: a `failed` or `cancelled` run stopped for a reason a power cycle does not clear, so it is reported and left alone rather than re-entered against the same wall. Either way the resume banner states exactly what it measured — how long since the run last wrote, and that nothing was rolled back — and attributes no cause, because a stopped host, a hung child, and a slow task look identical from here. Pair it with `restart: unless-stopped` on long-running containers and an overnight outage costs minutes instead of the whole night.
 - **One commit per task.** When **auto-commit** is on (the default) and you're in a git repo, the working tree is snapshotted into a single commit after each title passes, so the run produces a clean per-task history. It's best-effort: outside a repo, with nothing to commit, or on any git error, the loop reports the reason and keeps going. Toggle it in `/task-config`.
 
 ## Remote — drive a task from your phone

package/dist/task/auto-io.d.ts

@@ -1,3 +1,4 @@
+import type { AutoResumeCandidate } from './resume-gap.js';
 export interface TaskEntry {
     index: number;
     title: string;
@@ -58,5 +59,11 @@ export declare function stampTaskInProgress(cwd: string, id: string, index: numb
  * next step by "first unchecked" rather than by a cached index.
  */
 export declare function insertTaskAfter(cwd: string, id: string, afterIndex: number, title: string): Promise<boolean>;
-/** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
+/**
+ * Find the most-recently-updated resumable TASK_AUTO_* file, with the state and
+ * last-write time the resume banner reports (see resume-gap.ts). Null when there
+ * is nothing resumable.
+ */
+export declare function findResumableAutoDetailed(cwd: string): Promise<AutoResumeCandidate | null>;
+/** Id-only form of {@link findResumableAutoDetailed}. */
 export declare function findResumableAuto(cwd: string): Promise<string | null>;

package/dist/task/auto-io.js

@@ -194,8 +194,12 @@ export async function insertTaskAfter(cwd, id, afterIndex, title) {
     await setTaskSection(cwd, id, 'tasks', lines.join('\n'));
     return true;
 }
-/** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
-export async function findResumableAuto(cwd) {
+/**
+ * Find the most-recently-updated resumable TASK_AUTO_* file, with the state and
+ * last-write time the resume banner reports (see resume-gap.ts). Null when there
+ * is nothing resumable.
+ */
+export async function findResumableAutoDetailed(cwd) {
     await ensureTasksDir(cwd);
     const entries = await fsp.readdir(tasksDir(cwd));
     const candidates = [];
@@ -211,12 +215,16 @@ export async function findResumableAuto(cwd) {
             if (!RESUMABLE_STATES.includes(fm.state))
                 continue;
             const st = await fsp.stat(path.join(tasksDir(cwd), f));
-            candidates.push({ id: m[1], mtime: st.mtimeMs });
+            candidates.push({ id: m[1], state: fm.state, lastWriteMs: st.mtimeMs });
         }
         catch {
             /* skip unreadable */
         }
     }
-    candidates.sort((a, b) => b.mtime - a.mtime);
-    return candidates.length > 0 ? candidates[0].id : null;
+    candidates.sort((a, b) => b.lastWriteMs - a.lastWriteMs);
+    return candidates.length > 0 ? candidates[0] : null;
+}
+/** Id-only form of {@link findResumableAutoDetailed}. */
+export async function findResumableAuto(cwd) {
+    return (await findResumableAutoDetailed(cwd))?.id ?? null;
 }

package/dist/task/auto-orchestrator.js

@@ -14,7 +14,8 @@ import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js'
 import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT, DECOMPOSE_COVERAGE_PROMPT } from './auto-prompts.js';
 import { GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT } from './prompts.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
-import { allocateAutoId, buildAutoBody, parseDecomposeList, parseCoverageVerdict, parseTaskList, checkOffTask, stampTaskInProgress, insertTaskAfter, findResumableAuto } from './auto-io.js';
+import { allocateAutoId, buildAutoBody, parseDecomposeList, parseCoverageVerdict, parseTaskList, checkOffTask, stampTaskInProgress, insertTaskAfter, findResumableAutoDetailed } from './auto-io.js';
+import { decideResume } from './resume-gap.js';
 import { drainRepairQueue, mergeRepairCandidates, planHasRepairFor, parseRepairTitleFile, buildRepairTitle, buildRepairScopeFence, extractFailingCommand } from './root-cause-repair.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
 import { readTextFile } from '../shared/fs-text.js';
@@ -39,6 +40,7 @@ import { isYoloMode, yoloPickAnswer, yoloFinalGateChoice, YOLO_STAMP } from './y
 import { configureResearchRun, resumeResearchRun } from '../workers/research-cache.js';
 import { CONTRACT_EXTRACT_PROMPT, parseContractLines, keepGroundedContracts, appendContracts } from './contracts.js';
 import { reconcileTitleSources } from './decompose-fidelity.js';
+import { mandatesTestsInSameChange, rewriteBatchTestPlan } from './batch-test-task.js';
 import { REQUIREMENT_EXTRACT_PROMPT, COVERAGE_MAP_PROMPT, parseRequirementLines, keepGroundedRequirements, capRequirements, enumerateObligationPassages, uncoveredPassages, extractionRetryHint, parseCoverageMap, accountCoverage, isCrossCuttingRequirement, appendCarriedRequirements, buildRequirementsLedger } from './requirements.js';
 import { decideAdoption, groundedCoverage } from './coverage-loop.js';
 import { findSpecDanglingArtifacts, titlesCoverArtifact, danglingMissingText, danglingCarryText } from './artifact-closure.js';
@@ -590,8 +592,18 @@ export async function planAuto(ctx, cwd, feature, deps) {
     catch {
         // best-effort channel
     }
+    // Tests-in-the-same-change cadence (mx5 run 14, PROMPT item 6): when the
+    // decisions mandate it, a whole-project batch test task contradicts them —
+    // run 14 shipped one anyway (TASK_0037, 4.7h, yolo-accepted FAIL) because
+    // decompose mirrors the spec's milestone shape. The decisions channel
+    // OVERRIDES the spec doc, so this resolves toward the decision without asking.
+    const noBatchTests = mandatesTestsInSameChange(clarifications, featureForModel);
+    if (noBatchTests) {
+        logPlanDebug(cwd, 'decisions mandate tests-in-the-same-change — batch test tasks are banned '
+            + 'from this plan (prompt rule + host rewrite)');
+    }
     // decompose
-    const decomposePrompt = AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications, buildRequirementsLedger(reqEntries));
+    const decomposePrompt = AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications, buildRequirementsLedger(reqEntries), noBatchTests);
     // Parse + FIDELITY RECONCILIATION (mx5 run 11, goal B): ground each title's
     // [source: "…"] citation against the doc, strip the clause, and re-attach any
     // `+`-joined constraint fragment the paraphrased title dropped (the silently
@@ -606,7 +618,18 @@ export async function planAuto(ctx, cwd, feature, deps) {
                     .map(r => ` [task ${r.index + 1}: ${r.fragments.join(', ')}]`)
                     .join(''));
         }
-        return plan.titles;
+        // Batch-test ban (item 6): drop or scope a whole-project "write all the
+        // tests" task. Identity unless the cadence decision is present, and the
+        // sweep replacement re-grounds every requirement the drop would cost — so
+        // planned coverage cannot fall (run 12's lesson).
+        const debatched = rewriteBatchTestPlan(plan.titles, clarifications, featureForModel, reqEntries.map(e => e.quote), isCrossCuttingRequirement);
+        for (const a of debatched.actions) {
+            logPlanDebug(cwd, `batch test task ${a.kind} (tests-in-same-change decision): "${a.title}"`
+                + (a.kind === 'scoped' ?
+                    ` → scoped sweep over ${a.orphaned.length} orphaned requirement(s)`
+                    : ' — every requirement it touched is owned by another task'));
+        }
+        return debatched.titles;
     };
     const listRaw = await deps.runChild('auto-decompose', 'read', decomposePrompt);
     let planTitles = parsePlan(listRaw);
@@ -1571,15 +1594,22 @@ async function handleTaskAuto(args, ctx) {
         disarmCancelListener();
     }
 }
-async function handleTaskAutoResume(_args, ctx) {
+async function handleTaskAutoResume(args, ctx) {
     await ctx.waitForIdle();
     const cwd = ctx.cwd;
-    const id = await findResumableAuto(cwd);
-    if (!id) {
-        ctx.ui.notify('No resumable /task-auto run.', 'info');
+    // `--unattended` is the boot-hook path: no human decided to continue this
+    // run, so it resumes in-flight states only and refuses the rest by name.
+    const unattended = /(^|\s)--unattended(\s|$)/.test(args);
+    const candidate = await findResumableAutoDetailed(cwd);
+    const decision = decideResume(candidate, Date.now(), unattended);
+    ctx.ui.notify(decision.banner, decision.level);
+    // An unattended refusal happens with nobody watching the terminal — the
+    // remote view is the only surface that will still be there in the morning.
+    if (unattended)
+        publishLifecycleNotice(decision.banner, decision.level);
+    if (!decision.resume || !candidate)
         return;
-    }
-    ctx.ui.notify(`Resuming ${id}…`, 'info');
+    const id = candidate.id;
     await updateTaskFrontMatter(cwd, id, { state: 'in_progress' });
     autoRunning = true;
     armTerminalCancel(ctx);
@@ -1648,7 +1678,8 @@ export function registerTaskAuto(pi) {
         handler: handleTaskAuto
     });
     registerBridgeCommand(pi, 'task-auto-resume', {
-        description: 'Resume the active /task-auto run.',
+        description: 'Resume the active /task-auto run. Usage: /task-auto-resume [--unattended] '
+            + '(--unattended is for boot hooks: in-flight runs only, never a failed one).',
         handler: handleTaskAutoResume
     });
     registerBridgeCommand(pi, 'task-auto-cancel', {

package/dist/task/auto-prompts.d.ts

@@ -12,8 +12,12 @@ export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string) =>
  * belt): the spec's obligations ride into decompose explicitly, so mirroring the
  * spec's own milestone/section structure cannot silently discharge them. '' ⇒
  * the prompt is unchanged.
+ *
+ * `noBatchTests` adds the anti-batch-test rule (batch-test-task.ts) — emitted ONLY
+ * when the decisions mandate tests-in-the-same-change, so every other run sees the
+ * prompt it always saw. It is the belt; the host-side rewrite is the lever.
  */
-export declare const AUTO_DECOMPOSE_PROMPT: (feature: string, clarifications: string, requirementsLedger?: string) => string;
+export declare const AUTO_DECOMPOSE_PROMPT: (feature: string, clarifications: string, requirementsLedger?: string, noBatchTests?: boolean) => string;
 /**
  * Coverage triage: judge whether a decomposed task list covers the whole
  * feature. Guards the plan — the highest-leverage artifact in /task-auto —

package/dist/task/auto-prompts.js

@@ -3,6 +3,7 @@
  * LIST only; all research/spec depth is /task's job, run per-title later.
  */
 import { DECOMPOSE_SOURCE_RULE } from './decompose-fidelity.js';
+import { DECOMPOSE_NO_BATCH_TESTS_RULE } from './batch-test-task.js';
 /**
  * Clarify: asks ONE question at a time. Output MUST match parseClarifyList — a
  * single numbered question followed by a "SUGGESTED: <default>" line, an optional
@@ -71,8 +72,12 @@ NONE`;
  * belt): the spec's obligations ride into decompose explicitly, so mirroring the
  * spec's own milestone/section structure cannot silently discharge them. '' ⇒
  * the prompt is unchanged.
+ *
+ * `noBatchTests` adds the anti-batch-test rule (batch-test-task.ts) — emitted ONLY
+ * when the decisions mandate tests-in-the-same-change, so every other run sees the
+ * prompt it always saw. It is the belt; the host-side rewrite is the lever.
  */
-export const AUTO_DECOMPOSE_PROMPT = (feature, clarifications, requirementsLedger = '') => `Split this feature into an ordered list of implementation tasks. Each task
+export const AUTO_DECOMPOSE_PROMPT = (feature, clarifications, requirementsLedger = '', noBatchTests = false) => `Split this feature into an ordered list of implementation tasks. Each task
 will be handed, by its title, to a separate pipeline that does its own research
 and writes its own spec — so here you produce TITLES ONLY, not specs.
 
@@ -94,7 +99,7 @@ RULES:
   none. These are explicit user choices that may contradict the referenced spec
   doc; phrase them as imperative directives (e.g. "use Bun's built-in bundler, do
   not add vite"). Do NOT invent decisions — only restate ones from CLARIFICATIONS.
-${DECOMPOSE_SOURCE_RULE}
+${DECOMPOSE_SOURCE_RULE}${noBatchTests ? `\n${DECOMPOSE_NO_BATCH_TESTS_RULE}` : ''}
 - Output the checkbox list and NOTHING else (no preamble, no numbering).`;
 /**
  * Coverage triage: judge whether a decomposed task list covers the whole

package/dist/task/batch-test-task.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Does the decisions/spec text mandate tests-in-the-same-change?
+ *
+ * Scans sentence by sentence and requires BOTH signals in the SAME sentence, so
+ * a testing section that happens to sit near an unrelated "don't defer" line
+ * cannot trigger the ban. `decisions` is checked first and alone is sufficient;
+ * the spec is scanned too because run 14's cadence rule is stated in §10 of the
+ * doc and only echoed into the decisions channel.
+ */
+export declare function mandatesTestsInSameChange(decisions: string, spec?: string): boolean;
+/**
+ * Indices of titles that are whole-project BATCH test tasks.
+ *
+ * Three conditions must all hold — the title's deliverable is tests, its scope is
+ * the whole project, and it is not test INFRASTRUCTURE. A per-feature task that
+ * carries "+ tests" never matches (its head names the feature), which is the
+ * point: those are the cadence the decision asks for.
+ */
+export declare function findBatchTestTitles(titles: string[]): number[];
+/**
+ * The spec's own coverage source — the command whose report scopes the sweep.
+ *
+ * Only backticked spans are considered, so the result is a command the spec
+ * actually writes down rather than a phrase inferred from prose; a span carrying
+ * a coverage flag wins over a plain test run. Falls back to a generic phrase when
+ * the spec names no command, which keeps the sweep title well-formed either way.
+ */
+export declare function coverageSourceFromSpec(spec: string): string;
+/**
+ * The scoped replacement: a gap-filling sweep, bounded by what the coverage
+ * source reports and by the requirements that lost their only owner. It states
+ * the ban explicitly, because the child that receives this title sees nothing
+ * else.
+ */
+export declare function buildSweepTitle(orphaned: string[], coverageSource: string): string;
+export interface BatchTestAction {
+    /** Index of the offending title in the INPUT list. */
+    index: number;
+    /** The offending title, verbatim. */
+    title: string;
+    kind: 'dropped' | 'scoped';
+    /** The sweep title that replaced it (`kind: 'scoped'` only). */
+    replacement?: string;
+    /** Requirement quotes that no OTHER title grounds — what the sweep must cover. */
+    orphaned: string[];
+}
+export interface BatchTestRewrite {
+    titles: string[];
+    actions: BatchTestAction[];
+}
+/**
+ * Rewrite a decomposed plan so it carries no whole-project batch test task when
+ * the decisions mandate tests-in-the-same-change.
+ *
+ * No mandate, or no batch title ⇒ the plan is returned untouched (identity), so
+ * every non-cadence run behaves exactly as before.
+ *
+ * With a mandate, ALL batch titles are removed at once before coverage is
+ * re-measured — otherwise two batch tasks would each mask the other's orphans and
+ * both would look droppable. The orphaned set is then whatever grounded coverage
+ * the removal costs; it is non-empty only when no other task's title claims that
+ * requirement, and it becomes the sweep's scope. At most ONE sweep is emitted (in
+ * the first batch title's position, so plan order is preserved).
+ */
+export declare function rewriteBatchTestPlan(titles: string[], decisions: string, spec: string, requirementQuotes: string[], isCrossCutting: (quote: string) => boolean): BatchTestRewrite;
+/**
+ * The decompose-prompt rule (the belt; the host rewrite above is the lever).
+ * Emitted ONLY when the decisions mandate the cadence, so ordinary runs see the
+ * prompt they always saw. Kept next to the detector so the two cannot drift.
+ */
+export declare const DECOMPOSE_NO_BATCH_TESTS_RULE: string;

package/dist/task/batch-test-task.js

@@ -0,0 +1,320 @@
+/**
+ * batch-test-task — ban the whole-project "write all the tests" task when the
+ * DECISIONS channel mandates tests-in-the-same-change (mx5 run 14, PROMPT item 6).
+ *
+ * The failure this closes: run 14's plan contained
+ *
+ *   TASK_0037  "Write component and page tests — Playwright CT tests with
+ *               screenshot baselines for all components and pages"
+ *
+ * — ~4.7h, the worst active-time task of the run, ended in a yolo-accepted verify
+ * FAIL with a frozen-config violation — while the very decision carried ON THAT
+ * TITLE said the opposite:
+ *
+ *   "a test lands *as fast as possible* — in the same change — as each new route
+ *    or React component/page. No route or component is considered done until its
+ *    test exists and passes. Don't batch testing to the end of a milestone."
+ *
+ * Decompose did not invent the shape: the spec's own §10/§12 structure induced it,
+ * and decompose mirrors the spec. So the conflict is SPEC-INTERNAL (the spec's
+ * milestone shape vs the spec's own cadence rule), and the decisions channel
+ * OVERRIDES the spec doc by definition — the same precedence the task titles
+ * already state. Resolve toward the decision; never ask the user.
+ *
+ * The mechanism is a deterministic post-decompose rewrite (applied on EVERY
+ * decompose output, like fidelity reconciliation), plus a conditional prompt rule
+ * as the belt. Only the batch-EVERYTHING shape is banned — coverage is never
+ * nuked (run 12's lesson). Which of the two outcomes fires is decided by
+ * `groundedCoverage`, not by wording:
+ *
+ *   • the batch title grounds NO requirement that survives its removal ⇒ every
+ *     requirement it touched is owned by some other task, the per-change cadence
+ *     already covers the work, and the task is DROPPED;
+ *   • it is the ONLY title grounding some requirement(s) ⇒ dropping it would
+ *     reduce planned coverage, so it is REPLACED by a scoped sweep that names
+ *     exactly those orphaned requirements and points at the spec's own coverage
+ *     source ("fill the gaps <that command> reports"), never "test everything".
+ *
+ * Because the replacement's owned-set is computed from the same groundedCoverage
+ * the monotonic adoption guard uses, total planned coverage cannot fall.
+ */
+import { groundedCoverage } from './coverage-loop.js';
+/**
+ * Sentences that MANDATE tests landing with the change they cover. Deliberately
+ * narrow: a spec that merely REQUIRES tests ("every route has tests") does not
+ * ban a batch task — only an explicit cadence/anti-batch directive does.
+ */
+const SAME_CHANGE_RE = /\bin the same (?:change|commit|pr|patch|diff|task|step)\b|\b(?:do ?n['’]?t|do not|never|no)\s+(?:batch|defer|postpone|save|leave)\b|\bnot\b[^.]{0,60}\bdone until\b[^.]{0,60}\btest/i;
+/** Any mention of testing — the mandate must be ABOUT tests, not about docs. */
+const TEST_WORD_RE = /\btests?\b|\btesting\b|\btest-first\b/i;
+/**
+ * Does the decisions/spec text mandate tests-in-the-same-change?
+ *
+ * Scans sentence by sentence and requires BOTH signals in the SAME sentence, so
+ * a testing section that happens to sit near an unrelated "don't defer" line
+ * cannot trigger the ban. `decisions` is checked first and alone is sufficient;
+ * the spec is scanned too because run 14's cadence rule is stated in §10 of the
+ * doc and only echoed into the decisions channel.
+ */
+export function mandatesTestsInSameChange(decisions, spec = '') {
+    for (const text of [decisions, spec]) {
+        for (const sentence of text.split(/(?<=[.!?])\s+|\n{2,}/)) {
+            if (TEST_WORD_RE.test(sentence) && SAME_CHANGE_RE.test(sentence))
+                return true;
+        }
+    }
+    return false;
+}
+/** Trailing `[decisions: …]` clauses decompose appends — carried onto the
+ *  replacement title verbatim so the rewrite never loses a directive. */
+const DECISIONS_CLAUSE_RE = /\s*\[decisions:/i;
+/**
+ * Where decompose's trailing metadata starts. `[source: …]` is included because
+ * reconcileTitleSources only strips a WELL-FORMED trailing citation: measured
+ * live, the model also emits `[source: "…" [10. Testing]]`, which fails that
+ * regex and leaks the QUOTED SPEC LINE into the title. Judging scope on such a
+ * title reads the citation's words as the task's own — the cadence quote "…as
+ * each new route or React component/page" made a properly scoped
+ * "Write route/API tests for auth" look like a batch task (live false positive,
+ * rep 1). A citation is provenance, never scope.
+ */
+const CLAUSE_START_RE = /\s*\[(?:source|decisions)\s*:/i;
+/** Split a title into the part decompose authored, and the `[decisions: …]` tail
+ *  that must survive onto a replacement title. A leaked `[source: …]` remnant is
+ *  dropped from both — the sweep does not derive from that line. */
+function splitDecisions(title) {
+    const clause = CLAUSE_START_RE.exec(title);
+    const body = (clause ? title.slice(0, clause.index) : title).trim();
+    const decisions = DECISIONS_CLAUSE_RE.exec(title);
+    return { body, tail: decisions ? title.slice(decisions.index) : '' };
+}
+/** The head of a title: everything before the " — <detail>" separator. */
+function head(body) {
+    return body.split(/\s+[—–-]\s+|\s*\|\s*/)[0];
+}
+/**
+ * Remove double-quoted spans — they are QUOTED SPEC TEXT, never the task's own
+ * scope. Measured live: the model frequently appends its citation as a bare
+ * quote with no `[source: …]` wrapper ("Write auth route tests — … — "…a test
+ * lands as fast as possible — in the same change — as each new route or React
+ * component/page.""), and that borrowed "each" made five correctly scoped
+ * per-area test tasks read as batch tasks (rep 5). Trading a possible miss (a
+ * batch title whose only quantifier sits inside a quote) for never deleting a
+ * properly scoped test task: the false positive is far the more expensive error.
+ */
+function stripQuotedSpans(s) {
+    return s.replace(/"[^"]*"/g, ' ').replace(/[“][^”]*[”]/g, ' ');
+}
+/** A title whose DELIVERABLE is tests: an authoring verb whose object is tests,
+ *  with nothing else claimed in between ("Write component and page tests" ✓,
+ *  "Add listings CRUD + tests" ✗ — the `+` marks tests as an additive constraint
+ *  on a feature task, which is exactly the cadence the decision asks for). */
+const TEST_AUTHORING_RE = /^\s*(?:(?:write|add|create|implement|author|build|develop|produce|backfill)\b[\w\s,/-]*\b(?:tests?|test suite|test coverage|testing)\b|(?:tests?|testing)\b)/i;
+/** Enabling/infrastructure work — a runner, a config, fixtures, CI. Those are
+ *  NOT batched test authoring; banning them would remove the very thing the
+ *  per-change tests need to exist first. */
+const TEST_INFRA_RE = /\b(?:harness|infrastructure|infra|runner|config|configuration|scaffold|scaffolding|set ?up|fixtures?|helpers?|utilities|utility|ci|pipeline|database|seed)\b/i;
+/**
+ * WHOLE-PROJECT scope: a universal quantifier that governs a PROJECT-LEVEL target
+ * ("all components and pages", "every route"), not merely any noun.
+ *
+ * Both halves are load-bearing, each learned from a live false positive:
+ *   - "full"/"complete" are excluded — they routinely scope a single area
+ *     ("full login flow");
+ *   - the quantifier must reach a project-level plural within ~20 chars, because
+ *     "Test PartCard component — ALL badge combinations…" is a one-component task
+ *     that a bare-quantifier rule flagged and DROPPED (live rep 3).
+ */
+const WHOLE_SCOPE_RE = /\b(?:all|every|each|entire|whole|comprehensive)\b[\w\s,/-]{0,20}?\b(?:components?|pages?|routes?|endpoints?|screens?|views?|modules?|layers?|files?|features?|app|application|project|codebase|repo|repository|system|surface)\b|\bacross the (?:app|application|project|codebase|repo|repository)\b|\bend[- ]to[- ]end coverage\b/i;
+/**
+ * Indices of titles that are whole-project BATCH test tasks.
+ *
+ * Three conditions must all hold — the title's deliverable is tests, its scope is
+ * the whole project, and it is not test INFRASTRUCTURE. A per-feature task that
+ * carries "+ tests" never matches (its head names the feature), which is the
+ * point: those are the cadence the decision asks for.
+ */
+export function findBatchTestTitles(titles) {
+    const out = [];
+    for (let i = 0; i < titles.length; i++) {
+        const { body } = splitDecisions(titles[i]);
+        const scope = stripQuotedSpans(body);
+        const h = head(scope);
+        if (!TEST_AUTHORING_RE.test(h))
+            continue;
+        if (TEST_INFRA_RE.test(h))
+            continue;
+        if (!WHOLE_SCOPE_RE.test(scope))
+            continue;
+        out.push(i);
+    }
+    return out;
+}
+/** Test-runner commands a spec may name as the thing that REPORTS coverage. */
+const TEST_COMMAND_RE = /\b(?:bun test|npm (?:run )?test|yarn test|pnpm (?:run )?test|npx (?:vitest|jest|playwright test)|playwright test|vitest|jest|pytest|go test|cargo test|mix test|rspec)\b[^`\n]*/i;
+/**
+ * The spec's own coverage source — the command whose report scopes the sweep.
+ *
+ * Only backticked spans are considered, so the result is a command the spec
+ * actually writes down rather than a phrase inferred from prose; a span carrying
+ * a coverage flag wins over a plain test run. Falls back to a generic phrase when
+ * the spec names no command, which keeps the sweep title well-formed either way.
+ */
+export function coverageSourceFromSpec(spec) {
+    const spans = [...spec.matchAll(/`([^`\n]+)`/g)].map(m => m[1].trim());
+    const commands = spans.filter(s => TEST_COMMAND_RE.test(s));
+    const withCoverage = commands.find(s => /--coverage|\bcoverage\b/i.test(s));
+    return withCoverage ?? commands[0] ?? "the project's own test suite";
+}
+/**
+ * Vocabulary that every testing task and every testing requirement shares, so it
+ * carries NO ownership signal here. Without this scrub the bare token "test"
+ * connects a screenshot-baseline requirement to "Write auth route tests", and the
+ * orphan check goes blind. (Scrubbed locally rather than added to
+ * COVERAGE_STOPWORDS: those govern the A/B-validated monotonic adoption guard,
+ * where "test" IS a discriminating noun for a plan that has no testing task at
+ * all.) Token-level, not regex — `mx5_test` must scrub to `mx5`.
+ */
+const GENERIC_TEST_TOKENS = new Set([
+    'test',
+    'tests',
+    'testing',
+    'tested',
+    'spec',
+    'specs',
+    'suite',
+    'suites',
+    'coverage',
+    'assertion',
+    'assertions',
+    'case',
+    'cases',
+    'unit',
+    'e2e'
+]);
+/** Drop the generic testing vocabulary, keeping the tokenization coverage-loop
+ *  itself uses so the scrubbed text grounds exactly the same way. */
+function scrubTestVocabulary(s) {
+    return s
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(w => w.length > 0 && !GENERIC_TEST_TOKENS.has(w))
+        .join(' ');
+}
+/**
+ * Requirement indices that lose their owner when the batch titles are removed.
+ *
+ * Two independent measures, unioned:
+ *
+ *   1. STRICT (the one that actually fires): generic testing vocabulary scrubbed
+ *      from both sides, and a requirement that is ABOUT testing may only be owned
+ *      by a title that is about testing — "Implement login page" does not
+ *      discharge "every component/page test captures a screenshot".
+ *   2. PLAIN groundedCoverage, exactly as the monotonic adoption guard measures
+ *      it. This is the belt: whatever that guard would call a drop is an orphan
+ *      here too, so the rewrite can never trip the guard it feeds.
+ */
+function orphanedRequirements(quotes, titles, kept, isCrossCutting) {
+    const scrubbed = quotes.map(scrubTestVocabulary);
+    // Index-aligned cross-cutting lookup: the scrubbed text is not the quote the
+    // classifier expects, so map back to the original.
+    const crossByScrub = new Map();
+    quotes.forEach((q, i) => crossByScrub.set(scrubbed[i], isCrossCutting(q)));
+    const isCrossScrubbed = (s) => crossByScrub.get(s) ?? false;
+    const testish = (t) => TEST_WORD_RE.test(t);
+    const scrub = (list) => list.map(scrubTestVocabulary);
+    const strictBefore = groundedCoverage(scrubbed, scrub(titles), isCrossScrubbed);
+    const strictAfterAll = groundedCoverage(scrubbed, scrub(kept), isCrossScrubbed);
+    const strictAfterTest = groundedCoverage(scrubbed, scrub(kept.filter(testish)), isCrossScrubbed);
+    const plainBefore = groundedCoverage(quotes, titles, isCrossCutting);
+    const plainAfter = groundedCoverage(quotes, kept, isCrossCutting);
+    const out = [];
+    for (let i = 0; i < quotes.length; i++) {
+        const owner = testish(quotes[i]) ? strictAfterTest : strictAfterAll;
+        const strictLost = strictBefore.has(i) && !owner.has(i);
+        const plainLost = plainBefore.has(i) && !plainAfter.has(i);
+        if (strictLost || plainLost)
+            out.push(i);
+    }
+    return out;
+}
+/** How many orphaned requirement quotes the sweep title names, and how long each
+ *  may be — a title is a one-line handoff, not a ledger. */
+const MAX_SWEEP_QUOTES = 6;
+const MAX_QUOTE_CHARS = 120;
+function shorten(q) {
+    const s = q.replace(/\s+/g, ' ').trim();
+    return s.length <= MAX_QUOTE_CHARS ? s : s.slice(0, MAX_QUOTE_CHARS - 1).trimEnd() + '…';
+}
+/**
+ * The scoped replacement: a gap-filling sweep, bounded by what the coverage
+ * source reports and by the requirements that lost their only owner. It states
+ * the ban explicitly, because the child that receives this title sees nothing
+ * else.
+ */
+export function buildSweepTitle(orphaned, coverageSource) {
+    const named = orphaned.slice(0, MAX_SWEEP_QUOTES).map(q => `"${shorten(q)}"`);
+    const more = orphaned.length > named.length ? ` (+${orphaned.length - named.length} more)` : '';
+    return (`Fill the test-coverage gaps left by the per-change tests — run \`${coverageSource}\`,`
+        + ' and add tests ONLY for what it reports uncovered, specifically:'
+        + ` ${named.join('; ')}${more}.`
+        + ' Do NOT re-test what earlier tasks already covered, and do NOT modify'
+        + ' existing test config or existing tests.');
+}
+/**
+ * Rewrite a decomposed plan so it carries no whole-project batch test task when
+ * the decisions mandate tests-in-the-same-change.
+ *
+ * No mandate, or no batch title ⇒ the plan is returned untouched (identity), so
+ * every non-cadence run behaves exactly as before.
+ *
+ * With a mandate, ALL batch titles are removed at once before coverage is
+ * re-measured — otherwise two batch tasks would each mask the other's orphans and
+ * both would look droppable. The orphaned set is then whatever grounded coverage
+ * the removal costs; it is non-empty only when no other task's title claims that
+ * requirement, and it becomes the sweep's scope. At most ONE sweep is emitted (in
+ * the first batch title's position, so plan order is preserved).
+ */
+export function rewriteBatchTestPlan(titles, decisions, spec, requirementQuotes, isCrossCutting) {
+    if (!mandatesTestsInSameChange(decisions, spec))
+        return { titles, actions: [] };
+    const batch = findBatchTestTitles(titles);
+    if (batch.length === 0)
+        return { titles, actions: [] };
+    const batchSet = new Set(batch);
+    const kept = titles.filter((_, i) => !batchSet.has(i));
+    const orphaned = orphanedRequirements(requirementQuotes, titles, kept, isCrossCutting).map(i => requirementQuotes[i]);
+    const actions = [];
+    const out = [];
+    let sweepEmitted = false;
+    for (let i = 0; i < titles.length; i++) {
+        if (!batchSet.has(i)) {
+            out.push(titles[i]);
+            continue;
+        }
+        if (orphaned.length === 0 || sweepEmitted) {
+            actions.push({ index: i, title: titles[i], kind: 'dropped', orphaned: [] });
+            continue;
+        }
+        // Carry the offending title's own [decisions: …] clauses onto the sweep —
+        // they are user directives and survive the reshaping of the task.
+        const { tail } = splitDecisions(titles[i]);
+        const replacement = buildSweepTitle(orphaned, coverageSourceFromSpec(spec)) + tail;
+        actions.push({ index: i, title: titles[i], kind: 'scoped', replacement, orphaned });
+        out.push(replacement);
+        sweepEmitted = true;
+    }
+    return { titles: out, actions };
+}
+/**
+ * The decompose-prompt rule (the belt; the host rewrite above is the lever).
+ * Emitted ONLY when the decisions mandate the cadence, so ordinary runs see the
+ * prompt they always saw. Kept next to the detector so the two cannot drift.
+ */
+export const DECOMPOSE_NO_BATCH_TESTS_RULE = '- The CLARIFICATIONS mandate that tests land in the SAME change as the code they'
+    + ' cover. So do NOT emit a task whose job is writing tests for all components /'
+    + ' all routes / the whole project — that shape is rejected host-side. Fold each'
+    + " test into the task that builds the thing it tests (name it in that task's"
+    + ' title), and emit a separate testing task ONLY as a narrowly scoped sweep of'
+    + ' gaps a coverage run reports. Test INFRASTRUCTURE (runner, config, fixtures)'
+    + ' may still be its own early task.';

package/dist/task/resume-gap.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Resume gating & the honest resume banner.
+ *
+ * mx5 run 14 lost ~10 hours to dead air that looked like a stall: the host was
+ * powered off overnight, both containers stopped at 20:00Z, and the run picked
+ * up cleanly the moment they were restarted at 06:01Z. Nothing was wrong with
+ * the run — the only defect was that nobody could tell. Two things follow.
+ *
+ * (1) A restart-time resume can be automated (`restart: unless-stopped` on the
+ * containers plus a boot hook that runs `/task-auto-resume --unattended`), which
+ * turns that 10h of nothing into minutes.
+ *
+ * (2) An automated resume must not resume everything. `RESUMABLE_STATES`
+ * deliberately includes `failed` and `cancelled` because a HUMAN typing
+ * /task-auto-resume has decided to continue; a boot hook has decided nothing. A
+ * failed run stopped for a reason a power cycle does not clear, and re-entering
+ * it unattended burns the whole loop against the same wall. Unattended resume
+ * therefore covers in-flight states only (see UNATTENDED_STATES), and refuses
+ * the rest by name rather than silently doing nothing.
+ *
+ * The banner follows the honest-restart-hint rule (70a8497): say exactly what
+ * was observed and exactly what it does not tell you. All this process knows is
+ * when the AUTO file was last written — it cannot distinguish a stopped host
+ * from a hung child from a slow task, so it reports the gap and attributes no
+ * cause. It is equally careful about the tree: nothing is rolled back between
+ * the interruption and the resume.
+ */
+import type { TaskState } from './task-types.js';
+/** States an UNATTENDED resume may continue. In-flight only — see file header. */
+export declare const UNATTENDED_STATES: TaskState[];
+/** The most recent resumable AUTO run, with the two facts the banner needs. */
+export interface AutoResumeCandidate {
+    id: string;
+    state: TaskState;
+    /** AUTO-file mtime: the last moment the run demonstrably wrote progress. */
+    lastWriteMs: number;
+}
+export interface ResumeDecision {
+    /** Whether the caller should proceed with the resume. */
+    resume: boolean;
+    /** The line to show the user (and publish to the remote view). */
+    banner: string;
+    level: 'info' | 'warning';
+}
+/** Human gap, coarsest-two-units ("10h 1m", "45s", "2d 4h"). */
+export declare function formatGap(ms: number): string;
+/**
+ * Gate an incoming resume and phrase it. Pure: the caller supplies the candidate
+ * and the clock. `unattended` is the boot-hook path (`--unattended`), which is
+ * the only one that refuses on state.
+ */
+export declare function decideResume(candidate: AutoResumeCandidate | null, nowMs: number, unattended: boolean): ResumeDecision;

package/dist/task/resume-gap.js

@@ -0,0 +1,67 @@
+/** States an UNATTENDED resume may continue. In-flight only — see file header. */
+export const UNATTENDED_STATES = ['in_progress'];
+/**
+ * Below this the gap is ordinary hand-driven latency (you looked at the failure,
+ * then typed the command) and the unaccounted-time paragraph would be noise.
+ */
+const GAP_NARRATION_MS = 5 * 60_000;
+/** Human gap, coarsest-two-units ("10h 1m", "45s", "2d 4h"). */
+export function formatGap(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return s % 60 === 0 ? `${m}m` : `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return m % 60 === 0 ? `${h}h` : `${h}h ${m % 60}m`;
+    const d = Math.floor(h / 24);
+    return h % 24 === 0 ? `${d}d` : `${d}d ${h % 24}h`;
+}
+/**
+ * What the resume says about the time it was away. Attributes no cause: a gap
+ * is wall-clock silence, and this process cannot see which of the several very
+ * different explanations produced it.
+ */
+function gapClause(lastWriteMs, nowMs) {
+    const gap = nowMs - lastWriteMs;
+    const at = new Date(lastWriteMs).toISOString();
+    // A future mtime means the clock moved, not that the run wrote ahead of
+    // time; saying "0s ago" there would be the one thing this banner must not do.
+    if (gap < -60_000) {
+        return `its file is timestamped ${at}, which is in the future — the clock moved under it, so no gap can be measured`;
+    }
+    const shown = formatGap(Math.max(0, gap));
+    if (gap < GAP_NARRATION_MS)
+        return `last written ${shown} ago (${at})`;
+    return (`last written ${shown} ago (${at}). That gap is unaccounted-for wall time, not work: `
+        + `this process cannot tell a stopped host from a hung child from a slow task. `
+        + `Nothing was rolled back — the working tree is exactly as the interrupted run left it`);
+}
+/**
+ * Gate an incoming resume and phrase it. Pure: the caller supplies the candidate
+ * and the clock. `unattended` is the boot-hook path (`--unattended`), which is
+ * the only one that refuses on state.
+ */
+export function decideResume(candidate, nowMs, unattended) {
+    if (!candidate) {
+        return { resume: false, banner: 'No resumable /task-auto run.', level: 'info' };
+    }
+    const { id, state, lastWriteMs } = candidate;
+    if (unattended && !UNATTENDED_STATES.includes(state)) {
+        return {
+            resume: false,
+            banner: `Not auto-resuming ${id}: state=${state}. Unattended resume continues `
+                + `in-flight runs (${UNATTENDED_STATES.join(', ')}) only — a ${state} run stopped `
+                + `for a reason a restart does not clear. Look at it, then resume by hand with `
+                + `/task-auto-resume.`,
+            level: 'warning'
+        };
+    }
+    return {
+        resume: true,
+        banner: `Resuming ${id} (state=${state}) — ${gapClause(lastWriteMs, nowMs)}.`,
+        level: 'info'
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.40",
+    "version": "0.18.42",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",