salmon-loop 0.3.2 → 0.5.0

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

@@ -8,6 +8,7 @@ import { GitAdapter } from '../../adapters/git/git-adapter.js';
 import { logIgnoredError } from '../../observability/ignored-error.js';
 import { getLogger } from '../../observability/logger.js';
 import { getMonitor } from '../../observability/monitor.js';
+import { errorMessage } from '../../utils/error.js';
 import { isCanonicalPathWithinDirectory } from '../../utils/path.js';
 import { detectDependencyPaths } from '../layers/shadow-driver/strategy.js';
 const SECURITY_BLOCKLIST = [
@@ -56,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;
         }
     }
@@ -87,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;
@@ -100,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)}`);
             }
         }));
     }
@@ -135,7 +138,7 @@ export class WorkspaceSynchronizer {
             detectedDependencyPaths = await detectDependencyPaths(repoPath);
         }
         catch (error) {
-            getLogger().debug(`[checkpoint] Failed to detect dependency paths: ${error instanceof Error ? error.message : String(error)}`);
+            getLogger().debug(`[checkpoint] Failed to detect dependency paths: ${errorMessage(error)}`);
         }
         const candidates = new Set([
             ...DEFAULT_DEPENDENCY_ROOT_CANDIDATES,
@@ -159,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;
@@ -364,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;
                 }
@@ -445,7 +446,7 @@ export class WorkspaceSynchronizer {
             });
         }
         catch (error) {
-            throw new Error(`Apply-back completed with conflicts (Atomic Patch). Rejection files (.rej) have been generated. Original error: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Apply-back completed with conflicts (Atomic Patch). Rejection files (.rej) have been generated. Original error: ${errorMessage(error)}`);
         }
     }
     parseStatusEntries(statusPorcelainZ) {
@@ -545,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`);
                         }
                     }
@@ -594,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)}`);
                             }
                         }
                     }
@@ -624,7 +626,7 @@ export class WorkspaceSynchronizer {
                         stagedPatchPath,
                     };
                 };
-                dirtyBackup = (await createDirtyBackup());
+                dirtyBackup = await createDirtyBackup();
                 getLogger().info(text.loop.applyBackCheckpointCreated());
                 getLogger().info(text.loop.applyBackCheckpointLocation(dirtyBackup?.dir || ''));
                 if (telemetry) {
@@ -673,7 +675,7 @@ export class WorkspaceSynchronizer {
             }
         }
         catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
+            const err = error instanceof Error ? error : new Error(errorMessage(error));
             if (telemetry) {
                 telemetry.error = err.message;
             }
@@ -693,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;
                 }
             }
@@ -737,7 +739,7 @@ export class WorkspaceSynchronizer {
                             await copyFile(path.join(trackedDir, ...file.split('/')), path.join(mainRepoPath, ...file.split('/')));
                         }
                         catch (e) {
-                            getLogger().error(`[applyBack] Failed to restore tracked file ${file}: ${e instanceof Error ? e.message : String(e)}`);
+                            getLogger().error(`[applyBack] Failed to restore tracked file ${file}: ${errorMessage(e)}`);
                         }
                     }
                 }
@@ -751,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)}`);
                         }
                     }
                 }
