@undefineds.co/linx 0.3.5 → 0.3.7

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

@@ -0,0 +1,361 @@
+const DEFAULT_SECRETARY_AGENT = '__secretary__';
+const DEFAULT_ASSISTANT_AGENT = 'primary-agent';
+const DEFAULT_REVIEWER_AGENT = 'ai-reviewer';
+export function createThreadReconciler(policy) {
+    const normalized = normalizeThreadPolicy(policy);
+    return {
+        policy: normalized,
+        reconcile(event, options = {}) {
+            return reconcileThreadEvent({
+                ...options,
+                policy: normalized,
+                event,
+            });
+        },
+    };
+}
+export function reconcileThreadEvent(input) {
+    const policy = normalizeThreadPolicy(input.policy);
+    const createdAt = (input.now ?? new Date()).toISOString();
+    const event = normalizeThreadEvent(input.event, input, createdAt);
+    const placement = resolveThreadPlacement({
+        event,
+        chat: input.chat,
+        thread: input.thread,
+        randomId: input.randomId,
+    });
+    const jobs = selectWakeJobs(policy, event, placement, createdAt, input.randomId);
+    const skippedReason = jobs.length === 0 ? skipReasonFor(policy, event) : undefined;
+    return {
+        id: createReconcilerId('decision', input.randomId),
+        policyKind: policy.kind,
+        event,
+        placement,
+        wakeJobs: jobs,
+        ...(skippedReason ? { skippedReason } : {}),
+        createdAt,
+    };
+}
+export function summarizeReconcileDecision(decision) {
+    return {
+        id: decision.id,
+        policyKind: decision.policyKind,
+        eventType: decision.event.type,
+        thread: decision.placement.thread,
+        ...(decision.placement.chat ? { chat: decision.placement.chat } : {}),
+        ...(decision.skippedReason ? { skippedReason: decision.skippedReason } : {}),
+        wakeJobs: decision.wakeJobs.map((job) => ({
+            id: job.id,
+            thread: job.thread,
+            ...(job.chat ? { chat: job.chat } : {}),
+            targetAgent: job.targetAgent,
+            targetRole: job.targetRole,
+            trigger: job.trigger,
+            priority: job.priority,
+            status: job.status,
+            reason: job.reason,
+            ...(job.sourceEventId ? { sourceEventId: job.sourceEventId } : {}),
+            sourceEventType: job.sourceEventType,
+            ...(decision.event.resource ? { sourceResource: decision.event.resource } : {}),
+            ...(resolveControlGate(decision.event) ? { controlGate: resolveControlGate(decision.event) } : {}),
+        })),
+        createdAt: decision.createdAt,
+    };
+}
+export function resolveThreadPlacement(input) {
+    const chat = normalizeText(input.event.chat) ?? normalizeText(input.chat);
+    const explicitThread = normalizeText(input.event.thread) ?? normalizeText(input.thread);
+    if (input.event.type === 'schedule.tick') {
+        const scheduleId = normalizeText(input.event.resource)
+            ?? normalizeText(input.event.data?.schedule)
+            ?? normalizeText(input.event.data?.scheduleId)
+            ?? normalizeText(input.event.id)
+            ?? normalizeText(input.randomId)
+            ?? 'default';
+        const scheduleThread = explicitThread ?? createSyntheticThreadUri('schedule', scheduleId);
+        const shouldSplit = input.event.data?.splitThread === true
+            || input.event.data?.longRunning === true
+            || input.event.data?.noisy === true
+            || input.event.data?.needsReview === true
+            || input.event.data?.workerOwned === true;
+        if (shouldSplit) {
+            return {
+                ...(chat ? { chat } : {}),
+                thread: createSyntheticThreadUri('schedule-run', `${scheduleId}-${input.randomId ?? input.event.id ?? 'tick'}`),
+                kind: 'schedule_run',
+                parentThread: scheduleThread,
+                rootThread: scheduleThread,
+                splitFrom: scheduleThread,
+                splitReason: normalizeText(input.event.data?.splitReason) ?? 'schedule tick needs an execution thread',
+            };
+        }
+        return {
+            ...(chat ? { chat } : {}),
+            thread: scheduleThread,
+            kind: 'schedule',
+        };
+    }
+    if (explicitThread) {
+        return {
+            ...(chat ? { chat } : {}),
+            thread: explicitThread,
+            kind: threadKindFromEvent(input.event),
+        };
+    }
+    if (chat) {
+        return {
+            chat,
+            thread: createSyntheticThreadUri('control', chat),
+            kind: 'control',
+        };
+    }
+    return {
+        thread: 'urn:undefineds:linx:thread:system-control',
+        kind: 'control',
+    };
+}
+function selectWakeJobs(policy, event, placement, createdAt, randomId) {
+    if (policy.kind === 'direct') {
+        return isUserMessage(event)
+            ? [createWakeJob(policy, event, placement, {
+                    targetAgent: policy.defaultAssistantAgent ?? DEFAULT_ASSISTANT_AGENT,
+                    targetRole: 'primary-agent',
+                    priority: 'normal',
+                    reason: 'Direct thread routes user messages to the default assistant.',
+                    createdAt,
+                    randomId,
+                })]
+            : [];
+    }
+    if (policy.kind === 'auto') {
+        if (isInputApprovalOrBlocker(event)) {
+            return [createSecretaryWakeJob(policy, event, placement, 'Auto mode routes input, approval, and blocker events to the same-Thread Secretary.', 'high', createdAt, randomId)];
+        }
+        if (isUserMessage(event)) {
+            return [createSecretaryWakeJob(policy, event, placement, 'Auto mode routes user messages and steering input to the same-Thread Secretary before runtime projection.', 'normal', createdAt, randomId)];
+        }
+        if (isPrimaryAgentMessage(event)) {
+            return [createSecretaryWakeJob(policy, event, placement, 'Auto mode treats the latest backend message as a candidate next user-input slot.', 'normal', createdAt, randomId)];
+        }
+        return [];
+    }
+    if (policy.kind === 'symphony') {
+        if (isInputApprovalOrBlocker(event) || event.type === 'change.requested') {
+            return [createSecretaryWakeJob(policy, event, placement, 'Symphony routes blocker, input, approval, and change requests to Secretary for semantic judgment.', 'high', createdAt, randomId)];
+        }
+        if (event.type === 'delivery.submitted') {
+            if (isTaskDispatchDelivery(event) && policy.assignedWorkerAgent) {
+                return [createWakeJob(policy, event, placement, {
+                        targetAgent: policy.assignedWorkerAgent,
+                        targetRole: 'worker',
+                        priority: 'normal',
+                        reason: 'Symphony task-dispatch Delivery wakes the assigned worker through the scheduler.',
+                        createdAt,
+                        randomId,
+                    })];
+            }
+            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 and acceptance reconciliation.', 'high', createdAt, randomId)];
+        }
+        if (event.type === 'delivery.failed') {
+            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)];
+        }
+        if (event.type === 'schedule.tick') {
+            return [createSecretaryWakeJob(policy, event, placement, 'Schedule ticks are Thread events; Symphony wakes Secretary to decide whether to keep, split, or dispatch work.', 'normal', createdAt, randomId)];
+        }
+        return [];
+    }
+    if (policy.kind === 'open_group') {
+        const targets = resolveOpenGroupTargets(policy, event);
+        return targets.map((agent, index) => createWakeJob(policy, event, placement, {
+            targetAgent: agent.id,
+            targetRole: agent.role ?? 'primary-agent',
+            priority: 'normal',
+            reason: agent.subscribed ? 'Open group policy wakes a subscribed agent.' : 'Open group policy wakes a mentioned agent.',
+            createdAt,
+            randomId: `${randomId ?? event.id ?? 'event'}-${index + 1}`,
+        }));
+    }
+    if (policy.kind === 'review') {
+        if (event.type === 'delivery.submitted' || event.type === 'delivery.completed' || event.type === 'delivery.failed') {
+            const reviewer = policy.reviewerAgent ?? policy.secretaryAgent ?? DEFAULT_REVIEWER_AGENT;
+            return [createWakeJob(policy, event, placement, {
+                    targetAgent: reviewer,
+                    targetRole: policy.reviewerAgent ? 'reviewer' : 'secretary',
+                    priority: event.type === 'delivery.failed' ? 'high' : 'normal',
+                    reason: 'Review policy routes Delivery boundaries to reviewer or Secretary.',
+                    createdAt,
+                    randomId,
+                })];
+        }
+        return [];
+    }
+    return [];
+}
+function createSecretaryWakeJob(policy, event, placement, reason, priority, createdAt, randomId) {
+    return createWakeJob(policy, event, placement, {
+        targetAgent: policy.secretaryAgent ?? DEFAULT_SECRETARY_AGENT,
+        targetRole: 'secretary',
+        priority,
+        reason,
+        createdAt,
+        randomId,
+    });
+}
+function createWakeJob(_policy, event, placement, input) {
+    return {
+        id: createReconcilerId('wake', input.randomId ?? event.id),
+        thread: placement.thread,
+        ...(placement.chat ? { chat: placement.chat } : {}),
+        targetAgent: input.targetAgent,
+        targetRole: input.targetRole,
+        trigger: event.type,
+        priority: input.priority,
+        status: 'queued',
+        reason: input.reason,
+        ...(event.id ? { sourceEventId: event.id } : {}),
+        sourceEventType: event.type,
+        createdAt: input.createdAt,
+    };
+}
+function normalizeThreadPolicy(policy) {
+    return typeof policy === 'string' ? { kind: policy } : policy;
+}
+function normalizeThreadEvent(event, input, createdAt) {
+    return {
+        ...event,
+        ...(event.chat ?? input.chat ? { chat: event.chat ?? input.chat } : {}),
+        ...(event.thread ?? input.thread ? { thread: event.thread ?? input.thread } : {}),
+        id: event.id ?? createReconcilerId('event', input.randomId),
+        createdAt: event.createdAt ?? createdAt,
+    };
+}
+function threadKindFromEvent(event) {
+    if (event.type === 'delivery.submitted' || event.type === 'delivery.completed' || event.type === 'delivery.failed') {
+        return 'worker';
+    }
+    if (event.type === 'schedule.tick') {
+        return 'schedule';
+    }
+    if (event.type === 'issue.updated' || event.type === 'task.updated' || event.type === 'run.updated') {
+        return 'control';
+    }
+    return 'main';
+}
+function isInputApprovalOrBlocker(event) {
+    return event.type === 'input.required' || event.type === 'approval.required' || event.type === 'worker.blocked';
+}
+function resolveControlGate(event) {
+    if (event.type === 'input.required' || event.type === 'approval.required') {
+        return 'authority';
+    }
+    if (event.type === 'worker.blocked') {
+        return 'feasibility';
+    }
+    if (event.type === 'change.requested') {
+        return 'change';
+    }
+    if (event.type === 'delivery.completed') {
+        return 'quality';
+    }
+    if (event.type === 'delivery.failed') {
+        return 'feasibility';
+    }
+    if (event.type === 'issue.updated' || event.type === 'task.updated' || event.type === 'run.updated') {
+        return 'binding';
+    }
+    if (event.type === 'schedule.tick') {
+        return 'binding';
+    }
+    return undefined;
+}
+function isUserMessage(event) {
+    return event.type === 'message.appended'
+        && (event.actor?.role === 'user' || event.data?.role === 'user');
+}
+function isPrimaryAgentMessage(event) {
+    if (event.actor?.role === 'secretary') {
+        return false;
+    }
+    return event.type === 'message.appended'
+        && (event.actor?.role === 'primary-agent'
+            || event.actor?.role === 'assistant'
+            || event.actor?.role === 'worker'
+            || event.actor?.role === 'runtime'
+            || event.data?.role === 'assistant'
+            || event.data?.source === 'primary-agent');
+}
+function isTaskDispatchDelivery(event) {
+    return event.data?.deliveryType === 'task_dispatch'
+        || event.data?.type === 'task_dispatch'
+        || event.data?.dispatch === true;
+}
+function resolveOpenGroupTargets(policy, event) {
+    const agents = policy.agents ?? [];
+    const explicit = normalizeStringArray(event.data?.mentions);
+    const mentioned = explicit.length > 0
+        ? agents.filter((agent) => {
+            const aliases = [agent.id, ...(agent.aliases ?? [])].map((item) => item.toLowerCase());
+            return explicit.some((mention) => aliases.includes(mention.toLowerCase()));
+        })
+        : agents.filter((agent) => isMentioned(event.content, agent));
+    const subscribed = agents.filter((agent) => {
+        if (!agent.subscribed) {
+            return false;
+        }
+        return !mentioned.some((item) => item.id === agent.id);
+    });
+    const subscribedIds = new Set(policy.subscribedAgents ?? []);
+    const policySubscribed = agents.filter((agent) => {
+        if (!subscribedIds.has(agent.id)) {
+            return false;
+        }
+        return !mentioned.some((item) => item.id === agent.id) && !subscribed.some((item) => item.id === agent.id);
+    });
+    return [...mentioned, ...subscribed, ...policySubscribed];
+}
+function isMentioned(content, agent) {
+    if (!content) {
+        return false;
+    }
+    const normalized = content.toLowerCase();
+    return [agent.id, ...(agent.aliases ?? [])]
+        .filter(Boolean)
+        .some((name) => normalized.includes(`@${name.toLowerCase()}`));
+}
+function skipReasonFor(policy, event) {
+    if (policy.kind === 'open_group') {
+        return 'No mentioned or subscribed agents matched the event.';
+    }
+    return `Policy ${policy.kind} does not wake an agent for ${event.type}.`;
+}
+function createSyntheticThreadUri(kind, value) {
+    return `urn:undefineds:linx:thread:${kind}:${safeUriSegment(value)}`;
+}
+function createReconcilerId(prefix, randomId) {
+    const suffix = normalizeText(randomId)
+        ?? globalThis.crypto?.randomUUID?.()
+        ?? Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+    return `${prefix}_${safeUriSegment(suffix)}`;
+}
+function normalizeText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeStringArray(value) {
+    return Array.isArray(value)
+        ? value.map((item) => normalizeText(item)).filter((item) => Boolean(item))
+        : [];
+}
+function safeUriSegment(value) {
+    const normalized = value
+        .replace(/[^a-zA-Z0-9._:-]/gu, '-')
+        .replace(/-+/gu, '-')
+        .replace(/^-|-$/gu, '')
+        .slice(0, 160);
+    return normalized || 'unknown';
+}

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

