@undefineds.co/linx 0.3.5 → 0.3.8

package/dist/lib/symphony-command.js

@@ -1,218 +1,503 @@
 import { spawnSync } from 'node:child_process';
 import { resolve } from 'node:path';
+import { runThreadReconcilerCycle, summarizeWakeJobExecutionRecord, } from '../../vendor/agent-runtime/dist/index.js';
+import { appendSymphonyReconcilerDecision, createRunPlan, renderSymphonyRuntimePrompt, } from '../../vendor/agent-runtime/dist/symphony.js';
 import { runAutoMode, listArchivedAutoModeSessions } from './auto-mode/index.js';
-import { createArchivedSymphonyRunPlan, formatSymphonyRecordSummary, getSymphonyHome, listSymphonyDeliveries, listSymphonyIssues, listSymphonySessions, resolveSymphonyRecord, updateSymphonyIssueStatus, updateSymphonyDeliveryStatus, updateSymphonySessionStatus, } from './symphony/archive.js';
-const SYMPHONY_BACKENDS = ['codex', 'claude', 'codebuddy'];
+import { formatSymphonyRecordSummary, getSymphonyHome, attachSymphonyRunPlanToIssue, createSymphonyRunPlanDraft, triageSymphonyIssue, withSymphonyIssueStatus, withSymphonyDeliveryStatus, withSymphonySessionStatus, withSymphonyTaskStatus, writeSymphonyRunPlan, } from './symphony/archive.js';
+import { listOpenSymphonyIssuesFromPod, mirrorSymphonyProjectionJsonLdFromPod, persistSymphonyProjectionToPod } from './symphony/pod-projection.js';
 const defaultRuntime = {
     runAutoMode,
     listAutoModeSessions: listArchivedAutoModeSessions,
+    persistSymphonyProjectionToPod,
+    listOpenSymphonyIssuesFromPod,
+    mirrorSymphonyProjectionJsonLdFromPod,
 };
