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

package/dist/task-control-plane/task-control-plane-api.service.js

@@ -25,13 +25,14 @@ import { validateManualAdoptionAudit } from '../control-plane/manual-adoption-au
 import { validateMergeOverrideAudit } from '../control-plane/merge-override-audit.js';
 import { fnv1a64Hex } from '../control-plane/steps.js';
 import { POLICY_VERSION } from '../control-plane/default-playbook-policy.js';
-import { executionProfileFromRunProfile, topologyProfileFromRunProfile } from '../control-plane/run-profiles.js';
+import { launchBindingsFromRunProfile, runProfileHash, topologyProfileFromRunProfile, topologyStageTargetsFromRunProfile, } from '../control-plane/run-profiles.js';
 import { materializeTemplate, MATERIALIZER_VERSION } from '../pipeline-core/materialize.js';
 import { DbosService } from '../engine/dbos.service.js';
 import { PipelineService } from '../pipeline/pipeline.service.js';
 import { INTEGRATOR_PROGRESS_EVENT_TYPES, RUN_PROGRESS_EVENT_KEY } from '../pipeline/data-driven-task.workflow.js';
 import { templateFromExecutionPolicy } from '../pipeline/data-driven-template.js';
-import { normalizeExecutionProfile, normalizeParams, normalizeRouteGates, resolveBindingForRole, resolveRunnerForRole, RUNNER_PERMISSION_MODES, } from '../pipeline/route-contract.js';
+import { normalizeParams, normalizeRouteGates, resolveBindingForRole, resolveRunnerForRole, RUNNER_PERMISSION_MODES, } from '../pipeline/route-contract.js';
+import { assertValidInlineRunProfile } from '../playbook/catalog-schema-validator.js';
 import { InboxService } from '../revisium/inbox.service.js';
 import { PlaybooksService } from '../revisium/playbooks.service.js';
 import { RolesService } from '../revisium/roles.service.js';
@@ -39,15 +40,17 @@ import { RunService } from '../revisium/run.service.js';
 import { CreateRunWorkflowError, previewCreateRunIds, } from '../run/create-run.js';
 import { PrReadinessService } from './pr-readiness.service.js';
 const execFileAsync = promisify(execFile);
-const GATE_TOPICS = new Set(['plan', 'merge', 'question']);
-const WORKFLOW_SUCCESS_EVENT_TYPES = new Set(['step_succeeded', 'gate_signaled']);
+const GATE_TOPICS = new Set(['plan', 'merge', 'question', 'retry']);
+const WORKFLOW_SUCCESS_EVENT_TYPES = new Set(['step_succeeded', 'gate_signaled', 'question_signaled']);
 const WORKFLOW_FAILURE_EVENT_TYPES = new Set(['step_failed', 'attempt_failed']);
 export const WORKFLOW_PROGRESS_EVENT_TYPES = new Set([
     'pipeline_blocked',
+    'question_signal_pending',
+    'question_signaled',
     'pr_polled',
     ...INTEGRATOR_PROGRESS_EVENT_TYPES,
 ]);
