@tagma/sdk 0.7.4 → 0.7.5

package/dist/core/scheduler.js

@@ -1,35 +0,0 @@
-import { isTerminal } from './run-state';
-import { nowISO } from '../utils';
-/**
- * Return waiting tasks whose dependency states are terminal and which are not
- * already in flight. The caller owns actually launching them.
- */
-export function findLaunchableTasks(ctx, runningTaskIds) {
-    const launchable = [];
-    for (const [id, state] of ctx.states) {
-        if (state.status !== 'waiting' || runningTaskIds.has(id))
-            continue;
-        const node = ctx.dag.nodes.get(id);
-        const allDepsTerminal = node.dependsOn.length === 0 ||
-            node.dependsOn.every((depId) => isTerminal(ctx.states.get(depId).status));
-        if (allDepsTerminal)
-            launchable.push(id);
-    }
-    return launchable;
-}
-export function allTasksTerminal(ctx) {
-    return [...ctx.states.values()].every((state) => isTerminal(state.status));
-}
-/**
- * Abort cleanup helper: after in-flight tasks settle, any remaining
- * non-terminal tasks are waiting/idle tasks that were never started.
- */
-export function skipNonTerminalTasks(ctx, finishedAt = nowISO()) {
-    for (const [id, state] of ctx.states) {
-        if (isTerminal(state.status))
-            continue;
-        state.finishedAt = finishedAt;
-        ctx.setTaskStatus(id, 'skipped');
-    }
-}
-//# sourceMappingURL=scheduler.js.map

package/dist/core/scheduler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../src/core/scheduler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAe,EACf,cAAmC;IAEnC,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,SAAS;QACnE,MAAM,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAE,CAAC;QACpC,MAAM,eAAe,GACnB,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAC7E,IAAI,eAAe;YAAE,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,GAAe;IAC9C,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,GAAe,EACf,UAAU,GAAG,MAAM,EAAE;IAErB,KAAK,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;QACrC,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC;YAAE,SAAS;QACvC,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;QAC9B,GAAG,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;IACnC,CAAC;AACH,CAAC"}

package/dist/core/task-executor.d.ts

@@ -1,13 +0,0 @@
-import type { PluginRegistry } from '../registry';
-import { type Logger } from '../logger';
-import type { ApprovalGateway } from '../approval';
-import type { RunContext } from './run-context';
-export interface ExecuteTaskOptions {
-    readonly taskId: string;
-    readonly ctx: RunContext;
-    readonly registry: PluginRegistry;
-    readonly log: Logger;
-    readonly approvalGateway: ApprovalGateway;
-}
-export declare function executeTask(options: ExecuteTaskOptions): Promise<void>;
-//# sourceMappingURL=task-executor.d.ts.map

package/dist/core/task-executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../src/core/task-executor.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAWlD,OAAO,EAAmB,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAoBhD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0rB5E"}

package/dist/core/task-executor.js

@@ -1,610 +0,0 @@
-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,
-                    runtime: ctx.runtime,
-                })
-                    .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 stdoutPath = ctx.runtime.logStore.taskOutputPath({
-            workDir,
-            runId: ctx.runId,
-            taskId,
-            stream: 'stdout',
-        });
-        const stderrPath = ctx.runtime.logStore.taskOutputPath({
-            workDir,
-            runId: ctx.runId,
-            taskId,
-            stream: '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 ctx.runtime.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;
-                    if (typeof mwPlugin.enhanceDoc !== 'function') {
-                        throw new Error(`middleware "${mwConfig.type}" must provide enhanceDoc`);
-                    }
-                    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;
-                    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 ctx.runtime.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