salmon-loop 0.2.13 → 0.3.0

package/dist/cli/commands/serve.js

@@ -1,6 +1,10 @@
-import { buildA2AAgentCard, buildSidecarRouteDescriptors, createAcpFormalAgent, createAgentServerRuntime, createInteractionFacade, createSalmonTaskExecutor, createTaskEventBus, createPluginRegistry, createPromptRegistry, defaultPathAdapter, defaultSidecarRouteCatalog, getSidecarListenOptions, getUserAcpSessionStorePath, GitSnapshotCheckpointService, getLogger, mkdir, PlainReporter, PluginLoader, resolveExtensions, runSalmonLoop, setPluginRegistry, setPromptRegistry, startAcpStdioServer, StderrReporter, } from '../../core/facades/cli-serve.js';
+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 { createTerminalAuthorizationProvider } from '../authorization/provider.js';
 import { text } from '../locales/index.js';
+import { getOptionValueSourceWithGlobalFallback } from '../utils/command-option-source.js';
 import { createOutcomeReporter } from '../utils/outcome-reporter.js';
 import { resolveCliConfig } from '../utils/resolve-cli-config.js';
 import { createRuntimeLlmAndWarn } from './run/runtime-llm.js';
@@ -10,21 +14,44 @@ function parsePort(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : Number.NaN;
 }
