salmon-loop 0.2.3

package/dist/cli/locales/en.js

@@ -0,0 +1,409 @@
+export const en = {
+    // Program description
+    programDescription: 'A minimal viable loop for automated code patching',
+    runDescription: 'Run the salmon-loop',
+    contextDescription: 'Build and print the context prompt (no LLM call)',
+    serveDescription: 'Start the A2A + sidecar server',
+    serveAcpDescription: 'Start the agent-client-protocol (ACP) stdio server only',
+    noColorOption: 'Disable colored output in logs',
+    // Chat mode
+    chatResumed: (name) => `Resumed: ${name}`,
+    chatLastUpdated: (time) => `   Last updated: ${time}`,
+    chatIterations: (count) => `   Iterations: ${count}`,
+    chatNoPreviousSession: 'No previous session found. Starting new one.',
+    chatNewSession: (id) => `New session: ${id}`,
+    chatCommands: 'Commands:',
+    chatCommandExit: '  /exit, /quit  - Exit chat (or Ctrl+C twice)',
+    chatCommandStatus: '  /status       - Show session info',
+    chatCommandClear: '  /new          - Start a new session and clear context (clear)',
+    chatCommandHistory: '  /history      - Show iteration history',
+    chatCommandQueue: '  /queue        - Manage the chat queue',
+    chatCommandAuth: '  /config allowlist - Manage tool allowlist',
+    chatCommandMode: '  /mode         - Set permission mode (interactive/yolo)',
+    chatCommandConfig: '  /config           - Settings (log-mode/view/output/allowlist/permission-mode)',
+    chatSessionSaved: 'Session saved. Goodbye!',
+    chatThinking: 'Thinking...',
+    chatSuccess: (files) => `Changes applied successfully.\n\nFiles changed: ${files}`,
+    chatNoChanges: 'Completed successfully. No files were changed.',
+    chatReviewCompleted: 'Review completed successfully.',
+    chatResearchCompleted: 'Research completed successfully.',
+    chatFailed: (reason) => `Failed: ${reason}`,
+    chatPrompt: 's8p>',
+    chatExitHint: 'Press Ctrl+C again to exit',
+    chatTaskInterrupted: '[WARN] Task interrupted by user (Ctrl+C)',
+    chatIntentRouted: (intent, confidence, reason) => `Intent routed: ${intent} (confidence=${confidence.toFixed(2)}) reason=${reason}`,
+    chatAnswerEmpty: 'No answer produced.',
+    unknownCommand: (cmd) => `Unknown command: ${cmd}. Type /help for available commands.`,
+    helpAvailableCommands: (rows) => `Available Commands:\n${rows}`,
+    slashHandlerUnavailable: 'Command handler unavailable',
+    slashInternalError: 'Internal error',
+    skillNoPrompt: (id) => `Skill ${id} did not produce a prompt`,
+    askUserCancelled: 'User cancelled input request',
+    gui: {
+        title: 'Salmon Loop',
+        recentLogs: 'Recent Logs',
+        phase: 'Phase',
+        status: 'Status',
+        initializing: 'Initializing GUI...',
+        exitMessage: 'Exiting Salmon Loop...',
+        processing: 'Processing flow...',
+        inputPlaceholder: 'Type your instruction...',
+        backHint: 'Press ESC to back',
+        exitConfirmHint: 'Exit Salmonloop? (y/N)',
+        renderError: 'Error rendering content',
+        scrollHint: (current, total) => `(Scroll for more: ${current}/${total})`,
+        confirmationTitle: '[WARN] Action Required',
+        confirmationChallenge: (challenge) => `Enter [${challenge}] to confirm (Esc to cancel)`,
+        highRiskWarning: 'This operation involves physical code restoration. Please enter the validation code to continue.',
+        authorizationTitle: '[WARN] Authorization Required',
+        authorizationWarning: 'This tool call has side effects. Enter the authorization code to allow it once.',
+        authorizationHint: 'Tip: add "all", "save", or "global" after the code.',
+        selectionPlaceholder: 'Use Up/Down to select, Enter to confirm (Esc to cancel)',
+        selectionHint: 'Use Up/Down to navigate, Enter to select, Esc to cancel.',
+        selectionPlaceholderMulti: 'Use Up/Down, Space to toggle, Enter to confirm (Esc to cancel)',
+        selectionHintMulti: 'Use Up/Down to navigate, Space to toggle, Enter to confirm.',
+    },
+    // Command descriptions
+    commandExit: 'Exit the application',
+    commandStatus: 'Show current session status',
+    commandClear: 'Start a new session and clear context (clear)',
+    commandHistory: 'Show session history',
+    commandSessions: 'List all chat sessions',
+    commandQueue: 'Manage the chat queue',
+    commandLlmOutput: 'Set which LLM sections are shown in the UI (advanced)',
+    commandMode: 'Set permission mode (interactive|yolo) and save to config',
+    commandLogMode: 'Set UI verbosity (quiet|normal|debug) and save to config',
+    commandConfig: 'Settings hub (mode, log-mode, view, output, allowlist)',
+    commandAuth: 'Manage tool allowlist',
+    commandParallel: 'Manage parallel plans',
+    commandSubagent: 'Consult or dispatch a Smallfry (sub-agent)',
+    subagentUsage: 'Usage: /smallfry <list|info|log|stop> [agentId] [tail=<n>]',
+    subagentUnknownVerb: (verb) => `Unknown sub-agent verb: ${verb}.`,
+    subagentMissingId: (verb) => `Specify a Smallfry ID for "${verb}".`,
+    subagentNotFound: (id) => `Smallfry not found: ${id}.`,
+    subagentListHeader: 'Smallfry agents:',
+    subagentInfoHeader: (id) => `Smallfry info: ${id}`,
+    subagentLogHeader: (id) => `Logs for ${id}:`,
+    subagentStopRequested: (id) => `Stop requested for Smallfry ${id}.`,
+    queueUsage: 'Usage: /queue <status|pause|resume|retry|clear>',
+    queueUnavailable: 'Queue controls are not available in this mode.',
+    queuePaused: 'Queue paused. Use /queue resume or /queue retry to continue.',
+    queuePausedAfterInterrupt: 'Queue paused after interrupt. Use /queue resume or /queue retry to continue.',
+    queueAlreadyPaused: 'Queue is already paused.',
+    queueNotPaused: 'Queue is not paused.',
+    queueResumed: 'Queue resumed.',
+    queueCleared: 'Queue cleared.',
+    queueClearedCount: (count) => `Queue cleared. Dropped ${count} pending task(s).`,
+    queueRetryQueued: 'Re-queued the interrupted task at the front of the queue.',
+    queueRetryMissing: 'No interrupted task to retry.',
+    queueInterruptedHint: 'Interrupted task detected. Use /queue retry to re-run it.',
+    queueSubcommandHint: (sub) => `Queue ${sub} command`,
+    llmOutputSuggestion: (kind) => `Set LLM output to ${kind}`,
+    queueStatus: (pending, processing, paused, interrupted) => `Queue status: pending=${pending}, processing=${processing}, paused=${paused}, interrupted=${interrupted}`,
+    llmOutputUsage: 'Usage: /output <none|all|review,assistant_message,plan,patch>',
+    llmOutputCurrent: (kinds) => `Current LLM output kinds: ${kinds}`,
+    llmOutputUpdated: (kinds) => `LLM output kinds updated: ${kinds}`,
+    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>',
+    modeSuggestion: (mode) => {
+        if (mode === 'interactive')
+            return 'Interactive permission checks and allowlist rules';
+        if (mode === 'yolo')
+            return 'Bypass prompts, allowlist, and permission rules';
+        return `Set permission mode to ${mode}`;
+    },
+    modeCurrent: (mode) => `Current permission mode: ${mode}`,
+    modeInvalid: (mode) => `Invalid mode: ${mode}. Expected one of: interactive, yolo.`,
+    modeUpdated: (mode) => `Permission mode updated: ${mode}`,
+    modePersisted: (path) => `Permission mode saved to ${path}`,
+    modePersistFailed: (error) => `Failed to save permission mode: ${error}`,
+    logModeUsage: 'Usage: /log-mode <quiet|normal|debug>',
+    logModeSuggestion: (mode) => {
+        if (mode === 'quiet')
+            return 'Quiet: show errors only';
+        if (mode === 'normal')
+            return 'Normal: recommended (key steps + warnings/errors)';
+        if (mode === 'debug')
+            return 'Debug: verbose (all logs + tool details)';
+        return `Set UI verbosity to ${mode}`;
+    },
+    logModeCurrent: (mode) => `Current UI verbosity: ${mode}`,
+    logModeInvalid: (mode) => `Invalid log mode: ${mode}. Expected one of: quiet, normal, debug.`,
+    logModeUpdated: (mode) => `UI log mode updated: ${mode}`,
+    logModePersisted: (path) => `UI log mode saved to ${path}`,
+    logModePersistFailed: (error) => `Failed to save UI log mode: ${error}`,
+    configUsage: [
+        'Usage: /config <log-mode|view|output|allowlist|permission-mode>',
+        'Subcommands: log-mode, view, output, allowlist, permission-mode',
+    ].join('\n'),
+    configUnknownSubcommand: (name) => `Unknown subcommand: ${name}`,
+    configLogModeDescription: 'UI verbosity (quiet/normal/debug)',
+    configLogModeUsage: 'Usage: /config log-mode <quiet|normal|debug>',
+    configPermissionModeDescription: 'Permission mode (interactive/yolo)',
+    configPermissionModeUsage: 'Usage: /config permission-mode <interactive|yolo>',
+    configViewDescription: 'Set UI density (compact|standard|full) and save to config',
+    configViewUsage: 'Usage: /config view <full|standard|compact>',
+    configViewSuggestion: (view) => `Set UI density to ${view}`,
+    configViewCurrent: (view) => `Current UI density: ${view}`,
+    configViewInvalid: (view) => `Invalid UI density: ${view}. Expected one of: full, standard, compact.`,
+    configViewUpdated: (view) => `UI density updated: ${view}`,
+    configViewPersisted: (path) => `UI density saved to ${path}`,
+    configViewPersistFailed: (error) => `Failed to save UI density: ${error}`,
+    configOutputDescription: 'Set which LLM sections are shown in the UI (advanced)',
+    configOutputUsage: 'Usage: /config output <none|all|review,assistant_message,plan,patch>',
+    configAllowlistDescription: 'Manage tool allowlist (repo/user)',
+    a2aHostOption: 'A2A listen host (default: 127.0.0.1)',
+    a2aPortOption: 'A2A listen port (default: 7431)',
+    a2aTokenOption: 'Bearer token for A2A auth (repeatable)',
+    acpStdioDisableOption: 'Disable agent-client-protocol (ACP) stdio server',
+    sidecarSocketOption: 'UDS path for the sidecar UI server',
+    sidecarAllowConditionalOption: 'Expose conditional sidecar routes (use with care)',
+    acpStdioStarted: (port) => `ACP (agent-client-protocol) stdio enabled; port ${port}`,
+    invalidA2APort: (value) => `Invalid A2A port: ${value}`,
+    serveStarted: (host, port, socket) => `A2A listening on ${host}:${port}; sidecar socket at ${socket}`,
+    configAllowlistUsage: 'Usage: /config allowlist <list|add|remove|clear|hash|reload> [scope] [tool] [phase] [args=<hash>] [effects=a,b] [deny]',
+    authUsage: 'Usage: /allowlist <list|add|remove|clear|hash|reload> [scope] [tool] [phase] [args=<hash>] [effects=a,b] [deny]',
+    authSubcommandHint: (sub) => `Allowlist ${sub} command`,
+    parallelSubcommandHint: (sub) => `Parallel ${sub} command`,
+    subagentDescription: 'Smallfry (sub-agent) commands are still experimental. Use the agent_dispatch tool or the CLI helpers to spawn a sub-agent from your plan.',
+    authScopeHint: (scope) => `Use ${scope} allowlist`,
+    authPhaseHint: (phase) => `Phase ${phase.toUpperCase()}`,
+    authToolNameHint: 'Known tool name',
+    authConfigMissing: 'Allowlist config is unavailable.',
+    authHashUsage: 'Usage: /allowlist hash <json-or-string>',
+    authHashResult: (hash) => `Args hash: ${hash}`,
+    authListEmpty: (scope) => `No allowlist entries for ${scope}.`,
+    authListEntry: (tool, mode, phase, argsHash, effects) => {
+        const phaseText = phase ? ` phase=${phase}` : '';
+        const hashText = argsHash ? ` args=${argsHash}` : '';
+        const effectsText = effects && effects.length > 0 ? ` effects=${effects.join(',')}` : '';
+        return `${tool} mode=${mode}${phaseText}${hashText}${effectsText}`;
+    },
+    authCleared: (scope) => `Cleared ${scope} allowlist.`,
+    authAdded: (tool, scope, mode) => `Added ${tool} to ${scope} allowlist (mode=${mode}).`,
+    authRemoved: (tool, scope) => `Removed ${tool} from ${scope} allowlist.`,
+    authRemoveMissing: (tool, scope) => `No matching allowlist entry for ${tool} in ${scope}.`,
+    authAddUsage: 'Usage: /allowlist add <scope> <tool> [phase] [args=<hash>] [effects=a,b] [deny]',
+    authRemoveUsage: 'Usage: /allowlist remove <scope> <tool> [phase] [args=<hash>] [effects=a,b]',
+    authCacheCleared: 'Authorization allowlist cache cleared.',
+    authCacheInvalidated: (reason, path) => `Authorization allowlist cache invalidated: ${reason} (${path})`,
+    authPathBlocked: (path, scope) => `Blocked allowlist path outside ${scope} scope: ${path}`,
+    authToolRegistryUnavailable: 'Tool registry is unavailable. Try again later.',
+    authInvalidToolName: (tool) => `Unknown tool name: ${tool}.`,
+    authInvalidSideEffects: (effects) => `Invalid side effects: ${effects}.`,
+    authLockTimeout: (path) => `Authorization allowlist lock timeout: ${path}`,
+    authInvalidPhase: (phase) => `Invalid phase: ${phase}.`,
+    parallelUsage: 'Usage: /parallel <list|resume|delete> [planId]',
+    parallelListEmpty: 'No pending or blocked parallel plans found.',
+    parallelSelectTitle: 'Select a parallel plan',
+    parallelCanceled: 'Selection canceled.',
+    parallelNotFound: (id) => `Parallel plan not found: ${id}.`,
+    parallelResumed: (id, blocked, failed) => `Parallel plan resumed: ${id} (blocked=${blocked}, failed=${failed})`,
+    parallelDeleted: (id) => `Parallel plan deleted: ${id}.`,
+    toolAuthorizationPrompt: (tool, risk, effects, summary) => `Authorize tool call: ${tool} (risk=${risk}, effects=${effects})\nArgs: ${summary}\nUse code alone to allow once, append "all" for this session, "save" to persist in repo, or "global" to persist for this user.`,
+    toolAuthorizationMissingUi: 'Authorization UI is unavailable. Tool call denied.',
+    toolAuthorizationDenied: 'Tool call denied by user authorization.',
+    toolAuthorizationApproved: 'Tool call authorized by user.',
+    toolAuthorizationNonInteractiveMisconfigured: (strategy) => `Non-interactive authorization is misconfigured (${strategy}). Tool call denied.`,
+    toolAuthorizationNonInteractiveFailed: (code) => `Non-interactive authorization failed (${code}). Tool call denied.`,
+    toolAuthorizationNonInteractiveUnsupported: (strategy) => `Non-interactive authorization strategy is unsupported (${strategy}). Tool call denied.`,
+    toolAuthorizationTerminalQuestion: 'Authorize this tool call? (y=once, a=session, s=save repo, g=save user, n=deny)',
+    toolAuthorizationAutoApproved: (tool, risk) => `Auto-approved tool call: ${tool} (risk=${risk}).`,
+    toolAuthorizationAllowlisted: (tool) => `Allowlist approved tool call: ${tool}.`,
+    toolAuthorizationDenylisted: (tool) => `Denylist blocked tool call: ${tool}.`,
+    // Option descriptions
+    printOption: 'Run non-interactively with the given instruction (shorthand for "run --instruction")',
+    instructionOption: 'Instruction for code modification (required)',
+    verifyOption: 'Verification command to run (e.g., "pytest", "go test ./...", or your project test command) (required)',
+    configOption: 'Path to SalmonLoop config file (YAML/JSON). Default lookup: <repo>/.salmonloop/config/config.yaml, config.yml, config.json',
+    noConfigFileOption: 'Disable loading config file from the repository',
+    printConfigOption: 'Print the resolved config (redacted) and exit',
+    repoOption: 'Repository path (default: current directory)',
+    continueOption: 'Continue the most recent session in this repository',
+    resumeOption: 'Resume a session by ID (supports short prefix)',
+    fileOption: 'Target file path (relative to repo)',
+    selectionOption: 'Direct text selection (mutually exclusive with --file)',
+    allowedToolsOption: 'Allow tool calls by permission rules (comma-separated, repeatable). Example: Bash(pytest *)',
+    disallowedToolsOption: 'Deny tool calls by permission rules (comma-separated, repeatable). Example: Bash(rm *)',
+    dryRunOption: 'Generate patch without applying',
+    verboseOption: 'Enable verbose logging (basic, extended)',
+    forceResetOption: 'Force hard reset on failure (use with caution)',
+    validateOption: 'Run code quality checks (lint and tests)',
+    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)',
+    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',
+    streamOutputOption: 'Stream LLM responses to the CLI as they arrive (best effort)',
+    includePartialMessagesOption: 'Include partial message streaming events in stream-json output (alias for --stream-output).',
+    outputFormatOption: 'Output format (text, json, stream-json)',
+    outputProfileOption: 'Output profile for stream-json (native, anthropic, openai). Only valid with --output-format stream-json.',
+    headlessIncludeToolInputOption: 'Headless only: include (redacted) tool input in stream-json output. Only valid with --output-format stream-json.',
+    headlessIncludeToolOutputOption: 'Headless only: include tool output summary in stream-json output. Only valid with --output-format stream-json.',
+    headlessIncludeAuthorizationDecisionsOption: 'Headless only: include tool authorization decisions in headless output. Only valid with --output-format json or stream-json.',
+    allowOutsideCacheRootOption: 'Allow context cache persistent path outside configured allowed roots for this run only (high risk).',
+    jsonSchemaOption: 'JSON Schema for structured_output (file path or JSON string). Only valid with --output-format json.',
+    llmOutputOption: 'LLM output visibility (none, all, review, assistant_message, explore, research, plan, patch; comma-separated)',
+    auditScopeOption: 'Audit log scope (repo, user)',
+    contextDiffScopeOption: 'Diff scope for context (primary, ast_related)',
+    contextBudgetCharsOption: 'Context budget in characters (e.g., 30000)',
+    actModeOption: 'Flow mode to run (patch, review, debug, research)',
+    // Error messages
+    fileSelectionConflict: '--file and --selection are mutually exclusive',
+    instructionRequired: '--instruction is required',
+    verifyRequired: '--verify is required',
+    printInstructionConflict: '--print and --instruction are mutually exclusive.',
+    printCommandConflict: (cmd) => `--print can only be used with the "run" command (got: ${cmd}).`,
+    jsonSchemaRequiresJsonOutput: '--json-schema is only valid when --output-format is set to "json".',
+    jsonSchemaLoadFailed: (msg) => `Failed to load JSON schema: ${msg}.`,
+    structuredOutputSchemaFailed: 'Structured output failed schema validation.',
+    invalidActMode: (mode) => `Invalid --act-mode "${mode}". Expected "patch", "review", "debug", or "research".`,
+    invalidEnvironmentMode: (mode) => `Invalid --environment-mode "${mode}". Expected "strict" or "parity".`,
+    invalidOutputFormat: (format) => `Invalid --output-format "${format}". Expected "text", "stream-json", or "json".`,
+    invalidOutputProfile: (profile) => `Invalid --output-profile "${profile}". Expected "native", "anthropic", or "openai".`,
+    invalidAuditScope: (scope) => `Invalid --audit-scope "${scope}". Expected "repo" or "user".`,
+    headlessToolPayloadRequiresStreamJson: '--headless-include-tool-input/--headless-include-tool-output are only valid when --output-format is set to "stream-json".',
+    headlessToolPayloadNotSupportedWithOpenAiProfile: '--headless-include-tool-input/--headless-include-tool-output are not supported with --output-profile "openai".',
+    headlessAuthorizationDecisionsRequireHeadlessOutput: '--headless-include-authorization-decisions is only valid when --output-format is set to "json" or "stream-json".',
+    headlessAuthorizationDecisionsNotSupportedWithStrictProfiles: '--headless-include-authorization-decisions is not supported with --output-profile "anthropic" or "openai".',
+    outputProfileRequiresStreamJson: '--output-profile is only valid when --output-format is set to "stream-json".',
+    outputProfileNotSupportedYet: (profile) => `--output-profile "${profile}" is not supported. Expected "native", "anthropic", or "openai".`,
+    continueResumeConflict: '--continue and --resume are mutually exclusive.',
+    resumeNotFound: (id) => `Session not found: ${id}.`,
+    invalidLlmOutputKind: (kind) => `Invalid --llm-output value${kind ? `: "${kind}"` : ''}. Expected "none", "all", or a comma-separated list of: review, assistant_message, explore, research, plan, patch.`,
+    contextInvalidDiffScope: (scope) => `Invalid --diff-scope "${scope}". Expected "primary" or "ast_related".`,
+    contextInvalidBudgetChars: (value) => `Invalid --budget-chars "${value}".`,
+    apiKeyMissing: '[WARN] SALMONLOOP_API_KEY not found, using StubLLM. Set SALMONLOOP_API_KEY (or legacy S8P_API_KEY) to use a real LLM.',
+    providerNotSupported: (type) => `[WARN] Provider "${type}" is not supported yet. Falling back to StubLLM.`,
+    clientPackageNotSupported: (pkg) => `[WARN] LLM client.package "${pkg}" is not supported. Falling back to the default client.`,
+    // Resource and Workspace messages
+    resource: {
+        worktreeSkipCleanup: 'workPath equals baseRepoPath; skipping cleanup to avoid data loss',
+        lockTimeoutAttemptForce: (path) => `Lock acquisition timeout for ${path}, attempting force cleanup...`,
+        lockForceRemoved: (file) => `Forcefully removed stale lock file: ${file}`,
+        lockAcquiredAfterForce: (file) => `Lock acquired after force cleanup: ${file}`,
+        lockAcquireTimeout: (path) => `Failed to acquire lock for ${path} within timeout`,
+        lockReleaseFailed: (path) => `Failed to release lock for ${path}`,
+    },
+    // Startup information
+    starting: 'Starting salmon-loop...',
+    runningWith: 'Running salmon-loop with:',
+    scope: (scope) => `  Scope: ${scope}`,
+    verify: (command) => `  Verify: ${command}`,
+    instruction: (instruction) => `  Instruction: ${instruction}`,
+    repoPath: (path) => `  Repo path: ${path}`,
+    allowedTools: (rules) => `  Allowed tools: ${rules}`,
+    disallowedTools: (rules) => `  Disallowed tools: ${rules}`,
+    configPath: (path) => `  Config file: ${path}`,
+    contextFile: (file) => `  Context file: ${file}`,
+    contextSelection: (length) => `  Context selection length: ${length}`,
+    dryRunEnabled: '  Dry-run mode enabled',
+    target: (path) => `  Target: ${path}`,
+    // Result output
+    result: 'Result:',
+    operationSuccess: '\nOperation completed successfully.',
+    operationFailed: '\nOperation failed.',
+    success: (success) => `  Success: ${success}`,
+    reason: (reason) => `  Reason: ${reason}`,
+    attempts: (attempts) => `  Attempts: ${attempts}`,
+    errorCode: (code) => `  Error code: ${code}`,
+    auditPath: (path) => `  Audit log: ${path}`,
+    verifyOutputArtifact: (handle) => `  Verification output saved as ${handle} (use artifact.read to inspect)`,
+    authorizationSummary: (summary) => `  Authorization sources: ${summary}`,
+    authorizationSummaryRealtime: (summary) => `  Authorization sources (current): ${summary}`,
+    budgetSummaryTitle: '  Budget summary:',
+    budgetSummaryLine: (attempts, adjustments, alerts, criticalDrops, avgUtilizationPercent, truncationRatePercent, successRatePercent) => `    attempts=${attempts} adjustments=${adjustments} alerts=${alerts} critical_drops=${criticalDrops} avg_utilization=${avgUtilizationPercent}% truncation_rate=${truncationRatePercent}% success_rate=${successRatePercent}%`,
+    diffMeta: (files, lines) => `  Diff: ${files} files changed, ${lines} lines.`,
+    uiDiffMeta: (files, lines) => `Diff: ${files} file(s), ${lines} line(s) changed.`,
+    uiVerifyPassed: 'Verify passed.',
+    uiVerifyFailed: 'Verify failed.',
+    uiToolFailed: (tool, status) => `Tool failed: ${tool} (${status}).`,
+    retry: (from, to, reason) => `\nRetrying (${from} -> ${to}). Reason: ${reason}`,
+    contextBuilt: (usedChars, truncated) => `Context built (${usedChars} chars, truncated=${truncated})`,
+    // Step logs
+    stepLogs: 'Step Logs:',
+    stepEntry: (index, step, success) => `  ${index + 1}. ${step}: ${success ? '[ok]' : '[error]'}`,
+    stepError: (error) => `     Error: ${error}`,
+    stepOutput: (output, maxLen) => {
+        const truncated = output.length > maxLen;
+        return `     Output: ${output.substring(0, maxLen)}${truncated ? '...' : ''}`;
+    },
+    rawPatch: (patch) => `  [DEBUG] Raw Patch:\n${patch}`,
+    // Patch output
+    finalPatch: 'Final Patch:',
+    // Errors
+    error: (error) => `Error: ${error}`,
+    unexpectedError: (error) => `Unexpected error: ${error}`,
+    runningValidation: 'Running validation checks...',
+    validationUsingPackageManager: (packageManager) => `  Using detected package manager: ${packageManager}`,
+    runningScript: (scriptName, command) => `  Running "${scriptName}" script via: ${command}`,
+    scriptMissing: (scriptName) => `  Skipping "${scriptName}" because package.json has no "${scriptName}" script.`,
+    validationSkippedNoPackageJson: 'Validation skipped: no package.json found in target repository.',
+    validationSkippedNoScripts: 'Validation skipped: neither "lint" nor "test" script exists in package.json.',
+    runningEslint: '  Running ESLint...',
+    runningTests: '  Running Tests...',
+    testsFailedContinuing: '  [WARN] Tests failed, but continuing validation...',
+    validationCompleted: 'Validation completed.',
+    validationFailed: 'Validation failed.',
+    validationCommandTimeout: (scriptName, command) => `  ${scriptName} timed out: ${command}`,
+    validationCommandNotFound: (scriptName, command) => `  ${scriptName} command not found: ${command}`,
+    validationCommandExitCode: (scriptName, command, code) => `  ${scriptName} failed (${code}): ${command}`,
+    validationCommandSpawnError: (scriptName, command, reason) => `  ${scriptName} failed to start (${command}): ${reason}`,
+    validationCommandOutputExceeded: (scriptName, command) => `  ${scriptName} output exceeded capture limit: ${command}`,
+    validationCommandAborted: (scriptName, command) => `  ${scriptName} aborted: ${command}`,
+    invalidPreflightPolicy: (policy) => `Invalid --preflight-policy "${policy}". Expected "lenient" or "strict".`,
+    optionsRequired: 'Error: --instruction is required. --verify is required unless provided by config, or --validate is used.',
+    // Snapshot management
+    snapshotManageDescription: 'Manage snapshots',
+    restoreDescription: 'Restore the workspace to a specific snapshot',
+    restoreForceOption: 'Overwrite uncommitted changes',
+    restoreStarting: (hash) => `Restoring snapshot ${hash}...`,
+    restoreSuccess: (hash) => `Successfully restored snapshot ${hash}`,
+    restoreFailedDirty: 'Restore failed: Workspace has uncommitted changes.',
+    restoreFailedDirtyHint: 'Use --force to overwrite them, or commit/stash your changes first.',
+    restoreFailed: (error) => `Restore failed: ${error}`,
+    listSnapshotsDescription: 'List all available snapshots',
+    createSnapshotDescription: 'Create a new snapshot of the current workspace',
+    createSnapshotMessageOption: 'Description message for the snapshot',
+    createSnapshotIncludeOption: 'Specific files to include in the snapshot',
+    showSnapshotDescription: 'Show details and differences of a specific snapshot',
+    showSnapshotFilesOption: 'List all files included in the snapshot',
+    noSnapshots: 'No snapshots found.',
+    availableSnapshots: 'Available Snapshots:',
+    noSessionsFound: 'No saved sessions found.',
+    sessionsHeader: 'Available Sessions:',
+    snapshotTableHead: 'Hash     Timestamp                  Message',
+    autoSnapshotMsg: (hash) => `Auto-snapshot (staged: ${hash})`,
+    snapshotCreated: (hash) => `Snapshot created: ${hash}`,
+    snapshotMessage: (msg) => `Message: ${msg}`,
+    snapshotCreateFailed: (error) => `Failed to create snapshot: ${error}`,
+    snapshotDetails: (hash) => `Snapshot ${hash} Details:`,
+    stagedFiles: 'Staged Files:',
+    noStagedFiles: 'No staged files.',
+    unstagedChanges: 'Unstaged Changes:',
+    noUnstagedChanges: 'No unstaged changes.',
+    allFilesInSnapshot: 'All Files in Snapshot:',
+    snapshotShowFailed: (error) => `Failed to show snapshot: ${error}`,
+    noDifferences: 'No differences found.',
+    getDiffFailed: (error) => `Failed to get diff: ${error}`,
+    readFileFailed: (error) => `Failed to read file: ${error}`,
+    exportStarting: (hash, dir) => `Exporting snapshot ${hash} to ${dir}...`,
+    exportSuccess: (hash) => `Successfully exported snapshot ${hash}`,
+    exportFailed: (error) => `Failed to export snapshot: ${error}`,
+    snapshotDeleted: (hash) => `Snapshot ${hash} deleted.`,
+    snapshotDeleteFailed: (error) => `Failed to delete snapshot: ${error}`,
+    clearForcePrompt: 'Please use --force to clear all snapshots.',
+    allSnapshotsCleared: 'All snapshots cleared.',
+    clearSnapshotsFailed: (error) => `Failed to clear snapshots: ${error}`,
+    diffSnapshotDescription: 'Show diff between snapshots or workspace',
+    diffSnapshotCodeOption: 'Show full code diff instead of summary',
+    catSnapshotDescription: 'View file content from a snapshot',
+    exportSnapshotDescription: 'Export snapshot content to a directory',
+    deleteSnapshotDescription: 'Delete a snapshot',
+    clearSnapshotsDescription: 'Clear all snapshots',
+    clearSnapshotsForceOption: 'Force clear without confirmation',
+};
+//# sourceMappingURL=en.js.map

