@undefineds.co/linx 0.3.20 → 0.3.23

package/vendor/agent-runtime/dist/symphony.js

@@ -1,4 +1,4 @@
-import { summarizeReconcileDecision } from './reconciler.js';
+import { summarizeReconcileDecision, } from './reconciler.js';
 import { decideThreadControlEvent } from './thread-reconciler-controller.js';
 export const SYMPHONY_HOME_DIRNAME = 'symphony';
 export const SYMPHONY_IDEAS_DIRNAME = 'ideas';
@@ -6,11 +6,13 @@ export const SYMPHONY_ISSUES_DIRNAME = 'issues';
 export const SYMPHONY_TASKS_DIRNAME = 'tasks';
 export const SYMPHONY_DELIVERIES_DIRNAME = 'deliveries';
 export const SYMPHONY_SESSIONS_DIRNAME = 'sessions';
+export const SYMPHONY_RUN_STEPS_DIRNAME = 'run-steps';
 export const SYMPHONY_IDEA_FILE_NAME = 'idea.json';
 export const SYMPHONY_ISSUE_FILE_NAME = 'issue.json';
 export const SYMPHONY_TASK_FILE_NAME = 'task.json';
 export const SYMPHONY_DELIVERY_FILE_NAME = 'delivery.json';
 export const SYMPHONY_SESSION_FILE_NAME = 'session.json';