@@ -769,7 +771,7 @@ export class WorkspaceSynchronizer {
                         }
                     }
                     catch (e) {
-                        const patchError = e instanceof Error ? e.message : String(e);
+                        const patchError = errorMessage(e);
                         getLogger().error(`[applyBack] Failed to restore staged state from patch. ${patchError}. ` +
                             `Falling back to read-tree restore.`);
                         try {
@@ -780,7 +782,7 @@ export class WorkspaceSynchronizer {
                             }
                         }
                         catch (fallbackError) {
-                            const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+                            const fallbackMessage = errorMessage(fallbackError);
                             if (telemetry) {
                                 telemetry.stagedRestoreSucceeded = false;
                                 telemetry.stagedRestoreError = `${patchError}; fallback read-tree failed: ${fallbackMessage}`;
@@ -808,7 +810,7 @@ export class WorkspaceSynchronizer {
                 catch (snapshotRestoreError) {
                     getLogger().error(`[applyBack] Snapshot restore failed during clean rollback. ` +
                         `baseRef=${checkpointRef.baseRef}; ` +
-                        `error=${snapshotRestoreError instanceof Error ? snapshotRestoreError.message : String(snapshotRestoreError)}. ` +
+                        `error=${errorMessage(snapshotRestoreError)}. ` +
                         `Falling back to clean reset.`);
                 }
                 if (!restoredFromSnapshot) {
@@ -830,7 +832,7 @@ export class WorkspaceSynchronizer {
                     await rm(dirtyBackup.dir, { recursive: true, force: true });
                 }
                 catch (cleanupError) {
-                    getLogger().debug(`[applyBack] Failed to cleanup dirty backup ${dirtyBackup.dir}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+                    getLogger().debug(`[applyBack] Failed to cleanup dirty backup ${dirtyBackup.dir}: ${errorMessage(cleanupError)}`);
                 }
             }
             if (telemetry) {

package/dist/core/streaming/canonical/parts-from-llm-stream-chunk.js

@@ -1,14 +1,4 @@
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function getString(record, key) {
-    const value = record[key];
-    return typeof value === 'string' ? value : null;
-}
-function getRecord(record, key) {
-    const value = record[key];
-    return isRecord(value) ? value : null;
-}
+import { isRecord, getString, getRecord } from '../../utils/serialize.js';
 /**
  * Best-effort conversion from our provider-agnostic `LLMStreamChunk` into
  * provider-agnostic canonical stream parts.

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/structured-output/json-schema-validator.js

@@ -1,17 +1,5 @@
 import { Ajv } from 'ajv';
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        try {
-            return String(value);
-        }
-        catch {
-            return '[Unserializable]';
-        }
-    }
-}
+import { safeStringify } from '../utils/serialize.js';
 function toSchemaKey(schema) {
     if (!schema || typeof schema !== 'object')
         return `non_object:${typeof schema}`;

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/context-snapshot.js

@@ -1,5 +1,9 @@
 import { normalizeToolResultReplacementState, } from '../session/replacement-state.js';
 import { SUB_AGENT_CONTEXT_SNAPSHOT_VERSION, SUB_AGENT_CONTEXT_SNAPSHOT_FIELD_SEMANTICS, } from './types.js';
+const SUPPORTED_SNAPSHOT_FIELDS = new Set([
+    'version',
+    ...Object.keys(SUB_AGENT_CONTEXT_SNAPSHOT_FIELD_SEMANTICS),
+]);
 function deepClone(value) {
     if (typeof structuredClone === 'function') {
         return structuredClone(value);
@@ -39,7 +43,13 @@ function cloneConversationContext(messages) {
 function cloneToolCallingAudit(entries) {
     if (!Array.isArray(entries) || entries.length === 0)
         return undefined;
-    return entries.map((entry) => deepClone(entry));
+    return entries.map((entry) => ({
+        ...entry,
+        toolResultPatchArtifact: cloneArtifactHandle(entry.toolResultPatchArtifact),
+        toolResultAuditArtifact: cloneArtifactHandle(entry.toolResultAuditArtifact),
+        toolResultReadArtifact: cloneArtifactHandle(entry.toolResultReadArtifact),
+        toolResultPreviewArtifact: cloneArtifactHandle(entry.toolResultPreviewArtifact),
+    }));
 }
 function cloneArtifactHints(hints) {
     if (!hints)
@@ -106,11 +116,7 @@ function normalizeSnapshotVersion(snapshot) {
     return version;
 }
 function assertSupportedSnapshotFields(snapshot) {
-    const supportedFields = new Set([
-        'version',
-        ...Object.keys(SUB_AGENT_CONTEXT_SNAPSHOT_FIELD_SEMANTICS),
-    ]);
-    const unknownFields = Object.keys(snapshot).filter((key) => !supportedFields.has(key));
+    const unknownFields = Object.keys(snapshot).filter((key) => !SUPPORTED_SNAPSHOT_FIELDS.has(key));
     if (unknownFields.length > 0) {
         throw new Error(`Unsupported sub-agent context snapshot fields: ${unknownFields.sort().join(', ')}`);
     }

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

@@ -1,6 +1,9 @@
-const LOG_HISTORY_LIMIT = 50;
+const LOG_HISTORY_LIMIT = 200;
 export class InMemorySubAgentController {
     agents = new Map();
+    toolCallListeners = new Set();
+    results = new Map();
+    waiters = new Map();
     registerAgent(id, profile, status) {
         const existing = this.agents.get(id);
         if (existing) {
@@ -16,6 +19,8 @@ export class InMemorySubAgentController {
             updatedAt: new Date(),
             stopRequested: false,
             logs: [],
+            tokenUsage: 0,
+            toolCallCount: 0,
         });
     }
     updateStatus(id, status, summary) {
@@ -37,6 +42,35 @@ export class InMemorySubAgentController {
             agent.logs.splice(0, agent.logs.length - LOG_HISTORY_LIMIT);
         }
     }
+    addTokenUsage(id, tokens) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return;
+        agent.tokenUsage += tokens;
+    }
+    recordToolCall(id, toolName, durationMs, success) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            return;
+        agent.toolCallCount++;
+        const event = {
+            type: 'tool.call.end',
+            agentId: id,
+            toolName,
+            timestamp: Date.now(),
+            durationMs,
+            success,
+        };
+        for (const listener of this.toolCallListeners) {
+            listener(event);
+        }
+    }
+    onToolCall(listener) {
+        this.toolCallListeners.add(listener);
+        return () => {
+            this.toolCallListeners.delete(listener);
+        };
+    }
     listAgents() {
         return Array.from(this.agents.values());
     }
@@ -62,6 +96,41 @@ export class InMemorySubAgentController {
     isStopRequested(id) {
         return this.agents.get(id)?.stopRequested ?? false;
     }
+    setResult(id, result) {
+        this.results.set(id, result);
+        const waiters = this.waiters.get(id);
+        if (waiters) {
+            for (const resolve of waiters) {
+                resolve(result);
+            }
+            this.waiters.delete(id);
+        }
+    }
+    async awaitResult(id, timeoutMs = 300_000) {
+        // Check if result is already available
+        const existing = this.results.get(id);
+        if (existing)
+            return existing;
+        // Wait for the result with timeout
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                // Remove this waiter on timeout
+                const waiters = this.waiters.get(id);
+                if (waiters) {
+                    const idx = waiters.indexOf(resolve);
+                    if (idx >= 0)
+                        waiters.splice(idx, 1);
+                }
+                resolve(undefined);
+            }, timeoutMs);
+            const waiters = this.waiters.get(id) ?? [];
+            waiters.push((result) => {
+                clearTimeout(timer);
+                resolve(result);
+            });
+            this.waiters.set(id, waiters);
+        });
+    }
 }
 export function createSubAgentController() {
     return new InMemorySubAgentController();

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

@@ -27,12 +27,34 @@ export class SmallfryLoop {
     async execute(initCtx) {
         getLogger().debug(`[SmallfryLoop] ${text.smallfry.status.working} (${this.profile.name})`);
         let pipeline = Pipeline.of(initCtx);
+        let turnCount = 0;
+        const maxTurns = this.profile.maxTurns;
         // Dynamic Phase Injection based on Stratagem
+        // PREFLIGHT is deterministic (no LLM call), so it doesn't count as a turn
         pipeline = pipeline.step('PREFLIGHT', runPreflight);
-        pipeline = pipeline.step('CONTEXT', buildContext);
-        pipeline = pipeline.step('PLAN', generatePlan);
+        // Each subsequent step makes at least one LLM call
+        if (maxTurns !== undefined && turnCount >= maxTurns) {
+            getLogger().warn(`[SmallfryLoop] maxTurns (${maxTurns}) reached before CONTEXT — stopping early`);
+        }
+        else {
+            pipeline = pipeline.step('CONTEXT', buildContext);
+            turnCount++;
+        }
+        if (maxTurns !== undefined && turnCount >= maxTurns) {
+            getLogger().warn(`[SmallfryLoop] maxTurns (${maxTurns}) reached before PLAN — stopping early`);
+        }
+        else {
+            pipeline = pipeline.step('PLAN', generatePlan);
+            turnCount++;
+        }
         if (this.profile.stratagem === 'surgeon') {
-            pipeline = pipeline.step('PATCH', generatePatch);
+            if (maxTurns !== undefined && turnCount >= maxTurns) {
+                getLogger().warn(`[SmallfryLoop] maxTurns (${maxTurns}) reached before PATCH — stopping early`);
+            }
+            else {
+                pipeline = pipeline.step('PATCH', generatePatch);
+                turnCount++;
+            }
         }
         const report = await pipeline.execute();
         report.auditPath = await saveAudit(report, initCtx.options);