-const BUILTIN_RUNNERS = new Set(['claude-code', 'codex', 'script', 'stub-agent', 'revo-integrator', 'revo-merger', 'revo-deterministic']);
+const BUILTIN_RUNNERS = new Set(['claude-code', 'codex', 'script', 'stub-agent']);
 function asErrorMessage(error) {
     if (error instanceof Error)
         return error.message;
@@ -58,6 +61,9 @@ function asRecord(value) {
         return null;
     return value;
 }
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
 function dateOrEpoch(value) {
     if (value instanceof Date)
         return Number.isNaN(value.getTime()) ? new Date(0) : value;
@@ -75,6 +81,39 @@ function gateTopic(item) {
         return null;
     return topic;
 }
+function gateSignalTopic(item, topic) {
+    const context = asRecord(item.context);
+    const signalTopic = context?.signalTopic;
+    return typeof signalTopic === 'string' && signalTopic.length > 0 ? signalTopic : topic;
+}
+function questionSignalTopic(item) {
+    if (item.kind !== 'question' || !item.runId)
+        return null;
+    const context = asRecord(item.context);
+    if (context?.topic !== 'question')
+        return null;
+    const signalTopic = context.signalTopic;
+    return typeof signalTopic === 'string' && signalTopic.length > 0 ? signalTopic : null;
+}
+function questionSummary(item) {
+    const context = asRecord(item.context);
+    return asRecord(context?.summary);
+}
+function questionSignalTaskId(item) {
+    if (item.taskId)
+        return item.taskId;
+    const taskId = questionSummary(item)?.taskId;
+    return typeof taskId === 'string' ? taskId : '';
+}
+function questionSignalStepKey(item, signalTopic) {
+    const step = questionSummary(item)?.step;
+    if (typeof step === 'string' && step.length > 0)
+        return step;
+    return signalTopic.startsWith('question:') ? signalTopic : `question:${signalTopic}`;
+}
+function questionSignalResolvedBy(item, answer, fallbackResolvedBy) {
+    return nonEmptyString(item.resolvedBy) ?? nonEmptyString(asRecord(answer)?.resolvedBy) ?? fallbackResolvedBy;
+}
 function gateDeclaredOutcomes(item) {
     const context = asRecord(item.context);
     const summary = asRecord(context?.summary);
@@ -112,6 +151,13 @@ function assertRequiredGateNote(item, outcome, note) {
         throw new ControlPlaneError('VALIDATION_FAILURE', `questionGate ${outcome} requires a non-empty note`);
     }
 }
+function normalizeGateReconcile(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'keep')
+        return value;
+    throw new ControlPlaneError('VALIDATION_FAILURE', 'gate reconcile must be keep');
+}
 async function git(cwd, args) {
     try {
         const result = await execFileAsync('git', args, {
@@ -249,12 +295,6 @@ function optionalString(value) {
 function optionalInteger(value) {
     return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
 }
-function requiredRecord(value, field, runId) {
-    const record = asRecord(value);
-    if (record)
-        return record;
-    throw new ControlPlaneError('VALIDATION_FAILURE', `Cannot recover run ${runId}: parent ${field} is not a record`);
-}
 function optionalRecord(value) {
     return asRecord(value) ?? {};
 }
@@ -419,19 +459,15 @@ function isRouteDecision(value) {
     const record = asRecord(value);
     return Boolean(record?.playbookId && record?.pipelineRowId && Array.isArray(record.roleBindings));
 }
-function assertRunnerAvailable(runnerId, profile, roleId) {
-    const available = profile.availableRunners;
-    if (available && !available.includes(runnerId)) {
-        throw new ControlPlaneError('VALIDATION_FAILURE', `runner unavailable for role ${roleId}: ${runnerId}`);
-    }
-    if (!available && !BUILTIN_RUNNERS.has(runnerId)) {
+function assertRunnerAvailable(runnerId, roleId) {
+    if (!BUILTIN_RUNNERS.has(runnerId)) {
         throw new ControlPlaneError('VALIDATION_FAILURE', `runner implementation is not registered for role ${roleId}: ${runnerId}`);
     }
 }
 function assertProductionRunnerBinding(runnerId, runnerSource, roleId) {
-    if (runnerId !== 'stub-agent' || runnerSource === 'execution-profile')
+    if (runnerId !== 'stub-agent' || runnerSource === 'profile')
         return;
-    throw new ControlPlaneError('VALIDATION_FAILURE', `role ${roleId} binds production runner stub-agent; use an execution profile override for test stubs`);
+    throw new ControlPlaneError('VALIDATION_FAILURE', `role ${roleId} binds production runner stub-agent; use a run profile binding for test stubs`);
 }
 let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     runs;
@@ -558,11 +594,11 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             playbookId: input.playbookId,
             pipelineId: input.pipelineId,
             profileId: input.profileId,
+            profile: input.profile,
             params: input.params,
             issueRef: input.issueRef,
             issueAction: input.issueAction,
-            executionProfile: input.executionProfile,
-            source: input.pipelineId ? 'explicit' : 'deterministic-installed-playbook',
+            source: 'explicit',
         });
         const result = await this.runs.createRun({
             title: input.title,
@@ -576,7 +612,6 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             params: route.params,
             issueRef: route.params.issueRef,
             routeDecision: route,
-            executionProfile: route.executionProfile,
         });
         if (!input.start)
             return { ...result, started: false, route };
@@ -691,9 +726,8 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         if (!isRouteDecision(routeDecision)) {
             throw new ControlPlaneError('VALIDATION_FAILURE', `Cannot recover run ${parentRunId}: parent route_decision is invalid`);
         }
-        const executionProfile = requiredRecord(parentData.execution_profile, 'execution_profile', parentRunId);
         const idSuffix = fnv1a64Hex(`${parentRunId}|${blockedEvent.eventId}`).slice(0, 8);
-        return { title, repo, description, scope, priority, role: recoveryRole, playbookId, pipelineId, params, routeDecision, executionProfile, now, idSuffix };
+        return { title, repo, description, scope, priority, role: recoveryRole, playbookId, pipelineId, params, routeDecision, now, idSuffix };
     }
     async createRecoveryRunOrReuseExpected(input, expected) {
         try {
@@ -1063,7 +1097,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         const item = await this.getInboxItem(input.inboxId);
         const topic = gateTopic(item);
         if (!topic) {
-            throw new ControlPlaneError('VALIDATION_FAILURE', `inbox item is not a plan or merge gate: ${input.inboxId}`);
+            throw new ControlPlaneError('VALIDATION_FAILURE', `inbox item is not a named approval gate: ${input.inboxId}`);
         }
         const outcomes = gateOutcomes(item);
         if (outcomes.length === 0) {
@@ -1074,6 +1108,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             throw new ControlPlaneError('VALIDATION_FAILURE', `invalid gate outcome ${outcome}; expected one of: ${outcomes.join(', ')}`);
         }
         const note = input.note?.trim();
+        const reconcile = normalizeGateReconcile(input.reconcile);
         assertRequiredGateNote(item, outcome, note);
         const adoptionAudit = outcome === 'adopt_patch_manually'
             ? validateManualAdoptionAudit(input.adoptionAudit, item)
@@ -1085,6 +1120,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         const answer = {
             outcome,
             ...(note ? { note } : {}),
+            ...(reconcile ? { reconcile } : {}),
             ...(adoptionAudit ? { adoptionAudit } : {}),
             ...(mergeOverrideAudit ? { mergeOverrideAudit } : {}),
             resolvedBy,
@@ -1105,6 +1141,8 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     assertLegacyGateWrapperAllowed(item, inboxId, outcomes) {
         if (outcomes.length > 2
             || outcomes.includes('approve_anyway')
+            || outcomes.includes('retry')
+            || outcomes.includes('give_up')
             || outcomes.some((outcome) => isQuestionGateReasonOutcome(item, outcome))) {
             throw new ControlPlaneError('VALIDATION_FAILURE', `inbox item has named gate outcomes; use resolve_gate with an explicit outcome: ${inboxId}`);
         }
@@ -1136,12 +1174,27 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         if (gateTopic(item)) {
             throw new ControlPlaneError('VALIDATION_FAILURE', `inbox item is a gate; use resolve_gate, approve_gate, or reject_gate: ${input.inboxId}`);
         }
-        return this.resolveInboxItem({
+        const resolvedBy = input.resolvedBy ?? 'mcp';
+        const answerRecord = asRecord(input.answer);
+        if (typeof answerRecord?.outcome === 'string' && answerRecord.outcome.trim() === 'adopt_patch_manually') {
+            validateManualAdoptionAudit(answerRecord.adoptionAudit, item);
+        }
+        const result = await this.inbox.resolveInbox(input.inboxId, input.answer, resolvedBy);
+        const signalTopic = questionSignalTopic(item);
+        const shouldSignal = signalTopic !== null;
+        if (signalTopic) {
+            const signalItem = result.status === 'pending' ? await this.getInboxItem(input.inboxId) : item;
+            const signalResolvedBy = questionSignalResolvedBy(signalItem, result.answer, resolvedBy);
+            await this.signalQuestion(signalItem, signalTopic, result.answer, input.inboxId, signalResolvedBy);
+        }
+        return {
             inboxId: input.inboxId,
-            answer: input.answer,
-            resolvedBy: input.resolvedBy ?? 'mcp',
-            signalGate: false,
-        });
+            previousStatus: result.status,
+            answer: result.answer,
+            signaled: shouldSignal,
+            topic: shouldSignal ? 'question' : null,
+            runId: item.runId,
+        };
     }
     async resolveInboxItem(input) {
         const item = await this.getInboxItem(input.inboxId);
@@ -1162,6 +1215,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
                 }
                 this.assertGateOutcome(item, outcome);
                 const note = typeof answer?.note === 'string' ? answer.note.trim() : '';
+                const reconcile = normalizeGateReconcile(answer.reconcile);
                 assertRequiredGateNote(item, outcome, note);
                 const adoptionAudit = outcome === 'adopt_patch_manually'
                     ? validateManualAdoptionAudit(answer.adoptionAudit, item)
@@ -1173,6 +1227,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
                     ...answer,
                     outcome,
                     ...(typeof answer.note === 'string' ? { note } : {}),
+                    ...(reconcile ? { reconcile } : {}),
                     ...(adoptionAudit ? { adoptionAudit } : {}),
                     ...(mergeOverrideAudit ? { mergeOverrideAudit } : {}),
                 };
@@ -1193,18 +1248,35 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         };
     }
     async signalGate(item, topic, answer, inboxId) {
+        const signalTopic = gateSignalTopic(item, topic);
         const eventBase = {
             runId: item.runId,
             taskId: item.taskId,
             stepId: item.stepId,
             stepKey: `gate:${topic}`,
             actor: 'mcp',
-            payload: { inboxId, topic },
+            payload: { inboxId, topic, ...(signalTopic !== topic ? { signalTopic } : {}) },
         };
         await this.runs.appendEvent({ ...eventBase, type: 'gate_signal_pending' });
-        await this.dbos.signal(item.runId, topic, answer, inboxId);
+        await this.dbos.signal(item.runId, signalTopic, answer, inboxId);
         await this.runs.appendEvent({ ...eventBase, type: 'gate_signaled' });
     }
+    async signalQuestion(item, signalTopic, answer, inboxId, resolvedBy) {
+        const stepKey = questionSignalStepKey(item, signalTopic);
+        const eventBase = {
+            runId: item.runId,
+            taskId: questionSignalTaskId(item),
+            stepId: item.stepId,
+            stepKey,
+            actor: 'mcp',
+            idempotencyKey: inboxId,
+            payload: { inboxId, topic: 'question', signalTopic, stepKey },
+        };
+        const signalPayload = { answer, resolvedBy, inboxId };
+        await this.runs.appendEvent({ ...eventBase, type: 'question_signal_pending' });
+        await this.dbos.signal(item.runId, signalTopic, signalPayload, inboxId);
+        await this.runs.appendEvent({ ...eventBase, type: 'question_signaled' });
+    }
     async summarizeGateRisk(inboxId) {
         const item = await this.getInboxItem(inboxId);
         return {
@@ -1235,6 +1307,80 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     listProfiles(input = {}) {
         return this.playbooks.listRunProfiles(input);
     }
+    listProfilesPage(input) {
+        return this.playbooks.listRunProfilesPage(input);
+    }
+    async getProfile(input) {
+        const playbook = await this.playbooks.resolvePlaybook(input.playbookId);
+        const pipeline = await this.playbooks.resolvePipeline({ playbookId: playbook.id, pipelineId: input.pipelineId });
+        return this.playbooks.resolveRunProfile({
+            playbookId: playbook.id,
+            pipelineId: pipeline.pipelineId,
+            profileId: input.profileId,
+            includeDeprecated: true,
+        });
+    }
+    validateProfile(input) {
+        return this.validateRunProfileForPipeline(input);
+    }
+    async createProfile(input) {
+        const route = await this.validateRunProfileForPipeline(input);
+        const profile = asRecord(route.profileSnapshot);
+        if (!profile)
+            throw new ControlPlaneError('VALIDATION_FAILURE', 'validated profile snapshot is missing');
+        return this.playbooks.createRunProfile({
+            playbookId: route.playbookId,
+            pipelineId: route.basePipelineId ?? route.pipelineId,
+            profileId: input.profileId,
+            displayName: input.displayName,
+            summary: input.summary,
+            profile,
+            status: input.status,
+        });
+    }
+    async updateProfile(input) {
+        let playbookId;
+        let pipelineId = input.pipelineId;
+        let profile;
+        if (input.profile !== undefined) {
+            const route = await this.validateRunProfileForPipeline({
+                playbookId: input.playbookId,
+                pipelineId: input.pipelineId,
+                profile: input.profile,
+            });
+            playbookId = route.playbookId;
+            pipelineId = route.basePipelineId ?? route.pipelineId;
+            profile = asRecord(route.profileSnapshot) ?? undefined;
+            if (!profile)
+                throw new ControlPlaneError('VALIDATION_FAILURE', 'validated profile snapshot is missing');
+        }
+        else {
+            const playbook = await this.playbooks.resolvePlaybook(input.playbookId);
+            const pipeline = await this.playbooks.resolvePipeline({ playbookId: playbook.id, pipelineId: input.pipelineId });
+            playbookId = playbook.id;
+            pipelineId = pipeline.pipelineId;
+        }
+        return this.playbooks.updateRunProfile({
+            playbookId,
+            pipelineId,
+            profileId: input.profileId,
+            expectedProfileRevisionHash: input.expectedProfileRevisionHash,
+            displayName: input.displayName,
+            summary: input.summary,
+            profile,
+            status: input.status,
+        });
+    }
+    async deprecateProfile(input) {
+        const playbook = await this.playbooks.resolvePlaybook(input.playbookId);
+        const pipeline = await this.playbooks.resolvePipeline({ playbookId: playbook.id, pipelineId: input.pipelineId });
+        return this.playbooks.deprecateRunProfile({
+            playbookId: playbook.id,
+            pipelineId: pipeline.pipelineId,
+            profileId: input.profileId,
+            expectedProfileRevisionHash: input.expectedProfileRevisionHash,
+        });
+    }
     async getPipeline(pipelineId) {
         const result = await this.playbooks.getPipeline(pipelineId);
         if (!result)
@@ -1248,9 +1394,9 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             playbookId: input.playbookId,
             pipelineId: input.pipeline,
             profileId: input.profileId,
+            profile: input.profile,
             params: input.params,
-            executionProfile: input.executionProfile,
-            source: input.pipeline ? 'explicit' : 'deterministic-installed-playbook',
+            source: 'explicit',
         });
     }
     async previewPipelineSelection(input) {
@@ -1270,58 +1416,86 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     async routeForRun(run) {
         if (isRouteDecision(run.data.route_decision))
             return run.data.route_decision;
-        return this.resolveRouteDecision({
-            title: typeof run.data.title === 'string' ? run.data.title : 'Run',
-            repo: Array.isArray(run.data.repos) && typeof run.data.repos[0] === 'string' ? run.data.repos[0] : '',
-            description: typeof run.data.description === 'string' ? run.data.description : '',
-            scope: typeof run.data.scope === 'string' ? run.data.scope : '',
-            playbookId: typeof run.data.playbook_id === 'string' ? run.data.playbook_id : undefined,
-            pipelineId: typeof run.data.pipeline_id === 'string' ? run.data.pipeline_id : undefined,
-            params: run.data.params,
-            source: run.data.pipeline_id ? 'explicit' : 'deterministic-installed-playbook',
-        });
+        throw new ControlPlaneError('VALIDATION_FAILURE', 'run route_decision is missing or invalid');
     }
     async resolveRouteDecision(input) {
         const params = normalizeParams(input.params, input.issueRef, input.issueAction);
-        const callerProfile = normalizeExecutionProfile(input.executionProfile);
         const playbook = await this.playbooks.resolvePlaybook(input.playbookId);
-        const requestedPipelineId = input.pipelineId
-            ?? (await this.resolveAutoPipeline(playbook.id, [input.title, input.description, input.scope].join(' '))).pipelineId;
+        const requestedPipelineId = input.pipelineId?.trim();
+        if (!requestedPipelineId) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', 'pipelineId is required');
+        }
+        const hasProfileId = input.profileId !== undefined;
+        const hasInlineProfile = input.profile !== undefined;
+        if (hasProfileId === hasInlineProfile) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', 'exactly one of profileId or profile is required');
+        }
+        if (input.profileId?.trim() === '') {
+            throw new ControlPlaneError('VALIDATION_FAILURE', 'profileId must be a non-empty string');
+        }
         const pipeline = await this.playbooks.resolvePipeline({ playbookId: playbook.id, pipelineId: requestedPipelineId });
-        let executionPolicy = pipeline.executionPolicy;
-        let executionProfile = callerProfile;
-        const provenanceFields = {};
+        let profileSnapshot;
+        let profileHash;
+        let provenanceFields;
         if (input.profileId !== undefined) {
             const storedProfile = await this.playbooks.resolveRunProfile({
                 playbookId: playbook.id,
                 pipelineId: pipeline.pipelineId,
                 profileId: input.profileId,
             });
-            const topologyProfile = topologyProfileFromRunProfile(storedProfile.profile);
-            const baseTemplate = pipeline.executionPolicy.template_json;
-            if (!baseTemplate) {
-                throw new ControlPlaneError('VALIDATION_FAILURE', `pipeline "${pipeline.pipelineId}" carries no template_json`);
+            profileSnapshot = storedProfile.profile;
+            this.assertStoredRunProfileValid(storedProfile);
+            profileHash = runProfileHash(profileSnapshot, {
+                pipelineId: storedProfile.pipelineId,
+                schemaVersion: storedProfile.schemaVersion,
+            });
+            if (storedProfile.profileHash !== profileHash) {
+                throw new ControlPlaneError('VALIDATION_FAILURE', `stored run profile ${storedProfile.profileId} hash mismatch: expected ${storedProfile.profileHash}, got ${profileHash}`);
+            }
+            provenanceFields = {
+                profileSource: 'stored',
+                profileId: storedProfile.profileId,
+                profileVersion: storedProfile.version,
+            };
+        }
+        else {
+            const inlineProfile = asRecord(input.profile);
+            if (!inlineProfile) {
+                throw new ControlPlaneError('VALIDATION_FAILURE', 'profile must be an object');
+            }
+            try {
+                assertValidInlineRunProfile(inlineProfile, 'profile');
             }
-            const { template: materializedTemplate, materializedTemplateHash, diagnostics } = materializeTemplate(baseTemplate, topologyProfile, { allowlist: topologyProfile.toggles.map((toggle) => toggle.target) });
-            if (diagnostics.length > 0) {
-                throw new ControlPlaneError('VALIDATION_FAILURE', `run profile ${storedProfile.profileId} cannot be materialized: ${diagnostics.map((item) => item.message).join('; ')}`, { details: { diagnostics } });
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new ControlPlaneError('VALIDATION_FAILURE', message);
             }
-            executionPolicy = { template_json: materializedTemplate };
-            executionProfile = executionProfileFromRunProfile(storedProfile.profile, callerProfile);
-            provenanceFields.requestedPipelineId = requestedPipelineId;
-            provenanceFields.basePipelineId = pipeline.pipelineId;
-            provenanceFields.profileId = storedProfile.profileId;
-            provenanceFields.profileVersion = storedProfile.version;
-            provenanceFields.profileHash = storedProfile.profileHash;
-            provenanceFields.profileSnapshot = storedProfile.profile;
-            provenanceFields.materializedTemplateHash = materializedTemplateHash;
-            provenanceFields.materializedTemplate = materializedTemplate;
-            provenanceFields.materializerVersion = MATERIALIZER_VERSION;
-            provenanceFields.policyVersion = POLICY_VERSION;
+            profileSnapshot = inlineProfile;
+            profileHash = runProfileHash(profileSnapshot, { pipelineId: pipeline.pipelineId });
+            provenanceFields = { profileSource: 'inline' };
+        }
+        const topologyProfile = topologyProfileFromRunProfile(profileSnapshot, {
+            pipelineId: pipeline.pipelineId,
+            profileId: provenanceFields.profileId ?? 'inline',
+        });
+        const baseTemplate = pipeline.executionPolicy.template_json;
+        if (!baseTemplate) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', `pipeline "${pipeline.pipelineId}" carries no template_json`);
         }
+        this.assertRunProfileStagesClosed(profileSnapshot, baseTemplate);
+        const { template: materializedTemplate, materializedTemplateHash, diagnostics } = materializeTemplate(baseTemplate, topologyProfile, { allowlist: topologyProfile.toggles.map((toggle) => toggle.target) });
+        if (diagnostics.length > 0) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', `run profile cannot be materialized: ${diagnostics.map((item) => item.message).join('; ')}`, { details: { diagnostics } });
+        }
+        const executionPolicy = { ...asRecord(pipeline.executionPolicy), template_json: materializedTemplate };
+        const launchBindings = launchBindingsFromRunProfile(profileSnapshot, {
+            lifecycleNodeIds: Object.entries(materializedTemplate.nodes)
+                .filter(([, node]) => node.kind === 'script')
+                .map(([nodeId]) => nodeId),
+        });
         const allRoles = (await this.roles.listRoles()).filter((role) => role.playbookId === playbook.id);
-        await this.assertExecutionProfileClosed(executionProfile, allRoles);
-        const roleBindings = await this.resolveRouteRoles(playbook.id, pipeline, executionProfile, allRoles);
+        await this.assertLaunchBindingsClosed(launchBindings, allRoles, materializedTemplate);
+        const roleBindings = await this.resolveRouteRoles(playbook.id, pipeline, launchBindings, allRoles);
         return {
             playbookId: playbook.id,
             pipelineId: requestedPipelineId,
@@ -1332,101 +1506,178 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             optionalRoles: pipeline.optionalRoles,
             routeGates: normalizeRouteGates(pipeline.routeGates),
             executionPolicy,
-            executionProfile,
+            launchBindings,
             roleBindings,
             params,
+            requestedPipelineId,
+            basePipelineId: pipeline.pipelineId,
+            profileHash,
+            profileSnapshot,
+            materializedTemplateHash,
+            materializedTemplate,
+            materializerVersion: MATERIALIZER_VERSION,
+            policyVersion: POLICY_VERSION,
             ...provenanceFields,
         };
     }
-    async assertExecutionProfileClosed(executionProfile, roles) {
-        const overrides = executionProfile.bindingOverrides ?? [];
-        if (overrides.length === 0)
+    async validateRunProfileForPipeline(input) {
+        return this.resolveRouteDecision({
+            title: 'Run profile validation',
+            repo: '',
+            playbookId: input.playbookId,
+            pipelineId: input.pipelineId,
+            profile: input.profile,
+            source: 'explicit',
+        });
+    }
+    assertStoredRunProfileValid(storedProfile) {
+        try {
+            assertValidInlineRunProfile(storedProfile.profile, `run_profiles.${storedProfile.profileId}.profile_json`);
+        }
+        catch (error) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', asErrorMessage(error));
+        }
+    }
+    assertRunProfileStagesClosed(profileSnapshot, template) {
+        const nodeIds = new Set(Object.keys(template.nodes));
+        for (const stage of topologyStageTargetsFromRunProfile(profileSnapshot)) {
+            if (nodeIds.has(stage))
+                continue;
+            throw this.profileSchemaClosed(`topology stage "${stage}" does not exist in pipeline ${template.pipelineId}`);
+        }
+    }
+    async assertLaunchBindingsClosed(launchBindings, roles, template) {
+        if (launchBindings.length === 0)
             return;
-        const available = executionProfile.availableRunners;
         const byPlaybookRole = new Map(roles.map((r) => [r.playbookRoleId || r.name, r]));
+        const nodes = template.nodes;
         const cachedProfiles = new Map();
-        for (const override of overrides) {
+        for (const override of launchBindings) {
             const matchLabel = JSON.stringify(override.match);
-            const { roleId: mRoleId, nodeId: mNodeId, runnerId: mRunnerId } = override.match;
-            if (!mRoleId && !mNodeId && !mRunnerId) {
-                throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} must specify at least one of roleId, nodeId, runnerId`);
-            }
-            // Validate match.runnerId too, not just override.runnerId — an unregistered/typo'd match
-            // target would otherwise silently match nothing and the override becomes a no-op.
-            if (mRunnerId !== undefined) {
-                if (available && !available.includes(mRunnerId)) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} runnerId "${mRunnerId}" not in availableRunners`);
-                }
-                if (!available && !BUILTIN_RUNNERS.has(mRunnerId)) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} runnerId "${mRunnerId}" is not a registered runner`);
-                }
-            }
-            if (override.runnerId !== undefined) {
-                const ovRunner = override.runnerId;
-                if (available && !available.includes(ovRunner)) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} runnerId "${ovRunner}" not in availableRunners`);
-                }
-                if (!available && !BUILTIN_RUNNERS.has(ovRunner)) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} runnerId "${ovRunner}" is not a registered runner`);
-                }
-            }
-            if (override.modelLevel !== undefined) {
-                const lvl = override.modelLevel;
-                if (!VALID_MODEL_LEVELS.includes(lvl)) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} modelLevel "${lvl}" is unavailable`);
-                }
-                const cached = cachedProfiles.get(lvl);
-                if (cached === undefined) {
-                    try {
-                        await this.roles.loadModelProfile(lvl);
-                        cachedProfiles.set(lvl, true);
-                    }
-                    catch (err) {
-                        const isNotFound = err instanceof ControlPlaneError && (err.code === 'ROW_NOT_FOUND' || err.code === 'VALIDATION_FAILURE');
-                        if (isNotFound) {
-                            cachedProfiles.set(lvl, false);
-                            throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} modelLevel "${lvl}" is unavailable`);
-                        }
-                        throw err;
-                    }
-                }
-                else if (!cached) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} modelLevel "${lvl}" is unavailable`);
-                }
-            }
-            if (override.timeoutMs !== undefined) {
-                const ms = override.timeoutMs;
-                if (!Number.isInteger(ms) || ms <= 0 || ms > 86_400_000) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} timeoutMs must be a positive integer <= 86400000, got ${ms}`);
-                }
-            }
-            if (override.permissionMode !== undefined) {
-                let effectiveRunner;
-                if (override.runnerId) {
-                    effectiveRunner = override.runnerId;
-                }
-                else if (mRunnerId) {
-                    effectiveRunner = executionProfile.runnerOverrides[mRunnerId] ?? mRunnerId;
-                }
-                else if (mRoleId) {
-                    const role = byPlaybookRole.get(mRoleId);
-                    if (!role) {
-                        throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} permissionMode override requires a resolvable runner; pin runnerId`);
-                    }
-                    effectiveRunner = executionProfile.runnerOverrides[role.runner] ?? role.runner;
-                }
-                else {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} permissionMode override requires a resolvable runner; pin runnerId`);
-                }
-                const validModes = RUNNER_PERMISSION_MODES[effectiveRunner];
-                if (!validModes) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} permissionMode not supported for runner ${effectiveRunner}`);
-                }
-                if (!validModes.includes(override.permissionMode)) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: bindingOverride match ${matchLabel} permissionMode "${override.permissionMode}" is not valid for runner ${effectiveRunner}; expected one of ${validModes.join(', ')}`);
-                }
+            this.assertBindingMatchIsClosed(override, matchLabel);
+            this.assertBindingTargetIsKnown(override, matchLabel, byPlaybookRole, nodes);
+            this.assertScriptBindingShape(override, matchLabel, nodes);
+            this.assertBindingAccounts(override, matchLabel, nodes);
+            this.assertRegisteredRunner(override.match.runnerId, matchLabel);
+            this.assertRegisteredRunner(override.runnerId, matchLabel);
+            await this.assertModelLevelAvailable(override.modelLevel, matchLabel, cachedProfiles);
+            this.assertBindingTimeout(override, matchLabel);
+            this.assertBindingPermissionMode(override, matchLabel, byPlaybookRole, launchBindings);
+        }
+    }
+    profileSchemaClosed(message) {
+        return new ControlPlaneError('VALIDATION_FAILURE', `PROFILE_SCHEMA_CLOSED: ${message}`);
+    }
+    assertBindingMatchIsClosed(override, matchLabel) {
+        const { roleId, nodeId, runnerId } = override.match;
+        if (roleId || nodeId || runnerId)
+            return;
+        throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} must specify at least one of roleId, nodeId, runnerId`);
+    }
+    assertBindingTargetIsKnown(override, matchLabel, byPlaybookRole, nodes) {
+        const { roleId, nodeId } = override.match;
+        if (roleId !== undefined && !byPlaybookRole.has(roleId)) {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} roleId "${roleId}" does not exist in the selected playbook`);
+        }
+        if (nodeId !== undefined && !nodes[nodeId]) {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} nodeId "${nodeId}" does not exist in the selected pipeline`);
+        }
+    }
+    assertScriptBindingShape(override, matchLabel, nodes) {
+        const nodeId = override.match.nodeId;
+        if (!nodeId || nodes[nodeId]?.kind !== 'script')
+            return;
+        if (override.runnerId || override.modelLevel || override.timeoutMs !== undefined || override.permissionMode) {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} targets script node "${nodeId}" and must not set runnerId, modelLevel, timeoutMs, or permissionMode`);
+        }
+    }
+    assertBindingAccounts(override, matchLabel, nodes) {
+        const github = override.accounts?.github;
+        if (github === undefined)
+            return;
+        if (!github.trim()) {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} accounts.github must be a non-empty string`);
+        }
+        const nodeId = override.match.nodeId;
+        if (!nodeId || nodes[nodeId]?.kind !== 'script') {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} accounts are only supported for script nodes`);
+        }
+    }
+    assertRegisteredRunner(runnerId, matchLabel) {
+        if (runnerId === undefined || BUILTIN_RUNNERS.has(runnerId))
+            return;
+        throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} runnerId "${runnerId}" is not a registered runner`);
+    }
+    async assertModelLevelAvailable(modelLevel, matchLabel, cachedProfiles) {
+        if (modelLevel === undefined)
+            return;
+        if (!VALID_MODEL_LEVELS.includes(modelLevel)) {
+            throw this.unavailableModelLevel(matchLabel, modelLevel);
+        }
+        const cached = cachedProfiles.get(modelLevel);
+        if (cached === true)
+            return;
+        if (cached === false)
+            throw this.unavailableModelLevel(matchLabel, modelLevel);
+        try {
+            await this.roles.loadModelProfile(modelLevel);
+            cachedProfiles.set(modelLevel, true);
+        }
+        catch (err) {
+            const isUnavailable = err instanceof ControlPlaneError && (err.code === 'ROW_NOT_FOUND' || err.code === 'VALIDATION_FAILURE');
+            if (!isUnavailable)
+                throw err;
+            cachedProfiles.set(modelLevel, false);
+            throw this.unavailableModelLevel(matchLabel, modelLevel);
+        }
+    }
+    unavailableModelLevel(matchLabel, modelLevel) {
+        return this.profileSchemaClosed(`bindingOverride match ${matchLabel} modelLevel "${modelLevel}" is unavailable`);
+    }
+    assertBindingTimeout(override, matchLabel) {
+        const ms = override.timeoutMs;
+        if (ms === undefined || (Number.isInteger(ms) && ms > 0 && ms <= 86_400_000))
+            return;
+        throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} timeoutMs must be a positive integer <= 86400000, got ${ms}`);
+    }
+    assertBindingPermissionMode(override, matchLabel, byPlaybookRole, launchBindings) {
+        const permissionMode = override.permissionMode;
+        if (permissionMode === undefined)
+            return;
+        const effectiveRunner = this.effectivePermissionRunner(override, matchLabel, byPlaybookRole, launchBindings);
+        const validModes = RUNNER_PERMISSION_MODES[effectiveRunner];
+        if (!validModes) {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} permissionMode not supported for runner ${effectiveRunner}`);
+        }
+        if (!validModes.includes(permissionMode)) {
+            throw this.profileSchemaClosed(`bindingOverride match ${matchLabel} permissionMode "${permissionMode}" is not valid for runner ${effectiveRunner}; expected one of ${validModes.join(', ')}`);
+        }
+    }
+    effectivePermissionRunner(override, matchLabel, byPlaybookRole, launchBindings) {
+        if (override.runnerId)
+            return override.runnerId;
+        if (override.match.runnerId)
+            return override.match.runnerId;
+        const roleId = override.match.roleId;
+        if (!roleId)
+            throw this.unresolvablePermissionRunner(matchLabel);
+        const role = byPlaybookRole.get(roleId);
+        if (!role)
+            throw this.unresolvablePermissionRunner(matchLabel);
+        const roleOverride = this.findLastRoleRunnerOverride(launchBindings, roleId);
+        return roleOverride?.runnerId ?? role.runner;
+    }
+    findLastRoleRunnerOverride(launchBindings, roleId) {
+        for (let index = launchBindings.length - 1; index >= 0; index -= 1) {
+            const candidate = launchBindings[index];
+            if (candidate.match.roleId === roleId && !candidate.match.nodeId && candidate.runnerId !== undefined) {
+                return candidate;
             }
         }
+        return undefined;
+    }
+    unresolvablePermissionRunner(matchLabel) {
+        return this.profileSchemaClosed(`bindingOverride match ${matchLabel} permissionMode override requires a resolvable runner; pin runnerId`);
     }
     async resolveAutoPipeline(playbookId, text) {
         const pipelines = (await this.playbooks.listPipelines())
@@ -1448,7 +1699,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         }
         return best.pipeline;
     }
