cawdex 1.35.75 → 1.35.76

package/dist/index.js

@@ -10,11 +10,14 @@ import { initDebug, emit as dbgEmit, setDebugLevel, getDebugStatus, tailDebug }
 import chalk from 'chalk';
 import { loadConfig, saveConfig, configExists, getConfigDir, loadConfigFromEnv, applyRuntimeConfigOverrides } from './config.js';
 import { resetClient } from './api.js';
+import { explainPermission } from './permissions.js';
 import { CHATGPT_CODEX_BASE_URL, getOpenAICodexAuthStatus, runCodexLogin, } from './openai-oauth.js';
 import { formatOpenAICodexSmokeResult, runOpenAICodexSmokeTest } from './openai-smoke.js';
-import { fallbackModelForKnownFlakyTurn, isKnownFlakyOpenRouterModel, isTurnCancelKeySequence, runQuery } from './query.js';
+import { isKnownFlakyOpenRouterModel, isTurnCancelKeySequence, runQuery } from './query.js';
 import { ALL_TOOLS } from './tools/index.js';
 import { buildHarnessComponentsReport } from './tools/harness-components.js';
+import { buildContextBrief } from './context-brief.js';
+import { formatAgentsInstructionsReport } from './agents-md.js';
 import { GitHubRepoDigestTool } from './tools/github-repo-digest.js';
 import { ResearchSourcesTool } from './tools/research-sources.js';
 import { decodeBenchmarkReposSentinel, encodeBenchmarkReposSentinel, formatBenchmarkRepoCatalog, formatBenchmarkRepoCatalogUsage, parseBenchmarkRepoCatalogCommandArgs, } from './benchmark-repos.js';
@@ -28,7 +31,8 @@ import { printUsageSummary, setBudget } from './cost-tracker.js';
 import { getCompactionStats, OPENROUTER_FREE_ROUTER_SAFE_CONTEXT_WINDOW_TOKENS, OPENROUTER_UNKNOWN_FREE_MODEL_CONTEXT_WINDOW_TOKENS, } from './compaction.js';
 import { extractPatterns, printInstinctStatus, pruneExpired, listInstincts, exportInstincts, importInstincts } from './learning.js';
 import { MODES, listModes, normalizeModeName } from './modes.js';
-import { printModelOptions, switchModel, classifyComplexity, routeModel } from './model-router.js';
+import { printModelOptions, classifyComplexity, routeModel } from './model-router.js';
+import { deleteModelAlias, formatModelResolution, formatTurnOverride, listModelAliases, normalizeReasoningEffort, parseModelOnce, resolveModelReference, setModelAlias, tokenizeModelCommandArgs, } from './model-aliases.js';
 import { buildCommitPrompt, buildPRPrompt, printDiff, printLog } from './git-workflow.js';
 import { buildReviewPrompt, buildTDDPrompt, buildSecurityReviewPrompt, runAudit, printAuditReport, buildPlanPrompt, buildE2EPrompt, buildBuildFixPrompt, buildEvalPrompt, buildBenchmarkPrompt, splitBenchmarkArgs, } from './evaluation.js';
 import { buildDoctorReport, formatDoctorReport, runDoctorCli } from './doctor.js';
