@revisium/orchestrator 0.0.0 → 0.1.0-alpha.10

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

@@ -7,22 +7,32 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 import { execFile } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { baseUrl, getConfig, isAlive, isHealthy, readRuntime } from '../cli/config.js';
+import { AgentObservabilityService } from '../observability/agent-observability.service.js';
 import { ControlPlaneError } from '../control-plane/errors.js';
 import { DbosService } from '../engine/dbos.service.js';
-import { PipelineService } from '../pipeline/develop-task.workflow.js';
+import { PipelineService } from '../pipeline/pipeline.service.js';
+import { 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 { InboxService } from '../revisium/inbox.service.js';
 import { PlaybooksService } from '../revisium/playbooks.service.js';
 import { RolesService } from '../revisium/roles.service.js';
 import { RunService } from '../revisium/run.service.js';
 import { PrReadinessService } from './pr-readiness.service.js';
 const execFileAsync = promisify(execFile);
-const GATE_TOPICS = new Set(['plan', 'merge']);
+const GATE_TOPICS = new Set(['plan', 'merge', 'question']);
+const WORKFLOW_SUCCESS_EVENT_TYPES = new Set(['step_succeeded', 'gate_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']);
 function asErrorMessage(error) {
     if (error instanceof Error)
         return error.message;
@@ -33,6 +43,14 @@ function asRecord(value) {
         return null;
     return value;
 }
+function dateOrEpoch(value) {
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? new Date(0) : value;
+    if (value === undefined || value === '')
+        return new Date(0);
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? new Date(0) : parsed;
+}
 function gateTopic(item) {
     if (item.kind !== 'approval' || !item.runId)
         return null;
@@ -99,6 +117,171 @@ function summarizeAttempts(attempts) {
         costAmount: acc.costAmount + attempt.costAmount,
     }), { inputTokens: 0, outputTokens: 0, costAmount: 0 });
 }
