@undefineds.co/linx 0.3.5 → 0.3.8

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

@@ -1,11 +1,20 @@
+import { summarizeReconcileDecision } from './reconciler.js';
+import { decideThreadControlEvent } from './thread-reconciler-controller.js';
 export const SYMPHONY_HOME_DIRNAME = 'symphony';
+export const SYMPHONY_IDEAS_DIRNAME = 'ideas';
 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_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';
 const SYMPHONY_URI_PREFIX = 'urn:undefineds:linx';
+export function createSymphonyIdeaUri(options = {}) {
+    return createSymphonyResourceUri('idea', options);
+}
 export function createSymphonyIssueUri(options = {}) {
     return createSymphonyResourceUri('issue', options);
 }
@@ -20,16 +29,22 @@ export function createSymphonySessionUri(options = {}) {
 }
 export function getSymphonyArchiveRelativePaths(uri, kind) {
     const key = getSymphonyArchiveKey(uri);
-    const dirName = kind === 'issue'
-        ? SYMPHONY_ISSUES_DIRNAME
-        : kind === 'delivery'
-            ? SYMPHONY_DELIVERIES_DIRNAME
-            : SYMPHONY_SESSIONS_DIRNAME;
-    const fileName = kind === 'issue'
-        ? SYMPHONY_ISSUE_FILE_NAME
-        : kind === 'delivery'
-            ? SYMPHONY_DELIVERY_FILE_NAME
-            : SYMPHONY_SESSION_FILE_NAME;
+    const dirNameByKind = {
+        idea: SYMPHONY_IDEAS_DIRNAME,
+        issue: SYMPHONY_ISSUES_DIRNAME,
+        task: SYMPHONY_TASKS_DIRNAME,
+        delivery: SYMPHONY_DELIVERIES_DIRNAME,
+        session: SYMPHONY_SESSIONS_DIRNAME,
+    };
+    const fileNameByKind = {
+        idea: SYMPHONY_IDEA_FILE_NAME,
+        issue: SYMPHONY_ISSUE_FILE_NAME,
+        task: SYMPHONY_TASK_FILE_NAME,
+        delivery: SYMPHONY_DELIVERY_FILE_NAME,
+        session: SYMPHONY_SESSION_FILE_NAME,
+    };
+    const dirName = dirNameByKind[kind];
+    const fileName = fileNameByKind[kind];
     return {
         dir: `${dirName}/${key}`,
         file: `${dirName}/${key}/${fileName}`,
@@ -43,18 +58,26 @@ export function createRunPlan(input) {
     const objective = normalizeRequiredText(input.objective, 'objective');
     const title = normalizeOptionalText(input.title) ?? createSymphonyTitle(objective);
     const acceptanceCriteria = normalizeSymphonyAcceptanceCriteria(input.acceptanceCriteria);
-    const chatThread = normalizeSymphonyChatThreadRef(input);
+    const issuer = normalizeSymphonyIssuer(input);
+    const workerSpecs = normalizeSymphonyWorkerSpecs(input);
+    const primaryTarget = workerSpecs[0].target;
+    const chatThread = normalizeSymphonyChatThreadRef({
+        chat: normalizeOptionalText(input.chat) ?? primaryTarget.chat,
+        thread: normalizeOptionalText(input.thread) ?? primaryTarget.thread,
+        messages: input.messages ?? primaryTarget.messages,
+    });
     const workspace = {
         path: normalizeRequiredText(input.workspacePath, 'workspacePath'),
         kind: input.workspaceKind ?? 'folder',
         ...(normalizeOptionalText(input.repository) ? { repository: normalizeOptionalText(input.repository) } : {}),
         ...(normalizeOptionalText(input.branch) ? { branch: normalizeOptionalText(input.branch) } : {}),
         ...(normalizeOptionalText(input.worktree) ? { worktree: normalizeOptionalText(input.worktree) } : {}),
+        ...(normalizeOptionalText(input.workspaceUri) ? { workspaceUri: normalizeOptionalText(input.workspaceUri) } : {}),
+        ...(normalizeOptionalText(input.baseRevision) ? { baseRevision: normalizeOptionalText(input.baseRevision) } : {}),
+        environment: normalizeSymphonyWorkerEnvironment(input.environment, input.backend),
     };
     const issueUri = createSymphonyIssueUri(uriOptions);
-    const taskUri = createTaskUri(uriOptions);
-    const deliveryUri = createSymphonyDeliveryUri(uriOptions);
-    const sessionUri = createSymphonySessionUri(uriOptions);
+    const workerUris = workerSpecs.map((_, index) => createSymphonyWorkerUris(uriOptions, index));
     const issue = {
         uri: issueUri,
         title,
@@ -62,59 +85,139 @@ export function createRunPlan(input) {
         status: 'open',
         priority: 'medium',
         source: 'cli',
-        tasks: [taskUri],
-        ...chatThread,
-        createdAt: timestamp,
-        updatedAt: timestamp,
-    };
-    const session = {
-        uri: sessionUri,
-        issue: issueUri,
-        task: taskUri,
-        delivery: deliveryUri,
-        backend: input.backend,
-        mode: input.mode,
-        status: 'planned',
-        cwd: workspace.path,
-        ...(normalizeOptionalText(input.model) ? { model: normalizeOptionalText(input.model) } : {}),
+        issuer,
+        tasks: workerUris.map((item) => item.task),
+        deliveries: workerUris.map((item) => item.delivery),
+        sessions: workerUris.map((item) => item.session),
         ...chatThread,
         createdAt: timestamp,
         updatedAt: timestamp,
     };
-    const delivery = {
-        uri: deliveryUri,
-        issue: issueUri,
-        task: taskUri,
-        type: 'task_dispatch',
-        status: 'pending',
-        sourceAgent: 'ai-secretary',
-        targetBackend: input.backend,
-        targetAgent: `${input.backend}-worker`,
-        projection: {
-            runtimeRole: 'user',
-            prompt: renderSymphonyRuntimePrompt({
-                issue,
-                task: taskUri,
-                objective,
-                acceptanceCriteria,
-                workspace,
-                backend: input.backend,
-                mode: input.mode,
-                session: sessionUri,
-            }),
+    const workers = workerSpecs.map((spec, index) => {
+        const uris = workerUris[index];
+        const target = spec.target;
+        const workerWorkspace = normalizeSymphonyWorkerWorkspace(workspace, spec.workspace, target.backend);
+        const workerObjective = spec.objective;
+        const workerTitle = spec.title ?? createSymphonyTitle(workerObjective);
+        const workerAcceptanceCriteria = spec.acceptanceCriteria.length > 0
+            ? spec.acceptanceCriteria
+            : acceptanceCriteria;
+        const workerChatThread = normalizeSymphonyChatThreadRef({
+            chat: target.chat ?? chatThread.chat,
+            thread: target.thread ?? chatThread.thread,
+            messages: target.messages ?? chatThread.messages,
+        });
+        const targetAgent = target.agent ?? `${target.backend}-worker`;
+        const dispatchReconciler = createSymphonyDispatchReconcilerState({
+            issue: issueUri,
+            task: uris.task,
+            delivery: uris.delivery,
+            session: uris.session,
+            chat: workerChatThread.chat,
+            thread: workerChatThread.thread,
+            targetAgent,
+            now,
+            randomId: `${randomId}-w${index + 1}-dispatch`,
+        });
+        const taskRecord = {
+            uri: uris.task,
+            issue: issueUri,
+            title: workerTitle,
+            objective: workerObjective,
+            acceptanceCriteria: workerAcceptanceCriteria,
+            status: 'pending',
+            target,
+            backend: target.backend,
+            ...(target.agent ? { agent: target.agent } : {}),
+            delivery: uris.delivery,
+            session: uris.session,
+            reconciler: dispatchReconciler,
+            ...workerChatThread,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        const session = {
+            uri: uris.session,
+            issue: issueUri,
+            task: uris.task,
+            delivery: uris.delivery,
+            backend: target.backend,
+            mode: input.mode,
+            ...(input.secretaryAutoEnabled !== undefined ? { secretaryAutoEnabled: input.secretaryAutoEnabled } : {}),
+            status: 'planned',
+            cwd: workerWorkspace.path,
+            workspace: workerWorkspace,
+            target,
+            ...(spec.model ? { model: spec.model } : {}),
+            ...(spec.supervisor ? { supervisor: spec.supervisor } : {}),
+            reconciler: dispatchReconciler,
+            ...workerChatThread,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        const delivery = {
+            uri: uris.delivery,
+            issue: issueUri,
+            task: uris.task,
+            type: 'task_dispatch',
+            status: 'pending',
+            sourceAgent: '__secretary__',
+            targetBackend: target.backend,
+            targetAgent,
+            target,
+            projection: {
+                runtimeRole: 'user',
+                prompt: renderSymphonyRuntimePrompt({
+                    issue,
+                    task: uris.task,
+                    objective: workerObjective,
+                    acceptanceCriteria: workerAcceptanceCriteria,
+                    workspace: workerWorkspace,
+                    backend: target.backend,
+                    mode: input.mode,
+                    secretaryAutoEnabled: input.secretaryAutoEnabled,
+                    session: uris.session,
+                    target,
+                    issuer,
+                    workerIndex: index + 1,
+                    workerCount: workerSpecs.length,
+                }),
+            },
+            session: uris.session,
+            reconciler: dispatchReconciler,
+            ...workerChatThread,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        return { task: uris.task, taskRecord, delivery, session };
+    });
+    const primary = workers[0];
+    return { issue, task: primary.task, taskRecord: primary.taskRecord, delivery: primary.delivery, session: primary.session, workers };
+}
+export function appendSymphonyReconcilerDecision(record, decision) {
+    const summary = isReconcileDecisionSummary(decision)
+        ? decision
+        : summarizeReconcileDecision(decision);
+    return {
+        ...record,
+        reconciler: {
+            decisions: [
+                ...(record.reconciler?.decisions ?? []),
+                summary,
+            ],
         },
-        session: sessionUri,
-        ...chatThread,
-        createdAt: timestamp,
-        updatedAt: timestamp,
     };
-    return { issue, task: taskUri, delivery, session };
 }
 export function renderSymphonyRuntimePrompt(input) {
     const acceptanceCriteria = normalizeSymphonyAcceptanceCriteria(input.acceptanceCriteria);
     const criteria = acceptanceCriteria.length > 0
         ? acceptanceCriteria.map((item, index) => `${index + 1}. ${item}`).join('\n')
-        : '1. Complete the objective and report concrete verification evidence.';
+        : [
+            '1. Infer concrete acceptance criteria from the delegated objective, source context, and repository state.',
+            '2. If the objective cannot be made testable without a user decision, report the blocker to AI Secretary instead of guessing.',
+            '3. Otherwise complete the objective and report concrete verification evidence.',
+        ].join('\n');
+    const workThread = normalizeOptionalText(input.target?.thread ?? input.issue?.thread ?? input.issuer?.thread);
     return [
         '# LinX Symphony Task',
         '',
@@ -122,9 +225,32 @@ export function renderSymphonyRuntimePrompt(input) {
         `Task URI: ${input.task}`,
         `Session URI: ${input.session}`,
         `Backend: ${input.backend}`,
-        `Mode: ${input.mode}`,
+        `Worker mode: ${input.mode}`,
+        `Secretary auto: ${input.secretaryAutoEnabled === true ? 'on' : 'off'}`,
+        ...(input.issuer?.webId ? [`Issuer WebID: ${input.issuer.webId}`] : []),
+        ...(input.issuer?.agent ? [`Issuer agent: ${input.issuer.agent}`] : []),
+        ...(input.issuer?.chat ? [`Issuer chat: ${input.issuer.chat}`] : []),
+        ...(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?.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.workspaceUri ? [`Workspace URI: ${input.workspace.workspaceUri}`] : []),
+        ...(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: 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/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.',
         '',
         '## Objective',
         input.objective,
@@ -137,10 +263,62 @@ export function renderSymphonyRuntimePrompt(input) {
         '- Work only inside the workspace unless the task explicitly requires otherwise.',
         '- Treat this prompt as a delegated task from the user via AI Secretary.',
         '- Treat later Secretary messages in this session as Steer or follow-up Delivery updates, not as a replacement for the Goal.',
+        '- 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.',
         '- 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.',
+        '',
+        '## 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, 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/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 createSymphonyDispatchReconcilerState(input) {
+    const { summary } = decideThreadControlEvent({
+        policy: {
+            kind: 'symphony',
+            assignedWorkerAgent: input.targetAgent,
+            secretaryAgent: '__secretary__',
+        },
+        event: {
+            type: 'delivery.submitted',
+            ...(input.chat ? { chat: input.chat } : {}),
+            ...(input.thread ? { thread: input.thread } : {}),
+            resource: input.delivery,
+            actor: {
+                id: '__secretary__',
+                role: 'secretary',
+            },
+            data: {
+                deliveryType: 'task_dispatch',
+                issue: input.issue,
+                task: input.task,
+                delivery: input.delivery,
+                session: input.session,
+            },
+        },
+        now: input.now,
+        randomId: input.randomId,
+    });
+    return {
+        decisions: [summary],
+    };
+}
+function isReconcileDecisionSummary(decision) {
+    return 'eventType' in decision;
+}
 export function formatSymphonySessionSummary(session) {
     const linked = session.autoModeSessionId ? ` -> ${session.autoModeSessionId}` : '';
     return `${formatSymphonyUri(session.uri)} ${session.status} ${session.backend}/${session.mode}${linked} (${session.cwd})`;
@@ -203,6 +381,133 @@ function normalizeSymphonyChatThreadRef(input) {
         ...(messages.length > 0 ? { messages } : {}),
     };
 }
+function createSymphonyWorkerUris(options, index) {
+    if (index === 0) {
+        return {
+            task: createTaskUri(options),
+            delivery: createSymphonyDeliveryUri(options),
+            session: createSymphonySessionUri(options),
+        };
+    }
+    const suffix = `w${index + 1}`;
+    return {
+        task: createTaskUri({ ...options, randomId: `${normalizeSymphonyRandomId(options.randomId)}-${suffix}` }),
+        delivery: createSymphonyDeliveryUri({ ...options, randomId: `${normalizeSymphonyRandomId(options.randomId)}-${suffix}` }),
+        session: createSymphonySessionUri({ ...options, randomId: `${normalizeSymphonyRandomId(options.randomId)}-${suffix}` }),
+    };
+}
+function normalizeSymphonyWorkerWorkspace(root, override, backend) {
+    const path = normalizeOptionalText(override?.path) ?? root.path;
+    return {
+        path,
+        kind: override?.kind ?? root.kind,
+        ...(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?.workspaceUri ?? root.workspaceUri) ? { workspaceUri: normalizeOptionalText(override?.workspaceUri ?? root.workspaceUri) } : {}),
+        ...(normalizeOptionalText(override?.baseRevision ?? root.baseRevision) ? { baseRevision: normalizeOptionalText(override?.baseRevision ?? root.baseRevision) } : {}),
+        environment: normalizeSymphonyWorkerEnvironment(override?.environment ?? root.environment, backend),
+    };
+}
+function normalizeSymphonyWorkerEnvironment(environment, backend) {
+    const kind = environment?.kind ?? (backend === 'codex' || backend === 'claude' || backend === 'codebuddy' ? 'backend-runtime' : 'local-shell');
+    return {
+        kind,
+        ...(normalizeOptionalText(environment?.id) ? { id: normalizeOptionalText(environment?.id) } : {}),
+        ...(normalizeOptionalText(environment?.label) ? { label: normalizeOptionalText(environment?.label) } : {}),
+        runtime: normalizeOptionalText(environment?.runtime) ?? backend,
+    };
+}
+function formatSymphonyWorkerEnvironment(environment) {
+    return [
+        environment.kind,
+        environment.runtime ? `runtime=${environment.runtime}` : undefined,
+        environment.id ? `id=${environment.id}` : undefined,
+        environment.label ? `label=${environment.label}` : undefined,
+    ].filter(Boolean).join(' ');
+}
+function normalizeSymphonyIssuer(input) {
+    const explicit = input.issuer ?? {};
+    const chatThread = normalizeSymphonyChatThreadRef({
+        chat: explicit.chat ?? input.chat,
+        thread: explicit.thread ?? input.thread,
+        messages: explicit.messages ?? input.messages,
+    });
+    return {
+        source: explicit.source ?? 'user',
+        ...(normalizeOptionalText(explicit.webId) ? { webId: normalizeOptionalText(explicit.webId) } : {}),
+        ...(normalizeOptionalText(explicit.agent) ? { agent: normalizeOptionalText(explicit.agent) } : {}),
+        ...(normalizeOptionalText(explicit.label) ? { label: normalizeOptionalText(explicit.label) } : {}),
+        ...chatThread,
+    };
+}
+function normalizeSymphonyWorkerSpecs(input) {
+    const workers = input.workers && input.workers.length > 0 ? input.workers : [input.target ?? {}];
+    const rootObjective = normalizeRequiredText(input.objective, 'objective');
+    const rootAcceptanceCriteria = normalizeSymphonyAcceptanceCriteria(input.acceptanceCriteria);
+    return workers.map((worker, index) => {
+        const target = normalizeSymphonyDelegationTarget({
+            ...input,
+            target: {
+                ...worker,
+                backend: worker.backend ?? input.backend,
+            },
+        });
+        const objective = normalizeOptionalText(worker.objective) ?? rootObjective;
+        const label = normalizeOptionalText(worker.label) ?? normalizeOptionalText(worker.agent);
+        const title = normalizeOptionalText(worker.title)
+            ?? (workers.length > 1 && label ? createSymphonyTitle(`${label}: ${objective}`) : undefined)
+            ?? (workers.length > 1 ? createSymphonyTitle(`Worker ${index + 1}: ${objective}`) : undefined);
+        const acceptanceCriteria = normalizeSymphonyAcceptanceCriteria(worker.acceptanceCriteria);
+        const model = normalizeOptionalText(worker.model) ?? normalizeOptionalText(input.workerModel) ?? normalizeOptionalText(input.model);
+        const supervisor = createSymphonySupervisorPolicy(worker.supervisorIntervalMs ?? input.workerSupervisorIntervalMs);
+        return {
+            target,
+            ...(title ? { title } : {}),
+            objective,
+            acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : rootAcceptanceCriteria,
+            ...(model ? { model } : {}),
+            ...(supervisor ? { supervisor } : {}),
+            ...(worker.workspace ? { workspace: worker.workspace } : {}),
+        };
+    });
+}
+function createSymphonySupervisorPolicy(intervalMs) {
+    const normalized = typeof intervalMs === 'number' && Number.isFinite(intervalMs)
+        ? Math.trunc(intervalMs)
+        : undefined;
+    if (!normalized || normalized <= 0) {
+        return undefined;
+    }
+    return {
+        strategy: 'interval',
+        intervalMs: normalized,
+        immediateWakeKinds: ['approval', 'question', 'blocked', 'failed', 'completed'],
+    };
+}
+function normalizeSymphonyDelegationTarget(input) {
+    const explicit = input.target ?? {};
+    const chatThread = normalizeSymphonyChatThreadRef({
+        chat: explicit.chat ?? input.chat,
+        thread: explicit.thread ?? input.thread,
+        messages: explicit.messages ?? input.messages,
+    });
+    const agent = normalizeOptionalText(explicit.agent) ?? `${input.backend}-worker`;
+    const label = normalizeOptionalText(explicit.label);
+    const source = explicit.source
+        ?? (chatThread.chat || chatThread.thread
+            ? 'active-session'
+            : input.target
+                ? 'explicit-backend'
+                : 'default');
+    return {
+        source,
+        backend: explicit.backend ?? input.backend,
+        agent,
+        ...(label ? { label } : {}),
+        ...chatThread,
+    };
+}
 function formatSymphonyTimestamp(now = new Date()) {
     return now.toISOString().replace(/[:.]/gu, '-');
 }