salmon-loop 0.3.0 → 0.3.1

package/dist/cli/authorization/non-interactive.js

@@ -1,6 +1,6 @@
 import { execa } from 'execa';
 import { z } from 'zod';
-import { getLogger, McpClient } from '../../core/facades/cli-authorization-non-interactive.js';
+import { getLogger, McpConnectionManager, } from '../../core/facades/cli-authorization-non-interactive.js';
 import { text } from '../locales/index.js';
 const DecisionSchema = z
     .object({
@@ -21,22 +21,6 @@ function findMcpServer(extensions, name) {
         return undefined;
     return extensions.mcpServers.find((s) => s.enabled && s.name === name);
 }
-function toMcpClientConfig(server) {
-    if (server.transport === 'http') {
-        return {
-            name: server.name,
-            url: server.url,
-            headers: server.headers,
-        };
-    }
-    return {
-        name: server.name,
-        command: server.command,
-        args: server.args,
-        env: server.env,
-        cwd: server.cwd,
-    };
-}
 function extractDecisionPayloadFromMcpResult(result) {
     if (!result || typeof result !== 'object')
         return result;
@@ -130,11 +114,13 @@ export async function requestNonInteractiveAuthorizationDecision(params) {
         const timeoutMs = params.config.nonInteractive?.mcp?.timeoutMs ?? 10_000;
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        const client = new McpClient(toMcpClientConfig(server));
+        const manager = params.mcpConnectionManagerFactory?.(server) ?? new McpConnectionManager([server]);
         try {
-            await client.start();
+            await manager.startAll();
             const result = await Promise.race([
-                client.callTool(toolName, { request: params.request }),
+                manager.callTool(server.name, toolName, { request: params.request }, {
+                    signal: controller.signal,
+                }),
                 new Promise((_, reject) => {
                     controller.signal.addEventListener('abort', () => reject(new Error('timeout')), {
                         once: true,
@@ -156,7 +142,7 @@ export async function requestNonInteractiveAuthorizationDecision(params) {
         }
         finally {
             clearTimeout(timeout);
-            await client.stop();
+            await manager.stopAll();
         }
     }
     const unknown = String(params.config.nonInteractive?.strategy ?? '');

package/dist/cli/commands/chat.js

@@ -46,7 +46,7 @@ export async function handleChatCommand(options, command) {
     const modeOptionSource = getOptionValueSourceWithGlobalFallback(command, 'mode');
     const checkpointStrategyOptionSource = getOptionValueSourceWithGlobalFallback(command, 'checkpointStrategy');
     const rawPermissionMode = (modeOptionSource === 'cli' ? allOptions.mode : undefined) ??
-        resolvedConfig.permissionMode ??
+        normalizePermissionMode(resolvedConfig.raw?.mode) ??
         defaultFlowProfile.defaultPermissionMode ??
         'interactive';
     const permissionMode = normalizePermissionMode(rawPermissionMode);

package/dist/cli/commands/parallel.js

@@ -196,50 +196,55 @@ export const parallelCommand = {
                     authorizationMode: 'deferred',
                     extensions: extensionResolution.resolved,
                 });
-                const scheduler = new ParallelScheduler(toolstack.router, new InMemoryLockManager());
-                const phase = state.runtime?.phase || 'PATCH';
-                const runtime = {
-                    repoRoot: workspace.workPath,
-                    worktreeRoot: workspace.workPath,
-                    persistenceRoot: workspace.baseRepoPath,
-                    attemptId: 0,
-                    dryRun: false,
-                    model: state.runtime?.model,
-                    phase,
-                };
-                const runSignal = new AbortController().signal;
-                let result = await scheduler.run(state.plan, runtime, runSignal, {
-                    initialResults: state.result.nodeResults,
-                    resumeBlockedApprovals: true,
-                });
-                const canWaitForAuth = typeof toolstack.router.waitForAuthorization === 'function';
-                let resumeAttempts = 0;
-                while (result.blockedApprovals.length > 0 && canWaitForAuth && !runSignal.aborted) {
-                    resumeAttempts++;
-                    if (resumeAttempts > 10)
-                        break;
-                    await Promise.all(result.blockedApprovals.map(async (a) => {
-                        await toolstack.router.waitForAuthorization(a.nodeId, runSignal);
-                    }));
-                    result = await scheduler.run(state.plan, runtime, runSignal, {
-                        initialResults: result.nodeResults,
+                try {
+                    const scheduler = new ParallelScheduler(toolstack.router, new InMemoryLockManager());
+                    const phase = state.runtime?.phase || 'PATCH';
+                    const runtime = {
+                        repoRoot: workspace.workPath,
+                        worktreeRoot: workspace.workPath,
+                        persistenceRoot: workspace.baseRepoPath,
+                        attemptId: 0,
+                        dryRun: false,
+                        model: state.runtime?.model,
+                        phase,
+                    };
+                    const runSignal = new AbortController().signal;
+                    let result = await scheduler.run(state.plan, runtime, runSignal, {
+                        initialResults: state.result.nodeResults,
                         resumeBlockedApprovals: true,
                     });
+                    const canWaitForAuth = typeof toolstack.router.waitForAuthorization === 'function';
+                    let resumeAttempts = 0;
+                    while (result.blockedApprovals.length > 0 && canWaitForAuth && !runSignal.aborted) {
+                        resumeAttempts++;
+                        if (resumeAttempts > 10)
+                            break;
+                        await Promise.all(result.blockedApprovals.map(async (a) => {
+                            await toolstack.router.waitForAuthorization(a.nodeId, runSignal);
+                        }));
+                        result = await scheduler.run(state.plan, runtime, runSignal, {
+                            initialResults: result.nodeResults,
+                            resumeBlockedApprovals: true,
+                        });
+                    }
+                    await PlanPersistence.save(workspace.baseRepoPath, state.plan, result, {
+                        repoRoot: workspace.workPath,
+                        worktreeRoot: workspace.workPath,
+                        persistenceRoot: workspace.baseRepoPath,
+                        phase,
+                        model: state.runtime?.model,
+                    });
+                    emit({
+                        type: 'log',
+                        level: result.failed ? 'warn' : 'info',
+                        message: text.cli.parallelResumed(planId, result.blockedApprovals.length, result.failed),
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                finally {
+                    await toolstack.dispose?.();
                 }
-                await PlanPersistence.save(workspace.baseRepoPath, state.plan, result, {
-                    repoRoot: workspace.workPath,
-                    worktreeRoot: workspace.workPath,
-                    persistenceRoot: workspace.baseRepoPath,
-                    phase,
-                    model: state.runtime?.model,
-                });
-                emit({
-                    type: 'log',
-                    level: result.failed ? 'warn' : 'info',
-                    message: text.cli.parallelResumed(planId, result.blockedApprovals.length, result.failed),
-                    timestamp: new Date(),
-                });
-                return;
             }
             finally {
                 await WorkspaceManager.teardown(workspace, emit);

package/dist/cli/commands/run/assistant-message.js

@@ -2,6 +2,9 @@ import { text } from '../../locales/index.js';
 export function buildRunAssistantMessage(params) {
     if (!params.result.success)
         return text.cli.chatFailed(params.result.reason);
+    const answerMessage = params.mode === 'answer' ? params.result.assistantMessage?.trim() : '';
+    if (answerMessage)
+        return answerMessage;
     if (params.mode === 'review')
         return text.cli.chatReviewCompleted;
     if (params.mode === 'research')

package/dist/cli/commands/run/handler.js

@@ -244,8 +244,9 @@ export async function handleRunCommand(options, command) {
     }
     const profile = resolveExecutionProfile(mode);
     const permissionModeOptionSource = getOptionValueSourceWithGlobalFallback(command, 'mode');
+    const configuredPermissionMode = normalizePermissionMode(resolvedConfig.raw?.mode);
     const rawPermissionMode = (permissionModeOptionSource === 'cli' ? allOptions.mode : undefined) ??
-        resolvedConfig.permissionMode ??
+        configuredPermissionMode ??
         profile.defaultPermissionMode ??
         'interactive';
     const permissionMode = normalizePermissionMode(rawPermissionMode);

package/dist/cli/commands/serve.js

@@ -1,7 +1,7 @@
 import { normalizePermissionMode } from '../../core/config/index.js';
 import { buildA2AAgentCard, createAcpFormalAgent, createAgentServerRuntime, createInteractionFacade, createSalmonTaskExecutor, createTaskEventBus, createPluginRegistry, createPromptRegistry, getUserAcpSessionStorePath, GitSnapshotCheckpointService, getLogger, mergeResolvedExtensions, PACKAGE_VERSION, PlainReporter, PluginLoader, resolveExtensions, resolveExecutionProfile, runSalmonLoop, setPluginRegistry, setPromptRegistry, startAcpStdioServer, StderrReporter, } from '../../core/facades/cli-serve.js';
-import { selectPublicCapabilitiesForSurface, toA2APublicSkills, } from '../../core/public-capabilities/projections.js';
-import { buildPublicCapabilityRegistry } from '../../core/public-capabilities/registry.js';
+import { readPlan } from '../../core/plan/index.js';
+import { toA2APublicSkills } from '../../core/public-capabilities/projections.js';
 import { createTerminalAuthorizationProvider } from '../authorization/provider.js';
 import { text } from '../locales/index.js';
 import { getOptionValueSourceWithGlobalFallback } from '../utils/command-option-source.js';
@@ -41,7 +41,7 @@ function buildServeLoopExecutionDefaults(mode) {
     };
 }
 function registerServeShutdown({ message, closeRuntime, closeAcpStdio, }) {
-    process.once('SIGINT', async () => {
+    const shutdown = async () => {
         getLogger().info(message);
         try {
             await closeRuntime?.();
@@ -50,39 +50,12 @@ function registerServeShutdown({ message, closeRuntime, closeAcpStdio, }) {
             closeAcpStdio?.();
             process.exit(0);
         }
-    });
-}
-export function registerServeCommands(program) {
-    const serve = program
-        .command('serve')
-        .description(text.cli.serveDescription)
-        .option('--a2a-host <host>', text.cli.a2aHostOption)
-        .option('--a2a-port <port>', text.cli.a2aPortOption)
-        .option('--a2a-token <token>', text.cli.a2aTokenOption, (value, previous) => previous.concat([value]), [])
-        .option('--no-acp-stdio', text.cli.acpStdioDisableOption)
-        .option('--no-color', text.cli.noColorOption)
-        .action(handleServeCommand);
-    serve
-        .command('acp')
-        .description(text.cli.serveAcpDescription)
-        .option('--no-color', text.cli.noColorOption)
-        .action(handleServeAcpCommand);
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
 }
-export async function handleServeCommand(_options, command) {
-    const allOptions = command.optsWithGlobals();
-    const configResult = await resolveCliConfig({
-        repo: allOptions.repo,
-        cwd: process.cwd(),
-        configPath: allOptions.config,
-        enableConfigFile: allOptions.configFile !== false,
-        auditScope: allOptions.auditScope,
-        logMode: allOptions.logMode,
-    });
-    if (!configResult.ok) {
-        getLogger().error(configResult.message, true);
-        process.exit(1);
-    }
-    const { resolvedConfig, auditScope, repoPath: defaultRepoPath } = configResult;
+async function resolveServeCommonSetup(params) {
+    const { command, allOptions, defaultRepoPath, resolvedConfig, auditScope } = params;
     const defaultFlowMode = 'autopilot';
     const defaultPermissionMode = resolveServePermissionMode({
         command,
@@ -90,19 +63,6 @@ export async function handleServeCommand(_options, command) {
         rawConfiguredPermissionMode: resolvedConfig.raw?.mode,
         flowMode: defaultFlowMode,
     });
-    const serverConfig = resolvedConfig.server;
-    const rawA2aHost = allOptions.a2aHost ?? serverConfig?.a2a?.host;
-    const a2aHost = String(rawA2aHost ?? '127.0.0.1');
-    const rawA2aPort = allOptions.a2aPort ?? serverConfig?.a2a?.port;
-    const a2aPort = parsePort(rawA2aPort, 7431);
-    if (!Number.isFinite(a2aPort) || a2aPort <= 0) {
-        getLogger().error(text.cli.invalidA2APort(String(rawA2aPort ?? '')), true);
-        process.exit(1);
-    }
-    const acpStdioEnabled = allOptions.acpStdio !== false;
-    if (acpStdioEnabled) {
-        getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
-    }
     const languagePlugins = createPluginRegistry();
     setPluginRegistry(languagePlugins);
     setPromptRegistry(createPromptRegistry());
@@ -168,6 +128,87 @@ export async function handleServeCommand(_options, command) {
         executeTask: executor.execute,
         eventBus: sharedEventBus,
     });
+    return {
+        defaultPermissionMode,
+        executor,
+        sharedEventBus,
+        checkpointService,
+        acpFacade,
+    };
+}
+function buildAcpAgentOptions(params) {
+    return {
+        agentInfo: { name: 'salmon-loop', version: PACKAGE_VERSION },
+        defaultModeId: 'autopilot',
+        defaultPermissionPolicy: resolveDefaultAcpPermissionPolicy(params.defaultPermissionMode),
+        checkpointReader: {
+            listBySession: async ({ repoPath, sessionId, limit, }) => await params.checkpointService.list({ repoPath, sessionId, limit }),
+            getById: async ({ repoPath, checkpointId }) => (await params.checkpointService.loadWithStatus({ repoPath, checkpointId })).handle,
+            probeById: async ({ repoPath, checkpointId }) => {
+                const status = await params.checkpointService.loadWithStatus({ repoPath, checkpointId });
+                return { valid: Boolean(status.handle), reason: status.reason };
+            },
+        },
+        planReader: {
+            readBySession: async ({ repoPath, sessionId }) => await readPlan({ persistenceRoot: repoPath, sessionId }),
+        },
+        facade: params.facade,
+        sessionPersistencePath: getUserAcpSessionStorePath(),
+        sessionStorePolicy: params.sessionStorePolicy,
+        eventBus: params.sharedEventBus,
+    };
+}
+export function registerServeCommands(program) {
+    const serve = program
+        .command('serve')
+        .description(text.cli.serveDescription)
+        .option('--a2a-host <host>', text.cli.a2aHostOption)
+        .option('--a2a-port <port>', text.cli.a2aPortOption)
+        .option('--a2a-token <token>', text.cli.a2aTokenOption, (value, previous) => previous.concat([value]), [])
+        .option('--no-acp-stdio', text.cli.acpStdioDisableOption)
+        .option('--no-color', text.cli.noColorOption)
+        .action(handleServeCommand);
+    serve
+        .command('acp')
+        .description(text.cli.serveAcpDescription)
+        .option('--no-color', text.cli.noColorOption)
+        .action(handleServeAcpCommand);
+}
+export async function handleServeCommand(_options, command) {
+    const allOptions = command.optsWithGlobals();
+    const configResult = await resolveCliConfig({
+        repo: allOptions.repo,
+        cwd: process.cwd(),
+        configPath: allOptions.config,
+        enableConfigFile: allOptions.configFile !== false,
+        auditScope: allOptions.auditScope,
+        logMode: allOptions.logMode,
+    });
+    if (!configResult.ok) {
+        getLogger().error(configResult.message, true);
+        process.exit(1);
+    }
+    const { resolvedConfig, repoPath: defaultRepoPath } = configResult;
+    const serverConfig = resolvedConfig.server;
+    const rawA2aHost = allOptions.a2aHost ?? serverConfig?.a2a?.host;
+    const a2aHost = String(rawA2aHost ?? '127.0.0.1');
+    const rawA2aPort = allOptions.a2aPort ?? serverConfig?.a2a?.port;
+    const a2aPort = parsePort(rawA2aPort, 7431);
+    if (!Number.isFinite(a2aPort) || a2aPort <= 0) {
+        getLogger().error(text.cli.invalidA2APort(String(rawA2aPort ?? '')), true);
+        process.exit(1);
+    }
+    const acpStdioEnabled = allOptions.acpStdio !== false;
+    if (acpStdioEnabled) {
+        getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
+    }
+    const { defaultPermissionMode, executor, sharedEventBus, checkpointService, acpFacade } = await resolveServeCommonSetup({
+        command,
+        allOptions,
+        defaultRepoPath,
+        resolvedConfig,
+        auditScope: configResult.auditScope,
+    });
     const tokens = Array.isArray(allOptions.a2aToken)
         ? allOptions.a2aToken.filter((token) => typeof token === 'string')
         : [];
@@ -188,33 +229,22 @@ export async function handleServeCommand(_options, command) {
             next();
         }
         : undefined;
-    const a2aPublicCapabilities = selectPublicCapabilitiesForSurface('a2a', buildPublicCapabilityRegistry());
-    const a2aSkills = toA2APublicSkills(a2aPublicCapabilities);
+    const a2aSkills = toA2APublicSkills();
     const agentCard = buildA2AAgentCard({
         name: 'salmon-loop',
-        url: `http://${a2aHost}:${a2aPort}`,
+        url: `http://${a2aHost}:${a2aPort}/a2a/jsonrpc`,
         capabilities: a2aSkills,
         security: authTokens.length > 0 ? [{ type: 'http', scheme: 'bearer' }] : [],
     });
     if (acpStdioEnabled) {
-        startAcpStdioServer((conn) => createAcpFormalAgent({
-            conn,
-            agentInfo: { name: 'salmon-loop', version: PACKAGE_VERSION },
-            defaultModeId: 'autopilot',
-            defaultPermissionPolicy: resolveDefaultAcpPermissionPolicy(defaultPermissionMode),
-            checkpointReader: {
-                listBySession: async ({ repoPath, sessionId, limit }) => await checkpointService.list({ repoPath, sessionId, limit }),
-                getById: async ({ repoPath, checkpointId }) => (await checkpointService.loadWithStatus({ repoPath, checkpointId })).handle,
-                probeById: async ({ repoPath, checkpointId }) => {
-                    const status = await checkpointService.loadWithStatus({ repoPath, checkpointId });
-                    return { valid: Boolean(status.handle), reason: status.reason };
-                },
-            },
+        const agentOptions = buildAcpAgentOptions({
             facade: acpFacade,
-            sessionPersistencePath: getUserAcpSessionStorePath(),
+            checkpointService,
+            defaultPermissionMode,
+            sharedEventBus,
             sessionStorePolicy: resolvedConfig.server?.acp?.sessionStore,
-            eventBus: sharedEventBus,
-        }));
+        });
+        startAcpStdioServer((conn) => createAcpFormalAgent({ conn, ...agentOptions }));
         getLogger().info(text.cli.acpStdioStarted('n/a (stdio)'));
     }
     const runtime = createAgentServerRuntime({
@@ -250,97 +280,23 @@ export async function handleServeAcpCommand(_options, command) {
         getLogger().error(configResult.message, true);
         process.exit(1);
     }
-    const { resolvedConfig, auditScope, repoPath: defaultRepoPath } = configResult;
-    const defaultFlowMode = 'autopilot';
-    const defaultPermissionMode = resolveServePermissionMode({
+    const { resolvedConfig, repoPath: defaultRepoPath } = configResult;
+    getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
+    const { defaultPermissionMode, acpFacade, checkpointService, sharedEventBus } = await resolveServeCommonSetup({
         command,
         allOptions,
-        rawConfiguredPermissionMode: resolvedConfig.raw?.mode,
-        flowMode: defaultFlowMode,
+        defaultRepoPath,
+        resolvedConfig,
+        auditScope: configResult.auditScope,
     });
-    getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
-    const languagePlugins = createPluginRegistry();
-    setPluginRegistry(languagePlugins);
-    setPromptRegistry(createPromptRegistry());
-    await PluginLoader.loadPlugins(languagePlugins, defaultRepoPath);
-    const extensions = await resolveExtensions({ repoRoot: defaultRepoPath });
-    const { llm } = createRuntimeLlmAndWarn({
-        llmConfig: resolvedConfig.llm,
-        langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
-    });
-    const outcomeReporter = createOutcomeReporter({
-        enabled: resolvedConfig.observability.langfuse.outcome,
-        endpoint: resolvedConfig.observability.langfuse.endpoint,
-        llmBaseUrl: resolvedConfig.llm.api.baseUrl,
-        langfuseApiKey: resolvedConfig.observability.langfuse.apiKey,
-    });
-    const defaultAuthorizationProvider = createTerminalAuthorizationProvider({
-        config: resolvedConfig.toolAuthorization,
-        extensions: extensions.resolved,
-        forceNonInteractive: true,
-    });
-    const executor = createSalmonTaskExecutor({
-        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, extensions: taskExtensions, }) => {
-            const effectiveRepoPath = repoPath ?? defaultRepoPath;
-            const flowMode = mode;
-            const executionDefaults = buildServeLoopExecutionDefaults(flowMode);
-            const permissionMode = resolveServePermissionMode({
-                command,
-                allOptions,
-                rawConfiguredPermissionMode: resolvedConfig.raw?.mode,
-                flowMode,
-            });
-            return await runSalmonLoop({
-                instruction,
-                repoPath: effectiveRepoPath,
-                llm,
-                mode: flowMode,
-                verify: resolvedConfig.verify.command,
-                ...executionDefaults,
-                llmOutput: resolvedConfig.llmOutput,
-                outcomeReporter,
-                langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
-                langfuseUserId: resolvedConfig.observability.langfuse.userId,
-                auditScope,
-                permissionMode,
-                languagePlugins,
-                authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
-                authorizationMode,
-                extensions: mergeResolvedExtensions(extensions.resolved, taskExtensions),
-                onEvent,
-                signal,
-            });
-        },
-    });
-    const sharedEventBus = createTaskEventBus();
-    const checkpointService = new GitSnapshotCheckpointService(undefined, resolvedConfig.server?.acp?.checkpointManifest);
-    await checkpointService.gc({
-        repoPath: defaultRepoPath,
-        olderThanMs: 1000 * 60 * 60 * 24 * 14,
-        maxPerSession: 30,
-    });
-    const acpFacade = createInteractionFacade({
-        executeTask: executor.execute,
-        eventBus: sharedEventBus,
-    });
-    startAcpStdioServer((conn) => createAcpFormalAgent({
-        conn,
-        agentInfo: { name: 'salmon-loop', version: PACKAGE_VERSION },
-        defaultModeId: 'autopilot',
-        defaultPermissionPolicy: resolveDefaultAcpPermissionPolicy(defaultPermissionMode),
-        checkpointReader: {
-            listBySession: async ({ repoPath, sessionId, limit }) => await checkpointService.list({ repoPath, sessionId, limit }),
-            getById: async ({ repoPath, checkpointId }) => (await checkpointService.loadWithStatus({ repoPath, checkpointId })).handle,
-            probeById: async ({ repoPath, checkpointId }) => {
-                const status = await checkpointService.loadWithStatus({ repoPath, checkpointId });
-                return { valid: Boolean(status.handle), reason: status.reason };
-            },
-        },
+    const agentOptions = buildAcpAgentOptions({
         facade: acpFacade,
-        sessionPersistencePath: getUserAcpSessionStorePath(),
+        checkpointService,
+        defaultPermissionMode,
+        sharedEventBus,
         sessionStorePolicy: resolvedConfig.server?.acp?.sessionStore,
-        eventBus: sharedEventBus,
-    }));
+    });
+    startAcpStdioServer((conn) => createAcpFormalAgent({ conn, ...agentOptions }));
     getLogger().info(text.cli.acpStdioStarted('n/a (stdio)'));
     registerServeShutdown({
         message: 'Received SIGINT, shutting down ACP server...',

package/dist/cli/headless/json-protocol.js

@@ -63,7 +63,7 @@ export function encodeJsonResult(params) {
     const safeHint = overrides?.safeHint ?? params.loopResult.safeHint ?? params.loopResult.reason;
     const remediationSteps = overrides?.remediationSteps ?? params.loopResult.remediationSteps ?? [];
     const diagnosticCode = overrides?.diagnosticCode ?? params.loopResult.diagnosticCode ?? params.loopResult.reasonCode;
-    const reason = overrides?.reason ?? safeHint;
+    const reason = overrides?.reason ?? params.loopResult.reason;
     const reasonCode = overrides?.reasonCode ?? params.loopResult.reasonCode;
     const errorCode = overrides?.errorCode ?? params.loopResult.errorCode;
     const warnings = normalizeHeadlessWarnings(params.warnings);

package/dist/cli/headless/stream-json-protocol.js

@@ -76,6 +76,7 @@ export function encodeStreamLoopEvent(params) {
 export function encodeStreamResult(params) {
     const exitCode = getStreamExitCode(params.loopResult);
     const warnings = normalizeHeadlessWarnings(params.warnings);
+    const safeHint = params.loopResult.safeHint ?? params.loopResult.reason;
     const patchArtifact = params.loopResult.benchmarkPatchArtifact
         ? {
             kind: params.loopResult.benchmarkPatchArtifact.kind,
@@ -102,10 +103,10 @@ export function encodeStreamResult(params) {
             timestamp: toIso(params.at),
             success: Boolean(params.loopResult.success),
             exit_code: exitCode,
-            reason: params.loopResult.safeHint ?? params.loopResult.reason,
+            reason: params.loopResult.reason,
             reason_code: params.loopResult.reasonCode,
             diagnostic_code: params.loopResult.diagnosticCode ?? params.loopResult.reasonCode,
-            safe_hint: params.loopResult.safeHint ?? params.loopResult.reason,
+            safe_hint: safeHint,
             remediation_steps: params.loopResult.remediationSteps ?? [],
             attempts: params.loopResult.attempts,
             changed_files: params.loopResult.changedFiles ?? [],

package/dist/cli/slash/runtime.js

@@ -151,9 +151,10 @@ export async function createCliSlashRuntime(options) {
                             dryRun: false,
                             verbose: undefined,
                         }, silentEmit);
+                        let toolstack;
                         try {
                             await env.setup();
-                            const toolstack = await createStandardToolstack({
+                            toolstack = await createStandardToolstack({
                                 repoRoot: env.activeRepoPath,
                                 persistenceRoot: options.repoRoot,
                                 worktreeRoot: env.activeRepoPath,
@@ -188,6 +189,9 @@ export async function createCliSlashRuntime(options) {
                             return { kind: 'rewrite', input: res.injectedPrompt };
                         }
                         finally {
+                            await toolstack
+                                ?.dispose?.()
+                                .catch((error) => logIgnoredError('[SlashRuntime] toolstack cleanup failed', error));
                             await env
                                 .teardown()
                                 .catch((error) => logIgnoredError('[SlashRuntime] env teardown failed', error));

package/dist/core/adapters/fs/node-fs.js

@@ -4,4 +4,5 @@ export const promises = fsPromises;
 export const syncFs = Object.assign({}, fs, fsPromises);
 export const { access, appendFile, chmod, chown, copyFile, cp, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, unlink, utimes, writeFile, } = fsPromises;
 export const { existsSync, readFileSync, realpathSync } = fs;
+export const { constants } = fs;
 //# sourceMappingURL=node-fs.js.map

package/dist/core/benchmark/patch-artifact.js

@@ -23,7 +23,7 @@ const DIFF_ARGS = [
     '.',
 ];
 function normalizeGitPatch(text) {
-    const normalized = text.replace(/\r\n/g, '\n').replace(/\s+$/, '');
+    const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n+$/, '');
     return normalized.length > 0 ? `${normalized}\n` : '';
 }
 function splitLines(text) {

package/dist/core/context/service.js

@@ -163,7 +163,7 @@ export class ContextService {
             const absoluteFile = defaultPathAdapter.resolve(repoPath, relativeFile);
             try {
                 const stat = await this.fileAdapter.stat(absoluteFile);
-                parts.push(`${relativeFile}:${stat.mtimeMs}:${stat.size}`);
+                parts.push(this.formatStatSignature(relativeFile, stat));
             }
             catch {
                 parts.push(`${relativeFile}:missing`);
@@ -182,7 +182,7 @@ export class ContextService {
             const gitPath = defaultPathAdapter.resolve(repoPath, rel);
             try {
                 const stat = await this.fileAdapter.stat(gitPath);
-                parts.push(`${rel}:${stat.mtimeMs}:${stat.size}`);
+                parts.push(this.formatStatSignature(rel, stat));
             }
             catch {
                 parts.push(`${rel}:missing`);
@@ -190,6 +190,9 @@ export class ContextService {
         }
         return parts;
     }
+    formatStatSignature(relativePath, stat) {
+        return `${relativePath}:${stat.mtimeMs}:${stat.ctimeMs ?? 0}:${stat.size}`;
+    }
     getEntryTimestamp(entry) {
         return entry.lastAccessedAt ?? entry.createdAt ?? 0;
     }