salmon-loop 0.2.3 → 0.2.16

package/dist/cli/commands/run/runtime-llm.js

@@ -1,5 +1,32 @@
 import { createPhaseRoutingLlm, createRuntimeLlm, EXECUTION_PHASES, getLogger, Phase, } from '../../../core/facades/cli-run-runtime-llm.js';
 import { text } from '../../locales/index.js';
+function runtimeWarningMessage(code, params) {
+    if (code === 'API_KEY_MISSING')
+        return text.cli.apiKeyMissing;
+    if (code === 'PROVIDER_NOT_SUPPORTED') {
+        return text.cli.providerNotSupported(String(params.llmType));
+    }
+    if (code === 'CLIENT_PACKAGE_NOT_SUPPORTED') {
+        return text.cli.clientPackageNotSupported(String(params.clientPackage || ''));
+    }
+    return code;
+}
+function toHeadlessWarning(code, params) {
+    if (code === 'API_KEY_MISSING') {
+        return {
+            code: 'LLM_CREDENTIAL_MISSING',
+            message: 'LLM credential not configured; using StubLLM. Configure provider credentials to use a real LLM.',
+            source: 'llm.runtime',
+            severity: 'warning',
+        };
+    }
+    return {
+        code,
+        message: runtimeWarningMessage(code, params).replace(/^\[WARN\]\s*/, ''),
+        source: 'llm.runtime',
+        severity: 'warning',
+    };
+}
 export function createRuntimeLlmAndWarn(params) {
     const runtimeLlm = createRuntimeLlm(params.llmConfig, {
         langfuseEnabled: params.langfuseEnabled,
@@ -8,7 +35,7 @@ export function createRuntimeLlmAndWarn(params) {
     const phaseToProviderModel = params.llmConfig?.routing?.phaseToProviderModel;
     const phaseLlms = {};
     if (phaseToProviderModel && typeof phaseToProviderModel === 'object') {
-        const validPhases = new Set([...EXECUTION_PHASES, Phase.SLASH]);
+        const validPhases = new Set([...EXECUTION_PHASES, Phase.SLASH, Phase.AUTOPILOT]);
         for (const [phase, target] of Object.entries(phaseToProviderModel)) {
             if (!validPhases.has(phase))
                 continue;
@@ -29,6 +56,7 @@ export function createRuntimeLlmAndWarn(params) {
                     selectedModelId: target.model?.id,
                     selectedModelSlot: target.model?.slot || 'default',
                 },
+                capabilities: target.capabilities,
             };
             const created = createRuntimeLlm(perPhaseConfig, { langfuseEnabled: params.langfuseEnabled });
             warnings.push(...created.warnings);
@@ -40,17 +68,16 @@ export function createRuntimeLlmAndWarn(params) {
         : runtimeLlm.llm;
     const llmType = params.llmConfig?.type;
     const clientPackage = params.llmConfig?.clientPackage;
-    for (const w of Array.from(new Set(warnings))) {
-        if (w === 'API_KEY_MISSING') {
-            getLogger().warn(text.cli.apiKeyMissing);
-        }
-        else if (w === 'PROVIDER_NOT_SUPPORTED') {
-            getLogger().warn(text.cli.providerNotSupported(String(llmType)));
-        }
-        else if (w === 'CLIENT_PACKAGE_NOT_SUPPORTED') {
-            getLogger().warn(text.cli.clientPackageNotSupported(String(clientPackage || '')));
+    const uniqueWarnings = Array.from(new Set(warnings));
+    for (const w of uniqueWarnings) {
+        if (!params.headlessOutput) {
+            getLogger().warn(runtimeWarningMessage(w, { llmType, clientPackage }));
         }
     }
-    return { llm, warnings: Array.from(new Set(warnings)) };
+    return {
+        llm,
+        warnings: uniqueWarnings,
+        headlessWarnings: uniqueWarnings.map((w) => toHeadlessWarning(w, { llmType, clientPackage })),
+    };
 }
 //# sourceMappingURL=runtime-llm.js.map

package/dist/cli/commands/run/runtime-options.js

@@ -23,8 +23,8 @@ export async function resolveRunRuntimeOptions(params) {
     if (wantPartialMessages && !llmOutput.kinds.includes('plan')) {
         llmOutput.kinds.push('plan');
     }
-    const effectiveVerify = await resolveVerifyOption(params.repoPath, params.cliOptions.verify, params.resolvedConfig.verify.command);
-    const effectiveWorktreePrepare = await resolveWorktreePrepareOption(params.repoPath, params.cliOptions.checkpointStrategy, params.cliOptions.worktreePrepare);
+    const effectiveVerify = await resolveVerifyOption(params.repoPath, params.cliOptions.verify, params.resolvedConfig.verify.command, { quiet: params.headlessOutput });
+    const effectiveWorktreePrepare = await resolveWorktreePrepareOption(params.repoPath, params.cliOptions.checkpointStrategy, params.cliOptions.worktreePrepare, { quiet: params.headlessOutput });
     return { ok: true, llmOutput, effectiveVerify, effectiveWorktreePrepare };
 }
 //# sourceMappingURL=runtime-options.js.map

package/dist/cli/commands/run/validate-options.js

@@ -1,8 +1,3 @@
-export function resolveOutputFormat(raw) {
-    if (raw === 'text' || raw === 'stream-json' || raw === 'json')
-        return raw;
-    return undefined;
-}
 export function validateRunCommandOptions(params) {
     const { parsed } = params;
     if (parsed.explicitInstruction && parsed.printInstruction) {

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

@@ -1,12 +1,7 @@
 import { getLogger } from '../../../core/facades/cli-observability.js';
 import { text } from '../../locales/index.js';
-export function resolveVerboseLevel(raw) {
-    if (raw === true)
-        return 'basic';
-    if (typeof raw === 'string')
-        return raw;
-    return undefined;
-}
+import { resolveVerboseLevel } from '../../utils/verbose-level.js';
+export { resolveVerboseLevel };
 export function logRunVerboseSummary(params) {
     if (!params.verboseLevel)
         return;

package/dist/cli/commands/serve.js

@@ -1,8 +1,12 @@
-import { buildA2AAgentCard, buildSidecarRouteDescriptors, createAcpFormalAgent, createAgentServerRuntime, createInteractionFacade, createSalmonTaskExecutor, createTaskEventBus, createPluginRegistry, createPromptRegistry, defaultSidecarRouteCatalog, defaultPathAdapter, getSidecarListenOptions, getUserAcpSessionStorePath, GitSnapshotCheckpointService, getLogger, mkdir, PlainReporter, PluginLoader, resolveConfig, 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, 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 { resolveAuditScope } from '../utils/audit-scope.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';
 function parsePort(value, fallback) {
     if (value === undefined || value === null || value === '')
@@ -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
@@ -45,18 +70,27 @@ export function registerServeCommands(program) {
 }
 export async function handleServeCommand(_options, command) {
     const allOptions = command.optsWithGlobals();
-    const defaultRepoPath = defaultPathAdapter.resolve(allOptions.repo || process.cwd());
-    const resolvedConfig = await resolveConfig({ repoRoot: defaultRepoPath });
-    const serverConfig = resolvedConfig.server;
-    const auditScopeResolution = resolveAuditScope({
-        cliValue: allOptions.auditScope,
-        configValue: resolvedConfig.observability.audit.scope,
+    const configResult = await resolveCliConfig({
+        repo: allOptions.repo,
+        cwd: process.cwd(),
+        configPath: allOptions.config,
+        enableConfigFile: allOptions.configFile !== false,
+        auditScope: allOptions.auditScope,
+        logMode: allOptions.logMode,
     });
-    if (!auditScopeResolution.ok) {
-        getLogger().error(text.cli.invalidAuditScope(auditScopeResolution.invalid), true);
+    if (!configResult.ok) {
+        getLogger().error(configResult.message, true);
         process.exit(1);
     }
-    const auditScope = auditScopeResolution.value;
+    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');
     const rawA2aPort = allOptions.a2aPort ?? serverConfig?.a2a?.port;
@@ -69,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,20 +126,27 @@ export async function handleServeCommand(_options, command) {
     const executor = createSalmonTaskExecutor({
         runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, fileSystemOverride, }) => {
             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,
                 languagePlugins,
                 fileSystemOverride,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
@@ -154,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,
+            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,
@@ -189,47 +216,48 @@ 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();
-    const defaultRepoPath = defaultPathAdapter.resolve(allOptions.repo || process.cwd());
-    const resolvedConfig = await resolveConfig({ repoRoot: defaultRepoPath });
+    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;
+    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);
@@ -240,14 +268,6 @@ export async function handleServeAcpCommand(_options, command) {
         llmConfig: resolvedConfig.llm,
         langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
     });
-    const auditScopeResolution = resolveAuditScope({
-        cliValue: allOptions.auditScope,
-        configValue: resolvedConfig.observability.audit.scope,
-    });
-    if (!auditScopeResolution.ok) {
-        getLogger().error(text.cli.invalidAuditScope(auditScopeResolution.invalid), true);
-        process.exit(1);
-    }
     const outcomeReporter = createOutcomeReporter({
         enabled: resolvedConfig.observability.langfuse.outcome,
         endpoint: resolvedConfig.observability.langfuse.endpoint,
@@ -262,20 +282,27 @@ export async function handleServeAcpCommand(_options, command) {
     const executor = createSalmonTaskExecutor({
         runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, }) => {
             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: auditScopeResolution.value,
+                auditScope,
+                permissionMode,
                 languagePlugins,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
                 authorizationMode,
@@ -299,7 +326,8 @@ export async function handleServeAcpCommand(_options, command) {
     startAcpStdioServer((conn) => createAcpFormalAgent({
         conn,
         agentInfo: { name: 'salmon-loop', version: '0.2.0' },
-        defaultModeId: resolvedConfig.permissionMode,
+        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,
@@ -314,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));