salmon-loop 0.2.13 → 0.2.16

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

@@ -0,0 +1,160 @@
+import { createToolResultIdentity, freezeToolResultReplacementDecision, } from './replacement-state.js';
+const MAX_SUBAGENT_ARTIFACTS = 4;
+const MAX_READ_ARTIFACTS = 6;
+const MAX_PREVIEW_ARTIFACTS = 6;
+function isArtifactHandle(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.handle === 'string' &&
+        typeof candidate.mimeType === 'string' &&
+        typeof candidate.sha256 === 'string' &&
+        typeof candidate.size === 'number');
+}
+function cloneArtifactHandle(artifact) {
+    if (!artifact)
+        return undefined;
+    return {
+        handle: artifact.handle,
+        mimeType: artifact.mimeType,
+        sha256: artifact.sha256,
+        size: artifact.size,
+    };
+}
+function normalizeArtifactHandles(artifacts, limit) {
+    if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const artifact of artifacts) {
+        if (!isArtifactHandle(artifact))
+            continue;
+        if (seen.has(artifact.handle))
+            continue;
+        seen.add(artifact.handle);
+        unique.push(cloneArtifactHandle(artifact));
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-limit);
+}
+function normalizeReadArtifacts(artifacts, limit) {
+    if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const item of artifacts) {
+        const path = typeof item?.path === 'string' ? item.path.trim() : '';
+        if (!path || !isArtifactHandle(item?.artifact))
+            continue;
+        const key = `${path}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push({
+            path,
+            artifact: cloneArtifactHandle(item.artifact),
+        });
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-limit);
+}
+function normalizePreviewArtifacts(artifacts, limit) {
+    if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return undefined;
+    const unique = [];
+    const seen = new Set();
+    for (const item of artifacts) {
+        const label = typeof item?.label === 'string' ? item.label.trim() : '';
+        if (!label || !isArtifactHandle(item?.artifact))
+            continue;
+        const key = `${label}::${item.artifact.handle}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push({
+            label,
+            artifact: cloneArtifactHandle(item.artifact),
+        });
+    }
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(-limit);
+}
+function hasAnyArtifactState(state) {
+    return Boolean(state.verifyArtifact ||
+        state.subAgentPatchArtifacts?.length ||
+        state.subAgentAuditArtifacts?.length ||
+        state.recentReadArtifacts?.length ||
+        state.toolResultPreviewArtifacts?.length);
+}
+export function normalizeSessionArtifactState(state) {
+    if (!state)
+        return undefined;
+    const normalized = {
+        verifyArtifact: isArtifactHandle(state.verifyArtifact)
+            ? cloneArtifactHandle(state.verifyArtifact)
+            : undefined,
+        subAgentPatchArtifacts: normalizeArtifactHandles(state.subAgentPatchArtifacts, MAX_SUBAGENT_ARTIFACTS),
+        subAgentAuditArtifacts: normalizeArtifactHandles(state.subAgentAuditArtifacts, MAX_SUBAGENT_ARTIFACTS),
+        recentReadArtifacts: normalizeReadArtifacts(state.recentReadArtifacts, MAX_READ_ARTIFACTS),
+        toolResultPreviewArtifacts: normalizePreviewArtifacts(state.toolResultPreviewArtifacts, MAX_PREVIEW_ARTIFACTS),
+    };
+    return hasAnyArtifactState(normalized) ? normalized : undefined;
+}
+export function mergeSessionArtifactState(existing, incoming) {
+    const base = normalizeSessionArtifactState(existing);
+    const next = normalizeSessionArtifactState(incoming);
+    if (!base)
+        return next;
+    if (!next)
+        return base;
+    return normalizeSessionArtifactState({
+        verifyArtifact: next.verifyArtifact ?? base.verifyArtifact,
+        subAgentPatchArtifacts: [
+            ...(base.subAgentPatchArtifacts ?? []),
+            ...(next.subAgentPatchArtifacts ?? []),
+        ],
+        subAgentAuditArtifacts: [
+            ...(base.subAgentAuditArtifacts ?? []),
+            ...(next.subAgentAuditArtifacts ?? []),
+        ],
+        recentReadArtifacts: [...(base.recentReadArtifacts ?? []), ...(next.recentReadArtifacts ?? [])],
+        toolResultPreviewArtifacts: [
+            ...(base.toolResultPreviewArtifacts ?? []),
+            ...(next.toolResultPreviewArtifacts ?? []),
+        ],
+    });
+}
+export function buildSessionArtifactStateFromLoopResult(result) {
+    const hints = result.artifactHints;
+    const withVerifyFallback = hints || result.verifyArtifact
+        ? {
+            ...hints,
+            verifyArtifact: hints?.verifyArtifact ?? result.verifyArtifact,
+        }
+        : undefined;
+    return normalizeSessionArtifactState(withVerifyFallback);
+}
+export function mergeReplacementStateFromArtifactHints(existing, artifactHints, now = () => Date.now()) {
+    let next = existing;
+    for (const item of artifactHints?.toolResultPreviewArtifacts ?? []) {
+        const toolResultId = createToolResultIdentity({
+            canonicalToolCallIdentity: item.label,
+            payload: {
+                label: item.label,
+                handle: item.artifact.handle,
+            },
+        });
+        next = freezeToolResultReplacementDecision(next, {
+            toolResultId,
+            decision: 'replaced',
+            preview: item.label,
+            sourceArtifactHandle: item.artifact.handle,
+            frozenAt: now(),
+        }, { maxEntries: 256 });
+    }
+    return next;
+}
+//# sourceMappingURL=artifact-state.js.map

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

