@revisium/orchestrator 0.2.0-alpha.3 → 0.2.0-alpha.5

package/dist/pipeline/data-driven-task.workflow.js

@@ -1,14 +1,16 @@
 import { step as coreStep, initialState, validateTemplate, InterpretError, selectJoinWinner, reduceJoinVerdict, } from '../pipeline-core/index.js';
-import { runnerNeedsLivePreflight, runnerUsesRealIntegrator } from './route-contract.js';
+import { resolveLaunchOverrides, runnerNeedsLivePreflight } from './route-contract.js';
 import { redactEventPayload } from '../run/append-event.js';
 import { redactSecrets } from '../control-plane/inbox.js';
 import { fnv1a64Hex } from '../control-plane/steps.js';
-import { normalizeIssueRef } from '../run/issue-ref.js';
+import { normalizeIssueAction, normalizeIssueRef } from '../run/issue-ref.js';
 import { RUNNER_IDLE_TIMEOUT_KIND, RUNNER_WALL_CLOCK_LIMIT_KIND, } from '../worker/process-executor.js';
 export const RUN_PROGRESS_EVENT_KEY = 'run-progress';
+export const INTEGRATOR_PROGRESS_EVENT_TYPES = ['integrate_succeeded', 'foreign_pr_adopted'];
 const MAX_STEPS = 1_000;
 const DEFAULT_RUNNER_TRANSIENT_MAX_ATTEMPTS = 2;
 const DEFAULT_RUNNER_TRANSIENT_RETRY_BACKOFF_MS = 2_000;
+const TRANSIENT_RETRY_GATE_OUTCOMES = ['retry', 'give_up'];
 function readPositiveIntegerEnv(env, key, fallback) {
     const raw = env[key];
     if (raw === undefined)
@@ -44,11 +46,12 @@ function physicalAttemptFor(runId, stepKey, attemptNo) {
         attemptId: `attempt_${fnv1a64Hex(attemptKey)}`,
     };
 }
