@tagma/sdk 0.6.12 → 0.7.1

package/dist/core/task-executor.js

@@ -0,0 +1,623 @@
+import { resolve } from 'path';
+import { runCommand, runSpawn } from '../runner';
+import { parseDuration, nowISO } from '../utils';
+import { promptDocumentFromString, serializePromptDocument, prependContext, renderInputsBlock, renderOutputSchemaBlock, } from '../prompt-doc';
+import { resolveTaskBindingInputs, resolveTaskInputs, substituteInputs } from '../ports';
+import { executeHook, buildTaskContext } from '../hooks';
+import { clip, tailLines } from '../logger';
+import { extractSuccessfulOutputs, inferEffectivePorts } from './dataflow';
+import { TriggerBlockedError, TriggerTimeoutError } from './trigger-errors';
+const MAX_NORMALIZED_BYTES = 1_000_000;
+function isPromptTaskConfig(task) {
+    return task.prompt !== undefined && task.command === undefined;
+}
+function isCommandTaskConfig(task) {
+    return task.command !== undefined && task.prompt === undefined;
+}
+export async function executeTask(options) {
+    const { taskId, ctx, registry, log, approvalGateway } = options;
+    const dag = ctx.dag;
+    const config = ctx.config;
+    const workDir = ctx.workDir;
+    const pipelineInfo = ctx.pipelineInfo;
+    const state = ctx.states.get(taskId);
+    const node = dag.nodes.get(taskId);
+    const task = node.task;
+    const track = node.track;
+    log.section(`Task ${taskId}`, taskId);
+    log.debug(`[task:${taskId}]`, `type=${isPromptTaskConfig(task) ? 'ai' : 'cmd'} track=${track.id} deps=[${node.dependsOn.join(', ') || '(root)'}]`);
+    // 1. Check dependencies
+    for (const depId of node.dependsOn) {
+        const result = ctx.isDependencySatisfied(depId);
+        if (result === 'skip') {
+            const depStatus = ctx.states.get(depId)?.status ?? 'unknown';
+            log.debug(`[task:${taskId}]`, `skipped (upstream "${depId}" status=${depStatus})`);
+            state.finishedAt = nowISO();
+            ctx.setTaskStatus(taskId, 'skipped');
+            return;
+        }
+        if (result === 'unsatisfied')
+            return; // still waiting
+    }
+    // 2. Check trigger
+    if (task.trigger) {
+        log.debug(`[task:${taskId}]`, `trigger wait: type=${task.trigger.type} ${JSON.stringify(task.trigger)}`);
+        try {
+            const triggerPlugin = registry.getHandler('triggers', task.trigger.type);
+            // R6: race the plugin's watch() against the pipeline's abort signal
+            // AND the task-level timeout. Third-party triggers may forget to
+            // wire up ctx.signal — without the abort race, an aborted pipeline
+            // would hang forever waiting for the plugin's watch promise to
+            // resolve. And without the timeout race, a buggy watch() that never
+            // settles would ignore the user's `task.timeout` (which the spawn
+            // path at step 4 already honours) — a task could wedge the whole
+            // pipeline until pipeline-level timeout fires (or forever, if none
+            // is set). Honouring task.timeout here makes the two stages
+            // symmetric. The cleanup paths in finally never run on the orphaned
+            // plugin promise (it's allowed to leak a watcher; the pipeline is
+            // being torn down anyway).
+            const triggerTimeoutMs = task.timeout ? parseDuration(task.timeout) : 0;
+            await new Promise((resolve, reject) => {
+                let settled = false;
+                let timer = null;
+                const onAbort = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timer !== null)
+                        clearTimeout(timer);
+                    reject(new Error('Pipeline aborted'));
+                };
+                if (ctx.abortController.signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                ctx.abortController.signal.addEventListener('abort', onAbort, { once: true });
+                if (triggerTimeoutMs > 0) {
+                    timer = setTimeout(() => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        ctx.abortController.signal.removeEventListener('abort', onAbort);
+                        reject(new TriggerTimeoutError(`Trigger "${task.trigger.type}" did not settle within ${task.timeout} (task-level timeout)`));
+                    }, triggerTimeoutMs);
+                }
+                triggerPlugin
+                    .watch(task.trigger, {
+                    taskId: node.taskId,
+                    trackId: track.id,
+                    workDir: task.cwd ?? workDir,
+                    signal: ctx.abortController.signal,
+                    approvalGateway,
+                })
+                    .then((v) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timer !== null)
+                        clearTimeout(timer);
+                    ctx.abortController.signal.removeEventListener('abort', onAbort);
+                    resolve(v);
+                }, (e) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    if (timer !== null)
+                        clearTimeout(timer);
+                    ctx.abortController.signal.removeEventListener('abort', onAbort);
+                    reject(e);
+                });
+            });
+            log.debug(`[task:${taskId}]`, `trigger fired`);
+        }
+        catch (err) {
+            // If pipeline was aborted while we were still waiting for the trigger,
+            // this task never entered running state → skipped, not timeout.
+            state.finishedAt = nowISO();
+            if (ctx.abortReason !== null) {
+                ctx.setTaskStatus(taskId, 'skipped');
+            }
+            else if (err instanceof TriggerBlockedError) {
+                ctx.setTaskStatus(taskId, 'blocked'); // user/policy rejection
+            }
+            else if (err instanceof TriggerTimeoutError) {
+                ctx.setTaskStatus(taskId, 'timeout'); // genuine trigger wait timeout
+            }
+            else {
+                // A7 fallback: also check message strings for backward-compat with
+                // third-party trigger plugins that don't throw typed errors yet.
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg.includes('rejected') || msg.includes('denied')) {
+                    ctx.setTaskStatus(taskId, 'blocked');
+                }
+                else if (msg.includes('timeout')) {
+                    ctx.setTaskStatus(taskId, 'timeout');
+                }
+                else {
+                    ctx.setTaskStatus(taskId, 'failed'); // plugin error, watcher crash, etc.
+                }
+            }
+            try {
+                await ctx.fireHook(taskId, 'task_failure');
+            }
+            catch (hookErr) {
+                log.error(`[task:${taskId}]`, `hook execution failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`);
+            }
+            return;
+        }
+    }
+    // 3. task_start hook (gate)
+    const hookResult = await executeHook(config.hooks, 'task_start', buildTaskContext('task_start', pipelineInfo, ctx.trackInfoOf(taskId), ctx.buildTaskInfoObj(taskId)), workDir, ctx.abortController.signal);
+    if (hookResult.exitCode !== 0 || config.hooks?.task_start) {
+        log.debug(`[task:${taskId}]`, `task_start hook exit=${hookResult.exitCode} allowed=${hookResult.allowed}`);
+    }
+    if (!hookResult.allowed) {
+        state.finishedAt = nowISO();
+        ctx.setTaskStatus(taskId, 'blocked');
+        try {
+            await ctx.fireHook(taskId, 'task_failure');
+        }
+        catch (hookErr) {
+            log.error(`[task:${taskId}]`, `hook execution failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`);
+        }
+        return;
+    }
+    // 3.5. Resolve port inputs from upstream outputs. This is the last
+    // gate before execution: missing-required inputs block the task
+    // without ever spawning a process, so the caller sees a clear
+    // "blocked: missing input X" rather than a cryptic runtime error
+    // from a command that expanded a placeholder to the empty string.
+    // Resolution runs even for tasks that declare no ports — the call
+    // is cheap and returns `{kind: 'ready', inputs: {}}` in that case,
+    // which downstream code handles uniformly.
+    //
+    // Prompt Tasks have no declared ports — their I/O contract is
+    // inferred from direct-neighbor Command Tasks (see ports.ts:
+    // `inferPromptPorts`). We synthesize a `TaskPorts` object and
+    // feed it into the same resolve/substitute/render/extract
+    // pipeline the Command path uses. Collisions that a Prompt can't
+    // disambiguate (same input name on two upstreams, incompatible
+    // downstream output types) block the task with a clear message.
+    const effectivePortsResult = inferEffectivePorts(ctx, taskId);
+    if (effectivePortsResult.kind === 'blocked') {
+        log.error(`[task:${taskId}]`, `blocked — prompt port inference failed:\n${effectivePortsResult.reason}`);
+        state.result = {
+            exitCode: -1,
+            stdout: '',
+            stderr: `[engine] prompt port inference failed:\n${effectivePortsResult.reason}`,
+            stdoutPath: null,
+            stderrPath: null,
+            durationMs: 0,
+            sessionId: null,
+            normalizedOutput: null,
+            failureKind: 'spawn_error',
+            outputs: null,
+        };
+        state.finishedAt = nowISO();
+        ctx.setTaskStatus(taskId, 'blocked');
+        try {
+            await ctx.fireHook(taskId, 'task_failure');
+        }
+        catch (hookErr) {
+            log.error(`[task:${taskId}]`, `hook execution failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`);
+        }
+        if (ctx.getOnFailure(taskId) === 'stop_all')
+            ctx.applyStopAll();
+        return;
+    }
+    const isPromptTask = effectivePortsResult.isPromptTask;
+    const effectivePorts = effectivePortsResult.effectivePorts;
+    const bindingResolution = resolveTaskBindingInputs(task, ctx.bindingDataMap, node.dependsOn);
+    if (bindingResolution.kind === 'blocked') {
+        log.error(`[task:${taskId}]`, `blocked — cannot resolve task input bindings:\n${bindingResolution.reason}`);
+        state.result = {
+            exitCode: -1,
+            stdout: '',
+            stderr: `[engine] task input binding resolution failed:\n${bindingResolution.reason}`,
+            stdoutPath: null,
+            stderrPath: null,
+            durationMs: 0,
+            sessionId: null,
+            normalizedOutput: null,
+            failureKind: 'spawn_error',
+            outputs: null,
+        };
+        state.finishedAt = nowISO();
+        ctx.setTaskStatus(taskId, 'blocked');
+        try {
+            await ctx.fireHook(taskId, 'task_failure');
+        }
+        catch (hookErr) {
+            log.error(`[task:${taskId}]`, `hook execution failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`);
+        }
+        if (ctx.getOnFailure(taskId) === 'stop_all')
+            ctx.applyStopAll();
+        return;
+    }
+    if (bindingResolution.missingOptional.length > 0) {
+        log.debug(`[task:${taskId}]`, `optional input bindings unresolved (empty in placeholders): ${bindingResolution.missingOptional.join(', ')}`);
+    }
+    let inferredPromptInputs = {};
+    if (isPromptTask && effectivePorts?.inputs && effectivePorts.inputs.length > 0) {
+        const inputResolution = resolveTaskInputs({ ...task, ports: effectivePorts }, ctx.outputValuesMap, node.dependsOn);
+        if (inputResolution.kind === 'blocked') {
+            log.error(`[task:${taskId}]`, `blocked — cannot resolve inferred prompt inputs:\n${inputResolution.reason}`);
+            state.result = {
+                exitCode: -1,
+                stdout: '',
+                stderr: `[engine] inferred prompt input resolution failed:\n${inputResolution.reason}`,
+                stdoutPath: null,
+                stderrPath: null,
+                durationMs: 0,
+                sessionId: null,
+                normalizedOutput: null,
+                failureKind: 'spawn_error',
+                outputs: null,
+            };
+            state.finishedAt = nowISO();
+            ctx.setTaskStatus(taskId, 'blocked');
+            try {
+                await ctx.fireHook(taskId, 'task_failure');
+            }
+            catch (hookErr) {
+                log.error(`[task:${taskId}]`, `hook execution failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`);
+            }
+            if (ctx.getOnFailure(taskId) === 'stop_all')
+                ctx.applyStopAll();
+            return;
+        }
+        inferredPromptInputs = inputResolution.inputs;
+    }
+    const resolvedInputs = { ...inferredPromptInputs, ...bindingResolution.inputs };
+    ctx.resolvedInputsMap.set(taskId, resolvedInputs);
+    if (effectivePorts?.inputs && effectivePorts.inputs.length > 0) {
+        log.debug(`[task:${taskId}]`, `resolved inputs: ${JSON.stringify(resolvedInputs)}` +
+            (isPromptTask ? ' (inferred from upstream Commands)' : ''));
+    }
+    // 4. Mark running — set startedAt before emitting so subscribers see a
+    // complete task_update (startedAt non-null) on the status transition.
+    state.startedAt = nowISO();
+    ctx.setTaskStatus(taskId, 'running');
+    log.info(`[task:${taskId}]`, isCommandTaskConfig(task) ? `running: ${task.command}` : `running (driver task)`);
+    // File-only: resolved config for this task
+    const resolvedDriver = task.driver ?? track.driver ?? config.driver ?? 'opencode';
+    const resolvedModel = task.model ?? track.model ?? config.model ?? '(default)';
+    const resolvedPerms = task.permissions ?? track.permissions ?? '(default)';
+    const resolvedCwd = task.cwd ?? track.cwd ?? workDir;
+    log.debug(`[task:${taskId}]`, `resolved: driver=${resolvedDriver} model=${resolvedModel} cwd=${resolvedCwd}`);
+    log.debug(`[task:${taskId}]`, `permissions: ${JSON.stringify(resolvedPerms)}`);
+    if (task.continue_from) {
+        log.debug(`[task:${taskId}]`, `continue_from: "${task.continue_from}"`);
+    }
+    if (task.timeout) {
+        log.debug(`[task:${taskId}]`, `timeout: ${task.timeout}`);
+    }
+    try {
+        let result;
+        const timeoutMs = task.timeout ? parseDuration(task.timeout) : undefined;
+        // Stream child stdout/stderr directly to disk in the logger's run dir
+        // and keep only a bounded tail in the returned TaskResult. Filenames
+        // mirror the existing `.stderr` naming — dots in task ids are replaced
+        // so hierarchical ids (e.g. `track1.task2`) map cleanly to a flat dir.
+        const fsSafeTaskId = taskId.replace(/\./g, '_');
+        const stdoutPath = resolve(log.dir, `${fsSafeTaskId}.stdout`);
+        const stderrPath = resolve(log.dir, `${fsSafeTaskId}.stderr`);
+        const runOpts = {
+            timeoutMs,
+            signal: ctx.abortController.signal,
+            stdoutPath,
+            stderrPath,
+        };
+        if (isCommandTaskConfig(task)) {
+            // Substitute `{{inputs.X}}` placeholders into the command
+            // string. Tasks with no declared inputs always produce the same
+            // string back (no placeholders to match). Unresolved references
+            // render empty — validate-raw flags undeclared references as
+            // errors, so the only way to land here with an unresolved is an
+            // optional input that had no upstream producer and no default,
+            // which we surface in the log.
+            const { text: expandedCommand, unresolved } = substituteInputs(task.command, resolvedInputs);
+            if (unresolved.length > 0) {
+                log.debug(`[task:${taskId}]`, `command placeholders rendered empty: ${unresolved.join(', ')}`);
+            }
+            log.debug(`[task:${taskId}]`, `command: ${expandedCommand}`);
+            result = await runCommand(expandedCommand, task.cwd ?? workDir, runOpts);
+        }
+        else {
+            // AI task: apply middleware chain against a structured PromptDocument.
+            const driverName = task.driver ?? track.driver ?? config.driver ?? 'opencode';
+            const driver = registry.getHandler('drivers', driverName);
+            // Substitute placeholders in the user-authored prompt before
+            // wrapping into a PromptDocument so middlewares see the
+            // already-resolved task text.
+            const { text: expandedPrompt, unresolved } = substituteInputs(task.prompt, resolvedInputs);
+            if (unresolved.length > 0) {
+                log.debug(`[task:${taskId}]`, `prompt placeholders rendered empty: ${unresolved.join(', ')}`);
+            }
+            const originalLen = expandedPrompt.length;
+            let doc = promptDocumentFromString(expandedPrompt);
+            // Prepend port-related context blocks so the model sees them
+            // before any middleware-added retrieval / memory blocks. Order
+            // matters: [Output Format] first (sets the deliverable), then
+            // [Inputs] (the concrete data to operate on). Empty blocks are
+            // filtered out — tasks without ports get no extra blocks at all.
+            const outputFormatBlock = renderOutputSchemaBlock(effectivePorts?.outputs);
+            if (outputFormatBlock) {
+                doc = prependContext(doc, outputFormatBlock);
+            }
+            const inputsBlock = renderInputsBlock(effectivePorts?.inputs, resolvedInputs);
+            if (inputsBlock) {
+                doc = prependContext(doc, inputsBlock);
+            }
+            const mws = task.middlewares !== undefined ? task.middlewares : track.middlewares;
+            if (mws && mws.length > 0) {
+                log.debug(`[task:${taskId}]`, `middleware chain: ${mws.map((m) => m.type).join(' → ')}`);
+                const mwCtx = {
+                    task,
+                    track,
+                    workDir: task.cwd ?? workDir,
+                };
+                for (const mwConfig of mws) {
+                    const mwPlugin = registry.getHandler('middlewares', mwConfig.type);
+                    const beforeBlocks = doc.contexts.length;
+                    const beforeLen = serializePromptDocument(doc).length;
+                    // Prefer the structured API. Fall back to the legacy
+                    // `enhance(string) → string` path so v0.x plugins keep
+                    // working — that fallback loses context structure (the
+                    // middleware's output becomes the new task body) but never
+                    // silently drops content.
+                    if (typeof mwPlugin.enhanceDoc === 'function') {
+                        const next = await mwPlugin.enhanceDoc(doc, mwConfig, mwCtx);
+                        if (!next ||
+                            typeof next !== 'object' ||
+                            !Array.isArray(next.contexts) ||
+                            typeof next.task !== 'string') {
+                            throw new Error(`middleware "${mwConfig.type}".enhanceDoc() returned a malformed PromptDocument`);
+                        }
+                        doc = next;
+                    }
+                    else if (typeof mwPlugin.enhance === 'function') {
+                        const asString = serializePromptDocument(doc);
+                        const next = await mwPlugin.enhance(asString, mwConfig, mwCtx);
+                        // R3: a middleware that returns undefined / null / a non-string
+                        // would silently corrupt the prompt. Fail loud.
+                        if (typeof next !== 'string') {
+                            throw new Error(`middleware "${mwConfig.type}".enhance() returned ${next === null ? 'null' : typeof next}, expected string`);
+                        }
+                        // Legacy fallback: collapse the returned string into a
+                        // fresh doc. Earlier structure is folded into the string
+                        // (serializePromptDocument just ran), so bytes the driver
+                        // sees match the old string pipeline.
+                        doc = { contexts: [], task: next };
+                    }
+                    else {
+                        throw new Error(`middleware "${mwConfig.type}" provides neither enhanceDoc nor enhance`);
+                    }
+                    const afterLen = serializePromptDocument(doc).length;
+                    const addedBlocks = doc.contexts.length - beforeBlocks;
+                    log.debug(`[task:${taskId}]`, `  ${mwConfig.type}: ${beforeLen} → ${afterLen} chars` +
+                        (addedBlocks > 0
+                            ? ` (+${addedBlocks} context block${addedBlocks > 1 ? 's' : ''})`
+                            : ''));
+                }
+            }
+            const prompt = serializePromptDocument(doc);
+            log.debug(`[task:${taskId}]`, `prompt: ${originalLen} chars (final: ${prompt.length} chars, ${doc.contexts.length} block${doc.contexts.length === 1 ? '' : 's'})`);
+            log.quiet(`--- prompt (final) ---\n${clip(prompt)}\n--- end prompt ---`, taskId);
+            // H1: hand the driver a continue_from that has already been
+            // qualified by dag.ts. Without this, drivers like codex/opencode/
+            // claude-code look up maps directly with
+            // the user's raw (possibly bare) string, which races whenever two
+            // tracks share a task name. dag.ts has the only authoritative
+            // resolver, so we use its precomputed answer here.
+            // Drivers key sessionMap/normalizedMap by fully-qualified id. buildDag
+            // guarantees `resolvedContinueFrom` is set for every task that has a
+            // `continue_from`, so if we see the bare form here something upstream
+            // is broken — fail loud instead of silently miskeying the lookup.
+            if (task.continue_from && !node.resolvedContinueFrom) {
+                throw new Error(`Internal: task "${taskId}" has continue_from "${task.continue_from}" ` +
+                    `but no resolvedContinueFrom. buildDag should have qualified it.`);
+            }
+            const enrichedTask = {
+                ...task,
+                prompt,
+                continue_from: node.resolvedContinueFrom,
+            };
+            const driverCtx = {
+                sessionMap: ctx.sessionMap,
+                normalizedMap: ctx.normalizedMap,
+                workDir: task.cwd ?? workDir,
+                // Structured view for drivers that want fine-grained control
+                // over serialization (e.g. inserting [Previous Output] between
+                // contexts and task). Drivers that read task.prompt see the
+                // default serialization and need no changes.
+                promptDoc: doc,
+                // Resolved input values keyed by input name. Typed bindings have
+                // already been coerced when a binding declares `type`.
+                inputs: resolvedInputs,
+            };
+            const spec = await driver.buildCommand(enrichedTask, track, driverCtx);
+            log.debug(`[task:${taskId}]`, `driver=${driverName}`);
+            log.debug(`[task:${taskId}]`, `spawn args: ${JSON.stringify(spec.args)}`);
+            if (spec.cwd)
+                log.debug(`[task:${taskId}]`, `spawn cwd: ${spec.cwd}`);
+            if (spec.env)
+                log.debug(`[task:${taskId}]`, `spawn env overrides: ${Object.keys(spec.env).join(', ')}`);
+            if (spec.stdin)
+                log.debug(`[task:${taskId}]`, `spawn stdin: ${spec.stdin.length} chars`);
+            result = await runSpawn(spec, driver, runOpts);
+        }
+        // 6. Determine terminal status (without emitting yet — result must be complete first)
+        // H2: branch on failureKind so spawn errors no longer masquerade as
+        // timeouts. Old runners that don't set failureKind still work — we
+        // fall back to the historical `exitCode === -1 → timeout` heuristic so
+        // pre-existing third-party drivers don't regress.
+        let terminalStatus;
+        const kind = result.failureKind;
+        if (kind === 'timeout') {
+            terminalStatus = 'timeout';
+        }
+        else if (kind === 'spawn_error') {
+            terminalStatus = 'failed';
+        }
+        else if (kind === undefined && result.exitCode === -1) {
+            // Legacy path: pre-H2 driver returned -1 with no kind. Treat as
+            // timeout for backward compatibility (the previous behaviour).
+            terminalStatus = 'timeout';
+        }
+        else if (result.exitCode !== 0) {
+            terminalStatus = 'failed';
+        }
+        else if (task.completion) {
+            const plugin = registry.getHandler('completions', task.completion.type);
+            const completionCtx = { workDir: task.cwd ?? workDir, signal: ctx.abortController.signal };
+            const passed = await plugin.check(task.completion, result, completionCtx);
+            // R4: strict boolean check. Truthy strings/numbers used to be coerced
+            // to success — a check returning "ok" would let a failing task pass.
+            if (typeof passed !== 'boolean') {
+                throw new Error(`completion "${task.completion.type}".check() returned ${passed === null ? 'null' : typeof passed}, expected boolean`);
+            }
+            terminalStatus = passed ? 'success' : 'failed';
+        }
+        else {
+            terminalStatus = 'success';
+        }
+        // Extract declared outputs from the task's output stream. Only
+        // meaningful on success — a failed task's output is whatever the
+        // child happened to emit before exiting, and downstream tasks
+        // shouldn't receive partial data.
+        let extractedOutputs = null;
+        if (terminalStatus === 'success') {
+            const outputExtraction = extractSuccessfulOutputs({
+                task,
+                effectivePorts,
+                result,
+            });
+            extractedOutputs = outputExtraction.outputs;
+            if (task.outputs && Object.keys(task.outputs).length > 0) {
+                log.debug(`[task:${taskId}]`, `extracted binding outputs: ${JSON.stringify(extractedOutputs ?? {})}`);
+                if (outputExtraction.bindingDiagnostic) {
+                    log.debug(`[task:${taskId}]`, outputExtraction.bindingDiagnostic);
+                    const note = `\n[engine] ${outputExtraction.bindingDiagnostic}`;
+                    result = { ...result, stderr: result.stderr + note };
+                }
+            }
+            if (effectivePorts?.outputs && effectivePorts.outputs.length > 0) {
+                log.debug(`[task:${taskId}]`, `extracted outputs: ${JSON.stringify(extractedOutputs ?? {})}` +
+                    (isPromptTask ? ' (inferred from downstream Commands)' : ''));
+                if (outputExtraction.portDiagnostic) {
+                    log.error(`[task:${taskId}]`, outputExtraction.portDiagnostic);
+                    const note = `\n[engine] ${outputExtraction.portDiagnostic}`;
+                    result = { ...result, stderr: result.stderr + note };
+                }
+            }
+        }
+        // Attach outputs to the result (null when task has no declared
+        // outputs or extraction failed entirely). Consumers of TaskResult
+        // — hooks, wire events, test assertions — all go through this
+        // one field rather than re-running extraction.
+        result = { ...result, outputs: extractedOutputs };
+        if (extractedOutputs !== null) {
+            ctx.outputValuesMap.set(taskId, extractedOutputs);
+        }
+        ctx.bindingDataMap.set(taskId, {
+            outputs: extractedOutputs,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            normalizedOutput: result.normalizedOutput,
+            exitCode: result.exitCode,
+        });
+        // Store normalized text separately (in-memory) for continue_from handoff.
+        // R15: clip oversized values so a runaway parseResult can't accumulate
+        // hundreds of MB across tasks.
+        if (result.normalizedOutput !== null) {
+            const clipped = result.normalizedOutput.length > MAX_NORMALIZED_BYTES
+                ? result.normalizedOutput.slice(0, MAX_NORMALIZED_BYTES) +
+                    `\n[…clipped at ${MAX_NORMALIZED_BYTES} bytes]`
+                : result.normalizedOutput;
+            ctx.normalizedMap.set(taskId, clipped);
+        }
+        // Note: stderr is already persisted by runner.ts as it streams; the
+        // old "write full string after the fact" block is gone — that's what
+        // the streaming rewrite fixed (unbounded in-memory buffering).
+        if (result.sessionId) {
+            // H1: qualified-only key.
+            ctx.sessionMap.set(taskId, result.sessionId);
+        }
+        // Set result and finishedAt before emitting terminal status so listeners see complete state
+        state.result = result;
+        state.finishedAt = nowISO();
+        ctx.setTaskStatus(taskId, terminalStatus);
+        // Log task outcome with relevant details
+        const durSec = (result.durationMs / 1000).toFixed(1);
+        if (terminalStatus === 'success') {
+            log.info(`[task:${taskId}]`, `success (${durSec}s)`);
+        }
+        else {
+            log.error(`[task:${taskId}]`, `${terminalStatus} exit=${result.exitCode} duration=${durSec}s`);
+            if (result.stderr) {
+                const tail = tailLines(result.stderr, 10);
+                log.error(`[task:${taskId}]`, `stderr tail:\n${tail}`);
+            }
+        }
+        // File-only: byte counts (prefer full totals from the runner over the
+        // bounded tail length so oversized outputs show their real size) +
+        // paths to the on-disk full copies.
+        const stdoutSize = result.stdoutBytes ?? result.stdout.length;
+        const stderrSize = result.stderrBytes ?? result.stderr.length;
+        log.debug(`[task:${taskId}]`, `stdout: ${stdoutSize} bytes, stderr: ${stderrSize} bytes`);
+        if (result.sessionId) {
+            log.debug(`[task:${taskId}]`, `sessionId: ${result.sessionId}`);
+        }
+        if (result.stdoutPath) {
+            log.debug(`[task:${taskId}]`, `wrote stdout: ${result.stdoutPath}`);
+        }
+        if (result.stderrPath) {
+            log.debug(`[task:${taskId}]`, `wrote stderr: ${result.stderrPath}`);
+        }
+        if (result.stdout) {
+            log.quiet(`--- stdout (${taskId}) ---\n${clip(result.stdout)}\n--- end stdout ---`, taskId);
+        }
+        if (result.stderr) {
+            log.quiet(`--- stderr (${taskId}) ---\n${clip(result.stderr)}\n--- end stderr ---`, taskId);
+        }
+        if (task.completion) {
+            log.debug(`[task:${taskId}]`, `completion check: type=${task.completion.type} result=${terminalStatus}`);
+        }
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? (err.stack ?? err.message) : String(err);
+        log.error(`[task:${taskId}]`, `failed before execution: ${errMsg}`);
+        state.result = {
+            exitCode: -1,
+            stdout: '',
+            stderr: errMsg,
+            stdoutPath: null,
+            stderrPath: null,
+            stdoutBytes: 0,
+            stderrBytes: errMsg.length,
+            durationMs: 0,
+            sessionId: null,
+            normalizedOutput: null,
+            // H2: Engine-level pre-execution errors (driver throw, middleware
+            // throw, getHandler 404) classify as spawn_error — the process never
+            // ran, so calling them "timeout" was actively misleading.
+            failureKind: 'spawn_error',
+        };
+        state.finishedAt = nowISO();
+        ctx.setTaskStatus(taskId, 'failed');
+    }
+    // 7. Fire hooks
+    const finalStatus = state.status;
+    try {
+        await ctx.fireHook(taskId, finalStatus === 'success' ? 'task_success' : 'task_failure');
+    }
+    catch (hookErr) {
+        log.error(`[task:${taskId}]`, `hook execution failed: ${hookErr instanceof Error ? hookErr.message : String(hookErr)}`);
+    }
+    // 8. Handle stop_all for failure states
+    if (finalStatus !== 'success' && ctx.getOnFailure(taskId) === 'stop_all') {
+        ctx.applyStopAll();
+    }
+}
+//# sourceMappingURL=task-executor.js.map