@undefineds.co/linx 0.3.19 → 0.3.22

package/dist/lib/symphony/pod-projection.js

@@ -5,10 +5,10 @@ import { getSymphonyArchiveKey } from '../../../vendor/agent-runtime/dist/sympho
 import { DEFAULT_AGENT_RUNTIME_COMPANION_MODEL_ID } from '../../../vendor/agent-runtime/dist/companion-model.js';
 import { decideThreadControlEvent } from '../../../vendor/agent-runtime/dist/thread-reconciler-controller.js';
 import { createLinxPodSyncScope } from '../../../vendor/agent-runtime/dist/sync.js';
-import { insertExactRecordOnce, resolvePodResourceTemplateValue, upsertExactRecord, } from '@undefineds.co/drizzle-solid';
+import { buildSymphonyChatRow as buildSharedSymphonyChatRow, buildSymphonyContactRows as buildSharedSymphonyContactRows, buildSymphonyControlRows, buildSymphonyDeliveryRow as buildSharedSymphonyDeliveryRow, buildSymphonyIssueRow as buildSharedSymphonyIssueRow, buildSymphonyMessageIri as buildSharedSymphonyMessageIri, buildSymphonyRunRow as buildSharedSymphonyRunRow, buildSymphonyRunStepRow as buildSharedSymphonyRunStepRow, buildSymphonyRuntimeRunStepRow as buildSharedSymphonyRuntimeRunStepRow, buildSymphonySessionRow as buildSharedSymphonySessionRow, buildSymphonyStatusMessageRow as buildSharedSymphonyStatusMessageRow, buildSymphonyTaskRow as buildSharedSymphonyTaskRow, buildSymphonyThreadRow as buildSharedSymphonyThreadRow, listOpenSymphonyIssuesFromControlState, listRecentSymphonyReportsFromControlState, listRunningSymphonyWorkersFromControlState, } from '../../../vendor/stores/dist/symphony-control.js';
+import { insertExactRecordOnce, upsertExactRecord, } from '@undefineds.co/drizzle-solid';
 import { getDefaultPodDataSession } from '../pod-data-session.js';
-import { ContactClass, ContactType, EvidenceKind, chatRepository, agentResource, contactResource, deliveryResource, evidenceResource, ideaResource, issueResource, messageResource, reportResource, runResource, runStepResource, sessionResource, taskResource, threadRepository, } from '../models.js';
-import { pathToWorkspaceUri } from '../pi-adapter/pod-mirror-mapping.js';
+import { chatRepository, agentResource, contactResource, deliveryResource, ideaResource, issueResource, messageResource, runResource, runStepResource, sessionResource, taskResource, threadRepository, } from '../models.js';
 import { getSymphonyHome } from './archive.js';
 const SYMPHONY_CHAT_ID = 'symphony';
 const SYMPHONY_SECRETARY_AGENT_ID = '__secretary__';
@@ -16,240 +16,6 @@ const SYMPHONY_CONTACT_ID = 'symphony';
 const SYMPHONY_POLICY_VERSION = 'linx-symphony-session/v1';
 const SYMPHONY_WORKER_POD_ACCESS_POLICY_VERSION = 'linx-symphony-worker-pod-access/v1';
 const SYMPHONY_ARCHIVE_PROVENANCE_VERSION = 'linx-symphony-archive/v1';
-function ensureTrailingSlash(value) {
-    return value.endsWith('/') ? value : `${value}/`;
-}
-function podBaseUrlFromWebId(webId) {
-    const marker = '/profile/card#me';
-    if (webId.includes(marker)) {
-        return `${webId.slice(0, webId.indexOf(marker) + 1)}`;
-    }
-    const url = new URL(webId);
-    return `${url.origin}/`;
-}
-function podFileUrlFromWebId(webId, path) {
-    return new URL(path.replace(/^\/+/, ''), podBaseUrlFromWebId(webId)).toString();
-}
-function podFileUrl(podSession, path) {
-    return new URL(path.replace(/^\/+/, ''), ensureTrailingSlash(podSession.podUrl)).toString();
-}
-async function writePodFileToSession(session, file) {
-    const url = podFileUrl(session, file.path);
-    await ensurePodResourceContainers(session.fetch, url);
-    const response = await session.fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': file.contentType },
-        body: file.content.endsWith('\n') ? file.content : `${file.content}\n`,
-    });
-    if (!response.ok) {
-        const details = await response.text().catch(() => '');
-        const suffix = details.trim() ? ` - ${details.trim().slice(0, 500)}` : '';
-        throw new Error(`Failed to write Symphony Pod file ${url}: ${response.status} ${response.statusText}${suffix}`);
-    }
-}
-async function ensurePodResourceContainers(fetcher, resourceUrl) {
-    for (const containerUrl of containerUrlsForResource(resourceUrl)) {
-        const existing = await fetcher(containerUrl, { method: 'HEAD' }).catch(() => null);
-        if (existing?.ok)
-            continue;
-        if (existing && existing.status !== 404 && existing.status !== 405)
-            continue;
-        const response = await fetcher(containerUrl, {
-            method: 'PUT',
-            headers: {
-                Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"',
-                'Content-Type': 'text/turtle; charset=utf-8',
-            },
-            body: '',
-        });
-        if (!response.ok && response.status !== 409) {
-            throw new Error(`Failed to ensure Symphony Pod container ${containerUrl}: ${response.status} ${response.statusText}`);
-        }
-    }
-}
-function containerUrlsForResource(resourceUrl) {
-    const url = new URL(resourceUrl);
-    const parts = url.pathname.split('/').filter(Boolean);
-    const containers = [];
-    let path = '/';
-    for (let index = 0; index < parts.length - 1; index += 1) {
-        path += `${parts[index]}/`;
-        containers.push(new URL(path, url.origin).toString());
-    }
-    return containers;
-}
-function datePathParts(input) {
-    const date = safeDate(input);
-    return {
-        yyyy: String(date.getUTCFullYear()),
-        MM: String(date.getUTCMonth() + 1).padStart(2, '0'),
-        dd: String(date.getUTCDate()).padStart(2, '0'),
-    };
-}
-function buildSymphonyIssueDocumentPath(issue) {
-    return `/.data/issues/${buildSymphonyIssueId(issue)}/issue.md`;
-}
-function buildSymphonyIdeaDocumentPath(idea) {
-    const { yyyy, MM, dd } = datePathParts(idea.createdAt);
-    return `/.data/ideas/${yyyy}/${MM}/${dd}/${getSymphonyArchiveKey(idea.uri)}/idea.md`;
-}
-function buildSymphonyReportDocumentPath(worker) {
-    const { yyyy, MM, dd } = datePathParts(worker.session.completedAt ?? worker.session.updatedAt);
-    return `/.data/reports/${yyyy}/${MM}/${dd}/${getSymphonyArchiveKey(worker.session.uri)}-report.md`;
-}
-function buildSymphonyEvidenceDocumentPath(worker, stage) {
-    const { yyyy, MM, dd } = datePathParts(worker.session.completedAt ?? worker.session.updatedAt);
-    return `/.data/evidence/${yyyy}/${MM}/${dd}/${getSymphonyArchiveKey(worker.session.uri)}-${stage}-evidence.md`;
-}
-function renderMarkdownList(items) {
-    const values = (items ?? []).map((item) => item.trim()).filter(Boolean);
-    return values.length > 0 ? values.map((item) => `- ${item}`).join('\n') : '- None recorded.';
-}
-function renderSymphonyIssueMarkdown(plan) {
-    const issue = plan.issue;
-    const sections = [
-        `# ${issue.title || buildSymphonyIssueId(issue)}`,
-        '',
-        '## Summary',
-        issue.description?.trim() || issue.title || 'No summary recorded.',
-        '',
-        '## Status',
-        `- Status: ${issue.status}`,
-        `- Priority: ${issue.priority}`,
-        `- Source: ${issue.source}`,
-        '',
-        '## Acceptance Criteria',
-        renderMarkdownList(plan.workers.flatMap((worker) => worker.taskRecord.acceptanceCriteria ?? [])),
-        '',
-        '## Tasks',
-        renderMarkdownList(plan.workers.map((worker) => `${worker.taskRecord.title}: ${worker.taskRecord.objective}`)),
-        '',
-        '## Source Context',
-        `- Chat: ${issue.chat ?? plan.session.chat ?? 'not recorded'}`,
-        `- Thread: ${issue.thread ?? plan.session.thread ?? 'not recorded'}`,
-        `- Messages: ${(issue.messages ?? []).join(', ') || 'not recorded'}`,
-        '',
-        '## Control Records',
-        `- Issue: ${issue.uri}`,
-        ...plan.workers.flatMap((worker) => [
-            `- Task: ${worker.task}`,
-            `- Delivery: ${worker.delivery.uri}`,
-            `- Session: ${worker.session.uri}`,
-        ]),
-    ];
-    return sections.join('\n');
-}
-function renderSymphonyIdeaMarkdown(idea) {
-    return [
-        `# ${idea.summary || getSymphonyArchiveKey(idea.uri)}`,
-        '',
-        '## Input',
-        idea.input?.trim() || idea.summary || 'No input recorded.',
-        '',
-        '## Current Understanding',
-        idea.currentUnderstanding?.trim() || 'No current understanding recorded.',
-        '',
-        '## Open Questions',
-        renderMarkdownList(idea.openQuestions),
-        '',
-        '## Conflicts',
-        renderMarkdownList(idea.conflicts),
-        '',
-        '## Next Step',
-        idea.nextStep?.trim() || 'No next step recorded.',
-        '',
-        '## Source Context',
-        `- Status: ${idea.status}`,
-        `- Commitment: ${idea.commitment}`,
-        `- Chat: ${idea.chat ?? 'not recorded'}`,
-        `- Thread: ${idea.thread ?? 'not recorded'}`,
-        `- Messages: ${(idea.messages ?? []).join(', ') || 'not recorded'}`,
-        `- Idea: ${idea.uri}`,
-    ].join('\n');
-}
-function renderSymphonyReportMarkdown(plan, worker, stage) {
-    const status = worker.session.status === 'failed' || stage === 'failed' ? 'failed' : 'completed';
-    const summary = status === 'completed'
-        ? `${worker.taskRecord.title} completed.`
-        : `${worker.taskRecord.title} failed: ${worker.session.error ?? worker.delivery.error ?? 'worker did not complete successfully.'}`;
-    return [
-        `# ${worker.taskRecord.title} — ${status}`,
-        '',
-        '## Summary',
-        summary,
-        '',
-        '## Outcome',
-        `- Status: ${status}`,
-        `- Backend: ${worker.session.backend}`,
-        `- Agent: ${worker.session.target.agent ?? worker.delivery.targetAgent}`,
-        `- Auto mode session: ${worker.session.autoModeSessionId ?? 'not recorded'}`,
-        `- Exit code: ${worker.session.exitCode ?? 'not recorded'}`,
-        '',
-        '## Task',
-        worker.taskRecord.objective,
-        '',
-        '## Acceptance Criteria',
-        renderMarkdownList(worker.taskRecord.acceptanceCriteria),
-        '',
-        '## Linked Control Records',
-        `- Issue: ${buildSymphonyIssueId(plan.issue)}`,
-        `- Task: ${worker.task}`,
-        `- Delivery: ${worker.delivery.uri}`,
-        `- Session: ${worker.session.uri}`,
-        `- Run status: ${worker.session.status}`,
-        '',
-        '## Post-Run Reconciliation',
-        '- Secretary must review this report and linked Evidence before closing the task.',
-        '- Classify any follow-up as same_issue_task, new_issue, idea, evidence_only, or ask_user.',
-        '',
-        ...(worker.session.error || worker.delivery.error || worker.taskRecord.error ? [
-            '## Error',
-            worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error ?? '',
-            '',
-        ] : []),
-    ].join('\n');
-}
-function renderSymphonyEvidenceMarkdown(plan, webId, worker, stage) {
-    const status = worker.session.status === 'failed' || stage === 'failed' ? 'failed' : 'completed';
-    const summary = status === 'completed'
-        ? `${worker.taskRecord.title} completed with runtime status ${worker.session.status}.`
-        : `${worker.taskRecord.title} failed: ${worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error ?? 'worker did not complete successfully.'}`;
-    const run = buildSymphonyRunIri(webId, worker);
-    const runStep = buildSymphonyRunStepIri(webId, worker, stage);
-    return [
-        `# ${worker.taskRecord.title} — ${status} evidence`,
-        '',
-        '## Summary',
-        summary,
-        '',
-        '## Runtime Facts',
-        `- Backend: ${worker.session.backend}`,
-        `- Agent: ${worker.session.target.agent ?? worker.delivery.targetAgent}`,
-        `- Model: ${worker.session.model ?? 'not recorded'}`,
-        `- Auto mode session: ${worker.session.autoModeSessionId ?? 'not recorded'}`,
-        `- Exit code: ${worker.session.exitCode ?? 'not recorded'}`,
-        `- Run status: ${worker.session.status}`,
-        '',
-        '## Acceptance Criteria',
-        renderMarkdownList(worker.taskRecord.acceptanceCriteria),
-        '',
-        '## Linked Control Records',
-        `- Issue: ${buildSymphonyIssueIri(webId, plan.issue)}`,
-        `- Task: ${buildSymphonyTaskIri(webId, worker.task)}`,
-        `- Delivery: ${buildSymphonyDeliveryIri(webId, worker)}`,
-        `- Run: ${run}`,
-        `- Source RunStep: ${runStep}`,
-        `- Worker Thread: ${selectWorkerThreadIri(plan, webId, worker)}`,
-        '',
-        ...(worker.session.error || worker.delivery.error || worker.taskRecord.error ? [
-            '## Error',
-            worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error ?? '',
-            '',
-        ] : []),
-        '## Secretary Follow-Up Review',
-        'This Evidence is append-only proof/finding material. Secretary must use it with the Report and RunSteps to decide acceptance and whether follow-up work should be captured.',
-    ].join('\n');
-}
 function normalizeSymphonyRunPlan(plan) {
     const workers = Array.isArray(plan.workers) && plan.workers.length > 0
         ? plan.workers
@@ -326,6 +92,7 @@ function normalizeSymphonyRunPlan(plan) {
         delivery: primary.delivery,
         session: primary.session,
         workers: normalizedWorkers,
+        ...(plan.followUpIssues?.length ? { followUpIssues: plan.followUpIssues } : {}),
     };
 }
 async function dynamicImport(specifier) {
@@ -353,15 +120,14 @@ async function createDefaultRuntime() {
         issueResource: models.issueResource,
         taskResource: models.taskResource,
         deliveryResource: models.deliveryResource,
-        evidenceResource: models.evidenceResource,
-        reportResource: models.reportResource,
         runResource: models.runResource,
         runStepResource: models.runStepResource,
+        evidenceResource: models.evidenceResource,
+        reportResource: models.reportResource,
         agentResource: models.agentResource,
         contactResource: models.contactResource,
         auditResource: models.auditResource,
         inboxNotificationResource: models.inboxNotificationResource,
-        writePodFile: writePodFileToSession,
     };
 }
 function selectTargetChatIri(value, webId, plan) {
@@ -422,6 +188,24 @@ function buildSymphonyIssueId(issue) {
 function buildSymphonyIssueIri(webId, issue) {
     return issueResource.buildIri(webId, { id: buildSymphonyIssueId(issue) });
 }
+function normalizeSymphonyIssueIri(webId, issue) {
+    if (/^https?:\/\//u.test(issue)) {
+        return issue;
+    }
+    return buildSymphonyIssueIri(webId, {
+        uri: issue,
+        title: '',
+        status: 'open',
+        priority: 'medium',
+        source: 'cli',
+        issuer: { source: 'system' },
+        tasks: [],
+        deliveries: [],
+        sessions: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    });
+}
 function buildSymphonyTaskKey(task) {
     return getSymphonyArchiveKey(task);
 }
@@ -448,19 +232,6 @@ function buildSymphonyReportDeliveryIri(webId, worker) {
         createdAt: safeDate(worker.session.completedAt ?? worker.session.updatedAt),
     });
 }
