salmon-loop 0.3.2 → 0.5.0

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

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import { z } from 'zod';
 import { getLogger, McpConnectionManager, } from '../../core/facades/cli-authorization-non-interactive.js';
+import { isRecord } from '../../core/facades/cli-utils-serialize.js';
 import { text } from '../locales/index.js';
 const DecisionSchema = z
     .object({
@@ -22,24 +23,19 @@ function findMcpServer(extensions, name) {
     return extensions.mcpServers.find((s) => s.enabled && s.name === name);
 }
 function extractDecisionPayloadFromMcpResult(result) {
-    if (!result || typeof result !== 'object')
+    if (!isRecord(result))
         return result;
-    const obj = result;
-    if (obj.decision && typeof obj.decision === 'object')
-        return obj.decision;
-    if (typeof obj.outcome === 'string')
-        return obj;
-    const content = obj.content;
+    if (isRecord(result.decision))
+        return result.decision;
+    if (typeof result.outcome === 'string')
+        return result;
+    const content = result.content;
     if (!Array.isArray(content))
         return result;
     for (const item of content) {
-        if (!item || typeof item !== 'object')
+        if (!isRecord(item))
             continue;
-        const candidate = item.json ??
-            item.text ??
-            item.value ??
-            item.data ??
-            undefined;
+        const candidate = item.json ?? item.text ?? item.value ?? item.data ?? undefined;
         if (typeof candidate === 'string' && candidate.trim()) {
             try {
                 return JSON.parse(candidate);

package/dist/cli/authorization/provider.js

@@ -1,6 +1,5 @@
 import { createInterface } from 'readline/promises';
-import { getLogger } from '../../core/facades/cli-authorization-provider.js';
-import { TOOL_AUTH_CONFIG } from '../config.js';
+import { DEFAULT_TOOL_AUTH, getLogger } from '../../core/facades/cli-authorization-provider.js';
 import { text } from '../locales/index.js';
 import { getPendingAuthorization, requestAuthorization } from '../ui/authorization/bus.js';
 import { loadAllowlistDecision, persistAllowlistDecision } from './allowlist.js';
@@ -27,14 +26,7 @@ const shouldAutoAllow = (request, config) => {
 const resolveConfig = (config) => {
     if (config)
         return config;
-    return {
-        sessionTtlMs: TOOL_AUTH_CONFIG.SESSION_TTL_MS,
-        autoAllowRisk: TOOL_AUTH_CONFIG.AUTO_ALLOW_RISK,
-        allowlist: {
-            repoFile: '.salmonloop/config/authorization.json',
-            userFile: '~/.salmonloop/config/authorization-user.json',
-        },
-    };
+    return DEFAULT_TOOL_AUTH;
 };
 export function createUiAuthorizationProvider(options) {
     const pending = new Map();

package/dist/cli/chat.js

@@ -1,5 +1,6 @@
 import { buildSessionArtifactStateFromLoopResult, buildEffectiveConversationContext, ChatSessionManager, DEFAULT_LLM_OUTPUT_POLICY, emitLlmOutput, getDefaultSessionContextBudgetTokens, InputHistoryManager, logIgnoredError, getLogger, refreshSessionSummary, runSalmonLoop, TokenTracker, createInitialTracking, onNormalTurnComplete, runCompactionPipeline, reactiveCompact, } from '../core/facades/cli-chat.js';
 import { createSubAgentController } from '../core/facades/cli-subagent.js';
+import { isRecord } from '../core/facades/cli-utils-serialize.js';
 import { createUiAuthorizationProvider } from './authorization/provider.js';
 import { resolveActiveChatFlowMode, resolveChatCheckpointStrategy } from './chat-flow.js';
 import { commands } from './commands/registry.js';
@@ -66,8 +67,9 @@ export async function startChatMode(options) {
             const answers = {};
             for (const question of input.questions) {
                 if (requestOptions?.signal?.aborted) {
-                    const err = new Error(text.cli.askUserCancelled);
-                    err.code = 'ASK_USER_CANCELLED';
+                    const err = Object.assign(new Error(text.cli.askUserCancelled), {
+                        code: 'ASK_USER_CANCELLED',
+                    });
                     throw err;
                 }
                 const items = question.options.map((opt) => ({
@@ -84,8 +86,9 @@ export async function startChatMode(options) {
                     multiSelect: question.multiSelect,
                 });
                 if (!selected || selected.length === 0) {
-                    const err = new Error(text.cli.askUserCancelled);
-                    err.code = 'ASK_USER_CANCELLED';
+                    const err = Object.assign(new Error(text.cli.askUserCancelled), {
+                        code: 'ASK_USER_CANCELLED',
+                    });
                     throw err;
                 }
                 const answer = question.multiSelect ? selected.join(', ') : (selected[0] ?? '');
@@ -299,6 +302,7 @@ export async function startChatMode(options) {
                     authorizationMode: 'deferred',
                     userInputProvider,
                     subAgentController,
+                    llmFactory: options.llmFactory,
                     permissionMode: options.permissionMode,
                 }).catch(async (error) => {
                     // Level 2: Reactive Compact
@@ -307,13 +311,14 @@ export async function startChatMode(options) {
                     const isContextOverflow = (() => {
                         if (!error || typeof error !== 'object')
                             return false;
-                        if ('llmCode' in error &&
+                        if (isRecord(error) &&
+                            'llmCode' in error &&
                             error.llmCode === 'LLM_CONTEXT_LENGTH_EXCEEDED') {
                             return true;
                         }
                         const message = error instanceof Error
                             ? error.message
-                            : typeof error.message === 'string'
+                            : isRecord(error) && typeof error.message === 'string'
                                 ? String(error.message)
                                 : '';
                         const lower = message.toLowerCase();
@@ -382,6 +387,7 @@ export async function startChatMode(options) {
                         authorizationMode: 'deferred',
                         userInputProvider,
                         subAgentController,
+                        llmFactory: options.llmFactory,
                         permissionMode: options.permissionMode,
                     });
                 });

package/dist/cli/commands/allowlist.js

@@ -1,4 +1,4 @@
-import { EXECUTION_PHASES, getLogger } from '../../core/facades/cli-command-allowlist.js';
+import { EXECUTION_PHASES, getLogger, } from '../../core/facades/cli-command-allowlist.js';
 import { clearAllowlist, clearAllowlistCache, listAllowlist, persistAllowlistDecision, removeAllowlistRule, } from '../authorization/allowlist.js';
 import { text } from '../locales/index.js';
 import { clearKnownToolNames, getKnownToolNames, getKnownToolNamesSync, validateSideEffects, } from './tool-names.js';

package/dist/cli/commands/chat.js

@@ -1,4 +1,4 @@
-import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveExecutionProfile, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
+import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, createSubAgentLlmFactory, getString, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveExecutionProfile, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
 import { text } from '../locales/index.js';
 import { getOptionValueSourceWithGlobalFallback } from '../utils/command-option-source.js';
 import { resolveLlmOutputPolicyFromCli } from '../utils/llm-output.js';
@@ -8,26 +8,22 @@ import { resolveVerifyOption } from '../utils/verify-resolver.js';
 export async function handleChatCommand(options, command) {
     const allOptions = command.optsWithGlobals();
     const configResult = await resolveCliConfig({
-        repo: allOptions.repo,
+        repo: getString(allOptions, 'repo') ?? undefined,
         cwd: process.cwd(),
-        configPath: allOptions.config,
+        configPath: getString(allOptions, 'config') ?? undefined,
         enableConfigFile: allOptions.configFile !== false,
-        auditScope: allOptions.auditScope,
+        auditScope: getString(allOptions, 'auditScope') ?? undefined,
         verbose: allOptions.verbose,
-        logMode: allOptions.logMode,
+        logMode: getString(allOptions, 'logMode') ?? undefined,
     });
     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;
+    const printInstruction = getString(allOptions, 'print') ?? undefined;
     const continueSession = Boolean(allOptions.continue);
-    const resumeSessionId = typeof allOptions.resume === 'string'
-        ? allOptions.resume
-        : undefined;
+    const resumeSessionId = getString(allOptions, 'resume') ?? undefined;
     if (printInstruction) {
         getLogger().error(text.cli.printCommandConflict('chat'), true);
         process.exit(1);
@@ -54,7 +50,7 @@ export async function handleChatCommand(options, command) {
         getLogger().error(`Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`);
         process.exit(1);
     }
-    const llmOutputResolution = resolveLlmOutputPolicyFromCli(resolvedConfig.llmOutput, allOptions.llmOutput);
+    const llmOutputResolution = resolveLlmOutputPolicyFromCli(resolvedConfig.llmOutput, getString(allOptions, 'llmOutput') ?? undefined);
     if (!llmOutputResolution.ok) {
         getLogger().error(text.cli.invalidLlmOutputKind(llmOutputResolution.invalid), true);
         process.exitCode = 1;
@@ -64,6 +60,7 @@ export async function handleChatCommand(options, command) {
     const { llm } = createRuntimeLlm(resolvedConfig.llm, {
         langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
     });
+    const llmFactory = createSubAgentLlmFactory(resolvedConfig.llm);
     const outcomeReporter = createOutcomeReporter({
         enabled: resolvedConfig.observability.langfuse.outcome,
         endpoint: resolvedConfig.observability.langfuse.endpoint,
@@ -71,7 +68,9 @@ export async function handleChatCommand(options, command) {
         langfuseApiKey: resolvedConfig.observability.langfuse.apiKey,
     });
     // Smart verification resolution with auto-detection
-    const verifyCommand = await resolveVerifyOption(runPath, allOptions.verify, resolvedConfig.verify.command);
+    const verifyRaw = allOptions.verify;
+    const verifyCliOption = typeof verifyRaw === 'string' || typeof verifyRaw === 'boolean' ? verifyRaw : undefined;
+    const verifyCommand = await resolveVerifyOption(runPath, verifyCliOption, resolvedConfig.verify.command);
     // Verification is now optional - the loop will skip if undefined
     if (!verifyCommand) {
         getLogger().warn(text.verify.noCommandFound);
@@ -115,6 +114,7 @@ export async function handleChatCommand(options, command) {
             langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
             langfuseUserId: resolvedConfig.observability.langfuse.userId,
             languagePlugins,
+            llmFactory,
         });
     }
     catch (err) {

package/dist/cli/commands/config.js

@@ -169,9 +169,9 @@ const permissionModeSubcommand = {
     usage: text.cli.configPermissionModeUsage,
     getSuggestions: (ctx) => modeCommand.getSuggestions?.({
         ...ctx,
-        input: delegateInputToCommand(ctx.input, '/mode'),
+        input: delegateInputToCommand(ctx.input, '/permission-mode'),
     }) ?? [],
-    execute: async (ctx) => modeCommand.execute({ ...ctx, input: delegateInputToCommand(ctx.input, '/mode') }),
+    execute: async (ctx) => modeCommand.execute({ ...ctx, input: delegateInputToCommand(ctx.input, '/permission-mode') }),
 };
 const outputSubcommand = {
     name: 'output',

package/dist/cli/commands/mode.js

@@ -41,8 +41,8 @@ async function persistPermissionMode(repoRoot, mode) {
     return configPath;
 }
 export const modeCommand = {
-    name: '/mode',
-    aliases: ['/permission-mode', '/perm-mode'],
+    name: '/permission-mode',
+    aliases: ['/mode', '/perm-mode'],
     description: text.cli.commandMode,
     order: 53,
     getSuggestions: ({ input }) => {

package/dist/cli/commands/parallel.js

@@ -198,7 +198,7 @@ export const parallelCommand = {
                 });
                 try {
                     const scheduler = new ParallelScheduler(toolstack.router, new InMemoryLockManager());
-                    const phase = state.runtime?.phase || 'PATCH';
+                    const phase = state.runtime?.phase ?? 'PATCH';
                     const runtime = {
                         repoRoot: workspace.workPath,
                         worktreeRoot: workspace.workPath,

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

@@ -1,5 +1,5 @@
 import { randomUUID } from 'crypto';
-import { buildEffectiveConversationContext, createPluginRegistry, createPromptRegistry, getExitCode, getDefaultSessionContextBudgetTokens, getLogger, normalizePermissionMode, resolveExecutionProfile, SilentReporter, setPluginRegistry, setPromptRegistry, } from '../../../core/facades/cli-run-handler.js';
+import { buildEffectiveConversationContext, createPluginRegistry, createPromptRegistry, createSubAgentLlmFactory, getExitCode, getDefaultSessionContextBudgetTokens, getLogger, normalizePermissionMode, resolveExecutionProfile, SilentReporter, setPluginRegistry, setPromptRegistry, } from '../../../core/facades/cli-run-handler.js';
 import { createStdoutWriter } from '../../headless/stdout-writer.js';
 import { text } from '../../locales/index.js';
 import { getOptionValueSourceWithGlobalFallback } from '../../utils/command-option-source.js';
@@ -201,6 +201,7 @@ export async function handleRunCommand(options, command) {
     const llmOutput = runtimeOptions.llmOutput;
     const effectiveVerify = runtimeOptions.effectiveVerify;
     const effectiveWorktreePrepare = runtimeOptions.effectiveWorktreePrepare;
+    const verifyPolicyOverride = runtimeOptions.verifyPolicyOverride;
     const instructionGuard = ensureInstructionOrExit({
         command,
         instruction,
@@ -303,7 +304,7 @@ export async function handleRunCommand(options, command) {
     }
     const extensionResolution = extensionsResult.extensionResolution;
     const operationalHeadlessWarnings = [];
-    if (!effectiveVerify) {
+    if (!effectiveVerify && !verifyPolicyOverride) {
         if (!headlessOutput) {
             getLogger().warn(text.verify.noCommandFound);
         }
@@ -338,6 +339,7 @@ export async function handleRunCommand(options, command) {
             langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
             headlessOutput,
         });
+        const llmFactory = createSubAgentLlmFactory(resolvedConfig.llm);
         let structuredOutputState = { ok: true, candidate: null };
         const reporter = createRunReporter({
             useGui,
@@ -398,6 +400,7 @@ export async function handleRunCommand(options, command) {
         const loopParams = buildRunLoopParams({
             instruction: instructionText,
             verify: effectiveVerify,
+            verifyPolicy: verifyPolicyOverride,
             repoPath: runPath,
             llm,
             languagePlugins,
@@ -435,6 +438,7 @@ export async function handleRunCommand(options, command) {
                 ? { allow: allowedToolRules, deny: disallowedToolRules }
                 : undefined,
             permissionMode,
+            llmFactory,
         });
         const buildAssistantMessage = (result) => buildRunAssistantMessage({ mode, result });
         const result = await executeRunLoop({
@@ -504,8 +508,9 @@ export async function handleRunCommand(options, command) {
             rawOutputProfile !== 'openai' &&
             activeReporterStarted &&
             activeReporter) {
-            const error = new Error(text.cli.unexpectedError(msg));
-            error.auditPath = lastKnownAuditPath;
+            const error = Object.assign(new Error(text.cli.unexpectedError(msg)), {
+                auditPath: lastKnownAuditPath,
+            });
             activeReporter.onError(error);
         }
         else if (outputFormat === 'stream-json') {

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

@@ -3,6 +3,7 @@ export function buildRunLoopParams(params) {
     return {
         instruction: params.instruction,
         verify: params.verify,
+        verifyPolicy: params.verifyPolicy,
         repoPath: params.repoPath,
         llm: params.llm,
         conversationContext: params.conversationContext,
@@ -35,6 +36,7 @@ export function buildRunLoopParams(params) {
         permissionMode: params.permissionMode,
         extensions: params.extensions,
         permissionRules: params.permissionRules,
+        llmFactory: params.llmFactory,
         eventPayload: params.headlessIncludeToolInput ||
             params.headlessIncludeToolOutput ||
             params.headlessIncludeAuthorizationDecisions

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

@@ -1,3 +1,4 @@
+import { getString } from '../../../core/utils/serialize.js';
 import { resolveRepoPath } from '../../utils/resolve-cli-config.js';
 function splitToolRules(raw) {
     const parts = [];
@@ -20,39 +21,26 @@ function splitToolRules(raw) {
 }
 export function parseRunCommandOptions(command) {
     const allOptions = command.optsWithGlobals();
-    const repoPath = resolveRepoPath({ repo: allOptions.repo, cwd: process.cwd() });
+    const repoPath = resolveRepoPath({
+        repo: getString(allOptions, 'repo') ?? undefined,
+        cwd: process.cwd(),
+    });
     const continueSession = Boolean(allOptions.continue);
-    const resumeSessionId = typeof allOptions.resume === 'string'
-        ? allOptions.resume
-        : undefined;
-    const printInstruction = typeof allOptions.print === 'string'
-        ? allOptions.print
-        : undefined;
-    const explicitInstruction = typeof allOptions.instruction === 'string' ? allOptions.instruction : undefined;
-    const jsonSchemaSpec = typeof allOptions.jsonSchema === 'string'
-        ? allOptions.jsonSchema
-        : undefined;
+    const resumeSessionId = getString(allOptions, 'resume') ?? undefined;
+    const printInstruction = getString(allOptions, 'print') ?? undefined;
+    const explicitInstruction = getString(allOptions, 'instruction') ?? undefined;
+    const jsonSchemaSpec = getString(allOptions, 'jsonSchema') ?? undefined;
     const rawOutputFormat = String(allOptions.outputFormat || 'text');
-    const rawOutputProfile = typeof allOptions.outputProfile === 'string'
-        ? String(allOptions.outputProfile)
-        : undefined;
+    const rawOutputProfile = getString(allOptions, 'outputProfile') ?? undefined;
     const outputProfileForStreamJson = rawOutputProfile ?? 'native';
     const headlessIncludeToolInput = Boolean(allOptions.headlessIncludeToolInput);
     const headlessIncludeToolOutput = Boolean(allOptions.headlessIncludeToolOutput);
     const headlessIncludeAuthorizationDecisions = Boolean(allOptions.headlessIncludeAuthorizationDecisions);
     const allowOutsideCacheRoot = Boolean(allOptions.allowOutsideCacheRoot);
-    const exportPatchPath = typeof allOptions.exportPatch === 'string'
-        ? allOptions.exportPatch
-        : undefined;
-    const sweBenchInstanceId = typeof allOptions.sweBenchInstanceId === 'string'
-        ? allOptions.sweBenchInstanceId
-        : undefined;
-    const sweBenchModelName = typeof allOptions.sweBenchModelName === 'string'
-        ? allOptions.sweBenchModelName
-        : undefined;
-    const sweBenchPredictionsPath = typeof allOptions.sweBenchPredictions === 'string'
-        ? allOptions.sweBenchPredictions
-        : undefined;
+    const exportPatchPath = getString(allOptions, 'exportPatch') ?? undefined;
+    const sweBenchInstanceId = getString(allOptions, 'sweBenchInstanceId') ?? undefined;
+    const sweBenchModelName = getString(allOptions, 'sweBenchModelName') ?? undefined;
+    const sweBenchPredictionsPath = getString(allOptions, 'sweBenchPredictions') ?? undefined;
     const instruction = explicitInstruction ?? printInstruction;
     const allowedToolRules = splitToolRules(allOptions.allowedTools);
     const disallowedToolRules = splitToolRules(allOptions.disallowedTools);

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

@@ -41,24 +41,27 @@ export function createRuntimeLlmAndWarn(params) {
                 continue;
             if (!target || typeof target !== 'object')
                 continue;
+            const phaseTarget = target;
             const perPhaseConfig = {
-                id: target.id,
-                type: target.type,
-                clientPackage: target.clientPackage,
+                id: phaseTarget.id,
+                type: phaseTarget.type,
+                clientPackage: phaseTarget.clientPackage,
                 api: {
-                    baseUrl: target.api?.baseUrl,
-                    timeoutMs: target.api?.timeoutMs,
-                    headers: target.api?.headers,
-                    apiKey: target.api?.apiKey,
-                    apiKeySource: target.api?.apiKeySource,
+                    baseUrl: phaseTarget.api?.baseUrl,
+                    timeoutMs: phaseTarget.api?.timeoutMs,
+                    headers: phaseTarget.api?.headers,
+                    apiKey: phaseTarget.api?.apiKey,
+                    apiKeySource: phaseTarget.api?.apiKeySource,
                 },
                 models: {
-                    selectedModelId: target.model?.id,
-                    selectedModelSlot: target.model?.slot || 'default',
+                    selectedModelId: phaseTarget.model?.id,
+                    selectedModelSlot: phaseTarget.model?.slot || 'default',
                 },
-                capabilities: target.capabilities,
+                capabilities: phaseTarget.capabilities,
             };
-            const created = createRuntimeLlm(perPhaseConfig, { langfuseEnabled: params.langfuseEnabled });
+            const created = createRuntimeLlm(perPhaseConfig, {
+                langfuseEnabled: params.langfuseEnabled,
+            });
             warnings.push(...created.warnings);
             phaseLlms[phase] = created.llm;
         }

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

@@ -25,6 +25,8 @@ export async function resolveRunRuntimeOptions(params) {
     }
     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 };
+    // When --no-verify is explicit, override verifyPolicy to 'never'
+    const verifyPolicyOverride = params.cliOptions.verify === false && effectiveVerify === undefined ? 'never' : undefined;
+    return { ok: true, llmOutput, effectiveVerify, effectiveWorktreePrepare, verifyPolicyOverride };
 }
 //# sourceMappingURL=runtime-options.js.map

package/dist/cli/config.js

@@ -5,12 +5,4 @@ export const CHAT_QUEUE_CONFIG = {
     THINKING_MIN_VISIBLE_MS: 150, // Reduced from 300ms to minimize perceived lag
     TASK_TIMEOUT_MS: 10 * 60 * 1000,
 };
-export const TOOL_AUTH_CONFIG = {
-    SESSION_TTL_MS: 30 * 60 * 1000,
-    AUTO_ALLOW_RISK: {
-        low: true,
-        medium: false,
-        high: false,
-    },
-};
 //# sourceMappingURL=config.js.map

package/dist/cli/headless/openai-responses-canonical-applier.js

@@ -1,11 +1,5 @@
 import { parseCanonicalFunctionCallItemId, } from '../../core/facades/cli-headless.js';
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object';
-}
-function getString(record, key) {
-    const value = record[key];
-    return typeof value === 'string' ? value : null;
-}
+import { isRecord, getString } from '../../core/utils/serialize.js';
 export class OpenAiResponsesCanonicalApplier {
     state;
     constructor(state) {

package/dist/cli/locales/en.js

@@ -19,7 +19,7 @@ export const en = {
     chatCommandHistory: '  /history      - Show iteration history',
     chatCommandQueue: '  /queue        - Manage the chat queue',
     chatCommandAuth: '  /config allowlist - Manage tool allowlist',
-    chatCommandMode: '  /mode         - Set permission mode (interactive/yolo)',
+    chatCommandMode: '  /permission-mode - Set permission mode (interactive/yolo)',
     chatCommandConfig: '  /config           - Settings (log-mode/view/output/allowlist/permission-mode)',
     chatSessionSaved: 'Session saved. Goodbye!',
     chatThinking: 'Thinking...',
@@ -108,7 +108,7 @@ export const en = {
     llmOutputUnavailable: 'LLM output configuration is unavailable in this mode.',
     llmOutputPersisted: (path) => `LLM output settings saved to ${path}`,
     llmOutputPersistFailed: (reason) => `Failed to save LLM output settings: ${reason}`,
-    modeUsage: 'Usage: /mode <interactive|yolo>',
+    modeUsage: 'Usage: /permission-mode <interactive|yolo>',
     modeSuggestion: (mode) => {
         if (mode === 'interactive')
             return 'Interactive permission checks and allowlist rules';

package/dist/cli/reporters/standard.js

@@ -110,6 +110,16 @@ export class StandardReporter {
             getLogger().info(text.cli.budgetSummaryTitle);
             getLogger().info(text.cli.budgetSummaryLine(s.attemptCount, s.adjustmentCount, s.alertCount, s.criticalDropCount, Math.round(s.avgUtilization * 100), Math.round(s.truncationRate * 100), Math.round(s.successRate * 100)));
         }
+        if (result.usage) {
+            const u = result.usage;
+            const tokenLine = `Tokens: ${u.inputTokens.toLocaleString()} in / ${u.outputTokens.toLocaleString()} out (${u.totalTokens.toLocaleString()} total)`;
+            if (u.estimatedCost !== undefined && u.estimatedCost > 0) {
+                getLogger().info(`${tokenLine} | Est. cost: $${u.estimatedCost.toFixed(2)}`);
+            }
+            else {
+                getLogger().info(tokenLine);
+            }
+        }
         if (this.verbose && result.logs) {
             getLogger().log('\n' + chalk.bold(text.cli.stepLogs));
             result.logs.forEach((log) => {
@@ -124,9 +134,8 @@ export class StandardReporter {
         getLogger().error(text.cli.unexpectedError(error.message), true);
     }
     initProgressBar() {
-        // 🛡️ DCAP Defense: Check if stderr supports TTY operations to prevent clearLine crashes and unexpected termination
-        const stream = process.stderr;
-        if (typeof stream.clearLine !== 'function' || typeof stream.cursorTo !== 'function') {
+        // DCAP Defense: Check if stderr supports TTY operations to prevent clearLine crashes and unexpected termination
+        if (!('clearLine' in process.stderr) || !('cursorTo' in process.stderr)) {
             this.bar = {
                 render: () => { },
                 tick: () => { },

package/dist/cli/reporters/stream-json.js

@@ -98,7 +98,8 @@ export class StreamJsonReporter {
         }));
     }
     onError(error) {
-        const auditPath = typeof error.auditPath === 'string' ? error.auditPath : undefined;
+        const errorRecord = error;
+        const auditPath = typeof errorRecord.auditPath === 'string' ? errorRecord.auditPath : undefined;
         this.emit(encodeStreamFailure({
             uuid: this.uuid(),
             sessionId: this.sessionId,

package/dist/cli/slash/runtime.js

@@ -135,10 +135,10 @@ export async function createCliSlashRuntime(options) {
                         // @see https://agentskills.io/specification — Progressive disclosure
                         const skill = await skillLoader.activateSkill(catalogEntry.id);
                         const meta = (req.meta ?? {});
-                        const signal = meta?.signal;
+                        const signal = meta.signal;
                         // Prepare an isolated worktree environment for governed shell execution.
                         const silentEmit = (event) => {
-                            if (event?.type === 'log' && event?.level === 'error') {
+                            if (event.type === 'log' && event.level === 'error') {
                                 options.emit(event);
                                 return;
                             }

package/dist/cli/ui/hooks/useLoopEvents.js

@@ -9,7 +9,7 @@ import { prepareMessagePayload, sanitizeMessage } from '../utils/sanitizer.js';
  */
 export function useLoopEvents(mode, onStart, signal, options) {
     const store = useUIStore();
-    const dispatch = store.dispatch;
+    const { dispatch } = store;
     const runStartedRef = useRef(false);
     const activeStreamIdRef = useRef(null);
     const logModeRef = useRef('normal');

package/dist/cli/ui/hooks/useLoopState.js

@@ -31,7 +31,7 @@ export function useLoopState() {
                             {
                                 id: Math.random().toString(36).substring(7),
                                 message: event.message,
-                                level: event.level,
+                                level: event.level === 'trace' ? 'debug' : event.level,
                                 timestamp: event.timestamp,
                             },
                         ].slice(-100),

package/dist/core/adapters/fs/file-adapter.js

@@ -1,5 +1,6 @@
 import { promises as fs, constants } from 'fs';
 import * as path from 'path';
+import { getLogger } from '../../observability/logger.js';
 import { AtomicFileWriter } from './atomic-file-writer.js';
 /**
  * Unified file system adapter for all file operations.
@@ -45,7 +46,8 @@ export class FileAdapter {
             await fs.access(filePath);
             return true;
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[FileAdapter] exists check failed: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         }
     }

package/dist/core/adapters/git/git-adapter.js

@@ -662,8 +662,9 @@ export class GitAdapter {
             // Example: /tmp -> /private/tmp on macOS
             tmpReal = realpathSync(tmpResolved);
         }
-        catch {
+        catch (error) {
             // Fall back to resolved path. If tmp is not realpath-resolvable, prefer denying shadow checks elsewhere.
+            getLogger().debug(`[GitAdapter] realpath resolve failed for tmpdir: ${error instanceof Error ? error.message : String(error)}`);
             tmpReal = tmpResolved;
         }
         return path.join(tmpReal, 's8p-wt');
@@ -674,7 +675,8 @@ export class GitAdapter {
         try {
             repoReal = realpathSync(repoResolved);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[GitAdapter] realpath resolve failed for repo: ${error instanceof Error ? error.message : String(error)}`);
             repoReal = repoResolved;
         }
         const parent = path.dirname(repoReal);
@@ -721,7 +723,8 @@ export class GitAdapter {
             // Prevents attacker from creating a symlink to main repo inside shadow root
             repo = realpathSync(repoResolved);
         }
-        catch {
+        catch (error) {
+            getLogger().debug(`[GitAdapter] realpath resolve failed for shadow check: ${error instanceof Error ? error.message : String(error)}`);
             repo = repoResolved;
         }
         if (isPathWithinDirectory(expectedRoot, repo, { allowEqual: false }))

package/dist/core/adapters/git/git-runner.js

@@ -1,6 +1,7 @@
 import { realpathSync } from 'fs';
 import path from 'path';
 import { LIMITS } from '../../config/limits.js';
+import { getLogger } from '../../observability/logger.js';
 import { spawnCommand } from '../../runtime/process-runner.js';
 function assertCwdSandboxed(repoRoot, cwd) {
     const resolvedRoot = path.resolve(repoRoot);
@@ -10,13 +11,15 @@ function assertCwdSandboxed(repoRoot, cwd) {
     try {
         realRoot = realpathSync(resolvedRoot);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[GitRunner] realpath resolve failed for root: ${error instanceof Error ? error.message : String(error)}`);
         realRoot = resolvedRoot;
     }
     try {
         realCwd = realpathSync(resolvedCwd);
     }
-    catch {
+    catch (error) {
+        getLogger().debug(`[GitRunner] realpath resolve failed for cwd: ${error instanceof Error ? error.message : String(error)}`);
         realCwd = resolvedCwd;
     }
     const rel = path.relative(realRoot, realCwd);