-function stepInputForAttempt(nodeId, inputs, attempt) {
+function stepInputForAttempt(nodeId, inputs, attempt, retryContext) {
     return {
         nodeId,
         attempt: { attemptNo: attempt.attemptNo, attemptId: attempt.attemptId },
         ...(Object.keys(inputs).length > 0 ? { inputs } : {}),
+        ...(retryContext ? { retryContext } : {}),
     };
 }
 function optionalTiming(timing) {
@@ -97,6 +100,19 @@ function nextOrdinal(byNode, nodeId) {
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+function transientRetryGateOutcome(decision) {
+    const answer = isRecord(decision.answer) ? decision.answer : {};
+    let outcome = '';
+    if (typeof decision.outcome === 'string') {
+        outcome = decision.outcome;
+    }
+    else if (typeof answer.outcome === 'string') {
+        outcome = answer.outcome;
+    }
+    if (outcome === 'retry')
+        return 'retry';
+    return 'give_up';
+}
 function producedChangeArtifact(value) {
     if (!isRecord(value))
         return undefined;
@@ -108,10 +124,12 @@ function producedChangeArtifact(value) {
     if (typeof headSha !== 'string' || headSha.trim().length === 0)
         return undefined;
     const issueRef = normalizeArtifactIssueRef(candidate.issueRef);
+    const issueAction = normalizeArtifactIssueAction(candidate.issueAction);
     return {
         branch,
         headSha,
         ...(issueRef ? { issueRef } : {}),
+        ...(issueAction ? { issueAction } : {}),
         ...(typeof candidate.worktreePath === 'string' && candidate.worktreePath.trim() ? { worktreePath: candidate.worktreePath } : {}),
         ...(typeof candidate.artifactRef === 'string' && candidate.artifactRef.trim() ? { artifactRef: candidate.artifactRef } : {}),
         ...(typeof candidate.prNumber === 'number' && Number.isSafeInteger(candidate.prNumber) ? { prNumber: candidate.prNumber } : {}),
@@ -125,7 +143,15 @@ function normalizeArtifactIssueRef(value) {
         return undefined;
     }
 }
-function changeWithRunIssueRef(change, issueRef) {
+function normalizeArtifactIssueAction(value) {
+    try {
+        return normalizeIssueAction(value, 'change.issueAction');
+    }
+    catch {
+        return undefined;
+    }
+}
+function changeWithRunIssueContract(change, issueRef, issueAction) {
     const normalized = { ...change };
     if (issueRef) {
         normalized.issueRef = issueRef;
@@ -133,6 +159,12 @@ function changeWithRunIssueRef(change, issueRef) {
     else {
         delete normalized.issueRef;
     }
+    if (issueAction) {
+        normalized.issueAction = issueAction;
+    }
+    else {
+        delete normalized.issueAction;
+    }
     return normalized;
 }
 function producedChangeFromInputs(inputs) {
@@ -150,7 +182,16 @@ function mergeReadinessFromInputs(inputs) {
     const headSha = value.headSha;
     if (typeof headSha !== 'string' || headSha.trim().length === 0)
         return undefined;
-    return { headSha };
+    const override = isRecord(value.override) && value.override.accepted === true
+        ? { accepted: true }
+        : undefined;
+    return { headSha, ...(override ? { override } : {}) };
+}
+function headShaFromPayload(value) {
+    if (!isRecord(value))
+        return undefined;
+    const headSha = value.headSha;
+    return typeof headSha === 'string' && headSha.trim().length > 0 ? headSha.trim() : undefined;
 }
 function attachProducedChange(output, change) {
     if (isRecord(output))
@@ -162,9 +203,27 @@ function nodeProducesChange(node) {
         node.produces?.name === 'change' &&
         node.resultSchema === 'schema:change';
 }
+function recoveryContextAfterNode(nodeId, recoveryContext) {
+    if (!recoveryContext)
+        return undefined;
+    return nodeId === 'classifyRecovery' ? recoveryContext : null;
+}
 function runnerProducesWorktreeChanges(runnerId) {
     return runnerId === 'claude-code' || runnerId === 'codex';
 }
+const LIVE_WORKTREE_SCRIPT_REFS = new Set([
+    'script:integrator',
+    'script:confirmMerge',
+    'script:pollPr',
+    'script:overrideMerge',
+    'script:respondThreads',
+]);
+function scriptRequiresLiveWorktree(scriptRef) {
+    return LIVE_WORKTREE_SCRIPT_REFS.has(scriptRef);
+}
+function templateRequiresLiveWorktree(template) {
+    return Object.values(template.nodes).some((node) => node.kind === 'script' && scriptRequiresLiveWorktree(node.scriptRef));
+}
 function artifactRefFromResult(result) {
     const artifacts = result.artifacts;
     const processArtifact = isRecord(artifacts) && isRecord(artifacts.process) ? artifacts.process : artifacts;
@@ -199,6 +258,8 @@ function transientKind(reason) {
         return 'timeout';
     if (/\b429\b|rate.?limit|session limit/i.test(reason))
         return 'rate_limit';
+    if (/\b529\b|overloaded/i.test(reason))
+        return 'overloaded';
     if (isLegacyRetryableCrashReason(reason))
         return 'crash';
     return 'unknown';
@@ -275,16 +336,71 @@ function gateVerdict(decision, outcomes) {
         return outcomes[0];
     return outcomes.length > 1 ? outcomes.at(-1) : undefined;
 }
-function gateResolutionOutput(decision, verdict, fallbackInboxId) {
+function gateResolutionMetadata(decision, fallbackInboxId) {
+    const decisionRecord = isRecord(decision) ? decision : {};
+    const answer = isRecord(decision.answer) ? decision.answer : {};
+    const note = decision.note ?? (typeof answer.note === 'string' ? answer.note : undefined);
+    const resolvedBy = decision.resolvedBy ?? (typeof answer.resolvedBy === 'string' ? answer.resolvedBy : '');
+    const resolvedAt = decision.resolvedAt ?? (typeof answer.resolvedAt === 'string' ? answer.resolvedAt : '');
+    const inboxId = decision.inboxId ?? (typeof answer.inboxId === 'string' ? answer.inboxId : fallbackInboxId);
+    const mergeOverrideAudit = answer.mergeOverrideAudit ?? decisionRecord['mergeOverrideAudit'];
+    const adoptionAudit = answer.adoptionAudit ?? decisionRecord['adoptionAudit'];
+    return {
+        ...(note !== undefined ? { note } : {}),
+        resolvedBy,
+        resolvedAt,
+        ...(inboxId !== undefined ? { inboxId } : {}),
+        ...(mergeOverrideAudit !== undefined ? { mergeOverrideAudit } : {}),
+        ...(adoptionAudit !== undefined ? { adoptionAudit } : {}),
+    };
+}
+function gateResolutionOutput(decision, verdict, fallbackInboxId, trustedGateHeadSha) {
+    const resolution = gateResolutionMetadata(decision, fallbackInboxId);
     return {
         outcome: decision.outcome ?? verdict ?? decision.decision,
-        ...(decision.note !== undefined ? { note: decision.note } : {}),
-        resolvedBy: decision.resolvedBy ?? '',
-        resolvedAt: decision.resolvedAt ?? '',
-        inboxId: decision.inboxId ?? fallbackInboxId,
+        ...(resolution.note !== undefined ? { note: resolution.note } : {}),
+        resolvedBy: resolution.resolvedBy,
+        resolvedAt: resolution.resolvedAt,
+        inboxId: resolution.inboxId ?? fallbackInboxId,
+        ...(trustedGateHeadSha !== undefined ? { trustedGateHeadSha } : {}),
+        ...(resolution.mergeOverrideAudit !== undefined ? { mergeOverrideAudit: resolution.mergeOverrideAudit } : {}),
+        ...(resolution.adoptionAudit !== undefined ? { adoptionAudit: resolution.adoptionAudit } : {}),
         ...(decision.decision ? { decision: decision.decision } : {}),
     };
 }
+function nonEmptyString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function isSyntheticGateTimeoutFallback(decision) {
+    const answer = isRecord(decision.answer) ? decision.answer : {};
+    return decision.decision === 'reject' && answer.reason === 'gate-timeout';
+}
+function agentQuestionRetryContext(decision, nodeId, safeLesson) {
+    if (isSyntheticGateTimeoutFallback(decision))
+        return undefined;
+    const resolution = gateResolutionMetadata(decision);
+    const inboxId = nonEmptyString(resolution.inboxId);
+    const resolvedBy = nonEmptyString(resolution.resolvedBy);
+    if (!inboxId || !resolvedBy)
+        return undefined;
+    return {
+        kind: 'agent_question',
+        nodeId,
+        answer: decision.answer,
+        lesson: safeLesson,
+        inboxId,
+        resolvedBy,
+    };
+}
+function unresolvedAgentQuestionLesson(nodeId, safeLesson, decision) {
+    const reason = isSyntheticGateTimeoutFallback(decision)
+        ? 'agent question timed out'
+        : 'agent question resolution is missing inboxId or resolvedBy';
+    return `${reason} for ${nodeId}; original question: ${safeLesson}`;
+}
 function gateTopicFor(reason) {
     if (/merge/i.test(reason))
         return 'merge';
@@ -317,9 +433,29 @@ function gateArtifactView(row, as) {
         payloadRef: `attempt:${row.attemptId ?? ''}`,
     };
 }
-export function buildGateSummary(decision, outputsByNode, lastVerdict) {
+function freshMergeGateArtifact(decision, lastVerdict, lastProducedOutput) {
+    if (decision.nodeId !== 'mergeGate')
+        return undefined;
+    if (lastProducedOutput?.nodeId === 'mergeRecheck' && lastVerdict === 'clean')
+        return lastProducedOutput;
+    if (lastProducedOutput?.nodeId === 'mergeApproveReverify' && lastVerdict === 'recheck')
+        return lastProducedOutput;
+    return undefined;
+}
+function latestBlockedScriptArtifact(decision, recoveryContext) {
+    if (decision.nodeId !== 'recoveryGate')
+        return undefined;
+    const payload = recoveryContext?.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const record = payload;
+    return typeof record.lesson === 'string' && typeof record.reason === 'string' ? recoveryContext : undefined;
+}
+export function buildGateSummary(decision, outputsByNode, lastVerdict, lastProducedOutput, recoveryContext) {
     const summary = { nodeId: decision.nodeId, outcomes: decision.outcomes };
-    const artRow = resolveGateRow(decision.gatedArtifact, outputsByNode);
+    const artRow = latestBlockedScriptArtifact(decision, recoveryContext)
+        ?? freshMergeGateArtifact(decision, lastVerdict, lastProducedOutput)
+        ?? resolveGateRow(decision.gatedArtifact, outputsByNode);
     if (artRow)
         summary.gatedArtifact = gateArtifactView(artRow, decision.gatedArtifact?.as);
     const verdictRow = resolveGateRow(decision.verdictFrom, outputsByNode);
@@ -329,48 +465,133 @@ export function buildGateSummary(decision, outputsByNode, lastVerdict) {
         summary.reviewerVerdict = { verdict: lastVerdict };
     return summary;
 }
+function approvedMergeGateHeadSha(decision, verdict, summary) {
+    if (decision.nodeId !== 'mergeGate')
+        return undefined;
+    if (verdict === 'approved' || verdict === 'override_merge') {
+        return headShaFromPayload(summary.gatedArtifact?.payload) ?? null;
+    }
+    return null;
+}
+function approvedHeadMove(decision, approvedHeadSha, pointer, verdict) {
+    if (decision.nodeId !== 'mergeApproveReverify' || verdict !== 'clean' || approvedHeadSha === undefined)
+        return undefined;
+    const reverifyHeadSha = headShaFromPayload(pointer);
+    if (reverifyHeadSha === undefined || reverifyHeadSha === approvedHeadSha)
+        return undefined;
+    return { approvedHeadSha, reverifyHeadSha };
+}
+function reapprovalRequiredFeedback(pointer, approvedHeadSha, reverifyHeadSha) {
+    if (!isRecord(pointer))
+        return pointer;
+    const evidence = Array.isArray(pointer.evidence)
+        ? pointer.evidence.filter((item) => typeof item === 'string')
+        : [];
+    return {
+        ...pointer,
+        verdict: 'recheck',
+        evidence: [
+            ...evidence,
+            `approved mergeGate headSha=${approvedHeadSha}; reverify headSha=${reverifyHeadSha}; reapproval required`,
+        ],
+    };
+}
+function reopenNodeState(state, nodeId) {
+    return { ...state, activeNodeIds: new Set([nodeId]), status: 'running' };
+}
+function integratorResultPointer(result) {
+    return {
+        prUrl: result.prUrl,
+        branch: result.branch,
+        prNumber: result.prNumber,
+        headSha: result.headSha,
+        status: result.status,
+        ...(result.issueRef ? { issueRef: result.issueRef } : {}),
+        ...(result.foreignPr ? { foreignPr: true } : {}),
+        ...(result.prAuthor ? { prAuthor: result.prAuthor } : {}),
+        ...(result.integratorAccount ? { integratorAccount: result.integratorAccount } : {}),
+    };
+}
+function integratorProgressEventType(result) {
+    return result.foreignPr ? 'foreign_pr_adopted' : 'integrate_succeeded';
+}
+function mergeOverrideEventPayload(result) {
+    const audit = result.override.audit;
+    return {
+        actor: result.override.actor,
+        note: result.override.note,
+        reason: audit?.reason ?? result.override.reason ?? '',
+        risk: audit?.risk ?? '',
+        verificationResponsibility: audit?.verificationResponsibility ?? '',
+        headSha: audit?.headSha ?? result.headSha,
+        freshHeadSha: result.headSha,
+        prNumber: result.prNumber,
+        source: result.override.source,
+        overriddenFacts: result.override.facts,
+        replied: result.override.replied,
+        resolved: result.override.resolved,
+        ...(result.override.reason ? { refusalReason: result.override.reason } : {}),
+    };
+}
+function scriptGithubAccount(decision, launchBindings) {
+    if (!launchBindings)
+        return undefined;
+    for (let index = launchBindings.length - 1; index >= 0; index -= 1) {
+        const binding = launchBindings[index];
+        if (binding.match.nodeId === decision.nodeId)
+            return binding.accounts?.github;
+    }
+    return undefined;
+}
 export function buildSystemScriptRegistry(deps) {
-    const { appendEvent, releaseWorktreeFn, integrateFn, runStub, confirmMergeFn, runConfirmStub, pollPrFn, runPollStub, respondThreadsFn, runRespondStub } = deps;
-    function buildIntegratorInput(runId, ctx, inputs) {
-        const { taskId, title, base, issueRef } = ctx;
+    const { appendEvent, releaseWorktreeFn, integrateFn, confirmMergeFn, pollPrFn, overrideMergeFn, respondThreadsFn, } = deps;
+    function buildIntegratorInput(runId, ctx, inputs, githubAccount) {
+        const { taskId, title, base, issueRef, issueAction } = ctx;
         const change = producedChangeFromInputs(inputs);
         const mergeReadiness = mergeReadinessFromInputs(inputs);
-        const changeForIntegrator = change ? changeWithRunIssueRef(change, issueRef) : undefined;
+        const changeForIntegrator = change ? changeWithRunIssueContract(change, issueRef, issueAction) : undefined;
         return {
             runId,
             taskId,
             title,
             base,
+            ...(githubAccount ? { githubAccount } : {}),
             ...(issueRef ? { issueRef } : {}),
+            ...(issueAction ? { issueAction } : {}),
             ...(changeForIntegrator ? { change: changeForIntegrator } : {}),
             ...(inputs.triage === undefined ? {} : { triage: inputs.triage }),
+            ...(inputs.gateResolution === undefined ? {} : { gateResolution: inputs.gateResolution }),
             ...(mergeReadiness ? { mergeReadiness } : {}),
         };
     }
     function makeIntegratorScript(desc) {
-        return async ({ runId, decision, ctx, bindingByRef, stepKey, inputs }) => {
-            const integratorInput = buildIntegratorInput(runId, ctx, inputs);
-            const binding = bindingByRef.get(decision.scriptRef) ?? bindingByRef.get('script:integrator');
-            const useReal = !!binding && runnerUsesRealIntegrator(binding.resolvedRunnerId);
+        return async ({ runId, decision, ctx, launchBindings, stepKey, inputs }) => {
+            const integratorInput = buildIntegratorInput(runId, ctx, inputs, scriptGithubAccount(decision, launchBindings));
             let result;
             try {
-                result = useReal ? await desc.real(integratorInput) : desc.stub(integratorInput);
+                result = await desc.real(integratorInput);
             }
             catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
                 await appendEvent({
                     runId, taskId: ctx.taskId, stepId: '', stepKey,
                     type: 'step_failed',
-                    payload: { scriptRef: decision.scriptRef, error: err instanceof Error ? err.message : String(err) },
+                    payload: { scriptRef: decision.scriptRef, error: reason },
                 });
-                return { outcome: 'failed' };
+                return { outcome: 'failed', reason };
             }
             if ('needsHuman' in result) {
+                const pointer = {
+                    reason: desc.blockedReason,
+                    lesson: result.lesson,
+                    nodeId: decision.nodeId,
+                };
                 await appendEvent({
                     runId, taskId: ctx.taskId, stepId: '', stepKey: 'pipeline',
                     type: 'pipeline_blocked',
-                    payload: { reason: desc.blockedReason, lesson: result.lesson, nodeId: decision.nodeId },
+                    payload: pointer,
                 });
-                return { outcome: 'blocked' };
+                return { outcome: 'blocked', pointer };
             }
             const { eventType, payload, pointer, verdict } = desc.mapSuccess(result);
             await appendEvent({ runId, taskId: ctx.taskId, stepId: '', stepKey, type: eventType, payload });
@@ -378,40 +599,52 @@ export function buildSystemScriptRegistry(deps) {
         };
     }
     const cleanupWorktree = async ({ runId, decision, ctx, stepKey }) => {
+        let releaseResult;
         try {
-            await releaseWorktreeFn(runId, ctx.taskId);
+            releaseResult = await releaseWorktreeFn(runId, ctx.taskId);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            await appendEvent({
+                runId,
+                taskId: ctx.taskId,
+                stepId: '',
+                stepKey,
+                type: 'cleanup_failed',
+                payload: { nodeId: decision.nodeId, error, released: false },
+            });
+            return { outcome: 'ok', pointer: { released: false, error } };
+        }
+        if (!releaseResult.released) {
+            const pointer = {
+                released: false,
+                reason: releaseResult.reason,
+                worktreePath: releaseResult.worktreePath,
+            };
+            await appendEvent({
+                runId,
+                taskId: ctx.taskId,
+                stepId: '',
+                stepKey,
+                type: 'cleanup_failed',
+                payload: { nodeId: decision.nodeId, ...pointer },
+            });
+            return { outcome: 'ok', pointer };
         }
-        catch { /* best-effort */ }
         await appendEvent({ runId, taskId: ctx.taskId, stepId: '', stepKey, type: 'worktree_released', payload: { nodeId: decision.nodeId } });
         return { outcome: 'ok', pointer: { released: true } };
     };
     const integratorScript = makeIntegratorScript({
         real: integrateFn,
-        stub: runStub,
         blockedReason: 'integrate',
         mapSuccess: (result) => ({
-            eventType: 'integrate_succeeded',
-            payload: {
-                prUrl: result.prUrl,
-                branch: result.branch,
-                prNumber: result.prNumber,
-                headSha: result.headSha,
-                status: result.status,
-                ...(result.issueRef ? { issueRef: result.issueRef } : {}),
-            },
-            pointer: {
-                prUrl: result.prUrl,
-                branch: result.branch,
-                prNumber: result.prNumber,
-                headSha: result.headSha,
-                status: result.status,
-                ...(result.issueRef ? { issueRef: result.issueRef } : {}),
-            },
+            eventType: integratorProgressEventType(result),
+            payload: integratorResultPointer(result),
+            pointer: integratorResultPointer(result),
         }),
     });
     const confirmMergeScript = makeIntegratorScript({
         real: confirmMergeFn,
-        stub: runConfirmStub,
         blockedReason: 'confirm-merge',
         mapSuccess: (result) => ({
             eventType: 'merge_confirmed',
@@ -430,7 +663,6 @@ export function buildSystemScriptRegistry(deps) {
     });
     const pollPrScript = makeIntegratorScript({
         real: pollPrFn,
-        stub: runPollStub,
         blockedReason: 'poll-pr',
         mapSuccess: (result) => ({
             eventType: 'pr_polled',
@@ -447,9 +679,54 @@ export function buildSystemScriptRegistry(deps) {
             verdict: result.verdict,
         }),
     });
+    const overrideMergeScript = async ({ runId, decision, ctx, launchBindings, stepKey, inputs }) => {
+        const integratorInput = buildIntegratorInput(runId, ctx, inputs, scriptGithubAccount(decision, launchBindings));
+        let result;
+        try {
+            result = await overrideMergeFn(integratorInput);
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            await appendEvent({
+                runId, taskId: ctx.taskId, stepId: '', stepKey,
+                type: 'step_failed',
+                payload: { scriptRef: decision.scriptRef, error: reason },
+            });
+            return { outcome: 'failed', reason };
+        }
+        if ('needsHuman' in result) {
+            const pointer = { reason: 'override-merge', lesson: result.lesson, nodeId: decision.nodeId };
+            await appendEvent({
+                runId, taskId: ctx.taskId, stepId: '', stepKey: 'pipeline',
+                type: 'pipeline_blocked',
+                payload: pointer,
+            });
+            return { outcome: 'blocked', pointer };
+        }
+        if (result.override.replied > 0 || result.override.resolved > 0) {
+            await appendEvent({
+                runId,
+                taskId: ctx.taskId,
+                stepId: '',
+                stepKey,
+                type: 'threads_responded',
+                payload: { replied: result.override.replied, resolved: result.override.resolved },
+            });
+        }
+        if (result.override.accepted || result.verdict !== 'merged') {
+            await appendEvent({
+                runId,
+                taskId: ctx.taskId,
+                stepId: '',
+                stepKey,
+                type: result.override.accepted ? 'merge_overridden' : 'merge_override_refused',
+                payload: mergeOverrideEventPayload(result),
+            });
+        }
+        return { outcome: 'ok', pointer: result, verdict: result.verdict };
+    };
     const respondThreadsScript = makeIntegratorScript({
         real: respondThreadsFn,
-        stub: runRespondStub,
         blockedReason: 'respond-threads',
         mapSuccess: (result) => ({
             eventType: 'threads_responded',
@@ -461,8 +738,8 @@ export function buildSystemScriptRegistry(deps) {
         ['script:cleanupWorktree', cleanupWorktree],
         ['script:confirmMerge', confirmMergeScript],
         ['script:pollPr', pollPrScript],
+        ['script:overrideMerge', overrideMergeScript],
         ['script:respondThreads', respondThreadsScript],
-        // Unknown refs fall through to this entry, matching the original else-branch behavior.
         ['script:integrator', integratorScript],
     ]);
 }
@@ -501,7 +778,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
     }
     async function recordOutput(runId, node, ordinal, attemptId, output, outputsByNode) {
         if (!('produces' in node) || !node.produces)
-            return;
+            return undefined;
         const row = {
             runId,
             nodeId: node.id,
@@ -515,6 +792,23 @@ export function makeDataDrivenTask(runStepFn, deps) {
         list.push(row);
         outputsByNode.set(node.id, list);
         await appendRunOutput(row);
+        return row;
+    }
+    async function recordRecoveryContext(runId, node, ordinal, attemptId, payload, outputsByNode) {
+        const row = {
+            runId,
+            nodeId: node.id,
+            ordinal,
+            name: 'recoveryContext',
+            schemaRef: 'schema:recoveryContext',
+            payload,
+            attemptId,
+        };
+        const list = outputsByNode.get(node.id) ?? [];
+        list.push(row);
+        outputsByNode.set(node.id, list);
+        await appendRunOutput(row);
+        return row;
     }
     return async function dataDrivenTaskImpl(runId, opts) {
         try {
@@ -537,8 +831,9 @@ export function makeDataDrivenTask(runStepFn, deps) {
         if (diagnostics.length > 0) {
             throw new Error(`PINNED_TEMPLATE_INVALID: ${template.pipelineId} — ${diagnostics.map((d) => d.code).join(', ')}`);
         }
-        const { taskId, title, base, issueRef } = await loadRunTaskContext(runId);
-        const live = route.roleBindings.some((b) => runnerNeedsLivePreflight(b.resolvedRunnerId));
+        const { taskId, title, base, issueRef, issueAction } = await loadRunTaskContext(runId);
+        const live = route.roleBindings.some((b) => runnerNeedsLivePreflight(b.resolvedRunnerId)) ||
+            templateRequiresLiveWorktree(template);
         if (live) {
             const pf = await preflightFn(taskId, base);
             if ('needsHuman' in pf) {
@@ -548,27 +843,27 @@ export function makeDataDrivenTask(runStepFn, deps) {
         if (live) {
             await createWorktreeFn(runId, taskId, title, base, issueRef);
         }
-        return runGraph(runId, opts, taskId, title, base, issueRef, live);
+        return runGraph(runId, opts, taskId, title, base, issueRef, issueAction, live);
     }
-    async function runGraph(runId, opts, taskId, title, base, issueRef, live) {
+    async function runGraph(runId, opts, taskId, title, base, issueRef, issueAction, live) {
         const { route, template, runnerRetryPolicy } = opts;
         const bindingByRef = new Map();
         for (const binding of route.roleBindings) {
             bindingByRef.set(`role:${binding.roleId}`, binding);
-            bindingByRef.set(`script:${binding.roleId}`, binding);
             bindingByRef.set(binding.roleId, binding);
-            if (runnerUsesRealIntegrator(binding.resolvedRunnerId) && !bindingByRef.has('script:integrator')) {
-                bindingByRef.set('script:integrator', binding);
-            }
         }
-        const executionProfile = route.executionProfile;
+        const launchBindings = route.launchBindings ?? [];
         let state = initialState(template);
         let lastResult;
         let lastVerdict = '';
+        let lastProducedOutput;
+        let recoveryContext;
         let lastFailureReason = '';
+        let approvedMergeGateHeadShaValue;
         let stepCount = 0;
         const effectOrdinalByNode = new Map();
         const outputsByNode = new Map();
+        const agentQuestionRetryContextByNode = new Map();
         for (let i = 0; i < MAX_STEPS; i++) {
             const { state: nextState, decision } = coreStep(template, state, lastResult);
             state = nextState;
@@ -577,10 +872,13 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 return await finish(runId, decision.status, lastVerdict, stepCount, lastFailureReason);
             }
             const eff = await applyDecision(decision, {
-                runId, template, state, bindingByRef, executionProfile, taskId, title, base, issueRef,
-                effectOrdinalByNode, outputsByNode, runnerRetryPolicy,
+                runId, template, state, bindingByRef, launchBindings, taskId, title, base, issueRef, issueAction,
+                effectOrdinalByNode, outputsByNode, runnerRetryPolicy, agentQuestionRetryContextByNode,
                 live,
                 lastVerdict,
+                lastProducedOutput,
+                recoveryContext,
+                approvedMergeGateHeadSha: approvedMergeGateHeadShaValue,
             });
             stepCount += eff.stepDelta;
             if (eff.terminal) {
@@ -591,12 +889,30 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 await deps.setProgress?.(runId, progressCursor(state, eff.lastResult));
             }
             lastResult = eff.lastResult;
-            if (eff.lastVerdict !== undefined)
-                lastVerdict = eff.lastVerdict;
+            lastVerdict = eff.lastVerdict ?? lastVerdict;
+            lastProducedOutput = eff.producedOutput ?? lastProducedOutput;
+            if ('recoveryContext' in eff)
+                recoveryContext = eff.recoveryContext ?? undefined;
             lastFailureReason = eff.failureReason ?? '';
+            if (eff.approvedMergeGateHeadSha !== undefined) {
+                approvedMergeGateHeadShaValue = eff.approvedMergeGateHeadSha ?? undefined;
+            }
         }
         throw new InterpretError(`data-driven ${template.pipelineId} did not terminate within ${MAX_STEPS} steps (template loop bug)`);
     }
+    function forkBranchArrival(decision, branch, seq, status, lastVerdict) {
+        if (status !== 'succeeded') {
+            throw new InterpretError(`fork ${decision.nodeId} branch ${branch.id} completed ${status} before join ${decision.joinId}`);
+        }
+        return {
+            branchId: branch.id,
+            seq,
+            ...(lastVerdict ? { verdict: lastVerdict } : {}),
+        };
+    }
+    function recoveryContextFromEffect(current, effect) {
+        return 'recoveryContext' in effect ? effect.recoveryContext ?? undefined : current;
+    }
     function branchTemplateForJoin(template, joinId) {
         const join = resolveNode(template, joinId);
         if (join.kind !== 'join')
@@ -648,20 +964,15 @@ export function makeDataDrivenTask(runStepFn, deps) {
         };
         let lastResult;
         let lastVerdict = '';
+        let lastProducedOutput;
+        let recoveryContext;
         let stepDelta = 0;
         for (let i = 0; i < MAX_STEPS; i++) {
             const next = coreStep(branchTemplate, state, lastResult);
             state = next.state;
             if (next.decision.type === 'complete') {
-                if (next.decision.status !== 'succeeded') {
-                    throw new InterpretError(`fork ${decision.nodeId} branch ${branch.id} completed ${next.decision.status} before join ${decision.joinId}`);
-                }
                 return {
-                    arrival: {
-                        branchId: branch.id,
-                        seq,
-                        ...(lastVerdict ? { verdict: lastVerdict } : {}),
-                    },
+                    arrival: forkBranchArrival(decision, branch, seq, next.decision.status, lastVerdict),
                     stepDelta,
                 };
             }
@@ -670,15 +981,17 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 template: branchTemplate,
                 state,
                 lastVerdict,
+                lastProducedOutput,
+                recoveryContext,
             });
             stepDelta += eff.stepDelta;
             if (eff.terminal)
                 return { terminal: eff.terminal, stepDelta };
-            if (eff.stateOverride)
-                state = eff.stateOverride;
+            state = eff.stateOverride ?? state;
             lastResult = eff.lastResult;
-            if (eff.lastVerdict !== undefined)
-                lastVerdict = eff.lastVerdict;
+            lastVerdict = eff.lastVerdict ?? lastVerdict;
+            lastProducedOutput = eff.producedOutput ?? lastProducedOutput;
+            recoveryContext = recoveryContextFromEffect(recoveryContext, eff);
         }
         throw new InterpretError(`fork ${decision.nodeId} branch ${branch.id} did not reach join ${decision.joinId} within ${MAX_STEPS} steps`);
     }
@@ -691,15 +1004,25 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 const stepKey = stepKeyFor(node.id, ordinal);
                 const resolved = resolveConsumes(node, ctx.outputsByNode);
                 if ('missing' in resolved) {
+                    const reason = `${REVO_INPUT_MISSING}: required input ${resolved.missing} was not produced`;
                     await appendEvent({
                         runId, taskId, stepId: '', stepKey, type: 'step_failed',
-                        payload: { nodeId: node.id, error: `${REVO_INPUT_MISSING}: required input ${resolved.missing} was not produced` },
+                        payload: { nodeId: node.id, error: reason },
                     });
-                    return { lastResult: { outcome: 'failed', errorCode: REVO_INPUT_MISSING }, lastVerdict: 'failed', stepDelta: 1 };
+                    return { lastResult: { outcome: 'failed', errorCode: REVO_INPUT_MISSING }, lastVerdict: 'failed', failureReason: reason, stepDelta: 1 };
                 }
                 const result = await invokeRole(runId, decision, node, ctx, resolved.inputs, stepKey);
+                if ('question' in result) {
+                    ctx.agentQuestionRetryContextByNode.set(node.id, result.retryContext);
+                    return {
+                        lastResult: undefined,
+                        stateOverride: reopenNodeState(ctx.state, node.id),
+                        stepDelta: result.attemptsMade,
+                    };
+                }
                 if ('blocked' in result) {
                     if (result.recovery) {
+                        ctx.agentQuestionRetryContextByNode.delete(node.id);
                         const recovery = await awaitVerificationRecoveryGate(runId, ctx, result.recovery);
                         return {
                             lastResult: undefined,
@@ -711,6 +1034,22 @@ export function makeDataDrivenTask(runStepFn, deps) {
                             stepDelta: result.attemptsMade,
                         };
                     }
+                    if (result.retry?.attemptsExhausted) {
+                        const retryOutcome = await awaitTransientRetryGate(runId, ctx, {
+                            node,
+                            stepKey,
+                            binding: resolveRoleBinding(ctx, decision),
+                            retry: result.retry,
+                        });
+                        if (retryOutcome === 'retry') {
+                            return {
+                                lastResult: undefined,
+                                stateOverride: reopenNodeState(ctx.state, node.id),
+                                stepDelta: result.attemptsMade,
+                            };
+                        }
+                    }
+                    ctx.agentQuestionRetryContextByNode.delete(node.id);
                     return {
                         lastResult: undefined,
                         terminal: {
@@ -723,18 +1062,22 @@ export function makeDataDrivenTask(runStepFn, deps) {
                     };
                 }
                 if (result.failed) {
+                    ctx.agentQuestionRetryContextByNode.delete(node.id);
                     await appendEvent({
                         runId, taskId, stepId: '', stepKey, type: 'step_failed',
                         idempotencyKey: result.attemptId,
-                        payload: { nodeId: node.id, error: result.errorCode },
+                        payload: { nodeId: node.id, error: result.errorCode, reason: result.reason },
                     });
                     return { lastResult: { outcome: 'failed', errorCode: result.errorCode }, lastVerdict: 'failed', failureReason: result.reason, stepDelta: result.attemptsMade };
                 }
-                await recordOutput(runId, node, ordinal, result.attemptId, result.output, ctx.outputsByNode);
+                ctx.agentQuestionRetryContextByNode.delete(node.id);
+                const producedOutput = await recordOutput(runId, node, ordinal, result.attemptId, result.output, ctx.outputsByNode);
                 const verdict = result.verdict;
                 return {
                     lastResult: { outcome: 'succeeded', ...(verdict ? { verdict } : {}) },
                     ...(verdict ? { lastVerdict: verdict } : {}),
+                    ...(producedOutput ? { producedOutput } : {}),
+                    ...(ctx.recoveryContext ? { recoveryContext: recoveryContextAfterNode(node.id, ctx.recoveryContext) } : {}),
                     stepDelta: result.attemptsMade,
                 };
             }
@@ -743,30 +1086,64 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 const ordinal = nextOrdinal(ctx.effectOrdinalByNode, node.id);
                 const resolved = resolveConsumes(node, ctx.outputsByNode);
                 if ('missing' in resolved) {
+                    const reason = `${REVO_INPUT_MISSING}: required input ${resolved.missing} was not produced`;
                     await appendEvent({
                         runId, taskId, stepId: '', stepKey: stepKeyFor(node.id, ordinal), type: 'step_failed',
-                        payload: { nodeId: node.id, error: `${REVO_INPUT_MISSING}: required input ${resolved.missing} was not produced` },
+                        payload: { nodeId: node.id, error: reason },
                     });
-                    return { lastResult: { outcome: 'failed', errorCode: REVO_INPUT_MISSING }, lastVerdict: 'failed', stepDelta: 1 };
+                    return { lastResult: { outcome: 'failed', errorCode: REVO_INPUT_MISSING }, lastVerdict: 'failed', failureReason: reason, stepDelta: 1 };
                 }
-                const scriptResult = await invokeScript(runId, decision, { taskId, title, base, issueRef: ctx.issueRef }, bindingByRef, stepKeyFor(node.id, ordinal), resolved.inputs);
+                const scriptResult = await invokeScript(runId, decision, { taskId, title, base, issueRef: ctx.issueRef, issueAction: ctx.issueAction }, bindingByRef, ctx.launchBindings, stepKeyFor(node.id, ordinal), resolved.inputs);
                 if (scriptResult.outcome === 'blocked') {
-                    return { lastResult: { outcome: 'failed', errorCode: REVO_SCRIPT_BLOCKED }, lastVerdict: 'blocked', stepDelta: 1 };
+                    const recoveryContext = scriptResult.pointer === undefined
+                        ? undefined
+                        : await recordRecoveryContext(runId, node, ordinal, stepKeyFor(node.id, ordinal), scriptResult.pointer, ctx.outputsByNode);
+                    return {
+                        lastResult: { outcome: 'failed', errorCode: REVO_SCRIPT_BLOCKED },
+                        lastVerdict: 'blocked',
+                        ...(recoveryContext ? { recoveryContext } : {}),
+                        stepDelta: 1,
+                    };
                 }
                 if (scriptResult.outcome === 'failed') {
-                    return { lastResult: { outcome: 'failed', errorCode: REVO_SCRIPT_FAILED }, lastVerdict: 'failed', stepDelta: 1 };
+                    const reason = scriptResult.reason ? `${REVO_SCRIPT_FAILED}: ${scriptResult.reason}` : REVO_SCRIPT_FAILED;
+                    return { lastResult: { outcome: 'failed', errorCode: REVO_SCRIPT_FAILED }, lastVerdict: 'failed', recoveryContext: null, failureReason: reason, stepDelta: 1 };
+                }
+                let pointer = scriptResult.pointer;
+                let sv = scriptResult.verdict;
+                let stateOverride;
+                const headMove = approvedHeadMove(decision, ctx.approvedMergeGateHeadSha, pointer, sv);
+                if (headMove) {
+                    pointer = reapprovalRequiredFeedback(pointer, headMove.approvedHeadSha, headMove.reverifyHeadSha);
+                    sv = 'recheck';
+                    stateOverride = reopenNodeState(ctx.state, 'mergeGate');
                 }
-                await recordOutput(runId, node, ordinal, stepKeyFor(node.id, ordinal), scriptResult.pointer, ctx.outputsByNode);
-                const sv = scriptResult.verdict;
-                return { lastResult: { outcome: 'succeeded', ...(sv ? { verdict: sv } : {}) }, ...(sv ? { lastVerdict: sv } : {}), stepDelta: 1 };
+                const producedOutput = await recordOutput(runId, node, ordinal, stepKeyFor(node.id, ordinal), pointer, ctx.outputsByNode);
+                return {
+                    lastResult: stateOverride ? undefined : { outcome: 'succeeded', ...(sv ? { verdict: sv } : {}) },
+                    ...(sv ? { lastVerdict: sv } : {}),
+                    ...(producedOutput ? { producedOutput } : {}),
+                    ...(ctx.recoveryContext ? { recoveryContext: recoveryContextAfterNode(node.id, ctx.recoveryContext) } : {}),
+                    ...(stateOverride ? { stateOverride } : {}),
+                    stepDelta: 1,
+                };
             }
             case 'awaitGate': {
                 const topic = gateTopicFor(decision.reason);
                 const ordinal = nextOrdinal(ctx.effectOrdinalByNode, decision.nodeId);
-                const human = await awaitHuman(runId, topic, stepKeyFor(decision.nodeId, ordinal), `${decision.reason} approval`, buildGateSummary(decision, ctx.outputsByNode, ctx.lastVerdict), decision.outcomes);
+                const summary = buildGateSummary(decision, ctx.outputsByNode, ctx.lastVerdict, ctx.lastProducedOutput, ctx.recoveryContext);
+                const human = await awaitHuman(runId, topic, stepKeyFor(decision.nodeId, ordinal), `${decision.reason} approval`, summary, decision.outcomes);
                 const verdict = gateVerdict(human, decision.outcomes);
-                await recordOutput(runId, resolveNode(template, decision.nodeId), ordinal, stepKeyFor(decision.nodeId, ordinal), gateResolutionOutput(human, verdict, stepKeyFor(decision.nodeId, ordinal)), ctx.outputsByNode);
-                return { lastResult: verdict ? { verdict } : {}, ...(verdict ? { lastVerdict: verdict } : {}), stepDelta: 0 };
+                const approvedHeadSha = approvedMergeGateHeadSha(decision, verdict, summary);
+                const producedOutput = await recordOutput(runId, resolveNode(template, decision.nodeId), ordinal, stepKeyFor(decision.nodeId, ordinal), gateResolutionOutput(human, verdict, stepKeyFor(decision.nodeId, ordinal), approvedHeadSha), ctx.outputsByNode);
+                return {
+                    lastResult: verdict ? { verdict } : {},
+                    ...(verdict ? { lastVerdict: verdict } : {}),
+                    ...(producedOutput ? { producedOutput } : {}),
+                    ...(decision.nodeId === 'recoveryGate' ? { recoveryContext: null } : {}),
+                    ...(approvedHeadSha !== undefined ? { approvedMergeGateHeadSha: approvedHeadSha } : {}),
+                    stepDelta: 0,
+                };
             }
             case 'fork': {
                 await appendEvent({
@@ -783,9 +1160,43 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 return { lastResult: {}, stepDelta: 0 };
         }
     }
+    async function awaitTransientRetryGate(runId, ctx, input) {
+        const outcomes = [...TRANSIENT_RETRY_GATE_OUTCOMES];
+        const decision = await awaitHuman(runId, 'retry', `transientRetry:${input.stepKey}`, `Retry ${input.node.id} after transient runner failure`, {
+            kind: 'transient_retry',
+            runId,
+            taskId: ctx.taskId,
+            nodeId: input.node.id,
+            step: input.stepKey,
+            role: input.binding.rowId,
+            runner: input.binding.resolvedRunnerId,
+            reason: input.retry.reason,
+            lesson: input.retry.lesson,
+            attemptsExhausted: input.retry.attemptsExhausted,
+            attemptsMade: input.retry.attemptsMade,
+            maxAttempts: input.retry.maxAttempts,
+            attemptIds: input.retry.attemptIds,
+            lastAttemptId: input.retry.lastAttemptId,
+            ...(input.retry.failureKind ? { failureKind: input.retry.failureKind } : {}),
+            ...(input.retry.transientKind ? { transientKind: input.retry.transientKind } : {}),
+            ...(input.retry.timing !== undefined ? { timing: input.retry.timing } : {}),
+            reconcile: { default: 'keep', supported: ['keep'] },
+            outcomes,
+        }, outcomes);
+        return transientRetryGateOutcome(decision);
+    }
     async function invokeRole(runId, decision, node, ctx, inputs, stepKey) {
         const binding = resolveRoleBinding(ctx, decision);
-        return invokeRoleAttempts({ runId, decision, node, ctx, inputs, stepKey, binding });
+        return invokeRoleAttempts({
+            runId,
+            decision,
+            node,
+            ctx,
+            inputs,
+            stepKey,
+            binding,
+            retryContext: ctx.agentQuestionRetryContextByNode.get(node.id),
+        });
     }
     function resolveRoleBinding(ctx, decision) {
         const binding = ctx.bindingByRef.get(decision.roleRef);
@@ -797,20 +1208,24 @@ export function makeDataDrivenTask(runStepFn, deps) {
     async function invokeRoleAttempts(input) {
         const { runId, decision, node, ctx, inputs, stepKey, binding } = input;
         const attemptIds = [];
+        const retryContext = input.retryContext;
         for (let attemptNo = 1; attemptNo <= ctx.runnerRetryPolicy.maxAttempts; attemptNo++) {
             const physicalAttempt = physicalAttemptFor(runId, stepKey, attemptNo);
             attemptIds.push(physicalAttempt.attemptId);
-            const result = await runStepFn(runId, binding.rowId, stepKey, stepInputForAttempt(decision.nodeId, inputs, physicalAttempt), binding.resolvedRunnerId, ctx.executionProfile, physicalAttempt, ctx.template.verdicts.domain);
+            const launchOverrides = resolveLaunchOverrides(binding, decision.nodeId, ctx.launchBindings);
+            const result = await runStepFn(runId, binding.rowId, stepKey, stepInputForAttempt(decision.nodeId, inputs, physicalAttempt, retryContext), binding.resolvedRunnerId, physicalAttempt, ctx.template.verdicts.domain, launchOverrides);
             const needsHuman = await maybeHandleNeedsHumanRoleResult({
                 ...input,
                 attemptIds,
                 physicalAttempt,
                 result,
             });
-            if (needsHuman === 'retry')
-                continue;
-            if (needsHuman)
+            if (needsHuman) {
+                if ('action' in needsHuman) {
+                    continue;
+                }
                 return needsHuman;
+            }
             const failed = roleValidationFailure(ctx.template, node, result, physicalAttempt);
             if (failed)
                 return failed;
@@ -830,6 +1245,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
                     nodeId: node.id,
                     attemptId: physicalAttempt.attemptId,
                     ...(ctx.issueRef ? { issueRef: ctx.issueRef } : {}),
+                    ...(ctx.issueAction ? { issueAction: ctx.issueAction } : {}),
                     ...(artifactRef ? { artifactRef } : {}),
                 });
                 output = attachProducedChange(output, change);
@@ -870,17 +1286,57 @@ export function makeDataDrivenTask(runStepFn, deps) {
             }
             const transient = transientRunnerFailure(result);
             if (transient === undefined) {
-                return {
-                    blocked: true,
-                    reason: 'agent-needs-human',
-                    lesson: safeLesson,
-                    attemptsMade: physicalAttempt.attemptNo,
-                };
+                const question = await awaitAgentQuestion({ ...input, safeLesson, physicalAttempt });
+                if ('unresolved' in question) {
+                    return {
+                        blocked: true,
+                        reason: question.reason,
+                        lesson: question.lesson,
+                        attemptsMade: physicalAttempt.attemptNo,
+                    };
+                }
+                return { question: true, retryContext: question, attemptsMade: physicalAttempt.attemptNo };
             }
             return handleTransientRoleResult({ ...input, transient });
         }
         return undefined;
     }
+    async function awaitAgentQuestion(input) {
+        const { runId, node, ctx, stepKey, binding, physicalAttempt, safeLesson } = input;
+        const question = await awaitHuman(runId, 'question', `agentQuestion:${stepKey}:attempt${physicalAttempt.attemptNo}`, `${node.id} question`, {
+            kind: 'agent_question',
+            runId,
+            taskId: ctx.taskId,
+            nodeId: node.id,
+            step: stepKey,
+            role: binding.rowId,
+            runner: binding.resolvedRunnerId,
+            lesson: safeLesson,
+            attemptId: physicalAttempt.attemptId,
+        }, undefined, 'question');
+        const retryContext = agentQuestionRetryContext(question, node.id, safeLesson);
+        if (retryContext === undefined) {
+            return {
+                unresolved: true,
+                reason: 'agent-question-unresolved',
+                lesson: unresolvedAgentQuestionLesson(node.id, safeLesson, question),
+            };
+        }
+        await appendEvent({
+            runId,
+            taskId: ctx.taskId,
+            stepId: '',
+            stepKey,
+            type: 'agent_question_resolved',
+            idempotencyKey: `${physicalAttempt.attemptId}:question`,
+            payload: {
+                nodeId: node.id,
+                inboxId: retryContext.inboxId,
+                resolvedBy: retryContext.resolvedBy,
+            },
+        });
+        return retryContext;
+    }
     async function handleTransientRoleResult(input) {
         const { runId, node, ctx, stepKey, attemptIds, physicalAttempt, transient } = input;
         const policy = ctx.runnerRetryPolicy;
@@ -898,7 +1354,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
             });
             if (policy.backoffMs > 0)
                 await deps.sleep(policy.backoffMs);
-            return 'retry';
+            return { action: 'retry' };
         }
         const retry = runnerRetryBlockPayload({
             transient,
@@ -1021,9 +1477,21 @@ export function makeDataDrivenTask(runStepFn, deps) {
             lesson: `Human selected ${outcome}; recovery is recorded but no Revo worktree patch was adopted by the main session.`,
         };
     }
-    async function invokeScript(runId, decision, ctx, bindingByRef, stepKey, inputs) {
-        const handler = scriptRegistry.get(decision.scriptRef) ?? scriptRegistry.get('script:integrator');
-        return handler({ runId, decision, ctx, bindingByRef, stepKey, inputs });
+    async function invokeScript(runId, decision, ctx, bindingByRef, launchBindings, stepKey, inputs) {
+        const handler = scriptRegistry.get(decision.scriptRef);
+        if (!handler) {
+            const reason = `script handler is not registered: ${decision.scriptRef}`;
+            await appendEvent({
+                runId,
+                taskId: ctx.taskId,
+                stepId: '',
+                stepKey,
+                type: 'step_failed',
+                payload: { scriptRef: decision.scriptRef, error: reason },
+            });
+            return { outcome: 'failed', reason };
+        }
+        return handler({ runId, decision, ctx, bindingByRef, launchBindings, stepKey, inputs });
     }
     async function finish(runId, status, verdict, steps, failureReason = '') {
         if (status === 'succeeded') {