-function buildSymphonyReportIri(webId, worker) {
-    return reportResource.buildIri(webId, {
-        id: `${getSymphonyArchiveKey(worker.session.uri)}-report`,
-        task: buildSymphonyTaskIri(webId, worker.task),
-        createdAt: safeDate(worker.session.completedAt ?? worker.session.updatedAt),
-    });
-}
-function buildSymphonyEvidenceIri(webId, worker, stage) {
-    return evidenceResource.buildIri(webId, {
-        id: `${getSymphonyArchiveKey(worker.session.uri)}-${stage}`,
-        createdAt: safeDate(worker.session.completedAt ?? worker.session.updatedAt),
-    });
-}
 function buildSymphonyRunIri(webId, worker) {
     return runResource.buildIri(webId, {
         id: getSymphonyArchiveKey(worker.session.uri),
@@ -474,6 +245,12 @@ function buildSymphonyRunStepIri(webId, worker, stage) {
         run: buildSymphonyRunIri(webId, worker),
     });
 }
+function buildSymphonyRuntimeRunStepIri(webId, worker, step) {
+    return runStepResource.buildIri(webId, {
+        id: getSymphonyArchiveKey(step.uri),
+        run: buildSymphonyRunIri(webId, worker),
+    });
+}
 function buildSymphonyWorkerPodAccessPolicy(plan, webId, worker) {
     return {
         version: SYMPHONY_WORKER_POD_ACCESS_POLICY_VERSION,
@@ -592,11 +369,11 @@ function resolveSymphonyRuntimeSessionRelation(plan, webId, worker) {
     return 'runtime-projected-worker-session';
 }
 function buildSymphonyWorkspaceMetadata(plan, worker) {
-    const workspace = normalizeSymphonyWorkspaceRef(worker.session.workspace ?? plan.session.workspace, worker.session.cwd ?? plan.session.cwd);
+    const workspace = normalizeWorkerWorkspace(worker.session.workspace ?? plan.session.workspace, worker.session.cwd ?? plan.session.cwd);
     return {
         path: workspace.path,
         kind: workspace.kind,
-        ...(workspace.workspaceUri ? { uri: workspace.workspaceUri } : {}),
+        ...(workspace.container ? { container: workspace.container } : {}),
         ...(workspace.repository ? { repository: workspace.repository } : {}),
         ...(workspace.branch ? { branch: workspace.branch } : {}),
         ...(workspace.worktree ? { worktree: workspace.worktree } : {}),
@@ -609,14 +386,14 @@ function buildSymphonyWorkspaceMetadata(plan, worker) {
         equivalenceRequires: ['baseRevision', 'checksum-or-etag-or-artifact-uri'],
     };
 }
-function normalizeSymphonyWorkspaceRef(workspace, fallbackPath) {
+function normalizeWorkerWorkspace(workspace, fallbackPath) {
     return {
         path: workspace?.path ?? fallbackPath,
         kind: workspace?.kind ?? 'folder',
         ...(workspace?.repository ? { repository: workspace.repository } : {}),
         ...(workspace?.branch ? { branch: workspace.branch } : {}),
         ...(workspace?.worktree ? { worktree: workspace.worktree } : {}),
-        ...(workspace?.workspaceUri ? { workspaceUri: workspace.workspaceUri } : {}),
+        ...(workspace?.container ? { container: workspace.container } : {}),
         ...(workspace?.baseRevision ? { baseRevision: workspace.baseRevision } : {}),
         ...(workspace?.environment ? { environment: workspace.environment } : {}),
     };
@@ -719,6 +496,7 @@ function withChatThreadRefs(plan, refs) {
             thread: refs.thread,
             messages: refs.messages,
         },
+        ...(worker.runSteps?.length ? { runSteps: worker.runSteps } : {}),
     }));
     const primary = workers[0] ?? {
         task: plan.task,
@@ -753,6 +531,7 @@ function withChatThreadRefs(plan, refs) {
         delivery: primary.delivery,
         session: primary.session,
         workers,
+        ...(plan.followUpIssues?.length ? { followUpIssues: plan.followUpIssues } : {}),
     };
 }
 function withTargetRefs(plan, refs, webId) {
@@ -795,6 +574,7 @@ function withTargetRefs(plan, refs, webId) {
                 messages: workerRefs.messages,
                 target,
             },
+            ...(worker.runSteps?.length ? { runSteps: worker.runSteps } : {}),
         };
     });
     const primary = workers[0] ?? {
@@ -830,69 +610,9 @@ function withTargetRefs(plan, refs, webId) {
         delivery: primary.delivery,
         session: primary.session,
         workers,
+        ...(plan.followUpIssues?.length ? { followUpIssues: plan.followUpIssues } : {}),
     };
 }
-function buildSymphonyChatRow(plan, webId, stage, lastPreview) {
-    const createdAt = safeDate(plan.issue.createdAt);
-    const updatedAt = safeDate(plan.session.updatedAt);
-    const secretaryAgent = agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID });
-    const secretaryContact = buildSecretaryContactIri(webId);
-    const workerMembers = plan.workers.map((worker) => ({
-        contact: buildWorkerContactIri(webId, worker),
-        agent: buildWorkerAgentIri(webId, worker),
-        label: worker.session.target.label ?? worker.session.target.contact ?? worker.session.target.agent ?? backendDisplayName(worker.session.backend),
-    }));
-    const participants = Array.from(new Set([webId, secretaryContact, ...workerMembers.map((member) => member.contact)]));
-    const targetChat = selectTargetChatIri(plan.session.target?.chat, webId, plan);
-    return {
-        id: buildTargetChatId(plan, webId),
-        title: plan.session.target?.label ?? (targetChat === buildSymphonyChatUri(webId) ? 'AI Secretary · Symphony' : 'Symphony Delegation'),
-        participants,
-        metadata: {
-            kind: targetChat === buildSymphonyChatUri(webId) ? 'symphony-control-room' : 'symphony-target-room',
-            surface: 'symphony',
-            secretaryAgent,
-            secretaryContact,
-            currentBackend: plan.session.backend,
-            target: plan.session.target,
-            currentStage: stage,
-            memberRoles: Object.fromEntries([
-                [webId, 'owner'],
-                [secretaryContact, 'admin'],
-                ...workerMembers.map((member) => [member.contact, 'member']),
-            ]),
-            members: [
-                { uri: webId, role: 'user', label: 'User' },
-                { uri: secretaryContact, agent: secretaryAgent, role: 'secretary', label: 'AI Secretary' },
-                ...workerMembers.map((member) => ({
-                    uri: member.contact,
-                    agent: member.agent,
-                    role: 'worker',
-                    label: member.label,
-                })),
-            ],
-        },
-        lastActiveAt: updatedAt,
-        lastMessagePreview: lastPreview ? normalizeTitle(lastPreview, 100) : undefined,
-        createdAt,
-        updatedAt,
-    };
-}
-function collectSymphonyThreadProjectionGroups(plan, webId) {
-    const groups = new Map();
-    for (const worker of plan.workers) {
-        const chat = selectWorkerChatIri(plan, webId, worker);
-        const thread = selectWorkerThreadIri(plan, webId, worker);
-        const key = `${chat}\0${thread}`;
-        const existing = groups.get(key);
-        if (existing) {
-            existing.workers.push(worker);
-            continue;
-        }
-        groups.set(key, { chat, thread, workers: [worker] });
-    }
-    return Array.from(groups.values());
-}
 function buildSymphonyWorkerSummary(plan, webId, worker) {
     return {
         task: worker.task,
@@ -905,9 +625,6 @@ function buildSymphonyWorkerSummary(plan, webId, worker) {
         sessionResource: buildSymphonyWorkerSessionUri(webId, worker),
         backend: worker.session.backend,
         agent: worker.session.target.agent,
-        contact: worker.session.target.contact ?? buildWorkerContactId(worker),
-        contactResource: buildWorkerContactIri(webId, worker),
-        agentResource: buildWorkerAgentIri(webId, worker),
         status: worker.session.status,
         autoModeSessionId: worker.session.autoModeSessionId,
         target: worker.session.target,
@@ -915,6 +632,7 @@ function buildSymphonyWorkerSummary(plan, webId, worker) {
         workspace: buildSymphonyWorkspaceMetadata(plan, worker),
         podAccessPolicy: buildSymphonyWorkerPodAccessPolicy(plan, webId, worker),
         reconciler: buildSymphonyReconcilerMetadata(worker),
+        acceptanceReview: worker.taskRecord.acceptanceReview ?? worker.delivery.acceptanceReview ?? worker.session.acceptanceReview,
     };
 }
 function buildSymphonyReconcilerMetadata(worker) {
@@ -959,148 +677,21 @@ function createFallbackSymphonyDispatchDecision(worker) {
         randomId: `${worker.delivery.uri}-dispatch`,
     }).summary;
 }
-function buildSymphonyThreadRows(plan, webId, stage) {
-    return collectSymphonyThreadProjectionGroups(plan, webId)
-        .map((group) => buildSymphonyThreadRow(plan, webId, stage, group));
-}
-function buildSymphonyThreadRow(plan, webId, stage, group) {
-    const workers = group?.workers ?? plan.workers;
-    const primaryWorker = workers[0] ?? {
-        task: plan.task,
-        taskRecord: plan.taskRecord,
-        delivery: plan.delivery,
-        session: plan.session,
-    };
-    const createdAt = safeDate(primaryWorker.session.createdAt);
-    const updatedAt = safeDate(primaryWorker.session.updatedAt);
-    const parent = group?.chat ?? selectTargetChatIri(plan.session.target?.chat, webId, plan);
-    const thread = group?.thread ?? selectTargetThreadIri(plan.session.target?.thread, webId, plan);
-    const workspace = pathToWorkspaceUri(primaryWorker.session.cwd) ?? pathToWorkspaceUri(plan.session.cwd);
-    return {
-        id: threadRepository.idForChat(parent, thread),
-        parent,
-        title: normalizeTitle(plan.issue.title || plan.issue.description || 'Symphony Task'),
-        ...(workspace ? { workspace } : {}),
-        metadata: {
-            kind: 'symphony-run',
-            surface: 'symphony',
-            stage,
-            status: plan.session.status,
-            issue: plan.issue.uri,
-            task: primaryWorker.task,
-            delivery: primaryWorker.delivery.uri,
-            session: primaryWorker.session.uri,
-            issuer: plan.issue.issuer,
-            workers: workers.map((worker) => buildSymphonyWorkerSummary(plan, webId, worker)),
-            backend: primaryWorker.session.backend,
-            mode: primaryWorker.session.mode,
-            model: primaryWorker.session.model,
-            workspacePath: primaryWorker.session.cwd,
-            workspace: buildSymphonyWorkspaceMetadata(plan, primaryWorker),
-            reconciler: buildSymphonyReconcilerMetadata(primaryWorker),
-            autoModeSessionId: primaryWorker.session.autoModeSessionId,
-            exitCode: primaryWorker.session.exitCode,
-            error: primaryWorker.session.error ?? primaryWorker.delivery.error ?? plan.issue.error,
-            target: primaryWorker.session.target,
-        },
-        createdAt,
-        updatedAt,
-    };
-}
-function buildSymphonySessionRow(plan, webId, worker = plan.workers[0] ?? {
-    task: plan.task,
-    taskRecord: plan.taskRecord,
-    delivery: plan.delivery,
-    session: plan.session,
-}) {
-    const createdAt = safeDate(worker.session.createdAt);
-    const updatedAt = safeDate(worker.session.updatedAt);
-    const status = worker.session.status === 'completed'
-        ? 'completed'
-        : worker.session.status === 'failed'
-            ? 'error'
-            : 'active';
-    const workerSummary = buildSymphonyWorkerSummary(plan, webId, worker);
-    return {
-        id: buildSymphonySessionRecordId(worker.session),
-        owner: webId,
-        chat: selectWorkerChatIri(plan, webId, worker),
-        thread: selectWorkerThreadIri(plan, webId, worker),
-        sessionType: 'group',
-        status,
-        tool: `symphony:${worker.session.backend}`,
-        tokenUsage: 0,
-        messages: worker.session.messages,
-        policyVersion: SYMPHONY_POLICY_VERSION,
-        metadata: {
-            kind: 'symphony-run',
-            surface: 'symphony',
-            issue: plan.issue.uri,
-            task: worker.task,
-            delivery: worker.delivery.uri,
-            session: worker.session.uri,
-            issuer: plan.issue.issuer,
-            worker: workerSummary,
-            workers: [workerSummary],
-            backend: worker.session.backend,
-            mode: worker.session.mode,
-            model: worker.session.model,
-            workspacePath: worker.session.cwd,
-            workspace: buildSymphonyWorkspaceMetadata(plan, worker),
-            reconciler: buildSymphonyReconcilerMetadata(worker),
-            autoModeSessionId: worker.session.autoModeSessionId,
-            exitCode: worker.session.exitCode,
-            dryRun: worker.session.dryRun,
-            error: worker.session.error ?? worker.delivery.error ?? plan.issue.error,
-            target: worker.session.target,
-        },
-        createdAt,
-        updatedAt,
-        ...(status === 'completed' || status === 'error' ? { archivedAt: updatedAt } : {}),
-    };
-}
-function buildSymphonyIssueRow(plan, webId) {
-    const createdAt = safeDate(plan.issue.createdAt);
-    const updatedAt = safeDate(plan.issue.updatedAt);
-    const secretaryContact = buildSecretaryContactIri(webId);
-    return {
-        id: buildSymphonyIssueId(plan.issue),
-        // File-primary: title remains a compact index label for existing Issue schemas.
-        // The full problem statement and acceptance narrative live in issue.md.
-        title: plan.issue.title,
-        document: podFileUrlFromWebId(webId, buildSymphonyIssueDocumentPath(plan.issue)),
-        description: undefined,
-        status: plan.issue.status,
-        priority: plan.issue.priority,
-        labels: ['symphony'],
-        chat: selectTargetChatIri(plan.session.target?.chat, webId, plan),
-        thread: selectTargetThreadIri(plan.session.target?.thread, webId, plan),
-        tasks: Array.from(new Set((plan.issue.tasks?.length ? plan.issue.tasks : plan.workers.map((worker) => worker.task))
-            .map((task) => normalizeSymphonyTaskIri(webId, task)))),
-        createdBy: plan.issue.issuer.webId ?? webId,
-        assignedTo: secretaryContact,
-        createdAt,
-        updatedAt,
-        ...(plan.issue.closedAt ? { closedAt: safeDate(plan.issue.closedAt) } : {}),
-    };
-}
 function buildSymphonyIdeaRow(idea, webId) {
     const createdAt = safeDate(idea.createdAt);
     const updatedAt = safeDate(idea.updatedAt);
     return {
         id: getSymphonyArchiveKey(idea.uri),
         summary: idea.summary,
-        document: podFileUrlFromWebId(webId, buildSymphonyIdeaDocumentPath(idea)),
-        // File-primary: the source text lives in idea.md; TTL keeps only routing/index facts.
-        input: undefined,
+        input: idea.input,
         status: idea.status,
         commitment: idea.commitment,
         affectedArea: idea.affectedArea,
-        currentUnderstanding: undefined,
-        openQuestions: undefined,
+        currentUnderstanding: idea.currentUnderstanding,
+        openQuestions: idea.openQuestions,
         related: idea.relatedRecords,
-        conflicts: undefined,
-        nextStep: undefined,
+        conflicts: idea.conflicts,
+        nextStep: idea.nextStep,
         promotedTo: idea.promotedTo,
         chat: idea.chat,
         thread: idea.thread,
@@ -1108,277 +699,25 @@ function buildSymphonyIdeaRow(idea, webId) {
         createdBy: webId,
         metadata: {
             surface: 'symphony',
-            filePrimary: true,
-            documentPath: buildSymphonyIdeaDocumentPath(idea),
             ...buildSymphonyArchiveMetadata({ idea: idea.uri }),
         },
         createdAt,
         updatedAt,
     };
 }
-function mapSymphonyTaskStatus(status) {
-    if (status === 'running')
-        return 'active';
-    if (status === 'pending')
-        return 'open';
-    return status;
-}
-function mapSymphonyRunStatus(status) {
-    if (status === 'planned')
-        return 'queued';
-    if (status === 'running')
-        return 'running';
-    if (status === 'completed')
-        return 'completed';
-    if (status === 'failed')
-        return 'failed';
-    return 'queued';
-}
-function buildSymphonyTaskRow(plan, webId, worker) {
-    const createdAt = safeDate(worker.taskRecord.createdAt);
-    const updatedAt = safeDate(worker.taskRecord.updatedAt);
-    const workerContact = buildWorkerContactIri(webId, worker);
-    const workerAgent = buildWorkerAgentIri(webId, worker);
-    return {
-        id: taskResource.buildId({ id: buildSymphonyTaskKey(worker.task) }),
-        title: worker.taskRecord.title,
-        instruction: worker.taskRecord.objective,
-        prompt: worker.delivery.projection.prompt,
-        issue: buildSymphonyIssueIri(webId, plan.issue),
-        message: plan.issue.messages?.at(-1),
-        thread: selectWorkerThreadIri(plan, webId, worker),
-        workspace: pathToWorkspaceUri(worker.session.cwd) ?? pathToWorkspaceUri(plan.session.cwd) ?? 'file:///',
-        status: mapSymphonyTaskStatus(worker.taskRecord.status),
-        priority: plan.issue.priority,
-        assignedTo: workerContact,
-        source: buildSymphonyIssueIri(webId, plan.issue),
-        metadata: {
-            surface: 'symphony',
-            ...buildSymphonyArchiveMetadata({ task: worker.taskRecord.uri }),
-            acceptanceCriteria: worker.taskRecord.acceptanceCriteria,
-            backend: worker.session.backend,
-            target: worker.session.target,
-            assignedContact: workerContact,
-            assignedAgent: workerAgent,
-            workspace: buildSymphonyWorkspaceMetadata(plan, worker),
-            spaceContract: buildSymphonySpaceContract(plan, webId, worker),
-            podAccessPolicy: buildSymphonyWorkerPodAccessPolicy(plan, webId, worker),
-            reconciler: buildSymphonyReconcilerMetadata(worker),
-        },
-        createdAt,
-        updatedAt,
-    };
-}
-function buildSymphonyDeliveryRow(plan, webId, worker) {
-    const createdAt = safeDate(worker.delivery.createdAt);
-    const updatedAt = safeDate(worker.delivery.updatedAt);
-    const secretaryAgent = agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID });
-    const secretaryContact = buildSecretaryContactIri(webId);
-    const workerAgent = buildWorkerAgentIri(webId, worker);
-    const workerContact = buildWorkerContactIri(webId, worker);
-    return {
-        id: deliveryResource.buildId({
-            id: getSymphonyArchiveKey(worker.delivery.uri),
-            task: buildSymphonyTaskIri(webId, worker.task),
-            createdAt,
-        }),
-        kind: worker.delivery.type,
-        status: worker.delivery.status,
-        task: buildSymphonyTaskIri(webId, worker.task),
-        source: secretaryContact,
-        target: workerContact,
-        chat: selectWorkerChatIri(plan, webId, worker),
-        thread: selectWorkerThreadIri(plan, webId, worker),
-        targetThread: selectWorkerThreadIri(plan, webId, worker),
-        targetSession: worker.session.uri,
-        actor: secretaryAgent,
-        object: buildSymphonyTaskIri(webId, worker.task),
-        objective: worker.taskRecord.objective,
-        payload: {
-            issue: buildSymphonyIssueIri(webId, plan.issue),
-            acceptanceCriteria: worker.taskRecord.acceptanceCriteria,
-            backend: worker.session.backend,
-            mode: worker.session.mode,
-            target: worker.session.target,
-            targetContact: workerContact,
-            targetAgent: workerAgent,
-            workspace: buildSymphonyWorkspaceMetadata(plan, worker),
-            spaceContract: buildSymphonySpaceContract(plan, webId, worker),
-            podAccessPolicy: buildSymphonyWorkerPodAccessPolicy(plan, webId, worker),
-            reconciler: buildSymphonyReconcilerMetadata(worker),
-        },
-        projection: worker.delivery.projection,
-        projectedRole: worker.delivery.projection.runtimeRole,
-        metadata: {
-            surface: 'symphony',
-            ...buildSymphonyArchiveMetadata({
-                issue: plan.issue.uri,
-                task: worker.task,
-                delivery: worker.delivery.uri,
-                session: worker.session.uri,
-            }),
-            autoModeSessionId: worker.delivery.autoModeSessionId,
-            sourceAgent: secretaryAgent,
-            targetContact: workerContact,
-            targetAgent: workerAgent,
-            workspace: buildSymphonyWorkspaceMetadata(plan, worker),
-            spaceContract: buildSymphonySpaceContract(plan, webId, worker),
-            podAccessPolicy: buildSymphonyWorkerPodAccessPolicy(plan, webId, worker),
-            reconciler: buildSymphonyReconcilerMetadata(worker),
-        },
-        error: worker.delivery.error,
-        createdAt,
-        dispatchedAt: worker.delivery.status === 'dispatched' || worker.delivery.status === 'completed'
-            ? updatedAt
-            : undefined,
-        completedAt: worker.delivery.completedAt ? safeDate(worker.delivery.completedAt) : undefined,
-        updatedAt,
-    };
-}
-function buildSymphonyReportRow(plan, webId, worker, stage) {
-    const completedAt = safeDate(worker.session.completedAt ?? worker.session.updatedAt);
-    const workerAgent = buildWorkerAgentIri(webId, worker);
-    const run = buildSymphonyRunIri(webId, worker);
-    const task = buildSymphonyTaskIri(webId, worker.task);
-    const status = worker.session.status === 'failed' || stage === 'failed' ? 'failed' : 'completed';
-    const summary = status === 'completed'
-        ? `${worker.taskRecord.title} completed.`
-        : `${worker.taskRecord.title} failed: ${worker.session.error ?? worker.delivery.error ?? 'worker did not complete successfully.'}`;
-    const evidence = buildSymphonyEvidenceIri(webId, worker, stage);
-    return {
-        id: reportResource.buildId({
-            id: `${getSymphonyArchiveKey(worker.session.uri)}-report`,
-            task,
-            createdAt: completedAt,
-        }),
-        reportKind: 'handoff',
-        status: 'published',
-        outcome: status === 'completed' ? 'accepted' : 'blocked',
-        about: run,
-        issue: buildSymphonyIssueIri(webId, plan.issue),
-        task,
-        delivery: buildSymphonyDeliveryIri(webId, worker),
-        run,
-        thread: selectWorkerThreadIri(plan, webId, worker),
-        evidence: [
-            evidence,
-        ],
-        summary,
-        actor: workerAgent,
-        source: podFileUrlFromWebId(webId, buildSymphonyReportDocumentPath(worker)),
-        metricFacts: {
-            backend: worker.session.backend,
-            agent: worker.session.target.agent,
-            autoModeSessionId: worker.session.autoModeSessionId,
-            exitCode: worker.session.exitCode,
-        },
-        metadata: {
-            surface: 'symphony',
-            filePrimary: true,
-            reportFile: buildSymphonyReportDocumentPath(worker),
-            reportDelivery: buildSymphonyReportDeliveryIri(webId, worker),
-            postRunReconciliation: buildPostRunReconciliationMetadata(plan, webId, worker, stage),
-            ...buildSymphonyArchiveMetadata({
-                issue: plan.issue.uri,
-                task: worker.task,
-                delivery: worker.delivery.uri,
-                session: worker.session.uri,
-            }),
-        },
-        createdAt: completedAt,
-        publishedAt: completedAt,
-        updatedAt: completedAt,
-    };
-}
-function buildSymphonyEvidenceRow(plan, webId, worker, stage) {
-    const createdAt = safeDate(worker.session.completedAt ?? worker.session.updatedAt);
-    const status = worker.session.status === 'failed' || stage === 'failed' ? 'failed' : 'completed';
-    const run = buildSymphonyRunIri(webId, worker);
-    const task = buildSymphonyTaskIri(webId, worker.task);
-    const delivery = buildSymphonyDeliveryIri(webId, worker);
-    const runStep = buildSymphonyRunStepIri(webId, worker, stage);
-    const workerAgent = buildWorkerAgentIri(webId, worker);
-    return {
-        id: evidenceResource.buildId({
-            id: `${getSymphonyArchiveKey(worker.session.uri)}-${stage}`,
-            createdAt,
-        }),
-        evidenceKind: EvidenceKind.RUNTIME_LOG,
-        about: run,
-        issue: buildSymphonyIssueIri(webId, plan.issue),
-        task,
-        delivery,
-        run,
-        thread: selectWorkerThreadIri(plan, webId, worker),
-        summary: status === 'completed'
-            ? `${worker.taskRecord.title} completed with runtime status ${worker.session.status}.`
-            : `${worker.taskRecord.title} failed: ${worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error ?? 'worker did not complete successfully.'}`,
-        source: podFileUrlFromWebId(webId, buildSymphonyEvidenceDocumentPath(worker, stage)),
-        actor: workerAgent,
-        outcome: status,
-        metadata: {
-            surface: 'symphony',
-            filePrimary: true,
-            evidenceFile: buildSymphonyEvidenceDocumentPath(worker, stage),
-            sourceRunStep: runStep,
-            report: buildSymphonyReportIri(webId, worker),
-            reportDelivery: buildSymphonyReportDeliveryIri(webId, worker),
-            postRunReconciliation: buildPostRunReconciliationMetadata(plan, webId, worker, stage),
-            runtime: {
-                backend: worker.session.backend,
-                model: worker.session.model,
-                autoModeSessionId: worker.session.autoModeSessionId,
-                exitCode: worker.session.exitCode,
-                status: worker.session.status,
-            },
-            ...buildSymphonyArchiveMetadata({
-                issue: plan.issue.uri,
-                task: worker.task,
-                delivery: worker.delivery.uri,
-                session: worker.session.uri,
-            }),
-        },
-        createdAt,
-    };
-}
-function buildPostRunReconciliationMetadata(plan, webId, worker, stage) {
-    return {
-        required: true,
-        status: 'pending_secretary_review',
-        owner: buildSecretaryContactIri(webId),
-        sourceIssue: buildSymphonyIssueIri(webId, plan.issue),
-        sourceTask: buildSymphonyTaskIri(webId, worker.task),
-        sourceDelivery: buildSymphonyDeliveryIri(webId, worker),
-        sourceRun: buildSymphonyRunIri(webId, worker),
-        sourceRunStep: buildSymphonyRunStepIri(webId, worker, stage),
-        sourceEvidence: buildSymphonyEvidenceIri(webId, worker, stage),
-        sourceReport: buildSymphonyReportIri(webId, worker),
-        classifications: [
-            'same_issue_task',
-            'new_issue',
-            'idea',
-            'evidence_only',
-            'ask_user',
-        ],
-        rule: 'Secretary must reconcile acceptance and follow-up before task closure.',
-    };
-}
 function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
     const completedAt = safeDate(worker.session.completedAt ?? worker.session.updatedAt);