@@ -0,0 +1,183 @@
+import { getModelRecommendedBudget } from '../../context/token/adaptive-budget.js';
+import { LlmError } from '../../llm/errors.js';
+import { getLogger } from '../../observability/logger.js';
+import { refreshSessionSummary } from '../summary-sync.js';
+import { TokenTracker } from '../token-tracker.js';
+import { isCircuitBreakerTripped, onCompactionFailure, onCompactionSuccess } from './tracking.js';
+import { DEFAULT_AUTOCOMPACT_CONFIG } from './types.js';
+function isContextOverflowLike(error) {
+    if (error instanceof LlmError && error.llmCode === 'LLM_CONTEXT_LENGTH_EXCEEDED') {
+        return true;
+    }
+    const message = error instanceof Error
+        ? error.message
+        : error && typeof error === 'object' && typeof error.message === 'string'
+            ? String(error.message)
+            : '';
+    if (!message)
+        return false;
+    const lower = message.toLowerCase();
+    return (lower.includes('maximum context length') ||
+        lower.includes('context length') ||
+        lower.includes('too many tokens') ||
+        lower.includes('prompt is too long') ||
+        lower.includes('input is too long') ||
+        lower.includes('reduce the length') ||
+        lower.includes('please reduce'));
+}
+/**
+ * Autocompact (Level 1)
+ *
+ * Triggered when token count exceeds threshold.
+ * Uses existing summarization infrastructure to reduce context.
+ */
+export async function autocompact(params) {
+    const { sessionManager, llm, tracking, contextHash } = params;
+    const trigger = params.trigger ?? 'auto';
+    const modelId = llm.getModelId?.();
+    // Resolve dynamic threshold if not provided in config
+    let resolvedThreshold = params.config?.tokenThreshold;
+    if (resolvedThreshold === undefined) {
+        if (modelId) {
+            try {
+                resolvedThreshold = getModelRecommendedBudget(modelId);
+            }
+            catch (_error) {
+                // Fallback to default if resolution fails
+                resolvedThreshold = DEFAULT_AUTOCOMPACT_CONFIG.tokenThreshold;
+            }
+        }
+        else {
+            resolvedThreshold = DEFAULT_AUTOCOMPACT_CONFIG.tokenThreshold;
+        }
+    }
+    const config = {
+        ...DEFAULT_AUTOCOMPACT_CONFIG,
+        ...params.config,
+        tokenThreshold: resolvedThreshold,
+    };
+    // 1. Check circuit breaker
+    if (isCircuitBreakerTripped(tracking, config.maxFailures)) {
+        getLogger().audit('COMPACTION_SKIP', {
+            reason: 'circuit_breaker',
+            trigger,
+            modelId: modelId ?? 'unknown',
+            tokenThreshold: config.tokenThreshold,
+            consecutiveFailures: tracking.consecutiveFailures,
+            maxFailures: config.maxFailures,
+        }, {
+            source: 'session',
+            severity: 'low',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return { performed: false, tracking };
+    }
+    // 2. Check threshold (only for auto trigger)
+    const messages = sessionManager.getMessages();
+    const totalTokens = TokenTracker.estimateMessagesTokens(messages);
+    if (trigger === 'auto' && totalTokens < config.tokenThreshold) {
+        getLogger().audit('COMPACTION_SKIP', {
+            reason: 'below_threshold',
+            trigger,
+            modelId: modelId ?? 'unknown',
+            preTokens: totalTokens,
+            tokenThreshold: config.tokenThreshold,
+        }, {
+            source: 'session',
+            severity: 'low',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return { performed: false, tracking };
+    }
+    // 3. Perform summarization
+    try {
+        // Reuse existing refreshSessionSummary with 'force' strategy
+        // This will trigger the ConversationSummarizer logic
+        const summaryResult = await refreshSessionSummary({
+            sessionManager,
+            llm,
+            contextHash,
+            strategy: 'force',
+            strict: true,
+        });
+        if (!summaryResult.didSummarize) {
+            getLogger().audit('COMPACTION_SKIP', {
+                reason: 'no_op',
+                trigger,
+                modelId: modelId ?? 'unknown',
+                preTokens: totalTokens,
+                tokenThreshold: config.tokenThreshold,
+            }, {
+                source: 'session',
+                severity: 'low',
+                scope: 'session',
+                phase: 'COMPACTION',
+            });
+            return { performed: false, tracking };
+        }
+        const updatedSummary = sessionManager.getSummaryState();
+        getLogger().audit(`COMPACTION_${trigger.toUpperCase()}COMPACT`, {
+            trigger,
+            modelId: modelId ?? 'unknown',
+            preTokens: totalTokens,
+            tokenThreshold: config.tokenThreshold,
+            summaryTokens: updatedSummary?.summaryTokens,
+            hasRecoveryState: Boolean(updatedSummary?.recoveryState),
+            circuitBreakerState: { consecutiveFailures: 0 },
+        }, {
+            source: 'session',
+            severity: 'medium',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return {
+            performed: true,
+            tracking: onCompactionSuccess(tracking),
+            preTokens: totalTokens,
+            trigger: trigger,
+        };
+    }
+    catch (error) {
+        const newTracking = onCompactionFailure(tracking);
+        getLogger().audit('COMPACTION_FAILURE', {
+            error: error instanceof Error ? error.message : String(error),
+            consecutiveFailures: newTracking.consecutiveFailures,
+            trigger,
+        }, {
+            source: 'session',
+            severity: 'medium',
+            scope: 'session',
+            phase: 'COMPACTION',
+        });
+        return {
+            performed: false,
+            tracking: newTracking,
+        };
+    }
+}
+/**
+ * Reactive Compact (Level 2)
+ *
+ * Emergency compaction when LLM returns prompt-too-long error.
+ */
+export async function reactiveCompact(params) {
+    if (!isContextOverflowLike(params.error)) {
+        return { performed: false, tracking: params.tracking };
+    }
+    return autocompact({
+        ...params,
+        trigger: 'reactive',
+    });
+}
+/**
+ * Main Compaction Pipeline entry point
+ */
+export async function runCompactionPipeline(params) {
+    // Level 0 (Microcompact) is already integrated into buildEffectiveConversationContext
+    // and refreshSessionSummary.
+    // Level 1: Autocompact
+    return autocompact(params);
+}
+//# sourceMappingURL=index.js.map

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,