@undefineds.co/linx 0.3.19 → 0.3.22

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.js

@@ -173,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 SymphonyWorkspaceKind = '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 SymphonyWorkspaceRef {
-    path: string;
-    kind: SymphonyWorkspaceKind;
-    repository?: string;
-    branch?: string;
-    worktree?: string;
-    workspaceUri?: 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;
-    workspace?: SymphonyWorkspaceRef;
+    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,20 +231,182 @@ export interface SymphonyWorkerSpec extends Partial<SymphonyDelegationTarget> {
     acceptanceCriteria?: string[];
     model?: string;
     supervisorIntervalMs?: number;
-    workspace?: Partial<SymphonyWorkspaceRef>;
+    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;
-    workspaceKind?: SymphonyWorkspaceKind;
+    workspaceKind?: WorkerWorkspaceKind;
     repository?: string;
     branch?: string;
     worktree?: string;
-    workspaceUri?: 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: SymphonyWorkspaceRef;
+    workspace: WorkerWorkspace;
     backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
     secretaryAutoEnabled?: boolean;