@undefineds.co/linx 0.3.20 → 0.3.23

package/vendor/agent-runtime/dist/pod-resource-identity.js

@@ -0,0 +1,54 @@
+const ABSOLUTE_IRI = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+const AGENT_RESOURCE_ID = /^([A-Za-z0-9_.-]+)\/$/;
+const AGENT_KEY = /^[A-Za-z0-9_.-]+$/;
+export function asBaseRelativeResourceId(value, label = 'Resource id') {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty base-relative resource id.`);
+    }
+    const normalized = value.trim();
+    if (ABSOLUTE_IRI.test(normalized) || normalized.startsWith('/') || normalized.startsWith('//')) {
+        throw new Error(`${label} must be a base-relative resource id.`);
+    }
+    return normalized;
+}
+export function asResourceIri(value, label = 'Resource IRI') {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty resource IRI.`);
+    }
+    const normalized = value.trim();
+    if (!ABSOLUTE_IRI.test(normalized)) {
+        throw new Error(`${label} must be a full resource IRI.`);
+    }
+    return normalized;
+}
+export function requireRowResourceId(row, label = 'Pod row') {
+    if (!row || typeof row.id !== 'string' || row.id.trim().length === 0) {
+        throw new Error(`${label} row is missing row.id.`);
+    }
+    return asBaseRelativeResourceId(row.id, `${label} row.id`);
+}
+function defaultAgentKey() {
+    return `agent_${Math.random().toString(36).slice(2, 12)}`;
+}
+export function agentResourceId(key) {
+    const raw = typeof key === 'string' ? key.trim() : '';
+    const value = raw || defaultAgentKey();
+    if (AGENT_RESOURCE_ID.test(value)) {
+        return asBaseRelativeResourceId(value, 'Agent resource id');
+    }
+    if (!AGENT_KEY.test(value)) {
+        throw new Error('Agent key must use letters, numbers, dot, underscore, or dash.');
+    }
+    return asBaseRelativeResourceId(`${value}/`, 'Agent resource id');
+}
+export function agentKeyFromResourceId(resourceId) {
+    const id = asBaseRelativeResourceId(resourceId, 'Agent resource id');
+    const match = id.match(AGENT_RESOURCE_ID);
+    if (!match?.[1]) {
+        throw new Error('Agent resource id must use {agentKey}/.');
+    }
+    return match[1];
+}
+export function agentHomeDirFromResourceId(resourceId) {
+    return asBaseRelativeResourceId(agentResourceId(agentKeyFromResourceId(resourceId)), 'Agent home dir');
+}

package/vendor/agent-runtime/dist/reconciler.d.ts

@@ -1,5 +1,4 @@
 import type { AgentParticipantRole } from './turn-controller.js';
-import { type ClientReconcilerLease, type ReconcilerOwner } from './coordination.js';
 export type ThreadPolicyKind = 'direct' | 'auto' | 'symphony' | 'open_group' | 'review';
 export type ThreadKind = 'main' | 'control' | 'worker' | 'review' | 'schedule' | 'schedule_run';
 export type ReconcilerEventType = 'message.appended' | 'input.required' | 'approval.required' | 'inbox.notification.created' | 'inbox.notification.updated' | 'delivery.submitted' | 'delivery.completed' | 'delivery.failed' | 'schedule.tick' | 'worker.blocked' | 'change.requested' | 'issue.updated' | 'task.updated' | 'run.updated' | (string & {});
