salmon-loop 0.3.2 → 0.5.0

package/dist/core/reflection/engine.js

@@ -1,15 +1,21 @@
 import { getLogger } from '../observability/logger.js';
 import { getPromptRegistry } from '../prompts/registry.js';
 import { executeUpdateKnowledge } from '../tools/builtin/knowledge.js';
+// Frequency limiter for success reflections: at most once per N successes
+let successReflectionCounter = 0;
+const SUCCESS_REFLECTION_INTERVAL = 5;
 export class ReflectionEngine {
     llm;
     constructor(llm) {
         this.llm = llm;
     }
+    /**
+     * Main reflection: failures followed by success.
+     * Extracts "what went wrong and how it was fixed".
+     */
     async reflect(input, repoRoot) {
         const promptRegistry = getPromptRegistry();
         await promptRegistry.init();
-        // Only reflect if there were failures and final success
         const failures = input.history.filter((h) => h.error);
         if (failures.length === 0 || !input.success) {
             return { lessons: [] };
@@ -21,19 +27,45 @@ export class ReflectionEngine {
                 responseFormat: 'json_object',
             });
             const content = response.content;
-            // Extract JSON from response (handle potential markdown markers)
             const jsonStr = content.match(/\{[\s\S]*\}/)?.[0] || content;
             const result = JSON.parse(jsonStr);
-            // Persist suggested knowledge if any
-            if (result.suggestedRules && result.suggestedRules.length > 0) {
-                // Since we are in the engine, we can call the executor directly
-                const mockCtx = { repoRoot };
-                await executeUpdateKnowledge({
-                    category: 'project_rules',
-                    rules: result.suggestedRules,
-                    deprecated_rules: result.deprecatedRules,
-                }, mockCtx);
-            }
+            await this.persistKnowledge(result, repoRoot);
+            getLogger().debug(`[Reflection] Reflection completed with ${result.lessons?.length ?? 0} lessons.`);
+            return result;
+        }
+        catch (e) {
+            getLogger().warn(`[Reflection] Failed to perform reflection: ${e instanceof Error ? e.message : String(e)}`);
+            return { lessons: [] };
+        }
+    }
+    /**
+     * Reflect on first-try success (attempt === 1).
+     * Extracts "what was done right" as positive patterns.
+     * Frequency-limited: at most once every SUCCESS_REFLECTION_INTERVAL successes.
+     */
+    async reflectOnSuccess(input, repoRoot) {
+        successReflectionCounter++;
+        if (successReflectionCounter % SUCCESS_REFLECTION_INTERVAL !== 0) {
+            return { lessons: [] };
+        }
+        const promptRegistry = getPromptRegistry();
+        await promptRegistry.init();
+        getLogger().debug('[Reflection] Triggering success reflection (first-try success).');
+        const successPrompt = [
+            'The task was completed successfully on the first attempt.',
+            `Instruction: ${input.instruction}`,
+            '',
+            'Analyze what was done correctly. Extract 1-2 concise positive patterns that contributed to success.',
+            'Return JSON: { "lessons": ["..."], "suggestedDecisions": ["..."] }',
+            'Each decision should be a short, actionable pattern (10-200 chars).',
+        ].join('\n');
+        try {
+            const response = await this.llm.chat([{ role: 'user', content: successPrompt }], {
+                responseFormat: 'json_object',
+            });
+            const content = response.content;
+            const jsonStr = content.match(/\{[\s\S]*\}/)?.[0] || content;
+            const result = JSON.parse(jsonStr);
             if (result.suggestedDecisions && result.suggestedDecisions.length > 0) {
                 const mockCtx = { repoRoot };
                 for (const decision of result.suggestedDecisions) {
@@ -43,13 +75,81 @@ export class ReflectionEngine {
                     }, mockCtx);
                 }
             }
-            getLogger().debug(`[Reflection] Reflection completed with ${result.lessons?.length ?? 0} lessons.`);
+            await this.persistLessons(result.lessons, repoRoot, 'success');
             return result;
         }
         catch (e) {
-            getLogger().warn(`[Reflection] Failed to perform reflection: ${e instanceof Error ? e.message : String(e)}`);
+            getLogger().warn(`[Reflection] Failed to perform success reflection: ${e instanceof Error ? e.message : String(e)}`);
+            return { lessons: [] };
+        }
+    }
+    /**
+     * Reflect on final failure (all retries exhausted).
+     * Extracts "why it failed" as deprecated approaches.
+     * No LLM call — structured extraction from failure history.
+     */
+    async reflectOnFailure(input, repoRoot) {
+        const failures = input.history.filter((h) => h.error);
+        if (failures.length === 0)
             return { lessons: [] };
+        getLogger().debug(`[Reflection] Extracting failure lessons from ${failures.length} failed attempts.`);
+        // Structured extraction: collect unique error patterns
+        const errorPatterns = new Set();
+        for (const entry of failures) {
+            if (!entry.error)
+                continue;
+            const summary = typeof entry.contextSummary === 'string'
+                ? entry.contextSummary.slice(0, 200)
+                : String(entry.error).slice(0, 200);
+            errorPatterns.add(summary);
         }
+        const lessons = Array.from(errorPatterns).map((pattern) => `Approach failed: ${pattern}`);
+        // Write deprecated rules
+        const deprecatedApproaches = Array.from(errorPatterns).map((pattern) => `Avoid: ${pattern.slice(0, 100)}`);
+        if (deprecatedApproaches.length > 0) {
+            const mockCtx = { repoRoot };
+            await executeUpdateKnowledge({
+                category: 'project_rules',
+                rules: [],
+                deprecated_rules: deprecatedApproaches,
+            }, mockCtx).catch((e) => {
+                getLogger().warn(`[Reflection] Failed to persist failure lessons: ${String(e)}`);
+            });
+        }
+        await this.persistLessons(lessons, repoRoot, 'failure');
+        return { lessons };
+    }
+    async persistKnowledge(result, repoRoot) {
+        if (result.suggestedRules && result.suggestedRules.length > 0) {
+            const mockCtx = { repoRoot };
+            await executeUpdateKnowledge({
+                category: 'project_rules',
+                rules: result.suggestedRules,
+                deprecated_rules: result.deprecatedRules,
+            }, mockCtx);
+        }
+        if (result.suggestedDecisions && result.suggestedDecisions.length > 0) {
+            const mockCtx = { repoRoot };
+            for (const decision of result.suggestedDecisions) {
+                await executeUpdateKnowledge({
+                    category: 'architectural_decisions',
+                    decision,
+                }, mockCtx);
+            }
+        }
+        await this.persistLessons(result.lessons, repoRoot, 'success');
+    }
+    async persistLessons(lessons, repoRoot, source) {
+        if (lessons.length === 0)
+            return;
+        const mockCtx = { repoRoot };
+        await executeUpdateKnowledge({
+            category: 'lessons_learned',
+            lessons,
+            source,
+        }, mockCtx).catch((e) => {
+            getLogger().warn(`[Reflection] Failed to persist lessons: ${String(e)}`);
+        });
     }
 }
 //# sourceMappingURL=engine.js.map