@@ -1,29 +1,84 @@
-import type { AutoModeBackend, AutoModeMode } from './auto-mode.js';
+import type { AutoModeMode, AutoModeWorkerBackend } from './auto-mode.js';
+import { type ReconcileDecision, type ReconcileDecisionSummary } from './reconciler.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_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 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 SymphonyDeliveryStatus = 'pending' | 'dispatched' | 'completed' | 'failed';
 export type SymphonySessionStatus = 'planned' | 'running' | 'completed' | 'failed';
 export type SymphonyProjectionRole = 'user' | 'system' | 'tool';
-export type SymphonyResourceKind = 'issue' | 'task' | 'delivery' | 'session';
+export type SymphonyResourceKind = 'idea' | 'issue' | 'task' | 'delivery' | 'session';
+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';
+    id?: string;
+    label?: string;
+    runtime?: AutoModeWorkerBackend | string;
+}
+export interface SymphonySupervisorPolicy {
+    strategy: 'interval';
+    intervalMs: number;
+    immediateWakeKinds: string[];
+}
+export interface SymphonyIssuerRef extends SymphonyChatThreadRef {
+    source: 'user' | 'secretary' | 'system';
+    webId?: string;
+    agent?: string;
+    label?: string;
 }
 export interface SymphonyChatThreadRef {
     chat?: string;
     thread?: string;
     messages?: string[];
 }