+function normalizedRunStatus(status) {
+    return status === 'paused' ? 'blocked' : status;
+}
+function payloadRecord(event) {
+    return asRecord(event.payload);
+}
+function eventStepKey(event) {
+    const payload = payloadRecord(event);
+    const stepKey = payload?.stepKey;
+    return typeof stepKey === 'string' ? stepKey : '';
+}
+function eventSummary(event) {
+    const payload = payloadRecord(event);
+    const reason = payload?.reason;
+    const output = payload?.output;
+    if (typeof reason === 'string' && reason)
+        return reason;
+    if (typeof output === 'string' && output)
+        return output.slice(0, 180);
+    return event.type;
+}
+function stepKeyBase(stepKey) {
+    return stepKey.split('#')[0] ?? stepKey;
+}
+function activeNodeIds(progress) {
+    const cursor = asRecord(progress.graphCursor);
+    const value = cursor?.activeNodeIds;
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function cursorStatus(progress) {
+    const cursor = asRecord(progress.graphCursor);
+    const status = cursor?.status;
+    return typeof status === 'string' ? status : progress.workflowStatus;
+}
+function templateNodeLabel(node) {
+    return node.displayName ?? node.id.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/[-_]/g, ' ');
+}
+function roleFromRef(roleRef) {
+    if (!roleRef)
+        return null;
+    return roleRef.startsWith('role:') ? roleRef.slice('role:'.length) : roleRef;
+}
+function scriptFromRef(scriptRef) {
+    if (!scriptRef)
+        return null;
+    return scriptRef.startsWith('script:') ? scriptRef.slice('script:'.length) : scriptRef;
+}
+function mapAttemptForWorkflow(runId, attempt) {
+    return {
+        id: attempt.attemptId,
+        runId,
+        stepId: attempt.stepId,
+        stepKey: attempt.stepId,
+        iteration: attempt.iteration,
+        status: attempt.status,
+        verdict: attempt.verdict,
+        modelProfile: attempt.modelProfile,
+        inputTokens: attempt.inputTokens,
+        outputTokens: attempt.outputTokens,
+        costAmount: attempt.costAmount,
+        currency: attempt.currency,
+        durationMs: attempt.durationMs,
+        outputSummary: attempt.outputSummary,
+        artifactRef: attempt.artifactRef,
+        lesson: attempt.lesson,
+        error: attempt.error,
+        startedAt: dateOrEpoch(attempt.startedAt),
+    };
+}
+function mapInboxForWorkflow(item) {
+    return {
+        ...item,
+        runId: item.runId || null,
+        taskId: item.taskId || null,
+        stepId: item.stepId || null,
+        projectId: item.projectId || null,
+        resolvedBy: item.resolvedBy || null,
+        createdAt: dateOrEpoch(item.createdAt),
+        resolvedAt: item.resolvedAt ? dateOrEpoch(item.resolvedAt) : null,
+    };
+}
+function mapRunForWorkflow(run) {
+    return {
+        id: run.runId ?? run.id ?? '',
+        title: run.title ?? '',
+        status: normalizedRunStatus(run.status ?? ''),
+        priority: run.priority ?? 0,
+        description: run.description,
+        scope: run.scope,
+        repos: run.repos ?? [],
+        createdAt: dateOrEpoch(run.createdAt),
+    };
+}
+function workflowNodeStatus(input) {
+    if (input.gate)
+        return 'awaiting_approval';
+    if (input.failed)
+        return 'failed';
+    if (input.active)
+        return 'running';
+    if (input.succeeded)
+        return 'succeeded';
+    return 'pending';
+}
+function workflowGateTopic(node) {
+    const metadata = asRecord(node.metadata);
+    const reason = metadata?.reason;
+    return typeof reason === 'string' && reason ? reason : node.id;
+}
+function addAttemptForWorkflowNode(attemptsByBase, seenAttemptIdsByBase, base, attempt) {
+    const seen = seenAttemptIdsByBase.get(base) ?? new Set();
+    if (seen.has(attempt.attemptId))
+        return;
+    seen.add(attempt.attemptId);
+    seenAttemptIdsByBase.set(base, seen);
+    attemptsByBase.set(base, [...(attemptsByBase.get(base) ?? []), attempt]);
+}
+function workflowEdges(node) {
+    const record = node;
+    const edges = [];
+    const add = (to, label = '', kind = 'next') => {
+        if (typeof to === 'string' && to)
+            edges.push({ from: node.id, to, label, kind });
+    };
+    add(record.next);
+    add(record.join, 'join', 'join');
+    const branches = Array.isArray(record.branches) ? record.branches : [];
+    for (const branch of branches) {
+        const item = asRecord(branch);
+        add(item?.goto ?? item?.entry, typeof item?.id === 'string' ? item.id : '', node.kind === 'humanGate' ? 'gate' : 'branch');
+    }
+    return edges;
+}
+function words(value) {
+    return new Set(value.toLowerCase().split(/[^a-z0-9]+/).filter((part) => part.length > 2));
+}
+function routeScore(pipeline, text) {
+    const input = words(text);
+    let score = 0;
+    for (const trigger of pipeline.triggers) {
+        for (const word of words(trigger)) {
+            if (input.has(word))
+                score += 1;
+        }
+    }
+    return score;
+}
+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)) {
+        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')
+        return;
+    throw new ControlPlaneError('VALIDATION_FAILURE', `role ${roleId} binds production runner stub-agent; use an execution profile override for test stubs`);
+}
 let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     runs;
     inbox;
@@ -106,14 +289,16 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     playbooks;
     pipeline;
     dbos;
+    observability;
     prReadiness;
