salmon-loop 0.2.13 → 0.3.0

package/dist/core/session/compaction/microcompact.js

@@ -0,0 +1,78 @@
+import { getLogger } from '../../observability/logger.js';
+import { DEFAULT_MICROCOMPACT_CONFIG } from './types.js';
+/**
+ * Microcompact is a rule-based context reduction utility.
+ * It's idempotent, zero-LLM-cost, and operates on the "View" layer.
+ *
+ * Rules:
+ * - Only affects messages with role === 'assistant' that contain tool results.
+ * - Preserves the most recent `keepRecentTurns` rounds.
+ * - EXCLUDES "stateful" tools (e.g. cd, export) to avoid environment desync.
+ * - Preserves the assistant's thought process (the text part) before tools.
+ */
+export function microcompact(messages, config = {}) {
+    const mergedConfig = {
+        ...DEFAULT_MICROCOMPACT_CONFIG,
+        ...config,
+    };
+    const { keepRecentTurns, placeholder, statefulTools } = mergedConfig;
+    // 1. Identify cutoff turn (1 turn = user + assistant pair, usually)
+    // We'll keep the last N assistant messages as "recent"
+    let assistantCount = 0;
+    const cutoffIndex = [...messages].reverse().findIndex((msg) => {
+        if (msg.role === 'assistant') {
+            assistantCount++;
+        }
+        return assistantCount > keepRecentTurns;
+    });
+    // Calculate the absolute index in the original array
+    const absCutoffIndex = cutoffIndex === -1 ? -1 : messages.length - 1 - cutoffIndex;
+    let totalClearedCount = 0;
+    const result = messages.map((msg, index) => {
+        // Only process assistant messages BEFORE the cutoff
+        if (index > absCutoffIndex || msg.role !== 'assistant' || !msg.content) {
+            return msg;
+        }
+        const { content } = msg;
+        // Pattern to match tool results while capturing tool name and content
+        // Improved regex to handle attributes more robustly
+        const toolResultRegex = /<tool_result\b[^>]*?name="([^"]+)"[^>]*?>([\s\S]*?)<\/tool_result>/g;
+        let hasMatched = false;
+        const newContent = content.replace(toolResultRegex, (match, toolName, toolOutput) => {
+            // Rule: Skip stateful tools
+            if (statefulTools.includes(toolName)) {
+                return match;
+            }
+            // Rule: Skip if already cleared
+            if (toolOutput.trim() === placeholder) {
+                return match;
+            }
+            hasMatched = true;
+            totalClearedCount++;
+            // Extract original tag prefix (including attributes) to preserve them
+            const tagMatch = match.match(/<tool_result\b[^>]*?>/);
+            const tagPrefix = tagMatch ? tagMatch[0] : `<tool_result name="${toolName}">`;
+            return `${tagPrefix}${placeholder}</tool_result>`;
+        });
+        if (!hasMatched) {
+            return msg;
+        }
+        return {
+            ...msg,
+            content: newContent,
+        };
+    });
+    if (totalClearedCount > 0) {
+        getLogger().audit('COMPACTION_MICROCOMPACT', {
+            clearedCount: totalClearedCount,
+            keepRecentTurns,
+        }, {
+            source: 'session',
+            severity: 'low',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=microcompact.js.map

package/dist/core/session/compaction/tracking.js

@@ -0,0 +1,48 @@
+import { randomUUID } from 'crypto';
+/**
+ * Initial compaction tracking state
+ */
+export function createInitialTracking() {
+    return {
+        compacted: false,
+        turnCounter: 0,
+        consecutiveFailures: 0,
+    };
+}
+/**
+ * Update state on successful compaction
+ */
+export function onCompactionSuccess(_prev) {
+    return {
+        compacted: true,
+        compactId: randomUUID(),
+        turnCounter: 0,
+        consecutiveFailures: 0,
+        lastCompactedAt: Date.now(),
+    };
+}
+/**
+ * Update state on compaction failure (for circuit breaker)
+ */
+export function onCompactionFailure(prev) {
+    return {
+        ...prev,
+        consecutiveFailures: prev.consecutiveFailures + 1,
+    };
+}
+/**
+ * Increment turn counter after successful execution cycle
+ */
+export function onNormalTurnComplete(prev) {
+    return {
+        ...prev,
+        turnCounter: prev.turnCounter + 1,
+    };
+}
+/**
+ * Check if circuit breaker is tripped
+ */
+export function isCircuitBreakerTripped(tracking, maxFailures) {
+    return tracking.consecutiveFailures >= maxFailures;
+}
+//# sourceMappingURL=tracking.js.map

package/dist/core/session/compaction/types.js

@@ -0,0 +1,11 @@
+export const DEFAULT_MICROCOMPACT_CONFIG = {
+    keepRecentTurns: 3, // Keep last 3 rounds (approx 6 messages)
+    placeholder: '[Previous tool output cleared for context efficiency]',
+    statefulTools: ['cd', 'export', 'env_set', 'enter_worktree', 'exit_worktree'],
+};
+export const DEFAULT_AUTOCOMPACT_CONFIG = {
+    tokenThreshold: 8000,
+    maxFailures: 3,
+    keepRecentMessages: 10,
+};
+//# sourceMappingURL=types.js.map

package/dist/core/session/compression.js

@@ -1,6 +1,8 @@
 import { promisify } from 'util';
 import { gzip, gunzip } from 'zlib';
 import { FileAdapter } from '../adapters/fs/index.js';
+import { normalizeSessionArtifactState } from './artifact-state.js';
+import { normalizeToolResultReplacementState, } from './replacement-state.js';
 export const DEFAULT_COMPRESSION_CONFIG = {
     maxKeyMessages: 20,
     maxKeyIterations: 10,
@@ -53,6 +55,9 @@ export class SessionCompressor {
                 originalSize,
                 compressedSize: 0, // Will be updated after serialization
                 compressionRatio: 0, // Will be calculated after serialization
+                chatState: session.meta.chatState,
+                artifactState: normalizeSessionArtifactState(session.meta.artifactState),
+                replacementState: normalizeToolResultReplacementState(session.meta.replacementState),
             },
             compressed: {
                 summary: summary.text,
@@ -106,6 +111,9 @@ export class SessionCompressor {
                 successfulIterations: compressed.compressed.stats.successfulIterations,
                 totalTokens: compressed.compressed.stats.totalTokens,
                 snapshots: [], // Will be restored from full data
+                chatState: compressed.meta.chatState,
+                artifactState: normalizeSessionArtifactState(compressed.meta.artifactState),
+                replacementState: normalizeToolResultReplacementState(compressed.meta.replacementState),
             },
             messages: compressed.compressed.keyMessages.map((msg) => ({
                 role: msg.role,

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