salmon-loop 0.4.1 → 0.5.0

package/dist/core/strata/interaction/file-system-provider.js

@@ -81,7 +81,8 @@ export class StrataFileSystemProvider {
             const buffer = await fs.readFile(safePath);
             return this.guardian.inspect(buffer).isBinary;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[StrataFileSystem] Binary detection failed for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }

package/dist/core/strata/layers/file-state-resolver.js

@@ -3,6 +3,7 @@ import * as path from 'path';
 import * as fs from '../../adapters/fs/node-fs.js';
 import { LIMITS } from '../../config/limits.js';
 import { FileStatus } from '../../grizzco/domain/grizzco-types.js';
+import { getLogger } from '../../observability/logger.js';
 /**
  * FileStateResolver
  * Responsibilities: Accurately scan workspace and index state, implementing the data foundation for Zero Index Access.
@@ -43,9 +44,8 @@ export class FileStateResolver {
                 state.stagedContent = await this.git.show(':0', normalizedPath);
                 state.workingContent = await fs.readFile(absolutePath);
             }
-            catch {
-                // Fallback: If we can't capture content, we might be in a race condition.
-                // But proceed with what we have; strategy layer will handle missing content if needed.
+            catch (error) {
+                getLogger().debug(`[FileStateResolver] Failed to capture MM content for ${normalizedPath}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         return state;
@@ -124,8 +124,8 @@ export class FileStateResolver {
                 await fd.close();
             }
         }
-        catch {
-            // If file doesn't exist or can't be read, assume non-binary (safe default for new files)
+        catch (error) {
+            getLogger().debug(`[FileStateResolver] Binary detection failed for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }
@@ -137,7 +137,8 @@ export class FileStateResolver {
             const stats = await fs.lstat(filePath);
             return stats.isSymbolicLink();
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[FileStateResolver] Symlink detection failed for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }
@@ -149,7 +150,8 @@ export class FileStateResolver {
             const stats = await fs.stat(filePath);
             return stats.size;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[FileStateResolver] File size check failed for ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
             return 0;
         }
     }

package/dist/core/strata/layers/immutable-git-layer.js

@@ -4,6 +4,7 @@
  * Wraps existing CheckpointManager to provide StrataSystem interface
  * for L1 Git snapshot and worktree operations.
  */
