@mjasnikovs/pi-task 0.38.15 → 0.38.17

package/dist/task/gate-deps.js

@@ -24,7 +24,7 @@ import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { readContracts } from './contracts.js';
 import { recordDebt } from './accept-debt.js';
 import { recordRepairCandidate } from './root-cause-repair.js';
-import { runRepoHealthCheck, runRepoHealthCheckAsync } from './repo-health-check.js';
+import { runRepoHealthCheck } from './repo-health-check.js';
 import { runFinalIntegrationGate, discoverGateCommandLabels, discoverGateCommandBodies } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
 import { researchResolution } from './verify-resolution.js';
@@ -755,14 +755,19 @@ export function buildGateDeps(params) {
                 // own lint/typecheck and fails on a real non-zero exit, independent of
                 // the model-authored VERIFY block (which may not lint at all). ASYNC:
                 // the sync runner froze the event loop for the whole lint (see above).
-                repoHealth: () => deadAirBaseline ?
-                    Promise.resolve(runRepoHealthCheck(cwd2))
-                    : runRepoHealthCheckAsync(cwd2, {
-                        signal,
-                        onCommand: c => {
-                            stageLine = `repo health · ${c}`;
-                        }
-                    }),
+                // ONE call, both arms. The baseline arm used to call this
+                // without the signal or the progress hook, because
+                // `runRepoHealthCheck` was SYNCHRONOUS and blocking the event
+                // loop was the thing being measured. It is async now, so that
+                // branch measured treatment against treatment — and it also
+                // made `DEADAIR_AB_ARM=baseline` silently uncancellable and
+                // mute. The arm's real difference is the LOADER, above.
+                repoHealth: () => runRepoHealthCheck(cwd2, {
+                    signal,
+                    onCommand: c => {
+                        stageLine = `repo health · ${c}`;
+                    }
+                }),
                 // The deterministic probes, bound in one place (buildVerifyProbes
                 // above); the PROBE_ADAPTERS table in verify-work.ts runs them.
                 probes: buildVerifyProbes({
@@ -814,7 +819,7 @@ export function buildGateDeps(params) {
                 signal,
                 failReason,
                 runChild: gateChild(fixCtx, cwd2, taskTitle, 'lint-fix', 'verify-debug.log'),
-                repoHealth: () => runRepoHealthCheckAsync(cwd2, { signal }),
+                repoHealth: () => runRepoHealthCheck(cwd2, { signal }),
                 git: async (args) => {
                     const r = await git(cwd2, args, signal);
                     return { exitCode: r.exitCode, stdout: r.stdout };
@@ -846,7 +851,7 @@ export function buildGateDeps(params) {
                 startedAt,
                 lastLine: running ? `repo health · ${running}` : 'repo health'
             }));
-            return runRepoHealthCheckAsync(cwd2, {
+            return runRepoHealthCheck(cwd2, {
                 signal,
                 onCommand: c => {
                     running = c;
@@ -865,7 +870,9 @@ export function buildGateDeps(params) {
             runChild: gateChild(fixCtx, cwd2, 'final integration gate', 'final-fix', 'final-gate-debug.log'),
             // The gate re-run is the only arbiter of convergence, and the
             // shrink guard's discovery is the gate's own (see final-gate.ts).
-            gate: c => runFinalIntegrationGate(c),
+            // The run's cancel reaches the re-run too. Without it the whole
+            // `FinalGateOptions.signal` path is inert in the shipped code.
+            gate: c => runFinalIntegrationGate(c, { signal }),
             discoverLabels: discoverGateCommandLabels,
             discoverBodies: discoverGateCommandBodies,
             discard: discardTreeEdits,
@@ -893,7 +900,7 @@ export function buildGateDeps(params) {
             // depend on it.
             ignoredSnapshot: () => collectIgnoredSnapshot(cwd2, signal),
             ...(ignoredKnown && ignoredKnown.length > 0 ? { ignoredKnown } : {}),
-            gateWithoutIgnored: paths => gatePassesWithoutIgnored(cwd2, paths, c => runFinalIntegrationGate(c), makeDebugAppender(path.join(tasksDir(cwd2), 'final-gate-debug.log'))),
+            gateWithoutIgnored: paths => gatePassesWithoutIgnored(cwd2, paths, c => runFinalIntegrationGate(c, { signal }), makeDebugAppender(path.join(tasksDir(cwd2), 'final-gate-debug.log'))),
             log: makeDebugAppender(path.join(tasksDir(cwd2), 'final-gate-debug.log'))
         }),
         recommend: async (recCtx, cwd2, taskTitle, taskId, failReason) => {

package/dist/task/lint-fix.d.ts

@@ -42,6 +42,13 @@ export interface LintFixDeps {
      * deletion guard is disarmed (prior behavior).
      */
     introducedBy?: (rel: string) => Promise<string | null>;
+    /**
+     * Debug-log sink. This dep did not exist, so all four of this pass's guard
+     * trips were invisible in the trail while the twin (`FinalFixDeps.log`) logged
+     * three of its own — and a guard whose firing leaves no record cannot be
+     * distinguished from one that never armed.
+     */
+    log?: (msg: string) => void;
 }
 /** The fix child edits and runs the checker; bash exists to RUN the check, not git. */
 export declare const LINT_FIX_TOOLS = "read,edit,bash";

package/dist/task/lint-fix.js

@@ -58,6 +58,7 @@
  * `currentTaskId` and `introducedBy` are wired.
  */
 import { parseChangedFrozenFiles, pathNamedIn, revertFrozenPaths } from './frozen-path-guard.js';
+import { runFixChild } from './fix-child.js';
 import { parseTreeChanges } from './write-guard.js';
 import { findCrossTaskDeletions } from './task-provenance.js';
 /** The fix child edits and runs the checker; bash exists to RUN the check, not git. */
@@ -204,16 +205,27 @@ export async function runBoundedLintFix(deps) {
     // guard for this run (inconclusive ≠ evidence).
     const deletionGuardArmed = Boolean(deps.currentTaskId && deps.introducedBy);
     const preChanges = deletionGuardArmed ? await treeChanges(deps) : null;
-    try {
-        await deps.runChild(LINT_FIX_TOOLS, buildLintFixPrompt(deps.failReason, frozen), deps.signal);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        // A cancel must propagate so the caller's USER_CANCELLED path runs.
-        if (msg === '__user_cancelled__')
-            throw err;
-        return { ok: false, reason: `fix child failed: ${msg}` };
+    // The four-rung ladder lives in task/fix-child.ts. A cancel still propagates
+    // (it THROWS, so the caller's USER_CANCELLED path is unchanged); what is new
+    // here is the BLOCKED rung, which this pass instructed in its prompt and then
+    // discarded the reply of — so a child that reported BLOCKED still paid the
+    // whole guard stack and a repo-health re-run (15–69s measured) to be told
+    // `did not converge`, instead of its own stated reason.
+    const end = await runFixChild({
+        runChild: deps.runChild,
+        tools: LINT_FIX_TOOLS,
+        prompt: buildLintFixPrompt(deps.failReason, frozen),
+        signal: deps.signal,
+        marker: 'LINT-FIX'
+    });
+    if (end.kind === 'error') {
+        deps.log?.(`lint-fix child failed — ${end.msg}`);
+        return { ok: false, reason: `fix child failed: ${end.msg}` };
     }
+    // A BLOCKED child is NOT an early return from here: the guards below exist to
+    // catch a child that discarded work, and a child can discard work and then
+    // block. The marker is consulted after them, in place of the re-run — which is
+    // where the twin consults its own.
     // REVERT-GUARD: every pre-existing work file must still differ from HEAD, and
     // every pre-existing untracked file must still exist. Trip → restore snapshot.
     // Every comparison requires git to have actually SUCCEEDED: a git error after
@@ -250,6 +262,7 @@ export async function runBoundedLintFix(deps) {
             await deps.git(['checkout', snapshot, '--', '.', EXCLUDE_TASKS_DIR]);
             await deps.git(['reset']);
         }
+        deps.log?.(`lint-fix REVERT-GUARD — discarded ${violations.length} work file(s)`);
         return {
             ok: false,
             reason: `revert-guard: fix pass discarded work (${violations.slice(0, 3).join(', ')}`
@@ -277,6 +290,7 @@ export async function runBoundedLintFix(deps) {
             if (crossDeletions.length > 0) {
                 await deps.git(['checkout', '-f', 'HEAD', '--', ...crossDeletions.map(d => d.path)]);
                 const named = crossDeletions.map(d => `${d.path} — ${d.owner}'s deliverable`);
+                deps.log?.(`lint-fix CROSS-TASK-DELETION GUARD — ${named[0]}`);
                 return {
                     ok: false,
                     reason: `cross-task-deletion: fix child DELETED sibling task deliverable(s) `
@@ -300,6 +314,7 @@ export async function runBoundedLintFix(deps) {
             const frozenViolations = [...postFrozenDirty].filter(f => !preFrozenDirty.has(f));
             if (frozenViolations.length > 0) {
                 const reverted = await revertFrozenPaths(frozenViolations, deps.git);
+                deps.log?.(`lint-fix FROZEN-PATH GUARD — ${frozenViolations.slice(0, 3).join(', ')}`);
                 return {
                     ok: false,
                     reason: `frozen-path: fix child modified spec-frozen path(s) `
@@ -311,8 +326,28 @@ export async function runBoundedLintFix(deps) {
             }
         }
     }
+    if (end.kind === 'blocked')
+        deps.log?.(`lint-fix BLOCKED — ${end.note}`);
+    // The CHECK is the arbiter, including after a BLOCKED marker.
+    //
+    // The marker is scraped last-match-wins out of arbitrary child output, and
+    // LINT_FIX_TOOLS carries bash — so the child's own command output is in that
+    // text. A child can also genuinely converge and THEN block: `eslint --fix`
+    // silently clears the last finding, and the model still reports
+    // `LINT-FIX: BLOCKED the generated file is frozen`. Returning not-applied on
+    // the marker alone would send the gate to `deps.recommend(...)` with a
+    // failReason that no longer describes the tree, skipping the re-verify and
+    // burning a full implementation re-run on findings that are already gone —
+    // while the child's edits sit in the working tree.
+    //
+    // So BLOCKED does not decide; it only supplies a better REASON when the check
+    // agrees nothing converged. That was the durable half of the win. Skipping the
+    // re-run was the other half, and it is not worth this.
     const health = await deps.repoHealth();
     if (!health.ok) {
+        if (end.kind === 'blocked') {
+            return { ok: false, reason: `fix child blocked: ${end.note}` };
+        }
         // FROZEN-PATH TRACE on non-convergence (PROMPT 1 layer B): when the child
         // was honest — it did NOT touch the frozen path, so the guard above never
         // tripped — but the check is still red and its own output NAMES a frozen
@@ -324,6 +359,7 @@ export async function runBoundedLintFix(deps) {
         // rounds an impl re-run under the same freeze cannot converge out of.
         const implicated = frozen.filter(p => pathNamedIn(`${health.reason}\n${health.output ?? ''}`, p));
         if (implicated.length > 0) {
+            deps.log?.(`lint-fix FROZEN-PATH TRACE — ${implicated.slice(0, 3).join(', ')}`);
             return {
                 ok: false,
                 reason: `frozen-path: static findings implicate spec-frozen path(s) `

package/dist/task/orchestrator.d.ts

@@ -20,6 +20,7 @@ import { type WidgetState } from './widget.js';
 import { type RunTaskFn } from './gate-deps.js';
 import { type GateDeps } from './task-gates.js';
 import { type PhaseDeps } from './child-runner.js';
+import { type RunEnd } from './run-end.js';
 import type { SpawnFn } from '../shared/child-process.js';
 import { type SuperviseOptions } from './implementation-turn.js';
 /**
@@ -45,6 +46,16 @@ export interface TaskRunnerOptions {
      * the child is a premise of the test, not its subject.
      */
     runChild?: PhaseDeps['runChild'];
+    /**
+     * Test seam: `PhaseDeps.runWorker(label, input)`. Present → every research
+     * worker is answered BY NAME, so the three Research retry gates and the
+     * fatal/runaway/empty classification are reachable from a runner-driven test
+     * without matching a marker sentence inside the prompt.
+     */
+    runWorker?: PhaseDeps['runWorker'];
+    /** Test seam: the four EXTERNAL CONTEXT lookups plus the file inventory. Each
+     *  defaults to the real implementation when absent. */
+    lookups?: Pick<PhaseDeps, 'getFileInventory' | 'docsRaw' | 'fetchRaw' | 'npmVersionLookup' | 'docsFocused' | 'fetchFocused' | 'searchFn'>;
     /** Called with the resolved task id once its file exists, before any phase
      *  work. Lets callers record the id (e.g. stamp the /task-auto entry) so an
      *  interrupted run can be resumed instead of restarted. */
@@ -110,7 +121,13 @@ export declare class TaskRunner {
      *  armed for the same window (`withRun`); nested inside `runGatedTask` or
      *  the `/task-auto` loop the bracket refcounts, so this changes nothing there
      *  and covers the fire-and-forget `runSingleTask` path on its own. */
-    run(): Promise<void>;
+    /**
+     * Run the task and NAME how it ended.
+     *
+     * This returned `void`, so the caller re-read the task file to learn what had
+     * just happened here — see run-end.ts for the report that got wrong.
+     */
+    run(): Promise<RunEnd>;
     private _run;
     /** Stop the phase widget — clearing both the terminal and remote surfaces —
      *  exactly once. Nulling the disposer makes repeat calls no-ops, so the
@@ -129,7 +146,7 @@ export declare class TaskRunner {
      */
     private _specForDelivery;
 }
-export interface RunSingleTaskOptions extends Pick<TaskRunnerOptions, 'resumeId' | 'spawnFn' | 'runChild' | 'onStart' | 'planContext' | 'fixInstruction'> {
+export interface RunSingleTaskOptions extends Pick<TaskRunnerOptions, 'resumeId' | 'spawnFn' | 'runChild' | 'runWorker' | 'lookups' | 'onStart' | 'planContext' | 'fixInstruction'> {
     /** Await the session going idle after the spec is delivered, so the caller
      *  blocks until the agent has implemented it. Default false. */
     waitForImplementation?: boolean;
@@ -152,8 +169,15 @@ export interface RunSingleTaskOptions extends Pick<TaskRunnerOptions, 'resumeId'
 }
 export interface RunSingleTaskResult {
     taskId: string;
-    ok: boolean;
-    sessionCancelled: boolean;
+    /**
+     * How the run ended, named by the runner rather than re-derived from disk.
+     *
+     * This was `ok: boolean` plus `sessionCancelled`, `interrupted` and `reason`
+     * — four fields for one fact, three of them smuggled out of the `withSession`
+     * closure through mutable captures. `/task-cancel` fell into the `!ok` arm
+     * and was reported as a failure; see run-end.ts.
+     */
+    end: RunEnd;
     /**
      * The session context the caller must use for any work after this call. A
      * successful run replaces the session via ctx.newSession(), which leaves the
@@ -163,30 +187,15 @@ export interface RunSingleTaskResult {
      * only so test fakes that don't model session replacement can omit it.
      */
     ctx?: ExtensionCommandContext;
-    /**
-     * Set when the user interrupted the implementation (ESC) and then declined to
-     * steer (submitted an empty steer prompt) — i.e. they want the run to pause
-     * rather than continue. Only meaningful with waitForImplementation. The
-     * /task-auto loop reads this to pause (resumable) instead of checking the task
-     * off and advancing. A plain ESC that the user follows with steering text does
-     * NOT set this — that case loops on the same task until a turn finishes
-     * uninterrupted.
-     */
-    interrupted?: boolean;
-    /**
-     * Why the run is not ok, when known. Set when a waitForImplementation turn
-     * ended with stopReason "error" (the model/provider died mid-implementation —
-     * e.g. a context-overflow 400 — after the task file was already marked
-     * `completed` at spec-handoff). The /task-auto loop surfaces this in its
-     * "stopped at …" message so the real cause isn't lost. Undefined otherwise.
-     */
-    reason?: string;
 }
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and
  * deliver its spec. With waitForImplementation, block until the agent finishes
- * implementing the delivered spec. Success is read off the produced task file's
- * front-matter state (TaskRunner.run never throws).
+ * implementing the delivered spec.
+ *
+ * The ending comes from `TaskRunner.run`. It used to be read back off the task
+ * file's front matter — a disk round-trip this process made to learn what it had
+ * just done, and one that could not tell a cancel from a failure.
  */
 export declare function runSingleTask(ctx: ExtensionCommandContext, cwd: string, rawPrompt: string, opts?: RunSingleTaskOptions): Promise<RunSingleTaskResult>;
 /**

package/dist/task/orchestrator.js

@@ -17,7 +17,7 @@
  */
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
-import { PHASES, postCommitPhase } from './phases.js';
+import { PHASES, postCommitPhase, replayPhaseCarry, runPhaseRow } from './phases.js';
 import { handleFailure } from './failure-classifier.js';
 import { PHASE_INDEX, PHASE_ORDER, RESUMABLE_STATES } from './task-types.js';
 import { normaliseTaskId, parseFrontMatter, extractSection } from './task-parsers.js';
@@ -39,6 +39,7 @@ import { cancelCheckpoint } from './cancel-points.js';
 import { rearmCancelListener } from './cancel-input.js';
 import { takeHeldInput } from './mid-run-input.js';
 import { withRun, announceTerminal } from './run-bracket.js';
+import { RUN_END_POLICY, runSucceeded } from './run-end.js';
 import { formatTimings } from './timings.js';
 import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
 import { superviseImplementation } from './implementation-turn.js';
@@ -111,6 +112,8 @@ export class TaskRunner {
             signal: this._abort.signal,
             spawn: opts.spawnFn,
             runChild: opts.runChild,
+            runWorker: opts.runWorker,
+            ...opts.lookups,
             // Deliberately NOT a ChildStatus (child-status.ts): the phase widget's
             // state is the whole-run WidgetState — task id, phase, label — shared by
             // reference with PhaseContext and written by the phases themselves
@@ -160,6 +163,12 @@ export class TaskRunner {
      *  armed for the same window (`withRun`); nested inside `runGatedTask` or
      *  the `/task-auto` loop the bracket refcounts, so this changes nothing there
      *  and covers the fire-and-forget `runSingleTask` path on its own. */
+    /**
+     * Run the task and NAME how it ended.
+     *
+     * This returned `void`, so the caller re-read the task file to learn what had
+     * just happened here — see run-end.ts for the report that got wrong.
+     */
     async run() {
         return withRun(this._ctx, {}, () => this._run());
     }
@@ -237,6 +246,13 @@ export class TaskRunner {
                 const idx = PHASE_INDEX[phase.name];
                 if (idx < resumeIdx) {
                     this._pc[phase.field] = (await readSection(cwd, id, phase.section)) ?? '';
+                    // A row's `section` restores exactly ONE field. A phase that also
+                    // settles another one declares that as its `carry`, and the replay
+                    // is the only thing standing between a resume and losing it — the
+                    // task file deliberately stores the PRE-carry text for the field
+                    // compose rewrites. Trail lines are discarded: the live run that
+                    // wrote this section already recorded them.
+                    await replayPhaseCarry(phase, this._deps, this._pc);
                     continue;
                 }
                 await advance(phase.name);
@@ -246,7 +262,7 @@ export class TaskRunner {
                 const phaseStart = Date.now();
                 let out;
                 try {
-                    out = await phase.run(this._deps, this._pc);
+                    out = await runPhaseRow(phase, this._deps, this._pc);
                 }
                 finally {
                     const phaseMs = Date.now() - phaseStart;
@@ -279,6 +295,7 @@ export class TaskRunner {
             await setTaskSection(cwd, id, 'phase timings', formatTimings(this._timings));
             await setTaskSection(cwd, id, 'handoff', `handoff_at: ${new Date().toISOString()}`);
             await this._deliverSpec(ctx);
+            return { kind: 'completed' };
         }
         catch (err) {
             this._disposeWidget();
@@ -292,7 +309,12 @@ export class TaskRunner {
                     /* ignore — preserve original failure */
                 }
             }
-            await handleFailure(err, ctx, cwd, id, this._abort.signal.aborted);
+            // `classifyFailure` already decided whether this was a cancel or a
+            // fault; the value is the answer, not a side effect of writing a file.
+            const c = await handleFailure(err, ctx, cwd, id, this._abort.signal.aborted);
+            return c.state === 'cancelled' ?
+                { kind: 'cancelled' }
+                : { kind: 'failed', ...(c.reason === undefined ? {} : { reason: c.reason }) };
         }
         finally {
             this._disposeWidget();
@@ -374,11 +396,17 @@ export class TaskRunner {
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and
  * deliver its spec. With waitForImplementation, block until the agent finishes
- * implementing the delivered spec. Success is read off the produced task file's
- * front-matter state (TaskRunner.run never throws).
+ * implementing the delivered spec.
+ *
+ * The ending comes from `TaskRunner.run`. It used to be read back off the task
+ * file's front matter — a disk round-trip this process made to learn what it had
+ * just done, and one that could not tell a cancel from a failure.
  */
 export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
     let taskId = '';
+    // How the runner said it ended. `no-session` until it has run at all — the
+    // withSession callback below may never be entered.
+    let runEnd = { kind: 'no-session' };
     // The newSession replacement ctx, captured so the caller can keep driving the
     // UI after the original ctx is torn down. Defaults to the original for the
     // cancellation path (where no replacement occurs).
@@ -422,12 +450,14 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                 },
                 spawnFn: opts.spawnFn,
                 runChild: opts.runChild,
+                runWorker: opts.runWorker,
+                lookups: opts.lookups,
                 onStart: opts.onStart,
                 planContext: opts.planContext,
                 fixInstruction: opts.fixInstruction,
                 implAwaited: opts.waitForImplementation
             });
-            await runner.run();
+            runEnd = await runner.run();
             taskId = runner.taskId;
         }
     });
@@ -436,32 +466,29 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
         if (opts.notifyFinish) {
             void pushNotify('Task finished', `${taskId || 'Task'} cancelled — could not start a session.`, 'pi-end').catch(() => { });
         }
-        return { taskId, ok: false, sessionCancelled: true, ctx };
-    }
-    let ok = false;
-    let state;
-    if (taskId) {
-        try {
-            const { frontMatter } = await readTaskFile(cwd, taskId);
-            state = frontMatter.state;
-            ok = state === 'completed';
-        }
-        catch {
-            ok = false;
-        }
+        return { taskId, end: { kind: 'no-session' }, ctx };
     }
-    // The file reads `completed` from spec-handoff even when the implementation
-    // turn then died. Demote to a failure so /task-auto stops here (leaving the
-    // entry unchecked and resumable) instead of committing and advancing.
-    if (ok && implError)
-        ok = false;
+    // The runner already named the ending. What the SUPERVISION adds is the two
+    // endings the runner cannot see, because they happen after the spec is
+    // delivered and the task file already reads `completed`:
+    //
+    //   • the user interrupted and declined to steer — a pause, not a fault;
+    //   • the implementation turn died with stopReason "error" (a context-overflow
+    //     400, say), which must stop /task-auto here rather than let it commit and
+    //     advance on a file that says `completed`.
+    //
+    // Both used to reach the caller as extra fields beside a boolean, and both are
+    // endings.
+    let end = runEnd;
+    if (end.kind === 'completed' && interrupted)
+        end = { kind: 'interrupted' };
+    else if (end.kind === 'completed' && implError)
+        end = { kind: 'failed', reason: implError };
     if (opts.notifyFinish) {
-        // One push per top-level /task or /task-resume, on any terminal end. The
-        // file state is the source of truth: 'completed' on success, 'failed' /
-        // 'cancelled' otherwise; an unreadable/absent file falls back to 'ended'.
-        void pushNotify('Task finished', `${taskId || 'Task'} ${state ?? 'ended'}.`, 'pi-end').catch(() => { });
+        // One push per top-level /task or /task-resume, on any terminal end.
+        void pushNotify('Task finished', `${taskId || 'Task'} ${end.kind}.`, 'pi-end').catch(() => { });
     }
-    return { taskId, ok, sessionCancelled: false, ctx: freshCtx, interrupted, reason: implError };
+    return { taskId, end, ctx: freshCtx };
 }
 // ─── Gated single-task flow ────────────────────────────────────────────────────
 /**
@@ -533,19 +560,21 @@ async function runGatedTaskInner(ctx, cwd, raw, opts = {}) {
     const res = await deps.runTask(active, cwd, raw, { resumeId: opts.resumeId });
     active = res.ctx ?? active;
     const tag = res.taskId || 'Task';
-    if (res.sessionCancelled) {
-        announce(`${tag} — could not start a fresh session for /task.`, 'warning');
-        return;
-    }
-    if (res.interrupted) {
-        await markResumable(cwd, res.taskId);
-        announce(`${tag} paused — resume with /task-resume.`, 'warning');
-        return;
-    }
-    if (!res.ok) {
-        await markResumable(cwd, res.taskId);
-        const why = res.reason ? ` — ${res.reason.slice(0, 160)}` : '';
-        announce(`${tag} stopped${why} — fix and run /task-resume.`, 'error');
+    // One dispatch over the named ending. The four-branch ladder this replaces put
+    // a CANCELLED run into the `!ok` arm, so `/task-cancel` overwrote the file's
+    // `cancelled` with `failed` and told the user their task had stopped and needed
+    // fixing. Resumability comes from RUN_END_POLICY; the wording stays here,
+    // because `/task-auto` says `/task-auto-resume` where this says `/task-resume`.
+    if (!runSucceeded(res.end)) {
+        const policy = RUN_END_POLICY[res.end.kind];
+        if (policy.resumable)
+            await markResumable(cwd, res.taskId);
+        const why = res.end.kind === 'failed' && res.end.reason ? ` — ${res.end.reason.slice(0, 160)}` : '';
+        const msg = res.end.kind === 'no-session' ? `${tag} — could not start a fresh session for /task.`
+            : res.end.kind === 'cancelled' ? `${tag} cancelled.`
+                : res.end.kind === 'interrupted' ? `${tag} paused — resume with /task-resume.`
+                    : `${tag} stopped${why} — fix and run /task-resume.`;
+        announce(msg, policy.level);
         return;
     }
     // The composed task's own front-matter title — used in commit messages and
@@ -598,8 +627,8 @@ async function handleTask(args, ctx) {
         await runGatedTask(ctx, cwd, raw);
         return;
     }
-    const { sessionCancelled } = await runSingleTask(ctx, cwd, raw, { notifyFinish: true });
-    if (sessionCancelled) {
+    const { end } = await runSingleTask(ctx, cwd, raw, { notifyFinish: true });
+    if (end.kind === 'no-session') {
         ctx.ui.notify('Could not start a fresh session for /task.', 'warning');
     }
 }
@@ -687,8 +716,8 @@ async function handleTaskResume(args, ctx) {
         await runGatedTask(ctx, cwd, '', { resumeId: id });
         return;
     }
-    const { sessionCancelled } = await runSingleTask(ctx, cwd, '', { resumeId: id, notifyFinish: true });
-    if (sessionCancelled) {
+    const { end } = await runSingleTask(ctx, cwd, '', { resumeId: id, notifyFinish: true });
+    if (end.kind === 'no-session') {
         ctx.ui.notify('Could not start a fresh session for /task-resume.', 'warning');
     }
 }