salmon-loop 0.4.1 → 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/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

@@ -143,7 +143,8 @@ function loadUserAgentProfiles(registry) {
             const content = readFileSync(filePath, 'utf-8');
             return AgentsConfigSchema.parse(JSON.parse(content));
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[InitializeRuntime] Failed to load agent config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     };

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/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;
         }
     }

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

@@ -178,7 +178,8 @@ export class SessionArchiver {
                 })),
             };
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[SessionPruning] Failed to restore session from archive: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }

package/dist/core/session/token-tracker.js

@@ -1,6 +1,8 @@
 import path from 'path';
 import { FileAdapter } from '../adapters/fs/index.js';
+import { estimateCost } from '../config/model-pricing.js';
 import { logIgnoredError } from '../observability/ignored-error.js';
+import { getLogger } from '../observability/logger.js';
 import { isRecord } from '../utils/serialize.js';
 /**
  * Token usage tracker for chat sessions.
@@ -39,8 +41,8 @@ export class TokenTracker {
                 try {
                     events.push(JSON.parse(line));
                 }
-                catch {
-                    // Skip malformed lines
+                catch (error) {
+                    getLogger().debug(`[TokenTracker] Skipping malformed JSON line in events file: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             let inputTokens = 0;
@@ -76,11 +78,16 @@ export class TokenTracker {
         }
     }
     /**
-     * Accumulate tokens into session metadata
+     * Accumulate tokens into session metadata.
+     * Computes estimated cost if model pricing is available.
      */
