@revisium/orchestrator 0.2.0-alpha.2 → 0.2.0-alpha.4

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

@@ -1,11 +1,12 @@
 import { step as coreStep, initialState, validateTemplate, InterpretError, selectJoinWinner, reduceJoinVerdict, } from '../pipeline-core/index.js';
-import { runnerNeedsLivePreflight, runnerUsesRealIntegrator } from './route-contract.js';
+import { resolveLaunchOverrides, runnerNeedsLivePreflight, runnerUsesRealIntegrator } 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;
@@ -108,10 +109,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 +128,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 +144,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 +167,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))
@@ -275,13 +301,24 @@ function gateVerdict(decision, outcomes) {
         return outcomes[0];
     return outcomes.length > 1 ? outcomes.at(-1) : undefined;
 }
-function gateResolutionOutput(decision, verdict, fallbackInboxId) {
+function gateResolutionOutput(decision, verdict, fallbackInboxId, trustedGateHeadSha) {
+    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 {
         outcome: decision.outcome ?? verdict ?? decision.decision,
-        ...(decision.note !== undefined ? { note: decision.note } : {}),
-        resolvedBy: decision.resolvedBy ?? '',
-        resolvedAt: decision.resolvedAt ?? '',
-        inboxId: decision.inboxId ?? fallbackInboxId,
+        ...(note !== undefined ? { note } : {}),
+        resolvedBy,
+        resolvedAt,
+        inboxId,
+        ...(trustedGateHeadSha !== undefined ? { trustedGateHeadSha } : {}),
+        ...(mergeOverrideAudit !== undefined ? { mergeOverrideAudit } : {}),
+        ...(adoptionAudit !== undefined ? { adoptionAudit } : {}),
         ...(decision.decision ? { decision: decision.decision } : {}),
     };
 }
@@ -317,9 +354,19 @@ 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;
+}
+export function buildGateSummary(decision, outputsByNode, lastVerdict, lastProducedOutput) {
     const summary = { nodeId: decision.nodeId, outcomes: decision.outcomes };
-    const artRow = resolveGateRow(decision.gatedArtifact, outputsByNode);
+    const artRow = freshMergeGateArtifact(decision, lastVerdict, lastProducedOutput)
+        ?? resolveGateRow(decision.gatedArtifact, outputsByNode);
     if (artRow)
         summary.gatedArtifact = gateArtifactView(artRow, decision.gatedArtifact?.as);
     const verdictRow = resolveGateRow(decision.verdictFrom, outputsByNode);
@@ -329,8 +376,279 @@ 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 } : {}),
+    };
+}
+export function buildSystemScriptRegistry(deps) {
+    const { appendEvent, releaseWorktreeFn, integrateFn, runStub, confirmMergeFn, runConfirmStub, pollPrFn, runPollStub, overrideMergeFn, runOverrideStub, respondThreadsFn, runRespondStub, } = deps;
+    function buildIntegratorInput(runId, ctx, inputs) {
+        const { taskId, title, base, issueRef, issueAction } = ctx;
+        const change = producedChangeFromInputs(inputs);
+        const mergeReadiness = mergeReadinessFromInputs(inputs);
+        const changeForIntegrator = change ? changeWithRunIssueContract(change, issueRef, issueAction) : undefined;
+        return {
+            runId,
+            taskId,
+            title,
+            base,
+            ...(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);
+            let result;
+            try {
+                result = useReal ? await desc.real(integratorInput) : desc.stub(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) {
+                await appendEvent({
+                    runId, taskId: ctx.taskId, stepId: '', stepKey: 'pipeline',
+                    type: 'pipeline_blocked',
+                    payload: { reason: desc.blockedReason, lesson: result.lesson, nodeId: decision.nodeId },
+                });
+                return { outcome: 'blocked' };
+            }
+            const { eventType, payload, pointer, verdict } = desc.mapSuccess(result);
+            await appendEvent({ runId, taskId: ctx.taskId, stepId: '', stepKey, type: eventType, payload });
+            return { outcome: 'ok', pointer, ...(verdict !== undefined ? { verdict } : {}) };
+        };
+    }
+    const cleanupWorktree = async ({ runId, decision, ctx, stepKey }) => {
+        let releaseResult;
+        try {
+            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 };
+        }
+        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: integratorProgressEventType(result),
+            payload: integratorResultPointer(result),
+            pointer: integratorResultPointer(result),
+        }),
+    });
+    const confirmMergeScript = makeIntegratorScript({
+        real: confirmMergeFn,
+        stub: runConfirmStub,
+        blockedReason: 'confirm-merge',
+        mapSuccess: (result) => ({
+            eventType: 'merge_confirmed',
+            payload: {
+                prNumber: result.prNumber,
+                prUrl: result.prUrl,
+                ...(result.issueRef ? { issueRef: result.issueRef } : {}),
+            },
+            pointer: {
+                merged: true,
+                prNumber: result.prNumber,
+                prUrl: result.prUrl,
+                ...(result.issueRef ? { issueRef: result.issueRef } : {}),
+            },
+        }),
+    });
+    const pollPrScript = makeIntegratorScript({
+        real: pollPrFn,
+        stub: runPollStub,
+        blockedReason: 'poll-pr',
+        mapSuccess: (result) => ({
+            eventType: 'pr_polled',
+            payload: {
+                prNumber: result.prNumber,
+                headSha: result.headSha,
+                verdict: result.verdict,
+                evidence: result.evidence,
+                ciFailures: result.ciFailures.length,
+                reviewThreads: result.reviewThreads.length,
+                ...(result.issueRef ? { issueRef: result.issueRef } : {}),
+            },
+            pointer: result,
+            verdict: result.verdict,
+        }),
+    });
+    const overrideMergeScript = 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);
+        let result;
+        try {
+            result = useReal ? await overrideMergeFn(integratorInput) : runOverrideStub(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) {
+            await appendEvent({
+                runId, taskId: ctx.taskId, stepId: '', stepKey: 'pipeline',
+                type: 'pipeline_blocked',
+                payload: { reason: 'override-merge', lesson: result.lesson, nodeId: decision.nodeId },
+            });
+            return { outcome: 'blocked' };
+        }
+        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',
+            payload: { replied: result.replied, resolved: result.resolved },
+            pointer: result,
+        }),
+    });
+    return new Map([
+        ['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],
+    ]);
+}
 export function makeDataDrivenTask(runStepFn, deps) {
-    const { appendEvent, appendRunOutput, awaitHuman, completeRun, failRun, blockRun, cancelRun, loadRunTaskContext, integrateFn, runStub, confirmMergeFn, runConfirmStub, pollPrFn, runPollStub, respondThreadsFn, runRespondStub, captureChangeFn, preflightFn, createWorktreeFn, releaseWorktreeFn } = deps;
+    const { appendEvent, appendRunOutput, awaitHuman, completeRun, failRun, blockRun, cancelRun, loadRunTaskContext, captureChangeFn, preflightFn, createWorktreeFn } = deps;
+    const scriptRegistry = buildSystemScriptRegistry(deps);
     function resolveConsumes(node, outputsByNode) {
         const refs = 'consumes' in node ? (node.consumes ?? []) : [];
         const inputs = {};
@@ -363,7 +681,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,
@@ -377,6 +695,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
         list.push(row);
         outputsByNode.set(node.id, list);
         await appendRunOutput(row);
+        return row;
     }
     return async function dataDrivenTaskImpl(runId, opts) {
         try {
@@ -399,7 +718,7 @@ 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 { taskId, title, base, issueRef, issueAction } = await loadRunTaskContext(runId);
         const live = route.roleBindings.some((b) => runnerNeedsLivePreflight(b.resolvedRunnerId));
         if (live) {
             const pf = await preflightFn(taskId, base);
@@ -410,9 +729,9 @@ 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) {
@@ -427,7 +746,9 @@ export function makeDataDrivenTask(runStepFn, deps) {
         let state = initialState(template);
         let lastResult;
         let lastVerdict = '';
+        let lastProducedOutput;
         let lastFailureReason = '';
+        let approvedMergeGateHeadShaValue;
         let stepCount = 0;
         const effectOrdinalByNode = new Map();
         const outputsByNode = new Map();
@@ -439,10 +760,12 @@ 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,
+                runId, template, state, bindingByRef, executionProfile, taskId, title, base, issueRef, issueAction,
                 effectOrdinalByNode, outputsByNode, runnerRetryPolicy,
                 live,
                 lastVerdict,
+                lastProducedOutput,
+                approvedMergeGateHeadSha: approvedMergeGateHeadShaValue,
             });
             stepCount += eff.stepDelta;
             if (eff.terminal) {
@@ -453,9 +776,12 @@ 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;
             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)`);
     }
@@ -510,6 +836,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
         };
         let lastResult;
         let lastVerdict = '';
+        let lastProducedOutput;
         let stepDelta = 0;
         for (let i = 0; i < MAX_STEPS; i++) {
             const next = coreStep(branchTemplate, state, lastResult);
@@ -532,6 +859,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
                 template: branchTemplate,
                 state,
                 lastVerdict,
+                lastProducedOutput,
             });
             stepDelta += eff.stepDelta;
             if (eff.terminal)
@@ -541,6 +869,7 @@ export function makeDataDrivenTask(runStepFn, deps) {
             lastResult = eff.lastResult;
             if (eff.lastVerdict !== undefined)
                 lastVerdict = eff.lastVerdict;
+            lastProducedOutput = eff.producedOutput ?? lastProducedOutput;
         }
         throw new InterpretError(`fork ${decision.nodeId} branch ${branch.id} did not reach join ${decision.joinId} within ${MAX_STEPS} steps`);
     }
@@ -553,11 +882,12 @@ 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 ('blocked' in result) {
@@ -588,15 +918,16 @@ export function makeDataDrivenTask(runStepFn, deps) {
                     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);
+                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 } : {}),
                     stepDelta: result.attemptsMade,
                 };
             }
@@ -605,30 +936,54 @@ 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, stepKeyFor(node.id, ordinal), resolved.inputs);
                 if (scriptResult.outcome === 'blocked') {
                     return { lastResult: { outcome: 'failed', errorCode: REVO_SCRIPT_BLOCKED }, lastVerdict: 'blocked', 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', 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 } : {}),
+                    ...(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);
+                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 } : {}),
+                    ...(approvedHeadSha !== undefined ? { approvedMergeGateHeadSha: approvedHeadSha } : {}),
+                    stepDelta: 0,
+                };
             }
             case 'fork': {
                 await appendEvent({
@@ -662,7 +1017,8 @@ export function makeDataDrivenTask(runStepFn, deps) {
         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.executionProfile);
+            const result = await runStepFn(runId, binding.rowId, stepKey, stepInputForAttempt(decision.nodeId, inputs, physicalAttempt), binding.resolvedRunnerId, ctx.executionProfile, physicalAttempt, ctx.template.verdicts.domain, launchOverrides);
             const needsHuman = await maybeHandleNeedsHumanRoleResult({
                 ...input,
                 attemptIds,
@@ -692,6 +1048,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);
@@ -884,154 +1241,8 @@ export function makeDataDrivenTask(runStepFn, deps) {
         };
     }
     async function invokeScript(runId, decision, ctx, bindingByRef, stepKey, inputs) {
-        if (decision.scriptRef === 'script:cleanupWorktree') {
-            try {
-                await releaseWorktreeFn(runId, ctx.taskId);
-            }
-            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 isConfirmMerge = decision.scriptRef === 'script:confirmMerge';
-        const isPollPr = decision.scriptRef === 'script:pollPr';
-        const isRespondThreads = decision.scriptRef === 'script:respondThreads';
-        const binding = bindingByRef.get(decision.scriptRef) ?? bindingByRef.get('script:integrator');
-        const change = producedChangeFromInputs(inputs);
-        const mergeReadiness = mergeReadinessFromInputs(inputs);
-        const issueRef = ctx.issueRef;
-        const changeForIntegrator = change ? changeWithRunIssueRef(change, issueRef) : undefined;
-        const integratorInput = {
-            runId,
-            taskId: ctx.taskId,
-            title: ctx.title,
-            base: ctx.base,
-            ...(issueRef ? { issueRef } : {}),
-            ...(changeForIntegrator ? { change: changeForIntegrator } : {}),
-            ...(inputs.triage === undefined ? {} : { triage: inputs.triage }),
-            ...(mergeReadiness ? { mergeReadiness } : {}),
-        };
-        const useReal = !!binding && runnerUsesRealIntegrator(binding.resolvedRunnerId);
-        let result;
-        try {
-            if (isConfirmMerge) {
-                result = useReal ? await confirmMergeFn(integratorInput) : runConfirmStub(integratorInput);
-            }
-            else if (isPollPr) {
-                result = useReal ? await pollPrFn(integratorInput) : runPollStub(integratorInput);
-            }
-            else if (isRespondThreads) {
-                result = useReal ? await respondThreadsFn(integratorInput) : runRespondStub(integratorInput);
-            }
-            else {
-                result = useReal ? await integrateFn(integratorInput) : runStub(integratorInput);
-            }
-        }
-        catch (err) {
-            await appendEvent({
-                runId,
-                taskId: ctx.taskId,
-                stepId: '',
-                stepKey,
-                type: 'step_failed',
-                payload: { scriptRef: decision.scriptRef, error: err instanceof Error ? err.message : String(err) },
-            });
-            return { outcome: 'failed' };
-        }
-        if ('needsHuman' in result) {
-            const reason = isConfirmMerge ? 'confirm-merge' : isPollPr ? 'poll-pr' : isRespondThreads ? 'respond-threads' : 'integrate';
-            await appendEvent({
-                runId,
-                taskId: ctx.taskId,
-                stepId: '',
-                stepKey: 'pipeline',
-                type: 'pipeline_blocked',
-                payload: { reason, lesson: result.lesson, nodeId: decision.nodeId },
-            });
-            return { outcome: 'blocked' };
-        }
-        if (isConfirmMerge) {
-            const merged = result;
-            await appendEvent({
-                runId,
-                taskId: ctx.taskId,
-                stepId: '',
-                stepKey,
-                type: 'merge_confirmed',
-                payload: {
-                    prNumber: merged.prNumber,
-                    prUrl: merged.prUrl,
-                    ...(merged.issueRef ? { issueRef: merged.issueRef } : {}),
-                },
-            });
-            return {
-                outcome: 'ok',
-                pointer: {
-                    merged: true,
-                    prNumber: merged.prNumber,
-                    prUrl: merged.prUrl,
-                    ...(merged.issueRef ? { issueRef: merged.issueRef } : {}),
-                },
-            };
-        }
-        if (isPollPr) {
-            const feedback = result;
-            await appendEvent({
-                runId,
-                taskId: ctx.taskId,
-                stepId: '',
-                stepKey,
-                type: 'pr_polled',
-                payload: {
-                    prNumber: feedback.prNumber,
-                    headSha: feedback.headSha,
-                    verdict: feedback.verdict,
-                    evidence: feedback.evidence,
-                    ciFailures: feedback.ciFailures.length,
-                    reviewThreads: feedback.reviewThreads.length,
-                    ...(feedback.issueRef ? { issueRef: feedback.issueRef } : {}),
-                },
-            });
-            return { outcome: 'ok', pointer: feedback, verdict: feedback.verdict };
-        }
-        if (isRespondThreads) {
-            const responded = result;
-            await appendEvent({
-                runId,
-                taskId: ctx.taskId,
-                stepId: '',
-                stepKey,
-                type: 'threads_responded',
-                payload: { replied: responded.replied, resolved: responded.resolved },
-            });
-            return { outcome: 'ok', pointer: responded };
-        }
-        const integrated = result;
-        await appendEvent({
-            runId,
-            taskId: ctx.taskId,
-            stepId: '',
-            stepKey,
-            type: 'integrate_succeeded',
-            payload: {
-                prUrl: integrated.prUrl,
-                branch: integrated.branch,
-                prNumber: integrated.prNumber,
-                headSha: integrated.headSha,
-                status: integrated.status,
-                ...(integrated.issueRef ? { issueRef: integrated.issueRef } : {}),
-            },
-        });
-        return {
-            outcome: 'ok',
-            pointer: {
-                prUrl: integrated.prUrl,
-                branch: integrated.branch,
-                prNumber: integrated.prNumber,
-                headSha: integrated.headSha,
-                status: integrated.status,
-                ...(integrated.issueRef ? { issueRef: integrated.issueRef } : {}),
-            },
-        };
+        const handler = scriptRegistry.get(decision.scriptRef) ?? scriptRegistry.get('script:integrator');
+        return handler({ runId, decision, ctx, bindingByRef, stepKey, inputs });
     }
     async function finish(runId, status, verdict, steps, failureReason = '') {
         if (status === 'succeeded') {