-function buildSidecarHandlers(deps) {
+function resolveDefaultAcpPermissionPolicy(permissionMode) {
+    return permissionMode === 'yolo' ? 'allow_all' : 'ask';
+}
+function resolveServePermissionMode({ command, allOptions, rawConfiguredPermissionMode, flowMode, }) {
+    const permissionModeOptionSource = getOptionValueSourceWithGlobalFallback(command, 'mode');
+    const configuredPermissionMode = normalizePermissionMode(rawConfiguredPermissionMode);
+    const rawPermissionMode = (permissionModeOptionSource === 'cli' ? allOptions.mode : undefined) ??
+        configuredPermissionMode ??
+        resolveExecutionProfile(flowMode).defaultPermissionMode ??
+        'interactive';
+    const permissionMode = normalizePermissionMode(rawPermissionMode);
+    if (!permissionMode) {
+        getLogger().error(`Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`, true);
+        process.exit(1);
+    }
+    return permissionMode;
+}
+function buildServeLoopExecutionDefaults(mode) {
+    const profile = resolveExecutionProfile(mode);
+    const strategy = profile.defaultCheckpointStrategy ?? 'worktree';
     return {
-        health: async () => Response.json({ status: 'ok' }),
-        status: async () => Response.json({ state: 'idle' }),
-        info: async () => Response.json({
-            name: deps.name,
-            version: deps.version,
-            capabilities: deps.capabilities,
-        }),
-        abort: async () => new Response('Abort not implemented for this runtime', { status: 501 }),
-        workspace_files: async () => new Response('Workspace file access not enabled', { status: 501 }),
-        logs_stream: async () => new Response('Log streaming not enabled', { status: 501 }),
-        config_patch: async () => new Response('Config patch not enabled', { status: 501 }),
+        strategy,
+        applyBackOnDirty: strategy === 'worktree' ? '3way' : undefined,
+        environmentMode: 'strict',
     };
 }
+function registerServeShutdown({ message, closeRuntime, closeAcpStdio, }) {
+    process.once('SIGINT', async () => {
+        getLogger().info(message);
+        try {
+            await closeRuntime?.();
+        }
+        finally {
+            closeAcpStdio?.();
+            process.exit(0);
+        }
+    });
+}
 export function registerServeCommands(program) {
     const serve = program
         .command('serve')
@@ -33,8 +60,6 @@ export function registerServeCommands(program) {
         .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('--sidecar-socket <path>', text.cli.sidecarSocketOption)
-        .option('--sidecar-allow-conditional', text.cli.sidecarAllowConditionalOption)
         .option('--no-color', text.cli.noColorOption)
         .action(handleServeCommand);
     serve
@@ -58,6 +83,13 @@ export async function handleServeCommand(_options, command) {
         process.exit(1);
     }
     const { resolvedConfig, auditScope, repoPath: defaultRepoPath } = configResult;
+    const defaultFlowMode = 'autopilot';
+    const defaultPermissionMode = resolveServePermissionMode({
+        command,
+        allOptions,
+        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');
@@ -71,13 +103,6 @@ export async function handleServeCommand(_options, command) {
     if (acpStdioEnabled) {
         getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
     }
-    const sidecarListen = typeof allOptions.sidecarSocket === 'string' && allOptions.sidecarSocket.length > 0
-        ? { type: 'pipe', path: allOptions.sidecarSocket }
-        : getSidecarListenOptions();
-    const allowConditional = allOptions.sidecarAllowConditional ?? serverConfig?.sidecar?.allowConditional ?? false;
-    if (sidecarListen.type === 'pipe' && !sidecarListen.path.startsWith('\\\\.\\pipe\\')) {
-        await mkdir(defaultPathAdapter.dirname(sidecarListen.path), { recursive: true });
-    }
     const languagePlugins = createPluginRegistry();
     setPluginRegistry(languagePlugins);
     setPromptRegistry(createPromptRegistry());
@@ -99,28 +124,34 @@ export async function handleServeCommand(_options, command) {
         forceNonInteractive: true,
     });
     const executor = createSalmonTaskExecutor({
-        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, fileSystemOverride, }) => {
+        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, fileSystemOverride, 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: mode,
+                mode: flowMode,
                 verify: resolvedConfig.verify.command,
-                strategy: 'worktree',
-                applyBackOnDirty: '3way',
-                environmentMode: 'strict',
+                ...executionDefaults,
                 llmOutput: resolvedConfig.llmOutput,
                 outcomeReporter,
                 langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
                 langfuseUserId: resolvedConfig.observability.langfuse.userId,
                 auditScope,
-                permissionMode: resolvedConfig.permissionMode,
+                permissionMode,
                 languagePlugins,
                 fileSystemOverride,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
                 authorizationMode,
-                extensions: extensions.resolved,
+                extensions: mergeResolvedExtensions(extensions.resolved, taskExtensions),
                 onEvent,
                 signal,
             });
@@ -157,27 +188,20 @@ export async function handleServeCommand(_options, command) {
             next();
         }
         : undefined;
-    const capabilities = [{ id: 'patch', title: 'Patch code' }];
+    const a2aPublicCapabilities = selectPublicCapabilitiesForSurface('a2a', buildPublicCapabilityRegistry());
+    const a2aSkills = toA2APublicSkills(a2aPublicCapabilities);
     const agentCard = buildA2AAgentCard({
         name: 'salmon-loop',
         url: `http://${a2aHost}:${a2aPort}`,
-        capabilities,
+        capabilities: a2aSkills,
         security: authTokens.length > 0 ? [{ type: 'http', scheme: 'bearer' }] : [],
     });
-    const sidecarRoutes = buildSidecarRouteDescriptors({
-        strict: true,
-        catalog: defaultSidecarRouteCatalog,
-        handlers: buildSidecarHandlers({
-            name: 'salmon-loop',
-            version: '0.2.0',
-            capabilities,
-        }),
-    });
     if (acpStdioEnabled) {
         startAcpStdioServer((conn) => createAcpFormalAgent({
             conn,
-            agentInfo: { name: 'salmon-loop', version: '0.2.0' },
-            defaultModeId: resolvedConfig.permissionMode,
+            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,
@@ -192,42 +216,25 @@ export async function handleServeCommand(_options, command) {
             eventBus: sharedEventBus,
         }));
         getLogger().info(text.cli.acpStdioStarted('n/a (stdio)'));
-        // Handle SIGINT for graceful shutdown
-        process.on('SIGINT', () => {
-            getLogger().info('Received SIGINT, shutting down ACP server...');
-            process.stdin.destroy();
-            process.exit(0);
-        });
     }
-    const fastify = (await import('fastify')).default;
     const runtime = createAgentServerRuntime({
-        createFastify: () => fastify(),
         a2a: {
             buildAgentCard: () => agentCard,
             executeTask: executor.execute,
             eventBus: sharedEventBus,
             authMiddleware,
         },
-        sidecar: {
-            routes: sidecarRoutes,
-            allowConditional,
-        },
         listen: {
             a2a: { host: a2aHost, port: a2aPort },
-            sidecar: sidecarListen,
         },
-        a2aBaseUrl: `http://${a2aHost}:${a2aPort}`,
     });
-    // Handle SIGINT for graceful shutdown
-    process.on('SIGINT', () => {
-        getLogger().info('Received SIGINT, shutting down server...');
-        runtime.close().then(() => process.exit(0));
+    registerServeShutdown({
+        message: 'Received SIGINT, shutting down server...',
+        closeRuntime: () => runtime.close(),
+        closeAcpStdio: acpStdioEnabled ? () => void process.stdin.destroy() : undefined,
     });
     await runtime.start();
-    const sidecarAddress = sidecarListen.type === 'tcp'
-        ? `http://${sidecarListen.host}:${sidecarListen.port}`
-        : sidecarListen.path;
-    getLogger().success(text.cli.serveStarted(a2aHost, a2aPort, sidecarAddress));
+    getLogger().success(text.cli.serveStarted(a2aHost, a2aPort));
 }
 export async function handleServeAcpCommand(_options, command) {
     const allOptions = command.optsWithGlobals();
@@ -244,6 +251,13 @@ export async function handleServeAcpCommand(_options, command) {
         process.exit(1);
     }
     const { resolvedConfig, auditScope, repoPath: defaultRepoPath } = configResult;
+    const defaultFlowMode = 'autopilot';
+    const defaultPermissionMode = resolveServePermissionMode({
+        command,
+        allOptions,
+        rawConfiguredPermissionMode: resolvedConfig.raw?.mode,
+        flowMode: defaultFlowMode,
+    });
     getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
     const languagePlugins = createPluginRegistry();
     setPluginRegistry(languagePlugins);
@@ -266,27 +280,33 @@ export async function handleServeAcpCommand(_options, command) {
         forceNonInteractive: true,
     });
     const executor = createSalmonTaskExecutor({
-        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, }) => {
+        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: mode,
+                mode: flowMode,
                 verify: resolvedConfig.verify.command,
-                strategy: 'worktree',
-                applyBackOnDirty: '3way',
-                environmentMode: 'strict',
+                ...executionDefaults,
                 llmOutput: resolvedConfig.llmOutput,
                 outcomeReporter,
                 langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
                 langfuseUserId: resolvedConfig.observability.langfuse.userId,
                 auditScope,
-                permissionMode: resolvedConfig.permissionMode,
+                permissionMode,
                 languagePlugins,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
                 authorizationMode,
-                extensions: extensions.resolved,
+                extensions: mergeResolvedExtensions(extensions.resolved, taskExtensions),
                 onEvent,
                 signal,
             });
@@ -305,8 +325,9 @@ export async function handleServeAcpCommand(_options, command) {
     });
     startAcpStdioServer((conn) => createAcpFormalAgent({
         conn,
-        agentInfo: { name: 'salmon-loop', version: '0.2.0' },
-        defaultModeId: resolvedConfig.permissionMode,
+        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,
@@ -321,10 +342,9 @@ export async function handleServeAcpCommand(_options, command) {
         eventBus: sharedEventBus,
     }));
     getLogger().info(text.cli.acpStdioStarted('n/a (stdio)'));
-    process.on('SIGINT', () => {
-        getLogger().info('Received SIGINT, shutting down ACP server...');
-        process.stdin.destroy();
-        process.exit(0);
+    registerServeShutdown({
+        message: 'Received SIGINT, shutting down ACP server...',
+        closeAcpStdio: () => void process.stdin.destroy(),
     });
 }
 //# sourceMappingURL=serve.js.map

package/dist/cli/commands/tool-names.js

@@ -1,7 +1,7 @@
 import * as os from 'os';
 import * as path from 'path';
-import { getLogger, registerAllBuiltins, skillToToolSpec, SkillParser, ToolRegistry, } from '../../core/facades/cli-command-tool-names.js';
-import { existsSync, readFileUtf8, readFileUtf8Sync, readdirDirents, readdirDirentsSync, safePathJoin, stat, statSync, } from '../utils/safe-fs.js';
+import { getLogger, registerAllBuiltins, resolveExtensions, skillToToolSpec, SkillLoader, ToolRegistry, } from '../../core/facades/cli-command-tool-names.js';
+import { stat, statSync } from '../utils/safe-fs.js';
 const VALID_SIDE_EFFECTS = new Set([
     'none',
     'fs_read',
@@ -11,40 +11,23 @@ const VALID_SIDE_EFFECTS = new Set([
     'git_read',
     'git_write',
 ]);
+// Cache key includes repoRoot. Extensions config is not part of the key because
+// tool-names is used for tab completion where extensions may not be available.
 const toolNameCache = new Map();
-async function loadSkillsFromPath(root) {
-    if (!existsSync(root))
-        return [];
-    const entries = await readdirDirents(root, root);
-    const skills = [];
-    for (const entry of entries) {
-        const skillFile = entry.isDirectory()
-            ? safePathJoin(root, entry.name, 'SKILL.md')
-            : entry.name.endsWith('.md')
-                ? safePathJoin(root, entry.name)
-                : null;
-        if (!skillFile || !existsSync(skillFile, root))
-            continue;
-        try {
-            const content = await readFileUtf8(skillFile, root);
-            skills.push(SkillParser.parse(content, skillFile));
-        }
-        catch (error) {
-            getLogger().warn(`Failed to load skill at ${skillFile}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return skills;
-}
-function getSkillSearchPaths(repoRoot) {
-    return [
-        path.join(os.homedir(), '.claude/skills'),
-        path.join(repoRoot, '.salmonloop/skills'),
-        path.join(repoRoot, '.claude/skills'),
+/**
+ * Compute a cache-invalidation signature based on mtime of all skill search
+ * paths that SkillLoader would scan. Mirrors the strict search order.
+ */
+async function computeSkillSignature(repoRoot, extraPaths = []) {
+    const searchPaths = [
+        ...extraPaths,
+        path.join(repoRoot, '.salmonloop', 'skills'),
+        path.join(repoRoot, '.agents', 'skills'),
+        path.join(os.homedir(), '.salmonloop', 'skills'),
+        path.join(os.homedir(), '.agents', 'skills'),
     ];
-}
-async function computeSkillSignature(repoRoot) {
     const parts = [];
-    for (const searchPath of getSkillSearchPaths(repoRoot)) {
+    for (const searchPath of searchPaths) {
         try {
             const stats = await stat(searchPath);
             parts.push(`${searchPath}:${stats.mtimeMs}`);
@@ -56,8 +39,14 @@ async function computeSkillSignature(repoRoot) {
     return parts.join('|');
 }
 function computeSkillSignatureSync(repoRoot) {
+    const searchPaths = [
+        path.join(repoRoot, '.salmonloop', 'skills'),
+        path.join(repoRoot, '.agents', 'skills'),
+        path.join(os.homedir(), '.salmonloop', 'skills'),
+        path.join(os.homedir(), '.agents', 'skills'),
+    ];
     const parts = [];
-    for (const searchPath of getSkillSearchPaths(repoRoot)) {
+    for (const searchPath of searchPaths) {
         try {
             const stats = statSync(searchPath);
             parts.push(`${searchPath}:${stats.mtimeMs}`);
@@ -68,52 +57,63 @@ function computeSkillSignatureSync(repoRoot) {
     }
     return parts.join('|');
 }
-function loadSkillsFromPathSync(root) {
-    if (!existsSync(root))
-        return [];
-    const entries = readdirDirentsSync(root, root);
-    const skills = [];
-    for (const entry of entries) {
-        const skillFile = entry.isDirectory()
-            ? safePathJoin(root, entry.name, 'SKILL.md')
-            : entry.name.endsWith('.md')
-                ? safePathJoin(root, entry.name)
-                : null;
-        if (!skillFile || !existsSync(skillFile, root))
-            continue;
-        try {
-            const content = readFileUtf8Sync(skillFile, root);
-            skills.push(SkillParser.parse(content, skillFile));
-        }
-        catch (error) {
-            getLogger().warn(`Failed to load skill at ${skillFile}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return skills;
-}
+/**
+ * Get all known tool names including skills.
+ *
+ * Uses `resolveExtensions` to obtain the same SkillLoader configuration
+ * (extraPaths) as the main runtime, so that
+ * tool-name discovery and actual runtime skill availability stay consistent.
+ */
 export async function getKnownToolNames(repoRoot) {
-    const signature = await computeSkillSignature(repoRoot);
+    // Resolve extensions to get the same loader config as the runtime
+    let skillDiscovery = {};
+    try {
+        const { resolved } = await resolveExtensions({ repoRoot });
+        skillDiscovery = resolved.skillDiscovery;
+    }
+    catch {
+        // Extensions config unavailable — fall back to loader defaults
+    }
+    const extraPaths = skillDiscovery.paths ?? [];
+    const signature = await computeSkillSignature(repoRoot, extraPaths);
     const cached = toolNameCache.get(repoRoot);
     if (cached && cached.signature === signature)
         return cached.names;
     const registry = new ToolRegistry();
     registerAllBuiltins(registry);
-    for (const searchPath of getSkillSearchPaths(repoRoot)) {
-        const skills = await loadSkillsFromPath(searchPath);
-        for (const skill of skills) {
-            try {
-                registry.register(skillToToolSpec(skill));
-            }
-            catch (error) {
-                const label = skill.metadata?.name || skill.id;
-                getLogger().warn(`Failed to register skill ${label}: ${error instanceof Error ? error.message : String(error)}`);
-            }
+    const routerBox = { router: null };
+    const skillLoader = new SkillLoader({
+        repoRoot,
+        extraPaths,
+    });
+    const catalog = await skillLoader.loadCatalog();
+    for (const entry of catalog) {
+        try {
+            // Name-only registration: executor is never called, so null router is safe.
+            // Use catalog entry for lightweight registration (progressive disclosure).
+            registry.register(skillToToolSpec({ entry, loader: skillLoader }, routerBox));
+        }
+        catch (error) {
+            const label = entry.name || entry.id;
+            getLogger().warn(`Failed to register skill ${label}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     const names = new Set(registry.listAll().map((spec) => spec.name));
     toolNameCache.set(repoRoot, { names, signature });
     return names;
 }
+/**
+ * Synchronous variant for tab completion only.
+ *
+ * @nonAuthoritative This returns a best-effort approximation of known tool
+ * names using loader defaults (no extensions resolution, since
+ * resolveExtensions is async). The result may differ from the actual runtime
+ * tool set when custom `skills.json` discovery paths are configured.
+ *
+ * DO NOT use this for security decisions (allowlist enforcement, permission
+ * checks). Use the async {@link getKnownToolNames} instead, which resolves
+ * extensions for full consistency with the runtime.
+ */
 export function getKnownToolNamesSync(repoRoot) {
     const signature = computeSkillSignatureSync(repoRoot);
     const cached = toolNameCache.get(repoRoot);
@@ -121,16 +121,16 @@ export function getKnownToolNamesSync(repoRoot) {
         return cached.names;
     const registry = new ToolRegistry();
     registerAllBuiltins(registry);
-    for (const searchPath of getSkillSearchPaths(repoRoot)) {
-        const skills = loadSkillsFromPathSync(searchPath);
-        for (const skill of skills) {
-            try {
-                registry.register(skillToToolSpec(skill));
-            }
-            catch (error) {
-                const label = skill.metadata?.name || skill.id;
-                getLogger().warn(`Failed to register skill ${label}: ${error instanceof Error ? error.message : String(error)}`);
-            }
+    const routerBox = { router: null };
+    const skillLoader = new SkillLoader({ repoRoot });
+    const skills = skillLoader.initializeSync();
+    for (const skill of skills) {
+        try {
+            registry.register(skillToToolSpec(skill, routerBox));
+        }
+        catch (error) {
+            const label = skill.metadata?.name || skill.id;
+            getLogger().warn(`Failed to register skill ${label}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     const names = new Set(registry.listAll().map((spec) => spec.name));

package/dist/cli/headless/anthropic-stream-normalized-encoder.js

@@ -1,4 +1,9 @@
 import { encodeAnthropicStreamEvent, } from './anthropic-stream-protocol.js';
+function asToolInput(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
 export function encodeNormalizedToAnthropicStreamLines(params) {
     if (params.event.type === 'normalized.message_start') {
         return [
@@ -64,7 +69,7 @@ export function encodeNormalizedToAnthropicStreamLines(params) {
     }
     if (params.event.type === 'normalized.tool_request_start') {
         const parentToolUseId = params.event.callId;
-        const input = {};
+        const input = params.includeToolInput ? asToolInput(params.event.input) : {};
         return [
             encodeAnthropicStreamEvent({
                 sessionId: params.sessionId,

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

@@ -1,3 +1,4 @@
+import { HEADLESS_SCHEMA_VERSION, normalizeHeadlessWarnings, } from './protocol-metadata.js';
 function toExitCode(result) {
     if (result.reason === 'Operation cancelled by user')
         return 130;
@@ -31,6 +32,30 @@ function toAuthorizationDecisions(result) {
         timestamp: d.timestamp,
     }));
 }
+function toPatchArtifact(result) {
+    const artifact = result.benchmarkPatchArtifact;
+    if (!artifact)
+        return undefined;
+    return {
+        kind: artifact.kind,
+        path: artifact.path,
+        sha256: artifact.sha256,
+        bytes: artifact.bytes,
+        changed_files: artifact.changedFiles,
+        is_empty: artifact.isEmpty,
+    };
+}
+function toBenchmarkArtifact(result) {
+    const artifact = result.benchmarkArtifact;
+    if (!artifact)
+        return undefined;
+    return {
+        provider: artifact.provider,
+        instance_id: artifact.instanceId,
+        model_name_or_path: artifact.modelNameOrPath,
+        predictions_path: artifact.predictionsPath,
+    };
+}
 export function encodeJsonResult(params) {
     const overrides = params.overrides;
     const exitCode = overrides?.exitCode ?? toExitCode(params.loopResult);
@@ -41,11 +66,13 @@ export function encodeJsonResult(params) {
     const reason = overrides?.reason ?? safeHint;
     const reasonCode = overrides?.reasonCode ?? params.loopResult.reasonCode;
     const errorCode = overrides?.errorCode ?? params.loopResult.errorCode;
+    const warnings = normalizeHeadlessWarnings(params.warnings);
     return {
         result: params.resultText,
         structured_output: params.structuredOutput,
         session_id: params.sessionId,
         metadata: {
+            schema_version: HEADLESS_SCHEMA_VERSION,
             command: params.mode,
             repo_path: params.repoPath,
             instruction: params.instruction,
@@ -58,12 +85,15 @@ export function encodeJsonResult(params) {
             remediation_steps: remediationSteps,
             attempts: params.loopResult.attempts,
             changed_files: params.loopResult.changedFiles ?? [],
+            patch_artifact: toPatchArtifact(params.loopResult),
+            benchmark_artifact: toBenchmarkArtifact(params.loopResult),
             audit_path: params.loopResult.auditPath,
             error_code: errorCode,
             authorization_summary: params.loopResult.authorizationSummary,
             usage: toUsage(params.loopResult),
             authorization_decisions: toAuthorizationDecisions(params.loopResult),
             structured_output_error: overrides?.structuredOutputError,
+            warnings,
             timestamps: {
                 started_at: params.startedAt.toISOString(),
                 ended_at: params.endedAt.toISOString(),
@@ -79,11 +109,13 @@ export function encodeJsonResult(params) {
 export function encodeJsonFailure(params) {
     const at = params.at ?? new Date();
     const exitCode = params.exitCode ?? 1;
+    const warnings = normalizeHeadlessWarnings(params.warnings);
     return {
         result: '',
         structured_output: null,
         session_id: params.sessionId,
         metadata: {
+            schema_version: HEADLESS_SCHEMA_VERSION,
             command: params.mode,
             repo_path: params.repoPath,
             instruction: params.instruction,
@@ -91,6 +123,8 @@ export function encodeJsonFailure(params) {
             exit_code: exitCode,
             reason: params.message,
             error_code: params.errorCode,
+            audit_path: params.auditPath,
+            warnings,
             timestamps: {
                 started_at: at.toISOString(),
                 ended_at: at.toISOString(),
@@ -99,11 +133,13 @@ export function encodeJsonFailure(params) {
     };
 }
 export function encodeJsonCrash(params) {
+    const warnings = normalizeHeadlessWarnings(params.warnings);
     return {
         result: '',
         structured_output: null,
         session_id: params.sessionId,
         metadata: {
+            schema_version: HEADLESS_SCHEMA_VERSION,
             command: params.mode,
             repo_path: params.repoPath,
             instruction: params.instruction,
@@ -114,6 +150,7 @@ export function encodeJsonCrash(params) {
                 message: params.error.message,
                 stack: params.error.stack,
             },
+            warnings,
             timestamps: {
                 started_at: params.startedAt.toISOString(),
                 ended_at: params.endedAt.toISOString(),

package/dist/cli/headless/native-stream-normalized-encoder.js

@@ -1,4 +1,9 @@
 import { encodeStreamEvent, encodeStreamFailure, } from './stream-json-protocol.js';
+function asToolInput(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
 export function encodeNormalizedToNativeStreamLines(params) {
     const at = params.event.timestamp;
     if (params.event.type === 'normalized.message_start') {
@@ -75,7 +80,7 @@ export function encodeNormalizedToNativeStreamLines(params) {
         const parentToolUseId = params.event.callId;
         const phase = params.event.phase;
         const round = params.event.round;
-        const input = {};
+        const input = params.includeToolInput ? asToolInput(params.event.input) : {};
         return [
             encodeStreamEvent({
                 uuid: params.uuid(),