+export type SymphonyDelegationTargetSource = 'active-session' | 'group-chat' | 'ai-contact' | 'explicit-backend' | 'default';
+export interface SymphonyDelegationTarget extends SymphonyChatThreadRef {
+    source: SymphonyDelegationTargetSource;
+    backend: AutoModeWorkerBackend;
+    agent?: string;
+    label?: string;
+}
+export interface SymphonyIdeaRecord extends SymphonyChatThreadRef {
+    uri: string;
+    summary: string;
+    input?: string;
+    status: SymphonyIdeaStatus;
+    commitment: SymphonyIdeaCommitment;
+    source: 'cli';
+    affectedArea?: string;
+    currentUnderstanding?: string;
+    openQuestions: string[];
+    relatedRecords: string[];
+    conflicts: string[];
+    nextStep?: string;
+    promotedTo?: string;
+    createdAt: string;
+    updatedAt: string;
+}
 export interface SymphonyIssueRecord extends SymphonyChatThreadRef {
     uri: string;
     title: string;
@@ -31,27 +86,50 @@ export interface SymphonyIssueRecord extends SymphonyChatThreadRef {
     status: SymphonyIssueStatus;
     priority: 'low' | 'medium' | 'high' | 'urgent';
     source: 'cli';
+    issuer: SymphonyIssuerRef;
     tasks: string[];
+    deliveries: string[];
+    sessions: string[];
     createdAt: string;
     updatedAt: string;
     closedAt?: string;
     error?: string;
 }
+export interface SymphonyTaskRecord extends SymphonyChatThreadRef {
+    uri: string;
+    issue: string;
+    title: string;
+    objective: string;
+    acceptanceCriteria: string[];
+    status: SymphonyTaskStatus;
+    target: SymphonyDelegationTarget;
+    backend: AutoModeWorkerBackend;
+    agent?: string;
+    delivery: string;
+    session: string;
+    reconciler?: SymphonyReconcilerState;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    error?: string;
+}
 export interface SymphonyDeliveryRecord extends SymphonyChatThreadRef {
     uri: string;
     issue: string;
     task: string;
     type: 'task_dispatch';
     status: SymphonyDeliveryStatus;
-    sourceAgent: 'ai-secretary';
-    targetBackend: AutoModeBackend;
+    sourceAgent: '__secretary__';
+    targetBackend: AutoModeWorkerBackend;
     targetAgent: string;
+    target: SymphonyDelegationTarget;
     projection: {
         runtimeRole: SymphonyProjectionRole;
         prompt: string;
     };
     session?: string;
     autoModeSessionId?: string;
+    reconciler?: SymphonyReconcilerState;
     createdAt: string;
     updatedAt: string;
     completedAt?: string;
@@ -62,14 +140,19 @@ export interface SymphonySessionRecord extends SymphonyChatThreadRef {
     issue: string;
     task: string;
     delivery: string;
-    backend: AutoModeBackend;
+    backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
+    secretaryAutoEnabled?: boolean;
     status: SymphonySessionStatus;
     cwd: string;
+    workspace?: SymphonyWorkspaceRef;
+    target: SymphonyDelegationTarget;
     model?: string;
+    supervisor?: SymphonySupervisorPolicy;
     autoModeSessionId?: string;
     dryRun?: boolean;
     exitCode?: number | null;
+    reconciler?: SymphonyReconcilerState;
     createdAt: string;
     updatedAt: string;
     completedAt?: string;
@@ -78,9 +161,25 @@ export interface SymphonySessionRecord extends SymphonyChatThreadRef {
 export interface SymphonyRunPlan {
     issue: SymphonyIssueRecord;
     task: string;
+    taskRecord: SymphonyTaskRecord;
+    delivery: SymphonyDeliveryRecord;
+    session: SymphonySessionRecord;
+    workers: SymphonyWorkerPlan[];
+}
+export interface SymphonyWorkerPlan {
+    task: string;
+    taskRecord: SymphonyTaskRecord;
     delivery: SymphonyDeliveryRecord;
     session: SymphonySessionRecord;
 }
+export interface SymphonyWorkerSpec extends Partial<SymphonyDelegationTarget> {
+    title?: string;
+    objective?: string;
+    acceptanceCriteria?: string[];
+    model?: string;
+    supervisorIntervalMs?: number;
+    workspace?: Partial<SymphonyWorkspaceRef>;
+}
 export interface CreateSymphonyRunPlanInput {
     objective: string;
     title?: string;
@@ -90,15 +189,28 @@ export interface CreateSymphonyRunPlanInput {
     repository?: string;
     branch?: string;
     worktree?: string;
-    backend: AutoModeBackend;
+    workspaceUri?: string;
+    baseRevision?: string;
+    environment?: Partial<SymphonyWorkerEnvironmentRef>;
+    backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
+    secretaryAutoEnabled?: boolean;
     model?: string;
+    workerModel?: string;
+    workerSupervisorIntervalMs?: number;
     chat?: string;
     thread?: string;
     messages?: string[];
+    issuer?: Partial<SymphonyIssuerRef>;
+    target?: Partial<SymphonyDelegationTarget>;
+    workers?: SymphonyWorkerSpec[];
     now?: Date;
     randomId?: string;
 }
+export declare function createSymphonyIdeaUri(options?: {
+    now?: Date;
+    randomId?: string;
+}): string;
 export declare function createSymphonyIssueUri(options?: {
     now?: Date;
     randomId?: string;
@@ -115,20 +227,28 @@ export declare function createSymphonySessionUri(options?: {
     now?: Date;
     randomId?: string;
 }): string;
-export declare function getSymphonyArchiveRelativePaths(uri: string, kind: 'issue' | 'delivery' | 'session'): {
+export declare function getSymphonyArchiveRelativePaths(uri: string, kind: SymphonyResourceKind): {
     dir: string;
     file: string;
 };
 export declare function createRunPlan(input: CreateSymphonyRunPlanInput): SymphonyRunPlan;
+export declare function appendSymphonyReconcilerDecision<T extends {
+    reconciler?: SymphonyReconcilerState;
+}>(record: T, decision: ReconcileDecision | ReconcileDecisionSummary): T;
 export declare function renderSymphonyRuntimePrompt(input: {
     issue?: SymphonyIssueRecord;
     task: string;
     objective: string;
     acceptanceCriteria?: string[];
     workspace: SymphonyWorkspaceRef;
-    backend: AutoModeBackend;
+    backend: AutoModeWorkerBackend;
     mode: AutoModeMode;
+    secretaryAutoEnabled?: boolean;
     session: string;
+    target?: SymphonyDelegationTarget;
+    issuer?: SymphonyIssuerRef;
+    workerIndex?: number;
+    workerCount?: number;
 }): string;
 export declare function formatSymphonySessionSummary(session: SymphonySessionRecord): string;
 export declare function formatSymphonyDeliverySummary(delivery: SymphonyDeliveryRecord): string;