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

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

@@ -15,17 +15,24 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { Inject, Injectable } from '@nestjs/common';
-import { baseUrl, getConfig, isAlive, isHealthy, readRuntime } from '../cli/config.js';
+import { baseUrl, getConfig, isAlive } from '../cli/config.js';
+import { isGraphqlHealthy } from '../host/ensure-host.js';
+import { readHostRuntime } from '../host/host-runtime.js';
 import { AgentObservabilityService } from '../observability/agent-observability.service.js';
 import { ControlPlaneError } from '../control-plane/errors.js';
+import { VALID_MODEL_LEVELS } from '../control-plane/definitions.js';
 import { validateManualAdoptionAudit } from '../control-plane/manual-adoption-audit.js';
 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 { 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 { RUN_PROGRESS_EVENT_KEY } from '../pipeline/data-driven-task.workflow.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, resolveRunnerForProfile, } 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';
@@ -33,10 +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']);
-const BUILTIN_RUNNERS = new Set(['claude-code', 'codex', 'script', 'stub-agent', 'revo-integrator', 'revo-merger', 'revo-deterministic']);
+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']);
 function asErrorMessage(error) {
     if (error instanceof Error)
         return error.message;
@@ -47,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;
@@ -64,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);
@@ -76,6 +126,38 @@ function gateDeclaredOutcomes(item) {
 function gateOutcomes(item) {
     return gateDeclaredOutcomes(item);
 }
+function gateSummaryNodeId(item) {
+    const context = asRecord(item.context);
+    const summary = asRecord(context?.summary);
+    const nodeId = summary?.nodeId;
+    return typeof nodeId === 'string' ? nodeId : undefined;
+}
+function isQuestionGateReasonOutcome(item, outcome) {
+    if (outcome !== 'fix' && outcome !== 'wontfix')
+        return false;
+    if (gateSummaryNodeId(item) === 'questionGate')
+        return true;
+    const outcomes = gateOutcomes(item);
+    return gateTopic(item) === 'question' && outcomes.includes('fix') && outcomes.includes('wontfix');
+}
+function assertRequiredGateNote(item, outcome, note) {
+    if (outcome === 'approve_anyway' && !note) {
+        throw new ControlPlaneError('VALIDATION_FAILURE', 'approve_anyway requires a non-empty note');
+    }
+    if (outcome === 'override_merge' && !note) {
+        throw new ControlPlaneError('VALIDATION_FAILURE', 'override_merge requires a non-empty note');
+    }
+    if (isQuestionGateReasonOutcome(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, {
@@ -136,13 +218,11 @@ function summarizeAttempts(attempts) {
 function normalizedRunStatus(status) {
     return status === 'paused' ? 'blocked' : status;
 }
-function hasWorkflowProgress(events) {
+export function hasWorkflowProgress(events) {
     return events.some((event) => (event.type.startsWith('step_')
         || event.type.startsWith('attempt_')
         || event.type.startsWith('gate_')
-        || event.type === 'pipeline_blocked'
-        || event.type === 'pr_polled'
-        || event.type === 'integrate_succeeded'));
+        || WORKFLOW_PROGRESS_EVENT_TYPES.has(event.type)));
 }
 function observedRunStatus(rowStatus, workflowStatus, events) {
     if (rowStatus !== 'ready')
@@ -215,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) ?? {};
 }
@@ -385,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;
@@ -419,17 +489,17 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         this.prReadiness = prReadiness;
     }
     async getStatus() {
-        const runtime = readRuntime();
-        const alive = runtime ? isAlive(runtime.pid) : false;
-        const healthy = runtime && alive ? await isHealthy(runtime.httpPort) : false;
+        const host = readHostRuntime();
+        const hostAlive = host ? isAlive(host.pid) : false;
+        const hostHealthy = host && hostAlive ? await isGraphqlHealthy(host.graphqlPort) : false;
         return {
             daemon: {
-                running: Boolean(runtime && alive),
-                healthy,
-                pid: runtime?.pid ?? null,
-                baseUrl: runtime ? baseUrl(runtime.httpPort) : null,
-                httpPort: runtime?.httpPort ?? null,
-                pgPort: runtime?.pgPort ?? null,
+                running: Boolean(host && hostAlive),
+                healthy: hostHealthy,
+                pid: host?.pid ?? null,
+                baseUrl: host ? `${baseUrl(host.graphqlPort)}/graphql` : null,
+                graphqlPort: host?.graphqlPort ?? null,
+                mcpPort: host?.mcpPort ?? null,
             },
             project: this.getProject(),
         };
@@ -438,9 +508,9 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         const status = await this.getStatus();
         const issues = [];
         if (!status.daemon.running)
-            issues.push('Local Revisium daemon is not running.');
+            issues.push('Revo host daemon is not running.');
         if (status.daemon.running && !status.daemon.healthy)
-            issues.push('Local Revisium daemon is running but unhealthy.');
+            issues.push('Revo host daemon is running but unhealthy.');
         try {
             await this.roles.loadPipelinePolicy();
         }
@@ -523,10 +593,12 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             scope: input.scope,
             playbookId: input.playbookId,
             pipelineId: input.pipelineId,
+            profileId: input.profileId,
+            profile: input.profile,
             params: input.params,
             issueRef: input.issueRef,
-            executionProfile: input.executionProfile,
-            source: input.pipelineId ? 'explicit' : 'deterministic-installed-playbook',
+            issueAction: input.issueAction,
+            source: 'explicit',
         });
         const result = await this.runs.createRun({
             title: input.title,
@@ -540,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 };
@@ -655,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 {
@@ -815,6 +885,16 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
                 routeGates: route.routeGates,
                 activeNodeIds: activeIds,
                 status: cursorStatus(progress),
+                provenance: Object.fromEntries([
+                    ['requestedPipelineId', route.requestedPipelineId],
+                    ['basePipelineId', route.basePipelineId],
+                    ['profileId', route.profileId],
+                    ['profileVersion', route.profileVersion],
+                    ['profileHash', route.profileHash],
+                    ['materializedTemplateHash', route.materializedTemplateHash],
+                    ['materializerVersion', route.materializerVersion],
+                    ['policyVersion', route.policyVersion],
+                ].filter(([, v]) => v !== undefined)),
             },
             nodes,
             edges,
@@ -987,7 +1067,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     async approveGate(input) {
         const item = await this.getInboxItem(input.inboxId);
         const outcomes = gateDeclaredOutcomes(item);
-        this.assertLegacyGateWrapperAllowed(input.inboxId, outcomes);
+        this.assertLegacyGateWrapperAllowed(item, input.inboxId, outcomes);
         if (outcomes.length === 0 || (outcomes.length === 1 && outcomes[0] === 'approved')) {
             const resolvedBy = input.resolvedBy ?? 'mcp';
             return this.resolveLegacyGate(item, { decision: 'approve', resolvedBy }, resolvedBy, input.inboxId);
@@ -1001,7 +1081,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     async rejectGate(input) {
         const item = await this.getInboxItem(input.inboxId);
         const outcomes = gateDeclaredOutcomes(item);
-        this.assertLegacyGateWrapperAllowed(input.inboxId, outcomes);
+        this.assertLegacyGateWrapperAllowed(item, input.inboxId, outcomes);
         if (outcomes.length === 0) {
             const resolvedBy = input.resolvedBy ?? 'mcp';
             return this.resolveLegacyGate(item, { decision: 'reject', resolvedBy }, resolvedBy, input.inboxId);
@@ -1017,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) {
@@ -1028,9 +1108,8 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             throw new ControlPlaneError('VALIDATION_FAILURE', `invalid gate outcome ${outcome}; expected one of: ${outcomes.join(', ')}`);
         }
         const note = input.note?.trim();
-        if (outcome === 'approve_anyway' && !note) {
-            throw new ControlPlaneError('VALIDATION_FAILURE', 'approve_anyway requires a non-empty note');
-        }
+        const reconcile = normalizeGateReconcile(input.reconcile);
+        assertRequiredGateNote(item, outcome, note);
         const adoptionAudit = outcome === 'adopt_patch_manually'
             ? validateManualAdoptionAudit(input.adoptionAudit, item)
             : undefined;
@@ -1041,6 +1120,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         const answer = {
             outcome,
             ...(note ? { note } : {}),
+            ...(reconcile ? { reconcile } : {}),
             ...(adoptionAudit ? { adoptionAudit } : {}),
             ...(mergeOverrideAudit ? { mergeOverrideAudit } : {}),
             resolvedBy,
@@ -1058,8 +1138,12 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             runId: item.runId,
         };
     }
-    assertLegacyGateWrapperAllowed(inboxId, outcomes) {
-        if (outcomes.length > 2 || outcomes.includes('approve_anyway')) {
+    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}`);
         }
     }
@@ -1090,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);
@@ -1116,9 +1215,8 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
                 }
                 this.assertGateOutcome(item, outcome);
                 const note = typeof answer?.note === 'string' ? answer.note.trim() : '';
-                if (outcome === 'approve_anyway' && !note) {
-                    throw new ControlPlaneError('VALIDATION_FAILURE', 'approve_anyway requires a non-empty note');
-                }
+                const reconcile = normalizeGateReconcile(answer.reconcile);
+                assertRequiredGateNote(item, outcome, note);
                 const adoptionAudit = outcome === 'adopt_patch_manually'
                     ? validateManualAdoptionAudit(answer.adoptionAudit, item)
                     : undefined;
@@ -1129,6 +1227,7 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
                     ...answer,
                     outcome,
                     ...(typeof answer.note === 'string' ? { note } : {}),
+                    ...(reconcile ? { reconcile } : {}),
                     ...(adoptionAudit ? { adoptionAudit } : {}),
                     ...(mergeOverrideAudit ? { mergeOverrideAudit } : {}),
                 };
@@ -1149,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 {
@@ -1188,6 +1304,83 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     listPipelines() {
         return this.playbooks.listPipelines();
     }
+    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)
@@ -1200,8 +1393,10 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             repo: input.repo ?? '',
             playbookId: input.playbookId,
             pipelineId: input.pipeline,
+            profileId: input.profileId,
+            profile: input.profile,
             params: input.params,
-            source: input.pipeline ? 'explicit' : 'deterministic-installed-playbook',
+            source: 'explicit',
         });
     }
     async previewPipelineSelection(input) {
@@ -1221,40 +1416,269 @@ 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);
-        const executionProfile = normalizeExecutionProfile(input.executionProfile);
+        const params = normalizeParams(input.params, input.issueRef, input.issueAction);
         const playbook = await this.playbooks.resolvePlaybook(input.playbookId);
-        const pipeline = input.pipelineId
-            ? await this.playbooks.resolvePipeline({ playbookId: playbook.id, pipelineId: input.pipelineId })
-            : await this.resolveAutoPipeline(playbook.id, [input.title, input.description, input.scope].join(' '));
-        const roleBindings = await this.resolveRouteRoles(playbook.id, pipeline, executionProfile);
+        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 profileSnapshot;
+        let profileHash;
+        let provenanceFields;
+        if (input.profileId !== undefined) {
+            const storedProfile = await this.playbooks.resolveRunProfile({
+                playbookId: playbook.id,
+                pipelineId: pipeline.pipelineId,
+                profileId: input.profileId,
+            });
+            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');
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new ControlPlaneError('VALIDATION_FAILURE', message);
+            }
+            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.assertLaunchBindingsClosed(launchBindings, allRoles, materializedTemplate);
+        const roleBindings = await this.resolveRouteRoles(playbook.id, pipeline, launchBindings, allRoles);
         return {
             playbookId: playbook.id,
-            pipelineId: pipeline.pipelineId,
+            pipelineId: requestedPipelineId,
             pipelineRowId: pipeline.id,
             source: input.source,
             roles: roleBindings.map((binding) => binding.roleId),
             requiredRoles: pipeline.requiredRoles,
             optionalRoles: pipeline.optionalRoles,
             routeGates: normalizeRouteGates(pipeline.routeGates),
-            executionPolicy: pipeline.executionPolicy,
-            executionProfile,
+            executionPolicy,
+            launchBindings,
             roleBindings,
             params,
+            requestedPipelineId,
+            basePipelineId: pipeline.pipelineId,
+            profileHash,
+            profileSnapshot,
+            materializedTemplateHash,
+            materializedTemplate,
+            materializerVersion: MATERIALIZER_VERSION,
+            policyVersion: POLICY_VERSION,
+            ...provenanceFields,
         };
     }
+    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 byPlaybookRole = new Map(roles.map((r) => [r.playbookRoleId || r.name, r]));
+        const nodes = template.nodes;
+        const cachedProfiles = new Map();
+        for (const override of launchBindings) {
+            const matchLabel = JSON.stringify(override.match);
+            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())
             .filter((pipeline) => pipeline.playbookId === playbookId)
@@ -1275,8 +1699,8 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         }
         return best.pipeline;
     }
-    async resolveRouteRoles(playbookId, pipeline, executionProfile) {
-        const roles = (await this.roles.listRoles()).filter((role) => role.playbookId === playbookId);
+    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];
         for (const group of pipeline.alternativeRoles) {
@@ -1295,16 +1719,25 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         return selected.map((roleId) => {
             const role = byPlaybookRole.get(roleId);
             assertProductionRunnerBinding(role.runner, 'playbook', roleId);
-            const resolved = resolveRunnerForProfile(role.runner, executionProfile);
-            assertProductionRunnerBinding(resolved.runnerId, resolved.source, roleId);
-            assertRunnerAvailable(resolved.runnerId, executionProfile, roleId);
+            const runnerResolved = resolveRunnerForRole(role.runner, roleId, launchBindings);
+            assertProductionRunnerBinding(runnerResolved.runnerId, runnerResolved.source, roleId);
+            assertRunnerAvailable(runnerResolved.runnerId, roleId);
+            const bindingResolution = resolveBindingForRole(role, roleId, runnerResolved.runnerId, launchBindings);
             return {
                 roleId,
                 rowId: role.id,
                 modelLevel: role.modelLevel,
                 runnerId: role.runner,
-                resolvedRunnerId: resolved.runnerId,
-                runnerSource: resolved.source,
+                resolvedRunnerId: runnerResolved.runnerId,
+                runnerSource: runnerResolved.source,
+                resolvedModelLevel: bindingResolution.resolvedModelLevel,
+                modelSource: bindingResolution.modelSource,
+                timeoutMs: role.timeoutMs,
+                resolvedTimeoutMs: bindingResolution.resolvedTimeoutMs,
+                timeoutSource: bindingResolution.timeoutSource,
+                permissionMode: role.permissionMode,
+                resolvedPermissionMode: bindingResolution.resolvedPermissionMode,
+                permissionSource: bindingResolution.permissionSource,
             };
         });
     }