+export const SYMPHONY_RUN_STEP_FILE_NAME = 'run-step.json';
 const SYMPHONY_URI_PREFIX = 'urn:undefineds:linx';
 export function createSymphonyIdeaUri(options = {}) {
     return createSymphonyResourceUri('idea', options);
@@ -27,6 +29,9 @@ export function createSymphonyDeliveryUri(options = {}) {
 export function createSymphonySessionUri(options = {}) {
     return createSymphonyResourceUri('session', options);
 }
+export function createSymphonyRunStepUri(options = {}) {
+    return createSymphonyResourceUri('runStep', options);
+}
 export function getSymphonyArchiveRelativePaths(uri, kind) {
     const key = getSymphonyArchiveKey(uri);
     const dirNameByKind = {
@@ -35,6 +40,7 @@ export function getSymphonyArchiveRelativePaths(uri, kind) {
         task: SYMPHONY_TASKS_DIRNAME,
         delivery: SYMPHONY_DELIVERIES_DIRNAME,
         session: SYMPHONY_SESSIONS_DIRNAME,
+        runStep: SYMPHONY_RUN_STEPS_DIRNAME,
     };
     const fileNameByKind = {
         idea: SYMPHONY_IDEA_FILE_NAME,
@@ -42,6 +48,7 @@ export function getSymphonyArchiveRelativePaths(uri, kind) {
         task: SYMPHONY_TASK_FILE_NAME,
         delivery: SYMPHONY_DELIVERY_FILE_NAME,
         session: SYMPHONY_SESSION_FILE_NAME,
+        runStep: SYMPHONY_RUN_STEP_FILE_NAME,
     };
     const dirName = dirNameByKind[kind];
     const fileName = fileNameByKind[kind];
@@ -57,6 +64,7 @@ export function createRunPlan(input) {
     const uriOptions = { now, randomId };
     const objective = normalizeRequiredText(input.objective, 'objective');
     const title = normalizeOptionalText(input.title) ?? createSymphonyTitle(objective);
+    const source = input.source ?? 'cli';
     const acceptanceCriteria = normalizeSymphonyAcceptanceCriteria(input.acceptanceCriteria);
     const issuer = normalizeSymphonyIssuer(input);
     const workerSpecs = normalizeSymphonyWorkerSpecs(input);
@@ -72,7 +80,7 @@ export function createRunPlan(input) {
         ...(normalizeOptionalText(input.repository) ? { repository: normalizeOptionalText(input.repository) } : {}),
         ...(normalizeOptionalText(input.branch) ? { branch: normalizeOptionalText(input.branch) } : {}),
         ...(normalizeOptionalText(input.worktree) ? { worktree: normalizeOptionalText(input.worktree) } : {}),
-        ...(normalizeOptionalText(input.workspace) ? { workspace: normalizeOptionalText(input.workspace) } : {}),
+        ...(normalizeOptionalText(input.container) ? { container: normalizeOptionalText(input.container) } : {}),
         ...(normalizeOptionalText(input.baseRevision) ? { baseRevision: normalizeOptionalText(input.baseRevision) } : {}),
         environment: normalizeSymphonyWorkerEnvironment(input.environment, input.backend),
     };
@@ -84,7 +92,7 @@ export function createRunPlan(input) {
         description: objective,
         status: 'open',
         priority: 'medium',
-        source: 'cli',
+        source,
         issuer,
         tasks: workerUris.map((item) => item.task),
         deliveries: workerUris.map((item) => item.delivery),
@@ -107,7 +115,7 @@ export function createRunPlan(input) {
             thread: target.thread ?? chatThread.thread,
             messages: target.messages ?? chatThread.messages,
         });
-        const targetAgent = target.agent ?? target.contact ?? target.backend;
+        const targetAgent = target.agent ?? `${target.backend}-worker`;
         const dispatchReconciler = createSymphonyDispatchReconcilerState({
             issue: issueUri,
             task: uris.task,
@@ -146,7 +154,7 @@ export function createRunPlan(input) {
             ...(input.secretaryAutoEnabled !== undefined ? { secretaryAutoEnabled: input.secretaryAutoEnabled } : {}),
             status: 'planned',
             cwd: workerWorkspace.path,
-            workspaceRef: workerWorkspace,
+            workspace: workerWorkspace,
             target,
             ...(spec.model ? { model: spec.model } : {}),
             ...(spec.supervisor ? { supervisor: spec.supervisor } : {}),
@@ -208,6 +216,592 @@ export function appendSymphonyReconcilerDecision(record, decision) {
         },
     };
 }
+export function reconcileSymphonyThreadEvents(input) {
+    const policy = input.policy ?? { kind: 'symphony', secretaryAgent: '__secretary__' };
+    const events = (input.events ?? []).map((event, index) => normalizeSymphonyThreadReconcileEvent(event, input, index));
+    const now = input.now instanceof Date
+        ? input.now
+        : normalizeOptionalText(input.now)
+            ? new Date(normalizeOptionalText(input.now))
+            : undefined;
+    const decisions = events.map((event, index) => decideThreadControlEvent({
+        policy,
+        event,
+        ...(input.chat ? { chat: input.chat } : {}),
+        ...(input.thread ? { thread: input.thread } : {}),
+        ...(now && Number.isFinite(now.getTime()) ? { now } : {}),
+        randomId: `${input.randomId ?? event.id ?? 'symphony-thread'}-${index + 1}`,
+        ...(input.client ? { client: input.client } : {}),
+    }).summary);
+    const wakeJobs = decisions.flatMap((decision) => decision.wakeJobs);
+    const notificationEvents = decisions.flatMap((decision) => decision.notificationEvents ?? []);
+    const latestDecision = decisions.length > 0 ? decisions[decisions.length - 1] : undefined;
+    const latestEvent = events.length > 0 ? events[events.length - 1] : undefined;
+    const thread = latestDecision?.thread
+        ?? normalizeOptionalText(input.thread)
+        ?? latestEvent?.thread
+        ?? 'urn:undefineds:linx:thread:system-control';
+    const chat = latestDecision?.chat
+        ?? normalizeOptionalText(input.chat)
+        ?? latestEvent?.chat;
+    const nextAction = resolveSymphonyThreadReconcilerNextAction(wakeJobs, notificationEvents);
+    return {
+        policyKind: typeof policy === 'string' ? policy : policy.kind,
+        ...(chat ? { chat } : {}),
+        thread,
+        eventCount: events.length,
+        decisions,
+        wakeJobs,
+        notificationEvents,
+        nextAction,
+        summary: summarizeSymphonyThreadReconcilerResult(events.length, nextAction, wakeJobs.length, notificationEvents.length),
+    };
+}
+export function withSymphonyIssueStatus(record, status, updates = {}) {
+    const timestamp = normalizeSymphonyStatusTimestamp(updates.now);
+    return {
+        ...record,
+        status,
+        updatedAt: timestamp,
+        ...(updates.error ? { error: updates.error } : {}),
+        ...((updates.closedAt || status === 'resolved' || status === 'closed') ? { closedAt: updates.closedAt ?? timestamp } : {}),
+    };
+}
+export function withSymphonyTaskStatus(record, status, updates = {}) {
+    const timestamp = normalizeSymphonyStatusTimestamp(updates.now);
+    return {
+        ...record,
+        status,
+        updatedAt: timestamp,
+        ...(updates.error ? { error: updates.error } : {}),
+        ...((updates.completedAt || status === 'completed' || status === 'failed') ? { completedAt: updates.completedAt ?? timestamp } : {}),
+    };
+}
+export function withSymphonyDeliveryStatus(record, status, updates = {}) {
+    const timestamp = normalizeSymphonyStatusTimestamp(updates.now);
+    return {
+        ...record,
+        status,
+        updatedAt: timestamp,
+        ...(updates.autoModeSessionId ? { autoModeSessionId: updates.autoModeSessionId } : {}),
+        ...(updates.error ? { error: updates.error } : {}),
+        ...((updates.completedAt || status === 'completed' || status === 'failed') ? { completedAt: updates.completedAt ?? timestamp } : {}),
+    };
+}
+export function withSymphonySessionStatus(record, status, updates = {}) {
+    const timestamp = normalizeSymphonyStatusTimestamp(updates.now);
+    return {
+        ...record,
+        status,
+        updatedAt: timestamp,
+        ...(updates.autoModeSessionId ? { autoModeSessionId: updates.autoModeSessionId } : {}),
+        ...(updates.exitCode !== undefined ? { exitCode: updates.exitCode } : {}),
+        ...(updates.dryRun !== undefined ? { dryRun: updates.dryRun } : {}),
+        ...(updates.error ? { error: updates.error } : {}),
+        ...((updates.completedAt || status === 'completed' || status === 'failed') ? { completedAt: updates.completedAt ?? timestamp } : {}),
+    };
+}
+export function withSymphonyRunPlanPrimaryWorker(plan) {
+    const primary = plan.workers[0];
+    if (!primary) {
+        return plan;
+    }
+    return {
+        ...plan,
+        task: primary.task,
+        taskRecord: primary.taskRecord,
+        delivery: primary.delivery,
+        session: primary.session,
+    };
+}
+export function withSymphonyRunPlanWorker(plan, worker) {
+    return withSymphonyRunPlanPrimaryWorker({
+        ...plan,
+        workers: plan.workers.map((candidate) => (candidate.session.uri === worker.session.uri ? worker : candidate)),
+    });
+}
+export function createSymphonyRunStepRecord(input) {
+    const now = input.now ?? new Date();
+    const payload = sanitizeSymphonyRunStepPayload(input.payload);
+    return {
+        uri: createSymphonyRunStepUri({
+            now,
+            randomId: input.randomId ?? `${getSymphonyArchiveKey(input.worker.session.uri)}-${input.stepType}`,
+        }),
+        issue: input.worker.session.issue,
+        task: input.worker.task,
+        delivery: input.worker.delivery.uri,
+        session: input.worker.session.uri,
+        stepType: input.stepType,
+        message: normalizeOptionalText(input.message) ?? defaultSymphonyRunStepMessage(input.stepType, input.worker),
+        ...(payload ? { payload } : {}),
+        createdAt: now.toISOString(),
+    };
+}
+export function withSymphonyWorkerRunStep(worker, step) {
+    const existing = worker.runSteps ?? [];
+    if (existing.some((candidate) => candidate.uri === step.uri)) {
+        return worker;
+    }
+    return {
+        ...worker,
+        runSteps: [...existing, step],
+    };
+}
+export function withSymphonyWorkerRuntimeStep(worker, input) {
+    return withSymphonyWorkerRunStep(worker, createSymphonyRunStepRecord({
+        worker,
+        ...input,
+    }));
+}
+export function startSymphonyWorkerRun(input) {
+    const taskRecord = applySymphonyDecision(withSymphonyTaskStatus(input.worker.taskRecord, 'running', { now: input.now }), input.decision);
+    const delivery = applySymphonyDecision(withSymphonyDeliveryStatus(input.worker.delivery, 'dispatched', { now: input.now }), input.decision);
+    const session = applySymphonyDecision(withSymphonySessionStatus(input.worker.session, 'running', { now: input.now }), input.decision);
+    return withSymphonyWorkerRuntimeStep({
+        task: input.worker.task,
+        taskRecord,
+        delivery,
+        session,
+        ...(input.worker.runSteps?.length ? { runSteps: input.worker.runSteps } : {}),
+    }, {
+        stepType: 'run.started',
+        message: input.message ?? `${input.worker.session.backend} worker run started.`,
+        payload: {
+            issue: input.worker.session.issue,
+            task: input.worker.task,
+            delivery: input.worker.delivery.uri,
+            session: input.worker.session.uri,
+            backend: input.worker.session.backend,
+            targetAgent: input.worker.delivery.targetAgent,
+            ...(input.payload ?? {}),
+        },
+        now: input.now,
+        randomId: input.randomId ?? `${input.worker.delivery.uri}-run-started`,
+    });
+}
+export function recordSymphonyWorkerRuntimeEvent(input) {
+    const session = input.stepType === 'run.step'
+        ? withSymphonySessionStatus(input.worker.session, 'running', { now: input.now })
+        : input.worker.session;
+    return withSymphonyWorkerRuntimeStep({
+        ...input.worker,
+        session,
+    }, {
+        stepType: input.stepType,
+        message: input.message,
+        payload: {
+            issue: input.worker.session.issue,
+            task: input.worker.task,
+            delivery: input.worker.delivery.uri,
+            session: input.worker.session.uri,
+            backend: input.worker.session.backend,
+            ...(input.payload ?? {}),
+        },
+        now: input.now,
+        randomId: input.randomId,
+    });
+}
+export function completeSymphonyWorkerRun(input) {
+    const error = input.status === 'failed'
+        ? `Backend exited with code ${input.exitCode}`
+        : undefined;
+    const taskRecord = applySymphonyDecision(withSymphonyTaskStatus(input.worker.taskRecord, input.status, {
+        now: input.now,
+        ...(error ? { error } : {}),
+    }), input.decision);
+    const delivery = applySymphonyDecision(withSymphonyDeliveryStatus(input.worker.delivery, input.status, {
+        now: input.now,
+        ...(input.autoModeSessionId ? { autoModeSessionId: input.autoModeSessionId } : {}),
+        ...(error ? { error } : {}),
+    }), input.decision);
+    const session = applySymphonyDecision(withSymphonySessionStatus(input.worker.session, input.status, {
+        now: input.now,
+        ...(input.autoModeSessionId ? { autoModeSessionId: input.autoModeSessionId } : {}),
+        exitCode: input.exitCode,
+        ...(error ? { error } : {}),
+    }), input.decision);
+    return reconcileSymphonyWorkerDelivery({
+        issue: input.issue,
+        worker: {
+            task: input.worker.task,
+            taskRecord,
+            delivery,
+            session,
+            ...(input.worker.runSteps?.length ? { runSteps: input.worker.runSteps } : {}),
+        },
+        status: input.status,
+        exitCode: input.exitCode,
+        autoModeSessionId: input.autoModeSessionId,
+        reportText: input.reportText,
+        now: input.now,
+        randomId: input.randomId,
+    });
+}
+export function finalizeSymphonyRunPlanAfterWorkers(input) {
+    const workers = input.workers ?? input.plan.workers;
+    const followUpIssues = input.followUpIssues ?? input.plan.followUpIssues;
+    const basePlan = withSymphonyRunPlanPrimaryWorker({
+        ...input.plan,
+        workers,
+        ...(followUpIssues?.length ? { followUpIssues } : {}),
+    });
+    const failure = workers.find((worker) => {
+        const exitCode = worker.session.exitCode;
+        return worker.taskRecord.status === 'failed'
+            || worker.delivery.status === 'failed'
+            || worker.session.status === 'failed'
+            || (typeof exitCode === 'number' && exitCode !== 0);
+    });
+    if (failure) {
+        const exitCode = typeof failure.session.exitCode === 'number' ? failure.session.exitCode : undefined;
+        const error = failure.session.error
+            ?? failure.delivery.error
+            ?? failure.taskRecord.error
+            ?? (exitCode !== undefined ? `Backend ${failure.session.backend} exited with code ${exitCode}` : `Worker ${failure.taskRecord.title} failed.`);
+        return {
+            status: 'failed',
+            issueStatus: 'blocked',
+            blocker: {
+                kind: 'worker_failure',
+                error,
+                ...(exitCode !== undefined ? { exitCode } : {}),
+                worker: failure,
+            },
+            plan: withSymphonyRunPlanPrimaryWorker({
+                ...basePlan,
+                issue: withSymphonyIssueStatus(basePlan.issue, 'blocked', { error, now: input.now }),
+            }),
+        };
+    }
+    const acceptanceBlockedWorker = workers.find((worker) => {
+        const review = worker.taskRecord.acceptanceReview
+            ?? worker.delivery.acceptanceReview
+            ?? worker.session.acceptanceReview;
+        return Boolean(review && !review.accepted);
+    });
+    if (acceptanceBlockedWorker) {
+        const review = acceptanceBlockedWorker.taskRecord.acceptanceReview
+            ?? acceptanceBlockedWorker.delivery.acceptanceReview
+            ?? acceptanceBlockedWorker.session.acceptanceReview;
+        const error = review ? summarizeSymphonyAcceptanceBlocker(review) : `Worker ${acceptanceBlockedWorker.taskRecord.title} was not accepted.`;
+        return {
+            status: 'completed',
+            issueStatus: 'blocked',
+            blocker: {
+                kind: 'acceptance',
+                error,
+                worker: acceptanceBlockedWorker,
+            },
+            plan: withSymphonyRunPlanPrimaryWorker({
+                ...basePlan,
+                issue: withSymphonyIssueStatus(basePlan.issue, 'blocked', { error, now: input.now }),
+            }),
+        };
+    }
+    return {
+        status: 'completed',
+        issueStatus: 'resolved',
+        plan: withSymphonyRunPlanPrimaryWorker({
+            ...basePlan,
+            issue: withSymphonyIssueStatus(basePlan.issue, 'resolved', { now: input.now }),
+        }),
+    };
+}
+export function summarizeSymphonyAcceptanceBlocker(review) {
+    const blocking = review.followUps.find((followUp) => followUp.disposition === 'same_issue_task' || followUp.disposition === 'ask_user');
+    return blocking
+        ? `${review.summary}: ${blocking.summary}`
+        : review.summary;
+}
+function applySymphonyDecision(record, decision) {
+    return decision ? appendSymphonyReconcilerDecision(record, decision) : record;
+}
+export function reconcileSymphonyWorkerDelivery(input) {
+    const review = createSymphonyAcceptanceReview({
+        issue: input.issue,
+        worker: input.worker,
+        status: input.status,
+        exitCode: input.exitCode,
+        reportText: input.reportText,
+        now: input.now,
+    });
+    const followUpIssues = createFollowUpIssuesFromAcceptanceReview({
+        issue: input.issue,
+        worker: input.worker,
+        review,
+        now: input.now,
+        randomId: input.randomId,
+    });
+    const followUps = review.followUps.map((followUp) => {
+        const createdIssue = followUpIssues.find((issue) => issue.description?.includes(followUp.summary));
+        return followUp.disposition === 'new_issue' && createdIssue
+            ? { ...followUp, issue: createdIssue.uri }
+            : followUp;
+    });
+    const acceptanceReview = {
+        ...review,
+        followUps,
+        reusableExtraction: {
+            ...review.reusableExtraction,
+            candidates: review.reusableExtraction.candidates.map((candidate) => {
+                const updated = followUps.find((followUp) => followUp.summary === candidate.summary && followUp.kind === candidate.kind);
+                return updated ?? candidate;
+            }),
+        },
+    };
+    const taskRecord = withSymphonyWorkerAcceptanceTaskStatus(input.worker.taskRecord, acceptanceReview, input.status);
+    const terminalStep = createSymphonyRunStepRecord({
+        worker: input.worker,
+        stepType: input.status === 'completed' ? 'run.completed' : 'run.failed',
+        message: input.status === 'completed'
+            ? `${input.worker.taskRecord.title} completed and entered Secretary reconciliation.`
+            : `${input.worker.taskRecord.title} failed before Secretary acceptance.`,
+        payload: {
+            status: input.status,
+            exitCode: input.exitCode,
+            autoModeSessionId: input.autoModeSessionId,
+            acceptanceOutcome: acceptanceReview.outcome,
+            accepted: acceptanceReview.accepted,
+        },
+        now: input.now,
+        randomId: `${normalizeSymphonyRandomId(input.randomId)}-terminal`,
+    });
+    return {
+        acceptanceReview,
+        followUpIssues,
+        worker: withSymphonyWorkerRunStep({
+            task: input.worker.task,
+            taskRecord: {
+                ...taskRecord,
+                acceptanceReview,
+            },
+            delivery: {
+                ...input.worker.delivery,
+                ...(input.autoModeSessionId ? { autoModeSessionId: input.autoModeSessionId } : {}),
+                acceptanceReview,
+            },
+            session: {
+                ...input.worker.session,
+                ...(input.autoModeSessionId ? { autoModeSessionId: input.autoModeSessionId } : {}),
+                acceptanceReview,
+            },
+            ...(input.worker.runSteps?.length ? { runSteps: input.worker.runSteps } : {}),
+        }, terminalStep),
+    };
+}
+export function createSymphonyAcceptanceReview(input) {
+    const now = input.now ?? new Date();
+    const envelope = parseSymphonyFinalReportEnvelope(input.reportText);
+    const reportSummary = normalizeOptionalText(envelope?.summary)
+        ?? summarizeWorkerReportText(input.reportText)
+        ?? defaultWorkerCompletionSummary(input.worker, input.status, input.exitCode);
+    const followUps = (envelope?.followUps ?? inferFollowUpCandidatesFromReport(input.reportText))
+        .map((candidate) => classifySymphonyFollowUpCandidate(candidate));
+    const reusableCandidates = followUps.filter(isReusableExtractionFollowUp);
+    const reusableExtraction = createReusableExtractionDecision(reusableCandidates);
+    const blockingFollowUp = followUps.find((followUp) => followUp.disposition === 'same_issue_task' || followUp.disposition === 'ask_user');
+    const accepted = input.status === 'completed' && !blockingFollowUp;
+    const outcome = input.status === 'failed' || blockingFollowUp
+        ? 'blocked'
+        : followUps.some((followUp) => followUp.disposition === 'new_issue' || followUp.disposition === 'idea')
+            ? 'follow_up'
+            : accepted
+                ? 'accepted'
+                : 'rejected';
+    return {
+        outcome,
+        accepted,
+        reviewedBy: '__secretary__',
+        reviewedAt: now.toISOString(),
+        summary: reportSummary,
+        evidence: normalizeStringList(envelope?.evidence),
+        risks: normalizeStringList(envelope?.risks),
+        changedFiles: normalizeStringList(envelope?.changedFiles),
+        commands: normalizeStringList(envelope?.commands),
+        followUps,
+        reusableExtraction,
+        ...buildSymphonyImplementationChangeRequest({
+            issue: input.issue,
+            worker: input.worker,
+            status: input.status,
+            exitCode: input.exitCode,
+            summary: reportSummary,
+            evidence: normalizeStringList(envelope?.evidence),
+            risks: normalizeStringList(envelope?.risks),
+            blockingFollowUp,
+            now,
+        }),
+    };
+}
+function buildSymphonyImplementationChangeRequest(input) {
+    const trigger = input.status === 'failed'
+        ? 'worker_failed'
+        : input.blockingFollowUp
+            ? 'acceptance_blocked'
+            : undefined;
+    if (!trigger) {
+        return {};
+    }
+    const failureEvidence = [
+        ...input.evidence,
+        ...(input.worker.runSteps?.map((step) => `${step.stepType}: ${step.message}`) ?? []),
+    ].slice(0, 12);
+    const blockingSummary = input.blockingFollowUp?.summary;
+    const summary = trigger === 'worker_failed'
+        ? input.summary
+        : blockingSummary ?? input.summary;
+    const recommendedNextShape = input.blockingFollowUp?.disposition === 'ask_user'
+        ? 'request_authority'
+        : input.blockingFollowUp?.disposition === 'same_issue_task'
+            ? 'split'
+            : input.status === 'failed'
+                ? 'redesign'
+                : 'retry';
+    return {
+        implementationChangeRequest: {
+            trigger,
+            task: input.worker.task,
+            delivery: input.worker.delivery.uri,
+            session: input.worker.session.uri,
+            summary,
+            failedAssumption: trigger === 'worker_failed'
+                ? `Worker could complete "${input.worker.taskRecord.title}" under the current task plan.`
+                : `Current acceptance can be satisfied without resolving "${summary}".`,
+            evidence: failureEvidence,
+            risks: input.risks,
+            recommendedNextShape,
+            basedOnRunSteps: input.worker.runSteps?.map((step) => step.uri) ?? [],
+            createdAt: input.now.toISOString(),
+        },
+    };
+}
+function withSymphonyWorkerAcceptanceTaskStatus(taskRecord, acceptanceReview, status) {
+    if (status === 'failed' || acceptanceReview.accepted) {
+        return taskRecord;
+    }
+    const { completedAt: _completedAt, ...rest } = taskRecord;
+    return {
+        ...rest,
+        status: 'blocked',
+        error: acceptanceReview.summary,
+    };
+}
+export function classifySymphonyFollowUpCandidate(candidate) {
+    const normalized = normalizeSymphonyFollowUpCandidate(candidate);
+    const suggested = normalizeDisposition(candidate.suggestedDisposition);
+    let disposition;
+    let reason;
+    if (normalized.userDecisionRequired) {
+        disposition = 'ask_user';
+        reason = normalized.reason ?? 'The follow-up requires user-owned intent, authority, priority, or acceptance.';
+    }
+    else if (normalized.requiredBeforeAcceptance) {
+        disposition = 'same_issue_task';
+        reason = normalized.reason ?? 'The follow-up must be resolved before the current delivery can be accepted.';
+    }
+    else if (suggested) {
+        disposition = suggested;
+        reason = normalized.reason ?? `Worker suggested ${suggested}.`;
+    }
+    else if (isReusableExtractionKind(normalized.kind)) {
+        disposition = 'new_issue';
+        reason = normalized.reason ?? 'The finding is reusable across surfaces or workers and should be tracked independently.';
+    }
+    else if (normalized.kind === 'live_verification_gap' || normalized.kind === 'new_defect') {
+        disposition = 'new_issue';
+        reason = normalized.reason ?? 'The finding is actionable follow-up work discovered during the run.';
+    }
+    else if (normalized.kind === 'documentation' || normalized.kind === 'cleanup') {
+        disposition = 'idea';
+        reason = normalized.reason ?? 'The finding is useful but needs scope or priority before it becomes work.';
+    }
+    else {
+        disposition = 'evidence_only';
+        reason = normalized.reason ?? 'The finding is recorded as evidence and does not currently create new work.';
+    }
+    return {
+        ...normalized,
+        disposition,
+        reason,
+        source: 'worker_report',
+    };
+}
+export function parseSymphonyFinalReportEnvelope(text) {
+    const normalized = normalizeOptionalText(text);
+    if (!normalized) {
+        return null;
+    }
+    const explicit = extractSymphonyFinalJsonBlocks(normalized);
+    for (const block of explicit) {
+        const parsed = parseJsonObject(block);
+        const envelope = normalizeFinalReportEnvelope(parsed);
+        if (envelope) {
+            return envelope;
+        }
+    }
+    for (const block of extractGenericJsonBlocks(normalized)) {
+        const parsed = parseJsonObject(block);
+        const envelope = normalizeFinalReportEnvelope(parsed);
+        if (envelope) {
+            return envelope;
+        }
+    }
+    const parsed = parseJsonObject(normalized);
+    return normalizeFinalReportEnvelope(parsed);
+}
+export function parseSymphonyRuntimeDeliveryResult(text) {
+    const normalized = normalizeOptionalText(text);
+    if (!normalized) {
+        return null;
+    }
+    const explicit = extractSymphonyDeliveryJsonBlocks(normalized);
+    for (const block of explicit) {
+        const result = normalizeSymphonyRuntimeDeliveryResult(parseJsonObject(block));
+        if (result) {
+            return result;
+        }
+    }
+    for (const block of extractGenericJsonBlocks(normalized)) {
+        const result = normalizeSymphonyRuntimeDeliveryResult(parseJsonObject(block));
+        if (result) {
+            return result;
+        }
+    }
+    return normalizeSymphonyRuntimeDeliveryResult(parseJsonObject(normalized));
+}
+export function normalizeSymphonyRuntimeDeliveryResult(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const finalReport = normalizeRuntimeDeliveryReportText(value);
+    const events = normalizeRuntimeDeliveryEvents(value.events);
+    const exitCode = normalizeRuntimeDeliveryExitCode(value.exitCode ?? value.exit_code);
+    const status = normalizeRuntimeDeliveryStatus(value.status)
+        ?? (exitCode !== undefined && exitCode !== 0 ? 'failed' : 'completed');
+    const normalizedExitCode = exitCode ?? (status === 'completed' ? 0 : 1);
+    const hasSignal = value.symphonyDelivery === true
+        || value.symphonyFinal === true
+        || normalizeOptionalText(value.kind)?.toLowerCase().includes('symphony') === true
+        || normalizeOptionalText(value.type)?.toLowerCase().includes('symphony') === true
+        || finalReport !== undefined
+        || events.length > 0
+        || value.status !== undefined
+        || value.exitCode !== undefined
+        || value.exit_code !== undefined;
+    if (!hasSignal) {
+        return null;
+    }
+    return {
+        status,
+        exitCode: normalizedExitCode,
+        ...(normalizeOptionalText(value.autoModeSessionId ?? value.auto_mode_session_id ?? value.sessionId ?? value.session_id ?? value.externalRunId ?? value.external_run_id) ? {
+            autoModeSessionId: normalizeOptionalText(value.autoModeSessionId ?? value.auto_mode_session_id ?? value.sessionId ?? value.session_id ?? value.externalRunId ?? value.external_run_id),
+        } : {}),
+        ...(finalReport ? { reportText: finalReport } : {}),
+        events,
+    };
+}
 export function renderSymphonyRuntimePrompt(input) {
     const acceptanceCriteria = normalizeSymphonyAcceptanceCriteria(input.acceptanceCriteria);
     const criteria = acceptanceCriteria.length > 0
@@ -233,23 +827,22 @@ export function renderSymphonyRuntimePrompt(input) {
         ...(input.issuer?.thread ? [`Issuer thread: ${input.issuer.thread}`] : []),
         ...(input.target?.chat ? [`Target chat: ${input.target.chat}`] : []),
         ...(input.target?.thread ? [`Target thread: ${input.target.thread}`] : []),
-        ...(input.target?.contact ? [`Target contact: ${input.target.contact}`] : []),
         ...(input.target?.agent ? [`Target agent: ${input.target.agent}`] : []),
         ...(input.workerIndex && input.workerCount ? [`Worker: ${input.workerIndex}/${input.workerCount}`] : []),
         ...(workThread ? [`Work thread: ${workThread}`] : []),
         `Workspace: ${input.workspace.path}`,
         `Workspace kind: ${input.workspace.kind}`,
-        ...(input.workspace.workspace ? [`Workspace resource: ${input.workspace.workspace}`] : []),
+        ...(input.workspace.container ? [`Workspace container: ${input.workspace.container}`] : []),
         ...(input.workspace.repository ? [`Workspace repository: ${input.workspace.repository}`] : []),
         ...(input.workspace.branch ? [`Workspace branch: ${input.workspace.branch}`] : []),
         ...(input.workspace.baseRevision ? [`Workspace base revision: ${input.workspace.baseRevision}`] : []),
         ...(input.workspace.environment ? [`Workspace environment: ${formatSymphonyWorkerEnvironment(input.workspace.environment)}`] : []),
         '',
         '## Runtime Space Contract',
-        '- Shared control space: Idea/Issue/Report/Evidence are file-primary Pod resources with structured meta; Task, Delivery, Session, Run, and RunStep are TTL control resources. Use the provided URIs as the common coordination surface with AI Secretary and product UI.',
+        '- Shared control space: Issue, Task, Delivery, Session, Run, and Evidence URIs are the common coordination surface with AI Secretary and product UI.',
         '- Explicit session topology: you may be collaborating in the same room as Secretary or running in a runtime-projected worker session reached through control events. Follow the provided chat/thread/session targets; do not infer topology from workspace sharing.',
         '- Thread reconciliation: messages, input/approval requests, blockers, schedule ticks, and Delivery submissions enter the Thread first; the Reconciler/Scheduler wakes Secretary or workers.',
-        '- Report through Delivery plus file-primary Report/Evidence: return progress, blockers, implementation change requests, and verification so AI Secretary can persist structured control facts and Pod files without inlining long logs into TTL.',
+        '- Report through Delivery/Evidence: return progress, blockers, implementation change requests, and verification for AI Secretary to persist or route.',
         '- Thread workspace: workers assigned to the same Thread in the same environment should normally share this workspace; independent Threads may use separate worktrees.',
         '- Environment-scoped identity: cross-environment file identity requires revision, artifact, patch, checksum, or evidence references.',
         '',
@@ -267,26 +860,658 @@ export function renderSymphonyRuntimePrompt(input) {
         '- Report blockers to AI Secretary instead of asking the user directly.',
         '- Do not read sibling worker transcripts unless Secretary explicitly includes them in a Delivery.',
         '- Preserve a concise report with changed files, commands run, and remaining risks.',
-        '- In the final report, explicitly list follow-up candidates separately from assigned-work evidence: new defects, missing shared abstractions, app-local glue to move into shared models, storage, or adapter packages, live verification gaps, or deferred cleanup. Secretary classifies these; do not create or close Issues yourself.',
         '- If blocked by missing credentials, destructive actions, or unclear scope, report the blocker instead of guessing.',
         '- Your workspace path is local to this worker environment. Same-Thread workers in this environment may share it, but do not assume Secretary, the user, or workers in other environments can access the same absolute path.',
         '- When reporting file work across environments, include repo-relative paths plus base revision, checksums/etags, patch or artifact references, and verification evidence.',
         '',
+        '## Final Report And Follow-Up Candidates',
+        '- Final output must separate assigned-work evidence from follow-up candidates.',
+        '- Include changed files, commands/tests run, verification evidence, remaining risks, and blockers.',
+        '- If you created app-local glue that another surface or worker will likely need, report it as a follow-up candidate instead of hiding it in the summary.',
+        '- Candidate signals include missing shared abstractions, repeated model/ORM helpers, duplicated CLI/Web/service lifecycle logic, runtime adapter normalization, reusable test harnesses, live-verification gaps, defects, cleanup, or documentation work.',
+        '- You may recommend a disposition, but AI Secretary owns the final classification: same_issue_task, new_issue, idea, evidence_only, or ask_user.',
+        '- Prefer this machine-readable envelope at the end of the report so LinX can archive it:',
+        '```json',
+        '{',
+        '  "symphonyFinal": true,',
+        '  "summary": "one sentence result",',
+        '  "changedFiles": ["repo-relative/path.ts"],',
+        '  "commands": ["test command actually run"],',
+        '  "evidence": ["what proves acceptance"],',
+        '  "risks": ["known risk or not-tested gap"],',
+        '  "followUps": [',
+        '    {',
+        '      "kind": "missing_shared_abstraction",',
+        '      "summary": "shared extraction or follow-up work",',
+        '      "evidence": ["file or observation"],',
+        '      "suggestedDisposition": "new_issue",',
+        '      "reason": "why it is separate from this delivery"',
+        '    }',
+        '  ]',
+        '}',
+        '```',
+        '',
         '## Pod And Control Record Boundary',
         '- In LinX runtime, Pod control records are authoritative. Local files are mirrors, logs, or portable-runtime fallbacks.',
-        '- If Pod/model tools are available, read only the assigned Issue document/meta, Task, Delivery, Run, source context, and existing Report/Evidence files needed for this task.',
-        '- Write only execution facts for the assigned work: Run/RunStep progress, blockers, file-primary Evidence/Report, Delivery report metadata, or Implementation Change Request.',
+        '- If Pod/model tools are available, read only the assigned Issue, Task, Delivery, Run, source context, and existing evidence needed for this task.',
+        '- Write only execution facts for the assigned work: Run/RunStep progress, blockers, Evidence, Delivery report, or Implementation Change Request.',
         '- Do not close Issues, rewrite Spec/current truth, change acceptance criteria, change work split, alter release or roadmap state, create grants, or mutate sibling worker state.',
         '- Use shared model/ORM surfaces when writing structured Pod data. Do not hand-patch business TTL or invent Pod paths.',
         '- If Pod access is unavailable, return the same facts as a structured report so AI Secretary can persist them.',
         '',
         '## Documentation Authority',
-        '- Pod Issue files plus meta, Spec files, and Task control records are the authority for status, scope, acceptance, split, ownership, closure, and cross-client coordination.',
+        '- Pod Issue/Spec/Task records are the control authority for status, scope, acceptance, split, ownership, closure, and cross-client coordination.',
         '- Repository docs are the implementation authority for code-adjacent design, behavior notes, tests, examples, migration details, and file-level evidence.',
         '- When you edit repository docs, reference the Pod Issue/Spec/Task URI instead of creating a second Issue truth.',
         '- If repository findings contradict the Pod control record, write an Implementation Change Request instead of silently changing acceptance or scope.',
     ].join('\n');
 }
+function createFollowUpIssuesFromAcceptanceReview(input) {
+    const now = input.now ?? new Date();
+    const timestamp = now.toISOString();
+    return input.review.followUps
+        .filter((followUp) => followUp.disposition === 'new_issue')
+        .map((followUp, index) => {
+        const uri = createSymphonyIssueUri({
+            now,
+            randomId: `${normalizeSymphonyRandomId(input.randomId)}-fu${index + 1}`,
+        });
+        return {
+            uri,
+            title: createSymphonyTitle(followUp.summary),
+            description: [
+                followUp.summary,
+                '',
+                `Origin issue: ${input.issue.uri}`,
+                `Origin task: ${input.worker.task}`,
+                `Origin delivery: ${input.worker.delivery.uri}`,
+                `Origin session: ${input.worker.session.uri}`,
+                `Disposition reason: ${followUp.reason}`,
+                ...(followUp.evidence?.length ? ['', 'Evidence:', ...followUp.evidence.map((item) => `- ${item}`)] : []),
+            ].join('\n'),
+            status: 'open',
+            priority: input.issue.priority,
+            source: input.issue.source,
+            issuer: input.issue.issuer,
+            parentIssue: input.issue.uri,
+            labels: ['symphony', 'follow-up', followUp.kind],
+            tasks: [],
+            deliveries: [],
+            sessions: [],
+            ...(input.issue.chat ? { chat: input.issue.chat } : {}),
+            ...(input.issue.thread ? { thread: input.issue.thread } : {}),
+            ...(input.issue.messages ? { messages: input.issue.messages } : {}),
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+    });
+}
+function createReusableExtractionDecision(candidates) {
+    if (candidates.length === 0) {
+        return {
+            disposition: 'evidence_only',
+            reason: 'No reusable-module extraction candidate was reported or detected for this delivery.',
+            candidates: [],
+        };
+    }
+    const blocking = candidates.find((candidate) => candidate.disposition === 'same_issue_task');
+    if (blocking) {
+        return {
+            disposition: 'same_issue_task',
+            reason: blocking.reason,
+            candidates,
+        };
+    }
+    const newIssue = candidates.find((candidate) => candidate.disposition === 'new_issue');
+    if (newIssue) {
+        return {
+            disposition: 'new_issue',
+            reason: newIssue.reason,
+            candidates,
+        };
+    }
+    const askUser = candidates.find((candidate) => candidate.disposition === 'ask_user');
+    if (askUser) {
+        return {
+            disposition: 'ask_user',
+            reason: askUser.reason,
+            candidates,
+        };
+    }
+    const idea = candidates.find((candidate) => candidate.disposition === 'idea');
+    if (idea) {
+        return {
+            disposition: 'idea',
+            reason: idea.reason,
+            candidates,
+        };
+    }
+    return {
+        disposition: 'evidence_only',
+        reason: 'Reusable extraction candidates were recorded as evidence only.',
+        candidates,
+    };
+}
+function normalizeSymphonyFollowUpCandidate(candidate) {
+    return {
+        kind: normalizeFollowUpKind(candidate.kind),
+        summary: normalizeOptionalText(candidate.summary) ?? 'Unspecified Symphony follow-up',
+        evidence: normalizeStringList(candidate.evidence),
+        ...(normalizeDisposition(candidate.suggestedDisposition) ? { suggestedDisposition: normalizeDisposition(candidate.suggestedDisposition) } : {}),
+        ...(normalizeOptionalText(candidate.reason) ? { reason: normalizeOptionalText(candidate.reason) } : {}),
+        ...(candidate.requiredBeforeAcceptance ? { requiredBeforeAcceptance: true } : {}),
+        ...(candidate.userDecisionRequired ? { userDecisionRequired: true } : {}),
+        ...(normalizeOptionalText(candidate.targetPackage) ? { targetPackage: normalizeOptionalText(candidate.targetPackage) } : {}),
+    };
+}
+function normalizeFollowUpKind(value) {
+    if (value === 'new_defect'
+        || value === 'missing_shared_abstraction'
+        || value === 'app_local_glue'
+        || value === 'models_gap'
+        || value === 'orm_gap'
+        || value === 'runtime_api_gap'
+        || value === 'shared_runtime_utility'
+        || value === 'test_harness'
+        || value === 'live_verification_gap'
+        || value === 'documentation'
+        || value === 'cleanup'
+        || value === 'other') {
+        return value;
+    }
+    const text = normalizeOptionalText(typeof value === 'string' ? value : undefined)?.toLowerCase() ?? '';
+    if (text.includes('shared') || text.includes('abstraction') || text.includes('reuse'))
+        return 'missing_shared_abstraction';
+    if (text.includes('glue') || text.includes('local'))
+        return 'app_local_glue';
+    if (text.includes('model'))
+        return 'models_gap';
+    if (text.includes('orm'))
+        return 'orm_gap';
+    if (text.includes('runtime'))
+        return 'runtime_api_gap';
+    if (text.includes('harness') || text.includes('fixture'))
+        return 'test_harness';
+    if (text.includes('verify') || text.includes('validation'))
+        return 'live_verification_gap';
+    if (text.includes('doc'))
+        return 'documentation';
+    if (text.includes('cleanup'))
+        return 'cleanup';
+    if (text.includes('bug') || text.includes('defect'))
+        return 'new_defect';
+    return 'other';
+}
+function normalizeDisposition(value) {
+    if (value === 'same_issue_task'
+        || value === 'new_issue'
+        || value === 'idea'
+        || value === 'evidence_only'
+        || value === 'ask_user') {
+        return value;
+    }
+    return undefined;
+}
+function isReusableExtractionFollowUp(candidate) {
+    return isReusableExtractionKind(candidate.kind);
+}
+function isReusableExtractionKind(kind) {
+    return kind === 'missing_shared_abstraction'
+        || kind === 'app_local_glue'
+        || kind === 'models_gap'
+        || kind === 'orm_gap'
+        || kind === 'runtime_api_gap'
+        || kind === 'shared_runtime_utility'
+        || kind === 'test_harness';
+}
+function inferFollowUpCandidatesFromReport(text) {
+    const normalized = normalizeOptionalText(text);
+    if (!normalized) {
+        return [];
+    }
+    const lower = normalized.toLowerCase();
+    const candidates = [];
+    if (/(shared abstraction|reusable module|抽.*复用|复用.*模块|app-local glue|local glue|duplicated .*logic|duplicate .*helper)/iu.test(normalized)) {
+        candidates.push({
+            kind: 'missing_shared_abstraction',
+            summary: extractFollowUpSummary(normalized, 'Reusable extraction candidate detected from worker report.'),
+            evidence: extractEvidenceLines(normalized),
+        });
+    }
+    if (/(models?|schema|resource helper|iri|uri|id helper)/u.test(lower)) {
+        candidates.push({
+            kind: 'models_gap',
+            summary: extractFollowUpSummary(normalized, 'Model/helper gap detected from worker report.'),
+            evidence: extractEvidenceLines(normalized),
+        });
+    }
+    if (/(verification gap|not tested|not-tested|未验证|manual verification|live verification)/iu.test(normalized)) {
+        candidates.push({
+            kind: 'live_verification_gap',
+            summary: extractFollowUpSummary(normalized, 'Verification follow-up detected from worker report.'),
+            evidence: extractEvidenceLines(normalized),
+            suggestedDisposition: 'new_issue',
+        });
+    }
+    return dedupeFollowUpCandidates(candidates);
+}
+function dedupeFollowUpCandidates(candidates) {
+    const seen = new Set();
+    const deduped = [];
+    for (const candidate of candidates) {
+        const key = `${candidate.kind}\0${candidate.summary}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(candidate);
+    }
+    return deduped;
+}
+function extractFollowUpSummary(text, fallback) {
+    const lines = text.split(/\r?\n/u)
+        .map((line) => line.replace(/^[-*]\s*/u, '').trim())
+        .filter(Boolean);
+    const match = lines.find((line) => /(shared|reusable|复用|models?|schema|verification|not tested|未验证|helper|runtime|adapter|glue|duplicate)/iu.test(line));
+    return createSymphonyTitle(match ?? fallback);
+}
+function extractEvidenceLines(text) {
+    return text.split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => /(\bapps\/|\bpackages\/|\bdocs\/|\btests?\/|\.ts\b|\.tsx\b|\.mjs\b|\.md\b|not tested|未验证)/iu.test(line))
+        .slice(0, 8);
+}
+function summarizeWorkerReportText(text) {
+    const normalized = normalizeOptionalText(text);
+    if (!normalized) {
+        return undefined;
+    }
+    const line = normalized.split(/\r?\n/u).map((item) => item.trim()).find(Boolean);
+    return line ? createSymphonyTitle(line) : undefined;
+}
+function defaultWorkerCompletionSummary(worker, status, exitCode) {
+    return status === 'completed'
+        ? `${worker.taskRecord.title} completed.`
+        : `${worker.taskRecord.title} failed with exit code ${exitCode}.`;
+}
+function defaultSymphonyRunStepMessage(stepType, worker) {
+    if (stepType === 'session.started')
+        return `${worker.session.backend} worker session started.`;
+    if (stepType === 'session.resumed')
+        return `${worker.session.backend} worker session resumed.`;
+    if (stepType === 'run.started')
+        return `${worker.session.backend} worker run started.`;
+    if (stepType === 'run.step')
+        return `${worker.session.backend} worker progress heartbeat.`;
+    if (stepType === 'approval.required')
+        return `${worker.session.backend} worker requires approval.`;
+    if (stepType === 'input.required')
+        return `${worker.session.backend} worker requires input.`;
+    if (stepType === 'worker.blocked')
+        return `${worker.session.backend} worker is blocked.`;
+    if (stepType === 'delivery.submitted')
+        return `${worker.session.backend} worker submitted a delivery.`;
+    if (stepType === 'delivery.completed')
+        return `${worker.session.backend} worker delivery completed.`;
+    if (stepType === 'delivery.failed')
+        return `${worker.session.backend} worker delivery failed.`;
+    if (stepType === 'run.completed')
+        return `${worker.session.backend} worker run completed.`;
+    return `${worker.session.backend} worker run failed.`;
+}
+function sanitizeSymphonyRunStepPayload(payload) {
+    if (!payload) {
+        return undefined;
+    }
+    const entries = Object.entries(payload).filter(([, value]) => value !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizeSymphonyStatusTimestamp(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    const text = normalizeOptionalText(value);
+    if (text) {
+        const parsed = new Date(text);
+        return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : text;
+    }
+    return new Date().toISOString();
+}
+function normalizeSymphonyThreadReconcileEvent(value, input, index) {
+    const hookEventName = normalizeOptionalText(value.hookEventName ?? value.hook_event_name);
+    if (value.symphonyHookEvent === true || hookEventName) {
+        return normalizeSymphonyCodexHookThreadEvent(value, input, index, hookEventName ?? 'unknown');
+    }
+    const data = normalizeSymphonyThreadEventData(value, {
+        source: normalizeOptionalText(value.source) ?? 'codex-mcp',
+    });
+    return {
+        id: normalizeOptionalText(value.id) ?? `event_${input.randomId ?? 'symphony'}_${index + 1}`,
+        type: normalizeSymphonyThreadEventType(value.type ?? value.eventType ?? value.event_type) ?? 'run.updated',
+        ...(normalizeOptionalText(value.chat ?? input.chat) ? { chat: normalizeOptionalText(value.chat ?? input.chat) } : {}),
+        ...(normalizeOptionalText(value.thread ?? input.thread) ? { thread: normalizeOptionalText(value.thread ?? input.thread) } : {}),
+        ...(normalizeOptionalText(value.resource) ? { resource: normalizeOptionalText(value.resource) } : {}),
+        ...(normalizeSymphonyThreadEventActor(value.actor) ? { actor: normalizeSymphonyThreadEventActor(value.actor) } : {}),
+        ...(normalizeOptionalText(value.content ?? value.message) ? { content: normalizeOptionalText(value.content ?? value.message) } : {}),
+        ...(normalizeOptionalText(value.createdAt ?? value.created_at) ? { createdAt: normalizeOptionalText(value.createdAt ?? value.created_at) } : {}),
+        ...(data ? { data } : {}),
+    };
+}
+function normalizeSymphonyCodexHookThreadEvent(value, input, index, hookEventName) {
+    const sessionId = normalizeOptionalText(value.sessionId ?? value.session_id);
+    const commonData = normalizeSymphonyThreadEventData(value, {
+        source: 'codex-native-hook',
+        hookEventName,
+        ...(sessionId ? { sessionId } : {}),
+    });
+    const id = normalizeOptionalText(value.id)
+        ?? `codex_hook_${safeSymphonyIdSegment(sessionId ?? 'session')}_${safeSymphonyIdSegment(hookEventName)}_${index + 1}`;
+    const content = normalizeOptionalText(value.content ?? value.message)
+        ?? `Codex hook ${hookEventName}${sessionId ? ` for ${sessionId}` : ''}.`;
+    const createdAt = normalizeOptionalText(value.createdAt ?? value.created_at);
+    if (hookEventName === 'UserPromptSubmit') {
+        return {
+            id,
+            type: 'message.appended',
+            ...(normalizeOptionalText(input.chat) ? { chat: normalizeOptionalText(input.chat) } : {}),
+            ...(normalizeOptionalText(input.thread) ? { thread: normalizeOptionalText(input.thread) } : {}),
+            actor: { role: 'user' },
+            content,
+            ...(createdAt ? { createdAt } : {}),
+            data: {
+                ...(commonData ?? {}),
+                role: 'user',
+            },
+        };
+    }
+    if (hookEventName === 'PreToolUse') {
+        return {
+            id,
+            type: 'approval.required',
+            ...(normalizeOptionalText(input.chat) ? { chat: normalizeOptionalText(input.chat) } : {}),
+            ...(normalizeOptionalText(input.thread) ? { thread: normalizeOptionalText(input.thread) } : {}),
+            actor: { role: 'tool' },
+            content,
+            ...(createdAt ? { createdAt } : {}),
+            data: commonData,
+        };
+    }
+    return {
+        id,
+        type: 'run.updated',
+        ...(normalizeOptionalText(input.chat) ? { chat: normalizeOptionalText(input.chat) } : {}),
+        ...(normalizeOptionalText(input.thread) ? { thread: normalizeOptionalText(input.thread) } : {}),
+        actor: { role: 'runtime' },
+        content,
+        ...(createdAt ? { createdAt } : {}),
+        data: commonData,
+    };
+}
+function normalizeSymphonyThreadEventData(value, defaults) {
+    const data = isPlainSymphonyRecord(value.data) ? value.data : {};
+    return sanitizeSymphonyRunStepPayload({
+        ...data,
+        ...defaults,
+    });
+}
+function normalizeSymphonyThreadEventActor(value) {
+    if (!isPlainSymphonyRecord(value)) {
+        return undefined;
+    }
+    const id = normalizeOptionalText(value.id);
+    const role = normalizeOptionalText(value.role);
+    const label = normalizeOptionalText(value.label);
+    if (!id && !role && !label) {
+        return undefined;
+    }
+    return {
+        ...(id ? { id } : {}),
+        ...(role ? { role: role } : {}),
+        ...(label ? { label } : {}),
+    };
+}
+function normalizeSymphonyThreadEventType(value) {
+    return normalizeOptionalText(value);
+}
+function resolveSymphonyThreadReconcilerNextAction(wakeJobs, notificationEvents) {
+    if (wakeJobs.some((job) => job.targetRole === 'secretary')) {
+        return 'wake_secretary';
+    }
+    if (wakeJobs.some((job) => job.targetRole === 'worker')) {
+        return 'wake_worker';
+    }
+    if (wakeJobs.some((job) => job.targetRole === 'reviewer')) {
+        return 'wake_reviewer';
+    }
+    if (notificationEvents.length > 0) {
+        return 'notify_user';
+    }
+    return 'noop';
+}
+function summarizeSymphonyThreadReconcilerResult(eventCount, nextAction, wakeJobCount, notificationCount) {
+    if (eventCount === 0) {
+        return 'No Symphony thread events to reconcile.';
+    }
+    if (nextAction === 'wake_secretary') {
+        return `Reconciled ${eventCount} event(s); wake Secretary with ${wakeJobCount} queued job(s).`;
+    }
+    if (nextAction === 'wake_worker') {
+        return `Reconciled ${eventCount} event(s); wake worker with ${wakeJobCount} queued job(s).`;
+    }
+    if (nextAction === 'wake_reviewer') {
+        return `Reconciled ${eventCount} event(s); wake reviewer with ${wakeJobCount} queued job(s).`;
+    }
+    if (nextAction === 'notify_user') {
+        return `Reconciled ${eventCount} event(s); notify user with ${notificationCount} notification(s).`;
+    }
+    return `Reconciled ${eventCount} event(s); no wake job is required.`;
+}
+function safeSymphonyIdSegment(value) {
+    const normalized = value
+        .replace(/[^a-zA-Z0-9._:-]/gu, '-')
+        .replace(/-+/gu, '-')
+        .replace(/^-|-$/gu, '')
+        .slice(0, 96);
+    return normalized || 'unknown';
+}
+function isPlainSymphonyRecord(value) {
+    return isRecord(value) && !Array.isArray(value);
+}
+function extractSymphonyFinalJsonBlocks(text) {
+    const blocks = [];
+    for (const match of text.matchAll(/```(?:json)?\s*(?:symphony-final|linx-symphony-final)?\s*\n([\s\S]*?)```/giu)) {
+        const body = match[1]?.trim();
+        if (body && /"symphonyFinal"|"followUps"|"summary"/u.test(body)) {
+            blocks.push(body);
+        }
+    }
+    return blocks;
+}
+function extractSymphonyDeliveryJsonBlocks(text) {
+    const blocks = [];
+    for (const match of text.matchAll(/```(?:json)?\s*(?:symphony-delivery|linx-symphony-delivery)?\s*\n([\s\S]*?)```/giu)) {
+        const body = match[1]?.trim();
+        if (body && /"symphonyDelivery"|"symphonyFinal"|"events"|"reportText"|"exitCode"/u.test(body)) {
+            blocks.push(body);
+        }
+    }
+    return blocks;
+}
+function extractGenericJsonBlocks(text) {
+    const blocks = [];
+    for (const match of text.matchAll(/```json\s*\n([\s\S]*?)```/giu)) {
+        const body = match[1]?.trim();
+        if (body) {
+            blocks.push(body);
+        }
+    }
+    return blocks;
+}
+function normalizeRuntimeDeliveryReportText(value) {
+    const explicitReport = normalizeOptionalText(value.reportText ?? value.report_text);
+    if (explicitReport) {
+        return explicitReport;
+    }
+    const report = value.report ?? value.finalReport ?? value.final_report;
+    const reportText = normalizeOptionalText(report);
+    if (reportText) {
+        return reportText;
+    }
+    const reportEnvelope = normalizeFinalReportEnvelope(report);
+    if (reportEnvelope) {
+        return stringifySymphonyFinalReportEnvelope(reportEnvelope);
+    }
+    const envelope = normalizeFinalReportEnvelope(value);
+    return envelope ? stringifySymphonyFinalReportEnvelope(envelope) : undefined;
+}
+function stringifySymphonyFinalReportEnvelope(envelope) {
+    return [
+        '```json',
+        JSON.stringify({ symphonyFinal: true, ...envelope }),
+        '```',
+    ].join('\n');
+}
+function normalizeRuntimeDeliveryEvents(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => normalizeRuntimeDeliveryEvent(item))
+        .filter((item) => Boolean(item));
+}
+function normalizeRuntimeDeliveryEvent(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const stepType = normalizeRuntimeEventType(value.stepType ?? value.step_type ?? value.type);
+    if (!stepType) {
+        return null;
+    }
+    const payload = isRecord(value.payload) ? value.payload : undefined;
+    return {
+        stepType,
+        ...(normalizeOptionalText(value.message) ? { message: normalizeOptionalText(value.message) } : {}),
+        ...(payload ? { payload } : {}),
+        ...(normalizeRuntimeDeliveryTimestamp(value.createdAt ?? value.created_at ?? value.timestamp) ? {
+            createdAt: normalizeRuntimeDeliveryTimestamp(value.createdAt ?? value.created_at ?? value.timestamp),
+        } : {}),
+        ...(normalizeOptionalText(value.randomId ?? value.random_id) ? { randomId: normalizeOptionalText(value.randomId ?? value.random_id) } : {}),
+    };
+}
+function normalizeRuntimeEventType(value) {
+    const normalized = normalizeOptionalText(value);
+    if (normalized === 'session.started'
+        || normalized === 'session.resumed'
+        || normalized === 'run.started'
+        || normalized === 'run.step'
+        || normalized === 'approval.required'
+        || normalized === 'input.required'
+        || normalized === 'worker.blocked'
+        || normalized === 'delivery.submitted'
+        || normalized === 'delivery.completed'
+        || normalized === 'delivery.failed'
+        || normalized === 'run.completed'
+        || normalized === 'run.failed') {
+        return normalized;
+    }
+    return undefined;
+}
+function normalizeRuntimeDeliveryStatus(value) {
+    const normalized = normalizeOptionalText(value);
+    if (normalized === 'completed' || normalized === 'success' || normalized === 'succeeded' || normalized === 'ok') {
+        return 'completed';
+    }
+    if (normalized === 'failed' || normalized === 'failure' || normalized === 'error') {
+        return 'failed';
+    }
+    return undefined;
+}
+function normalizeRuntimeDeliveryExitCode(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    const normalized = normalizeOptionalText(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(normalized, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function normalizeRuntimeDeliveryTimestamp(value) {
+    const normalized = normalizeOptionalText(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const parsed = new Date(normalized);
+    return Number.isFinite(parsed.getTime()) ? parsed.toISOString() : normalized;
+}
+function parseJsonObject(text) {
+    const normalized = normalizeOptionalText(text);
+    if (!normalized) {
+        return null;
+    }
+    try {
+        return JSON.parse(normalized);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFinalReportEnvelope(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const followUps = normalizeFollowUpCandidateList(value.followUps ?? value.follow_up_candidates ?? value.followUpCandidates);
+    const evidence = normalizeStringList(value.evidence);
+    const risks = normalizeStringList(value.risks);
+    const changedFiles = normalizeStringList(value.changedFiles ?? value.changed_files);
+    const commands = normalizeStringList(value.commands);
+    const envelope = {
+        ...(normalizeOptionalText(value.summary) ? { summary: normalizeOptionalText(value.summary) } : {}),
+        evidence,
+        risks,
+        changedFiles,
+        commands,
+        followUps,
+    };
+    const hasEnvelopeSignal = value.symphonyFinal === true
+        || envelope.summary
+        || evidence.length > 0
+        || risks.length > 0
+        || changedFiles.length > 0
+        || commands.length > 0
+        || followUps.length > 0;
+    return hasEnvelopeSignal ? envelope : null;
+}
+function normalizeFollowUpCandidateList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => normalizeFollowUpCandidateFromUnknown(item))
+        .filter((item) => Boolean(item));
+}
+function normalizeFollowUpCandidateFromUnknown(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const summary = normalizeOptionalText(value.summary);
+    if (!summary) {
+        return null;
+    }
+    return normalizeSymphonyFollowUpCandidate({
+        kind: normalizeFollowUpKind(value.kind),
+        summary,
+        evidence: normalizeStringList(value.evidence),
+        ...(normalizeDisposition(value.suggestedDisposition ?? value.suggested_disposition ?? value.disposition) ? {
+            suggestedDisposition: normalizeDisposition(value.suggestedDisposition ?? value.suggested_disposition ?? value.disposition),
+        } : {}),
+        ...(normalizeOptionalText(value.reason) ? { reason: normalizeOptionalText(value.reason) } : {}),
+        ...(value.requiredBeforeAcceptance === true || value.required_before_acceptance === true ? { requiredBeforeAcceptance: true } : {}),
+        ...(value.userDecisionRequired === true || value.user_decision_required === true ? { userDecisionRequired: true } : {}),
+        ...(normalizeOptionalText(value.targetPackage ?? value.target_package) ? { targetPackage: normalizeOptionalText(value.targetPackage ?? value.target_package) } : {}),
+    });
+}
 function createSymphonyDispatchReconcilerState(input) {
     const { summary } = decideThreadControlEvent({
         policy: {
@@ -371,6 +1596,17 @@ function normalizeOptionalText(value) {
     const normalized = typeof value === 'string' ? value.trim() : '';
     return normalized || undefined;
 }
+function normalizeStringList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => normalizeOptionalText(item))
+        .filter((item) => Boolean(item));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
 function normalizeSymphonyChatThreadRef(input) {
     const chat = normalizeOptionalText(input.chat);
     const thread = normalizeOptionalText(input.thread);
@@ -406,7 +1642,7 @@ function normalizeSymphonyWorkerWorkspace(root, override, backend) {
         ...(normalizeOptionalText(override?.repository ?? root.repository) ? { repository: normalizeOptionalText(override?.repository ?? root.repository) } : {}),
         ...(normalizeOptionalText(override?.branch ?? root.branch) ? { branch: normalizeOptionalText(override?.branch ?? root.branch) } : {}),
         ...(normalizeOptionalText(override?.worktree ?? root.worktree) ? { worktree: normalizeOptionalText(override?.worktree ?? root.worktree) } : {}),
-        ...(normalizeOptionalText(override?.workspace ?? root.workspace) ? { workspace: normalizeOptionalText(override?.workspace ?? root.workspace) } : {}),
+        ...(normalizeOptionalText(override?.container ?? root.container) ? { container: normalizeOptionalText(override?.container ?? root.container) } : {}),
         ...(normalizeOptionalText(override?.baseRevision ?? root.baseRevision) ? { baseRevision: normalizeOptionalText(override?.baseRevision ?? root.baseRevision) } : {}),
         environment: normalizeSymphonyWorkerEnvironment(override?.environment ?? root.environment, backend),
     };
@@ -489,14 +1725,12 @@ function createSymphonySupervisorPolicy(intervalMs) {
 }
 function normalizeSymphonyDelegationTarget(input) {
     const explicit = input.target ?? {};
-    const backend = explicit.backend ?? input.backend;
     const chatThread = normalizeSymphonyChatThreadRef({
         chat: explicit.chat ?? input.chat,
         thread: explicit.thread ?? input.thread,
         messages: explicit.messages ?? input.messages,
     });
-    const contact = normalizeOptionalText(explicit.contact) ?? normalizeOptionalText(explicit.agent) ?? backend;
-    const agent = normalizeOptionalText(explicit.agent) ?? contact;
+    const agent = normalizeOptionalText(explicit.agent) ?? `${input.backend}-worker`;
     const label = normalizeOptionalText(explicit.label);
     const source = explicit.source
         ?? (chatThread.chat || chatThread.thread
@@ -506,8 +1740,7 @@ function normalizeSymphonyDelegationTarget(input) {
                 : 'default');
     return {
         source,
-        backend,
-        contact,
+        backend: explicit.backend ?? input.backend,
         agent,
         ...(label ? { label } : {}),
         ...chatThread,
@@ -518,7 +1751,21 @@ function formatSymphonyTimestamp(now = new Date()) {
 }
 function normalizeSymphonyRandomId(randomId) {
     const normalized = typeof randomId === 'string'
-        ? randomId.replace(/[^a-zA-Z0-9_-]/gu, '').slice(0, 12)
+        ? randomId.replace(/[^a-zA-Z0-9_-]/gu, '')
         : '';
-    return normalized || Math.random().toString(36).slice(2, 10);
+    if (!normalized) {
+        return Math.random().toString(36).slice(2, 10);
+    }
+    if (normalized.length <= 12) {
+        return normalized;
+    }
+    return `${normalized.slice(0, 6)}${hashSymphonyRandomId(normalized)}`;
+}
+function hashSymphonyRandomId(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36).slice(0, 6).padStart(6, '0');
 }