-    constructor(runs, inbox, roles, playbooks, pipeline, dbos, prReadiness = new PrReadinessService()) {
+    constructor(runs, inbox, roles, playbooks, pipeline, dbos, observability, prReadiness = new PrReadinessService()) {
         this.runs = runs;
         this.inbox = inbox;
         this.roles = roles;
         this.playbooks = playbooks;
         this.pipeline = pipeline;
         this.dbos = dbos;
+        this.observability = observability;
         this.prReadiness = prReadiness;
     }
     async getStatus() {
@@ -214,19 +399,36 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         return { ...validation, files, ...packageContext };
     }
     async createRun(input) {
+        const route = await this.resolveRouteDecision({
+            title: input.title,
+            repo: input.repo,
+            description: input.description,
+            scope: input.scope,
+            playbookId: input.playbookId,
+            pipelineId: input.pipelineId,
+            params: input.params,
+            executionProfile: input.executionProfile,
+            source: input.pipelineId ? 'explicit' : 'deterministic-installed-playbook',
+        });
         const result = await this.runs.createRun({
             title: input.title,
             repo: input.repo,
             description: input.description,
             scope: input.scope,
             priority: input.priority ?? 0,
-            role: input.role ?? 'architect',
+            role: route.roleBindings[0]?.rowId ?? input.role ?? 'architect',
+            playbookId: route.playbookId,
+            pipelineId: route.pipelineId,
+            params: route.params,
+            routeDecision: route,
+            executionProfile: route.executionProfile,
         });
         if (!input.start)
-            return { ...result, started: false };
+            return { ...result, started: false, route };
         const started = await this.startRun({
             runId: result.runId,
-            runnerMode: input.runnerMode ?? 'script',
+            runnerMode: input.runnerMode,
+            route,
         });
         return { ...result, started: true, workflow: started };
     }
@@ -234,15 +436,25 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         const run = await this.runs.getRun(input.runId);
         if (!run)
             throw new ControlPlaneError('ROW_NOT_FOUND', `run not found: ${input.runId}`);
+        const route = input.route ?? await this.routeForRun(run);
         const existingStatus = await this.dbos.getWorkflowStatus(input.runId);
-        const handle = await this.pipeline.startDevelopTask(input.runId, {
-            runnerMode: input.runnerMode ?? 'script',
-        });
+        // CUTOVER (plan 0015 slice 3): the data-driven engine is the SOLE pipeline engine. EVERY pipeline
+        // routes to the data-driven workflow, executing the state-machine template carried in its
+        // execution_policy (template_json). A pipeline lacking a valid template FAILS LOUD here
+        // (PIPELINE_NOT_DATA_DRIVEN) rather than silently no-op-ing — there is no hardcoded fallback engine.
+        // A present-but-malformed/invalid template likewise throws (templateFromExecutionPolicy).
+        const template = templateFromExecutionPolicy(route.executionPolicy);
+        if (!template) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', `PIPELINE_NOT_DATA_DRIVEN: pipeline ${route.pipelineId} carries no state-machine template ` +
+                `(execution_policy.template_json); the data-driven engine is the only engine`);
+        }
+        const handle = await this.pipeline.startDataDrivenTask(input.runId, { route, template });
         return {
             runId: input.runId,
             workflowID: handle.workflowID,
             alreadyStarted: existingStatus !== null,
-            runnerMode: input.runnerMode ?? 'script',
+            route,
+            engine: 'data-driven',
         };
     }
     resumeRun(input) {
@@ -270,9 +482,146 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
     getRunEvents(input) {
         return this.runs.listRunEvents(input.runId, { type: input.type, limit: input.limit });
     }
+    async getRunProgress(runId) {
+        const detail = await this.runs.showRun(runId);
+        if (!detail)
+            throw new ControlPlaneError('ROW_NOT_FOUND', `run not found: ${runId}`);
+        const workflow = await this.dbos.getWorkflowStatus(runId);
+        if (!workflow) {
+            return {
+                workflowStatus: 'NOT_STARTED',
+                graphCursor: null,
+                updatedAt: dateOrEpoch(detail.run.createdAt),
+            };
+        }
+        const graphCursor = await this.dbos.getEvent(workflow.workflowID, RUN_PROGRESS_EVENT_KEY, { timeoutSeconds: 0 });
+        return {
+            workflowStatus: workflow.status,
+            graphCursor,
+            updatedAt: dateOrEpoch(workflow.updatedAt ?? workflow.createdAt),
+        };
+    }
     getRunLog(input) {
         return this.runs.listRunAttempts(input.runId, { limit: input.limit });
     }
+    async getRunWorkflow(runId) {
+        const [detail, runRow, events, attempts, pendingInbox, progress] = await Promise.all([
+            this.getRun({ runId }),
+            this.runs.getRun(runId),
+            this.runs.listRunEvents(runId, { limit: 500 }),
+            this.runs.listRunAttempts(runId, { limit: 500 }),
+            this.inbox.listInbox({ runId, status: 'pending', limit: 100 }),
+            this.getRunProgress(runId),
+        ]);
+        if (!runRow)
+            throw new ControlPlaneError('ROW_NOT_FOUND', `run not found: ${runId}`);
+        const route = await this.routeForRun(runRow);
+        const template = templateFromExecutionPolicy(route.executionPolicy);
+        const activeIds = activeNodeIds(progress);
+        const active = new Set(activeIds);
+        const succeeded = new Set(events
+            .filter((event) => WORKFLOW_SUCCESS_EVENT_TYPES.has(event.type))
+            .map(eventStepKey)
+            .filter(Boolean)
+            .map(stepKeyBase));
+        const failed = new Set(events
+            .filter((event) => WORKFLOW_FAILURE_EVENT_TYPES.has(event.type))
+            .map(eventStepKey)
+            .filter(Boolean)
+            .map(stepKeyBase));
+        const inboxByNode = new Map();
+        for (const item of pendingInbox) {
+            const context = asRecord(item.context);
+            const summary = asRecord(context?.summary);
+            const nodeId = typeof summary?.nodeId === 'string' ? summary.nodeId : '';
+            if (nodeId)
+                inboxByNode.set(nodeId, item);
+        }
+        const attemptsByBase = new Map();
+        const seenAttemptIdsByBase = new Map();
+        for (const event of events) {
+            const key = eventStepKey(event);
+            if (!key)
+                continue;
+            const base = stepKeyBase(key);
+            const eventAttempts = attempts.filter((attempt) => attempt.attemptId === asRecord(event.payload)?.attemptId);
+            for (const attempt of eventAttempts) {
+                addAttemptForWorkflowNode(attemptsByBase, seenAttemptIdsByBase, base, attempt);
+            }
+        }
+        const nodes = Object.values(template?.nodes ?? {}).map((node) => {
+            const record = node;
+            const nodeAttempts = attemptsByBase.get(node.id) ?? [];
+            const roleId = roleFromRef(record.roleRef);
+            const binding = roleId ? route.roleBindings.find((item) => item.roleId === roleId) : undefined;
+            const isActive = active.has(node.id);
+            const gate = inboxByNode.get(node.id);
+            const status = workflowNodeStatus({
+                gate,
+                failed: failed.has(node.id),
+                active: isActive,
+                succeeded: succeeded.has(node.id),
+            });
+            return {
+                id: node.id,
+                label: templateNodeLabel(node),
+                kind: node.kind,
+                roleId,
+                scriptId: scriptFromRef(record.scriptRef),
+                modelLevel: binding?.modelLevel ?? null,
+                runner: binding?.resolvedRunnerId ?? null,
+                status,
+                attemptCount: nodeAttempts.length,
+                inputTokens: nodeAttempts.reduce((sum, attempt) => sum + attempt.inputTokens, 0),
+                outputTokens: nodeAttempts.reduce((sum, attempt) => sum + attempt.outputTokens, 0),
+                costAmount: nodeAttempts.reduce((sum, attempt) => sum + attempt.costAmount, 0),
+                verdict: nodeAttempts.at(-1)?.verdict ?? null,
+                inboxId: gate?.id ?? null,
+                metadata: node,
+            };
+        });
+        const edges = Object.values(template?.nodes ?? {}).flatMap((node) => workflowEdges(node));
+        return {
+            run: {
+                ...mapRunForWorkflow(detail.run),
+            },
+            pipeline: {
+                id: route.pipelineRowId,
+                pipelineId: route.pipelineId,
+                playbookId: route.playbookId,
+                title: template?.title ?? route.pipelineId,
+                routeGates: route.routeGates,
+                activeNodeIds: activeIds,
+                status: cursorStatus(progress),
+            },
+            nodes,
+            edges,
+            currentNodeIds: activeIds,
+            gates: nodes
+                .filter((node) => node.kind === 'humanGate')
+                .map((node) => {
+                const inbox = inboxByNode.get(node.id);
+                return {
+                    nodeId: node.id,
+                    topic: workflowGateTopic(node),
+                    status: inbox ? 'pending' : node.status,
+                    inboxId: inbox?.id ?? null,
+                    answer: inbox?.answer ?? null,
+                };
+            }),
+            attempts: attempts.map((attempt) => mapAttemptForWorkflow(runId, attempt)),
+            pendingInbox: pendingInbox.map(mapInboxForWorkflow),
+            usage: summarizeAttempts(attempts),
+            activity: events.slice(-50).reverse().map((event) => ({
+                id: event.eventId,
+                type: event.type,
+                actor: event.actor,
+                createdAt: dateOrEpoch(event.createdAt),
+                summary: eventSummary(event),
+                payload: event.payload,
+            })),
+        };
+    }
     async getRunDigest(runId) {
         const detail = await this.runs.showRun(runId);
         if (!detail)
@@ -290,6 +639,90 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
             usage: summarizeAttempts(attempts),
         };
     }
