salmon-loop 0.3.2 → 0.4.1

package/dist/core/session/manager.js

@@ -268,34 +268,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 +321,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 +344,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

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

@@ -1,6 +1,7 @@
 import path from 'path';
 import { FileAdapter } from '../adapters/fs/index.js';
 import { logIgnoredError } from '../observability/ignored-error.js';
+import { isRecord } from '../utils/serialize.js';
 /**
  * Token usage tracker for chat sessions.
  * Extracts and accumulates token statistics from LLM execution results.
@@ -21,26 +22,36 @@ export class TokenTracker {
         try {
             const auditRaw = await this.fileAdapter.readFile(result.auditPath, 'utf8');
             const audit = JSON.parse(auditRaw);
-            const eventsRef = audit?.context?.eventsRef;
+            if (!isRecord(audit))
+                return null;
+            const context = isRecord(audit.context) ? audit.context : null;
+            const eventsRef = isRecord(context?.eventsRef) ? context.eventsRef : null;
             if (!eventsRef || typeof eventsRef.path !== 'string')
                 return null;
             const eventsPath = path.isAbsolute(eventsRef.path)
                 ? eventsRef.path
                 : path.join(path.dirname(result.auditPath), eventsRef.path);
             const eventsRaw = await this.fileAdapter.readFile(eventsPath, 'utf8');
-            const events = eventsRaw
-                .split('\n')
-                .filter((line) => line.trim().length > 0)
-                .map((line) => JSON.parse(line));
+            const events = [];
+            for (const line of eventsRaw.split('\n')) {
+                if (line.trim().length === 0)
+                    continue;
+                try {
+                    events.push(JSON.parse(line));
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
             let inputTokens = 0;
             let outputTokens = 0;
             for (const event of events) {
-                if (!event || typeof event !== 'object')
+                if (!isRecord(event))
                     continue;
                 if (event.action !== 'llm.usage')
                     continue;
                 const details = event.details;
-                if (!details || typeof details !== 'object')
+                if (!isRecord(details))
                     continue;
                 const promptTokens = details.promptTokens;
                 const completionTokens = details.completionTokens;

package/dist/core/skills/parser.js

@@ -3,6 +3,7 @@ import { parse as parseYaml } from 'yaml';
 import { z } from 'zod';
 import { text } from '../../locales/index.js';
 import { tryGetLogger } from '../observability/logger.js';
+import { errorMessage } from '../utils/error.js';
 /**
  * Safe logger accessor that never throws when the logger is not yet initialized.
  *
@@ -129,7 +130,7 @@ export class SkillParser {
             parsed = parseYaml(yamlRaw);
         }
         catch (error) {
-            const reason = error instanceof Error ? error.message : String(error);
+            const reason = errorMessage(error);
             const msg = text.skills.yamlParseError(filePath, reason);
             safeLogger().error(msg);
             throw new Error(msg);
@@ -188,7 +189,7 @@ export class SkillParser {
             parsed = parseYaml(yamlRaw);
         }
         catch (error) {
-            const reason = error instanceof Error ? error.message : String(error);
+            const reason = errorMessage(error);
             const msg = text.skills.yamlParseError(filePath, reason);
             safeLogger().error(msg);
             throw new Error(msg);

package/dist/core/skills/runtime/MicroTaskRunner.js

@@ -67,7 +67,7 @@ export class MicroTaskRunner {
                     cmd,
                     output: output,
                 })),
-                injectedPrompt: injectAction?.params?.prompt || '',
+                injectedPrompt: String(injectAction?.params?.prompt ?? ''),
                 status: plan.shouldAbort ? 'FAILURE' : 'SUCCESS',
             };
         }

package/dist/core/skills/runtime/SkillRunner.js

@@ -2,6 +2,7 @@ import * as crypto from 'crypto';
 import { MicroTaskRunner } from '../../grizzco/dsl/MicroTaskRunner.js';
 import { tryGetLogger } from '../../observability/logger.js';
 import { Phase } from '../../types/index.js';
+import { isRecord } from '../../utils/serialize.js';
 import { emitSkillAuditEvent, generateSkillTraceId, hashSkillArgs } from '../audit.js';
 import { SkillParser } from '../parser.js';
 import { SkillStrategyDSL } from '../strategy.js';
@@ -227,7 +228,9 @@ export async function executeSkill(options) {
                             argsHash,
                             traceId,
                             denyReason: result.error?.code || 'unknown',
-                            denySource: result.meta?.authorization?.source || 'policy',
+                            denySource: isRecord(result.meta) && isRecord(result.meta.authorization)
+                                ? result.meta.authorization.source
+                                : 'policy',
                             durationMs: Date.now() - startedAt,
                         });
                     }
@@ -264,7 +267,7 @@ export async function executeSkill(options) {
                 cmd,
                 output: String(output),
             })),
-            injectedPrompt: String(inject?.params?.prompt ?? ''),
+            injectedPrompt: String((isRecord(inject?.params) ? inject.params.prompt : undefined) ?? ''),
             status,
         };
     }

package/dist/core/slash/steps/slash-execute.js

@@ -2,12 +2,13 @@ function planToDecision(plan, options) {
     const action = plan.actions[0];
     if (!action)
         return { kind: 'consumed' };
+    const p = action.params ?? {};
     if (action.type === 'FORWARD_TEXT') {
-        const next = String(action.params?.input ?? '');
+        const next = String(p.input ?? '');
         return { kind: 'forward', input: next };
     }
     if (action.type === 'UNKNOWN_SLASH') {
-        const cmd = String(action.params?.commandName ?? '');
+        const cmd = String(p.commandName ?? '');
         if (options.unknownSlashPolicy === 'forward_as_text') {
             return { kind: 'forward', input: cmd };
         }
@@ -31,7 +32,8 @@ export function buildSlashExecuteStep(options, meta) {
             const decision = planToDecision(plan, { unknownSlashPolicy: options.unknownSlashPolicy });
             return { ...context, data: { ...data, __decision: decision } };
         }
-        const commandName = String(action.params?.commandName ?? '');
+        const p = action.params ?? {};
+        const commandName = String(p.commandName ?? '');
         const spec = options.registry.find(commandName);
         if (!spec) {
             const decision = planToDecision({ ...plan, actions: [{ type: 'UNKNOWN_SLASH', params: { commandName } }] }, { unknownSlashPolicy: options.unknownSlashPolicy });
@@ -50,8 +52,8 @@ export function buildSlashExecuteStep(options, meta) {
         const req = {
             rawInput: context.input.raw,
             command: spec,
-            argsText: String(action.params?.argsText ?? ''),
-            tokens: Array.isArray(action.params?.tokens) ? action.params.tokens : [],
+            argsText: String(p.argsText ?? ''),
+            tokens: Array.isArray(p.tokens) ? p.tokens : [],
             meta,
         };
         const result = await handler.execute(req);

package/dist/core/slash/strategy.js

@@ -18,7 +18,7 @@ export const SlashStrategyDSL = (engine) => {
         .when((c) => c.input.isSlash && Boolean(c.resolved?.command), (p) => {
         p.setWorker('slash.execute');
         p.addAction('EXECUTE_SLASH', {
-            commandName: engine.ctx.resolved.command.name,
+            commandName: engine.ctx.resolved?.command?.name ?? '',
             argsText: engine.ctx.input.argsText ?? '',
             tokens: engine.ctx.input.tokens ?? [],
         });

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

@@ -5,7 +5,9 @@ import { text } from '../../../locales/index.js';
 import { access, readdir, realpath, rm } from '../../adapters/fs/node-fs.js';
 import { GitAdapter } from '../../adapters/git/git-adapter.js';
 import { getLogger } from '../../observability/logger.js';
+import { errorMessage } from '../../utils/error.js';
 import { isPathWithinDirectory, normalizePath } from '../../utils/path.js';
+import { isRecord } from '../../utils/serialize.js';
 import { detectDependencyPaths } from './shadow-driver/strategy.js';
 function resolveEnvironmentMode(options) {
     return options.environmentMode === 'parity' ? 'parity' : 'strict';
@@ -73,14 +75,14 @@ async function removeProjectedWorktreeEntries(workPath) {
         worktreeRealPath = await realpath(workPath);
     }
     catch (error) {
-        throw new Error(`Failed to resolve worktree path before git cleanup (${workPath}): ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to resolve worktree path before git cleanup (${workPath}): ${errorMessage(error)}`);
     }
     let entries = [];
     try {
         entries = (await readdir(workPath, { withFileTypes: true }));
     }
     catch (error) {
-        throw new Error(`Failed to enumerate worktree entries before git cleanup (${workPath}): ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to enumerate worktree entries before git cleanup (${workPath}): ${errorMessage(error)}`);
     }
     for (const entry of entries) {
         const name = entry?.name;
@@ -116,7 +118,7 @@ async function pruneWorktreeDependencyRoots(baseRepoPath, worktreePath) {
             getLogger().debug(`Pruned disposable dependency root before worktree cleanup: ${dependencyRoot}`);
         }
         catch (error) {
-            getLogger().debug(`Failed to prune dependency root before worktree cleanup (${dependencyRoot}): ${error instanceof Error ? error.message : String(error)}`);
+            getLogger().debug(`Failed to prune dependency root before worktree cleanup (${dependencyRoot}): ${errorMessage(error)}`);
         }
     }
 }
@@ -243,7 +245,7 @@ export class WorkspaceManager {
                         return true;
                     }
                     catch (error) {
-                        if (error && typeof error === 'object' && error.code === 'ENOENT') {
+                        if (isRecord(error) && error.code === 'ENOENT') {
                             return false;
                         }
                         return true;
@@ -268,11 +270,7 @@ export class WorkspaceManager {
             }
         }
         catch (error) {
-            const msg = error instanceof Error
-                ? error instanceof Error
-                    ? error.message
-                    : String(error)
-                : String(error);
+            const msg = errorMessage(error);
             onEvent?.({
                 type: 'action.fallback',
                 tool: 'git',

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 = [
@@ -135,7 +136,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,
@@ -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) {
@@ -624,7 +625,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 +674,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;
             }
@@ -737,7 +738,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)}`);
                         }
                     }
                 }
@@ -769,7 +770,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 +781,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 +809,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 +831,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-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/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);