-    const workerAgent = buildWorkerAgentIri(webId, worker);
-    const workerContact = buildWorkerContactIri(webId, worker);
+    const workerAgent = agentResource.buildIri(webId, {
+        id: buildWorkerAgentId(worker.session.backend, worker.session.target.agent),
+    });
     const secretaryAgent = agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID });
-    const secretaryContact = buildSecretaryContactIri(webId);
     const run = buildSymphonyRunIri(webId, worker);
-    const report = buildSymphonyReportIri(webId, worker);
     const task = buildSymphonyTaskIri(webId, worker.task);
     const originalDelivery = buildSymphonyDeliveryIri(webId, worker);
     const status = worker.session.status === 'failed' || stage === 'failed' ? 'failed' : 'completed';
     const summary = status === 'completed'
         ? `${worker.taskRecord.title} completed.`
         : `${worker.taskRecord.title} failed: ${worker.session.error ?? worker.delivery.error ?? 'worker did not complete successfully.'}`;
-    const evidence = buildSymphonyEvidenceIri(webId, worker, stage);
-    const sourceRunStep = buildSymphonyRunStepIri(webId, worker, stage);
     return {
         id: deliveryResource.buildId({
             id: `${getSymphonyArchiveKey(worker.session.uri)}-report`,
@@ -1388,14 +727,14 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
         kind: 'report',
         status: 'completed',
         task,
-        source: workerContact,
-        target: secretaryContact,
+        source: workerAgent,
+        target: secretaryAgent,
         chat: selectWorkerChatIri(plan, webId, worker),
         thread: selectWorkerThreadIri(plan, webId, worker),
         targetThread: selectTargetThreadIri(plan.issue.thread ?? worker.session.target?.thread, webId, plan),
         targetSession: buildSymphonyControlSessionUri(webId, plan),
         actor: workerAgent,
-        object: report,
+        object: run,
         objective: summary,
         payload: {
             kind: 'symphony_report',
@@ -1404,25 +743,18 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
             issue: buildSymphonyIssueIri(webId, plan.issue),
             task,
             delivery: originalDelivery,
-            report,
             reportDelivery: buildSymphonyReportDeliveryIri(webId, worker),
             session: buildSymphonyControlSessionUri(webId, plan),
             run,
             backend: worker.session.backend,
             agent: worker.session.target.agent,
-            contact: worker.session.target.contact ?? buildWorkerContactId(worker),
-            sourceAgent: workerAgent,
-            sourceContact: workerContact,
             autoModeSessionId: worker.session.autoModeSessionId,
             exitCode: worker.session.exitCode,
             error: worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error,
-            reportFile: buildSymphonyReportDocumentPath(worker),
-            evidenceFile: buildSymphonyEvidenceDocumentPath(worker, stage),
-            postRunReconciliation: buildPostRunReconciliationMetadata(plan, webId, worker, stage),
+            acceptanceReview: worker.delivery.acceptanceReview ?? worker.taskRecord.acceptanceReview ?? worker.session.acceptanceReview,
             evidence: {
-                statusMessage: buildSymphonyMessageUri(webId, plan, buildStatusMessageRow(plan, webId, stage)),
-                sourceRunStep,
-                evidence,
+                statusMessage: buildSharedSymphonyMessageIri(webId, plan, buildSharedSymphonyStatusMessageRow(plan, webId, stage)),
+                runStep: buildSymphonyRunStepIri(webId, worker, stage),
             },
         },
         projection: {
@@ -1439,11 +771,7 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
                 session: worker.session.uri,
             }),
             reportKind: 'worker-completion',
-            filePrimary: true,
-            reportFile: buildSymphonyReportDocumentPath(worker),
-            evidence,
-            evidenceFile: buildSymphonyEvidenceDocumentPath(worker, stage),
-            postRunReconciliation: buildPostRunReconciliationMetadata(plan, webId, worker, stage),
+            acceptanceReview: worker.delivery.acceptanceReview ?? worker.taskRecord.acceptanceReview ?? worker.session.acceptanceReview,
         },
         error: status === 'failed' ? worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error : undefined,
         createdAt: completedAt,
@@ -1453,101 +781,13 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
         updatedAt: completedAt,
     };
 }