+    async waitForRun(input) {
+        const timeoutMs = input.timeoutMs ?? 0;
+        const intervalMs = input.intervalMs ?? 1000;
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const state = await this.resolveRunState(input.runId);
+            if (state.state !== 'running' || Date.now() >= deadline)
+                return state;
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+    /**
+     * Resolve a single run to its actionable state. Public so `RunWatchService` (slice 141 D2) can
+     * fan it out across many runs; it is a point-in-time level read (gate = `inbox.find(approval)`),
+     * not an event cursor — the watch primitive layers at-least-once + idempotent delivery on top.
+     */
+    async resolveRunState(runId) {
+        const detail = await this.runs.showRun(runId);
+        if (!detail)
+            throw new ControlPlaneError('ROW_NOT_FOUND', `run not found: ${runId}`);
+        const [inbox, events, workflow] = await Promise.all([
+            this.inbox.listInbox({ runId, status: 'pending', limit: 20 }),
+            this.runs.listRunEvents(runId, { limit: 20 }),
+            this.dbos.getWorkflowStatus(runId),
+        ]);
+        const gate = inbox.find((item) => item.kind === 'approval');
+        if (gate) {
+            return {
+                runId,
+                state: 'pending_gate',
+                nextAction: 'resolve approval with approve_gate or reject_gate',
+                runStatus: detail.run.status,
+                workflowStatus: workflow?.status ?? '',
+                inbox: gate,
+            };
+        }
+        const question = inbox.find((item) => item.kind === 'question');
+        if (question) {
+            return {
+                runId,
+                state: 'question',
+                nextAction: 'answer question with answer_question',
+                runStatus: detail.run.status,
+                workflowStatus: workflow?.status ?? '',
+                inbox: question,
+            };
+        }
+        if (detail.run.status === 'completed') {
+            return { runId, state: 'completed', nextAction: 'none', runStatus: detail.run.status, workflowStatus: workflow?.status ?? '' };
+        }
+        if (detail.run.status === 'failed') {
+            return { runId, state: 'failed', nextAction: 'inspect get_run_events/get_run_log', runStatus: detail.run.status, workflowStatus: workflow?.status ?? '' };
+        }
+        if (detail.run.status === 'cancelled') {
+            return { runId, state: 'blocked', nextAction: 'run was cancelled; create or resume a different run', runStatus: detail.run.status, workflowStatus: workflow?.status ?? '' };
+        }
+        if (detail.run.status === 'paused') {
+            return { runId, state: 'blocked', nextAction: 'inspect blocking event and decide whether to create a follow-up run', runStatus: detail.run.status, workflowStatus: workflow?.status ?? '' };
+        }
+        const blocked = [...events].reverse().find((event) => event.type === 'pipeline_blocked');
+        if (blocked) {
+            return {
+                runId,
+                state: 'blocked',
+                nextAction: 'inspect blocking event and decide whether to create a follow-up run',
+                runStatus: detail.run.status,
+                workflowStatus: workflow?.status ?? '',
+                latestBlockingEvent: blocked,
+            };
+        }
+        if (workflow?.status === 'ERROR') {
+            return { runId, state: 'failed', nextAction: 'inspect get_run_events/get_run_log', runStatus: detail.run.status, workflowStatus: workflow.status };
+        }
+        if (workflow?.status === 'SUCCESS') {
+            return { runId, state: 'completed', nextAction: 'none', runStatus: detail.run.status, workflowStatus: workflow.status };
+        }
+        return {
+            runId,
+            state: 'running',
+            nextAction: 'wait_for_run again or inspect get_run_digest',
+            runStatus: detail.run.status,
+            workflowStatus: workflow?.status ?? '',
+        };
+    }
     listInbox(filter) {
         return this.inbox.listInbox(filter);
     }
@@ -403,37 +836,150 @@ let TaskControlPlaneApiService = class TaskControlPlaneApiService {
         return result;
     }
     simulateRoute(input) {
-        const pipeline = input.pipeline ?? 'feature-development';
-        return {
+        return this.resolveRouteDecision({
             title: input.title,
             repo: input.repo ?? '',
-            pipeline,
-            executionMode: 'agent-method-compatible',
-            runnerMode: input.live ? 'live' : 'script',
-            roles: ['architect', 'developer', 'reviewer', 'integrator'],
-            gates: ['plan', 'merge'],
-            reviewLoop: { maxIterationsSource: 'routing_policy.pipeline' },
-            notes: [
-                'MCP route simulation is advisory; workflow-as-data route proposal is a later slice.',
-                'Use create_run then start_run to execute the current DBOS developTask workflow.',
-            ],
+            playbookId: input.playbookId,
+            pipelineId: input.pipeline,
+            params: input.params,
+            source: input.pipeline ? 'explicit' : 'deterministic-installed-playbook',
+        });
+    }
+    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',
+        });
+    }
+    async resolveRouteDecision(input) {
+        const params = normalizeParams(input.params);
+        const executionProfile = normalizeExecutionProfile(input.executionProfile);
+        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);
+        return {
+            playbookId: playbook.id,
+            pipelineId: pipeline.pipelineId,
+            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,
+            roleBindings,
+            params,
         };
     }
