@undefineds.co/linx 0.3.4 → 0.3.7

package/dist/lib/pi-adapter/pod-mirror.js

@@ -1,78 +1,260 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { createAgentRuntimeConfigSnapshot, } from '../../../vendor/agent-runtime/dist/index.js';
+import { buildLinxSessionControlState, mergeLinxSessionControlMetadata, } from '../../../vendor/agent-runtime/dist/control-plane.js';
+import { createLinxPodSyncQueue, listLinxSyncCheckpoints, } from '../../../vendor/agent-runtime/dist/sync.js';
+import { upsertExactRecord } from '@undefineds.co/drizzle-solid';
 import { DEFAULT_LINX_CLOUD_MODEL_ID } from '../default-model.js';
 import { getDefaultPodDataSession } from '../pod-data-session.js';
-import { agentResource, auditResource, chatResource, drizzle, messageResource, sessionResource, solidResources, threadResource, } from '../models.js';
+import { agentResource, auditResource, chatResource, drizzle, messageResource, sessionResource, skillResource, solidResources, threadResource, } from '../models.js';
 export { buildPodMessageRow } from './pod-mirror-mapping.js';
-import { DEFAULT_SECRETARY_CHAT_ID, PI_AGENT_ID, buildPodMessageRow as buildPodMessageRowFromMapping, buildThreadTitle, buildToolAuditId, calculateTokenUsage, pathToWorkspaceUri, } from './pod-mirror-mapping.js';
+import { DEFAULT_SECRETARY_CHAT_ID, PI_AGENT_ID, buildPodMessageRow as buildPodMessageRowFromMapping, buildThreadTitle, buildToolAuditId, calculateTokenUsage, getActiveSessionEntries, pathToWorkspaceUri, sanitizePodLiteralText, secretaryThreadResourceId, } from './pod-mirror-mapping.js';
 const PI_POLICY_VERSION = 'linx-pi-pod-mirror/v1';