-    async resolveRouteRoles(playbookId, pipeline, executionProfile, preloadedRoles) {
+    async resolveRouteRoles(playbookId, pipeline, launchBindings, preloadedRoles) {
         const roles = preloadedRoles ?? (await this.roles.listRoles()).filter((role) => role.playbookId === playbookId);
         const byPlaybookRole = new Map(roles.map((role) => [role.playbookRoleId || role.name, role]));
         const selected = [...pipeline.requiredRoles];
@@ -1468,10 +1719,10 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         return selected.map((roleId) => {
             const role = byPlaybookRole.get(roleId);
             assertProductionRunnerBinding(role.runner, 'playbook', roleId);
-            const runnerResolved = resolveRunnerForRole(role.runner, roleId, executionProfile);
+            const runnerResolved = resolveRunnerForRole(role.runner, roleId, launchBindings);
             assertProductionRunnerBinding(runnerResolved.runnerId, runnerResolved.source, roleId);
-            assertRunnerAvailable(runnerResolved.runnerId, executionProfile, roleId);
-            const bindingResolution = resolveBindingForRole(role, roleId, runnerResolved.runnerId, executionProfile);
+            assertRunnerAvailable(runnerResolved.runnerId, roleId);
+            const bindingResolution = resolveBindingForRole(role, roleId, runnerResolved.runnerId, launchBindings);
             return {
                 roleId,
                 rowId: role.id,