package/dist/cli/locales/index.js

@@ -0,0 +1,7 @@
+import { text as coreText } from '../../locales/index.js';
+import { en as cliEn } from './en.js';
+export const text = {
+    ...coreText,
+    cli: cliEn,
+};
+//# sourceMappingURL=index.js.map

package/dist/cli/program-bootstrap.js

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { initializeRuntime } from '../core/facades/cli-program-bootstrap.js';
+import { text } from './locales/index.js';
+export function bootstrapProgram() {
+    initializeRuntime();
+    // Force global chalk level for all output paths.
+    chalk.level = 3;
+    const program = new Command();
+    program.exitOverride();
+    program.name('s8p').alias('salmonloop').description(text.cli.programDescription).version('0.2.0');
+    return program;
+}
+//# sourceMappingURL=program-bootstrap.js.map

package/dist/cli/program-commands.js

@@ -0,0 +1,106 @@
+import { handleChatCommand } from './commands/chat.js';
+import { handleContextCommand } from './commands/context.js';
+import { handleRestoreCommand } from './commands/restore.js';
+import { handleRunCommand } from './commands/run.js';
+import { registerServeCommands } from './commands/serve.js';
+import { handleSnapshotCat, handleSnapshotClear, handleSnapshotCreate, handleSnapshotDelete, handleSnapshotDiff, handleSnapshotExport, handleSnapshotList, handleSnapshotShow, } from './commands/snapshot.js';
+import { text } from './locales/index.js';
+export function registerProgramCommands(program) {
+    program
+        .command('run')
+        .description(text.cli.runDescription)
+        .option('-i, --instruction <instruction>', text.cli.instructionOption)
+        .option('--config <path>', text.cli.configOption)
+        .option('--no-config-file', text.cli.noConfigFileOption)
+        .option('--print-config', text.cli.printConfigOption)
+        .option('-f, --file <path>', text.cli.fileOption)
+        .option('-s, --selection <text>', text.cli.selectionOption)
+        .option('--allowedTools <rules>', text.cli.allowedToolsOption, (value, previous) => previous.concat([value]), [])
+        .option('--disallowedTools <rules>', text.cli.disallowedToolsOption, (value, previous) => previous.concat([value]), [])
+        .option('--dry-run', text.cli.dryRunOption)
+        .option('--verbose [level]', text.cli.verboseOption)
+        .option('--force-reset', text.cli.forceResetOption)
+        .option('--validate', text.cli.validateOption)
+        .option('--preflight-policy <policy>', text.cli.preflightPolicyOption, 'lenient')
+        .option('--act-mode <mode>', text.cli.actModeOption, 'patch')
+        .option('--apply-back-on-dirty <mode>', text.cli.applyBackOnDirtyOption, '3way')
+        .option('--environment-mode <mode>', text.cli.environmentModeOption, 'strict')
+        .option('--worktree-prepare <command>', text.cli.worktreePrepareOption)
+        .option('--stream-output', text.cli.streamOutputOption)
+        .option('--include-partial-messages', text.cli.includePartialMessagesOption)
+        .option('--output-format <format>', text.cli.outputFormatOption, 'text')
+        .option('--output-profile <profile>', text.cli.outputProfileOption)
+        .option('--headless-include-tool-input', text.cli.headlessIncludeToolInputOption)
+        .option('--headless-include-tool-output', text.cli.headlessIncludeToolOutputOption)
+        .option('--allow-outside-cache-root', text.cli.allowOutsideCacheRootOption)
+        .option('--headless-include-authorization-decisions', text.cli.headlessIncludeAuthorizationDecisionsOption)
+        .option('--json-schema <schema>', text.cli.jsonSchemaOption)
+        .option('--gui', 'Enable experimental TUI mode (Ink)')
+        .action(handleRunCommand);
+    program
+        .command('restore <hash>')
+        .alias('checkout')
+        .description(text.cli.restoreDescription)
+        .option('--force', text.cli.restoreForceOption)
+        .action(handleRestoreCommand);
+    const snapshot = program
+        .command('snapshot')
+        .alias('snap')
+        .description(text.cli.snapshotManageDescription);
+    snapshot
+        .command('list')
+        .alias('ls')
+        .description(text.cli.listSnapshotsDescription)
+        .action(handleSnapshotList);
+    snapshot
+        .command('create')
+        .description(text.cli.createSnapshotDescription)
+        .option('-m, --message <text>', text.cli.createSnapshotMessageOption)
+        .option('--include <files...>', text.cli.createSnapshotIncludeOption)
+        .action(handleSnapshotCreate);
+    snapshot
+        .command('show <hash>')
+        .description(text.cli.showSnapshotDescription)
+        .option('--files', text.cli.showSnapshotFilesOption)
+        .action(handleSnapshotShow);
+    snapshot
+        .command('diff <hash> [otherHash]')
+        .description(text.cli.diffSnapshotDescription)
+        .option('--code', text.cli.diffSnapshotCodeOption)
+        .action(handleSnapshotDiff);
+    snapshot
+        .command('cat <hash> <file>')
+        .description(text.cli.catSnapshotDescription)
+        .action(handleSnapshotCat);
+    snapshot
+        .command('export <hash> <directory>')
+        .description(text.cli.exportSnapshotDescription)
+        .action(handleSnapshotExport);
+    snapshot
+        .command('delete <hash>')
+        .alias('rm')
+        .description(text.cli.deleteSnapshotDescription)
+        .action(handleSnapshotDelete);
+    snapshot
+        .command('clear')
+        .description(text.cli.clearSnapshotsDescription)
+        .option('--force', text.cli.clearSnapshotsForceOption)
+        .action(handleSnapshotClear);
+    program
+        .command('context')
+        .description(text.cli.contextDescription)
+        .option('-i, --instruction <instruction>', text.cli.instructionOption)
+        .option('-f, --file <path>', text.cli.fileOption)
+        .option('-s, --selection <text>', text.cli.selectionOption)
+        .option('--diff-scope <scope>', text.cli.contextDiffScopeOption, 'primary')
+        .option('--budget-chars <n>', text.cli.contextBudgetCharsOption)
+        .option('--allow-outside-cache-root', text.cli.allowOutsideCacheRootOption)
+        .action(handleContextCommand);
+    registerServeCommands(program);
+    program
+        .command('chat', { isDefault: true })
+        .description('Enter interactive chat mode (default)')
+        .option('--verbose [level]', text.cli.verboseOption)
+        .action(handleChatCommand);
+}
+//# sourceMappingURL=program-commands.js.map