-    static accumulate(session, usage) {
+    static accumulate(session, usage, modelId) {
         session.meta.totalTokens.input += usage.inputTokens;
         session.meta.totalTokens.output += usage.outputTokens;
+        const cost = usage.estimatedCost ?? estimateCost(usage.inputTokens, usage.outputTokens, modelId);
+        if (cost !== undefined) {
+            session.meta.totalTokens.estimatedCost = (session.meta.totalTokens.estimatedCost ?? 0) + cost;
+        }
     }
     /**
      * Estimate token count based on text length

package/dist/core/skills/permissions.js

@@ -89,9 +89,9 @@ export class SkillPermissionManager {
                 this.policies = [];
             }
         }
-        catch {
+        catch (error) {
             const logger = tryGetLogger();
-            logger?.warn(text.skills.permissionFileLoadError(this.filePath));
+            logger?.warn(`${text.skills.permissionFileLoadError(this.filePath)}: ${error instanceof Error ? error.message : String(error)}`);
             this.policies = [];
         }
     }

package/dist/core/strata/checkpoint/manager.js

@@ -63,7 +63,8 @@ export class CheckpointManager {
                     try {
                         writeTreeProbe = await probeWriteTreeFailure(git);
                     }
-                    catch {
+                    catch (probeError) {
+                        getLogger().debug(`[CheckpointManager] probeWriteTreeFailure failed: ${probeError instanceof Error ? probeError.message : String(probeError)}`);
                         writeTreeProbe = {};
                     }
                 }
@@ -129,7 +130,8 @@ export class CheckpointManager {
         try {
             meta = JSON.parse(msg);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CheckpointManager] Invalid snapshot metadata for ${snapshotHash}: ${error instanceof Error ? error.message : String(error)}`);
             throw new Error(`Invalid snapshot metadata for ${snapshotHash}`);
         }
         if (!meta.staged) {
@@ -268,8 +270,8 @@ export class CheckpointManager {
             try {
                 await rm(tempIndexFile, { force: true });
             }
-            catch {
-                // Ignore cleanup errors
+            catch (error) {
+                getLogger().debug(`[CheckpointManager] Failed to cleanup temp index: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
     }
@@ -292,7 +294,8 @@ export class CheckpointManager {
         try {
             meta = JSON.parse(msg);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CheckpointManager] Invalid snapshot metadata for ${snapshotHash}: ${error instanceof Error ? error.message : String(error)}`);
             throw new Error(`Invalid snapshot metadata for ${snapshotHash}`);
         }
         // 3. Get Parent Commit (Original HEAD)
@@ -339,7 +342,8 @@ export class CheckpointManager {
                 return { hash, timestamp, message, ref };
             });
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CheckpointManager] Failed to list snapshots: ${error instanceof Error ? error.message : String(error)}`);
             return [];
         }
     }
@@ -354,8 +358,8 @@ export class CheckpointManager {
             await git.exec(['update-ref', '-d', `refs/s8p/snapshots/${snapshotHash}`]);
             return;
         }
-        catch {
-            // If direct deletion fails (maybe hash mismatch or short hash), try to find the ref
+        catch (error) {
+            getLogger().debug(`[CheckpointManager] Direct snapshot deletion failed, trying ref search: ${error instanceof Error ? error.message : String(error)}`);
         }
         // Fallback: find the ref pointing to this hash
         // Note: This is expensive if there are many snapshots, but safe.
@@ -392,7 +396,8 @@ export class CheckpointManager {
         try {
             meta = JSON.parse(msg);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CheckpointManager] Invalid snapshot metadata for ${snapshotHash}: ${error instanceof Error ? error.message : String(error)}`);
             throw new Error(`Invalid snapshot metadata for ${snapshotHash}`);
         }
         // Staged files: Diff between Parent (HEAD at time of snapshot) and Staged Tree
@@ -475,7 +480,8 @@ export class CheckpointManager {
         try {
             meta = JSON.parse(msg);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[CheckpointManager] Invalid backup metadata for ${backupHash}: ${error instanceof Error ? error.message : String(error)}`);
             throw new Error(`Invalid backup metadata for ${backupHash}`);
         }
         // 2. Restore Worktree and Index to the T1 state

package/dist/core/strata/checkpoint/snapshot-create.js

@@ -2,6 +2,7 @@ import { randomBytes } from 'crypto';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { rm } from '../../adapters/fs/node-fs.js';
+import { getLogger } from '../../observability/logger.js';
 import { normalizePath } from '../../utils/path.js';
 async function getSafeUntrackedFiles(git) {
     // --exclude-standard: Respect .gitignore
@@ -50,8 +51,8 @@ export async function createSnapshotCommitFromStagedTree(input) {
                         await git.exec(['add', '--', file], { env });
                     }
                 }
-                catch {
-                    // Ignore per-file add failures to keep snapshot best-effort.
+                catch (error) {
+                    getLogger().debug(`[SnapshotCreate] Failed to add file ${file} to snapshot index: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
         }
@@ -71,8 +72,8 @@ export async function createSnapshotCommitFromStagedTree(input) {
         try {
             await rm(tempIndexFile, { force: true });
         }
-        catch {
-            // Ignore cleanup errors.
+        catch (error) {
+            getLogger().debug(`[SnapshotCreate] Failed to clean up temp index file: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 }

package/dist/core/strata/checkpoint/snapshot-write-tree.js

@@ -1,5 +1,6 @@
 import { join } from 'path';
 import { stat } from '../../adapters/fs/node-fs.js';
+import { getLogger } from '../../observability/logger.js';
 import { classifyGitFailureHint } from './snapshot-audit.js';
 export async function tryWriteTreeWithRetry(git, retryDelaysMs) {
     let attempts = 0;
@@ -28,7 +29,8 @@ export async function probeWriteTreeFailure(git) {
         details.indexLockPresent = true;
         details.indexLockAgeMs = Math.max(0, Math.floor(Date.now() - lockStat.mtimeMs));
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[SnapshotWriteTree] Index lock not present or unreadable: ${error instanceof Error ? error.message : String(error)}`);
         details.indexLockPresent = false;
     }
     try {
@@ -39,7 +41,8 @@ export async function probeWriteTreeFailure(git) {
             .filter(Boolean).length;
         details.unmergedCount = count;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[SnapshotWriteTree] Failed to list unmerged files: ${error instanceof Error ? error.message : String(error)}`);
         details.unmergedCount = undefined;
     }
     try {
@@ -64,7 +67,8 @@ export async function probeWriteTreeFailure(git) {
             });
         }
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[SnapshotWriteTree] Failed to probe work tree status: ${error instanceof Error ? error.message : String(error)}`);
         details.isInsideWorkTree = undefined;
     }
     return details;

package/dist/core/strata/engine/shadow-merge-engine.js

@@ -269,7 +269,8 @@ export class ShadowMergeEngine {
                 return false;
             return this.guardian.inspect(buffer).isBinary;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ShadowMergeEngine] Binary detection failed for ${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }
@@ -282,7 +283,8 @@ export class ShadowMergeEngine {
         try {
             return await git.show(ref, relativePath);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ShadowMergeEngine] git show failed for ${relativePath}@${ref}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }