salmon-loop 0.2.13 → 0.2.16

package/dist/core/session/manager.js

@@ -1,15 +1,51 @@
 import { randomBytes } from 'crypto';
 import { join } from 'path';
 import { FileAdapter } from '../adapters/fs/index.js';
+import { recordAuditEvent } from '../observability/audit-trail.js';
 import { getLogger } from '../observability/logger.js';
+import { parseFlowMode } from '../types/flow-mode.js';
+import { mergeReplacementStateFromArtifactHints, mergeSessionArtifactState, normalizeSessionArtifactState, } from './artifact-state.js';
 import { SessionCompressor, CompressedSessionStore } from './compression.js';
 import { SessionPruningEngine } from './pruning-strategy.js';
+import { freezeToolResultReplacementDecision, normalizeToolResultReplacementState, } from './replacement-state.js';
+import { createResumeRepairPipeline } from './resume-repair/pipeline.js';
+const RESUME_REPAIR_V1_FLAG = 'SALMONLOOP_RESUME_REPAIR_V1';
+function resolveResumeRepairV1Enabled() {
+    const raw = process.env[RESUME_REPAIR_V1_FLAG];
+    if (!raw || !raw.trim())
+        return true;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === '0' || normalized === 'false' || normalized === 'off' || normalized === 'no') {
+        return false;
+    }
+    return true;
+}
+function recordResumeRepairMetrics(details) {
+    recordAuditEvent('session.resume_repair.completed', {
+        mode: details.mode,
+        success: details.success,
+        metric: 'repair_violation_rate',
+        repairViolationCount: details.repairViolationCount,
+        replacementReuseMetric: 'replacement_reuse_hit_rate',
+        replacementReuseHitCount: details.replacementReuseHitCount,
+        contractViolationCodes: details.contractViolationCodes ?? [],
+    }, {
+        source: 'session',
+        severity: details.success ? 'low' : 'medium',
+        scope: 'session',
+    });
+}
+function normalizeChatState(chatState) {
+    const flowMode = parseFlowMode(chatState?.flowMode);
+    return flowMode ? { flowMode } : undefined;
+}
 /**
  * Manages chat session persistence and lifecycle.
  * Storage: .salmonloop/chat-sessions/<id>.json
  * Features: Auto-pruning, compression, intelligent cleanup
  */
 export class ChatSessionManager {
+    repoPath;
     storageDir;
     currentSession = null;
     fileAdapter = new FileAdapter();
@@ -17,6 +53,7 @@ export class ChatSessionManager {
     compressor;
     compressedStore;
     constructor(repoPath, pruningStrategy) {
+        this.repoPath = repoPath;
         this.storageDir = join(repoPath, '.salmonloop', 'chat-sessions');
         this.pruningEngine = new SessionPruningEngine(pruningStrategy);
         this.compressor = new SessionCompressor();
@@ -87,7 +124,11 @@ export class ChatSessionManager {
         const filePath = join(this.storageDir, `${targetId}.json`);
         try {
             const data = await this.fileAdapter.readFile(filePath);
-            this.currentSession = JSON.parse(data);
+            const parsed = JSON.parse(data);
+            parsed.meta.chatState = normalizeChatState(parsed.meta.chatState);
+            parsed.meta.artifactState = normalizeSessionArtifactState(parsed.meta.artifactState);
+            parsed.meta.replacementState = normalizeToolResultReplacementState(parsed.meta.replacementState);
+            this.currentSession = parsed;
             return this.currentSession;
         }
         catch {
@@ -171,6 +212,9 @@ export class ChatSessionManager {
     getSummaryState() {
         return this.currentSession?.meta.summaryState;
     }
+    getArtifactState() {
+        return normalizeSessionArtifactState(this.currentSession?.meta.artifactState);
+    }
     /**
      * Update summary state after summarization.
      */
@@ -179,6 +223,38 @@ export class ChatSessionManager {
             throw new Error('No active session');
         this.currentSession.meta.summaryState = state;
     }
+    updateArtifactState(state) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.meta.artifactState = normalizeSessionArtifactState(state);
+    }
+    mergeArtifactState(state) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.meta.artifactState = mergeSessionArtifactState(this.currentSession.meta.artifactState, state);
+        this.currentSession.meta.replacementState = mergeReplacementStateFromArtifactHints(this.currentSession.meta.replacementState, state);
+    }
+    getReplacementState() {
+        return normalizeToolResultReplacementState(this.currentSession?.meta.replacementState);
+    }
+    updateReplacementState(state) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.meta.replacementState = normalizeToolResultReplacementState(state);
+    }
+    getChatFlowMode() {
+        return this.currentSession?.meta.chatState?.flowMode;
+    }
+    updateChatFlowMode(mode) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.meta.chatState = normalizeChatState(mode === undefined ? undefined : { flowMode: mode });
+    }
+    freezeReplacementDecision(entry, options) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.meta.replacementState = freezeToolResultReplacementDecision(this.currentSession.meta.replacementState, entry, options);
+    }
     /**
      * Clear summary state (e.g., on session reset).
      */
@@ -255,6 +331,9 @@ export class ChatSessionManager {
                 const filePath = join(this.storageDir, file);
                 const data = await this.fileAdapter.readFile(filePath);
                 const session = JSON.parse(data);
+                session.meta.chatState = normalizeChatState(session.meta.chatState);
+                session.meta.artifactState = normalizeSessionArtifactState(session.meta.artifactState);
+                session.meta.replacementState = normalizeToolResultReplacementState(session.meta.replacementState);
                 sessions.push(session);
             }
             catch (error) {
@@ -298,17 +377,174 @@ export class ChatSessionManager {
      * List archived sessions
      */
     async listArchivedSessions() {
-        // Implement archived session list functionality
-        // This needs to access the compressed storage
-        return [];
+        const archiveDir = this.getArchiveStorageDir();
+        const files = await this.fileAdapter.readdir(archiveDir).catch(() => []);
+        const archived = [];
+        for (const file of files) {
+            if (!file.endsWith('.mpack.gz'))
+                continue;
+            try {
+                const compressed = await this.compressedStore.loadCompressed(file);
+                if (!compressed)
+                    continue;
+                const stats = await this.fileAdapter.stat(join(archiveDir, file));
+                archived.push({
+                    id: compressed.meta.id,
+                    name: compressed.meta.name,
+                    archivedAt: stats.mtime.getTime(),
+                });
+            }
+            catch (error) {
+                getLogger().warn(`Failed to load archived session ${file}: ${error}`);
+            }
+        }
+        return archived.sort((a, b) => b.archivedAt - a.archivedAt);
     }
     /**
      * Restore session from archive
      */
-    async restoreFromArchive(_archiveId) {
-        // Implement session restoration from archive functionality
-        // This needs to access the compressed storage and decompress
-        return null;
+    async restoreFromArchive(archiveId) {
+        const filename = await this.resolveArchiveFilename(archiveId);
+        if (!filename)
+            return null;
+        const resumeRepairV1Enabled = resolveResumeRepairV1Enabled();
+        try {
+            if (!resumeRepairV1Enabled) {
+                const restored = await this.restoreFromArchiveLegacy(filename);
+                if (!restored) {
+                    recordResumeRepairMetrics({
+                        mode: 'legacy',
+                        success: false,
+                        repairViolationCount: 1,
+                        replacementReuseHitCount: 0,
+                        contractViolationCodes: ['LEGACY_RESTORE_FAILED'],
+                    });
+                    return null;
+                }
+                recordResumeRepairMetrics({
+                    mode: 'legacy',
+                    success: true,
+                    repairViolationCount: 0,
+                    replacementReuseHitCount: Object.keys(restored.meta.replacementState?.entries ?? {})
+                        .length,
+                });
+                this.currentSession = restored;
+                await this.save();
+                return restored;
+            }
+            const pipeline = createResumeRepairPipeline({
+                compressedStore: this.compressedStore,
+                compressor: this.compressor,
+                repoPath: this.repoPath,
+            });
+            const repaired = await pipeline.run({ archiveId, filename });
+            if (!repaired.session) {
+                recordResumeRepairMetrics({
+                    mode: 'repair_v1',
+                    success: false,
+                    repairViolationCount: repaired.contractViolations.length,
+                    replacementReuseHitCount: 0,
+                    contractViolationCodes: repaired.contractViolations.map((entry) => entry.code),
+                });
+                const violationText = repaired.contractViolations.map((entry) => entry.message).join('; ');
+                getLogger().warn(`Failed to restore archived session ${archiveId}: ${violationText || 'repair pipeline rejected archive'}`);
+                return null;
+            }
+            repaired.session.meta.resumeRepairState = {
+                schemaVersion: 1,
+                lastRunAt: Date.now(),
+                warnings: repaired.warnings.map((entry) => `${entry.code}: ${entry.message}`),
+                repairActions: repaired.repairActions.map((entry) => `${entry.code}: ${entry.detail}`),
+                contractViolations: repaired.contractViolations.map((entry) => `${entry.code}: ${entry.message}`),
+            };
+            repaired.session.meta.replacementState = normalizeToolResultReplacementState(repaired.replacementState);
+            recordResumeRepairMetrics({
+                mode: 'repair_v1',
+                success: true,
+                repairViolationCount: repaired.contractViolations.length,
+                replacementReuseHitCount: Object.keys(repaired.replacementState?.entries ?? {}).length,
+                contractViolationCodes: repaired.contractViolations.map((entry) => entry.code),
+            });
+            this.currentSession = repaired.session;
+            await this.save();
+            return repaired.session;
+        }
+        catch (error) {
+            recordResumeRepairMetrics({
+                mode: resumeRepairV1Enabled ? 'repair_v1' : 'legacy',
+                success: false,
+                repairViolationCount: 1,
+                replacementReuseHitCount: 0,
+                contractViolationCodes: ['RESTORE_EXCEPTION'],
+            });
+            getLogger().warn(`Failed to restore archived session ${archiveId}: ${error}`);
+            return null;
+        }
+    }
+    async restoreFromArchiveLegacy(filename) {
+        const compressed = await this.compressedStore.loadCompressed(filename);
+        if (!compressed)
+            return null;
+        const partial = await this.compressor.decompressToSession(compressed);
+        if (!partial?.meta?.id || !partial?.meta?.name)
+            return null;
+        return {
+            meta: {
+                id: partial.meta.id,
+                name: partial.meta.name,
+                repoPath: this.repoPath,
+                createdAt: partial.meta.createdAt,
+                updatedAt: Date.now(),
+                totalIterations: partial.meta.totalIterations ?? partial.iterations.length,
+                successfulIterations: partial.meta.successfulIterations ?? 0,
+                totalTokens: partial.meta.totalTokens ?? { input: 0, output: 0 },
+                snapshots: [],
+                chatState: normalizeChatState(partial.meta.chatState),
+                artifactState: normalizeSessionArtifactState(partial.meta.artifactState),
+                replacementState: normalizeToolResultReplacementState(partial.meta.replacementState),
+            },
+            messages: partial.messages.map((message, index) => ({
+                id: `restored-msg-${index}`,
+                role: message.role,
+                content: message.content,
+                timestamp: message.timestamp,
+            })),
+            iterations: partial.iterations.map((iteration, index) => ({
+                id: iteration.id || `restored-iter-${index + 1}`,
+                attempt: index + 1,
+                plan: null,
+                patch: null,
+                error: iteration.outcome === 'failure' ? iteration.summary : undefined,
+                contextSummary: iteration.summary,
+            })),
+        };
+    }
+    getArchiveStorageDir() {
+        return join(this.repoPath, '.salmonloop', 'compressed-sessions');
+    }
+    async resolveArchiveFilename(archiveId) {
+        const archiveDir = this.getArchiveStorageDir();
+        const files = (await this.fileAdapter.readdir(archiveDir).catch(() => [])).filter((file) => file.endsWith('.mpack.gz'));
+        if (files.length === 0)
+            return null;
+        if (archiveId.endsWith('.mpack.gz') && files.includes(archiveId)) {
+            return archiveId;
+        }
+        const exactFilename = `${archiveId}.mpack.gz`;
+        if (files.includes(exactFilename)) {
+            return exactFilename;
+        }
+        const prefixMatches = files.filter((file) => file.startsWith(archiveId));
+        if (prefixMatches.length === 0)
+            return null;
+        if (prefixMatches.length === 1)
+            return prefixMatches[0];
+        const withMtime = await Promise.all(prefixMatches.map(async (file) => {
+            const stats = await this.fileAdapter.stat(join(archiveDir, file));
+            return { file, mtime: stats.mtime.getTime() };
+        }));
+        withMtime.sort((a, b) => b.mtime - a.mtime);
+        return withMtime[0]?.file ?? null;
     }
 }
 //# sourceMappingURL=manager.js.map

package/dist/core/session/pruning-strategy.js

@@ -1,3 +1,7 @@
+import { FileAdapter } from '../adapters/fs/index.js';
+import { getLogger } from '../observability/logger.js';
+import { normalizeSessionArtifactState } from './artifact-state.js';
+import { SessionCompressor } from './compression.js';
 /**
  * Default memory pruning strategy configuration
  */
@@ -113,8 +117,14 @@ export class SessionPruningEngine {
  */
 export class SessionArchiver {
     archiveDir;
+    baseDir;
+    fileAdapter;
+    compressor;
     constructor(baseDir) {
+        this.baseDir = baseDir;
         this.archiveDir = `${baseDir}/.salmonloop/chat-archives`;
+        this.fileAdapter = new FileAdapter();
+        this.compressor = new SessionCompressor();
     }
     /**
      * Create session archive
@@ -131,23 +141,59 @@ export class SessionArchiver {
     /**
      * Restore session from archive
      */
-    async restoreFromArchive(_archiveId) {
+    async restoreFromArchive(archiveId) {
         try {
-            // Need to implement decompression and deserialization logic
-            // Return null for now, implement later
-            return null;
+            const archiveFile = archiveId.endsWith('.mpack.gz') ? archiveId : `${archiveId}.mpack.gz`;
+            const archivePath = `${this.archiveDir}/${archiveFile}`;
+            const encoded = await this.fileAdapter.readFile(archivePath);
+            const binary = new Uint8Array(Buffer.from(encoded, 'base64'));
+            const compressed = await this.compressor.decompressFromBinary(binary);
+            const partial = await this.compressor.decompressToSession(compressed);
+            return {
+                meta: {
+                    id: partial.meta.id,
+                    name: partial.meta.name,
+                    repoPath: this.baseDir,
+                    createdAt: partial.meta.createdAt,
+                    updatedAt: Date.now(),
+                    totalIterations: partial.meta.totalIterations ?? partial.iterations.length,
+                    successfulIterations: partial.meta.successfulIterations ?? 0,
+                    totalTokens: partial.meta.totalTokens ?? { input: 0, output: 0 },
+                    snapshots: [],
+                    artifactState: normalizeSessionArtifactState(partial.meta.artifactState),
+                },
+                messages: partial.messages.map((message, index) => ({
+                    id: `archived-msg-${index}`,
+                    role: message.role,
+                    content: message.content,
+                    timestamp: message.timestamp,
+                })),
+                iterations: partial.iterations.map((iter, index) => ({
+                    id: iter.id || `archived-iter-${index + 1}`,
+                    attempt: index + 1,
+                    plan: null,
+                    patch: null,
+                    error: iter.outcome === 'failure' ? iter.summary : undefined,
+                    contextSummary: iter.summary,
+                })),
+            };
         }
         catch {
             return null;
         }
     }
     async ensureArchiveDir() {
-        // This method is not implemented as it requires file system adapter
-        // The SessionArchiver is currently a placeholder for future implementation
+        await this.fileAdapter.mkdir(this.archiveDir);
     }
-    async writeCompressedData(_archivePath, _compressedData) {
-        // This method is not implemented as it requires file system adapter
-        // The SessionArchiver is currently a placeholder for future implementation
+    async writeCompressedData(archivePath, compressedData) {
+        const encoded = Buffer.from(compressedData).toString('base64');
+        try {
+            await this.fileAdapter.writeFile(archivePath, encoded);
+        }
+        catch (error) {
+            getLogger().warn(`Failed to write session archive ${archivePath}: ${error}`);
+            throw error;
+        }
     }
 }
 //# sourceMappingURL=pruning-strategy.js.map

package/dist/core/session/replacement-preview-provider.js

@@ -0,0 +1,24 @@
+export class SessionReplacementPreviewProvider {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    getPreviewHints() {
+        if (!this.state)
+            return undefined;
+        const out = Object.values(this.state.entries)
+            .filter((entry) => entry.decision === 'replaced' && entry.sourceArtifactHandle)
+            .sort((a, b) => a.frozenAt - b.frozenAt)
+            .map((entry) => ({
+            label: `Tool result preview: ${entry.toolResultId}`,
+            artifact: {
+                handle: entry.sourceArtifactHandle,
+                mimeType: 'application/json',
+                sha256: entry.toolResultId,
+                size: entry.preview.length,
+            },
+        }));
+        return out.length > 0 ? out : undefined;
+    }
+}
+//# sourceMappingURL=replacement-preview-provider.js.map

package/dist/core/session/replacement-state.js

@@ -0,0 +1,131 @@
+import { createHash } from 'crypto';
+export const TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION = 'v1';
+export const TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM = 'sha256';
+export const TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION = 1;
+const DEFAULT_MAX_ENTRIES = 256;
+function normalizeNewlines(value) {
+    return value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+function canonicalize(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string') {
+        return JSON.stringify(normalizeNewlines(value));
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            return JSON.stringify(String(value));
+        return JSON.stringify(Number(value));
+    }
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => canonicalize(item)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        const keys = Object.keys(record).sort();
+        const pairs = keys.map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`);
+        return `{${pairs.join(',')}}`;
+    }
+    return JSON.stringify(String(value));
+}
+export function createToolResultIdentity(params) {
+    const payloadBytes = canonicalize(params.payload);
+    const hash = createHash(TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM);
+    hash.update(TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION);
+    hash.update('\n');
+    hash.update(normalizeNewlines(params.canonicalToolCallIdentity).trim());
+    hash.update('\n');
+    hash.update(payloadBytes);
+    return hash.digest('hex');
+}
+function isValidEntry(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const entry = value;
+    if (!entry.toolResultId || typeof entry.toolResultId !== 'string')
+        return false;
+    if (entry.decision !== 'kept' && entry.decision !== 'replaced')
+        return false;
+    if (typeof entry.preview !== 'string')
+        return false;
+    if (typeof entry.frozenAt !== 'number' || !Number.isFinite(entry.frozenAt))
+        return false;
+    if (entry.sourceArtifactHandle !== undefined && typeof entry.sourceArtifactHandle !== 'string') {
+        return false;
+    }
+    if (entry.identityVersion !== TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION)
+        return false;
+    if (entry.hashAlgorithm !== TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM)
+        return false;
+    return true;
+}
+export function normalizeToolResultReplacementState(state) {
+    if (!state || typeof state !== 'object')
+        return undefined;
+    if (state.schemaVersion !== TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION)
+        return undefined;
+    if (!state.entries || typeof state.entries !== 'object')
+        return undefined;
+    const normalizedEntries = {};
+    for (const [key, value] of Object.entries(state.entries)) {
+        if (!isValidEntry(value))
+            continue;
+        if (value.toolResultId !== key)
+            continue;
+        normalizedEntries[key] = {
+            toolResultId: value.toolResultId,
+            decision: value.decision,
+            preview: value.preview,
+            frozenAt: value.frozenAt,
+            sourceArtifactHandle: value.sourceArtifactHandle,
+            identityVersion: value.identityVersion,
+            hashAlgorithm: value.hashAlgorithm,
+        };
+    }
+    if (Object.keys(normalizedEntries).length === 0)
+        return undefined;
+    return {
+        schemaVersion: TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION,
+        entries: normalizedEntries,
+    };
+}
+export function createEmptyToolResultReplacementState() {
+    return {
+        schemaVersion: TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION,
+        entries: {},
+    };
+}
+export function freezeToolResultReplacementDecision(state, entry, options) {
+    const base = normalizeToolResultReplacementState(state) ?? createEmptyToolResultReplacementState();
+    const existing = base.entries[entry.toolResultId];
+    if (existing) {
+        return base;
+    }
+    const nextEntries = {
+        ...base.entries,
+        [entry.toolResultId]: {
+            toolResultId: entry.toolResultId,
+            decision: entry.decision,
+            preview: entry.preview,
+            frozenAt: entry.frozenAt ?? Date.now(),
+            sourceArtifactHandle: entry.sourceArtifactHandle,
+            identityVersion: TOOL_RESULT_REPLACEMENT_IDENTITY_VERSION,
+            hashAlgorithm: TOOL_RESULT_REPLACEMENT_HASH_ALGORITHM,
+        },
+    };
+    const maxEntries = Math.max(1, options?.maxEntries ?? DEFAULT_MAX_ENTRIES);
+    const keys = Object.keys(nextEntries);
+    if (keys.length > maxEntries) {
+        const sorted = keys.sort((a, b) => nextEntries[a].frozenAt - nextEntries[b].frozenAt);
+        for (const evict of sorted.slice(0, keys.length - maxEntries)) {
+            delete nextEntries[evict];
+        }
+    }
+    return {
+        schemaVersion: TOOL_RESULT_REPLACEMENT_STATE_SCHEMA_VERSION,
+        entries: nextEntries,
+    };
+}
+//# sourceMappingURL=replacement-state.js.map

package/dist/core/session/resume-repair/pipeline.js

@@ -0,0 +1,79 @@
+import { randomBytes } from 'crypto';
+import { loadRawArchiveStateStage } from './stages/load-raw-archive-state.js';
+import { reattachRuntimeStateStage } from './stages/reattach-runtime-state.js';
+import { recoverOrphanedBranchesStage } from './stages/recover-orphaned-branches.js';
+import { relinkBoundaryAndTailStage } from './stages/relink-boundary-and-tail.js';
+import { replayStartupHooksStage } from './stages/replay-startup-hooks.js';
+import { rescueStaleMetadataStage } from './stages/rescue-stale-metadata.js';
+export function createResumeRepairPipeline(params) {
+    const context = {
+        repoPath: params.repoPath,
+        now: params.now ?? (() => Date.now()),
+        nextId: params.nextId ?? (() => randomBytes(6).toString('hex')),
+        startupHooks: params.startupHooks ?? [],
+    };
+    return {
+        async run(input) {
+            const compressed = await params.compressedStore.loadCompressed(input.filename);
+            if (!compressed) {
+                return {
+                    warnings: [],
+                    repairActions: [],
+                    contractViolations: [
+                        {
+                            code: 'ARCHIVE_CORRUPTED',
+                            message: `Archive "${input.archiveId}" cannot be loaded.`,
+                        },
+                    ],
+                };
+            }
+            const partial = await params.compressor.decompressToSession(compressed);
+            const state = {
+                archiveId: input.archiveId,
+                filename: input.filename,
+                compressed,
+                partial,
+                session: {
+                    meta: {
+                        id: '',
+                        name: '',
+                        repoPath: context.repoPath,
+                        createdAt: 0,
+                        updatedAt: 0,
+                        totalIterations: 0,
+                        successfulIterations: 0,
+                        totalTokens: { input: 0, output: 0 },
+                        snapshots: [],
+                    },
+                    messages: [],
+                    iterations: [],
+                },
+                warnings: [],
+                repairActions: [],
+                contractViolations: [],
+            };
+            const stages = [
+                loadRawArchiveStateStage,
+                rescueStaleMetadataStage,
+                relinkBoundaryAndTailStage,
+                recoverOrphanedBranchesStage,
+                reattachRuntimeStateStage,
+                replayStartupHooksStage,
+            ];
+            for (const stage of stages) {
+                await stage(state, context);
+                if (state.contractViolations.length > 0) {
+                    break;
+                }
+            }
+            return {
+                session: state.contractViolations.length > 0 ? undefined : state.session,
+                replacementState: state.replacementState,
+                warnings: state.warnings,
+                repairActions: state.repairActions,
+                contractViolations: state.contractViolations,
+            };
+        },
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/core/session/resume-repair/stages/load-raw-archive-state.js

@@ -0,0 +1,40 @@
+import { parseFlowMode } from '../../../types/flow-mode.js';
+import { normalizeSessionArtifactState } from '../../artifact-state.js';
+import { normalizeToolResultReplacementState } from '../../replacement-state.js';
+export const loadRawArchiveStateStage = async (state, context) => {
+    const partial = state.partial;
+    const flowMode = parseFlowMode(partial.meta.chatState?.flowMode);
+    const reconstructed = {
+        meta: {
+            id: partial.meta.id,
+            name: partial.meta.name,
+            repoPath: context.repoPath,
+            createdAt: partial.meta.createdAt,
+            updatedAt: context.now(),
+            totalIterations: partial.meta.totalIterations ?? partial.iterations.length,
+            successfulIterations: partial.meta.successfulIterations ?? 0,
+            totalTokens: partial.meta.totalTokens ?? { input: 0, output: 0 },
+            snapshots: [],
+            chatState: flowMode ? { flowMode } : undefined,
+            artifactState: normalizeSessionArtifactState(partial.meta.artifactState),
+            replacementState: normalizeToolResultReplacementState(partial.meta.replacementState),
+        },
+        messages: partial.messages.map((message, index) => ({
+            id: `restored-msg-${index}`,
+            role: message.role,
+            content: message.content,
+            timestamp: message.timestamp,
+        })),
+        iterations: partial.iterations.map((iteration, index) => ({
+            id: iteration.id || `restored-iter-${index + 1}`,
+            attempt: index + 1,
+            plan: null,
+            patch: null,
+            error: iteration.outcome === 'failure' ? iteration.summary : undefined,
+            contextSummary: iteration.summary,
+        })),
+    };
+    state.session = reconstructed;
+    state.replacementState = reconstructed.meta.replacementState;
+};
+//# sourceMappingURL=load-raw-archive-state.js.map