+    async resolveAutoPipeline(playbookId, text) {
+        const pipelines = (await this.playbooks.listPipelines())
+            .filter((pipeline) => pipeline.playbookId === playbookId)
+            .sort((left, right) => left.id.localeCompare(right.id));
+        if (pipelines.length === 0) {
+            throw new ControlPlaneError('ROW_NOT_FOUND', `no installed pipelines found for playbook ${playbookId}`);
+        }
+        const scored = pipelines
+            .map((pipeline) => ({ pipeline, score: routeScore(pipeline, text) }))
+            .sort((left, right) => right.score - left.score || left.pipeline.id.localeCompare(right.pipeline.id));
+        const best = scored[0];
+        const second = scored[1];
+        if (!best || best.score <= 0) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', `unable to choose a pipeline confidently; provide pipelineId`);
+        }
+        if (second?.score === best.score) {
+            throw new ControlPlaneError('VALIDATION_FAILURE', `ambiguous pipeline route; provide pipelineId`);
+        }
+        return best.pipeline;
+    }
+    async resolveRouteRoles(playbookId, pipeline, executionProfile) {
+        const roles = (await this.roles.listRoles()).filter((role) => role.playbookId === playbookId);
+        const byPlaybookRole = new Map(roles.map((role) => [role.playbookRoleId || role.name, role]));
+        // The route selects WHICH roles a pipeline binds (capability handles the data-driven engine
+        // resolves). Order is no longer load-bearing — the data-driven template owns node sequencing — so
+        // alternative-group selections simply append (the old `insertBeforeFirstDeveloperRole` phase-order
+        // hardcode is removed with the rest of the hardcoded engine, plan 0015 slice 3).
+        const selected = [...pipeline.requiredRoles];
+        for (const group of pipeline.alternativeRoles) {
+            const match = group.roles.find((roleId) => byPlaybookRole.has(roleId));
+            if (!match) {
+                throw new ControlPlaneError('VALIDATION_FAILURE', `pipeline ${pipeline.pipelineId} alternative group ${group.group_id} has no installed role`);
+            }
+            if (!selected.includes(match))
+                selected.push(match);
+        }
+        for (const roleId of selected) {
+            if (!byPlaybookRole.has(roleId)) {
+                throw new ControlPlaneError('VALIDATION_FAILURE', `pipeline ${pipeline.pipelineId} references missing installed role: ${roleId}`);
+            }
+        }
+        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);
+            return {
+                roleId,
+                rowId: role.id,
+                modelLevel: role.modelLevel,
+                runnerId: role.runner,
+                resolvedRunnerId: resolved.runnerId,
+                runnerSource: resolved.source,
+            };
+        });
+    }
     getPrReadiness(input) {
         return this.prReadiness.getPrReadiness(input);
     }
     listPrFeedback(input) {
         return this.prReadiness.listPrFeedback(input);
     }