@@ -367,25 +371,13 @@ async function setupWizard(rl, currentConfig) {
     const modelInput = await rl.question(chalk.yellow(`  Model [${model}]: `));
     if (modelInput.trim())
         model = modelInput.trim();
-    // Auto-heal known-slow / known-flaky OpenRouter models. These
-    // IDs frequently return empty responses, the literal string "ERROR",
-    // or no first stream event. Warning-only was not enough: users could
-    // save a broken first-run config and every prompt looked like it was
-    // stuck in the live queue. Keep an explicit env escape hatch for model
-    // debugging, but default normal users back to the free router.
+    // Warn only. The user-selected model is part of their config and must
+    // never be silently replaced by a "safer" default.
     if (isKnownFlakyOpenRouterModel({ provider: provider.name, model })) {
         console.log('');
         console.log(chalk.yellow(`  ⚠  "${model}" is known to stall badly in interactive OpenRouter sessions`));
-        console.log(chalk.yellow(`     or return empty / "ERROR" responses.`));
-        if (process.env.CAWDEX_ALLOW_FLAKY_MODELS === '1') {
-            console.log(chalk.dim('     Keeping it because CAWDEX_ALLOW_FLAKY_MODELS=1 is set.'));
-        }
-        else {
-            const safer = providerKey === 'openrouter' ? PROVIDERS.openrouter.defaultModel : provider.defaultModel;
-            console.log(chalk.dim(`     Using safer default instead: ${safer}`));
-            console.log(chalk.dim('     Override only for debugging: CAWDEX_ALLOW_FLAKY_MODELS=1 cawdex'));
-            model = safer;
-        }
+        console.log(chalk.yellow(`     or return empty / "ERROR" responses. Keeping your selected model.`));
+        console.log(chalk.dim('     Configure /fallback explicitly if you want an automatic retry after a real failure.'));
         console.log('');
     }
     if (providerKey === 'openrouter' && !isOpenRouterFreeModelId(model)) {
@@ -526,8 +518,6 @@ async function setupWizard(rl, currentConfig) {
     console.log(chalk.dim(`  Configured: /model, /fallback, /perm, and /swarm. Memory stays under /memory.`));
     console.log();
     return config;
-    console.log();
-    return config;
 }
 /**
  * Pretty-print a resumed session's conversation history to stdout so
@@ -964,6 +954,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(d('  ') + c('/harness') + d('          — file-level harness component map'));
             console.log(d('  ') + c('/rules') + d('            — show coding rules'));
             console.log(d('  ') + c('/perm <mode>') + d('      — set permission mode (ask/auto/yolo); no arg shows current + always-allow list'));
+            console.log(d('  ') + c('/perm why <tool>') + d(' — explain whether a tool call allows, prompts, or blocks'));
             console.log(d('  ') + c('/perm-reset') + d('       — clear the per-tool always-allow list'));
             console.log(d('  ') + c('/sandbox [level]') + d('  — OS-native bash sandbox (off / standard / strict)'));
             console.log(d('  ') + c('/dry-run') + d('          — toggle dry-run mode'));
@@ -977,6 +968,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(d('  ') + c('/update-docs') + d('      — sync documentation with code'));
             console.log(d('  ') + c('/checkpoint [label]') + d(' — save git state checkpoint'));
             console.log(d('  ') + c('/checkpoints') + d('      — list saved checkpoints'));
+            console.log(d('  ') + c('/context brief') + d('   — cheap local repo/context preflight'));
             console.log(d('  ') + c('/search-first <task>') + d(' — research before coding'));
             console.log(d('  ') + c('/sources <query>') + d(' — direct arXiv/GitHub/HF/Kaggle source scan'));
             console.log(d('  ') + c('/benchmark-repos') + d('  — public Terminal-Bench repo catalog'));
@@ -1399,19 +1391,70 @@ export function handleSlashCommand(input, config, messages, session, mode) {
         // ── Model ─────────────────────────────────────────
         case '/model':
             if (args) {
-                const newModel = switchModel(config, args);
-                if (newModel) {
-                    applyModelSelection(config, newModel);
+                const tokens = tokenizeModelCommandArgs(args);
+                const sub = (tokens[0] || '').toLowerCase();
+                if (sub === 'alias' || sub === 'aliases') {
+                    if (tokens.length === 1 || sub === 'aliases') {
+                        const aliases = listModelAliases(config);
+                        console.log(chalk.cyan('\n  Model aliases:'));
+                        for (const item of aliases) {
+                            const source = item.source === 'builtin' ? 'built-in' : 'user';
+                            console.log(chalk.dim(`  ${item.alias.padEnd(18)} -> ${item.model} (${source})`));
+                        }
+                        console.log(chalk.dim('\n  Set: /model alias <name> <model-id>   Remove: /model unalias <name>'));
+                        return { handled: true };
+                    }
+                    const alias = tokens[1] || '';
+                    const target = tokens.slice(2).join(' ');
+                    const set = setModelAlias(config, alias, target);
+                    if (!set.ok) {
+                        console.log(chalk.yellow(`  ${set.error}`));
+                        return { handled: true };
+                    }
                     saveConfig(config);
-                    resetClient();
-                    console.log(chalk.green(`  Model: ${config.model}`));
+                    console.log(chalk.green(`  Model alias ${alias.toLowerCase()} -> ${set.model}`));
+                    return { handled: true };
                 }
-                else {
-                    applyModelSelection(config, args);
-                    saveConfig(config);
-                    resetClient();
-                    console.log(chalk.green(`  Model: ${config.model} (custom)`));
+                if (sub === 'unalias' || sub === 'remove' || sub === 'rm' || sub === 'delete') {
+                    const alias = tokens[1] || '';
+                    if (!alias) {
+                        console.log(chalk.yellow('  Usage: /model unalias <name>'));
+                        return { handled: true };
+                    }
+                    const removed = deleteModelAlias(config, alias);
+                    if (removed) {
+                        saveConfig(config);
+                        console.log(chalk.green(`  Removed model alias ${alias.toLowerCase()}`));
+                    }
+                    else {
+                        console.log(chalk.yellow(`  No user model alias named ${alias}.`));
+                    }
+                    return { handled: true };
                 }
+                if (sub === 'once' || sub === 'next') {
+                    const parsedOnce = parseModelOnce(config, tokens.slice(1).join(' '));
+                    if (parsedOnce.error || !parsedOnce.override) {
+                        console.log(chalk.yellow(`  ${parsedOnce.error || 'Could not parse one-shot model override.'}`));
+                        return { handled: true };
+                    }
+                    console.log(chalk.green(`  Next turn override: ${formatTurnOverride(parsedOnce.override, config.model)}`));
+                    return { handled: true, turnOverride: parsedOnce.override };
+                }
+                if (sub === 'effort' || sub === 'reasoning') {
+                    const effort = normalizeReasoningEffort(tokens[1]);
+                    if (!effort) {
+                        console.log(chalk.yellow('  Usage: /model effort none|minimal|low|medium|high|xhigh'));
+                        return { handled: true };
+                    }
+                    const turnOverride = { reasoningEffort: effort, source: 'manual' };
+                    console.log(chalk.green(`  Next turn reasoning effort: ${effort}`));
+                    return { handled: true, turnOverride };
+                }
+                const resolvedModel = resolveModelReference(config, args);
+                applyModelSelection(config, resolvedModel.model);
+                saveConfig(config);
+                resetClient();
+                console.log(chalk.green(`  Model: ${formatModelResolution(resolvedModel)}`));
                 return { handled: true };
             }
             // No args. On OpenRouter, the user wants the interactive
@@ -1855,10 +1898,61 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(report.output);
             return { handled: true };
         }
+        case '/context': {
+            const parts = args.split(/\s+/).map((part) => part.trim()).filter(Boolean);
+            const sub = (parts.shift() || '').toLowerCase();
+            if (!sub || sub === 'brief') {
+                const target = parts.join(' ').trim() || process.cwd();
+                console.log(buildContextBrief(target));
+            }
+            else {
+                console.log(chalk.yellow('  Usage: /context brief [path]'));
+            }
+            return { handled: true };
+        }
         case '/rules':
             printRules();
             return { handled: true };
+        case '/agents':
+            console.log(formatAgentsInstructionsReport(process.cwd(), config.model, ALL_TOOLS));
+            return { handled: true };
         case '/perm':
+            if (args.trim().toLowerCase().startsWith('why')) {
+                const parts = args.split(/\s+/).filter(Boolean);
+                parts.shift();
+                const toolName = parts.shift();
+                if (!toolName) {
+                    console.log(chalk.yellow('  Usage: /perm why <tool> [command-or-path]'));
+                    console.log(chalk.dim('  Examples: /perm why bash git status'));
+                    console.log(chalk.dim('            /perm why write_file src/example.ts'));
+                    return { handled: true };
+                }
+                const tool = ALL_TOOLS.find((candidate) => candidate.name === toolName);
+                if (!tool) {
+                    console.log(chalk.red(`  Unknown tool: ${toolName}`));
+                    console.log(chalk.dim('  Run /tools to list available tool names.'));
+                    return { handled: true };
+                }
+                const rest = parts.join(' ');
+                const input = tool.name === 'bash'
+                    ? { command: rest }
+                    : tool.name === 'write_file' || tool.name === 'edit_file' || tool.name === 'read_file'
+                        ? { file_path: rest }
+                        : {};
+                const explanation = explainPermission(tool, input, config);
+                const color = explanation.decision === 'allow'
+                    ? chalk.green
+                    : explanation.decision === 'deny'
+                        ? chalk.red
+                        : chalk.yellow;
+                console.log(chalk.cyan('\n  Permission explanation'));
+                console.log(color(`  Decision: ${explanation.decision.toUpperCase()} - ${explanation.reason}`));
+                for (const line of explanation.lines)
+                    console.log(chalk.dim(`  ${line}`));
+                const sandbox = config.sandbox?.level || 'off';
+                console.log(chalk.dim(`  sandbox: ${sandbox} (separate from permission prompts)`));
+                return { handled: true };
+            }
             if (args && ['ask', 'auto', 'yolo'].includes(args)) {
                 config.permissionMode = args;
                 saveConfig(config);
@@ -1976,7 +2070,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
         }
         // ── Learning & Cost ───────────────────────────────
         case '/usage':
-            printUsageSummary();
+            printUsageSummary(session.id);
             return { handled: true };
         case '/budget': {
             const [daily, monthly] = args.split(/\s+/).map(Number);
@@ -3529,34 +3623,6 @@ async function main() {
     // for screen readers, so they're force-off in that mode. Sighted
     // users get them by default; the CAWDEX_ANIMATIONS=0 env var still
     // overrides for users who specifically don't want the motion.
-    // Saved configs can contain OpenRouter preview models that are known
-    // to hang before the first token. Do not let the CLI boot into that
-    // broken state by default; keep an env escape hatch for deliberate
-    // provider debugging.
-    const runtimeModelOverride = !!process.env.CAWDEX_MODEL_OVERRIDE || !!process.env.CAWDEX_MODEL;
-    const knownFlakyFallback = fallbackModelForKnownFlakyTurn(config)
-        || (process.env.CAWDEX_ALLOW_FLAKY_MODELS !== '1'
-            && isKnownFlakyOpenRouterModel(config)
-            && /openrouter/i.test(config.provider)
-            ? PROVIDERS.openrouter.defaultModel
-            : null);
-    if (knownFlakyFallback) {
-        const previousModel = config.model;
-        applyModelSelection(config, knownFlakyFallback);
-        config.fallbackModel = knownFlakyFallback;
-        resetClient();
-        if (!nonInteractive && !runtimeModelOverride) {
-            saveConfig(config);
-            console.log(theme.warning(`  ⚠  Saved model "${previousModel}" is known to stall; switched config to ${knownFlakyFallback}.`));
-            console.log(theme.dim('     Use CAWDEX_ALLOW_FLAKY_MODELS=1 only if you are deliberately testing that model.'));
-            console.log('');
-        }
-        else if (!nonInteractive) {
-            console.log(theme.warning(`  ⚠  Requested model "${previousModel}" is known to stall; using ${knownFlakyFallback} for this session.`));
-            console.log(theme.dim('     Use CAWDEX_ALLOW_FLAKY_MODELS=1 to force the requested model.'));
-            console.log('');
-        }
-    }
     {
         const { setAnimationConfig } = await import('./animations.js');
         setAnimationConfig({
@@ -3648,6 +3714,29 @@ async function main() {
         },
     });
     let autoRoute = false;
+    let nextTurnOverride = null;
+    const consumeTurnConfig = () => {
+        if (!nextTurnOverride)
+            return config;
+        const override = nextTurnOverride;
+        nextTurnOverride = null;
+        const turnConfig = {
+            ...config,
+            memory: config.memory ? { ...config.memory } : config.memory,
+            sandbox: config.sandbox ? { ...config.sandbox } : config.sandbox,
+            voice: config.voice ? { ...config.voice } : config.voice,
+            openaiAuth: config.openaiAuth ? { ...config.openaiAuth } : config.openaiAuth,
+            swarm: config.swarm ? { ...config.swarm } : config.swarm,
+            footer: config.footer ? { ...config.footer } : config.footer,
+            modelAliases: config.modelAliases ? { ...config.modelAliases } : config.modelAliases,
+        };
+        if (override.model)
+            applyModelSelection(turnConfig, override.model);
+        if (override.reasoningEffort)
+            turnConfig.reasoningEffort = override.reasoningEffort;
+        console.log(chalk.dim(`  [one-shot: ${formatTurnOverride(override, config.model)}]`));
+        return turnConfig;
+    };
     // ── F-key hotkey listener ────────────────────────────────
     // Voice / accessibility hotkeys — all on the F-row.
     //
@@ -4652,6 +4741,10 @@ async function main() {
                 messages.length = 0;
                 messages.push(...result.newMessages);
             }
+            if (result.turnOverride !== undefined) {
+                nextTurnOverride = result.turnOverride;
+            }
+            syncFooter();
             if (trimmed.startsWith('/config') && !result?.shouldExit) {
                 deactivateFooter();
                 config = await setupWizard(rl, config);
@@ -4814,7 +4907,10 @@ async function main() {
                     messages.push({ role: 'user', content: result.injectPrompt });
                 }
                 await saveWithSnapshot();
-                await runQuery({ config, messages, cwd: process.cwd(), rl, sessionId: session.id, mode: mode.current });
+                const turnConfig = consumeTurnConfig();
+                updateFooter(buildFooterSnapshot(turnConfig, mode.current, session, process.cwd()));
+                await runQuery({ config: turnConfig, messages, cwd: process.cwd(), rl, sessionId: session.id, mode: mode.current });
+                syncFooter();
                 await saveWithSnapshot();
                 continue;
             }
@@ -4843,22 +4939,24 @@ async function main() {
             const route = routeModel(config, complexity);
             if (route.model !== config.model) {
                 console.log(chalk.dim(`  [routing: ${route.reason}]`));
-                applyModelSelection(config, route.model);
-                resetClient();
+                nextTurnOverride = { model: route.model, source: 'route' };
             }
             autoRoute = false;
         }
         // Add user message and run query
         messages.push({ role: 'user', content: trimmed });
         await saveWithSnapshot();
+        const turnConfig = consumeTurnConfig();
+        updateFooter(buildFooterSnapshot(turnConfig, mode.current, session, process.cwd()));
         await runQuery({
-            config,
+            config: turnConfig,
             messages,
             cwd: process.cwd(),
             rl,
             sessionId: session.id,
             mode: mode.current,
         });
+        syncFooter();
         // Auto-save session
         await saveWithSnapshot();
         // Strategic compaction check