-function buildSymphonyRunRow(plan, webId, worker) {
-    const createdAt = safeDate(worker.session.createdAt);
-    const updatedAt = safeDate(worker.session.updatedAt);
-    return {
-        id: runResource.buildId({
-            id: getSymphonyArchiveKey(worker.session.uri),
-            task: buildSymphonyTaskIri(webId, worker.task),
-            createdAt,
-        }),
-        task: buildSymphonyTaskIri(webId, worker.task),
-        delivery: buildSymphonyDeliveryIri(webId, worker),
-        trigger: plan.issue.messages?.at(-1) ?? buildSymphonyIssueIri(webId, plan.issue),
-        input: buildSymphonyDeliveryIri(webId, worker),
-        thread: selectWorkerThreadIri(plan, webId, worker),
-        workspace: pathToWorkspaceUri(worker.session.cwd) ?? pathToWorkspaceUri(plan.session.cwd) ?? 'file:///',
-        status: mapSymphonyRunStatus(worker.session.status),
-        runner: worker.session.backend,
-        prompt: worker.delivery.projection.prompt,
-        externalRunId: worker.session.autoModeSessionId,
-        error: worker.session.error,
-        metadata: {
-            surface: 'symphony',
-            ...buildSymphonyArchiveMetadata({ session: worker.session.uri }),
-            mode: worker.session.mode,
-            model: worker.session.model,
-            target: worker.session.target,
-            workspace: buildSymphonyWorkspaceMetadata(plan, worker),
-            spaceContract: buildSymphonySpaceContract(plan, webId, worker),
-            podAccessPolicy: buildSymphonyWorkerPodAccessPolicy(plan, webId, worker),
-            reconciler: buildSymphonyReconcilerMetadata(worker),
-            exitCode: worker.session.exitCode,
-            dryRun: worker.session.dryRun,
-        },
-        createdAt,
-        startedAt: worker.session.status === 'running' || worker.session.status === 'completed' || worker.session.status === 'failed'
-            ? updatedAt
-            : undefined,
-        completedAt: worker.session.completedAt ? safeDate(worker.session.completedAt) : undefined,
-        updatedAt,
-    };
-}
-function buildSymphonyRunStepRow(plan, webId, worker, stage) {
-    const run = buildSymphonyRunIri(webId, worker);
-    const createdAt = stage === 'planned' ? safeDate(worker.session.createdAt) : safeDate(worker.session.updatedAt);
-    const stepType = stage === 'planned'
-        ? 'run.created'
-        : stage === 'running'
-            ? 'run.started'
-            : stage === 'completed'
-                ? 'run.completed'
-                : 'run.failed';
-    return {
-        id: runStepResource.buildId({
-            id: `${getSymphonyArchiveKey(worker.session.uri)}-${stage}`,
-            run,
-        }),
-        run,
-        stepType,
-        message: buildStatusContent(plan, stage),
-        data: {
-            surface: 'symphony',
-            stage,
-            issue: buildSymphonyIssueIri(webId, plan.issue),
-            task: buildSymphonyTaskIri(webId, worker.task),
-            delivery: buildSymphonyDeliveryIri(webId, worker),
-            archive: buildSymphonyArchiveRefs({ session: worker.session.uri }),
-            autoModeSessionId: worker.session.autoModeSessionId,
-        },
-        createdAt,
-    };
-}
-function normalizeSymphonyActorKey(value, fallback) {
-    return (value ?? fallback)
+function buildWorkerAgentId(backend, agent) {
+    const suffix = (agent ?? `${backend}-worker`)
         .trim()
         .replace(/[^a-zA-Z0-9._-]/gu, '-')
         .replace(/-+/gu, '-')
-        .replace(/^-|-$/gu, '')
-        || fallback;
-}
-function buildWorkerContactId(worker) {
-    return normalizeSymphonyActorKey(worker.session.target.contact ?? worker.session.target.agent ?? worker.delivery.targetAgent, worker.session.backend);
-}
-function buildWorkerAgentId(backend, agent, contact) {
-    return normalizeSymphonyActorKey(agent ?? contact, backend);
-}
-function buildSecretaryContactIri(webId) {
-    return contactResource.buildIri(webId, { id: SYMPHONY_CONTACT_ID });
-}
-function buildWorkerAgentIri(webId, worker) {
-    return agentResource.buildIri(webId, {
-        id: buildWorkerAgentId(worker.session.backend, worker.session.target.agent, worker.session.target.contact),
-    });
-}
-function buildWorkerContactIri(webId, worker) {
-    return contactResource.buildIri(webId, { id: buildWorkerContactId(worker) });
+        .replace(/^-|-$/gu, '');
+    return `symphony-${suffix || `${backend}-worker`}`;
 }
 function buildSymphonyAgents(plan) {
     const now = safeDate(plan.session.updatedAt);
@@ -1564,7 +804,7 @@ function buildSymphonyAgents(plan) {
     ];
     const seen = new Set(agents.map((agent) => agent.id));
     for (const worker of plan.workers) {
-        const id = buildWorkerAgentId(worker.session.backend, worker.session.target.agent, worker.session.target.contact);
+        const id = buildWorkerAgentId(worker.session.backend, worker.session.target.agent);
         if (seen.has(id)) {
             continue;
         }
@@ -1581,146 +821,6 @@ function buildSymphonyAgents(plan) {
     }
     return agents;
 }
-function buildSymphonyContacts(plan, webId) {
-    const now = safeDate(plan.session.updatedAt);
-    const contacts = [
-        {
-            id: SYMPHONY_CONTACT_ID,
-            name: 'AI Secretary',
-            entity: agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID }),
-            rdfType: ContactClass.AGENT,
-            contactType: ContactType.AGENT,
-            createdAt: now,
-            updatedAt: now,
-        },
-    ];
-    const seen = new Set(contacts.map((contact) => contact.id));
-    for (const worker of plan.workers) {
-        const id = buildWorkerContactId(worker);
-        if (seen.has(id)) {
-            continue;
-        }
-        seen.add(id);
-        contacts.push({
-            id,
-            name: worker.session.target.label ?? worker.session.target.contact ?? worker.session.target.agent ?? backendDisplayName(worker.session.backend),
-            entity: buildWorkerAgentIri(webId, worker),
-            rdfType: ContactClass.AGENT,
-            contactType: ContactType.AGENT,
-            createdAt: now,
-            updatedAt: now,
-        });
-    }
-    return contacts;
-}
-function buildProgressBlock(plan, stage) {
-    const statusByStage = {
-        planned: 'pending',
-        running: 'running',
-        completed: 'done',
-        failed: 'error',
-    };
-    const workerSteps = plan.workers.map((worker, index) => ({
-        id: `${buildSymphonyThreadId(plan)}-worker-${index + 1}`,
-        label: `${worker.session.target.label ?? worker.session.target.agent ?? backendDisplayName(worker.session.backend)} worker`,
-        status: worker.session.status === 'completed'
-            ? 'done'
-            : worker.session.status === 'failed'
-                ? 'error'
-                : worker.session.status === 'running'
-                    ? 'running'
-                    : statusByStage[stage],
-        detail: worker.session.autoModeSessionId ?? worker.session.uri,
-    }));
-    return {
-        type: 'task_progress',
-        task: plan.task,
-        title: plan.issue.title,
-        steps: [
-            {
-                id: `${buildSymphonyThreadId(plan)}-plan`,
-                label: 'Secretary created task projection',
-                status: stage === 'planned' ? 'running' : 'done',
-                detail: plan.issue.uri,
-            },
-            ...workerSteps,
-            {
-                id: `${buildSymphonyThreadId(plan)}-finish`,
-                label: 'Archive Symphony result',
-                status: stage === 'completed' ? 'done' : stage === 'failed' ? 'error' : 'pending',
-                detail: plan.issue.error ?? plan.session.error ?? `${plan.workers.length} worker${plan.workers.length === 1 ? '' : 's'}`,
-            },
-        ],
-        currentStep: stage === 'planned' ? 1 : stage === 'running' ? 2 : workerSteps.length + 2,
-        totalSteps: workerSteps.length + 2,
-    };
-}
-function buildStatusContent(plan, stage) {
-    if (stage === 'planned') {
-        return `I created a Symphony issue with ${plan.workers.length} worker${plan.workers.length === 1 ? '' : 's'}.\n\n${plan.issue.description ?? plan.issue.title}`;
-    }
-    if (stage === 'running') {
-        const running = plan.workers
-            .filter((worker) => worker.session.status === 'running')
-            .map((worker) => worker.session.target.label ?? worker.session.target.agent ?? backendDisplayName(worker.session.backend));
-        return `Symphony workers are active: ${running.length > 0 ? running.join(', ') : plan.workers.length}.\n\nIssue: ${plan.issue.uri}`;
-    }
-    if (stage === 'completed') {
-        return `Symphony issue completed.\n\nWorkers: ${plan.workers.length}`;
-    }
-    return `Symphony issue failed.\n\n${plan.issue.error ?? plan.session.error ?? plan.delivery.error ?? 'Backend did not complete successfully.'}`;
-}
-function buildStatusMessageRow(plan, webId, stage) {
-    const createdAt = stage === 'planned'
-        ? safeDate(plan.issue.createdAt)
-        : safeDate(plan.session.updatedAt);
-    const content = buildStatusContent(plan, stage);
-    const secretaryAgent = agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID });
-    const routeTargetAgent = agentResource.buildIri(webId, {
-        id: buildWorkerAgentId(plan.session.backend, plan.session.target?.agent, plan.session.target?.contact),
-    });
-    return {
-        id: `${buildSymphonyThreadId(plan)}-${stage}`,
-        chat: selectTargetChatIri(plan.session.target?.chat, webId, plan),
-        thread: selectTargetThreadIri(plan.session.target?.thread, webId, plan),
-        maker: secretaryAgent,
-        role: 'assistant',
-        content,
-        richContent: JSON.stringify({
-            blocks: [buildProgressBlock(plan, stage)],
-            symphony: {
-                stage,
-                issue: plan.issue.uri,
-                task: plan.task,
-                delivery: plan.delivery.uri,
-                session: plan.session.uri,
-                issuer: plan.issue.issuer,
-                workers: plan.workers.map((worker) => ({
-                    task: worker.task,
-                    title: worker.taskRecord.title,
-                    objective: worker.taskRecord.objective,
-                    acceptanceCriteria: worker.taskRecord.acceptanceCriteria,
-                    taskStatus: worker.taskRecord.status,
-                    delivery: worker.delivery.uri,
-                    session: worker.session.uri,
-                    backend: worker.session.backend,
-                    agent: worker.session.target.agent,
-                    contact: worker.session.target.contact ?? buildWorkerContactId(worker),
-                    status: worker.session.status,
-                    autoModeSessionId: worker.session.autoModeSessionId,
-                })),
-                autoModeSessionId: plan.session.autoModeSessionId,
-            },
-        }),
-        status: stage === 'failed' ? 'error' : 'sent',
-        senderName: 'AI Secretary',
-        routedBy: secretaryAgent,
-        routeTargetAgent,
-        coordinationId: plan.session.uri,
-        createdAt,
-        updatedAt: createdAt,
-    };
-}
 function auditActionForStage(stage) {
     if (stage === 'running')
         return 'symphony.dispatched';
@@ -1743,13 +843,15 @@ function buildSymphonyReportInboxNotificationRow(webId, worker) {
     const createdAt = safeDate(worker.session.completedAt ?? worker.session.updatedAt);
     return {
         id: stableReportInboxNotificationId(worker),
-        actor: buildWorkerContactIri(webId, worker),
+        actor: agentResource.buildIri(webId, {
+            id: buildWorkerAgentId(worker.session.backend, worker.session.target.agent),
+        }),
         object: buildSymphonyReportDeliveryIri(webId, worker),
         createdAt,
     };
 }
 function buildSymphonyAuditRow(plan, webId, stage) {
-    const message = buildStatusMessageRow(plan, webId, stage);
+    const message = buildSharedSymphonyStatusMessageRow(plan, webId, stage);
     const createdAt = safeDate(message.createdAt);
     return {
         id: stableAuditId(plan, stage),
@@ -1758,7 +860,7 @@ function buildSymphonyAuditRow(plan, webId, stage) {
         actorRole: 'secretary',
         onBehalfOf: webId,
         session: buildSymphonyControlSessionUri(webId, plan),
-        entry: buildSymphonyMessageUri(webId, plan, message),
+        entry: buildSharedSymphonyMessageIri(webId, plan, message),
         policyVersion: SYMPHONY_POLICY_VERSION,
         createdAt,
     };
@@ -1795,6 +897,7 @@ async function upsertMessage(db, runtime, row) {
         routedBy: row.routedBy,
         routeTargetAgent: row.routeTargetAgent,
         coordinationId: row.coordinationId,
+        metadata: row.metadata,
         updatedAt: row.updatedAt,
     });
 }
@@ -1821,12 +924,12 @@ async function upsertIssue(db, runtime, row) {
     await upsertExactRecord(db, runtime.issueResource, { id: row.id }, row, {
         title: row.title,
         description: row.description,
-        document: row.document,
         status: row.status,
         priority: row.priority,
         labels: row.labels,
         chat: row.chat,
         thread: row.thread,
+        parentIssue: row.parentIssue,
         tasks: row.tasks,
         assignedTo: row.assignedTo,
         updatedAt: row.updatedAt,
@@ -1836,7 +939,6 @@ async function upsertIssue(db, runtime, row) {
 async function upsertIdea(db, runtime, row) {
     await upsertExactRecord(db, runtime.ideaResource, { id: row.id }, row, {
         summary: row.summary,
-        document: row.document,
         input: row.input,
         status: row.status,
         commitment: row.commitment,
@@ -1871,51 +973,6 @@ async function upsertTask(db, runtime, row) {
         updatedAt: row.updatedAt,
     });
 }
-async function upsertReport(db, runtime, row) {
-    await upsertExactRecord(db, runtime.reportResource, {
-        id: row.id,
-        task: row.task,
-        createdAt: row.createdAt,
-    }, row, {
-        reportKind: row.reportKind,
-        status: row.status,
-        outcome: row.outcome,
-        about: row.about,
-        issue: row.issue,
-        task: row.task,
-        delivery: row.delivery,
-        run: row.run,
-        thread: row.thread,
-        evidence: row.evidence,
-        summary: row.summary,
-        reviewer: row.reviewer,
-        actor: row.actor,
-        source: row.source,
-        metricFacts: row.metricFacts,
-        metadata: row.metadata,
-        publishedAt: row.publishedAt,
-        updatedAt: row.updatedAt,
-    });
-}
-async function upsertEvidence(db, runtime, row) {
-    await upsertExactRecord(db, runtime.evidenceResource, {
-        id: row.id,
-        createdAt: row.createdAt,
-    }, row, {
-        evidenceKind: row.evidenceKind,
-        about: row.about,
-        issue: row.issue,
-        task: row.task,
-        delivery: row.delivery,
-        run: row.run,
-        thread: row.thread,
-        summary: row.summary,
-        source: row.source,
-        actor: row.actor,
-        outcome: row.outcome,
-        metadata: row.metadata,
-    });
-}
 async function upsertDelivery(db, runtime, row) {
     await upsertExactRecord(db, runtime.deliveryResource, { id: row.id }, row, {
         kind: row.kind,
@@ -1962,6 +1019,31 @@ async function upsertRun(db, runtime, row) {
 async function insertRunStepOnce(db, runtime, row) {
     await insertExactRecordOnce(db, runtime.runStepResource, String(row.id), row);
 }
+async function insertEvidenceOnce(db, runtime, row) {
+    await insertExactRecordOnce(db, runtime.evidenceResource, String(row.id), row);
+}
+async function upsertReport(db, runtime, row) {
+    await upsertExactRecord(db, runtime.reportResource, { id: row.id }, row, {
+        reportKind: row.reportKind,
+        status: row.status,
+        outcome: row.outcome,
+        about: row.about,
+        issue: row.issue,
+        task: row.task,
+        delivery: row.delivery,
+        run: row.run,
+        thread: row.thread,
+        evidence: row.evidence,
+        summary: row.summary,
+        reviewer: row.reviewer,
+        actor: row.actor,
+        source: row.source,
+        metricFacts: row.metricFacts,
+        metadata: row.metadata,
+        publishedAt: row.publishedAt,
+        updatedAt: row.updatedAt,
+    });
+}
 async function upsertAgent(db, runtime, row) {
     const target = { id: row.id };
     const agentResourceWithId = runtime.agentResource;
@@ -1981,7 +1063,7 @@ async function upsertAgent(db, runtime, row) {
 async function upsertContact(db, runtime, row) {
     await upsertExactRecord(db, runtime.contactResource, { id: row.id }, row, {
         name: row.name,
-        entity: row.entity,
+        about: row.about,
         rdfType: row.rdfType,
         contactType: row.contactType,
         updatedAt: row.updatedAt,
@@ -2000,7 +1082,7 @@ async function insertInboxNotificationOnce(db, runtime, row) {
     await insertExactRecordOnce(db, runtime.inboxNotificationResource, String(row.id), row);
 }
 function collectMessageUris(webId, plan, stages) {
-    return Array.from(new Set(stages.map((stage) => buildSymphonyMessageUri(webId, plan, buildStatusMessageRow(plan, webId, stage)))));
+    return Array.from(new Set(stages.map((stage) => buildSharedSymphonyMessageIri(webId, plan, buildSharedSymphonyStatusMessageRow(plan, webId, stage)))));
 }
 function collectSymphonyProjectionResources(webId, plan, stages) {
     const resources = [];
@@ -2015,13 +1097,16 @@ function collectSymphonyProjectionResources(webId, plan, stages) {
     };
     add('chat', selectTargetChatIri(plan.session.target?.chat, webId, plan));
     add('issue', buildSymphonyIssueIri(webId, plan.issue));
+    for (const issue of plan.followUpIssues ?? []) {
+        add('issue', buildSymphonyIssueIri(webId, issue));
+    }
     for (const message of collectMessageUris(webId, plan, stages)) {
         add('message', message);
     }
     for (const agent of buildSymphonyAgents(plan)) {
         add('agent', agentResource.buildIri(webId, { id: agent.id }));
     }
-    for (const contact of buildSymphonyContacts(plan, webId)) {
+    for (const contact of buildSharedSymphonyContactRows(plan, webId)) {
         add('contact', contactResource.buildIri(webId, { id: contact.id }));
     }
     for (const worker of plan.workers) {
@@ -2034,10 +1119,10 @@ function collectSymphonyProjectionResources(webId, plan, stages) {
         for (const stage of stages) {
             add('runStep', buildSymphonyRunStepIri(webId, worker, stage));
         }
+        for (const step of worker.runSteps ?? []) {
+            add('runStep', buildSymphonyRuntimeRunStepIri(webId, worker, step));
+        }
         if (worker.session.status === 'completed' || worker.session.status === 'failed') {
-            const terminalStage = worker.session.status === 'failed' ? 'failed' : 'completed';
-            add('evidence', buildSymphonyEvidenceIri(webId, worker, terminalStage));
-            add('report', buildSymphonyReportIri(webId, worker));
             add('delivery', buildSymphonyReportDeliveryIri(webId, worker));
         }
     }
@@ -2074,7 +1159,6 @@ export async function persistSymphonyControlStateToPod(plan, options = {}) {
     };
     const projected = withTargetRefs(normalizedPlan, refs, podSession.webId);
     const resources = collectSymphonyProjectionResources(podSession.webId, projected, stages);
-    const latestMessage = buildStatusMessageRow(projected, podSession.webId, stage);
     const controlWrite = createLinxPodSyncScope({
         source: 'symphony-control-state',
         plane: 'control-plane',
@@ -2110,9 +1194,7 @@ export async function persistSymphonyControlStateToPod(plan, options = {}) {
             webId: podSession.webId,
             stage,
             stages,
-            latestMessage,
             shouldUpsertChat: !normalizedPlan.session.target?.chat,
-            podSession,
         }),
     });
     return {
@@ -2186,10 +1268,6 @@ function resolveProjectionResourceModel(runtime, kind) {
         return runtime.taskResource;
     if (kind === 'delivery')
         return runtime.deliveryResource;
-    if (kind === 'evidence')
-        return runtime.evidenceResource;
-    if (kind === 'report')
-        return runtime.reportResource;
     if (kind === 'run')
         return runtime.runResource;
     if (kind === 'runStep')
@@ -2204,6 +1282,14 @@ function resolveProjectionResourceModel(runtime, kind) {
         return runtime.inboxNotificationResource ?? null;
     return null;
 }
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function normalizeString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
 function serializeOrmRowAsJsonLd(model, iri, row) {
     const context = {};
     const document = {
@@ -2327,18 +1413,7 @@ export async function persistSymphonyIdeaToPod(idea, options = {}) {
                 },
             },
             {
-                id: 'symphony.idea.write-file-primary-document',
-                kind: 'upsert',
-                apply: async () => {
-                    await runtime.writePodFile?.(podSession, {
-                        path: buildSymphonyIdeaDocumentPath(idea),
-                        content: renderSymphonyIdeaMarkdown(idea),
-                        contentType: 'text/markdown; charset=utf-8',
-                    });
-                },
-            },
-            {
-                id: 'symphony.idea.upsert-meta',
+                id: 'symphony.idea.upsert',
                 kind: 'upsert',
                 apply: () => upsertIdea(db, runtime, buildSymphonyIdeaRow(idea, podSession.webId)),
             },
@@ -2354,13 +1429,10 @@ export async function listOpenSymphonyIssuesFromPod(options = {}) {
     }
     const db = runtime.createDb(podSession);
     try {
-        await db.init([runtime.issueResource]).catch(() => undefined);
-        const rows = await db.select().from(runtime.issueResource).execute();
-        return rows
-            .map((row) => issueRowToSymphonyIssueRecord(row, podSession.webId))
-            .filter((issue) => issue !== null)
-            .filter((issue) => !isClosedIssueStatus(issue.status))
-            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        return await listOpenSymphonyIssuesFromControlState({
+            db,
+            webId: podSession.webId,
+        });
     }
     catch {
         return null;
@@ -2374,13 +1446,7 @@ export async function listRunningSymphonyWorkersFromPod(options = {}) {
     }
     const db = runtime.createDb(podSession);
     try {
-        await db.init([runtime.sessionResource]).catch(() => undefined);
-        const rows = await db.select().from(runtime.sessionResource).execute();
-        return rows
-            .filter(isSymphonySessionRow)
-            .flatMap((row) => extractRunningSymphonyWorkersFromSession(row))
-            .sort(compareWorkerStatusUpdatedAt)
-            .map(({ updatedAt: _updatedAt, ...worker }) => worker);
+        return await listRunningSymphonyWorkersFromControlState({ db });
     }
     catch {
         return null;
@@ -2394,217 +1460,22 @@ export async function listRecentSymphonyReportsFromPod(options = {}) {
     }
     const db = runtime.createDb(podSession);
     try {
-        await db.init([runtime.deliveryResource]).catch(() => undefined);
-        const rows = await db.select().from(runtime.deliveryResource).execute();
-        return rows
-            .map(deliveryRowToSymphonyReportStatus)
-            .filter((report) => report !== null)
-            .sort((left, right) => right.sortAt - left.sortAt)
-            .slice(0, options.limit ?? 5)
-            .map(({ sortAt: _sortAt, ...report }) => report);
+        return await listRecentSymphonyReportsFromControlState({
+            db,
+            limit: options.limit ?? 5,
+        });
     }
     catch {
         return null;
     }
 }
-function issueRowToSymphonyIssueRecord(row, webId) {
-    const record = asRecord(row);
-    const id = normalizeString(record?.id);
-    const title = normalizeString(record?.title);
-    if (!record || !id || !title) {
-        return null;
-    }
-    const status = normalizeIssueStatus(record.status);
-    const priority = normalizeIssuePriority(record.priority);
-    const tasks = Array.isArray(record.tasks)
-        ? record.tasks.map((item) => normalizeString(item)).filter((item) => Boolean(item))
-        : [];
-    const createdAt = toIsoDate(record.createdAt);
-    const updatedAt = toIsoDate(record.updatedAt) ?? createdAt;
-    return {
-        uri: symphonyIssueUriFromResourceId(id),
-        title,
-        description: normalizeString(record.description),
-        status,
-        priority,
-        source: 'cli',
-        issuer: {
-            source: 'user',
-            webId: normalizeString(record.createdBy) ?? webId,
-            ...(normalizeString(record.chat) ? { chat: normalizeString(record.chat) } : {}),
-            ...(normalizeString(record.thread) ? { thread: normalizeString(record.thread) } : {}),
-        },
-        tasks,
-        deliveries: [],
-        sessions: [],
-        ...(normalizeString(record.chat) ? { chat: normalizeString(record.chat) } : {}),
-        ...(normalizeString(record.thread) ? { thread: normalizeString(record.thread) } : {}),
-        createdAt,
-        updatedAt,
-        ...(record.closedAt ? { closedAt: toIsoDate(record.closedAt) ?? updatedAt } : {}),
-    };
-}
-function symphonyIssueUriFromResourceId(id) {
-    const normalized = resolvePodResourceTemplateValue(issueResource, id) ?? id;
-    return `urn:undefineds:linx:issue:${normalized}`;
-}
-function normalizeIssueStatus(value) {
-    const normalized = normalizeString(value);
-    if (normalized === 'open'
-        || normalized === 'triaging'
-        || normalized === 'in_progress'
-        || normalized === 'blocked'
-        || normalized === 'resolved'
-        || normalized === 'closed') {
-        return normalized;
-    }
-    return 'open';
-}
-function normalizeIssuePriority(value) {
-    const normalized = normalizeString(value);
-    if (normalized === 'low' || normalized === 'medium' || normalized === 'high' || normalized === 'urgent') {
-        return normalized;
-    }
-    return 'medium';
-}
-function isClosedIssueStatus(status) {
-    return status === 'closed' || status === 'resolved';
-}
-function isSymphonySessionRow(row) {
-    if (!row || typeof row !== 'object') {
-        return false;
-    }
-    const record = row;
-    const metadata = asRecord(record.metadata);
-    return metadata?.kind === 'symphony-run'
-        || record.policyVersion === SYMPHONY_POLICY_VERSION
-        || (typeof record.tool === 'string' && record.tool.startsWith('symphony:'));
-}
-function extractRunningSymphonyWorkersFromSession(row) {
-    const metadata = asRecord(row.metadata) ?? {};
-    const sessionStatus = normalizePodSymphonySessionStatus(metadata.status ?? row.status);
-    const workers = Array.isArray(metadata.workers) ? metadata.workers : [];
-    const updatedAt = safeOptionalDate(row.updatedAt);
-    if (workers.length === 0) {
-        if (sessionStatus !== 'running') {
-            return [];
-        }
-        return [{
-                status: sessionStatus,
-                backend: normalizeString(metadata.backend) ?? parseBackendFromTool(row.tool) ?? 'unknown',
-                mode: normalizeString(metadata.mode) ?? 'auto',
-                cwd: normalizeString(metadata.workspacePath),
-                autoModeSessionId: normalizeString(metadata.autoModeSessionId),
-                target: normalizeSymphonyWorkerTarget(asRecord(metadata.target)),
-                updatedAt,
-            }];
-    }
-    return workers
-        .map((item) => asRecord(item))
-        .filter((item) => item !== null)
-        .map((worker) => ({
-        status: normalizePodSymphonySessionStatus(worker.status ?? worker.taskStatus ?? sessionStatus),
-        backend: normalizeString(worker.backend) ?? normalizeString(metadata.backend) ?? parseBackendFromTool(row.tool) ?? 'unknown',
-        mode: normalizeString(worker.mode) ?? normalizeString(metadata.mode) ?? 'auto',
-        cwd: normalizeString(worker.workspacePath) ?? normalizeString(metadata.workspacePath),
-        autoModeSessionId: normalizeString(worker.autoModeSessionId) ?? normalizeString(metadata.autoModeSessionId),
-        target: normalizeSymphonyWorkerTarget(asRecord(worker.target), worker, asRecord(metadata.target)),
-        updatedAt,
-    }))
-        .filter((worker) => worker.status === 'running');
-}
-function deliveryRowToSymphonyReportStatus(row) {
-    const record = asRecord(row);
-    if (!record) {
-        return null;
-    }
-    const metadata = asRecord(record.metadata);
-    const payload = asRecord(record.payload);
-    if (record.kind !== 'report' && metadata?.reportKind !== 'worker-completion' && payload?.kind !== 'symphony_report') {
-        return null;
-    }
-    const completedAt = safeOptionalDate(record.completedAt);
-    const updatedAt = safeOptionalDate(record.updatedAt);
-    const createdAt = safeOptionalDate(record.createdAt);
-    const sortAt = completedAt?.getTime() ?? updatedAt?.getTime() ?? createdAt?.getTime() ?? 0;
-    const agent = normalizeString(payload?.agent);
-    const title = normalizeString(record.objective);
-    const summary = normalizeString(payload?.summary);
-    const task = normalizeString(record.task);
-    const archive = asRecord(metadata?.archive);
-    const delivery = normalizeString(payload?.delivery) ?? normalizeString(archive?.delivery);
-    const reportDelivery = normalizeString(payload?.reportDelivery) ?? normalizeString(record.id);
-    const run = normalizeString(payload?.run) ?? normalizeString(record.object);
-    const chat = normalizeString(record.chat);
-    const thread = normalizeString(record.thread);
-    const autoModeSessionId = normalizeString(payload?.autoModeSessionId);
-    const error = normalizeString(payload?.error) ?? normalizeString(record.error);
-    return {
-        status: normalizeString(payload?.outcome) ?? normalizeString(record.status) ?? 'completed',
-        backend: normalizeString(payload?.backend) ?? 'unknown',
-        ...(agent ? { agent } : {}),
-        ...(title ? { title } : {}),
-        ...(summary ? { summary } : {}),
-        ...(task ? { task } : {}),
-        ...(delivery ? { delivery } : {}),
-        ...(reportDelivery ? { reportDelivery } : {}),
-        ...(run ? { run } : {}),
-        ...(chat ? { chat } : {}),
-        ...(thread ? { thread } : {}),
-        ...(autoModeSessionId ? { autoModeSessionId } : {}),
-        ...(error ? { error } : {}),
-        ...(completedAt ? { completedAt: completedAt.toISOString() } : {}),
-        ...(updatedAt ? { updatedAt: updatedAt.toISOString() } : {}),
-        sortAt,
-    };
-}
-function normalizeSymphonyWorkerTarget(target, worker = {}, fallback = null) {
-    const normalized = {
-        label: normalizeString(target?.label) ?? normalizeString(worker.title) ?? normalizeString(fallback?.label),
-        agent: normalizeString(target?.agent) ?? normalizeString(worker.agent) ?? normalizeString(fallback?.agent),
-        chat: normalizeString(target?.chat) ?? normalizeString(worker.chat) ?? normalizeString(fallback?.chat),
-    };
-    return Object.values(normalized).some(Boolean) ? normalized : undefined;
-}
-function compareWorkerStatusUpdatedAt(left, right) {
-    return (right.updatedAt?.getTime() ?? 0) - (left.updatedAt?.getTime() ?? 0);
-}
-function normalizePodSymphonySessionStatus(value) {
-    const normalized = normalizeString(value);
-    if (normalized === 'active')
-        return 'running';
-    if (normalized === 'error')
-        return 'failed';
-    if (normalized === 'queued')
-        return 'planned';
-    return normalized ?? 'planned';
-}
-function parseBackendFromTool(value) {
-    const tool = normalizeString(value);
-    if (!tool?.startsWith('symphony:')) {
-        return undefined;
-    }
-    return tool.slice('symphony:'.length) || undefined;
-}
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
-}
-function normalizeString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function safeOptionalDate(value) {
-    if (!value) {
-        return undefined;
-    }
-    const date = value instanceof Date ? value : new Date(String(value));
-    return Number.isFinite(date.getTime()) ? date : undefined;
-}
-function toIsoDate(value) {
-    return (safeOptionalDate(value) ?? new Date()).toISOString();
-}
 function buildSymphonyProjectionOperations(input) {
+    const controlRows = buildSymphonyControlRows({
+        plan: input.plan,
+        webId: input.webId,
+        stage: input.stage,
+        stages: input.stages,
+    });
     return [
         {
             id: 'symphony.prepare-resources',
@@ -2618,10 +1489,10 @@ function buildSymphonyProjectionOperations(input) {
                     input.runtime.issueResource,
                     input.runtime.taskResource,
                     input.runtime.deliveryResource,
-                    input.runtime.evidenceResource,
-                    input.runtime.reportResource,
                     input.runtime.runResource,
                     input.runtime.runStepResource,
+                    input.runtime.evidenceResource,
+                    input.runtime.reportResource,
                     input.runtime.agentResource,
                     input.runtime.contactResource,
                     input.runtime.auditResource,
@@ -2630,82 +1501,84 @@ function buildSymphonyProjectionOperations(input) {
             },
         },
         {
-            id: 'symphony.write-file-primary-documents',
+            id: 'symphony.upsert-issue',
             kind: 'upsert',
-            apply: async () => {
-                await input.runtime.writePodFile?.(input.podSession, {
-                    path: buildSymphonyIssueDocumentPath(input.plan.issue),
-                    content: renderSymphonyIssueMarkdown(input.plan),
-                    contentType: 'text/markdown; charset=utf-8',
-                });
-            },
+            apply: () => upsertIssue(input.db, input.runtime, controlRows.issue),
         },
-        {
-            id: 'symphony.upsert-issue-meta',
+        ...controlRows.issues.slice(1).map((row, index) => ({
+            id: `symphony.upsert-follow-up-issue:${index + 1}`,
             kind: 'upsert',
-            apply: () => upsertIssue(input.db, input.runtime, buildSymphonyIssueRow(input.plan, input.webId)),
-        },
-        ...input.plan.workers.flatMap((worker, index) => [
-            {
-                id: `symphony.upsert-task:${index + 1}`,
-                kind: 'upsert',
-                apply: () => upsertTask(input.db, input.runtime, buildSymphonyTaskRow(input.plan, input.webId, worker)),
-            },
-            {
-                id: `symphony.upsert-delivery:${index + 1}`,
-                kind: 'upsert',
-                apply: () => upsertDelivery(input.db, input.runtime, buildSymphonyDeliveryRow(input.plan, input.webId, worker)),
-            },
-            {
-                id: `symphony.upsert-run:${index + 1}`,
-                kind: 'upsert',
-                apply: () => upsertRun(input.db, input.runtime, buildSymphonyRunRow(input.plan, input.webId, worker)),
-            },
-            ...input.stages.map((stage) => ({
-                id: `symphony.insert-run-step:${index + 1}:${stage}`,
-                kind: 'insert',
-                apply: () => insertRunStepOnce(input.db, input.runtime, buildSymphonyRunStepRow(input.plan, input.webId, worker, stage)),
-            })),
-        ]),
+            apply: () => upsertIssue(input.db, input.runtime, row),
+        })),
+        ...controlRows.tasks.map((row, index) => ({
+            id: `symphony.upsert-task:${index + 1}`,
+            kind: 'upsert',
+            apply: () => upsertTask(input.db, input.runtime, row),
+        })),
+        ...controlRows.deliveries.map((row, index) => ({
+            id: `symphony.upsert-delivery:${index + 1}`,
+            kind: 'upsert',
+            apply: () => upsertDelivery(input.db, input.runtime, row),
+        })),
+        ...controlRows.runs.map((row, index) => ({
+            id: `symphony.upsert-run:${index + 1}`,
+            kind: 'upsert',
+            apply: () => upsertRun(input.db, input.runtime, row),
+        })),
+        ...controlRows.runSteps.map((row, index) => ({
+            id: `symphony.insert-run-step:${index + 1}`,
+            kind: 'insert',
+            apply: () => insertRunStepOnce(input.db, input.runtime, row),
+        })),
+        ...controlRows.evidence.map((row, index) => ({
+            id: `symphony.insert-evidence:${index + 1}`,
+            kind: 'insert',
+            apply: () => insertEvidenceOnce(input.db, input.runtime, row),
+        })),
+        ...controlRows.reports.map((row, index) => ({
+            id: `symphony.upsert-report:${index + 1}`,
+            kind: 'upsert',
+            apply: () => upsertReport(input.db, input.runtime, row),
+        })),
         ...buildSymphonyReportOperations(input),
         ...buildSymphonyAgents(input.plan).map((agent) => ({
             id: `symphony.upsert-agent:${agent.id}`,
             kind: 'upsert',
             apply: () => upsertAgent(input.db, input.runtime, agent),
         })),
-        ...buildSymphonyContacts(input.plan, input.webId).map((contact) => ({
+        ...controlRows.contacts.map((contact) => ({
             id: `symphony.upsert-contact:${contact.id}`,
             kind: 'upsert',
             apply: () => upsertContact(input.db, input.runtime, contact),
         })),
-        {
+        ...controlRows.chats.map((row, index) => ({
             id: 'symphony.upsert-chat',
             kind: 'upsert',
             shouldRun: () => input.shouldUpsertChat,
-            apply: () => upsertChat(input.db, input.runtime, buildSymphonyChatRow(input.plan, input.webId, input.stage, input.latestMessage.content)),
-        },
-        ...buildSymphonyThreadRows(input.plan, input.webId, input.stage).map((row, index) => ({
+            apply: () => upsertChat(input.db, input.runtime, row),
+        })),
+        ...controlRows.threads.map((row, index) => ({
             id: `symphony.upsert-thread:${index + 1}`,
             kind: 'upsert',
             apply: () => upsertThread(input.db, input.runtime, row),
         })),
-        ...input.plan.workers.map((worker, index) => ({
+        ...controlRows.sessions.map((row, index) => ({
             id: `symphony.upsert-session:${index + 1}`,
             kind: 'upsert',
-            apply: () => upsertSession(input.db, input.runtime, buildSymphonySessionRow(input.plan, input.webId, worker)),
+            apply: () => upsertSession(input.db, input.runtime, row),
         })),
-        ...input.stages.flatMap((stage) => [
+        ...controlRows.messages.flatMap((row, index) => [
             {
-                id: `symphony.upsert-message:${stage}`,
+                id: `symphony.upsert-message:${input.stages[index] ?? index + 1}`,
                 kind: 'upsert',
-                apply: () => upsertMessage(input.db, input.runtime, buildStatusMessageRow(input.plan, input.webId, stage)),
-            },
-            {
-                id: `symphony.insert-audit:${stage}`,
-                kind: 'insert',
-                apply: () => insertAuditOnce(input.db, input.runtime, buildSymphonyAuditRow(input.plan, input.webId, stage)),
+                apply: () => upsertMessage(input.db, input.runtime, row),
             },
         ]),
+        ...input.stages.map((stage) => ({
+            id: `symphony.insert-audit:${stage}`,
+            kind: 'insert',
+            apply: () => insertAuditOnce(input.db, input.runtime, buildSymphonyAuditRow(input.plan, input.webId, stage)),
+        })),
     ];
 }
 function buildSymphonyReportOperations(input) {
@@ -2714,38 +1587,6 @@ function buildSymphonyReportOperations(input) {
     }
     const terminalStage = input.stage;
     return input.plan.workers.flatMap((worker, index) => [
-        {
-            id: `symphony.write-evidence-file:${index + 1}`,
-            kind: 'upsert',
-            apply: async () => {
-                await input.runtime.writePodFile?.(input.podSession, {
-                    path: buildSymphonyEvidenceDocumentPath(worker, terminalStage),
-                    content: renderSymphonyEvidenceMarkdown(input.plan, input.webId, worker, terminalStage),
-                    contentType: 'text/markdown; charset=utf-8',
-                });
-            },
-        },
-        {
-            id: `symphony.upsert-evidence:${index + 1}`,
-            kind: 'upsert',
-            apply: () => upsertEvidence(input.db, input.runtime, buildSymphonyEvidenceRow(input.plan, input.webId, worker, terminalStage)),
-        },
-        {
-            id: `symphony.write-report-file:${index + 1}`,
-            kind: 'upsert',
-            apply: async () => {
-                await input.runtime.writePodFile?.(input.podSession, {
-                    path: buildSymphonyReportDocumentPath(worker),
-                    content: renderSymphonyReportMarkdown(input.plan, worker, terminalStage),
-                    contentType: 'text/markdown; charset=utf-8',
-                });
-            },
-        },
-        {
-            id: `symphony.upsert-report:${index + 1}`,
-            kind: 'upsert',
-            apply: () => upsertReport(input.db, input.runtime, buildSymphonyReportRow(input.plan, input.webId, worker, terminalStage)),
-        },
         {
             id: `symphony.upsert-report-delivery:${index + 1}`,
             kind: 'upsert',
@@ -2771,21 +1612,21 @@ export const __symphonyPodProjectionInternal = {
     buildSymphonyMessageUri,
     auditActionForStage,
     buildSymphonyAuditRow,
-    buildStatusMessageRow,
-    buildSymphonyChatRow,
-    buildSymphonyThreadRow,
-    buildSymphonySessionRow,
-    buildSymphonyIssueRow,
+    buildStatusMessageRow: buildSharedSymphonyStatusMessageRow,
+    buildSymphonyChatRow: buildSharedSymphonyChatRow,
+    buildSymphonyThreadRow: buildSharedSymphonyThreadRow,
+    buildSymphonySessionRow: buildSharedSymphonySessionRow,
+    buildSymphonyIssueRow: buildSharedSymphonyIssueRow,
     buildSymphonyIdeaRow,
-    buildSymphonyTaskRow,
-    buildSymphonyDeliveryRow,
-    buildSymphonyEvidenceRow,
+    buildSymphonyTaskRow: buildSharedSymphonyTaskRow,
+    buildSymphonyDeliveryRow: buildSharedSymphonyDeliveryRow,
     buildSymphonyReportDeliveryRow,
     buildSymphonyReportInboxNotificationRow,
-    buildSymphonyRunRow,
-    buildSymphonyRunStepRow,
+    buildSymphonyRunRow: buildSharedSymphonyRunRow,
+    buildSymphonyRunStepRow: buildSharedSymphonyRunStepRow,
+    buildSymphonyRuntimeRunStepRow: buildSharedSymphonyRuntimeRunStepRow,
     buildSymphonyAgents,
-    buildSymphonyContacts,
+    buildSymphonyContacts: buildSharedSymphonyContactRows,
     withChatThreadRefs,
     normalizeSymphonyRunPlan,
 };