@entelligentsia/forgecli 0.21.0 → 1.0.3

package/dist/extensions/forgecli/run-task.js

@@ -29,6 +29,7 @@ import { isStateStale as isJsonStateStale, readJsonState, taskStateFilePath, wri
 import { resolveModelForPhase } from "./model-resolver.js";
 import { loadWorkflow } from "./parsers/workflow-loader.js";
 import { getSessionRegistry } from "./session-registry.js";
+import { OrchestratorTranscriptWriter } from "./subagent/orchestrator-transcript.js";
 import { resolveToCanonicalId, resolveToolDir } from "./store-resolver.js";
 import { attachViewportObserver } from "./viewport-events.js";
 import { fmtPhaseSummary } from "./viewport-renderer.js";
@@ -420,463 +421,532 @@ export async function runTaskPipeline(opts) {
     // on OpenAI. Falls back to a task-scoped key if the task is unattached.
     const taskRecordAtStart = readTaskRecord(taskId, storeCli, cwd);
     const cacheSessionId = taskRecordAtStart?.sprintId ? `forge:${taskRecordAtStart.sprintId}` : `forge:task:${taskId}`;
-    while (currentPhaseIndex < PHASES.length) {
-        // ── Between-phase cancellation gate ────────────────────────────
-        if (opts.signal?.aborted) {
-            ctx.ui.notify(`⊘ forge:run-task — ${taskId} cancelled by user.`, "info");
-            registry.completePhase(taskId, PHASES[currentPhaseIndex]?.role ?? "unknown", "cancelled");
-            registry.confirmCancelled(taskId);
-            // ADR-S21-01: preserve state file so cancelled runs are resumable
-            // from the beginning of the cancelled phase (not deleted).
-            writeState(cwd, {
-                taskId,
-                phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: false,
-                status: "cancelled",
-                lastError: undefined,
-                savedAt: new Date().toISOString(),
-            });
-            return { status: "cancelled", lastPhaseIndex: currentPhaseIndex, iterationCounts };
-        }
-        const phase = PHASES[currentPhaseIndex];
-        if (!phase) {
-            ctx.ui.notify(`× forge:run-task — invalid phase index ${currentPhaseIndex}`, "error");
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: `invalid phase index ${currentPhaseIndex}`,
-            };
-        }
-        ctx.ui.setStatus?.(STATUS_KEY, `run-task ${taskId}: phase ${currentPhaseIndex + 1}/${PHASES.length} (${phase.role})`);
-        ctx.ui.notify(`→ ${taskId}: ${phase.role} (phase ${currentPhaseIndex + 1}/${PHASES.length})`, "info");
-        const subWorkflowPath = path.join(cwd, ".forge", "workflows", `${phase.workflowFile}.md`);
-        // ── Read sub-workflow ─────────────────────────────────────────
-        let subWorkflowMd;
-        let subWorkflowAudience = "any";
-        try {
-            const loaded = loadWorkflow(subWorkflowPath);
-            subWorkflowMd = loaded.rawMarkdown;
-            subWorkflowAudience = loaded.audience;
-        }
-        catch (err) {
-            const e = err;
-            ctx.ui.notify(`× forge:run-task — failed to read sub-workflow for ${phase.role}: ${e.message ?? "unknown"}`, "error");
-            writeState(cwd, {
-                taskId,
+    // ── Orchestrator transcript ──────────────────────────────────────────
+    // FORGE-BUG-040 follow-up: one JSONL file per pipeline run, ISO-prefixed
+    // in its filename so review-loop iterations preserve their own logs
+    // instead of overwriting. Captures every ctx.ui.notify line plus
+    // structured phase-boundary events.
+    const orchTranscript = new OrchestratorTranscriptWriter({
+        cwd,
+        entityKind: "task",
+        entityId: taskId,
+    });
+    const __origNotify = ctx.ui.notify.bind(ctx.ui);
+    ctx.ui.notify = ((msg, level) => {
+        __origNotify(msg, level);
+        orchTranscript.record({
+            kind: "notify",
+            ts: new Date().toISOString(),
+            level: (level ?? "info"),
+            message: typeof msg === "string" ? msg : String(msg),
+        });
+    });
+    const pipelineStartMs = Date.now();
+    try {
+        while (currentPhaseIndex < PHASES.length) {
+            // ── Between-phase cancellation gate ────────────────────────────
+            if (opts.signal?.aborted) {
+                ctx.ui.notify(`⊘ forge:run-task — ${taskId} cancelled by user.`, "info");
+                registry.completePhase(taskId, PHASES[currentPhaseIndex]?.role ?? "unknown", "cancelled");
+                registry.confirmCancelled(taskId);
+                // ADR-S21-01: preserve state file so cancelled runs are resumable
+                // from the beginning of the cancelled phase (not deleted).
+                writeState(cwd, {
+                    taskId,
+                    phaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    halted: false,
+                    status: "cancelled",
+                    lastError: undefined,
+                    savedAt: new Date().toISOString(),
+                });
+                return { status: "cancelled", lastPhaseIndex: currentPhaseIndex, iterationCounts };
+            }
+            const phase = PHASES[currentPhaseIndex];
+            if (!phase) {
+                ctx.ui.notify(`× forge:run-task — invalid phase index ${currentPhaseIndex}`, "error");
+                return {
+                    status: "failed",
+                    lastPhaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    lastError: `invalid phase index ${currentPhaseIndex}`,
+                };
+            }
+            ctx.ui.setStatus?.(STATUS_KEY, `run-task ${taskId}: phase ${currentPhaseIndex + 1}/${PHASES.length} (${phase.role})`);
+            ctx.ui.notify(`→ ${taskId}: ${phase.role} (phase ${currentPhaseIndex + 1}/${PHASES.length})`, "info");
+            orchTranscript.record({
+                kind: "phase-start",
+                ts: new Date().toISOString(),
+                phase: phase.role,
                 phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: true,
-                lastError: `sub-workflow read failed: ${e.message ?? "unknown"}`,
-                savedAt: new Date().toISOString(),
+                phaseCount: PHASES.length,
+                attempt: (iterationCounts[phase.role] ?? 0) + 1,
+                workflowFile: phase.workflowFile,
+                persona: phase.personaNoun,
             });
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: `sub-workflow read failed: ${e.message ?? "unknown"}`,
-            };
-        }
-        // ── 6a. Preflight gate ────────────────────────────────────────
-        if (fs.existsSync(preflightGate)) {
-            const preflightResult = runPreflightGate(preflightGate, phase.role, taskId, cwd);
-            if (preflightResult === "halt") {
-                ctx.ui.notify(`× forge:run-task — preflight gate failed for phase ${phase.role} (exit 1); halting.`, "error");
+            const subWorkflowPath = path.join(cwd, ".forge", "workflows", `${phase.workflowFile}.md`);
+            // ── Read sub-workflow ─────────────────────────────────────────
+            let subWorkflowMd;
+            let subWorkflowAudience = "any";
+            try {
+                const loaded = loadWorkflow(subWorkflowPath);
+                subWorkflowMd = loaded.rawMarkdown;
+                subWorkflowAudience = loaded.audience;
+            }
+            catch (err) {
+                const e = err;
+                ctx.ui.notify(`× forge:run-task — failed to read sub-workflow for ${phase.role}: ${e.message ?? "unknown"}`, "error");
                 writeState(cwd, {
                     taskId,
                     phaseIndex: currentPhaseIndex,
                     iterationCounts,
                     halted: true,
-                    lastError: `preflight gate exit 1 for ${phase.role}`,
+                    lastError: `sub-workflow read failed: ${e.message ?? "unknown"}`,
                     savedAt: new Date().toISOString(),
                 });
                 return {
-                    status: "halted",
+                    status: "failed",
+                    lastPhaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    lastError: `sub-workflow read failed: ${e.message ?? "unknown"}`,
+                };
+            }
+            // ── 6a. Preflight gate ────────────────────────────────────────
+            if (fs.existsSync(preflightGate)) {
+                const preflightResult = runPreflightGate(preflightGate, phase.role, taskId, cwd);
+                if (preflightResult === "halt") {
+                    ctx.ui.notify(`× forge:run-task — preflight gate failed for phase ${phase.role} (exit 1); halting.`, "error");
+                    writeState(cwd, {
+                        taskId,
+                        phaseIndex: currentPhaseIndex,
+                        iterationCounts,
+                        halted: true,
+                        lastError: `preflight gate exit 1 for ${phase.role}`,
+                        savedAt: new Date().toISOString(),
+                    });
+                    return {
+                        status: "halted",
+                        lastPhaseIndex: currentPhaseIndex,
+                        iterationCounts,
+                        lastError: `preflight gate exit 1 for ${phase.role}`,
+                    };
+                }
+                if (preflightResult === "escalate") {
+                    ctx.ui.notify(`× forge:run-task — preflight gate escalated for phase ${phase.role} (exit 2); manual intervention required.`, "error");
+                    writeState(cwd, {
+                        taskId,
+                        phaseIndex: currentPhaseIndex,
+                        iterationCounts,
+                        halted: true,
+                        lastError: `preflight gate exit 2 (escalate) for ${phase.role}`,
+                        savedAt: new Date().toISOString(),
+                    });
+                    return {
+                        status: "escalated",
+                        lastPhaseIndex: currentPhaseIndex,
+                        iterationCounts,
+                        lastError: `preflight gate exit 2 (escalate) for ${phase.role}`,
+                    };
+                }
+            }
+            // ── 6. Materialization-marker check ───────────────────────────
+            const markerCheck = checkMaterialization(subWorkflowPath, subWorkflowMd);
+            if (!markerCheck.ok) {
+                for (const marker of markerCheck.missing) {
+                    ctx.ui.notify(`× workflow regression: ${marker} not found in ${subWorkflowPath}`, "error");
+                }
+                return {
+                    status: "failed",
                     lastPhaseIndex: currentPhaseIndex,
                     iterationCounts,
-                    lastError: `preflight gate exit 1 for ${phase.role}`,
+                    lastError: `materialization markers missing: ${markerCheck.missing.join(", ")}`,
                 };
             }
-            if (preflightResult === "escalate") {
-                ctx.ui.notify(`× forge:run-task — preflight gate escalated for phase ${phase.role} (exit 2); manual intervention required.`, "error");
+            // ── 5. Audience check ─────────────────────────────────────────
+            // Wrap with CallerContextStore.asSubagent so assertAudience treats
+            // this as a subagent context (IL10: we ARE dispatching from subagent chain).
+            const audienceOk = CallerContextStore.asSubagent(phase.role, () => assertAudience({ workflowName: phase.workflowFile, audience: subWorkflowAudience }, ctx));
+            if (!audienceOk) {
                 writeState(cwd, {
                     taskId,
                     phaseIndex: currentPhaseIndex,
                     iterationCounts,
                     halted: true,
-                    lastError: `preflight gate exit 2 (escalate) for ${phase.role}`,
+                    lastError: `audience check failed for ${phase.workflowFile}`,
                     savedAt: new Date().toISOString(),
                 });
                 return {
-                    status: "escalated",
+                    status: "failed",
                     lastPhaseIndex: currentPhaseIndex,
                     iterationCounts,
-                    lastError: `preflight gate exit 2 (escalate) for ${phase.role}`,
+                    lastError: `audience check failed for ${phase.workflowFile}`,
                 };
             }
-        }
-        // ── 6. Materialization-marker check ───────────────────────────
-        const markerCheck = checkMaterialization(subWorkflowPath, subWorkflowMd);
-        if (!markerCheck.ok) {
-            for (const marker of markerCheck.missing) {
-                ctx.ui.notify(`× workflow regression: ${marker} not found in ${subWorkflowPath}`, "error");
-            }
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: `materialization markers missing: ${markerCheck.missing.join(", ")}`,
-            };
-        }
-        // ── 5. Audience check ─────────────────────────────────────────
-        // Wrap with CallerContextStore.asSubagent so assertAudience treats
-        // this as a subagent context (IL10: we ARE dispatching from subagent chain).
-        const audienceOk = CallerContextStore.asSubagent(() => assertAudience({ workflowName: phase.workflowFile, audience: subWorkflowAudience }, ctx));
-        if (!audienceOk) {
-            writeState(cwd, {
-                taskId,
-                phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: true,
-                lastError: `audience check failed for ${phase.workflowFile}`,
-                savedAt: new Date().toISOString(),
-            });
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: `audience check failed for ${phase.workflowFile}`,
-            };
-        }
-        // ── Persona load ──────────────────────────────────────────────
-        let persona;
-        try {
-            persona = loadForgePersona(phase.personaNoun, cwd);
-        }
-        catch (err) {
-            const e = err;
-            ctx.ui.notify(`× forge:run-task — persona '${phase.personaNoun}' not found for phase ${phase.role}: ${e.message ?? "unknown"}. ` +
-                "Run /forge:regenerate to materialize persona files.", "error");
-            writeState(cwd, {
-                taskId,
-                phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: true,
-                lastError: `persona load failed: ${e.message ?? "unknown"}`,
-                savedAt: new Date().toISOString(),
-            });
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: `persona load failed: ${e.message ?? "unknown"}`,
-            };
-        }
-        // ── 4. Dispatch via runForgeSubagent (IL10) ───────────────────
-        // NEVER sendKickoff here — that would reproduce issue #30 (same-context inline = no fork).
-        // Read fresh task record to carry forward prior phase summaries (forge-cli#19).
-        const taskRecordForSummaries = currentPhaseIndex > 0 ? readTaskRecord(taskId, storeCli, cwd) : null;
-        const summariesBlock = buildSummariesBlock(taskRecordForSummaries?.summaries);
-        const taskBody = composeTaskBody(subWorkflowMd, taskId, summariesBlock || undefined);
-        // Log whether carry-forward summaries were injected (forge-cli#19).
-        if (summariesBlock) {
-            const debugCarryPath = path.join(cwd, ".forge", "cache", `run-task-debug-${taskId}.jsonl`);
-            try {
-                fs.mkdirSync(path.dirname(debugCarryPath), { recursive: true });
-                fs.appendFileSync(debugCarryPath, `${JSON.stringify({ ts: new Date().toISOString(), phase: phase.role, kind: "carry_forward_injected", summariesLength: summariesBlock.length, summariesBlock })}\n`, "utf8");
-            }
-            catch { /* best-effort debug log */ }
-        }
-        // Resolve per-phase model from layered config (Plan 16 Slice 2).
-        // Pipeline name "default" matches the Forge plugin's shipped pipeline.
-        // When config is absent or cascade bottoms out, resolves to inherit
-        // (model: undefined) — setModel is skipped and pi's current model is used.
-        const modelResolution = resolveModelForPhase("default", phase.role, phase.personaNoun, modelRoutingConfig);
-        const phaseStart = Date.now();
-        // Stabilization debug log — every subagent event appended as JSONL.
-        const debugLogPath = path.join(cwd, ".forge", "cache", `run-task-debug-${taskId}.jsonl`);
-        const writeDebug = (rec) => {
+            // ── Persona load ──────────────────────────────────────────────
+            let persona;
             try {
-                fs.mkdirSync(path.dirname(debugLogPath), { recursive: true });
-                fs.appendFileSync(debugLogPath, `${JSON.stringify({ ts: new Date().toISOString(), phase: phase.role, ...rec })}\n`, "utf8");
+                persona = loadForgePersona(phase.personaNoun, cwd);
             }
-            catch {
-                // non-fatal; debug log is best-effort
-            }
-        };
-        writeDebug({ kind: "phase_start", phaseIndex: currentPhaseIndex });
-        writeDebug({
-            kind: "requested_model",
-            requested: modelResolution.model ?? null,
-            source: modelResolution.source,
-            persona: phase.personaNoun,
-        });
-        registry.startPhase(taskId, phase.role, currentPhaseIndex);
-        // Capture the first stream-observed model on turn_end (IL10 visibility).
-        // If pi auto-substitutes or setModel silently no-ops, this line will diverge
-        // from requested_model — exactly the diagnostic signal we want.
-        let modelObservedLogged = false;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const wrappedOnEvent = (event) => {
-            if (!modelObservedLogged && event?.type === "turn_end" && typeof event?.message?.model === "string") {
-                modelObservedLogged = true;
-                writeDebug({
-                    kind: "model_observed",
-                    provider: event.message.provider ?? null,
-                    model: event.message.model,
+            catch (err) {
+                const e = err;
+                ctx.ui.notify(`× forge:run-task — persona '${phase.personaNoun}' not found for phase ${phase.role}: ${e.message ?? "unknown"}. ` +
+                    "Run /forge:regenerate to materialize persona files.", "error");
+                writeState(cwd, {
+                    taskId,
+                    phaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    halted: true,
+                    lastError: `persona load failed: ${e.message ?? "unknown"}`,
+                    savedAt: new Date().toISOString(),
                 });
+                return {
+                    status: "failed",
+                    lastPhaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    lastError: `persona load failed: ${e.message ?? "unknown"}`,
+                };
             }
-            observer.onEvent(event);
-        };
-        const refreshStatus = () => {
-            if (process.env.FORGE_VERBOSE !== "1")
-                return;
-            const elapsed = Math.floor((Date.now() - phaseStart) / 1000);
-            const tail = observer.state.lastTool ? ` · ${observer.state.lastTool}` : "";
-            ctx.ui.setStatus?.(STATUS_KEY, `run-task ${taskId}: ${phase.role} · t${observer.state.turn} · tools ${observer.state.toolCount}${observer.state.errCount ? ` · err ${observer.state.errCount}` : ""} · ${elapsed}s${tail}`);
-        };
-        const observer = attachViewportObserver({
-            registry,
-            sessionId: taskId,
-            phaseRole: phase.role,
-            beginHeader: `─── phase ${currentPhaseIndex + 1}/${PHASES.length} ${phase.role} begin · ${taskId} ───`,
-            writeDebug,
-            notify: (msg, level) => ctx.ui.notify(msg, level),
-            setStatusVerbose: process.env.FORGE_VERBOSE === "1" ? (k, v) => ctx.ui.setStatus?.(k, v) : undefined,
-            verboseKeys: { messageKey: MESSAGE_KEY },
-            afterEach: refreshStatus,
-        });
-        let result;
-        try {
-            result = await runForgeSubagent({
-                persona,
-                task: taskBody,
-                cwd,
-                exportTag: `${taskId}__${phase.role}`,
-                cacheSessionId,
-                streamFn: opts.streamFnFactory?.({ kind: "task-phase", persona: persona.name, phase: phase.role, taskId }),
-                onEvent: wrappedOnEvent,
-                requestedModel: modelResolution.model,
-                modelRegistry: ctx.modelRegistry,
-                signal: opts.signal,
-                customTools: opts.forgeToolDefs ? getSubagentTools(opts.forgeToolDefs, persona.name) : undefined,
-            });
-        }
-        catch (err) {
-            const e = err;
-            ctx.ui.notify(`× forge:run-task — runForgeSubagent threw for phase ${phase.role}: ${e.message ?? "unknown"}`, "error");
-            writeState(cwd, {
-                taskId,
-                phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: true,
-                lastError: `runForgeSubagent threw: ${e.message ?? "unknown"}`,
-                savedAt: new Date().toISOString(),
-            });
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: `runForgeSubagent threw: ${e.message ?? "unknown"}`,
+            // ── 4. Dispatch via runForgeSubagent (IL10) ───────────────────
+            // NEVER sendKickoff here — that would reproduce issue #30 (same-context inline = no fork).
+            // Read fresh task record to carry forward prior phase summaries (forge-cli#19).
+            const taskRecordForSummaries = currentPhaseIndex > 0 ? readTaskRecord(taskId, storeCli, cwd) : null;
+            const summariesBlock = buildSummariesBlock(taskRecordForSummaries?.summaries);
+            const taskBody = composeTaskBody(subWorkflowMd, taskId, summariesBlock || undefined);
+            // Log whether carry-forward summaries were injected (forge-cli#19).
+            if (summariesBlock) {
+                const debugCarryPath = path.join(cwd, ".forge", "cache", `run-task-debug-${taskId}.jsonl`);
+                try {
+                    fs.mkdirSync(path.dirname(debugCarryPath), { recursive: true });
+                    fs.appendFileSync(debugCarryPath, `${JSON.stringify({ ts: new Date().toISOString(), phase: phase.role, kind: "carry_forward_injected", summariesLength: summariesBlock.length, summariesBlock })}\n`, "utf8");
+                }
+                catch { /* best-effort debug log */ }
+            }
+            // Resolve per-phase model from layered config (Plan 16 Slice 2).
+            // Pipeline name "default" matches the Forge plugin's shipped pipeline.
+            // When config is absent or cascade bottoms out, resolves to inherit
+            // (model: undefined) — setModel is skipped and pi's current model is used.
+            const modelResolution = resolveModelForPhase("default", phase.role, phase.personaNoun, modelRoutingConfig);
+            const phaseStart = Date.now();
+            // Stabilization debug log — every subagent event appended as JSONL.
+            const debugLogPath = path.join(cwd, ".forge", "cache", `run-task-debug-${taskId}.jsonl`);
+            const writeDebug = (rec) => {
+                try {
+                    fs.mkdirSync(path.dirname(debugLogPath), { recursive: true });
+                    fs.appendFileSync(debugLogPath, `${JSON.stringify({ ts: new Date().toISOString(), phase: phase.role, ...rec })}\n`, "utf8");
+                }
+                catch {
+                    // non-fatal; debug log is best-effort
+                }
             };
-        }
-        // ── Post-subagent abort detection ─────────────────────────────────
-        // If the abort signal fired during the subagent run, treat it as
-        // cancellation regardless of the exit code (subagent may have been
-        // mid-turn when aborted — exitCode could be 0 or 1).
-        // This check MUST come before halt-on-failure so that
-        // stopReason="aborted" + exitCode=1 is classified as cancellation,
-        // not a phase failure.
-        if (result.stopReason === "aborted" || opts.signal?.aborted) {
-            ctx.ui.notify(`⊘ forge:run-task — ${taskId} phase ${phase.role} cancelled.`, "info");
-            registry.completePhase(taskId, phase.role, "cancelled");
-            registry.confirmCancelled(taskId);
-            // ADR-S21-01: preserve state file so cancelled runs are resumable
-            writeState(cwd, {
-                taskId,
-                phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: false,
-                status: "cancelled",
-                lastError: undefined,
-                savedAt: new Date().toISOString(),
-            });
-            return { status: "cancelled", lastPhaseIndex: currentPhaseIndex, iterationCounts };
-        }
-        // ── Halt-on-failure ───────────────────────────────────────────
-        if (result.exitCode !== 0) {
-            ctx.ui.notify(`× forge:run-task — phase ${phase.role} failed (exit ${result.exitCode})` +
-                (result.errorMessage ? `: ${result.errorMessage}` : "") +
-                (result.stopReason ? ` [${result.stopReason}]` : ""), "error");
-            writeState(cwd, {
-                taskId,
-                phaseIndex: currentPhaseIndex,
-                iterationCounts,
-                halted: true,
-                lastError: result.errorMessage ?? result.stopReason ?? "subagent exit non-zero",
-                savedAt: new Date().toISOString(),
+            writeDebug({ kind: "phase_start", phaseIndex: currentPhaseIndex });
+            writeDebug({
+                kind: "requested_model",
+                requested: modelResolution.model ?? null,
+                source: modelResolution.source,
+                persona: phase.personaNoun,
             });
-            return {
-                status: "failed",
-                lastPhaseIndex: currentPhaseIndex,
-                iterationCounts,
-                lastError: result.errorMessage ?? result.stopReason ?? "subagent exit non-zero",
+            registry.startPhase(taskId, phase.role, currentPhaseIndex);
+            // Capture the first stream-observed model on turn_end (IL10 visibility).
+            // If pi auto-substitutes or setModel silently no-ops, this line will diverge
+            // from requested_model — exactly the diagnostic signal we want.
+            let modelObservedLogged = false;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const wrappedOnEvent = (event) => {
+                if (!modelObservedLogged && event?.type === "turn_end" && typeof event?.message?.model === "string") {
+                    modelObservedLogged = true;
+                    writeDebug({
+                        kind: "model_observed",
+                        provider: event.message.provider ?? null,
+                        model: event.message.model,
+                    });
+                }
+                observer.onEvent(event);
             };
-        }
-        // Capture model/provider from subagent result (REVIEW FIX #1).
-        if (result.model)
-            lastModel = result.model;
-        if (result.provider)
-            lastProvider = result.provider;
-        // Phase-complete liveliness ping (counts + duration).
-        {
-            const elapsed = Math.floor((Date.now() - phaseStart) / 1000);
-            const { turn, toolCount, errCount, cumUsage } = observer.state;
-            ctx.ui.notify(`✓ ${phase.role}: ${turn} turn${turn === 1 ? "" : "s"} · ${toolCount} tool call${toolCount === 1 ? "" : "s"}${errCount ? ` · ${errCount} err` : ""} · ${elapsed}s`, "info");
-            registry.appendTail(taskId, phase.role, fmtPhaseSummary({
-                role: phase.role,
-                turns: turn,
-                tools: toolCount,
-                errors: errCount,
-                wallSeconds: elapsed,
-                usage: cumUsage,
-                model: result.model,
-                provider: result.provider,
-            }));
-        }
-        // ── Plan 11 / Slice 2: orchestrator emits phase event ─────────
-        const phaseEndMs = Date.now();
-        const taskRecord = readTaskRecord(taskId, storeCli, cwd);
-        const sprintId = taskRecord?.sprintId;
-        if (!sprintId) {
-            ctx.ui.notify(`⚠ forge:run-task — could not resolve sprintId for ${taskId}; ` +
-                `skipping orchestrator emit for phase ${phase.role}`, "warning");
-            writeDebug({ kind: "emit_skipped", reason: "no-sprintId" });
-        }
-        else {
-            const phaseIteration = (iterationCounts[phase.role] ?? 0) + 1;
-            const emitCtx = {
-                entityType: "task",
-                taskId,
-                sprintId,
-                phase,
-                iteration: phaseIteration,
-                startMs: phaseStart,
-                endMs: phaseEndMs,
-                model: result.model ?? "unknown",
-                provider: result.provider ?? "unknown",
-                usage: {
-                    input: result.usage.input,
-                    output: result.usage.output,
-                    cacheRead: result.usage.cacheRead,
-                    cacheWrite: result.usage.cacheWrite,
-                },
-                judgement: judgementFromSummary(taskRecord, phase.role),
-                storeCli,
-                cwd,
+            const refreshStatus = () => {
+                if (process.env.FORGE_VERBOSE !== "1")
+                    return;
+                const elapsed = Math.floor((Date.now() - phaseStart) / 1000);
+                const tail = observer.state.lastTool ? ` · ${observer.state.lastTool}` : "";
+                ctx.ui.setStatus?.(STATUS_KEY, `run-task ${taskId}: ${phase.role} · t${observer.state.turn} · tools ${observer.state.toolCount}${observer.state.errCount ? ` · err ${observer.state.errCount}` : ""} · ${elapsed}s${tail}`);
             };
-            const phaseEvent = buildPhaseEvent(emitCtx);
-            const emitResult = emitEvent(storeCli, cwd, sprintId, phaseEvent);
-            if (!emitResult.ok) {
-                ctx.ui.notify(`⚠ forge:run-task — phase event emit failed for ${phase.role}: ${emitResult.stderr.trim()}`, "warning");
-                writeDebug({ kind: "emit_failed", stderr: emitResult.stderr });
+            const observer = attachViewportObserver({
+                registry,
+                sessionId: taskId,
+                phaseRole: phase.role,
+                beginHeader: `─── phase ${currentPhaseIndex + 1}/${PHASES.length} ${phase.role} begin · ${taskId} ───`,
+                writeDebug,
+                notify: (msg, level) => ctx.ui.notify(msg, level),
+                setStatusVerbose: process.env.FORGE_VERBOSE === "1" ? (k, v) => ctx.ui.setStatus?.(k, v) : undefined,
+                verboseKeys: { messageKey: MESSAGE_KEY },
+                afterEach: refreshStatus,
+            });
+            let result;
+            try {
+                // FORGE-BUG-040: wrap the runForgeSubagent dispatch in the phase
+                // caller context (parity with fix-bug.ts) so the phase-ownership
+                // guard can verify tool calls from the subagent. Single setter
+                // of phase context for the task pipeline.
+                result = await CallerContextStore.asSubagent(phase.role, () => runForgeSubagent({
+                    persona,
+                    task: taskBody,
+                    cwd,
+                    exportTag: `${taskId}__${phase.role}`,
+                    cacheSessionId,
+                    streamFn: opts.streamFnFactory?.({ kind: "task-phase", persona: persona.name, phase: phase.role, taskId }),
+                    onEvent: wrappedOnEvent,
+                    requestedModel: modelResolution.model,
+                    modelRegistry: ctx.modelRegistry,
+                    signal: opts.signal,
+                    customTools: opts.forgeToolDefs ? getSubagentTools(opts.forgeToolDefs, persona.name) : undefined,
+                }));
             }
-            else {
-                writeDebug({ kind: "emit_ok", eventId: phaseEvent.eventId });
+            catch (err) {
+                const e = err;
+                ctx.ui.notify(`× forge:run-task — runForgeSubagent threw for phase ${phase.role}: ${e.message ?? "unknown"}`, "error");
+                writeState(cwd, {
+                    taskId,
+                    phaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    halted: true,
+                    lastError: `runForgeSubagent threw: ${e.message ?? "unknown"}`,
+                    savedAt: new Date().toISOString(),
+                });
+                return {
+                    status: "failed",
+                    lastPhaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    lastError: `runForgeSubagent threw: ${e.message ?? "unknown"}`,
+                };
             }
-            // Notify sprint-level observer (FORGE-S21-T03).
-            if (onPhaseEvent)
-                onPhaseEvent(phaseEvent);
-            // Drain friction file for this phase, if any.
-            const frictionPath = path.join(cwd, ".forge", "cache", `FRICTION-${phase.role}.jsonl`);
-            const drain = drainFrictionFile(frictionPath, emitCtx);
-            if (drain.emitted + drain.failed > 0) {
-                writeDebug({ kind: "friction_drain", ...drain });
-                if (drain.failed > 0) {
-                    ctx.ui.notify(`⚠ forge:run-task — friction drain for ${phase.role}: ${drain.emitted} ok, ${drain.failed} failed`, "warning");
-                }
+            // ── Post-subagent abort detection ─────────────────────────────────
+            // If the abort signal fired during the subagent run, treat it as
+            // cancellation regardless of the exit code (subagent may have been
+            // mid-turn when aborted — exitCode could be 0 or 1).
+            // This check MUST come before halt-on-failure so that
+            // stopReason="aborted" + exitCode=1 is classified as cancellation,
+            // not a phase failure.
+            if (result.stopReason === "aborted" || opts.signal?.aborted) {
+                ctx.ui.notify(`⊘ forge:run-task — ${taskId} phase ${phase.role} cancelled.`, "info");
+                registry.completePhase(taskId, phase.role, "cancelled");
+                registry.confirmCancelled(taskId);
+                // ADR-S21-01: preserve state file so cancelled runs are resumable
+                writeState(cwd, {
+                    taskId,
+                    phaseIndex: currentPhaseIndex,
+                    iterationCounts,
+                    halted: false,
+                    status: "cancelled",
+                    lastError: undefined,
+                    savedAt: new Date().toISOString(),
+                });
+                return { status: "cancelled", lastPhaseIndex: currentPhaseIndex, iterationCounts };
             }
-        }
-        // ── 6b. Verdict check (review phases only) ────────────────────
-        if (phase.isReview) {
-            const verdict = readVerdict(taskId, phase.role, storeCli, cwd);
-            if (verdict === "missing") {
-                ctx.ui.notify(`× forge:run-task — verdict missing for phase ${phase.role} after subagent completed. ` +
-                    "Subagent may have crashed or failed to write summaries. Escalating.", "error");
+            // ── Halt-on-failure ───────────────────────────────────────────
+            if (result.exitCode !== 0) {
+                ctx.ui.notify(`× forge:run-task — phase ${phase.role} failed (exit ${result.exitCode})` +
+                    (result.errorMessage ? `: ${result.errorMessage}` : "") +
+                    (result.stopReason ? ` [${result.stopReason}]` : ""), "error");
                 writeState(cwd, {
                     taskId,
                     phaseIndex: currentPhaseIndex,
                     iterationCounts,
                     halted: true,
-                    lastError: `verdict missing for ${phase.role}`,
+                    lastError: result.errorMessage ?? result.stopReason ?? "subagent exit non-zero",
                     savedAt: new Date().toISOString(),
                 });
                 return {
                     status: "failed",
                     lastPhaseIndex: currentPhaseIndex,
                     iterationCounts,
-                    lastError: `verdict missing for ${phase.role}`,
+                    lastError: result.errorMessage ?? result.stopReason ?? "subagent exit non-zero",
+                };
+            }
+            // Capture model/provider from subagent result (REVIEW FIX #1).
+            if (result.model)
+                lastModel = result.model;
+            if (result.provider)
+                lastProvider = result.provider;
+            // Phase-complete liveliness ping (counts + duration).
+            {
+                const elapsed = Math.floor((Date.now() - phaseStart) / 1000);
+                const { turn, toolCount, errCount, cumUsage } = observer.state;
+                ctx.ui.notify(`✓ ${phase.role}: ${turn} turn${turn === 1 ? "" : "s"} · ${toolCount} tool call${toolCount === 1 ? "" : "s"}${errCount ? ` · ${errCount} err` : ""} · ${elapsed}s`, "info");
+                orchTranscript.record({
+                    kind: "phase-end",
+                    ts: new Date().toISOString(),
+                    phase: phase.role,
+                    phaseIndex: currentPhaseIndex,
+                    attempt: (iterationCounts[phase.role] ?? 0) + 1,
+                    verdict: "n/a",
+                    elapsedMs: Date.now() - phaseStart,
+                    turns: turn,
+                    toolCount,
+                    errCount,
+                });
+                const { cumCompression } = observer.state;
+                registry.appendTail(taskId, phase.role, fmtPhaseSummary({
+                    role: phase.role,
+                    turns: turn,
+                    tools: toolCount,
+                    errors: errCount,
+                    wallSeconds: elapsed,
+                    usage: cumUsage,
+                    model: result.model,
+                    provider: result.provider,
+                    compression: cumCompression.tokensSaved > 0 ? cumCompression : undefined,
+                }));
+            }
+            // ── Plan 11 / Slice 2: orchestrator emits phase event ─────────
+            const phaseEndMs = Date.now();
+            const taskRecord = readTaskRecord(taskId, storeCli, cwd);
+            const sprintId = taskRecord?.sprintId;
+            if (!sprintId) {
+                ctx.ui.notify(`⚠ forge:run-task — could not resolve sprintId for ${taskId}; ` +
+                    `skipping orchestrator emit for phase ${phase.role}`, "warning");
+                writeDebug({ kind: "emit_skipped", reason: "no-sprintId" });
+            }
+            else {
+                const phaseIteration = (iterationCounts[phase.role] ?? 0) + 1;
+                const emitCtx = {
+                    entityType: "task",
+                    taskId,
+                    sprintId,
+                    phase,
+                    iteration: phaseIteration,
+                    startMs: phaseStart,
+                    endMs: phaseEndMs,
+                    model: result.model ?? "unknown",
+                    provider: result.provider ?? "unknown",
+                    usage: {
+                        input: result.usage.input,
+                        output: result.usage.output,
+                        cacheRead: result.usage.cacheRead,
+                        cacheWrite: result.usage.cacheWrite,
+                    },
+                    judgement: judgementFromSummary(taskRecord, phase.role),
+                    storeCli,
+                    cwd,
                 };
+                const phaseEvent = buildPhaseEvent(emitCtx);
+                const emitResult = emitEvent(storeCli, cwd, sprintId, phaseEvent);
+                if (!emitResult.ok) {
+                    ctx.ui.notify(`⚠ forge:run-task — phase event emit failed for ${phase.role}: ${emitResult.stderr.trim()}`, "warning");
+                    writeDebug({ kind: "emit_failed", stderr: emitResult.stderr });
+                }
+                else {
+                    writeDebug({ kind: "emit_ok", eventId: phaseEvent.eventId });
+                }
+                // Notify sprint-level observer (FORGE-S21-T03).
+                if (onPhaseEvent)
+                    onPhaseEvent(phaseEvent);
+                // Drain friction file for this phase, if any.
+                const frictionPath = path.join(cwd, ".forge", "cache", `FRICTION-${phase.role}.jsonl`);
+                const drain = drainFrictionFile(frictionPath, emitCtx);
+                if (drain.emitted + drain.failed > 0) {
+                    writeDebug({ kind: "friction_drain", ...drain });
+                    if (drain.failed > 0) {
+                        ctx.ui.notify(`⚠ forge:run-task — friction drain for ${phase.role}: ${drain.emitted} ok, ${drain.failed} failed`, "warning");
+                    }
+                }
             }
-            if (verdict === "revision") {
-                // Increment iteration count for this review phase
-                iterationCounts[phase.role] = (iterationCounts[phase.role] ?? 0) + 1;
-                if (iterationCounts[phase.role] >= phase.maxIterations) {
-                    ctx.ui.notify(`× forge:run-task — revision cap reached for phase ${phase.role} ` +
-                        `(${iterationCounts[phase.role]}/${phase.maxIterations} iterations). Escalating.`, "error");
+            // ── 6b. Verdict check (review phases only) ────────────────────
+            if (phase.isReview) {
+                const verdict = readVerdict(taskId, phase.role, storeCli, cwd);
+                if (verdict === "missing") {
+                    ctx.ui.notify(`× forge:run-task — verdict missing for phase ${phase.role} after subagent completed. ` +
+                        "Subagent may have crashed or failed to write summaries. Escalating.", "error");
                     writeState(cwd, {
                         taskId,
                         phaseIndex: currentPhaseIndex,
                         iterationCounts,
                         halted: true,
-                        lastError: `revision cap reached for ${phase.role}`,
+                        lastError: `verdict missing for ${phase.role}`,
                         savedAt: new Date().toISOString(),
                     });
                     return {
-                        status: "escalated",
+                        status: "failed",
                         lastPhaseIndex: currentPhaseIndex,
                         iterationCounts,
-                        lastError: `revision cap reached for ${phase.role}`,
+                        lastError: `verdict missing for ${phase.role}`,
                     };
                 }
-                // Loop back to predecessor non-review phase
-                const predIndex = findPredecessorIndex(PHASES, currentPhaseIndex);
-                ctx.ui.notify(`⟳ forge:run-task — ${phase.role} returned revision; looping to ${PHASES[predIndex]?.role ?? predIndex} ` +
-                    `(attempt ${iterationCounts[phase.role]}/${phase.maxIterations})`, "info");
-                // Write intermediate state (not halted — still running)
-                writeState(cwd, {
-                    taskId,
-                    phaseIndex: predIndex,
-                    iterationCounts,
-                    halted: false,
-                    savedAt: new Date().toISOString(),
-                });
-                currentPhaseIndex = predIndex;
-                continue;
+                if (verdict === "revision") {
+                    // Increment iteration count for this review phase
+                    iterationCounts[phase.role] = (iterationCounts[phase.role] ?? 0) + 1;
+                    if (iterationCounts[phase.role] >= phase.maxIterations) {
+                        ctx.ui.notify(`× forge:run-task — revision cap reached for phase ${phase.role} ` +
+                            `(${iterationCounts[phase.role]}/${phase.maxIterations} iterations). Escalating.`, "error");
+                        writeState(cwd, {
+                            taskId,
+                            phaseIndex: currentPhaseIndex,
+                            iterationCounts,
+                            halted: true,
+                            lastError: `revision cap reached for ${phase.role}`,
+                            savedAt: new Date().toISOString(),
+                        });
+                        return {
+                            status: "escalated",
+                            lastPhaseIndex: currentPhaseIndex,
+                            iterationCounts,
+                            lastError: `revision cap reached for ${phase.role}`,
+                        };
+                    }
+                    // Loop back to predecessor non-review phase
+                    const predIndex = findPredecessorIndex(PHASES, currentPhaseIndex);
+                    ctx.ui.notify(`⟳ forge:run-task — ${phase.role} returned revision; looping to ${PHASES[predIndex]?.role ?? predIndex} ` +
+                        `(attempt ${iterationCounts[phase.role]}/${phase.maxIterations})`, "info");
+                    orchTranscript.record({
+                        kind: "phase-loopback",
+                        ts: new Date().toISOString(),
+                        fromPhase: phase.role,
+                        toPhase: PHASES[predIndex]?.role ?? String(predIndex),
+                        fromPhaseIndex: currentPhaseIndex,
+                        toPhaseIndex: predIndex,
+                        reason: `${phase.role} returned revision (attempt ${iterationCounts[phase.role]}/${phase.maxIterations})`,
+                    });
+                    // Write intermediate state (not halted — still running)
+                    writeState(cwd, {
+                        taskId,
+                        phaseIndex: predIndex,
+                        iterationCounts,
+                        halted: false,
+                        savedAt: new Date().toISOString(),
+                    });
+                    currentPhaseIndex = predIndex;
+                    continue;
+                }
+                // verdict === "approved": fall through to advance
             }
-            // verdict === "approved": fall through to advance
+            // ── Advance to next phase ─────────────────────────────────────
+            registry.completePhase(taskId, phase.role, "completed");
+            writeState(cwd, {
+                taskId,
+                phaseIndex: currentPhaseIndex,
+                iterationCounts,
+                halted: false,
+                savedAt: new Date().toISOString(),
+            });
+            currentPhaseIndex++;
         }
-        // ── Advance to next phase ─────────────────────────────────────
-        registry.completePhase(taskId, phase.role, "completed");
-        writeState(cwd, {
-            taskId,
-            phaseIndex: currentPhaseIndex,
-            iterationCounts,
-            halted: false,
-            savedAt: new Date().toISOString(),
+        // ── All phases complete ───────────────────────────────────────────
+        deleteState(cwd, taskId);
+        orchTranscript.record({
+            kind: "pipeline-end",
+            ts: new Date().toISOString(),
+            outcome: "complete",
+            elapsedMs: Date.now() - pipelineStartMs,
         });
-        currentPhaseIndex++;
+        return {
+            status: "completed",
+            lastPhaseIndex: PHASES.length - 1,
+            iterationCounts,
+            model: lastModel,
+            provider: lastProvider,
+        };
+    }
+    finally {
+        ctx.ui.notify = __origNotify;
     }
-    // ── All phases complete ───────────────────────────────────────────
-    deleteState(cwd, taskId);
-    return {
-        status: "completed",
-        lastPhaseIndex: PHASES.length - 1,
-        iterationCounts,
-        model: lastModel,
-        provider: lastProvider,
-    };
 }
 export function registerRunTask(pi, options = {}) {
     pi.registerCommand("forge:run-task", {