salmon-loop 0.2.3 → 0.2.13

package/dist/cli/chat.js

@@ -266,6 +266,7 @@ export async function startChatMode(options) {
                     authorizationMode: 'deferred',
                     userInputProvider,
                     subAgentController,
+                    permissionMode: options.permissionMode,
                 });
                 return { kind: 'flow', mode: intentDecision.intent, result };
             })(), CHAT_QUEUE_CONFIG.TASK_TIMEOUT_MS, () => timeoutAbort.abort()).finally(() => {

package/dist/cli/commands/chat.js

@@ -1,13 +1,25 @@
-import { resolve } from 'path';
-import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveConfig, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
+import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
 import { text } from '../locales/index.js';
-import { resolveAuditScope } from '../utils/audit-scope.js';
 import { resolveLlmOutputPolicyFromCli } from '../utils/llm-output.js';
 import { createOutcomeReporter } from '../utils/outcome-reporter.js';
+import { resolveCliConfig } from '../utils/resolve-cli-config.js';
 import { resolveVerifyOption } from '../utils/verify-resolver.js';
 export async function handleChatCommand(options, command) {
     const allOptions = command.optsWithGlobals();
-    const runPath = resolve(allOptions.repo || process.cwd());
+    const configResult = await resolveCliConfig({
+        repo: allOptions.repo,
+        cwd: process.cwd(),
+        configPath: allOptions.config,
+        enableConfigFile: allOptions.configFile !== false,
+        auditScope: allOptions.auditScope,
+        verbose: allOptions.verbose,
+        logMode: allOptions.logMode,
+    });
+    if (!configResult.ok) {
+        getLogger().error(configResult.message, true);
+        process.exit(1);
+    }
+    const { resolvedConfig, auditScope, repoPath: runPath, verboseLevel } = configResult;
     const printInstruction = typeof allOptions.print === 'string'
         ? allOptions.print
         : undefined;
@@ -28,19 +40,6 @@ export async function handleChatCommand(options, command) {
     setPluginRegistry(languagePlugins);
     setPromptRegistry(createPromptRegistry());
     await PluginLoader.loadPlugins(languagePlugins, runPath);
-    const resolvedConfig = await resolveConfig({
-        repoRoot: runPath,
-        enableConfigFile: true,
-    });
-    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 auditScope = auditScopeResolution.value;
     const rawPermissionMode = allOptions.mode ?? resolvedConfig.permissionMode ?? 'interactive';
     const permissionMode = normalizePermissionMode(rawPermissionMode);
     if (!permissionMode) {
@@ -94,7 +93,7 @@ export async function handleChatCommand(options, command) {
                 : allOptions.checkpointStrategy || 'worktree',
             continue: continueSession,
             resumeSessionId,
-            verbose: allOptions.verbose,
+            verbose: verboseLevel,
             llmOutput,
             markdownTheme: resolvedConfig.markdownTheme,
             markdownRenderMode: resolvedConfig.markdownRenderMode,

package/dist/cli/commands/context.js

@@ -1,8 +1,21 @@
-import { createContextCacheStore, createDefaultPermissionGate, ContextService, defaultPathAdapter, getLogger, resolveConfig, setChurnRankingPolicy, } from '../../core/facades/cli-context.js';
+import { createContextCacheStore, createDefaultPermissionGate, ContextService, getLogger, setChurnRankingPolicy, } from '../../core/facades/cli-context.js';
 import { text } from '../locales/index.js';
+import { resolveCliConfig } from '../utils/resolve-cli-config.js';
 export async function handleContextCommand(options, command) {
     const allOptions = command.optsWithGlobals();
-    const repoPath = defaultPathAdapter.resolve(allOptions.repo || process.cwd());
+    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 } = configResult;
     if (options.file && options.selection) {
         getLogger().error(text.cli.fileSelectionConflict, true);
         process.exit(1);
@@ -26,7 +39,6 @@ export async function handleContextCommand(options, command) {
         }
         budgetChars = parsed;
     }
-    const resolvedConfig = await resolveConfig({ repoRoot: repoPath });
     setChurnRankingPolicy({
         primaryBoost: resolvedConfig.raw?.context?.churn?.weight?.primary,
         rerankWeight: resolvedConfig.raw?.context?.churn?.weight?.rerank,

package/dist/cli/commands/help-format.js

@@ -0,0 +1,12 @@
+export function formatHelpRows(items) {
+    const rows = items.map((item) => {
+        const aliases = item.aliases?.length ? ` (${item.aliases.join(', ')})` : '';
+        return {
+            label: `${item.name}${aliases}`,
+            description: item.description,
+        };
+    });
+    const maxName = Math.max(...rows.map((row) => row.label.length), 0);
+    return rows.map((row) => `${row.label}`.padEnd(maxName + 2) + row.description).join('\n');
+}
+//# sourceMappingURL=help-format.js.map

package/dist/cli/commands/registry.js

@@ -1,6 +1,8 @@
+import { text } from '../locales/index.js';
 import { allowlistCommand } from './allowlist.js';
 import { configCommand } from './config.js';
 import { exitCommand } from './exit.js';
+import { formatHelpRows } from './help-format.js';
 import { llmOutputCommand } from './llm-output.js';
 import { logModeCommand } from './log-mode.js';
 import { modeCommand } from './mode.js';
@@ -29,16 +31,11 @@ const baseCommands = [
         order: 80,
         execute: ({ emit }) => {
             const visible = commands.filter((c) => !c.hidden);
-            const maxName = Math.max(...visible.map((cmd) => cmd.name.length), 0);
-            const rows = visible.map((cmd) => {
-                const paddedName = `${cmd.name}`.padEnd(maxName + 2);
-                return `${paddedName}${cmd.description}`;
-            });
-            const helpMsg = rows.join('\n');
+            const helpMsg = formatHelpRows(visible);
             emit({
                 type: 'log',
                 level: 'info',
-                message: `Available Commands:\n${helpMsg}`,
+                message: text.cli.helpAvailableCommands(helpMsg),
                 timestamp: new Date(),
             });
         },

package/dist/cli/commands/run/config-resolution.js

@@ -1,37 +1,43 @@
-import { redactConfigForPrint, resolveConfig, ConfigError } from '../../../core/config/index.js';
+import { redactConfigForPrint } from '../../../core/config/index.js';
 import { getLogger } from '../../../core/facades/cli-observability.js';
-import { text } from '../../locales/index.js';
+import { resolveCliConfig } from '../../utils/resolve-cli-config.js';
 export async function resolveRunConfig(params) {
-    let resolvedConfig;
-    try {
-        resolvedConfig = await resolveConfig({
-            repoRoot: params.repoPath,
-            configFilePath: params.cliOptions.config,
-            enableConfigFile: params.cliOptions.configFile !== false,
-        });
-    }
-    catch (err) {
-        if (err instanceof ConfigError) {
-            const msg = text.config.error(err.code || err.message, err.details);
-            getLogger().error(msg);
-            if (params.outputFormat === 'json') {
-                params.writeJsonFailure({ message: msg, errorCode: err.code, repoPath: params.repoPath });
-            }
-            return { ok: false, exitCode: 1 };
-        }
-        const msg = err instanceof Error ? err.message : String(err);
-        getLogger().error(text.config.loadFailed(msg));
+    const resolved = await resolveCliConfig({
+        repoPath: params.repoPath,
+        configPath: params.cliOptions.config,
+        enableConfigFile: params.cliOptions.configFile !== false,
+        auditScope: params.cliOptions.auditScope,
+        verbose: params.cliOptions.verbose,
+        outputFormat: params.cliOptions.outputFormat,
+        logMode: params.cliOptions.logMode,
+    });
+    if (!resolved.ok) {
+        getLogger().error(resolved.message);
         if (params.outputFormat === 'json') {
-            params.writeJsonFailure({ message: text.config.loadFailed(msg), repoPath: params.repoPath });
+            params.writeJsonFailure({
+                message: resolved.message,
+                errorCode: resolved.errorCode,
+                repoPath: params.repoPath,
+            });
         }
         return { ok: false, exitCode: 1 };
     }
     if (params.cliOptions.printConfig) {
-        const raw = resolvedConfig.raw || { version: 1 };
+        const raw = resolved.resolvedConfig.raw || { version: 1 };
         const redacted = redactConfigForPrint(raw);
         process.stdout.write(JSON.stringify(redacted, null, 2) + '\n');
         return { ok: true, printedConfig: true };
     }
-    return { ok: true, resolvedConfig };
+    return {
+        ok: true,
+        resolvedConfig: {
+            repoPath: resolved.repoPath,
+            verboseLevel: resolved.verboseLevel,
+            outputFormat: resolved.outputFormat,
+            headlessOutput: resolved.headlessOutput,
+            resolvedConfig: resolved.resolvedConfig,
+            auditScope: resolved.auditScope,
+        },
+    };
 }
 //# sourceMappingURL=config-resolution.js.map

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

@@ -3,8 +3,9 @@ import { buildSessionConversationContext, createPluginRegistry, createPromptRegi
 import { createStdoutWriter } from '../../headless/stdout-writer.js';
 import { text } from '../../locales/index.js';
 import { StderrLogReporter } from '../../reporters/stderr-log-reporter.js';
-import { resolveAuditScope } from '../../utils/audit-scope.js';
 import { createOutcomeReporter } from '../../utils/outcome-reporter.js';
+import { resolveOutputFormat } from '../../utils/output-format.js';
+import { resolveCliCommonOptions } from '../../utils/resolve-cli-config.js';
 import { buildRunAssistantMessage } from './assistant-message.js';
 import { resolveRunConfig } from './config-resolution.js';
 import { handleEarlyRunCommandErrors } from './early-errors.js';
@@ -22,7 +23,7 @@ import { createRuntimeLlmAndWarn } from './runtime-llm.js';
 import { resolveRunRuntimeOptions } from './runtime-options.js';
 import { initializeSession } from './session.js';
 import { buildStructuredOutputState } from './structured-output.js';
-import { logRunVerboseSummary, resolveVerboseLevel } from './verbose.js';
+import { logRunVerboseSummary } from './verbose.js';
 export async function handleRunCommand(options, command) {
     const parsed = parseRunCommandOptions(command);
     const allOptions = parsed.allOptions;
@@ -36,13 +37,20 @@ export async function handleRunCommand(options, command) {
     const explicitInstruction = parsed.explicitInstruction;
     const jsonSchemaSpec = parsed.jsonSchemaSpec;
     const rawOutputFormat = parsed.rawOutputFormat;
-    if (rawOutputFormat !== 'text' &&
-        rawOutputFormat !== 'stream-json' &&
-        rawOutputFormat !== 'json') {
+    const commonOptions = resolveCliCommonOptions({
+        repoPath: runPath,
+        verbose: allOptions.verbose,
+        outputFormat: rawOutputFormat,
+    });
+    if (!commonOptions.ok) {
+        getLogger().error(commonOptions.message, true);
+        process.exit(1);
+    }
+    const outputFormat = commonOptions.options.outputFormat ?? resolveOutputFormat(rawOutputFormat);
+    if (!outputFormat) {
         getLogger().error(text.cli.invalidOutputFormat(rawOutputFormat), true);
         process.exit(1);
     }
-    const outputFormat = rawOutputFormat;
     const headlessOutput = outputFormat !== 'text';
     const rawOutputProfile = parsed.rawOutputProfile;
     const outputProfileForStreamJson = parsed.outputProfileForStreamJson;
@@ -167,7 +175,7 @@ export async function handleRunCommand(options, command) {
     }
     if ('printedConfig' in configResult)
         return;
-    const resolvedConfig = configResult.resolvedConfig;
+    const { resolvedConfig, auditScope } = configResult.resolvedConfig;
     const runtimeOptions = await resolveRunRuntimeOptions({
         repoPath: runPath,
         resolvedConfig,
@@ -253,7 +261,7 @@ export async function handleRunCommand(options, command) {
     if (!effectiveVerify) {
         getLogger().warn(text.verify.noCommandFound);
     }
-    const verboseLevel = resolveVerboseLevel(allOptions.verbose);
+    const verboseLevel = commonOptions.options.verboseLevel;
     logRunVerboseSummary({
         verboseLevel,
         instruction: instructionText,
@@ -267,15 +275,6 @@ export async function handleRunCommand(options, command) {
         configPath: resolvedConfig.source.used ? resolvedConfig.source.path || '' : undefined,
     });
     try {
-        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 auditScope = auditScopeResolution.value;
         const { llm } = createRuntimeLlmAndWarn({
             llmConfig: resolvedConfig.llm,
             langfuseEnabled: resolvedConfig.observability.langfuse.enabled,

package/dist/cli/commands/run/loop-params.js

@@ -30,6 +30,7 @@ export function buildRunLoopParams(params) {
             forceNonInteractive: params.headlessOutput || params.printMode,
             permissionMode: params.permissionMode,
         }),
+        permissionMode: params.permissionMode,
         extensions: params.extensions,
         permissionRules: params.permissionRules,
         eventPayload: params.headlessIncludeToolInput ||

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

@@ -1,4 +1,4 @@
-import { resolve } from 'path';
+import { resolveRepoPath } from '../../utils/resolve-cli-config.js';
 function splitToolRules(raw) {
     const parts = [];
     const push = (s) => {
@@ -20,7 +20,7 @@ function splitToolRules(raw) {
 }
 export function parseRunCommandOptions(command) {
     const allOptions = command.optsWithGlobals();
-    const repoPath = resolve(allOptions.repo || process.cwd());
+    const repoPath = resolveRepoPath({ repo: allOptions.repo, cwd: process.cwd() });
     const continueSession = Boolean(allOptions.continue);
     const resumeSessionId = typeof allOptions.resume === 'string'
         ? allOptions.resume

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,8 @@
-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 { 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 { createTerminalAuthorizationProvider } from '../authorization/provider.js';
 import { text } from '../locales/index.js';
-import { resolveAuditScope } from '../utils/audit-scope.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 === '')
@@ -45,18 +45,20 @@ 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 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;
@@ -113,6 +115,7 @@ export async function handleServeCommand(_options, command) {
                 langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
                 langfuseUserId: resolvedConfig.observability.langfuse.userId,
                 auditScope,
+                permissionMode: resolvedConfig.permissionMode,
                 languagePlugins,
                 fileSystemOverride,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
@@ -228,8 +231,19 @@ export async function handleServeCommand(_options, command) {
 }
 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;
     getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
     const languagePlugins = createPluginRegistry();
     setPluginRegistry(languagePlugins);
@@ -240,14 +254,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,
@@ -275,7 +281,8 @@ export async function handleServeAcpCommand(_options, command) {
                 outcomeReporter,
                 langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
                 langfuseUserId: resolvedConfig.observability.langfuse.userId,
-                auditScope: auditScopeResolution.value,
+                auditScope,
+                permissionMode: resolvedConfig.permissionMode,
                 languagePlugins,
                 authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
                 authorizationMode,

package/dist/cli/locales/en.js

@@ -35,6 +35,7 @@ export const en = {
     chatAnswerEmpty: 'No answer produced.',
     unknownCommand: (cmd) => `Unknown command: ${cmd}. Type /help for available commands.`,
     helpAvailableCommands: (rows) => `Available Commands:\n${rows}`,
+    programHelpFooter: '\nTips:\n  Use "s8p <command> --help" to see command-specific options.\n  In chat, type /help to list slash commands.',
     slashHandlerUnavailable: 'Command handler unavailable',
     slashInternalError: 'Internal error',
     skillNoPrompt: (id) => `Skill ${id} did not produce a prompt`,
@@ -234,6 +235,7 @@ export const en = {
     preflightPolicyOption: 'Preflight policy (lenient: continue on test failure, strict: fail on test failure)',
     checkpointStrategyOption: 'Checkpoint strategy to use (direct, worktree)',
     permissionModeOption: 'Permission mode (interactive, yolo)',
+    logModeOption: 'UI log mode (quiet, normal, debug)',
     environmentModeOption: 'Worktree environment mode (strict, parity)',
     applyBackOnDirtyOption: 'Behavior when apply-back detects a dirty workspace (3way, abort)',
     worktreePrepareOption: 'Optional setup command to run inside worktree',

package/dist/cli/program-bootstrap.js

@@ -8,7 +8,12 @@ export function bootstrapProgram() {
     chalk.level = 3;
     const program = new Command();
     program.exitOverride();
-    program.name('s8p').alias('salmonloop').description(text.cli.programDescription).version('0.2.0');
+    program
+        .name('s8p')
+        .alias('salmonloop')
+        .description(text.cli.programDescription)
+        .version('0.2.0')
+        .addHelpText('after', text.cli.programHelpFooter);
     return program;
 }
 //# sourceMappingURL=program-bootstrap.js.map

package/dist/cli/program-commands.js

@@ -90,6 +90,8 @@ export function registerProgramCommands(program) {
         .command('context')
         .description(text.cli.contextDescription)
         .option('-i, --instruction <instruction>', text.cli.instructionOption)
+        .option('--config <path>', text.cli.configOption)
+        .option('--no-config-file', text.cli.noConfigFileOption)
         .option('-f, --file <path>', text.cli.fileOption)
         .option('-s, --selection <text>', text.cli.selectionOption)
         .option('--diff-scope <scope>', text.cli.contextDiffScopeOption, 'primary')
@@ -100,6 +102,8 @@ export function registerProgramCommands(program) {
     program
         .command('chat', { isDefault: true })
         .description('Enter interactive chat mode (default)')
+        .option('--config <path>', text.cli.configOption)
+        .option('--no-config-file', text.cli.noConfigFileOption)
         .option('--verbose [level]', text.cli.verboseOption)
         .action(handleChatCommand);
 }

package/dist/cli/program-options.js

@@ -7,6 +7,7 @@ export function configureGlobalProgramOptions(program) {
         .option('--resume <sessionId>', text.cli.resumeOption)
         .option('-v, --verify <command>', text.cli.verifyOption)
         .option('--no-verify', 'Disable verification')
+        .option('--log-mode <mode>', text.cli.logModeOption)
         .option('-cs, --checkpoint-strategy <type>', text.cli.checkpointStrategyOption, 'worktree')
         .option('--mode <mode>', text.cli.permissionModeOption, 'interactive')
         .option('--llm-output <kinds>', text.cli.llmOutputOption)

package/dist/cli/slash/runtime.js

@@ -1,4 +1,5 @@
 import { createSlashRegistry, createStandardToolstack, executeSkill, logIgnoredError, getLogger, RuntimeEnvironment, SkillLoader, SlashRouter, } from '../../core/facades/cli-slash-runtime.js';
+import { formatHelpRows } from '../commands/help-format.js';
 import { suggestSubcommands } from '../commands/subcommand-suggestions.js';
 import { text } from '../locales/index.js';
 function isSafeSkillId(id) {
@@ -63,12 +64,11 @@ export async function createCliSlashRuntime(options) {
                 const handler = {
                     execute: async (_req) => {
                         const visible = registry.list().filter((c) => !c.hidden);
-                        const maxName = Math.max(...visible.map((c) => c.name.length), 0);
-                        const rows = visible.map((c) => `${c.name}`.padEnd(maxName + 2) + c.description);
+                        const rows = formatHelpRows(visible);
                         options.emit({
                             type: 'log',
                             level: 'info',
-                            message: text.cli.helpAvailableCommands(rows.join('\n')),
+                            message: text.cli.helpAvailableCommands(rows),
                             timestamp: new Date(),
                         });
                         return { kind: 'consumed' };

package/dist/cli/utils/output-format.js

@@ -0,0 +1,6 @@
+export function resolveOutputFormat(raw) {
+    if (raw === 'text' || raw === 'stream-json' || raw === 'json')
+        return raw;
+    return undefined;
+}
+//# sourceMappingURL=output-format.js.map

package/dist/cli/utils/resolve-cli-config.js

@@ -0,0 +1,98 @@
+import { defaultPathAdapter } from '../../core/adapters/path/path-adapter.js';
+import { ConfigError, normalizeUiLogMode, resolveConfig } from '../../core/config/index.js';
+import { text } from '../locales/index.js';
+import { resolveAuditScope } from './audit-scope.js';
+import { resolveOutputFormat } from './output-format.js';
+import { resolveVerboseLevel } from './verbose-level.js';
+export async function resolveCliConfig(params) {
+    const common = resolveCliCommonOptions({
+        repoPath: params.repoPath,
+        repo: params.repo,
+        cwd: params.cwd,
+        verbose: params.verbose,
+        outputFormat: params.outputFormat,
+    });
+    if (!common.ok) {
+        return { ok: false, message: common.message };
+    }
+    const { repoPath, verboseLevel, outputFormat, headlessOutput } = common.options;
+    let resolvedConfig;
+    try {
+        resolvedConfig = await resolveConfig({
+            repoRoot: repoPath,
+            configFilePath: params.configPath,
+            enableConfigFile: params.enableConfigFile !== false,
+        });
+    }
+    catch (err) {
+        if (err instanceof ConfigError) {
+            return {
+                ok: false,
+                message: text.config.error(err.code || err.message, err.details),
+                errorCode: err.code,
+            };
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, message: text.config.loadFailed(msg) };
+    }
+    const auditScopeResolution = resolveAuditScope({
+        cliValue: params.auditScope,
+        configValue: resolvedConfig.observability.audit.scope,
+    });
+    if (!auditScopeResolution.ok) {
+        return {
+            ok: false,
+            message: text.cli.invalidAuditScope(auditScopeResolution.invalid),
+        };
+    }
+    if (params.logMode !== undefined) {
+        const normalized = normalizeUiLogMode(params.logMode);
+        if (!normalized) {
+            return { ok: false, message: text.cli.logModeInvalid(String(params.logMode)) };
+        }
+        resolvedConfig = {
+            ...resolvedConfig,
+            ui: {
+                ...resolvedConfig.ui,
+                logMode: normalized,
+            },
+        };
+    }
+    return {
+        ok: true,
+        repoPath,
+        verboseLevel,
+        outputFormat,
+        headlessOutput,
+        resolvedConfig,
+        auditScope: auditScopeResolution.value,
+    };
+}
+export function resolveRepoPath(params) {
+    return defaultPathAdapter.resolve(params.repo || params.cwd || process.cwd());
+}
+export function resolveCliCommonOptions(params) {
+    const repoPath = params.repoPath ?? resolveRepoPath({ repo: params.repo, cwd: params.cwd });
+    const verboseLevel = resolveVerboseLevel(params.verbose);
+    let outputFormat;
+    let headlessOutput;
+    if (params.outputFormat !== undefined) {
+        const raw = String(params.outputFormat || '');
+        const resolved = resolveOutputFormat(raw);
+        if (!resolved) {
+            return { ok: false, message: text.cli.invalidOutputFormat(raw) };
+        }
+        outputFormat = resolved;
+        headlessOutput = resolved !== 'text';
+    }
+    return {
+        ok: true,
+        options: {
+            repoPath,
+            verboseLevel,
+            outputFormat,
+            headlessOutput,
+        },
+    };
+}
+//# sourceMappingURL=resolve-cli-config.js.map

package/dist/cli/utils/verbose-level.js

@@ -0,0 +1,8 @@
+export function resolveVerboseLevel(raw) {
+    if (raw === true)
+        return 'basic';
+    if (typeof raw === 'string')
+        return raw;
+    return undefined;
+}
+//# sourceMappingURL=verbose-level.js.map