+    getAgentActivity(runId) {
+        return this.observability.getAgentActivity(runId);
+    }
+    getAgentAttempts(runId) {
+        return this.observability.listAgentAttempts(runId);
+    }
+    getAgentLog(input) {
+        return this.observability.getAgentLog(input);
+    }
+    readAgentOutputEvents(input) {
+        return this.observability.readAgentOutputEvents(input);
+    }
+    watchAgentActivity(input) {
+        return this.observability.watchAgentActivity(input);
+    }
+    watchAgentOutput(input) {
+        return this.observability.watchAgentOutput(input);
+    }
 };
 TaskControlPlaneApiService = __decorate([
     Injectable(),
+    __param(0, Inject(RunService)),
+    __param(1, Inject(InboxService)),
+    __param(2, Inject(RolesService)),
+    __param(3, Inject(PlaybooksService)),
+    __param(4, Inject(PipelineService)),
+    __param(5, Inject(DbosService)),
+    __param(6, Inject(AgentObservabilityService)),
     __metadata("design:paramtypes", [RunService,
         InboxService,
         RolesService,
         PlaybooksService,
         PipelineService,
         DbosService,
+        AgentObservabilityService,
         PrReadinessService])
 ], TaskControlPlaneApiService);
 export { TaskControlPlaneApiService };