+import { getLogger } from '../../observability/logger.js';
 import { CheckpointManager } from '../checkpoint/manager.js';
 /**
  * ImmutableGitLayer Implementation
@@ -34,7 +35,8 @@ export class ImmutableGitLayerImpl {
             const content = await this.checkpointManager.getSnapshotFileContent(process.cwd(), 'HEAD', path);
             return Buffer.from(content);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ImmutableGitLayer] Failed to get file from snapshot: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }

package/dist/core/strata/layers/shadow-driver/readonly-lock.js

@@ -129,7 +129,8 @@ async function removeLockByToken(lockPath, expectedToken) {
     try {
         await rename(lockPath, swapPath);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ReadonlyLock] Failed to rename lock file for atomic swap: ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
     try {
@@ -141,18 +142,19 @@ async function removeLockByToken(lockPath, expectedToken) {
         try {
             await rename(swapPath, lockPath);
         }
-        catch {
-            // Best-effort rollback when concurrent updates happen.
+        catch (rollbackError) {
+            getLogger().debug(`[ReadonlyLock] Failed to rollback lock swap (token mismatch): ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
             await unlink(swapPath).catch(() => null);
         }
         return false;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ReadonlyLock] Failed to verify lock token after swap: ${error instanceof Error ? error.message : String(error)}`);
         try {
             await rename(swapPath, lockPath);
         }
-        catch {
-            // Best-effort rollback when concurrent updates happen.
+        catch (rollbackError) {
+            getLogger().debug(`[ReadonlyLock] Failed to rollback lock swap (verification error): ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
             await unlink(swapPath).catch(() => null);
         }
         return false;

package/dist/core/strata/layers/shadow-driver/shadow-driver.js

@@ -36,7 +36,8 @@ async function pointsToExpectedDependency(sourcePath, targetPath) {
         ]);
         return arePathsEquivalent(resolvedSourcePath, resolvedTargetPath);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[ShadowDriver] Failed to verify dependency path equivalence: ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
 }

package/dist/core/strata/layers/worktree.js

@@ -48,7 +48,8 @@ async function tryRealpath(value) {
     try {
         return await realpath(value);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[Worktree] Failed to resolve realpath for ${value}: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }

package/dist/core/strata/runtime/environment.js

@@ -20,7 +20,8 @@ async function pathExists(target) {
         await stat(target);
         return true;
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[RuntimeEnvironment] pathExists check failed for ${target}: ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }
 }

package/dist/core/strata/runtime/synchronizer.js

@@ -57,7 +57,8 @@ export class WorkspaceSynchronizer {
         try {
             return await realpath(value);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[Synchronizer] realpath failed for ${value}: ${error instanceof Error ? error.message : String(error)}`);
             return null;
         }
     }
@@ -88,7 +89,8 @@ export class WorkspaceSynchronizer {
         try {
             entries = (await readdir(tempRoot, { withFileTypes: true }));
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[Synchronizer] Failed to read tmpdir for backup pruning: ${error instanceof Error ? error.message : String(error)}`);
             return;
         }
         const cutoffTs = Date.now() - retentionMs;
@@ -101,8 +103,8 @@ export class WorkspaceSynchronizer {
                     await rm(backupPath, { recursive: true, force: true });
                 }
             }
-            catch {
-                // Ignore stale cleanup failures; cleanup is best-effort.
+            catch (error) {
+                getLogger().debug(`[Synchronizer] Failed to prune stale backup ${entry.name}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }));
     }
@@ -160,8 +162,8 @@ export class WorkspaceSynchronizer {
                     symlinkedRoots.add(normalizedCandidate);
                 }
             }
-            catch {
-                // Ignore non-existent dependency roots.
+            catch (error) {
+                getLogger().debug(`[Synchronizer] Dependency root probe failed for ${normalizedCandidate}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
         return symlinkedRoots;
@@ -365,10 +367,8 @@ export class WorkspaceSynchronizer {
                 try {
                     oursContent = await readFile(mainAbsPath);
                 }
-                catch {
-                    // If file missing in main but modify in shadow -> conflict or re-create?
-                    // Since we filtered for 'M', it implies it existed in Base. If missing in Main, User deleted it.
-                    // Merge Modified vs Deleted -> Conflict.
+                catch (error) {
+                    getLogger().debug(`[ExplicitMerge] Ours file missing in main workspace, treating as conflict: ${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
                     conflicts.push(relativePath);
                     continue;
                 }
@@ -546,7 +546,8 @@ export class WorkspaceSynchronizer {
                             const content = await readFile(path.join(mainRepoPath, ...file.split('/')));
                             entries.push(`${file}:${hashContent(content)}`);
                         }
-                        catch {
+                        catch (error) {
+                            getLogger().debug(`[Synchronizer] Fingerprint read failed for untracked file ${file}: ${error instanceof Error ? error.message : String(error)}`);
                             entries.push(`${file}:missing`);
                         }
                     }
@@ -595,8 +596,8 @@ export class WorkspaceSynchronizer {
                             try {
                                 await copyFile(src, dst);
                             }
-                            catch {
-                                // Ignore backup failure for deleted files
+                            catch (error) {
+                                getLogger().debug(`[Synchronizer] Failed to backup dirty file ${file}: ${error instanceof Error ? error.message : String(error)}`);
                             }
                         }
                     }
@@ -694,8 +695,8 @@ export class WorkspaceSynchronizer {
                             current.working !== originalFingerprint.working ||
                             current.untracked !== originalFingerprint.untracked;
                 }
-                catch {
-                    // If fingerprinting fails, assume changed to be safe.
+                catch (error) {
+                    getLogger().debug(`[Synchronizer] Workspace fingerprint comparison failed, assuming changed: ${error instanceof Error ? error.message : String(error)}`);
                     workspaceChanged = true;
                 }
             }
@@ -752,8 +753,8 @@ export class WorkspaceSynchronizer {
                             });
                             await copyFile(path.join(untrackedDir, ...file.split('/')), path.join(mainRepoPath, ...file.split('/')));
                         }
-                        catch {
-                            // Ignore restore errors for untracked files
+                        catch (error) {
+                            getLogger().debug(`[Synchronizer] Failed to restore untracked file ${file}: ${error instanceof Error ? error.message : String(error)}`);
                         }
                     }
                 }

package/dist/core/structured-output/json-extract.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 function findFirstJsonStart(text) {
     const obj = text.indexOf('{');
     const arr = text.indexOf('[');
@@ -63,7 +64,8 @@ export function extractFirstJsonValueFromText(text) {
     try {
         return JSON.parse(slice);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[StructuredOutput] Failed to parse extracted JSON: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }

package/dist/core/sub-agent/artifacts/store.js

@@ -125,8 +125,9 @@ export class ArtifactStore {
                 getLogger().debug(`[ArtifactStore] GC removed ${result.removedFiles} files (${result.removedBytes} bytes)`);
             }
         }
-        catch {
+        catch (error) {
             // Best-effort only; never fail the caller.
+            getLogger().debug(`[ArtifactStore] GC failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     static ensureGcLoop() {

package/dist/core/sub-agent/core/manager.js

@@ -15,6 +15,7 @@ import { cloneSubAgentContextSnapshot } from '../context-snapshot.js';
 import { isReadOnlySubAgentContext, resolveSubAgentDryRun } from '../dispatch-policy.js';
 import { validateSharedPrefixConsistency } from '../prefix-consistency.js';
 import { getSubAgentRegistry } from '../registry.js';
+import { generateSubAgentSummary, formatSubAgentSummary } from '../summary.js';
 import { SmallfryLoop } from './loop.js';
 /**
  * SubAgentManager coordinates the lifecycle of Smallfrys.
@@ -24,6 +25,7 @@ export class SubAgentManager {
     ctx;
     controller;
     activeAgents = new Map();
+    completedResults = [];
     deps;
     constructor(ctx, controller, deps) {
         this.ctx = ctx;
@@ -98,6 +100,24 @@ export class SubAgentManager {
             });
         });
     }
+    /**
+     * Get a summary of all completed sub-agent results.
+     * Includes conflict detection across patches.
+     */
+    getSummary() {
+        if (this.completedResults.length === 0)
+            return null;
+        return generateSubAgentSummary(this.completedResults);
+    }
+    /**
+     * Get a formatted summary string for LLM context injection.
+     */
+    getFormattedSummary() {
+        const summary = this.getSummary();
+        if (!summary)
+            return null;
+        return formatSubAgentSummary(summary);
+    }
     normalizeRequest(request) {
         // Fork mode: no prefix consistency validation needed (it's a clone, not a shared session)
         if (request.session_target === 'fork')
@@ -153,6 +173,8 @@ export class SubAgentManager {
                 taskId,
                 state: result.success ? 'completed' : 'failed',
             });