@@ -63,9 +62,6 @@ export interface ThreadControlEvent<TData extends Record<string, unknown> = Reco
 }
 export interface ThreadPolicy {
     kind: ThreadPolicyKind;
-    reconcilerOwner?: ReconcilerOwner;
-    humanAuthorities?: string[];
-    humanAuthorityCount?: number;
     secretaryAgent?: string;
     defaultAssistantAgent?: string;
     assignedWorkerAgent?: string;
@@ -118,7 +114,6 @@ export interface ReconcilerNotificationEvent {
 export interface ReconcileDecision {
     id: string;
     policyKind: ThreadPolicyKind;
-    reconcilerOwner: ReconcilerOwner;
     event: ThreadControlEvent;
     placement: ThreadPlacement;
     wakeJobs: WakeJob[];
@@ -145,7 +140,6 @@ export interface WakeJobSummary {
 export interface ReconcileDecisionSummary {
     id: string;
     policyKind: ThreadPolicyKind;
-    reconcilerOwner: ReconcilerOwner;
     eventType: ReconcilerEventType;
     thread: string;
     chat?: string;
@@ -157,11 +151,6 @@ export interface ReconcileDecisionSummary {
 export interface ReconcileThreadEventInput {
     policy: ThreadPolicyKind | ThreadPolicy;
     event: ThreadControlEvent;
-    reconcilerOwner?: ReconcilerOwner;
-    humanAuthorities?: string[];
-    humanAuthorityCount?: number;
-    clientReconcilerLease?: ClientReconcilerLease | null;
-    requireClientReconcilerLease?: boolean;
     chat?: string;
     thread?: string;
     now?: Date;

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

@@ -1,4 +1,3 @@
-import { canClientCoordinateThread, resolveReconcilerOwnership, } from './coordination.js';
 const DEFAULT_SECRETARY_AGENT = '__secretary__';
 const DEFAULT_ASSISTANT_AGENT = 'primary-agent';
 const DEFAULT_REVIEWER_AGENT = 'ai-reviewer';
@@ -25,27 +24,12 @@ export function reconcileThreadEvent(input) {
         thread: input.thread,
         randomId: input.randomId,
     });
-    const ownership = resolveReconcilerOwnership({
-        policyKind: policy.kind,
-        humanAuthorities: input.humanAuthorities ?? policy.humanAuthorities,
-        humanAuthorityCount: input.humanAuthorityCount ?? policy.humanAuthorityCount,
-        reconcilerOwner: input.reconcilerOwner ?? policy.reconcilerOwner,
-    });
-    const clientCoordinationSkip = resolveClientCoordinationSkip({
-        ownership,
-        input,
-        placement,
-        createdAt,
-    });
-    const jobs = clientCoordinationSkip
-        ? []
-        : selectWakeJobs(policy, event, placement, createdAt, input.randomId, input.client);
+    const jobs = selectWakeJobs(policy, event, placement, createdAt, input.randomId, input.client);
     const notificationEvents = selectNotificationEvents(event, placement, createdAt, input.randomId);
-    const skippedReason = clientCoordinationSkip ?? (jobs.length === 0 ? skipReasonFor(policy, event, input.client) : undefined);
+    const skippedReason = jobs.length === 0 ? skipReasonFor(policy, event, input.client) : undefined;
     return {
         id: createReconcilerId('decision', input.randomId),
         policyKind: policy.kind,
-        reconcilerOwner: ownership.reconcilerOwner,
         event,
         placement,
         wakeJobs: jobs,
@@ -58,7 +42,6 @@ export function summarizeReconcileDecision(decision) {
     return {
         id: decision.id,
         policyKind: decision.policyKind,
-        reconcilerOwner: decision.reconcilerOwner,
         eventType: decision.event.type,
         thread: decision.placement.thread,
         ...(decision.placement.chat ? { chat: decision.placement.chat } : {}),
@@ -137,27 +120,6 @@ export function resolveThreadPlacement(input) {
         kind: 'control',
     };
 }
-function resolveClientCoordinationSkip(input) {
-    if (input.ownership.reconcilerOwner !== 'client') {
-        return undefined;
-    }
-    if (!input.input.requireClientReconcilerLease && !input.input.clientReconcilerLease) {
-        return undefined;
-    }
-    const clientId = input.input.client?.id;
-    if (canClientCoordinateThread({
-        clientId,
-        thread: input.placement.thread,
-        lease: input.input.clientReconcilerLease,
-        now: input.createdAt,
-    })) {
-        return undefined;
-    }
-    const owner = input.input.clientReconcilerLease?.ownerClientId;
-    return owner
-        ? `Client-owned Reconciler is leased by ${owner}; client ${clientId ?? 'unknown'} must not reconcile ${input.placement.thread}.`
-        : `Client-owned Reconciler requires an active client coordinator lease for ${input.placement.thread}.`;
-}
 function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
     if (policy.kind === 'direct') {
         return isUserMessage(event)
@@ -165,7 +127,7 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
                     targetAgent: policy.defaultAssistantAgent ?? DEFAULT_ASSISTANT_AGENT,
                     targetRole: 'primary-agent',
                     priority: 'normal',
-                    reason: 'Single-human assistant surfaces route user messages to the default assistant.',
+                    reason: 'Direct thread routes user messages to the default assistant.',
                     createdAt,
                     randomId,
                 })]
@@ -211,10 +173,10 @@ function selectWakeJobs(policy, event, placement, createdAt, randomId, client) {
             return [createSecretaryWakeJob(policy, event, placement, 'Symphony Delivery submissions wake Secretary for review or routing.', 'normal', createdAt, randomId)];
         }
         if (event.type === 'delivery.completed') {
-            return [createSecretaryWakeJob(policy, event, placement, 'Symphony completion Delivery wakes Secretary for quality, acceptance, and follow-up extraction reconciliation.', 'high', createdAt, randomId)];
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony completion Delivery wakes Secretary for quality and acceptance reconciliation.', 'high', createdAt, randomId)];
         }
         if (event.type === 'delivery.failed') {
-            return [createSecretaryWakeJob(policy, event, placement, 'Symphony failed Delivery wakes Secretary for feasibility, retry, scope change, or follow-up extraction reconciliation.', 'high', createdAt, randomId)];
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony failed Delivery wakes Secretary for feasibility, retry, or scope change reconciliation.', 'high', createdAt, randomId)];
         }
         if (event.type === 'issue.updated' || event.type === 'task.updated' || event.type === 'run.updated') {
             return [createSecretaryWakeJob(policy, event, placement, 'Symphony state changes wake Secretary to reconcile system state.', 'normal', createdAt, randomId)];

package/vendor/agent-runtime/dist/symphony.d.ts

@@ -1,44 +1,79 @@
 import type { AutoModeMode, AutoModeWorkerBackend } from './auto-mode.js';
-import { type ReconcileDecision, type ReconcileDecisionSummary } from './reconciler.js';
+import { type ReconcileDecision, type ReconcileDecisionSummary, type ReconcilerActorRef, type ReconcilerClientContext, type ReconcilerEventType, type ReconcilerNotificationEvent, type ThreadPolicy, type ThreadPolicyKind, type WakeJobSummary } from './reconciler.js';
+import type { AgentWorkspace, AgentWorkspaceEnvironment, AgentWorkspaceKind } from './workspace.js';
 export declare const SYMPHONY_HOME_DIRNAME = "symphony";
 export declare const SYMPHONY_IDEAS_DIRNAME = "ideas";
 export declare const SYMPHONY_ISSUES_DIRNAME = "issues";
 export declare const SYMPHONY_TASKS_DIRNAME = "tasks";
 export declare const SYMPHONY_DELIVERIES_DIRNAME = "deliveries";
 export declare const SYMPHONY_SESSIONS_DIRNAME = "sessions";
+export declare const SYMPHONY_RUN_STEPS_DIRNAME = "run-steps";
 export declare const SYMPHONY_IDEA_FILE_NAME = "idea.json";
 export declare const SYMPHONY_ISSUE_FILE_NAME = "issue.json";
 export declare const SYMPHONY_TASK_FILE_NAME = "task.json";
 export declare const SYMPHONY_DELIVERY_FILE_NAME = "delivery.json";
 export declare const SYMPHONY_SESSION_FILE_NAME = "session.json";
-export type WorkerWorkspaceKind = 'git' | 'folder';
+export declare const SYMPHONY_RUN_STEP_FILE_NAME = "run-step.json";
+export type WorkerWorkspaceKind = AgentWorkspaceKind;
 export type SymphonyIdeaStatus = 'captured' | 'exploring' | 'candidate' | 'promoted' | 'deferred' | 'rejected' | 'superseded';
 export type SymphonyIdeaCommitment = 'thought' | 'direction' | 'tentative_decision' | 'committed';
 export type SymphonyIssueStatus = 'open' | 'triaging' | 'in_progress' | 'blocked' | 'resolved' | 'closed';
-export type SymphonyTaskStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type SymphonyTaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'blocked';
 export type SymphonyDeliveryStatus = 'pending' | 'dispatched' | 'completed' | 'failed';
 export type SymphonySessionStatus = 'planned' | 'running' | 'completed' | 'failed';
 export type SymphonyProjectionRole = 'user' | 'system' | 'tool';
-export type SymphonyResourceKind = 'idea' | 'issue' | 'task' | 'delivery' | 'session';
+export type SymphonyResourceKind = 'idea' | 'issue' | 'task' | 'delivery' | 'session' | 'runStep';
+export type SymphonyRuntimeEventType = 'session.started' | 'session.resumed' | 'run.started' | 'run.step' | 'approval.required' | 'input.required' | 'worker.blocked' | 'delivery.submitted' | 'delivery.completed' | 'delivery.failed' | 'run.completed' | 'run.failed';
+export type SymphonyFollowUpCandidateKind = 'new_defect' | 'missing_shared_abstraction' | 'app_local_glue' | 'models_gap' | 'orm_gap' | 'runtime_api_gap' | 'shared_runtime_utility' | 'test_harness' | 'live_verification_gap' | 'documentation' | 'cleanup' | 'other';
+export type SymphonyFollowUpDisposition = 'same_issue_task' | 'new_issue' | 'idea' | 'evidence_only' | 'ask_user';
+export type SymphonyAcceptanceOutcome = 'accepted' | 'rejected' | 'blocked' | 'follow_up';
+export type SymphonyRecordSource = 'cli' | 'web' | 'service' | 'tui' | 'mcp' | 'runtime' | 'control-plane';
 export interface SymphonyReconcilerState {
     decisions: ReconcileDecisionSummary[];
 }
-export interface WorkerWorkspaceRef {
-    path: string;
-    kind: WorkerWorkspaceKind;
-    repository?: string;
-    branch?: string;
-    worktree?: string;
-    workspace?: string;
-    baseRevision?: string;
-    environment?: SymphonyWorkerEnvironmentRef;
-}
-export interface SymphonyWorkerEnvironmentRef {
-    kind: 'local-shell' | 'remote-container' | 'cloud-runner' | 'backend-runtime' | 'unknown';
+export type SymphonyThreadReconcilerNextAction = 'noop' | 'wake_secretary' | 'wake_worker' | 'wake_reviewer' | 'notify_user';
+export interface SymphonyThreadReconcileEventInput {
     id?: string;
-    label?: string;
-    runtime?: AutoModeWorkerBackend | string;
+    type?: ReconcilerEventType;
+    eventType?: ReconcilerEventType;
+    chat?: string;
+    thread?: string;
+    resource?: string;
+    actor?: ReconcilerActorRef;
+    content?: string;
+    message?: string;
+    createdAt?: string;
+    data?: Record<string, unknown>;
+    symphonyHookEvent?: boolean;
+    hookEventName?: string;
+    sessionId?: string;
+    source?: string;
+    [key: string]: unknown;
+}
+export interface ReconcileSymphonyThreadEventsInput {
+    policy?: ThreadPolicyKind | ThreadPolicy;
+    chat?: string;
+    thread?: string;
+    randomId?: string;
+    now?: Date | string;
+    client?: ReconcilerClientContext;
+    events?: SymphonyThreadReconcileEventInput[];
+}
+export interface ReconcileSymphonyThreadEventsResult {
+    policyKind: ThreadPolicyKind;
+    chat?: string;
+    thread: string;
+    eventCount: number;
+    decisions: ReconcileDecisionSummary[];
+    wakeJobs: WakeJobSummary[];
+    notificationEvents: ReconcilerNotificationEvent[];
+    nextAction: SymphonyThreadReconcilerNextAction;
+    summary: string;
 }
+export type WorkerWorkspace = AgentWorkspace & {
+    path: string;
+};
+export type WorkerEnvironment = AgentWorkspaceEnvironment;
 export interface SymphonySupervisorPolicy {
     strategy: 'interval';
     intervalMs: number;
@@ -59,7 +94,6 @@ export type SymphonyDelegationTargetSource = 'active-session' | 'group-chat' | '
 export interface SymphonyDelegationTarget extends SymphonyChatThreadRef {
     source: SymphonyDelegationTargetSource;
     backend: AutoModeWorkerBackend;
-    contact?: string;
     agent?: string;
     label?: string;
 }
@@ -69,7 +103,7 @@ export interface SymphonyIdeaRecord extends SymphonyChatThreadRef {
     input?: string;
     status: SymphonyIdeaStatus;
     commitment: SymphonyIdeaCommitment;
-    source: 'cli';
+    source: SymphonyRecordSource;
     affectedArea?: string;
     currentUnderstanding?: string;
     openQuestions: string[];
@@ -86,8 +120,10 @@ export interface SymphonyIssueRecord extends SymphonyChatThreadRef {
     description?: string;
     status: SymphonyIssueStatus;
     priority: 'low' | 'medium' | 'high' | 'urgent';
-    source: 'cli';
+    source: SymphonyRecordSource;
     issuer: SymphonyIssuerRef;
+    parentIssue?: string;
+    labels?: string[];
     tasks: string[];
     deliveries: string[];
     sessions: string[];
@@ -105,10 +141,10 @@ export interface SymphonyTaskRecord extends SymphonyChatThreadRef {
     status: SymphonyTaskStatus;
     target: SymphonyDelegationTarget;
     backend: AutoModeWorkerBackend;
-    contact?: string;
     agent?: string;
     delivery: string;
     session: string;
+    acceptanceReview?: SymphonyAcceptanceReview;
     reconciler?: SymphonyReconcilerState;
     createdAt: string;
     updatedAt: string;
@@ -131,6 +167,7 @@ export interface SymphonyDeliveryRecord extends SymphonyChatThreadRef {
     };
     session?: string;
     autoModeSessionId?: string;
+    acceptanceReview?: SymphonyAcceptanceReview;
     reconciler?: SymphonyReconcilerState;
     createdAt: string;
     updatedAt: string;
@@ -147,13 +184,14 @@ export interface SymphonySessionRecord extends SymphonyChatThreadRef {
     secretaryAutoEnabled?: boolean;
     status: SymphonySessionStatus;
     cwd: string;
-    workspaceRef?: WorkerWorkspaceRef;
+    workspace?: WorkerWorkspace;
     target: SymphonyDelegationTarget;
     model?: string;
     supervisor?: SymphonySupervisorPolicy;
     autoModeSessionId?: string;
     dryRun?: boolean;
     exitCode?: number | null;
+    acceptanceReview?: SymphonyAcceptanceReview;
     reconciler?: SymphonyReconcilerState;
     createdAt: string;
     updatedAt: string;
@@ -167,12 +205,25 @@ export interface SymphonyRunPlan {
     delivery: SymphonyDeliveryRecord;
     session: SymphonySessionRecord;
     workers: SymphonyWorkerPlan[];
+    followUpIssues?: SymphonyIssueRecord[];
 }
 export interface SymphonyWorkerPlan {
     task: string;
     taskRecord: SymphonyTaskRecord;
     delivery: SymphonyDeliveryRecord;
     session: SymphonySessionRecord;
+    runSteps?: SymphonyRunStepRecord[];
+}
+export interface SymphonyRunStepRecord {
+    uri: string;
+    issue: string;
+    task: string;
+    delivery: string;
+    session: string;
+    stepType: SymphonyRuntimeEventType;
+    message: string;
+    payload?: Record<string, unknown>;
+    createdAt: string;
 }
 export interface SymphonyWorkerSpec extends Partial<SymphonyDelegationTarget> {
     title?: string;
@@ -180,10 +231,172 @@ export interface SymphonyWorkerSpec extends Partial<SymphonyDelegationTarget> {
     acceptanceCriteria?: string[];
     model?: string;
     supervisorIntervalMs?: number;
-    workspace?: Partial<WorkerWorkspaceRef>;
+    workspace?: Partial<WorkerWorkspace>;
+}
+export interface SymphonyFollowUpCandidate {
+    kind: SymphonyFollowUpCandidateKind;
+    summary: string;
+    evidence?: string[];
+    suggestedDisposition?: SymphonyFollowUpDisposition;
+    reason?: string;
+    requiredBeforeAcceptance?: boolean;
+    userDecisionRequired?: boolean;
+    targetPackage?: string;
+}
+export interface SymphonyClassifiedFollowUp extends SymphonyFollowUpCandidate {
+    disposition: SymphonyFollowUpDisposition;
+    reason: string;
+    source: 'worker_report' | 'secretary_inference';
+    issue?: string;
+}
+export interface SymphonyReusableExtractionDecision {
+    disposition: SymphonyFollowUpDisposition;
+    reason: string;
+    candidates: SymphonyClassifiedFollowUp[];
+}
+export interface SymphonyImplementationChangeRequest {
+    trigger: 'worker_failed' | 'acceptance_blocked';
+    task: string;
+    delivery: string;
+    session: string;
+    summary: string;
+    failedAssumption: string;
+    evidence: string[];
+    risks: string[];
+    recommendedNextShape: 'retry' | 'split' | 'redesign' | 'defer' | 'reduce_scope' | 'request_authority';
+    basedOnRunSteps: string[];
+    createdAt: string;
+}
+export interface SymphonyFinalReportEnvelope {
+    summary?: string;
+    evidence?: string[];
+    risks?: string[];
+    changedFiles?: string[];
+    commands?: string[];
+    followUps?: SymphonyFollowUpCandidate[];
+}
+export interface SymphonyRuntimeDeliveryEvent {
+    stepType: SymphonyRuntimeEventType;
+    message?: string;
+    payload?: Record<string, unknown>;
+    createdAt?: string;
+    randomId?: string;
+}
+export interface SymphonyRuntimeDeliveryResult {
+    status: 'completed' | 'failed';
+    exitCode: number;
+    autoModeSessionId?: string;
+    reportText?: string;
+    events: SymphonyRuntimeDeliveryEvent[];
+}
+export interface SymphonyAcceptanceReview {
+    outcome: SymphonyAcceptanceOutcome;
+    accepted: boolean;
+    reviewedBy: '__secretary__';
+    reviewedAt: string;
+    summary: string;
+    evidence: string[];
+    risks: string[];
+    changedFiles: string[];
+    commands: string[];
+    followUps: SymphonyClassifiedFollowUp[];
+    reusableExtraction: SymphonyReusableExtractionDecision;
+    implementationChangeRequest?: SymphonyImplementationChangeRequest;
+}
+export interface ReconcileSymphonyWorkerDeliveryInput {
+    issue: SymphonyIssueRecord;
+    worker: SymphonyWorkerPlan;
+    status: 'completed' | 'failed';
+    exitCode: number;
+    autoModeSessionId?: string;
+    reportText?: string;
+    now?: Date;
+    randomId?: string;
+}
+export interface ReconcileSymphonyWorkerDeliveryResult {
+    worker: SymphonyWorkerPlan;
+    acceptanceReview: SymphonyAcceptanceReview;
+    followUpIssues: SymphonyIssueRecord[];
+}
+export interface StartSymphonyWorkerRunInput {
+    worker: SymphonyWorkerPlan;
+    decision?: ReconcileDecision | ReconcileDecisionSummary;
+    now?: Date;
+    randomId?: string;
+    message?: string;
+    payload?: Record<string, unknown>;
+}
+export interface RecordSymphonyWorkerRuntimeEventInput {
+    worker: SymphonyWorkerPlan;
+    stepType: SymphonyRuntimeEventType;
+    message?: string;
+    payload?: Record<string, unknown>;
+    now?: Date;
+    randomId?: string;
+}
+export interface CompleteSymphonyWorkerRunInput {
+    issue: SymphonyIssueRecord;
+    worker: SymphonyWorkerPlan;
+    status: 'completed' | 'failed';
+    exitCode: number;
+    autoModeSessionId?: string;
+    reportText?: string;
+    decision?: ReconcileDecision | ReconcileDecisionSummary;
+    now?: Date;
+    randomId?: string;
+}
+export interface CreateSymphonyRunStepInput {
+    worker: SymphonyWorkerPlan;
+    stepType: SymphonyRuntimeEventType;
+    message?: string;
+    payload?: Record<string, unknown>;
+    now?: Date;
+    randomId?: string;
+}
+export interface SymphonyIssueStatusUpdates {
+    error?: string;
+    closedAt?: string;
+    now?: Date | string;
+}
+export interface SymphonyTaskStatusUpdates {
+    error?: string;
+    completedAt?: string;
+    now?: Date | string;
+}
+export interface SymphonyDeliveryStatusUpdates {
+    error?: string;
+    autoModeSessionId?: string;
+    completedAt?: string;
+    now?: Date | string;
+}
+export interface SymphonySessionStatusUpdates {
+    error?: string;
+    autoModeSessionId?: string;
+    exitCode?: number | null;
+    dryRun?: boolean;
+    completedAt?: string;
+    now?: Date | string;
+}
+export interface FinalizeSymphonyRunPlanAfterWorkersInput {
+    plan: SymphonyRunPlan;
+    workers?: SymphonyWorkerPlan[];
+    followUpIssues?: SymphonyIssueRecord[];
+    now?: Date | string;
+}
+export interface FinalizeSymphonyRunPlanAfterWorkersResult {
+    plan: SymphonyRunPlan;
+    status: 'completed' | 'failed';
+    issueStatus: 'resolved' | 'blocked';
+    blocker?: {
+        kind: 'worker_failure' | 'acceptance';
+        error: string;
+        exitCode?: number;
+        worker: SymphonyWorkerPlan;
+    };
 }
 export interface CreateSymphonyRunPlanInput {
     objective: string;
+    source?: SymphonyRecordSource;
     title?: string;
     acceptanceCriteria?: string[];
     workspacePath: string;
@@ -191,9 +404,9 @@ export interface CreateSymphonyRunPlanInput {
     repository?: string;
     branch?: string;
     worktree?: string;
-    workspace?: string;
+    container?: string;
     baseRevision?: string;
-    environment?: Partial<SymphonyWorkerEnvironmentRef>;
+    environment?: Partial<WorkerEnvironment>;
     backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
     secretaryAutoEnabled?: boolean;
@@ -229,6 +442,10 @@ export declare function createSymphonySessionUri(options?: {
     now?: Date;
     randomId?: string;
 }): string;
+export declare function createSymphonyRunStepUri(options?: {
+    now?: Date;
+    randomId?: string;
+}): string;
 export declare function getSymphonyArchiveRelativePaths(uri: string, kind: SymphonyResourceKind): {
     dir: string;
     file: string;
@@ -237,12 +454,40 @@ export declare function createRunPlan(input: CreateSymphonyRunPlanInput): Sympho
 export declare function appendSymphonyReconcilerDecision<T extends {
     reconciler?: SymphonyReconcilerState;
 }>(record: T, decision: ReconcileDecision | ReconcileDecisionSummary): T;
+export declare function reconcileSymphonyThreadEvents(input: ReconcileSymphonyThreadEventsInput): ReconcileSymphonyThreadEventsResult;
+export declare function withSymphonyIssueStatus(record: SymphonyIssueRecord, status: SymphonyIssueStatus, updates?: SymphonyIssueStatusUpdates): SymphonyIssueRecord;
+export declare function withSymphonyTaskStatus(record: SymphonyTaskRecord, status: SymphonyTaskStatus, updates?: SymphonyTaskStatusUpdates): SymphonyTaskRecord;
+export declare function withSymphonyDeliveryStatus(record: SymphonyDeliveryRecord, status: SymphonyDeliveryStatus, updates?: SymphonyDeliveryStatusUpdates): SymphonyDeliveryRecord;
+export declare function withSymphonySessionStatus(record: SymphonySessionRecord, status: SymphonySessionStatus, updates?: SymphonySessionStatusUpdates): SymphonySessionRecord;
+export declare function withSymphonyRunPlanPrimaryWorker(plan: SymphonyRunPlan): SymphonyRunPlan;
+export declare function withSymphonyRunPlanWorker(plan: SymphonyRunPlan, worker: SymphonyWorkerPlan): SymphonyRunPlan;
+export declare function createSymphonyRunStepRecord(input: CreateSymphonyRunStepInput): SymphonyRunStepRecord;
+export declare function withSymphonyWorkerRunStep(worker: SymphonyWorkerPlan, step: SymphonyRunStepRecord): SymphonyWorkerPlan;
+export declare function withSymphonyWorkerRuntimeStep(worker: SymphonyWorkerPlan, input: Omit<CreateSymphonyRunStepInput, 'worker'>): SymphonyWorkerPlan;
+export declare function startSymphonyWorkerRun(input: StartSymphonyWorkerRunInput): SymphonyWorkerPlan;
+export declare function recordSymphonyWorkerRuntimeEvent(input: RecordSymphonyWorkerRuntimeEventInput): SymphonyWorkerPlan;
+export declare function completeSymphonyWorkerRun(input: CompleteSymphonyWorkerRunInput): ReconcileSymphonyWorkerDeliveryResult;
+export declare function finalizeSymphonyRunPlanAfterWorkers(input: FinalizeSymphonyRunPlanAfterWorkersInput): FinalizeSymphonyRunPlanAfterWorkersResult;
+export declare function summarizeSymphonyAcceptanceBlocker(review: SymphonyAcceptanceReview): string;
+export declare function reconcileSymphonyWorkerDelivery(input: ReconcileSymphonyWorkerDeliveryInput): ReconcileSymphonyWorkerDeliveryResult;
+export declare function createSymphonyAcceptanceReview(input: {
+    issue: SymphonyIssueRecord;
+    worker: SymphonyWorkerPlan;
+    status: 'completed' | 'failed';
+    exitCode: number;
+    reportText?: string;
+    now?: Date;
+}): SymphonyAcceptanceReview;
+export declare function classifySymphonyFollowUpCandidate(candidate: SymphonyFollowUpCandidate): SymphonyClassifiedFollowUp;
+export declare function parseSymphonyFinalReportEnvelope(text: string | undefined): SymphonyFinalReportEnvelope | null;
+export declare function parseSymphonyRuntimeDeliveryResult(text: string | undefined): SymphonyRuntimeDeliveryResult | null;
+export declare function normalizeSymphonyRuntimeDeliveryResult(value: unknown): SymphonyRuntimeDeliveryResult | null;
 export declare function renderSymphonyRuntimePrompt(input: {
     issue?: SymphonyIssueRecord;
     task: string;
     objective: string;
     acceptanceCriteria?: string[];
-    workspace: WorkerWorkspaceRef;
+    workspace: WorkerWorkspace;
     backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
     secretaryAutoEnabled?: boolean;