+const PI_SYMPHONY_SKILL_ID = 'symphony';
+const POD_MIRROR_TRANSIENT_RETRY_DELAYS_MS = [250, 1_000, 2_500];
 export class LinxPiPodMirror {
     options;
     contextPromise = null;
-    queue = Promise.resolve();
+    queue;
     seenMessageIds = new Set();
     messageResourceRefs = new Set();
     runtimePromise;
+    syncCheckpoints = new Map();
+    syncResults = [];
+    projectionDisabledReason = null;
     closed = false;
+    taskSeq = 0;
     constructor(options) {
         this.options = options;
         this.runtimePromise = createDefaultRuntime(options.runtime);
+        this.queue = createLinxPodSyncQueue({
+            source: 'pi-runtime',
+            target: 'pod',
+            direction: 'local-to-core',
+            plane: 'projection',
+            authority: 'core',
+            metadata: {
+                cwd: options.cwd,
+            },
+            onError: options.onError,
+            checkpoint: {
+                writeCheckpoint: async (checkpoint) => {
+                    this.syncCheckpoints.set(checkpoint.id, checkpoint);
+                    await options.checkpointStore?.writeCheckpoint(checkpoint);
+                },
+                readCheckpoint: options.checkpointStore?.readCheckpoint?.bind(options.checkpointStore),
+                listCheckpoints: options.checkpointStore?.listCheckpoints?.bind(options.checkpointStore),
+                deleteCheckpoint: options.checkpointStore?.deleteCheckpoint?.bind(options.checkpointStore),
+            },
+            onResult: (result) => {
+                this.syncResults.push(result);
+            },
+        });
     }
     handleEvent(event) {
         if (this.closed || !isRecord(event)) {
             return;
         }
+        if (this.projectionDisabledReason) {
+            return;
+        }
         if (event.type === 'message_end') {
-            this.enqueue(async () => {
+            this.enqueue('message_end', async () => {
                 const message = event.message;
                 const entry = this.resolveLatestEntryForMessage(message);
                 if (!entry || this.seenMessageIds.has(entry.id)) {
                     return;
                 }
-                this.seenMessageIds.add(entry.id);
-                await this.persistEntry(entry);
+                if (await this.persistEntry(entry)) {
+                    this.seenMessageIds.add(entry.id);
+                }
             });
             return;
         }
         if (event.type === 'tool_execution_start') {
-            this.enqueue(() => this.persistToolAudit('tool_execution_started', event));
+            this.enqueue('tool_execution_start', () => this.persistToolAudit('tool_execution_started', event));
             return;
         }
         if (event.type === 'tool_execution_end') {
-            this.enqueue(() => this.persistToolAudit(event.isError ? 'tool_execution_failed' : 'tool_execution_completed', event));
+            this.enqueue('tool_execution_end', () => this.persistToolAudit(event.isError ? 'tool_execution_failed' : 'tool_execution_completed', event));
             return;
         }
         if (event.type === 'agent_end') {
-            this.enqueue(() => this.persistUnseenMessageEntries());
+            this.enqueue('agent_end', () => this.persistUnseenMessageEntries());
         }
     }
     async flush() {
-        await this.queue;
+        await this.queue.flush();
+    }
+    getSyncCheckpoints() {
+        return [...this.syncCheckpoints.values()];
+    }
+    getSyncResults() {
+        return [...this.syncResults];
+    }
+    syncAutoControlState(enabled) {
+        this.options.autoEnabled = enabled;
+        if (this.projectionDisabledReason) {
+            return Promise.resolve(null);
+        }
+        return this.enqueue('auto_control_state', async () => {
+            const context = await this.getContext();
+            if (!context) {
+                throw new Error('Pod data session unavailable for Pi control-plane sync');
+            }
+            const refs = resolvePiResourceRefs(context, this.options);
+            if (this.options.syncConversationRoot) {
+                await ensurePiConversationRoot(context, this.options, refs);
+            }
+            await persistRuntimeSession(context, this.options, refs, 'active', this.messageResourceRefs);
+        }, {
+            autoEnabled: enabled,
+        }, {
+            plane: 'control-plane',
+            authority: 'core',
+        });
+    }
+    syncSymphonyControlState(enabled) {
+        this.options.symphonyEnabled = enabled;
+        if (this.projectionDisabledReason) {
+            return Promise.resolve(null);
+        }
+        return this.enqueue('symphony_control_state', async () => {
+            const context = await this.getContext();
+            if (!context) {
+                throw new Error('Pod data session unavailable for Pi control-plane sync');
+            }
+            const refs = resolvePiResourceRefs(context, this.options);
+            if (this.options.syncConversationRoot) {
+                await ensurePiConversationRoot(context, this.options, refs);
+            }
+            await persistRuntimeSession(context, this.options, refs, 'active', this.messageResourceRefs);
+        }, {
+            symphonyEnabled: enabled,
+        }, {
+            plane: 'control-plane',
+            authority: 'core',
+        });
+    }
+    syncRewindProjection(input) {
+        if (this.projectionDisabledReason) {
+            return Promise.resolve(null);
+        }
+        return this.enqueue('rewind_projection', async () => {
+            const context = await this.getContext();
+            if (!context) {
+                throw new Error('Pod data session unavailable for Pi rewind projection');
+            }
+            const refs = resolvePiResourceRefs(context, this.options);
+            if (this.options.syncConversationRoot) {
+                await ensurePiConversationRoot(context, this.options, refs);
+            }
+            await archivePreviousRuntimeSession(context, this.options, input);
+            await markAbandonedPreviousMessages(context, this.options, input);
+            this.seenMessageIds.clear();
+            this.messageResourceRefs.clear();
+            await this.persistUnseenMessageEntries();
+            await persistRuntimeSession(context, this.options, refs, 'active', this.messageResourceRefs);
+        }, {
+            previousSessionId: input.previousSessionId,
+            cleanSessionId: input.cleanSessionId,
+            abandonedEntries: input.abandonedEntries?.length ?? 0,
+        }, {
+            plane: 'projection',
+            authority: 'core',
+        });
+    }
+    async replayPendingSync() {
+        const checkpointStore = this.options.checkpointStore;
+        if (!checkpointStore) {
+            return [];
+        }
+        const pending = await listLinxSyncCheckpoints(checkpointStore, {
+            source: 'pi-runtime',
+            target: 'pod',
+            plane: 'projection',
+            status: ['failed', 'partial'],
+            metadata: {
+                resourceBindings: {
+                    session: {
+                        local: this.options.sessionManager.getSessionId(),
+                    },
+                },
+            },
+        });
+        const replayablePending = pending.filter(isReplayablePiProjectionCheckpoint);
+        if (replayablePending.length === 0) {
+            return [];
+        }
+        const result = await this.enqueue('retry_pending_projection', () => this.persistUnseenMessageEntries(), {
+            retryOf: replayablePending.map((checkpoint) => checkpoint.id),
+        });
+        if (result?.status === 'completed') {
+            await Promise.all(replayablePending.map((checkpoint) => checkpointStore.deleteCheckpoint?.(checkpoint.id)));
+        }
+        return result ? [result] : [];
     }
     async close() {
         if (this.closed) {
             return;
         }
         this.closed = true;
-        this.enqueue(async () => {
+        if (this.projectionDisabledReason) {
+            await this.queue.flush();
+            return;
+        }
+        this.enqueue('close', async () => {
             const context = await this.getContext();
             if (!context) {
                 return;
             }
             await persistRuntimeSession(context, this.options, resolvePiResourceRefs(context, this.options), 'completed', this.messageResourceRefs);
         });
-        await this.queue;
+        await this.queue.flush();
     }
-    enqueue(task) {
-        this.queue = this.queue
-            .then(task, task)
-            .catch((error) => {
-            this.options.onError?.(error);
+    enqueue(description, task, metadata = {}, sync = {}) {
+        if (this.projectionDisabledReason) {
+            return Promise.resolve(null);
+        }
+        const action = `pi-pod-mirror.${description}`;
+        return this.queue.enqueue({
+            id: this.nextTaskId(),
+            action,
+            description,
+            kind: 'custom',
+            plane: sync.plane,
+            authority: sync.authority,
+            resourceBindings: createPiPodMirrorSyncResourceBindings(this.options),
+            metadata,
+            resolveResourceBindings: async () => {
+                const podContext = await this.getContext();
+                return podContext ? createPiPodMirrorSyncResourceBindings(this.options, resolvePiResourceRefs(podContext, this.options)) : undefined;
+            },
+            run: async (context) => {
+                if (this.projectionDisabledReason) {
+                    return;
+                }
+                try {
+                    await runWithTransientPodMirrorRetry(context, () => task(context));
+                }
+                catch (error) {
+                    if (isPodMirrorCircuitBreakerError(error)) {
+                        this.projectionDisabledReason = formatPodMirrorCircuitBreakerReason(error);
+                    }
+                    throw error;
+                }
+            },
         });
     }
+    nextTaskId() {
+        const sessionId = this.options.sessionManager.getSessionId();
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        return `pi-pod-mirror:${sessionId}:${timestamp}:${++this.taskSeq}`;
+    }
     resolveLatestEntryForMessage(message) {
         if (!message) {
             return null;
         }
-        const entries = [...this.options.sessionManager.getEntries()].reverse();
+        const entries = [...getActiveSessionEntries(this.options.sessionManager)].reverse();
         const timestamp = typeof message.timestamp === 'number'
             ? message.timestamp
             : null;
@@ -94,8 +276,11 @@ export class LinxPiPodMirror {
     }
     async persistEntry(entry) {
         const context = await this.getContext();
-        if (!context || entry.type !== 'message') {
-            return;
+        if (entry.type !== 'message') {
+            return true;
+        }
+        if (!context) {
+            throw new Error('Pod data session unavailable for Pi projection');
         }
         const refs = resolvePiResourceRefs(context, this.options);
         if (this.options.syncConversationRoot) {
@@ -103,7 +288,7 @@ export class LinxPiPodMirror {
         }
         const row = buildPodMessageRowFromMapping(context.webId, this.options, entry);
         if (!row) {
-            return;
+            return true;
         }
         const resourceRef = await persistMessage(context, normalizePodMessageRow(context, row, refs));
         this.messageResourceRefs.add(resourceRef);
@@ -111,14 +296,16 @@ export class LinxPiPodMirror {
         if (this.options.syncConversationRoot) {
             await touchPiConversation(context, this.options, refs, row.content);
         }
+        return true;
     }
     async persistUnseenMessageEntries() {
-        for (const entry of this.options.sessionManager.getEntries()) {
+        for (const entry of getActiveSessionEntries(this.options.sessionManager)) {
             if (entry.type !== 'message' || this.seenMessageIds.has(entry.id)) {
                 continue;
             }
-            this.seenMessageIds.add(entry.id);
-            await this.persistEntry(entry);
+            if (await this.persistEntry(entry)) {
+                this.seenMessageIds.add(entry.id);
+            }
         }
     }
     async persistToolAudit(action, event) {
@@ -175,12 +362,12 @@ export class LinxPiPodMirror {
 async function ensurePiConversationRoot(context, options, refs) {
     const now = new Date();
     const threadId = options.sessionManager.getSessionId();
-    await upsertByResource(context.db, chatResource, { id: DEFAULT_SECRETARY_CHAT_ID }, {
+    await upsertExactRecord(context.db, chatResource, { id: DEFAULT_SECRETARY_CHAT_ID }, {
         id: DEFAULT_SECRETARY_CHAT_ID,
         title: 'AI Secretary',
         participants: [context.webId, refs.agentUri],
         metadata: {
-            kind: 'ai-secretary',
+            kind: 'secretary-chat',
             surface: 'cli',
             agent: refs.agentUri,
         },
@@ -191,16 +378,17 @@ async function ensurePiConversationRoot(context, options, refs) {
         title: 'AI Secretary',
         participants: [context.webId, refs.agentUri],
         metadata: {
-            kind: 'ai-secretary',
+            kind: 'secretary-chat',
             surface: 'cli',
             agent: refs.agentUri,
         },
         lastActiveAt: now,
         updatedAt: now,
     });
-    await upsertByResource(context.db, threadResource, { id: threadId, chat: refs.chatUri }, {
-        id: threadId,
-        chat: refs.chatUri,
+    const threadResourceId = secretaryThreadResourceId(threadId);
+    await upsertExactRecord(context.db, threadResource, { id: threadResourceId }, {
+        id: threadResourceId,
+        parent: refs.chatUri,
         title: buildThreadTitle(options.sessionManager),
         workspace: pathToWorkspaceUri(options.cwd),
         metadata: buildThreadMetadata(options),
@@ -212,25 +400,85 @@ async function ensurePiConversationRoot(context, options, refs) {
         metadata: buildThreadMetadata(options),
         updatedAt: now,
     });
-    await upsertByResource(context.db, agentResource, { id: PI_AGENT_ID }, {
-        id: PI_AGENT_ID,
+    await upsertExactRecord(context.db, agentResource, { id: PI_AGENT_ID }, {
+        id: agentResource.buildId({ id: PI_AGENT_ID }),
         name: 'LinX CLI Assistant',
+        root: refs.agentUri,
+        hasSkill: [refs.symphonySkillUri],
         provider: 'undefineds',
+        backend: 'linx',
+        runtime: 'pi',
+        transport: 'pi-runtime',
+        credentialSource: 'pod-session',
         model: DEFAULT_LINX_CLOUD_MODEL_ID,
+        enabled: true,
+        metadata: {
+            kind: 'secretary-agent',
+            surface: 'cli',
+            fileBackedSkills: true,
+        },
         createdAt: now,
         updatedAt: now,
     }, {
         name: 'LinX CLI Assistant',
+        root: refs.agentUri,
+        hasSkill: [refs.symphonySkillUri],
         provider: 'undefineds',
+        backend: 'linx',
+        runtime: 'pi',
+        transport: 'pi-runtime',
+        credentialSource: 'pod-session',
         model: DEFAULT_LINX_CLOUD_MODEL_ID,
+        enabled: true,
+        metadata: {
+            kind: 'secretary-agent',
+            surface: 'cli',
+            fileBackedSkills: true,
+        },
+        updatedAt: now,
+    });
+    await upsertExactRecord(context.db, skillResource, {
+        id: PI_SYMPHONY_SKILL_ID,
+        agent: refs.agentUri,
+    }, {
+        id: skillResource.buildId({
+            id: PI_SYMPHONY_SKILL_ID,
+            agent: refs.agentUri,
+        }),
+        agent: refs.agentUri,
+        root: refs.symphonySkillUri,
+        name: PI_SYMPHONY_SKILL_ID,
+        displayName: 'Symphony',
+        enabled: true,
+        source: 'linx-cli:skills/symphony',
+        loadPolicy: 'file-backed',
+        metadata: {
+            file: 'SKILL.md',
+            scope: 'linx-cli',
+        },
+        createdAt: now,
+        updatedAt: now,
+    }, {
+        agent: refs.agentUri,
+        root: refs.symphonySkillUri,
+        name: PI_SYMPHONY_SKILL_ID,
+        displayName: 'Symphony',
+        enabled: true,
+        source: 'linx-cli:skills/symphony',
+        loadPolicy: 'file-backed',
+        metadata: {
+            file: 'SKILL.md',
+            scope: 'linx-cli',
+        },
         updatedAt: now,
     });
 }
-async function persistRuntimeSession(context, options, refs, status = 'active', messageResourceRefs = new Set()) {
+async function persistRuntimeSession(context, options, refs, status = 'active', _messageResourceRefs = new Set()) {
     const now = new Date();
     const threadId = options.sessionManager.getSessionId();
     const runtimeSessionId = threadId;
     const createdAt = getSessionCreatedAt(options.sessionManager);
+    const activeMessageResourceRefs = resolveActiveMessageResourceRefs(context, options, refs);
     const metadata = {
         cwd: options.cwd,
         sessionFile: options.sessionManager.getSessionFile(),
@@ -238,37 +486,145 @@ async function persistRuntimeSession(context, options, refs, status = 'active',
         runtimeSessionId,
         surface: 'cli',
         threadUri: refs.threadUri,
-        messageResources: [...messageResourceRefs],
+        messages: [...activeMessageResourceRefs],
+        runtimeSnapshot: createPiRuntimeSnapshot(refs, createdAt),
     };
+    const controlState = buildLinxSessionControlState({
+        autoEnabled: options.autoEnabled === true,
+        symphonyEnabled: options.symphonyEnabled === true,
+        updatedAt: now,
+        updatedBy: 'cli',
+    });
+    const sessionMetadata = mergeLinxSessionControlMetadata(metadata, controlState);
     const row = {
         id: runtimeSessionId,
-        ownerWebId: context.webId,
+        owner: context.webId,
         chat: refs.chatUri,
         thread: refs.threadUri,
         sessionType: 'direct',
         status,
         tool: 'linx',
-        tokenUsage: calculateTokenUsage(options.sessionManager.getEntries()),
-        messageResources: [...messageResourceRefs],
+        tokenUsage: calculateTokenUsage(getActiveSessionEntries(options.sessionManager)),
+        messages: [...activeMessageResourceRefs],
         policyVersion: PI_POLICY_VERSION,
-        metadata,
+        metadata: sessionMetadata,
         createdAt,
         updatedAt: now,
     };
     await upsertByIri(context.db, sessionResource, refs.sessionUri, row, {
-        ownerWebId: context.webId,
+        owner: context.webId,
         chat: refs.chatUri,
         thread: refs.threadUri,
         sessionType: 'direct',
         status,
         tool: 'linx',
         tokenUsage: row.tokenUsage,
-        messageResources: [...messageResourceRefs],
+        messages: [...activeMessageResourceRefs],
         policyVersion: PI_POLICY_VERSION,
-        metadata,
+        metadata: sessionMetadata,
         updatedAt: now,
     });
 }
+async function archivePreviousRuntimeSession(context, options, input) {
+    const previousSessionId = normalizeString(input.previousSessionId);
+    if (!previousSessionId || previousSessionId === options.sessionManager.getSessionId()) {
+        return;
+    }
+    const previousCreatedAt = toDate(input.previousCreatedAt)
+        ?? parseTimestampFromUuidLikeId(previousSessionId)
+        ?? new Date();
+    const previousRefs = resolvePiResourceRefsForSession(context, options, previousSessionId, previousCreatedAt);
+    const existing = await context.db.findByIri(sessionResource, previousRefs.sessionUri);
+    if (!existing) {
+        return;
+    }
+    const now = new Date();
+    const existingMetadataValue = existing.metadata;
+    const existingMetadata = isRecord(existingMetadataValue)
+        ? existingMetadataValue
+        : {};
+    await context.db.updateByIri(sessionResource, previousRefs.sessionUri, {
+        status: 'archived',
+        archivedAt: now,
+        updatedAt: now,
+        metadata: {
+            ...existingMetadata,
+            rewoundAt: now.toISOString(),
+            rewoundToSessionId: options.sessionManager.getSessionId(),
+            rewoundToSessionFile: normalizeString(input.cleanSessionFile),
+            rewindPreviousSessionFile: normalizeString(input.previousSessionFile),
+        },
+    });
+}
+async function markAbandonedPreviousMessages(context, options, input) {
+    const previousSessionId = normalizeString(input.previousSessionId);
+    const abandonedEntries = Array.isArray(input.abandonedEntries) ? input.abandonedEntries : [];
+    if (!previousSessionId || abandonedEntries.length === 0) {
+        return;
+    }
+    const previousCreatedAt = toDate(input.previousCreatedAt)
+        ?? parseTimestampFromUuidLikeId(previousSessionId)
+        ?? new Date();
+    const previousRefs = resolvePiResourceRefsForSession(context, options, previousSessionId, previousCreatedAt);
+    const previousSessionManager = {
+        getSessionId: () => previousSessionId,
+    };
+    const now = new Date();
+    for (const entry of abandonedEntries) {
+        if (entry.type !== 'message') {
+            continue;
+        }
+        const row = buildPodMessageRowFromMapping(context.webId, { sessionManager: previousSessionManager }, entry);
+        if (!row) {
+            continue;
+        }
+        const normalized = normalizePodMessageRow(context, row, previousRefs);
+        const resourceRef = messageResource.buildIri(context.webId, {
+            id: normalized.id,
+            chat: normalized.chat,
+            thread: normalized.thread,
+            createdAt: normalized.createdAt,
+        });
+        const existing = await context.db.findByIri(messageResource, resourceRef);
+        if (!existing) {
+            continue;
+        }
+        const existingMetadataValue = existing.metadata;
+        const existingMetadata = isRecord(existingMetadataValue)
+            ? existingMetadataValue
+            : {};
+        await context.db.updateByIri(messageResource, resourceRef, {
+            status: 'abandoned',
+            updatedAt: now,
+            metadata: {
+                ...existingMetadata,
+                rewoundAt: now.toISOString(),
+                rewoundFromSessionId: previousSessionId,
+                rewoundToSessionId: options.sessionManager.getSessionId(),
+            },
+        });
+    }
+}
+function resolveActiveMessageResourceRefs(context, options, refs) {
+    const activeRefs = new Set();
+    for (const entry of getActiveSessionEntries(options.sessionManager)) {
+        if (entry.type !== 'message') {
+            continue;
+        }
+        const row = buildPodMessageRowFromMapping(context.webId, options, entry);
+        if (!row) {
+            continue;
+        }
+        const normalized = normalizePodMessageRow(context, row, refs);
+        activeRefs.add(messageResource.buildIri(context.webId, {
+            id: normalized.id,
+            chat: normalized.chat,
+            thread: normalized.thread,
+            createdAt: normalized.createdAt,
+        }));
+    }
+    return activeRefs;
+}
 async function persistMessage(context, row) {
     const insert = {
         id: row.id,
@@ -276,20 +632,30 @@ async function persistMessage(context, row) {
         thread: row.thread,
         maker: row.maker,
         role: row.role,
-        content: row.content,
-        ...(row.richContent ? { richContent: row.richContent } : {}),
+        content: sanitizePodLiteralText(row.content),
+        ...(row.richContent ? { richContent: sanitizePodLiteralText(row.richContent) } : {}),
         status: row.status,
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
     };
-    await insertResource(context.db, messageResource, insert);
-    return context.db.resolveLocatorIri(messageResource, { id: row.id, chat: row.chat, createdAt: row.createdAt });
+    const resourceRef = messageResource.buildIri(context.webId, { id: row.id, chat: row.chat, thread: row.thread, createdAt: row.createdAt });
+    await upsertByIri(context.db, messageResource, resourceRef, insert, {
+        chat: row.chat,
+        thread: row.thread,
+        maker: row.maker,
+        role: row.role,
+        content: sanitizePodLiteralText(row.content),
+        ...(row.richContent ? { richContent: sanitizePodLiteralText(row.richContent) } : {}),
+        status: row.status,
+        updatedAt: row.updatedAt,
+    });
+    return resourceRef;
 }
 async function touchPiConversation(context, options, refs, preview) {
     const now = new Date();
     const threadId = options.sessionManager.getSessionId();
     await context.db.updateById(chatResource, DEFAULT_SECRETARY_CHAT_ID, {
-        lastMessagePreview: preview.slice(0, 100),
+        lastMessagePreview: sanitizePodLiteralText(preview).slice(0, 100),
         lastActiveAt: now,
         updatedAt: now,
     });
@@ -320,12 +686,30 @@ function createPodMirrorDb(session) {
 function resolvePiResourceRefs(context, options) {
     const sessionId = options.sessionManager.getSessionId();
     const createdAt = getSessionCreatedAt(options.sessionManager);
-    const chatUri = context.db.resolveLocatorIri(chatResource, { id: DEFAULT_SECRETARY_CHAT_ID });
+    return resolvePiResourceRefsForSession(context, options, sessionId, createdAt);
+}
+function resolvePiResourceRefsForSession(context, _options, sessionId, createdAt) {
+    const chatUri = chatResource.buildIri(context.webId, { id: DEFAULT_SECRETARY_CHAT_ID });
+    const agentUri = agentResource.buildIri(context.webId, { id: PI_AGENT_ID });
     return {
-        agentUri: context.db.resolveLocatorIri(agentResource, { id: PI_AGENT_ID }),
+        agentUri,
         chatUri,
-        sessionUri: context.db.resolveLocatorIri(sessionResource, { id: sessionId, createdAt }),
-        threadUri: context.db.resolveLocatorIri(threadResource, { id: sessionId, chat: chatUri }),
+        sessionUri: sessionResource.buildIri(context.webId, { id: sessionId, createdAt }),
+        symphonySkillUri: skillResource.buildIri(context.webId, {
+            id: PI_SYMPHONY_SKILL_ID,
+            agent: agentUri,
+        }),
+        threadUri: threadResource.buildIri(context.webId, { id: secretaryThreadResourceId(sessionId) }),
+    };
+}
+function createPiPodMirrorSyncResourceBindings(options, refs) {
+    const sessionId = options.sessionManager.getSessionId();
+    return {
+        chat: { uri: refs?.chatUri, local: DEFAULT_SECRETARY_CHAT_ID },
+        thread: { uri: refs?.threadUri, local: sessionId },
+        session: { uri: refs?.sessionUri, local: sessionId },
+        agent: { uri: refs?.agentUri, local: PI_AGENT_ID },
+        skill: { uri: refs?.symphonySkillUri, local: PI_SYMPHONY_SKILL_ID },
     };
 }
 function normalizePodMessageRow(context, row, refs) {
@@ -336,20 +720,6 @@ function normalizePodMessageRow(context, row, refs) {
         maker: row.role === 'user' ? context.webId : refs.agentUri,
     };
 }
-async function upsertByResource(db, resource, target, insert, update) {
-    const id = String(target.id ?? '');
-    const iri = db.resolveLocatorIri(resource, target);
-    const existing = id ? await db.findById(resource, id) : await db.findByIri(resource, iri);
-    if (!existing) {
-        await db.insert(resource).values(insert).execute();
-        return;
-    }
-    if (id) {
-        await db.updateById(resource, id, update);
-        return;
-    }
-    await db.updateByIri(resource, iri, update);
-}
 async function upsertByIri(db, resource, iri, insert, update) {
     const existing = await db.findByIri(resource, iri);
     if (!existing) {
@@ -358,6 +728,56 @@ async function upsertByIri(db, resource, iri, insert, update) {
     }
     await db.updateByIri(resource, iri, update);
 }
+async function runWithTransientPodMirrorRetry(context, task) {
+    for (let attempt = 0; attempt <= POD_MIRROR_TRANSIENT_RETRY_DELAYS_MS.length; attempt += 1) {
+        try {
+            await task();
+            return;
+        }
+        catch (error) {
+            if (attempt >= POD_MIRROR_TRANSIENT_RETRY_DELAYS_MS.length || !isTransientPodMirrorError(error)) {
+                throw error;
+            }
+            await delay(POD_MIRROR_TRANSIENT_RETRY_DELAYS_MS[attempt], undefined, { signal: context.signal });
+        }
+    }
+}
+function isTransientPodMirrorError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    if (normalized.includes('401') || normalized.includes('unauthorized')) {
+        return false;
+    }
+    if (normalized.includes('invalid unicode') || normalized.includes('surrogate pair') || normalized.includes('parse error')) {
+        return false;
+    }
+    return normalized.includes('http status 502')
+        || normalized.includes('http status 503')
+        || normalized.includes('http status 504')
+        || normalized.includes('502 bad gateway')
+        || normalized.includes('503 service unavailable')
+        || normalized.includes('504 gateway timeout')
+        || normalized.includes('bad gateway')
+        || normalized.includes('service unavailable')
+        || normalized.includes('gateway timeout')
+        || normalized.includes('fetch failed')
+        || normalized.includes('timed out')
+        || normalized.includes('timeout');
+}
+function isPodMirrorCircuitBreakerError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.toLowerCase();
+    return normalized.includes('401')
+        || normalized.includes('403')
+        || normalized.includes('unauthorized')
+        || normalized.includes('forbidden')
+        || normalized.includes('invalid solid token')
+        || normalized.includes('linx cloud login expired');
+}
+function formatPodMirrorCircuitBreakerReason(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `Pod projection disabled for this session after auth/permission failure: ${message}`;
+}
 async function insertResource(db, resource, insert) {
     await db.insert(resource).values(insert).execute();
 }
@@ -415,7 +835,54 @@ function buildThreadMetadata(options) {
         sessionFile: options.sessionManager.getSessionFile(),
     };
 }
+function createPiRuntimeSnapshot(refs, createdAt) {
+    const skills = [
+        {
+            id: skillResource.buildId({
+                id: PI_SYMPHONY_SKILL_ID,
+                agent: refs.agentUri,
+            }),
+            name: PI_SYMPHONY_SKILL_ID,
+            source: 'linx-cli:skills/symphony',
+            loadPolicy: 'file-backed',
+            enabled: true,
+        },
+    ];
+    return createAgentRuntimeConfigSnapshot({
+        agent: PI_AGENT_ID,
+        role: 'secretary',
+        label: 'AI Secretary',
+        model: DEFAULT_LINX_CLOUD_MODEL_ID,
+        runtime: {
+            backend: 'linx',
+            model: DEFAULT_LINX_CLOUD_MODEL_ID,
+            credentialSource: 'pod-session',
+            runtime: 'pi',
+            transport: 'pi-runtime',
+        },
+        skills,
+    }, {
+        createdAt,
+        source: 'linx-cli.pi-pod-mirror',
+    });
+}
+function isReplayablePiProjectionCheckpoint(checkpoint) {
+    const syncTaskDescription = checkpoint.metadata?.syncTaskDescription ?? checkpoint.metadata?.taskDescription;
+    const replayableTask = syncTaskDescription === 'message_end'
+        || syncTaskDescription === 'agent_end'
+        || syncTaskDescription === 'retry_pending_projection';
+    if (!replayableTask) {
+        return false;
+    }
+    if (!checkpoint.failures || checkpoint.failures.length === 0) {
+        return checkpoint.status === 'partial';
+    }
+    return checkpoint.failures.some((failure) => isTransientPodMirrorError(failure.message));
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function normalizeString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
 //# sourceMappingURL=pod-mirror.js.map