package/dist/core/runtime/agent-server-runtime.js

@@ -65,12 +65,13 @@ export function createAgentServerRuntime(deps) {
         }
     }
     async function close() {
-        if (!a2aServerInstance) {
+        const instance = a2aServerInstance;
+        if (!instance) {
             started = false;
             return;
         }
         await new Promise((resolve, reject) => {
-            a2aServerInstance.close((error) => {
+            instance.close((error) => {
                 if (error) {
                     reject(error);
                     return;

package/dist/core/runtime/batch-runner.js

@@ -0,0 +1,81 @@
+import { createRunSalmonLoop } from './loop.js';
+export class BatchRunner {
+    runLoop;
+    constructor(deps) {
+        this.runLoop = createRunSalmonLoop({ semaphore: deps?.semaphore });
+    }
+    async run(tasks, batchOptions) {
+        const { rateLimitMs = 0, filter, signal } = batchOptions ?? {};
+        const filtered = filter ? tasks.filter(filter) : tasks;
+        const results = [];
+        for (let i = 0; i < filtered.length; i++) {
+            if (signal?.aborted)
+                break;
+            if (i > 0 && rateLimitMs > 0) {
+                await new Promise((r) => setTimeout(r, rateLimitMs));
+            }
+            const result = await this.runLoop(filtered[i]);
+            results.push(result);
+        }
+        return buildBatchRunReport(results);
+    }
+}
+function aggregateUsage(results) {
+    const total = { inputTokens: 0, outputTokens: 0, totalTokens: 0, estimatedCost: 0 };
+    for (const r of results) {
+        if (!r.usage)
+            continue;
+        total.inputTokens += r.usage.inputTokens;
+        total.outputTokens += r.usage.outputTokens;
+        total.totalTokens += r.usage.totalTokens;
+        if (r.usage.estimatedCost)
+            total.estimatedCost += r.usage.estimatedCost;
+    }
+    return total;
+}
+export function buildBatchRunReport(results) {
+    const completed = results.filter((r) => r.success).length;
+    const failed = results.length - completed;
+    const totalDuration = results.reduce((s, r) => s + (r.durationMs ?? 0), 0);
+    return {
+        totalRuns: results.length,
+        completedRuns: completed,
+        failedRuns: failed,
+        successRate: results.length > 0 ? completed / results.length : 0,
+        avgDurationMs: results.length > 0 ? totalDuration / results.length : 0,
+        results,
+        totalUsage: aggregateUsage(results),
+        byDimension: (dimension) => buildDimensionMap(results, dimension),
+    };
+}
+function buildDimensionMap(results, dimension) {
+    const map = {};
+    for (const r of results) {
+        const value = String(r.providerMeta?.[dimension] ?? 'unknown');
+        map[value] ??= {
+            total: 0,
+            success: 0,
+            failed: 0,
+            avgDurationMs: 0,
+            totalUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        };
+        const bucket = map[value];
+        bucket.total++;
+        if (r.success)
+            bucket.success++;
+        else
+            bucket.failed++;
+        if (r.durationMs)
+            bucket.avgDurationMs += r.durationMs;
+        if (r.usage) {
+            bucket.totalUsage.inputTokens += r.usage.inputTokens;
+            bucket.totalUsage.outputTokens += r.usage.outputTokens;
+            bucket.totalUsage.totalTokens += r.usage.totalTokens;
+        }
+    }
+    for (const bucket of Object.values(map)) {
+        bucket.avgDurationMs = bucket.total > 0 ? bucket.avgDurationMs / bucket.total : 0;
+    }
+    return map;
+}
+//# sourceMappingURL=batch-runner.js.map

package/dist/core/runtime/initialize.js

@@ -1,19 +1,24 @@
+import { readFileSync } from '../adapters/fs/node-fs.js';
 import { initializeDefaultCalculator } from '../context/policies/pack-until-full.js';
+import { getRepoAgentsConfigPath, getUserAgentsConfigPath } from '../extensions/paths.js';
+import { AgentsConfigSchema } from '../extensions/schemas.js';
 import { createLogger, getLogger, setLogger, tryGetLogger } from '../observability/logger.js';
 import { createMonitor, setMonitor, tryGetMonitor } from '../observability/monitor.js';
 import { registerDefaultSubAgentProfiles } from '../sub-agent/registry-defaults.js';
 import { createSubAgentRegistry, setSubAgentRegistry, tryGetSubAgentRegistry, } from '../sub-agent/registry.js';
+import { isRecord } from '../utils/serialize.js';
 /**
  * Initializes the Core safety runtime.
  * Mounts global error handlers and ensures environment safety.
  */
+const GLOBAL_FLAG = '__SALMON_RUNTIME_INITIALIZED__';
 export function initializeRuntime() {
     // Prevent duplicate initialization
-    if (globalThis.__SALMON_RUNTIME_INITIALIZED__)
+    if (globalThis[GLOBAL_FLAG])
         return;
     // Bypass interception in debug mode to allow raw console/stream output
     if (process.env.SALMONLOOP_DEBUG === 'true') {
-        globalThis.__SALMON_RUNTIME_INITIALIZED__ = true;
+        globalThis[GLOBAL_FLAG] = true;
         return;
     }
     // Preload token calculator in background (non-blocking)
@@ -32,6 +37,7 @@ export function initializeRuntime() {
     if (!tryGetSubAgentRegistry()) {
         const registry = createSubAgentRegistry();
         registerDefaultSubAgentProfiles(registry);
+        loadUserAgentProfiles(registry);
         setSubAgentRegistry(registry);
     }
     const isGui = process.argv.includes('--gui');
@@ -40,10 +46,12 @@ export function initializeRuntime() {
     const originalConsoleError = console.error;
     console.error = (...args) => {
         const sanitizedArgs = args.map((arg) => {
-            if (typeof arg === 'object' && arg !== null) {
+            if (isRecord(arg)) {
                 // Drop the object structure entirely for console output to prevent UI pollution
-                const code = arg.code || arg.llmCode || 'TECHNICAL_ERROR';
-                const msg = arg.message || 'No detail provided';
+                const code = (typeof arg.code === 'string' ? arg.code : undefined) ||
+                    (typeof arg.llmCode === 'string' ? arg.llmCode : undefined) ||
+                    'TECHNICAL_ERROR';
+                const msg = (typeof arg.message === 'string' ? arg.message : undefined) || 'No detail provided';
                 return `[${code}] ${msg}`;
             }
             return arg;
@@ -127,6 +135,63 @@ export function initializeRuntime() {
     process.on('uncaughtException', (error) => {
         getLogger().error('Uncaught Exception detected in Core runtime', error, true);
     });
-    globalThis.__SALMON_RUNTIME_INITIALIZED__ = true;
+    globalThis[GLOBAL_FLAG] = true;
+}
+function loadUserAgentProfiles(registry) {
+    const tryLoadSync = (filePath) => {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            return AgentsConfigSchema.parse(JSON.parse(content));
+        }
+        catch (error) {
+            getLogger().debug(`[InitializeRuntime] Failed to load agent config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    };
+    // Load from repo and user scopes; repo takes priority
+    const repoRoot = process.cwd();
+    const userConfig = tryLoadSync(getUserAgentsConfigPath());
+    const repoConfig = tryLoadSync(getRepoAgentsConfigPath(repoRoot));
+    const toProfile = (raw) => ({
+        id: raw.id,
+        name: raw.name,
+        role: raw.role,
+        description: raw.description,
+        allowedTools: raw.allowedTools ?? ['code.search', 'fs.read'],
+        readOnly: raw.readOnly ?? false,
+        stratagem: raw.stratagem ?? 'investigator',
+        toolInheritance: raw.toolInheritance,
+        permissionMode: raw.permissionMode,
+        systemPrompt: raw.systemPrompt,
+        maxTokens: raw.maxTokens,
+        maxAttempts: raw.maxAttempts,
+        timeoutMs: raw.timeoutMs,
+    });
+    // User profiles first (lower priority)
+    if (userConfig) {
+        for (const agent of userConfig.agents) {
+            if (agent.enabled === false)
+                continue;
+            // Don't override built-in profiles
+            if (registry.has(agent.id)) {
+                tryGetLogger()?.debug(`[initializeRuntime] Skipping user agent '${agent.id}': conflicts with built-in profile`);
+                continue;
+            }
+            registry.register(toProfile(agent));
+        }
+    }
+    // Repo profiles override user (higher priority)
+    if (repoConfig) {
+        for (const agent of repoConfig.agents) {
+            if (agent.enabled === false)
+                continue;
+            // Don't override built-in profiles
+            if (registry.has(agent.id)) {
+                tryGetLogger()?.debug(`[initializeRuntime] Skipping repo agent '${agent.id}': conflicts with built-in profile`);
+                continue;
+            }
+            registry.register(toProfile(agent));
+        }
+    }
 }
 //# sourceMappingURL=initialize.js.map

package/dist/core/runtime/loop-finalize.js

@@ -1,4 +1,5 @@
 import { text } from '../../locales/index.js';
+import { persistEffectiveness } from '../context/effectiveness/persistence.js';
 import { appendAuditTrailToAuditFile } from '../observability/audit-file.js';
 import { clearAuditContext, drainAuditDropStats, recordAuditEvent, } from '../observability/audit-trail.js';
 import { getLogger } from '../observability/logger.js';
@@ -64,6 +65,8 @@ export async function finalizeLoopRun(params) {
             if (finalResult)
                 finalResult.auditPath = appendedPath;
         }
+        // Persist effectiveness data for cross-session learning
+        await persistEffectiveness(options.repoPath).catch(() => { });
         clearAuditContext();
     }
     return { latestAuditPath, finalResult };

package/dist/core/runtime/loop-session-runner.js

@@ -1,5 +1,10 @@
+import { restoreEffectiveness } from '../context/effectiveness/persistence.js';
+import { getEffectivenessTracker } from '../context/effectiveness/tracker.js';
 import { buildFlowTransactionRunner, runFlowSession } from '../grizzco/engine/transaction/index.js';
 export async function executeLoopSession(params) {
+    // Restore effectiveness data from previous sessions
+    await restoreEffectiveness(params.options.repoPath).catch(() => { });
+    getEffectivenessTracker().startSession();
     const hostContext = await params.lifecycle.hostRunner.boot();
     const runner = buildFlowTransactionRunner({
         flowMode: hostContext.flowMode,

package/dist/core/runtime/loop.js

@@ -25,6 +25,7 @@ export class SalmonLoop {
         this.config = config;
     }
     async run(options) {
+        const runStartedAt = Date.now();
         const lifecycle = initializeLoopLifecycle(options);
         let latestAuditPath;
         let finalResult;
@@ -78,6 +79,9 @@ export class SalmonLoop {
             });
             latestAuditPath = finalized.latestAuditPath;
             finalResult = finalized.finalResult;
+            if (finalResult) {
+                finalResult.durationMs = Date.now() - runStartedAt;
+            }
         }
     }
 }

package/dist/core/runtime/paths.js

@@ -2,12 +2,14 @@ import { createHash } from 'crypto';
 import * as os from 'os';
 import path from 'path';
 import { mkdir, readdir, rename, rm, stat } from '../adapters/fs/node-fs.js';
+import { getLogger } from '../observability/logger.js';
 async function pathExists(target) {
     try {
         await stat(target);
         return true;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[RuntimePaths] pathExists check failed for ${target}: ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
 }
@@ -54,7 +56,8 @@ export async function migrateLegacyRuntime(repoRoot) {
             await rename(legacyRoot, runtimeRoot);
             return;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[RuntimePaths] Failed to rename legacy runtime root: ${error instanceof Error ? error.message : String(error)}`);
             await mkdir(runtimeRoot, { recursive: true });
         }
     }
@@ -67,8 +70,8 @@ export async function migrateLegacyRuntime(repoRoot) {
         try {
             await rename(from, to);
         }
-        catch {
-            // Best-effort migration; keep legacy data if move fails.
+        catch (error) {
+            getLogger().debug(`[RuntimePaths] Failed to migrate legacy entry ${entry.name}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     try {
@@ -77,8 +80,8 @@ export async function migrateLegacyRuntime(repoRoot) {
             await rm(legacyRoot, { recursive: true, force: true });
         }
     }
-    catch {
-        // Ignore cleanup failures; legacy folder can be removed manually.
+    catch (error) {
+        getLogger().debug(`[RuntimePaths] Failed to clean up legacy runtime folder: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 //# sourceMappingURL=paths.js.map

package/dist/core/runtime/spawn-interactive.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import { EventEmitter } from 'events';
+import { getLogger } from '../observability/logger.js';
 import { getBunRuntime, normalizeSignal, toNodeReadableStream } from './bun-runtime.js';
 export function spawnInteractiveProcess(input) {
     const bun = getBunRuntime();
@@ -37,8 +38,8 @@ export function spawnInteractiveProcess(input) {
                 try {
                     subprocess.kill(signal);
                 }
-                catch {
-                    // Ignore kill errors.
+                catch (error) {
+                    getLogger().debug(`[SpawnInteractive] Failed to kill bun subprocess: ${error instanceof Error ? error.message : String(error)}`);
                 }
             },
             on: (event, listener) => {
@@ -75,8 +76,8 @@ export function spawnInteractiveProcess(input) {
             try {
                 child.kill(signal);
             }
-            catch {
-                // Ignore kill errors.
+            catch (error) {
+                getLogger().debug(`[SpawnInteractive] Failed to kill child process: ${error instanceof Error ? error.message : String(error)}`);
             }
         },
         on: (event, listener) => {

package/dist/core/security/redaction.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 const DEFAULT_REDACTION_MARK = '[REDACTED]';
 const DEFAULT_LIMITS = {
     maxDepth: 6,
@@ -34,8 +35,8 @@ export function setRedactionConfig(options) {
             try {
                 compiledPatterns.push(new RegExp(pattern, 'g'));
             }
-            catch {
-                // Ignore invalid patterns to avoid breaking runtime.
+            catch (error) {
+                getLogger().debug(`[SecurityRedaction] Skipping invalid redaction pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
             }
         }
     }

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

@@ -1,6 +1,7 @@
 import { getModelRecommendedBudget } from '../../context/token/adaptive-budget.js';
 import { LlmError } from '../../llm/errors.js';
 import { getLogger } from '../../observability/logger.js';
+import { isRecord } from '../../utils/serialize.js';
 import { refreshSessionSummary } from '../summary-sync.js';
 import { TokenTracker } from '../token-tracker.js';
 import { isCircuitBreakerTripped, onCompactionFailure, onCompactionSuccess } from './tracking.js';
@@ -11,8 +12,8 @@ function isContextOverflowLike(error) {
     }
     const message = error instanceof Error
         ? error.message
-        : error && typeof error === 'object' && typeof error.message === 'string'
-            ? String(error.message)
+        : isRecord(error) && typeof error.message === 'string'
+            ? error.message
             : '';
     if (!message)
         return false;
@@ -136,7 +137,7 @@ export async function autocompact(params) {
             performed: true,
             tracking: onCompactionSuccess(tracking),
             preTokens: totalTokens,
-            trigger: trigger,
+            trigger,
         };
     }
     catch (error) {

package/dist/core/session/compression.js

@@ -1,6 +1,7 @@
 import { promisify } from 'util';
 import { gzip, gunzip } from 'zlib';
 import { FileAdapter } from '../adapters/fs/index.js';
+import { getLogger } from '../observability/logger.js';
 import { normalizeSessionArtifactState } from './artifact-state.js';
 import { normalizeToolResultReplacementState, } from './replacement-state.js';
 export const DEFAULT_COMPRESSION_CONFIG = {
@@ -307,7 +308,8 @@ export class CompressedSessionStore {
             const data = await this.readFile(filepath);
             return await this.compressor.decompressFromBinary(data);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[SessionCompression] Failed to load compressed session ${filename}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }

package/dist/core/session/manager.js

@@ -132,7 +132,8 @@ export class ChatSessionManager {
             this.currentSession = parsed;
             return this.currentSession;
         }
-        catch {
+        catch (error) {
+            getLogger().warn(`[SessionManager] Failed to load session ${targetId}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }
@@ -268,34 +269,11 @@ export class ChatSessionManager {
      * List all sessions (sorted by update time)
      */
     async listSessions() {
-        const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
-        const jsonFiles = files.filter((f) => f.endsWith('.json'));
-        const sessions = [];
-        for (let i = 0; i < jsonFiles.length; i += ChatSessionManager.FILE_READ_CHUNK_SIZE) {
-            const chunk = jsonFiles.slice(i, i + ChatSessionManager.FILE_READ_CHUNK_SIZE);
-            const promises = chunk.map(async (file) => {
-                try {
-                    const filePath = join(this.storageDir, file);
-                    const data = await this.fileAdapter.readFile(filePath);
-                    const session = JSON.parse(data);
-                    return {
-                        id: session.meta.id,
-                        name: session.meta.name,
-                        updatedAt: session.meta.updatedAt,
-                    };
-                }
-                catch (error) {
-                    getLogger().warn(`Failed to list session file ${file}: ${error}`);
-                    return null;
-                }
-            });
-            const results = await Promise.all(promises);
-            for (const result of results) {
-                if (result) {
-                    sessions.push(result);
-                }
-            }
-        }
+        const sessions = await this.scanSessionFiles((session) => ({
+            id: session.meta.id,
+            name: session.meta.name,
+            updatedAt: session.meta.updatedAt,
+        }));
         return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
     }
     /**
@@ -344,9 +322,22 @@ export class ChatSessionManager {
      * Load all sessions from storage
      */
     async loadAllSessions() {
+        return this.scanSessionFiles((session) => {
+            session.meta.chatState = normalizeChatState(session.meta.chatState);
+            session.meta.artifactState = normalizeSessionArtifactState(session.meta.artifactState);
+            session.meta.replacementState = normalizeToolResultReplacementState(session.meta.replacementState);
+            return session;
+        });
+    }
+    /**
+     * Shared scan-and-parse for session files.
+     * Reads JSON files from storageDir in chunks, parses each, and maps via the provided callback.
+     * Silently skips files that fail to parse.
+     */
+    async scanSessionFiles(mapFn) {
         const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
         const jsonFiles = files.filter((f) => f.endsWith('.json'));
-        const sessions = [];
+        const results = [];
         for (let i = 0; i < jsonFiles.length; i += ChatSessionManager.FILE_READ_CHUNK_SIZE) {
             const chunk = jsonFiles.slice(i, i + ChatSessionManager.FILE_READ_CHUNK_SIZE);
             const promises = chunk.map(async (file) => {
@@ -354,24 +345,21 @@ 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);
-                    return session;
+                    return mapFn(session);
                 }
                 catch (error) {
                     getLogger().warn(`Failed to load session file ${file}: ${error}`);
                     return null;
                 }
             });
-            const results = await Promise.all(promises);
-            for (const result of results) {
+            const chunkResults = await Promise.all(promises);
+            for (const result of chunkResults) {
                 if (result) {
-                    sessions.push(result);
+                    results.push(result);
                 }
             }
         }
-        return sessions;
+        return results;
     }
     /**
      * Delete a session file