+            // Track for summary generation
+            this.completedResults.push({ agentId, result });
             // Notify completion listener (for background auto-notify)
             this.deps.onSubAgentComplete?.(agentId, result);
         })
@@ -540,7 +562,8 @@ export class SubAgentManager {
                 fileExt: 'json',
             });
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[SubAgentManager] Failed to persist audit artifact: ${error instanceof Error ? error.message : String(error)}`);
             return undefined;
         }
     }

package/dist/core/sub-agent/registry-defaults.js

@@ -12,7 +12,7 @@ const DEFAULT_SUB_AGENT_PROFILES = [
         maxAttempts: 3,
         timeoutMs: 60_000,
         maxTurns: 20,
-        model: 'haiku',
+        model: 'inherit',
     },
     {
         id: 'surgeon',
@@ -42,7 +42,7 @@ const DEFAULT_SUB_AGENT_PROFILES = [
         maxAttempts: 2,
         timeoutMs: 60_000,
         maxTurns: 15,
-        model: 'haiku',
+        model: 'inherit',
     },
     {
         id: 'cleaner',

package/dist/core/sub-agent/summary.js

@@ -0,0 +1,96 @@
+/**
+ * Sub-agent result synthesis.
+ *
+ * Detects file-level conflicts between sub-agent patches
+ * and generates structured summaries for parent injection.
+ */
+/**
+ * Extract file paths touched by a unified diff.
+ * Parses diff headers (lines starting with "--- a/" and "+++ b/").
+ */
+export function extractDiffFiles(patch) {
+    const files = new Set();
+    const lines = patch.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('+++ b/')) {
+            files.add(line.slice(6));
+        }
+    }
+    return Array.from(files);
+}
+/**
+ * Detect file-level conflicts across multiple sub-agent results.
+ * Two agents conflict if they both modify the same file.
+ */
+export function detectConflicts(results) {
+    const fileToAgents = new Map();
+    for (const { agentId, result } of results) {
+        if (!result.finalPatch || typeof result.finalPatch !== 'string')
+            continue;
+        const files = extractDiffFiles(result.finalPatch);
+        for (const file of files) {
+            const agents = fileToAgents.get(file) ?? [];
+            agents.push(agentId);
+            fileToAgents.set(file, agents);
+        }
+    }
+    const conflicts = [];
+    for (const [file, agents] of fileToAgents) {
+        if (agents.length > 1) {
+            conflicts.push({ file, agents });
+        }
+    }
+    return conflicts;
+}
+/**
+ * Generate a structured summary of all sub-agent results.
+ */
+export function generateSubAgentSummary(results) {
+    const conflicts = detectConflicts(results);
+    const changedFiles = new Set();
+    let succeeded = 0;
+    let failed = 0;
+    let totalTokens = 0;
+    for (const { result } of results) {
+        if (result.success)
+            succeeded++;
+        else
+            failed++;
+        totalTokens += result.tokenUsage ?? 0;
+        if (result.finalPatch && typeof result.finalPatch === 'string') {
+            for (const file of extractDiffFiles(result.finalPatch)) {
+                changedFiles.add(file);
+            }
+        }
+    }
+    return {
+        totalAgents: results.length,
+        succeeded,
+        failed,
+        conflicts,
+        totalTokens,
+        changedFiles: Array.from(changedFiles),
+    };
+}
+/**
+ * Format a sub-agent summary as a human-readable string for LLM context injection.
+ */
+export function formatSubAgentSummary(summary) {
+    const lines = [
+        `## Sub-Agent Summary`,
+        `- Total: ${summary.totalAgents} | Succeeded: ${summary.succeeded} | Failed: ${summary.failed}`,
+        `- Total tokens: ${summary.totalTokens.toLocaleString()}`,
+        `- Changed files: ${summary.changedFiles.length}`,
+    ];
+    if (summary.changedFiles.length > 0) {
+        lines.push(`- Files: ${summary.changedFiles.join(', ')}`);
+    }
+    if (summary.conflicts.length > 0) {
+        lines.push(`\n### Conflicts Detected`);
+        for (const conflict of summary.conflicts) {
+            lines.push(`- \`${conflict.file}\`: modified by ${conflict.agents.join(', ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=summary.js.map

package/dist/core/sub-agent/tools/task-spawn.js

@@ -123,10 +123,13 @@ export const subAgentTaskSpec = {
     ],
     executor: async (input, ctx) => {
         const parsed = SubAgentRequestSchema.parse(input);
-        const manager = new SubAgentManager(ctx, ctx.subAgentController ?? createSubAgentController(), {
-            llmFactory: ctx.llmFactory,
-            onSubAgentComplete: ctx.onSubAgentComplete,
-        });
+        const controller = ctx.subAgentController ?? createSubAgentController();
+        const manager = ctx.subAgentManagerFactory
+            ? ctx.subAgentManagerFactory(ctx, controller)
+            : new SubAgentManager(ctx, controller, {
+                llmFactory: ctx.llmFactory,
+                onSubAgentComplete: ctx.onSubAgentComplete,
+            });
         const request = normalizeDispatchRequest(parsed, ctx);
         try {
             return await manager.execute(request);

package/dist/core/target-runtime/profile.js

@@ -1,5 +1,6 @@
 import { existsSync } from '../adapters/fs/node-fs.js';
 import { readFile } from '../adapters/fs/node-fs.js';
+import { getLogger } from '../observability/logger.js';
 import { ensureInSandbox, safeJoin } from '../utils/path.js';
 const LOCKFILE_HINTS = [
     { file: 'bun.lock', manager: 'bun' },
@@ -59,7 +60,8 @@ export async function detectNodeRuntimeProfile(repoPath) {
     try {
         parsed = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[TargetRuntime] Failed to parse package.json: ${error instanceof Error ? error.message : String(error)}`);
         return undefined;
     }
     const { packageManager, source } = detectPackageManager(repoPath, parsed);

package/dist/core/tools/audit.js

@@ -1,5 +1,5 @@
 import { text } from '../../locales/index.js';
-import { tryGetLogger } from '../observability/logger.js';
+import { getLogger, tryGetLogger } from '../observability/logger.js';
 import { Phase } from '../types/runtime.js';
 import { sanitizeErrorMessage } from '../utils/sanitizer.js';
 export class ToolAuditLogger {
@@ -112,7 +112,8 @@ export class ToolAuditLogger {
             const str = JSON.stringify(data);
             return str.length > 200 ? str.substring(0, 200) + '...' : str;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[ToolAudit] Failed to summarize data: ${error instanceof Error ? error.message : String(error)}`);
             return '[Circular/Unserializable]';
         }
     }

package/dist/core/tools/budget.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 /**
  * Default budget limits to ensure system stability.
  */
@@ -103,7 +104,8 @@ export class BudgetGuard {
             // This is expensive for large objects, but safe for checking limits
             return JSON.stringify(obj).length;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[Budget] Failed to estimate size: ${error instanceof Error ? error.message : String(error)}`);
             return 0; // Circular structure or otherwise un-stringifiable
         }
     }