@undefineds.co/linx 0.3.16 → 0.3.17

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

@@ -7,7 +7,7 @@ import { decideThreadControlEvent } from '../../../vendor/agent-runtime/dist/thr
 import { createLinxPodSyncScope } from '../../../vendor/agent-runtime/dist/sync.js';
 import { insertExactRecordOnce, resolvePodResourceTemplateValue, upsertExactRecord, } from '@undefineds.co/drizzle-solid';
 import { getDefaultPodDataSession } from '../pod-data-session.js';
-import { ContactClass, ContactType, chatRepository, agentResource, contactResource, deliveryResource, ideaResource, issueResource, messageResource, runResource, runStepResource, sessionResource, taskResource, threadRepository, } from '../models.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 { getSymphonyHome } from './archive.js';
 const SYMPHONY_CHAT_ID = 'symphony';
@@ -16,6 +16,240 @@ 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
@@ -119,12 +353,15 @@ async function createDefaultRuntime() {
         issueResource: models.issueResource,
         taskResource: models.taskResource,
         deliveryResource: models.deliveryResource,
+        evidenceResource: models.evidenceResource,
+        reportResource: models.reportResource,
         runResource: models.runResource,
         runStepResource: models.runStepResource,
         agentResource: models.agentResource,
-        contactResource: models.contactResource,
+        contactResource: models.contactTable,
         auditResource: models.auditResource,
         inboxNotificationResource: models.inboxNotificationResource,
+        writePodFile: writePodFileToSession,
     };
 }
 function selectTargetChatIri(value, webId, plan) {
@@ -211,6 +448,19 @@ 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),
@@ -808,8 +1058,11 @@ function buildSymphonyIssueRow(plan, webId) {
     const updatedAt = safeDate(plan.issue.updatedAt);
     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,
-        description: plan.issue.description,
+        document: podFileUrlFromWebId(webId, buildSymphonyIssueDocumentPath(plan.issue)),
+        description: undefined,
         status: plan.issue.status,
         priority: plan.issue.priority,
         labels: ['symphony'],
@@ -830,15 +1083,17 @@ function buildSymphonyIdeaRow(idea, webId) {
     return {
         id: getSymphonyArchiveKey(idea.uri),
         summary: idea.summary,
-        input: idea.input,
+        document: podFileUrlFromWebId(webId, buildSymphonyIdeaDocumentPath(idea)),
+        // File-primary: the source text lives in idea.md; TTL keeps only routing/index facts.
+        input: undefined,
         status: idea.status,
         commitment: idea.commitment,
         affectedArea: idea.affectedArea,
-        currentUnderstanding: idea.currentUnderstanding,
-        openQuestions: idea.openQuestions,
+        currentUnderstanding: undefined,
+        openQuestions: undefined,
         related: idea.relatedRecords,
-        conflicts: idea.conflicts,
-        nextStep: idea.nextStep,
+        conflicts: undefined,
+        nextStep: undefined,
         promotedTo: idea.promotedTo,
         chat: idea.chat,
         thread: idea.thread,
@@ -846,6 +1101,8 @@ function buildSymphonyIdeaRow(idea, webId) {
         createdBy: webId,
         metadata: {
             surface: 'symphony',
+            filePrimary: true,
+            documentPath: buildSymphonyIdeaDocumentPath(idea),
             ...buildSymphonyArchiveMetadata({ idea: idea.uri }),
         },
         createdAt,
@@ -965,6 +1222,138 @@ function buildSymphonyDeliveryRow(plan, webId, worker) {
         updatedAt,
     };
 }
+function buildSymphonyReportRow(plan, webId, worker, stage) {
+    const completedAt = safeDate(worker.session.completedAt ?? worker.session.updatedAt);
+    const workerAgent = agentResource.buildIri(webId, {
+        id: buildWorkerAgentId(worker.session.backend, worker.session.target.agent),
+    });
+    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 = agentResource.buildIri(webId, {
+        id: buildWorkerAgentId(worker.session.backend, worker.session.target.agent),
+    });
+    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: agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID }),
+        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 = agentResource.buildIri(webId, {
@@ -972,12 +1361,15 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
     });
     const secretaryAgent = agentResource.buildIri(webId, { id: SYMPHONY_SECRETARY_AGENT_ID });
     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`,
@@ -994,7 +1386,7 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
         targetThread: selectTargetThreadIri(plan.issue.thread ?? worker.session.target?.thread, webId, plan),
         targetSession: buildSymphonyControlSessionUri(webId, plan),
         actor: workerAgent,
-        object: run,
+        object: report,
         objective: summary,
         payload: {
             kind: 'symphony_report',
@@ -1003,6 +1395,7 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
             issue: buildSymphonyIssueIri(webId, plan.issue),
             task,
             delivery: originalDelivery,
+            report,
             reportDelivery: buildSymphonyReportDeliveryIri(webId, worker),
             session: buildSymphonyControlSessionUri(webId, plan),
             run,
@@ -1011,9 +1404,13 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
             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),
             evidence: {
                 statusMessage: buildSymphonyMessageUri(webId, plan, buildStatusMessageRow(plan, webId, stage)),
-                runStep: buildSymphonyRunStepIri(webId, worker, stage),
+                sourceRunStep,
+                evidence,
             },
         },
         projection: {
@@ -1030,6 +1427,11 @@ 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),
         },
         error: status === 'failed' ? worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error : undefined,
         createdAt: completedAt,
@@ -1371,6 +1773,7 @@ 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,
@@ -1385,6 +1788,7 @@ 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,
@@ -1419,6 +1823,51 @@ 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,
@@ -1538,6 +1987,9 @@ function collectSymphonyProjectionResources(webId, plan, stages) {
             add('runStep', buildSymphonyRunStepIri(webId, worker, stage));
         }
         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));
         }
     }
@@ -1612,6 +2064,7 @@ export async function persistSymphonyControlStateToPod(plan, options = {}) {
             stages,
             latestMessage,
             shouldUpsertChat: !normalizedPlan.session.target?.chat,
+            podSession,
         }),
     });
     return {
@@ -1685,6 +2138,10 @@ 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')
@@ -1822,7 +2279,18 @@ export async function persistSymphonyIdeaToPod(idea, options = {}) {
                 },
             },
             {
-                id: 'symphony.idea.upsert',
+                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',
                 kind: 'upsert',
                 apply: () => upsertIdea(db, runtime, buildSymphonyIdeaRow(idea, podSession.webId)),
             },
@@ -2102,6 +2570,8 @@ 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.agentResource,
@@ -2112,7 +2582,18 @@ function buildSymphonyProjectionOperations(input) {
             },
         },
         {
-            id: 'symphony.upsert-issue',
+            id: 'symphony.write-file-primary-documents',
+            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',
+                });
+            },
+        },
+        {
+            id: 'symphony.upsert-issue-meta',
             kind: 'upsert',
             apply: () => upsertIssue(input.db, input.runtime, buildSymphonyIssueRow(input.plan, input.webId)),
         },
@@ -2185,6 +2666,38 @@ 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',
@@ -2218,6 +2731,7 @@ export const __symphonyPodProjectionInternal = {
     buildSymphonyIdeaRow,
     buildSymphonyTaskRow,
     buildSymphonyDeliveryRow,
+    buildSymphonyEvidenceRow,
     buildSymphonyReportDeliveryRow,
     buildSymphonyReportInboxNotificationRow,
     buildSymphonyRunRow,