package/dist/cli/program-options.js

@@ -0,0 +1,15 @@
+import { text } from './locales/index.js';
+export function configureGlobalProgramOptions(program) {
+    program
+        .option('-r, --repo <path>', text.cli.repoOption, process.cwd())
+        .option('-p, --print <instruction>', text.cli.printOption)
+        .option('--continue', text.cli.continueOption)
+        .option('--resume <sessionId>', text.cli.resumeOption)
+        .option('-v, --verify <command>', text.cli.verifyOption)
+        .option('--no-verify', 'Disable verification')
+        .option('-cs, --checkpoint-strategy <type>', text.cli.checkpointStrategyOption, 'worktree')
+        .option('--mode <mode>', text.cli.permissionModeOption, 'interactive')
+        .option('--llm-output <kinds>', text.cli.llmOutputOption)
+        .option('--audit-scope <scope>', text.cli.auditScopeOption);
+}
+//# sourceMappingURL=program-options.js.map

package/dist/cli/program-output-mode.js

@@ -0,0 +1,11 @@
+export function configureProgramOutputForHeadless(context) {
+    if (!context.headlessDetection.outputFormat)
+        return;
+    context.program.configureOutput({
+        writeOut: () => { },
+        writeErr: () => { },
+    });
+    context.program.showHelpAfterError(false);
+    context.program.showSuggestionAfterError(false);
+}
+//# sourceMappingURL=program-output-mode.js.map

package/dist/cli/program-parse.js

@@ -0,0 +1,24 @@
+import { emitHeadlessCommanderUsageError, getCommanderErrorExitCode, isCommanderError, shouldExitCommanderError, } from './commander-error-adapter.js';
+import { reportCliCrash } from './crash-reporter.js';
+export async function parseProgramOrExit(context) {
+    try {
+        await context.program.parseAsync(context.rewrittenArgv);
+        return { status: 'ok' };
+    }
+    catch (err) {
+        if (isCommanderError(err)) {
+            emitHeadlessCommanderUsageError({
+                err,
+                headlessDetection: context.headlessDetection,
+            });
+            if (shouldExitCommanderError(err)) {
+                process.exit(getCommanderErrorExitCode(err));
+                return { status: 'exited' };
+            }
+            return { status: 'ok' };
+        }
+        reportCliCrash(err);
+        return { status: 'crash-reported' };
+    }
+}
+//# sourceMappingURL=program-parse.js.map