@undefineds.co/linx 0.3.8 → 0.3.15

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, chatRepository, agentResource, contactResource, deliveryResource, 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,191 @@ 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 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}`,
+        '',
+        ...(worker.session.error || worker.delivery.error || worker.taskRecord.error ? [
+            '## Error',
+            worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error ?? '',
+            '',
+        ] : []),
+    ].join('\n');
+}
 function normalizeSymphonyRunPlan(plan) {
     const workers = Array.isArray(plan.workers) && plan.workers.length > 0
         ? plan.workers
@@ -119,12 +304,14 @@ async function createDefaultRuntime() {
         issueResource: models.issueResource,
         taskResource: models.taskResource,
         deliveryResource: models.deliveryResource,
+        reportResource: models.reportResource,
         runResource: models.runResource,
         runStepResource: models.runStepResource,
         agentResource: models.agentResource,
         contactResource: models.contactTable,
         auditResource: models.auditResource,
         inboxNotificationResource: models.inboxNotificationResource,
+        writePodFile: writePodFileToSession,
     };
 }
 function selectTargetChatIri(value, webId, plan) {
@@ -211,6 +398,13 @@ 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 buildSymphonyRunIri(webId, worker) {
     return runResource.buildIri(webId, {
         id: getSymphonyArchiveKey(worker.session.uri),
@@ -808,8 +1002,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 +1027,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 +1045,8 @@ function buildSymphonyIdeaRow(idea, webId) {
         createdBy: webId,
         metadata: {
             surface: 'symphony',
+            filePrimary: true,
+            documentPath: buildSymphonyIdeaDocumentPath(idea),
             ...buildSymphonyArchiveMetadata({ idea: idea.uri }),
         },
         createdAt,
@@ -965,6 +1166,61 @@ 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.'}`;
+    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: [
+            buildSymphonyRunStepIri(webId, worker, stage),
+        ],
+        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),
+            ...buildSymphonyArchiveMetadata({
+                issue: plan.issue.uri,
+                task: worker.task,
+                delivery: worker.delivery.uri,
+                session: worker.session.uri,
+            }),
+        },
+        createdAt: completedAt,
+        publishedAt: completedAt,
+        updatedAt: completedAt,
+    };
+}
 function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
     const completedAt = safeDate(worker.session.completedAt ?? worker.session.updatedAt);
     const workerAgent = agentResource.buildIri(webId, {
@@ -972,6 +1228,7 @@ 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';
@@ -994,7 +1251,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 +1260,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,6 +1269,7 @@ 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),
             evidence: {
                 statusMessage: buildSymphonyMessageUri(webId, plan, buildStatusMessageRow(plan, webId, stage)),
                 runStep: buildSymphonyRunStepIri(webId, worker, stage),
@@ -1030,6 +1289,8 @@ function buildSymphonyReportDeliveryRow(plan, webId, worker, stage) {
                 session: worker.session.uri,
             }),
             reportKind: 'worker-completion',
+            filePrimary: true,
+            reportFile: buildSymphonyReportDocumentPath(worker),
         },
         error: status === 'failed' ? worker.session.error ?? worker.delivery.error ?? worker.taskRecord.error : undefined,
         createdAt: completedAt,
@@ -1371,6 +1632,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 +1647,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 +1682,32 @@ 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 upsertDelivery(db, runtime, row) {
     await upsertExactRecord(db, runtime.deliveryResource, { id: row.id }, row, {
         kind: row.kind,
@@ -1538,6 +1827,7 @@ function collectSymphonyProjectionResources(webId, plan, stages) {
             add('runStep', buildSymphonyRunStepIri(webId, worker, stage));
         }
         if (worker.session.status === 'completed' || worker.session.status === 'failed') {
+            add('report', buildSymphonyReportIri(webId, worker));
             add('delivery', buildSymphonyReportDeliveryIri(webId, worker));
         }
     }
@@ -1552,7 +1842,7 @@ function projectionStagesForStatus(status) {
         return ['planned', 'running', 'failed'];
     return ['planned'];
 }
-export async function persistSymphonyProjectionToPod(plan, options = {}) {
+export async function persistSymphonyControlStateToPod(plan, options = {}) {
     const normalizedPlan = normalizeSymphonyRunPlan(plan);
     const runtime = options.runtime ?? await createDefaultRuntime();
     const podSession = await runtime.getPodDataSession();
@@ -1575,9 +1865,12 @@ export async function persistSymphonyProjectionToPod(plan, options = {}) {
     const projected = withTargetRefs(normalizedPlan, refs, podSession.webId);
     const resources = collectSymphonyProjectionResources(podSession.webId, projected, stages);
     const latestMessage = buildStatusMessageRow(projected, podSession.webId, stage);
-    const projectionSync = createLinxPodSyncScope({ source: 'symphony-run-plan' });
-    await projectionSync.runOperations({
-        action: 'symphony.project',
+    const controlWrite = createLinxPodSyncScope({
+        source: 'symphony-control-state',
+        plane: 'control-plane',
+    });
+    await controlWrite.runOperations({
+        action: 'symphony.write',
         resourceBindings: {
             session: {
                 uri: buildSymphonyControlSessionUri(podSession.webId, projected),
@@ -1609,6 +1902,7 @@ export async function persistSymphonyProjectionToPod(plan, options = {}) {
             stages,
             latestMessage,
             shouldUpsertChat: !normalizedPlan.session.target?.chat,
+            podSession,
         }),
     });
     return {
@@ -1617,6 +1911,8 @@ export async function persistSymphonyProjectionToPod(plan, options = {}) {
         resources,
     };
 }
+/** @deprecated Use persistSymphonyControlStateToPod for LinX-owned Symphony records. */
+export const persistSymphonyProjectionToPod = persistSymphonyControlStateToPod;
 export async function mirrorSymphonyProjectionJsonLdFromPod(projection, options = {}) {
     const runtime = options.runtime ?? await createDefaultRuntime();
     const podSession = await runtime.getPodDataSession();
@@ -1680,6 +1976,8 @@ function resolveProjectionResourceModel(runtime, kind) {
         return runtime.taskResource;
     if (kind === 'delivery')
         return runtime.deliveryResource;
+    if (kind === 'report')
+        return runtime.reportResource;
     if (kind === 'run')
         return runtime.runResource;
     if (kind === 'runStep')
@@ -1782,9 +2080,12 @@ export async function persistSymphonyIdeaToPod(idea, options = {}) {
         return null;
     }
     const db = runtime.createDb(podSession);
-    const ideaSync = createLinxPodSyncScope({ source: 'symphony-idea' });
-    await ideaSync.runOperations({
-        action: 'symphony.idea.project',
+    const ideaWrite = createLinxPodSyncScope({
+        source: 'symphony-control-state',
+        plane: 'control-plane',
+    });
+    await ideaWrite.runOperations({
+        action: 'symphony.idea.write',
         resourceBindings: {
             idea: {
                 uri: ideaResource.buildIri(podSession.webId, {
@@ -1814,7 +2115,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)),
             },
@@ -2094,6 +2406,7 @@ function buildSymphonyProjectionOperations(input) {
                     input.runtime.issueResource,
                     input.runtime.taskResource,
                     input.runtime.deliveryResource,
+                    input.runtime.reportResource,
                     input.runtime.runResource,
                     input.runtime.runStepResource,
                     input.runtime.agentResource,
@@ -2104,7 +2417,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)),
         },
@@ -2177,6 +2501,22 @@ function buildSymphonyReportOperations(input) {
     }
     const terminalStage = input.stage;
     return input.plan.workers.flatMap((worker, index) => [
+        {
+            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',