-export function createSymphonyCommand(runtime = defaultRuntime) {
-    return {
-        command: 'symphony <command>',
-        describe: 'Inspect and tune AI Secretary Symphony delegation',
-        builder(command) {
-            return buildSymphonyCommandTree(command, runtime)
-                .demandCommand(1, 'Usage: linx symphony <run|issues|sessions|deliveries|show>');
+export async function runSymphony(argv, runtime = defaultRuntime) {
+    throwIfAborted(argv.signal);
+    const objective = normalizeObjective(argv.objective);
+    const cwd = resolve(argv.cwd || process.cwd());
+    const workspace = resolveWorkspaceMetadata(cwd, argv);
+    const backend = argv.backend ?? 'codex';
+    const mode = 'off';
+    const secretaryAutoEnabled = Boolean(argv.auto);
+    const workers = normalizeWorkers(argv.worker, backend, argv.target);
+    const agentRuntime = resolveSymphonyAgentRuntime(argv);
+    const requestedWorkerModel = normalizeOptional(argv.workerModel) ?? normalizeOptional(argv.model);
+    assertSymphonyWorkerModelCompatibility(backend, requestedWorkerModel, workers);
+    const planInput = {
+        objective,
+        title: normalizeOptional(argv.title),
+        acceptanceCriteria: normalizeAcceptanceCriteria(argv.acceptance),
+        workspacePath: cwd,
+        workspaceKind: workspace.kind,
+        repository: workspace.repository,
+        branch: workspace.branch,
+        worktree: workspace.worktree,
+        baseRevision: workspace.baseRevision,
+        environment: {
+            kind: 'local-shell',
+            label: 'linx-cli',
+            runtime: backend,
         },
-        handler() {
-            // Subcommands own execution.
+        backend,
+        mode,
+        secretaryAutoEnabled,
+        model: normalizeOptional(argv.model),
+        workerModel: normalizeOptional(argv.workerModel),
+        workerSupervisorIntervalMs: normalizePositiveInteger(argv.workerSupervisorIntervalMs),
+        chat: normalizeOptional(argv.chat),
+        thread: normalizeOptional(argv.thread),
+        messages: normalizeMessages(argv.messages),
+        issuer: {
+            source: 'user',
+            chat: normalizeOptional(argv.chat),
+            thread: normalizeOptional(argv.thread),
+            messages: normalizeMessages(argv.messages),
         },
+        target: argv.target,
+        workers,
     };
+    const plan = await createSymphonyRunPlanForRuntime(planInput, runtime, argv.signal);
+    throwIfAborted(argv.signal);
+    const quietProjectionErrors = argv.quietProjectionErrors === true;
+    let currentPlan = await persistSymphonyProjectionBestEffort(plan, 'planned', runtime, {
+        quiet: quietProjectionErrors,
+        signal: argv.signal,
+    });
+    if (argv.dryRun) {
+        throwIfAborted(argv.signal);
+        currentPlan = withUpdatedIssue({
+            ...currentPlan,
+            workers: currentPlan.workers.map((worker) => ({
+                ...worker,
+                session: withSymphonySessionStatus(worker.session, 'planned', { dryRun: true }),
+            })),
+        });
+        currentPlan = await persistSymphonyProjectionBestEffort(currentPlan, 'planned', runtime, {
+            quiet: quietProjectionErrors,
+            signal: argv.signal,
+        });
+        if (argv.print !== false) {
+            printSymphonyRunPlan(currentPlan, { dryRun: true });
+        }
+        return currentPlan;
+    }
+    let issue = withSymphonyIssueStatus(currentPlan.issue, 'in_progress');
+    currentPlan = { ...currentPlan, issue };
+    currentPlan = await persistSymphonyProjectionBestEffort(currentPlan, 'running', runtime, {
+        quiet: quietProjectionErrors,
+        signal: argv.signal,
+    });
+    issue = currentPlan.issue;
+    try {
+        const dispatchedWorkers = [];
+        let firstFailure = null;
+        for (const [index, worker] of currentPlan.workers.entries()) {
+            throwIfAborted(argv.signal);
+            const dispatched = await runSymphonyWorker({
+                worker,
+                issue: currentPlan.issue,
+                workerIndex: index + 1,
+                workerCount: currentPlan.workers.length,
+                secretaryAutoEnabled,
+                cwd,
+                plain: Boolean(argv.plain),
+                agentRuntime,
+                model: normalizeOptional(argv.workerModel) ?? normalizeOptional(argv.model),
+                credentialSource: normalizeCredentialSource(argv.credentialSource),
+                goalMode: argv.workerGoalMode !== false,
+                quiet: argv.quietWorkers === true,
+                passthroughArgs: (argv['--'] ?? []).map(String),
+                commandOverride: normalizeOptional(argv.commandOverride),
+                commandEnv: normalizeCommandEnv(argv.commandEnv),
+                runtime,
+                signal: argv.signal,
+                onWorkerDispatched: async (runningWorker) => {
+                    currentPlan = withUpdatedWorker(currentPlan, runningWorker);
+                    currentPlan = await persistSymphonyProjectionBestEffort(currentPlan, 'running', runtime, {
+                        quiet: quietProjectionErrors,
+                        signal: argv.signal,
+                    });
+                },
+            });
+            dispatchedWorkers.push(dispatched.worker);
+            currentPlan = withUpdatedWorker(currentPlan, dispatched.worker);
+            if (dispatched.exitCode !== 0 && !firstFailure) {
+                firstFailure = {
+                    exitCode: dispatched.exitCode,
+                    error: `Backend ${dispatched.worker.session.backend} exited with code ${dispatched.exitCode}`,
+                };
+            }
+        }
+        const status = firstFailure ? 'failed' : 'completed';
+        issue = withSymphonyIssueStatus(issue, firstFailure ? 'blocked' : 'resolved', firstFailure ? { error: firstFailure.error } : {});
+        currentPlan = withUpdatedIssue({
+            ...currentPlan,
+            issue,
+            workers: dispatchedWorkers,
+        });
+        currentPlan = await persistSymphonyProjectionBestEffort(currentPlan, status, runtime, {
+            quiet: quietProjectionErrors,
+            signal: argv.signal,
+        });
+        if (argv.print !== false) {
+            printSymphonyRunPlan(currentPlan, { dryRun: false });
+        }
+        if (firstFailure) {
+            process.exitCode = firstFailure.exitCode;
+        }
+        return currentPlan;
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        issue = withSymphonyIssueStatus(issue, 'blocked', { error: message });
+        const failedWorker = currentPlan.workers[0];
+        if (failedWorker) {
+            const worker = {
+                task: failedWorker.task,
+                taskRecord: withSymphonyTaskStatus(failedWorker.taskRecord, 'failed', { error: message }),
+                delivery: withSymphonyDeliveryStatus(failedWorker.delivery, 'failed', { error: message }),
+                session: withSymphonySessionStatus(failedWorker.session, 'failed', { error: message, exitCode: 1 }),
+            };
+            currentPlan = withUpdatedWorker({ ...currentPlan, issue }, worker);
+        }
+        else {
+            currentPlan = { ...currentPlan, issue };
+        }
+        await persistSymphonyProjectionBestEffort(currentPlan, 'failed', runtime, {
+            quiet: quietProjectionErrors,
+            signal: argv.signal,
+        });
+        throw error;
+    }
 }
-export const symphonyCommand = createSymphonyCommand();
-export function buildSymphonyCommandTree(command, runtime = defaultRuntime) {
-    return command
-        .command(createRunCommand(runtime))
-        .command(createListCommand('issues', 'List Symphony issues', () => listSymphonyIssues().map((record) => formatSymphonyRecordSummary('issue', record))))
-        .command(createListCommand('sessions', 'List Symphony sessions', () => listSymphonySessions().map((record) => formatSymphonyRecordSummary('session', record))))
-        .command(createListCommand('deliveries', 'List Symphony deliveries', () => listSymphonyDeliveries().map((record) => formatSymphonyRecordSummary('delivery', record))))
-        .command(createShowCommand());
+async function createSymphonyRunPlanForRuntime(input, runtime, signal) {
+    throwIfAborted(signal);
+    const listIssues = runtime.listOpenSymphonyIssuesFromPod;
+    if (!listIssues) {
+        return createSymphonyRunPlanDraft(input);
+    }
+    let podIssues;
+    try {
+        podIssues = await withAbortSignal(listIssues(), signal);
+        throwIfAborted(signal);
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        podIssues = null;
+    }
+    if (!podIssues) {
+        return createSymphonyRunPlanDraft(input);
+    }
+    const plan = createRunPlan(input);
+    const triage = triageSymphonyIssue({
+        objective: input.objective,
+        chat: input.chat,
+        thread: input.thread,
+        workspacePath: input.workspacePath,
+        issues: podIssues,
+    });
+    return triage.action === 'update' && triage.issue
+        ? attachSymphonyRunPlanToIssue(plan, triage.issue)
+        : plan;
 }
-function createRunCommand(runtime) {
-    return {
-        command: 'run [objective..]',
-        describe: 'Ask AI Secretary to delegate work through Symphony',
-        builder(command) {
-            return command
-                .positional('objective', {
-                array: true,
-                type: 'string',
-                describe: 'Task objective for Secretary to delegate',
-            })
-                .option('backend', {
-                type: 'string',
-                choices: SYMPHONY_BACKENDS,
-                default: 'codex',
-                describe: 'Worker backend receiving Secretary-projected work',
-            })
-                .option('auto', {
-                type: 'boolean',
-                default: false,
-                describe: 'Let AI Secretary handle in-policy worker confirmations',
-            })
-                .option('dry-run', {
-                type: 'boolean',
-                default: false,
-                describe: 'Archive the issue/delivery/session plan without launching a backend',
-            })
-                .option('cwd', {
-                type: 'string',
-                describe: 'Workspace path for the target runtime session',
-            })
-                .option('title', {
-                type: 'string',
-                describe: 'Human-readable task title',
-            })
-                .option('acceptance', {
-                alias: 'a',
-                array: true,
-                type: 'string',
-                describe: 'Acceptance criterion; repeat for multiple criteria',
-            })
-                .option('model', {
-                type: 'string',
-                describe: 'Model id forwarded to the backend',
-            })
-                .option('plain', {
-                type: 'boolean',
-                default: false,
-                describe: 'Disable full-screen backend UI and use plain output',
-            })
-                .option('repository', {
-                type: 'string',
-                describe: 'Repository URL metadata override',
-            })
-                .option('branch', {
-                type: 'string',
-                describe: 'Git branch metadata override',
-            })
-                .option('worktree', {
-                type: 'string',
-                describe: 'Git worktree metadata override',
-            })
-                .option('workspace-kind', {
-                type: 'string',
-                choices: ['git', 'folder'],
-                describe: 'Workspace kind metadata override',
+async function runSymphonyWorker(input) {
+    throwIfAborted(input.signal);
+    const beforeAutoModeIds = new Set(input.runtime.listAutoModeSessions().map((record) => record.id));
+    const cwd = input.worker.session.cwd || input.cwd;
+    const workspace = input.worker.session.workspace ?? {
+        path: cwd,
+        kind: 'folder',
+    };
+    const prompt = renderSymphonyRuntimePrompt({
+        issue: input.issue,
+        task: input.worker.task,
+        objective: input.worker.taskRecord.objective,
+        acceptanceCriteria: input.worker.taskRecord.acceptanceCriteria,
+        workspace,
+        backend: input.worker.session.backend,
+        mode: input.worker.session.mode,
+        secretaryAutoEnabled: input.worker.session.secretaryAutoEnabled ?? input.secretaryAutoEnabled,
+        session: input.worker.session.uri,
+        target: input.worker.session.target,
+        issuer: input.issue.issuer,
+        ...(input.workerCount > 1 ? {
+            workerIndex: input.workerIndex,
+            workerCount: input.workerCount,
+        } : {}),
+    });
+    let exitCode = null;
+    let wakeError;
+    let runningDelivery = input.worker.delivery;
+    let runningSession = input.worker.session;
+    let runningTask = input.worker.taskRecord;
+    const cycle = await runThreadReconcilerCycle({
+        policy: {
+            kind: 'symphony',
+            assignedWorkerAgent: input.worker.delivery.targetAgent,
+            secretaryAgent: '__secretary__',
+        },
+        handleWakeJob: async ({ decisionSummary, record }) => {
+            try {
+                throwIfAborted(input.signal);
+                exitCode = await input.runtime.runAutoMode({
+                    backend: input.worker.session.backend,
+                    autoEnabled: input.secretaryAutoEnabled,
+                    mode: 'off',
+                    cwd,
+                    plain: input.plain,
+                    model: normalizeOptional(input.worker.session.model) ?? input.model,
+                    credentialSource: input.credentialSource,
+                    prompt,
+                    goalMode: input.goalMode,
+                    quiet: input.quiet,
+                    passthroughArgs: input.passthroughArgs,
+                    ...(input.commandOverride ? { commandOverride: input.commandOverride } : {}),
+                    ...(input.commandEnv ? { commandEnv: input.commandEnv } : {}),
+                    metadata: {
+                        symphony: {
+                            issue: input.issue.uri,
+                            task: input.worker.task,
+                            delivery: input.worker.delivery.uri,
+                            session: input.worker.session.uri,
+                            ...(input.agentRuntime ? { agentRuntime: input.agentRuntime } : {}),
+                            ...(input.worker.session.model ? { workerModel: input.worker.session.model } : {}),
+                            ...(input.worker.session.supervisor ? { supervisor: input.worker.session.supervisor } : {}),
+                        },
+                        reconciler: decisionSummary,
+                        scheduler: {
+                            wakeRecord: summarizeWakeJobExecutionRecord(record),
+                        },
+                    },
+                    ...(input.signal ? { signal: input.signal } : {}),
+                });
+                throwIfAborted(input.signal);
+                return { exitCode };
+            }
+            catch (error) {
+                wakeError = error;
+                throw error;
+            }
+        },
+        event: createSymphonyWorkerDispatchEvent(input.worker),
+        dispatchOptions: {
+            randomId: `${input.worker.delivery.uri}-dispatch`,
+        },
+        onDispatched: (dispatch) => {
+            throwIfAborted(input.signal);
+            runningDelivery = appendSymphonyReconcilerDecision(withSymphonyDeliveryStatus(input.worker.delivery, 'dispatched'), dispatch.summary);
+            runningSession = appendSymphonyReconcilerDecision(withSymphonySessionStatus(input.worker.session, 'running'), dispatch.summary);
+            runningTask = appendSymphonyReconcilerDecision(withSymphonyTaskStatus(input.worker.taskRecord, 'running'), dispatch.summary);
+            return input.onWorkerDispatched?.({
+                task: input.worker.task,
+                taskRecord: runningTask,
+                delivery: runningDelivery,
+                session: runningSession,
             });
         },
-        async handler(argv) {
-            await runSymphony(argv, runtime);
+    });
+    const dispatchScheduler = cycle.schedulerSummary;
+    if (dispatchScheduler.failed.length > 0) {
+        throw wakeError ?? new Error(String(dispatchScheduler.failed[0]?.error ?? 'Symphony worker wake job failed'));
+    }
+    if (exitCode === null) {
+        throw new Error('Symphony worker was not awakened by the Thread Reconciler.');
+    }
+    throwIfAborted(input.signal);
+    const autoModeSessionId = resolveCreatedAutoModeSessionId(beforeAutoModeIds, input.runtime);
+    const status = exitCode === 0 ? 'completed' : 'failed';
+    const statusDecision = await dispatchSymphonyWorkerStatusDecision({
+        worker: {
+            task: input.worker.task,
+            taskRecord: runningTask,
+            delivery: runningDelivery,
+            session: runningSession,
+        },
+        status,
+        exitCode,
+        autoModeSessionId,
+    });
+    return {
+        status,
+        exitCode,
+        worker: {
+            task: input.worker.task,
+            taskRecord: appendSymphonyReconcilerDecision(withSymphonyTaskStatus(runningTask, status, {
+                ...(exitCode === 0 ? {} : { error: `Backend exited with code ${exitCode}` }),
+            }), statusDecision.decision),
+            delivery: appendSymphonyReconcilerDecision(withSymphonyDeliveryStatus(runningDelivery, status, {
+                autoModeSessionId,
+                ...(exitCode === 0 ? {} : { error: `Backend exited with code ${exitCode}` }),
+            }), statusDecision.decision),
+            session: appendSymphonyReconcilerDecision(withSymphonySessionStatus(runningSession, status, {
+                autoModeSessionId,
+                exitCode,
+                ...(exitCode === 0 ? {} : { error: `Backend exited with code ${exitCode}` }),
+            }), statusDecision.decision),
         },
     };
 }
-function createListCommand(commandName, describe, loadLines) {
+function createSymphonyWorkerDispatchEvent(worker) {
     return {
-        command: commandName,
-        describe,
-        builder(command) {
-            return command;
+        type: 'delivery.submitted',
+        ...(worker.delivery.chat ? { chat: worker.delivery.chat } : {}),
+        ...(worker.delivery.thread ? { thread: worker.delivery.thread } : {}),
+        resource: worker.delivery.uri,
+        actor: {
+            id: '__secretary__',
+            role: 'secretary',
+        },
+        data: {
+            deliveryType: worker.delivery.type,
+            issue: worker.delivery.issue,
+            task: worker.delivery.task,
+            delivery: worker.delivery.uri,
+            session: worker.session.uri,
+        },
+    };
+}
+async function dispatchSymphonyWorkerStatusDecision(input) {
+    let wakeError;
+    const cycle = await runThreadReconcilerCycle({
+        policy: {
+            kind: 'symphony',
+            secretaryAgent: '__secretary__',
         },
-        handler() {
-            const lines = loadLines();
-            if (lines.length === 0) {
-                process.stdout.write(`No Symphony ${commandName} found.\n`);
-                return;
+        handleWakeJob: ({ job }) => {
+            try {
+                return {
+                    targetAgent: job.targetAgent,
+                    targetRole: job.targetRole,
+                    status: input.status,
+                };
+            }
+            catch (error) {
+                wakeError = error;
+                throw error;
             }
-            process.stdout.write(`${lines.join('\n')}\n`);
         },
+        event: createSymphonyWorkerStatusEvent(input),
+        dispatchOptions: {
+            randomId: `${input.worker.delivery.uri}-${input.status}`,
+        },
+    });
+    const scheduler = cycle.schedulerSummary;
+    if (scheduler.failed.length > 0) {
+        throw wakeError ?? new Error(String(scheduler.failed[0]?.error ?? 'Symphony status wake job failed'));
+    }
+    return {
+        decision: cycle.summary,
+        scheduler,
     };
 }
-function createShowCommand() {
+function createSymphonyWorkerStatusEvent(input) {
     return {
-        command: 'show <id>',
-        describe: 'Show a Symphony issue, delivery, or session by URI/key prefix',
-        builder(command) {
-            return command.positional('id', {
-                type: 'string',
-                describe: 'Issue, delivery, or session URI/key prefix',
-            });
+        type: input.status === 'completed' ? 'delivery.completed' : 'delivery.failed',
+        ...(input.worker.delivery.chat ? { chat: input.worker.delivery.chat } : {}),
+        ...(input.worker.delivery.thread ? { thread: input.worker.delivery.thread } : {}),
+        resource: input.worker.delivery.uri,
+        actor: {
+            id: input.worker.delivery.targetAgent,
+            role: 'worker',
         },
-        handler(argv) {
-            const id = typeof argv.id === 'string' ? argv.id : '';
-            const resolved = resolveSymphonyRecord(id);
-            if (!resolved) {
-                throw new Error(`Symphony record not found: ${id}`);
-            }
-            process.stdout.write(`${formatSymphonyRecordSummary(resolved.kind, resolved.record)}\n`);
-            process.stdout.write(`${JSON.stringify(resolved.record, null, 2)}\n`);
+        data: {
+            issue: input.worker.delivery.issue,
+            task: input.worker.delivery.task,
+            delivery: input.worker.delivery.uri,
+            session: input.worker.session.uri,
+            autoModeSessionId: input.autoModeSessionId,
+            exitCode: input.exitCode,
         },
     };
 }
-export async function runSymphony(argv, runtime = defaultRuntime) {
-    const objective = normalizeObjective(argv.objective);
-    const cwd = resolve(argv.cwd || process.cwd());
-    const workspace = resolveWorkspaceMetadata(cwd, argv);
-    const backend = argv.backend ?? 'codex';
-    const mode = argv.auto ? 'auto' : 'manual';
-    const plan = createArchivedSymphonyRunPlan({
-        objective,
-        title: normalizeOptional(argv.title),
-        acceptanceCriteria: normalizeAcceptanceCriteria(argv.acceptance),
-        workspacePath: cwd,
-        workspaceKind: workspace.kind,
-        repository: workspace.repository,
-        branch: workspace.branch,
-        worktree: workspace.worktree,
-        backend,
-        mode,
-        model: normalizeOptional(argv.model),
-    });
-    if (argv.dryRun) {
-        updateSymphonySessionStatus(plan.session, 'planned', { dryRun: true });
-        printSymphonyRunPlan(plan, { dryRun: true });
+async function persistSymphonyProjectionBestEffort(plan, stage, runtime, options = {}) {
+    throwIfAborted(options.signal);
+    const persist = runtime.persistSymphonyProjectionToPod;
+    if (!persist) {
+        writeSymphonyRunPlan(plan);
         return plan;
     }
-    let issue = updateSymphonyIssueStatus(plan.issue, 'in_progress');
-    let delivery = updateSymphonyDeliveryStatus(plan.delivery, 'dispatched');
-    let session = updateSymphonySessionStatus(plan.session, 'running');
-    const beforeAutoModeIds = new Set(runtime.listAutoModeSessions().map((record) => record.id));
     try {
-        const exitCode = await runtime.runAutoMode({
-            backend,
-            mode,
-            autoModeEnabled: argv.auto,
-            cwd,
-            plain: Boolean(argv.plain),
-            model: normalizeOptional(argv.model),
-            prompt: plan.delivery.projection.prompt,
-            goalMode: true,
-            passthroughArgs: (argv['--'] ?? []).map(String),
-        });
-        const autoModeSessionId = resolveCreatedAutoModeSessionId(beforeAutoModeIds, runtime);
-        const status = exitCode === 0 ? 'completed' : 'failed';
-        issue = updateSymphonyIssueStatus(issue, exitCode === 0 ? 'resolved' : 'blocked', exitCode === 0 ? {} : { error: `Backend exited with code ${exitCode}` });
-        delivery = updateSymphonyDeliveryStatus(delivery, status, {
-            autoModeSessionId,
-            ...(exitCode === 0 ? {} : { error: `Backend exited with code ${exitCode}` }),
-        });
-        session = updateSymphonySessionStatus(session, status, {
-            autoModeSessionId,
-            exitCode,
-            ...(exitCode === 0 ? {} : { error: `Backend exited with code ${exitCode}` }),
-        });
-        printSymphonyRunPlan({ issue, task: plan.task, delivery, session }, { dryRun: false });
-        if (exitCode !== 0) {
-            process.exitCode = exitCode;
+        const result = await withAbortSignal(persist(plan, { stage }), options.signal);
+        throwIfAborted(options.signal);
+        if (!result) {
+            writeSymphonyRunPlan(plan);
+            return plan;
         }
-        return { issue, task: plan.task, delivery, session };
+        await mirrorSymphonyProjectionBestEffort(result, runtime, options);
+        return result.plan;
     }
     catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
         const message = error instanceof Error ? error.message : String(error);
-        updateSymphonyIssueStatus(issue, 'blocked', { error: message });
-        updateSymphonyDeliveryStatus(delivery, 'failed', { error: message });
-        updateSymphonySessionStatus(session, 'failed', { error: message, exitCode: 1 });
-        throw error;
+        if (!options.quiet) {
+            process.stderr.write(`[symphony] Pod projection skipped: ${message}\n`);
+        }
+        writeSymphonyRunPlan(plan);
+        return plan;
+    }
+}
+async function mirrorSymphonyProjectionBestEffort(result, runtime, options = {}) {
+    throwIfAborted(options.signal);
+    if (!result) {
+        return;
+    }
+    const mirror = runtime.mirrorSymphonyProjectionJsonLdFromPod;
+    if (!mirror) {
+        return;
+    }
+    try {
+        await withAbortSignal(mirror(result), options.signal);
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        if (!options.quiet) {
+            process.stderr.write(`[symphony] Pod JSON-LD mirror skipped: ${message}\n`);
+        }
     }
 }
+function withUpdatedIssue(plan) {
+    const primary = plan.workers[0];
+    if (!primary) {
+        return plan;
+    }
+    return {
+        ...plan,
+        task: primary.task,
+        delivery: primary.delivery,
+        session: primary.session,
+    };
+}
+function withUpdatedWorker(plan, worker) {
+    const workers = plan.workers.map((candidate) => (candidate.session.uri === worker.session.uri ? worker : candidate));
+    return withUpdatedIssue({
+        ...plan,
+        workers,
+    });
+}
 function printSymphonyRunPlan(plan, options) {
-    process.stdout.write(options.dryRun ? 'LinX Symphony dry-run\n' : 'LinX Symphony run\n');
-    process.stdout.write(`issue: ${formatSymphonyRecordSummary('issue', plan.issue)}\n`);
-    process.stdout.write(`task: ${plan.task}\n`);
-    process.stdout.write(`delivery: ${formatSymphonyRecordSummary('delivery', plan.delivery)}\n`);
-    process.stdout.write(`session: ${formatSymphonyRecordSummary('session', plan.session)}\n`);
-    process.stdout.write(`archive: ${getSymphonyHome()}\n`);
+    process.stdout.write(options.dryRun ? 'LinX Secretary Symphony dry-run\n' : 'LinX Secretary Symphony dispatch\n');
+    process.stdout.write(`work: ${formatSymphonyRecordSummary('issue', plan.issue)}\n`);
+    for (const [index, worker] of plan.workers.entries()) {
+        const prefix = plan.workers.length > 1 ? `worker ${index + 1}/${plan.workers.length}` : 'worker';
+        if (worker.taskRecord) {
+            process.stdout.write(`${prefix}: ${formatSymphonyRecordSummary('task', worker.taskRecord)}\n`);
+        }
+        process.stdout.write(`task: ${worker.task}\n`);
+        process.stdout.write(`dispatch: ${formatSymphonyRecordSummary('delivery', worker.delivery)}\n`);
+        process.stdout.write(`session: ${formatSymphonyRecordSummary('session', worker.session)}\n`);
+    }
+    process.stdout.write(`local mirror/cache: ${getSymphonyHome()}\n`);
     if (options.dryRun) {
         process.stdout.write('\nProjected runtime prompt:\n');
         process.stdout.write(`${plan.delivery.projection.prompt}\n`);
@@ -224,6 +509,52 @@ function resolveCreatedAutoModeSessionId(beforeIds, runtime) {
         .sort((left, right) => right.startedAt.localeCompare(left.startedAt));
     return created[0]?.id;
 }
+function assertSymphonyWorkerModelCompatibility(fallbackBackend, workerModel, workers) {
+    if (!workerModel || !isNonCodexProviderModel(workerModel)) {
+        return;
+    }
+    const targets = workers && workers.length > 0 ? workers : [{ backend: fallbackBackend }];
+    const codexTarget = targets.find((target) => (target.backend ?? fallbackBackend) === 'codex');
+    if (codexTarget) {
+        throw new Error(`codex backend cannot run worker model ${workerModel}. Use backend claude/cc or linx for provider-routed models.`);
+    }
+    const claudeTarget = targets.find((target) => (target.backend ?? fallbackBackend) === 'claude');
+    if (claudeTarget && isProviderRoutedClaudeModel(workerModel)) {
+        throw new Error(`claude backend cannot set provider-routed worker model ${workerModel}. Configure it behind a Claude Code alias such as opus, or omit the worker model.`);
+    }
+}
+function isNonCodexProviderModel(model) {
+    return /(?:deepseek|claude|qwen|gemini|kimi|moonshot|mistral|grok|glm|minimax)/iu.test(model);
+}
+function isProviderRoutedClaudeModel(model) {
+    return /(?:deepseek|qwen|gemini|kimi|moonshot|mistral|grok|glm|minimax)/iu.test(model);
+}
+function normalizeWorkers(values, fallbackBackend, explicitTarget) {
+    if (!values || values.length === 0) {
+        return explicitTarget ? [explicitTarget] : undefined;
+    }
+    return values.map((value) => {
+        const [backendPart, agentPart] = value.split(':', 2);
+        const backend = normalizeBackend(backendPart) ?? fallbackBackend;
+        const agent = normalizeOptional(agentPart) ?? `${backend}-worker`;
+        return {
+            source: 'explicit-backend',
+            backend,
+            agent,
+            label: agent,
+        };
+    });
+}
+function normalizeBackend(value) {
+    const normalized = normalizeOptional(value);
+    if (normalized === 'cc') {
+        return 'claude';
+    }
+    if (normalized === 'linx' || normalized === 'codex' || normalized === 'claude' || normalized === 'codebuddy') {
+        return normalized;
+    }
+    return undefined;
+}
 function normalizeObjective(parts) {
     const objective = (parts ?? [])
         .filter((item) => typeof item === 'string')
@@ -231,7 +562,7 @@ function normalizeObjective(parts) {
         .replace(/\s+/g, ' ')
         .trim();
     if (!objective) {
-        throw new Error('Usage: linx symphony run <objective> [--backend codex] [--dry-run]');
+        throw new Error('Symphony objective is required');
     }
     return objective;
 }
@@ -242,10 +573,102 @@ function normalizeAcceptanceCriteria(value) {
         .map((item) => item.trim())
         .filter(Boolean);
 }
+function normalizeMessages(value) {
+    const messages = (value ?? [])
+        .map((item) => normalizeOptional(item))
+        .filter((item) => Boolean(item));
+    return messages.length > 0 ? messages : undefined;
+}
+function resolveSymphonyAgentRuntime(argv) {
+    const explicit = normalizeAgentRuntimeConfig(argv.agentRuntime);
+    const model = explicit?.model
+        ?? normalizeOptional(argv.secretaryModel)
+        ?? normalizeOptional(argv.model);
+    if (!explicit && !model) {
+        return undefined;
+    }
+    return {
+        backend: explicit?.backend ?? 'linx',
+        credentialSource: explicit?.credentialSource ?? 'cloud',
+        ...explicit,
+        ...(model ? { model } : {}),
+    };
+}
+function normalizeAgentRuntimeConfig(value) {
+    if (!value) {
+        return undefined;
+    }
+    const metadata = isRecord(value.metadata) ? { ...value.metadata } : undefined;
+    const resolved = {
+        ...(normalizeOptional(value.backend) ? { backend: normalizeOptional(value.backend) } : {}),
+        ...(normalizeOptional(value.model) ? { model: normalizeOptional(value.model) } : {}),
+        ...(normalizeOptional(value.credentialSource) ? { credentialSource: normalizeOptional(value.credentialSource) } : {}),
+        ...(normalizeOptional(value.runtime) ? { runtime: normalizeOptional(value.runtime) } : {}),
+        ...(normalizeOptional(value.transport) ? { transport: normalizeOptional(value.transport) } : {}),
+        ...(normalizeOptional(value.endpoint) ? { endpoint: normalizeOptional(value.endpoint) } : {}),
+        ...(metadata ? { metadata } : {}),
+    };
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
 function normalizeOptional(value) {
     const normalized = typeof value === 'string' ? value.trim() : '';
     return normalized || undefined;
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function normalizeCommandEnv(value) {
+    if (!value) {
+        return undefined;
+    }
+    const entries = Object.entries(value)
+        .map(([key, entryValue]) => [key.trim(), String(entryValue)])
+        .filter(([key]) => Boolean(key));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizeCredentialSource(value) {
+    return value === 'local' ? 'local' : value === 'cloud' ? 'cloud' : undefined;
+}
+function normalizePositiveInteger(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    const normalized = Math.trunc(value);
+    return normalized > 0 ? normalized : undefined;
+}
+function createAbortError(message = 'The operation was aborted.') {
+    const error = new Error(message);
+    error.name = 'AbortError';
+    return error;
+}
+function isAbortError(error) {
+    return error instanceof Error && (error.name === 'AbortError' || error.message.toLowerCase().includes('aborted'));
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        throw reason;
+    }
+    throw createAbortError(typeof reason === 'string' && reason.trim() ? reason : undefined);
+}
+function withAbortSignal(promise, signal) {
+    if (!signal) {
+        return promise;
+    }
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason instanceof Error
+            ? signal.reason
+            : createAbortError(typeof signal.reason === 'string' && signal.reason.trim() ? signal.reason : undefined));
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
 function resolveWorkspaceMetadata(cwd, argv) {
     const git = isGitWorkspace(cwd);
     return {
@@ -253,6 +676,7 @@ function resolveWorkspaceMetadata(cwd, argv) {
         repository: normalizeOptional(argv.repository) ?? (git ? gitOutput(cwd, ['remote', 'get-url', 'origin']) : undefined),
         branch: normalizeOptional(argv.branch) ?? (git ? gitOutput(cwd, ['branch', '--show-current']) : undefined),
         worktree: normalizeOptional(argv.worktree) ?? (git ? gitOutput(cwd, ['rev-parse', '--show-toplevel']) : undefined),
+        baseRevision: git ? gitOutput(cwd, ['rev-parse', 'HEAD']) : undefined,
     };
 }
 function isGitWorkspace(cwd) {