cawdex 1.35.69 → 1.35.74

package/dist/index.js

@@ -27,7 +27,7 @@ import { initHooksDir, runHooks, listHooks, saveHooksConfig, clearQuarantinedHoo
 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 } from './modes.js';
+import { MODES, listModes, normalizeModeName } from './modes.js';
 import { printModelOptions, switchModel, classifyComplexity, routeModel } from './model-router.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';
@@ -79,7 +79,7 @@ import { status as sandboxStatus } from './sandbox.js';
 // API key rotation pool (/keys)
 import { listStatus as keyPoolStatus, setPool as syncKeyPool } from './key-rotation.js';
 // Agentic swarm — fan-out concurrent agents on the same task (/swarm)
-import { buildSwarmAgentTask, buildSwarmPlan, decodeSwarmSentinel, encodeSwarmSentinel, formatSwarmResults, parseSwarmCommandArgs, resolveAgents, runSwarm, } from './swarm.js';
+import { buildSwarmAgentTask, buildSwarmPlan, clampSwarmMaxAgents, decodeSwarmSentinel, encodeSwarmSentinel, formatSwarmResults, parseSwarmCommandArgs, resolveAgents, runSwarm, } from './swarm.js';
 // Voice / accessibility — built-in dictation (Whisper) + readout (ElevenLabs)
 import { printVoiceStatus, isVoiceEnabled, getTtsConfig, getSttConfig, getAccessibilityConfig, speak, dictateOnce, } from './voice.js';
 import { isFfmpegAvailable, audioCue, startRecording, probeMic, micProbeMessage } from './audio.js';
@@ -88,6 +88,8 @@ import { COMMAND_CATALOG, allSlashCommandNames, completeSlashCommandNames, resol
 import { inlineSuggest, resolveInlineSuggestQuestionInput } from './inline-suggest.js';
 import { normalizeTypeaheadDraftForPrompt } from './prompt-buffer.js';
 import { maybeInstantAnswer } from './instant-answer.js';
+import { getCurrentVersion, startStartupUpdateCheck } from './updater.js';
+import { activateFooter, askWithFooterPrompt, buildFooterSnapshot, deactivateFooter, isFooterActive, shouldUseFixedFooter, updateFooter, } from './fixed-footer.js';
 /**
  * Unified prompt resolver — prefers the bundled ECC prompt for a given
  * intent and falls back to the built-in builder when ECC isn't installed.
@@ -127,8 +129,8 @@ function clipSetupValue(value, max = 120) {
     const single = value.replace(/\s+/g, ' ').trim();
     return single.length <= max ? single : single.slice(0, max - 1) + '…';
 }
-async function runSwarmSetupWizard(rl, plan) {
-    if (!stdin.isTTY || process.env.CAWDEX_SWARM_WIZARD === '0')
+async function runSwarmSetupWizard(rl, plan, config) {
+    if (!stdin.isTTY || process.env.CAWDEX_SWARM_WIZARD === '0' || config.swarm?.setupWizard === false)
         return plan;
     const next = {
         ...plan,
@@ -189,6 +191,115 @@ function printUnknownSlashCommand(cmd) {
     console.log(d('  Did you mean: ') + suggestions.map((entry) => c(entry.command)).join(d(', ')));
     console.log(d('  Try: ') + c(`/help ${suggestions[0].command}`) + d(' for exact usage.'));
 }
+async function promptSecretLine(rl, prompt, existingValue = '') {
+    const suffix = existingValue ? ' [stored; Enter keeps it]' : '';
+    const label = `${prompt}${suffix}: `;
+    if (!stdin.isTTY || !stdout.isTTY) {
+        const answer = await rl.question(chalk.yellow(label));
+        return answer.trim() || existingValue;
+    }
+    return new Promise((resolve) => {
+        let value = '';
+        const wasRaw = stdin.isRaw;
+        const keypressListeners = stdin.listeners('keypress').slice();
+        const detached = keypressListeners.filter((listener) => !listener.__cawdexHotkey__);
+        function render() {
+            const shown = value ? '*'.repeat(Math.min(value.length, 16)) : '';
+            stdout.write(`\r\x1b[2K${chalk.yellow(label)}${chalk.dim(shown)}`);
+        }
+        function cleanup() {
+            stdin.removeListener('data', onData);
+            for (const listener of detached)
+                stdin.on('keypress', listener);
+            try {
+                stdin.setRawMode(wasRaw);
+            }
+            catch { /* noop */ }
+            stdout.write('\n');
+        }
+        function done(nextValue) {
+            cleanup();
+            resolve(nextValue.trim() || existingValue);
+        }
+        function onData(buf) {
+            if (buf.length === 1 && buf[0] === 0x03) {
+                cleanup();
+                process.exit(130);
+            }
+            if (buf.length === 1 && buf[0] === 0x1B) {
+                done(existingValue);
+                return;
+            }
+            if (buf.length === 1 && (buf[0] === 0x0D || buf[0] === 0x0A)) {
+                done(value);
+                return;
+            }
+            if (buf.length === 1 && (buf[0] === 0x7F || buf[0] === 0x08)) {
+                value = value.slice(0, -1);
+                render();
+                return;
+            }
+            const text = buf.toString('utf8').replace(/[^\x20-\x7E]/g, '');
+            if (text) {
+                value += text;
+                render();
+            }
+        }
+        for (const listener of detached)
+            stdin.removeListener('keypress', listener);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch { /* noop */ }
+        stdin.resume();
+        stdin.on('data', onData);
+        render();
+    });
+}
+async function runAppearanceWizard(rl, config) {
+    const themeChoices = [
+        { label: 'full', detail: 'banner and full context on launch', value: 'full' },
+        { label: 'compact', detail: 'same banner, tighter future surfaces', value: 'compact' },
+        { label: 'minimal', detail: 'small launch header', value: 'minimal' },
+    ];
+    const currentTheme = config.theme || 'full';
+    const themeDefault = Math.max(0, themeChoices.findIndex((choice) => choice.value === currentTheme));
+    const selectedTheme = await selectConfigChoice(rl, 'Display theme', themeChoices, {
+        defaultIndex: themeDefault,
+        fallbackPrompt: `  Display theme [${themeDefault + 1}]: `,
+        parseFallback: (answer, defaultIndex) => {
+            const raw = (answer || String(defaultIndex + 1)).trim().toLowerCase();
+            const byName = themeChoices.find((choice) => choice.value === raw);
+            if (byName)
+                return byName.value;
+            return themeChoices[Number.parseInt(raw, 10) - 1]?.value;
+        },
+    });
+    const paletteChoices = listPalettes().map((meta) => ({
+        label: meta.id,
+        detail: meta.description,
+        value: meta.id,
+    }));
+    const currentPalette = getPaletteId();
+    const paletteDefault = Math.max(0, paletteChoices.findIndex((choice) => choice.value === currentPalette));
+    const selectedPalette = await selectConfigChoice(rl, 'Color palette', paletteChoices, {
+        defaultIndex: paletteDefault,
+        fallbackPrompt: `  Color palette [${paletteDefault + 1}]: `,
+        parseFallback: (answer, defaultIndex) => {
+            const raw = (answer || String(defaultIndex + 1)).trim().toLowerCase();
+            const resolved = resolvePaletteId(raw);
+            if (resolved)
+                return resolved;
+            return paletteChoices[Number.parseInt(raw, 10) - 1]?.value;
+        },
+    });
+    config.theme = selectedTheme;
+    setPalette(selectedPalette);
+    config.palette = selectedPalette;
+    saveConfig(config);
+    console.log(theme.brandBold(`  ${sym.mark} Appearance: ${selectedTheme} / ${selectedPalette}`));
+    console.log(theme.dim('  Brand · ') + theme.brand('brand') + theme.dim(' · ') + theme.success('success') + theme.dim(' · ') + theme.warning('warning') + theme.dim(' · ') + theme.error('error') + theme.dim(' · ') + theme.command('command'));
+}
 async function setupWizard(rl, currentConfig) {
     console.log(chalk.bold.cyan(`\n  ${BRAND_NAME} — First-time Setup\n`));
     const providerKeys = Object.keys(PROVIDERS);
@@ -220,8 +331,9 @@ async function setupWizard(rl, currentConfig) {
     }
     let apiKey = '';
     let openaiAuth;
+    const sameProvider = normalizeProvider(currentConfig?.provider ?? '') === normalizeProvider(provider.name);
     if (provider.requiresKey) {
-        apiKey = await rl.question(chalk.yellow(`  API Key for ${provider.name}: `));
+        apiKey = await promptSecretLine(rl, `  API Key for ${provider.name}`, sameProvider ? currentConfig?.apiKey ?? '' : '');
     }
     if (providerKey === 'openai-codex') {
         openaiAuth = {
@@ -241,7 +353,6 @@ async function setupWizard(rl, currentConfig) {
             console.log(chalk.dim(`  After setup, run /openai-login or run "codex login". ${BRAND_NAME} will read ~/.codex/auth.json.`));
         }
     }
-    const sameProvider = normalizeProvider(currentConfig?.provider ?? '') === normalizeProvider(provider.name);
     let model = sameProvider && currentConfig?.model ? currentConfig.model : provider.defaultModel;
     const modelInput = await rl.question(chalk.yellow(`  Model [${model}]: `));
     if (modelInput.trim())
@@ -274,6 +385,46 @@ async function setupWizard(rl, currentConfig) {
         console.log(chalk.dim('  Free variants usually end with :free. Switch later with /openrouter-free or /model <id>.'));
         console.log('');
     }
+    let fallbackModel;
+    if (providerKey === 'openrouter') {
+        const currentFallback = sameProvider ? currentConfig?.fallbackModel : undefined;
+        const fallbackDefaultIndex = currentFallback === PROVIDERS.openrouter.defaultModel
+            ? 1
+            : currentFallback
+                ? 2
+                : 0;
+        console.log(chalk.white('  OpenRouter fallback'));
+        console.log(chalk.dim('  Fallback retries can hide a bad primary model by silently switching to another model.'));
+        console.log(chalk.dim('  Choose explicitly; you can change this later with /fallback.'));
+        const fallbackChoice = await selectConfigChoice(rl, 'Fallback behavior', [
+            { label: 'Disable fallback', detail: 'show the primary model failure; never switch to free automatically', value: 'off' },
+            { label: 'Use openrouter/free', detail: 'retry once with the free router on timeout, empty, or cryptic errors', value: 'free' },
+            { label: 'Custom fallback model', detail: 'enter a specific OpenRouter model id', value: 'custom' },
+        ], {
+            defaultIndex: fallbackDefaultIndex,
+            fallbackPrompt: `  Fallback behavior [${fallbackDefaultIndex + 1}]: `,
+            parseFallback: (answer, defaultIndex) => {
+                const raw = (answer || String(defaultIndex + 1)).trim().toLowerCase();
+                if (['off', 'none', 'disable', 'disabled', 'no', 'n', '1'].includes(raw))
+                    return 'off';
+                if (['free', 'openrouter/free', 'yes', 'y', '2'].includes(raw))
+                    return 'free';
+                if (['custom', 'model', '3'].includes(raw))
+                    return 'custom';
+                return undefined;
+            },
+        });
+        if (fallbackChoice === 'free')
+            fallbackModel = PROVIDERS.openrouter.defaultModel;
+        if (fallbackChoice === 'custom') {
+            const customFallback = currentFallback && currentFallback !== PROVIDERS.openrouter.defaultModel
+                ? currentFallback
+                : '';
+            const answer = await rl.question(chalk.yellow(`  Fallback model${customFallback ? ` [${customFallback}]` : ''}: `));
+            fallbackModel = answer.trim() || customFallback || undefined;
+        }
+        console.log('');
+    }
     const permissionChoices = [
         { label: 'ask', detail: 'prompt before writes/commands (safest)', value: 'ask' },
         { label: 'auto', detail: 'auto-approve reads, ask for destructive', value: 'auto' },
@@ -293,21 +444,17 @@ async function setupWizard(rl, currentConfig) {
             return byNumber?.value;
         },
     });
-    // ── MemPalace memory setup ──────────────────────────────
-    // Featured capability, opt-out at setup time. Explain briefly so the
-    // user can make an informed choice — most users want this on.
-    console.log(chalk.white('\n  MemPalace persistent memory'));
-    console.log(chalk.dim('  Lets the agent remember your preferences, codebase landmarks, and lessons across sessions.'));
-    console.log(chalk.dim('  Two stores: global (~/.cawdex/memory) for cross-project facts, project (.cawdex/memory'));
-    console.log(chalk.dim('  in each repo) for codebase-specific knowledge. Searchable via /memory or by the agent itself.'));
-    console.log(chalk.dim('  Zero external dependencies; storage is local JSON files. Can be toggled anytime via /memory disable.'));
-    const memoryDefaultIndex = currentConfig?.memory?.enabled === false ? 1 : 0;
-    const memoryEnabled = await selectConfigChoice(rl, 'Enable MemPalace memory', [
-        { label: 'Enable', detail: 'local global + project memory stores', value: true },
-        { label: 'Disable', detail: 'can be re-enabled later with /memory enable', value: false },
+    // /config stays focused on the main live controls: model/fallback,
+    // permissions, and swarm. Other subsystems keep their own commands.
+    console.log(chalk.white('\n  Swarm settings'));
+    console.log(chalk.dim('  Defaults for /swarm <task>. Per-task setup still comes from the task text.'));
+    const swarmWizardDefaultIndex = currentConfig?.swarm?.setupWizard === false ? 1 : 0;
+    const swarmSetupWizard = await selectConfigChoice(rl, 'Swarm setup wizard', [
+        { label: 'Enable', detail: 'ask goal/budget/stack/assets/quality before natural /swarm tasks', value: true },
+        { label: 'Disable', detail: 'infer setup fields without asking', value: false },
     ], {
-        defaultIndex: memoryDefaultIndex,
-        fallbackPrompt: `  Enable MemPalace memory? [${memoryDefaultIndex === 0 ? 'Y/n' : 'y/N'}]: `,
+        defaultIndex: swarmWizardDefaultIndex,
+        fallbackPrompt: `  Swarm setup wizard? [${swarmWizardDefaultIndex === 0 ? 'Y/n' : 'y/N'}]: `,
         parseFallback: (answer, defaultIndex) => {
             const raw = answer.trim().toLowerCase();
             if (!raw)
@@ -324,31 +471,51 @@ async function setupWizard(rl, currentConfig) {
             return undefined;
         },
     });
+    const currentMaxAgents = clampSwarmMaxAgents(currentConfig?.swarm?.maxAgents);
+    const maxAgentsAnswer = await rl.question(chalk.yellow(`  Max swarm agents [${currentMaxAgents}]: `));
+    const maxAgents = maxAgentsAnswer.trim()
+        ? clampSwarmMaxAgents(Number.parseInt(maxAgentsAnswer.trim(), 10))
+        : currentMaxAgents;
+    const askOptionalSwarmDefault = async (label, current) => {
+        const answer = await rl.question(chalk.yellow(`  ${label}${current ? ` [${current}]` : ''}: `));
+        return answer.trim() || current || undefined;
+    };
+    const defaultBudget = await askOptionalSwarmDefault('Default budget/time', currentConfig?.swarm?.defaultBudget);
+    const defaultTarget = await askOptionalSwarmDefault('Default target platform/stack', currentConfig?.swarm?.defaultTarget);
+    const defaultAssets = await askOptionalSwarmDefault('Default starting assets/resources', currentConfig?.swarm?.defaultAssets);
+    const defaultQuality = await askOptionalSwarmDefault('Default quality bar/release target', currentConfig?.swarm?.defaultQuality);
     const config = {
+        ...(currentConfig ?? {}),
         apiKey,
         baseURL,
         model,
-        fallbackModel: providerKey === 'openrouter' ? PROVIDERS.openrouter.defaultModel : undefined,
         provider: provider.name,
-        ...(openaiAuth ? { openaiAuth } : {}),
-        maxTokens: 8192,
-        temperature: 0.3,
+        maxTokens: currentConfig?.maxTokens ?? 8192,
+        temperature: currentConfig?.temperature ?? 0.3,
         permissionMode: permMode,
-        memory: {
-            enabled: memoryEnabled,
-            globalScope: true,
-            projectScope: true,
+        swarm: {
+            setupWizard: swarmSetupWizard,
+            maxAgents,
+            ...(defaultBudget ? { defaultBudget } : {}),
+            ...(defaultTarget ? { defaultTarget } : {}),
+            ...(defaultAssets ? { defaultAssets } : {}),
+            ...(defaultQuality ? { defaultQuality } : {}),
         },
     };
+    if (fallbackModel)
+        config.fallbackModel = fallbackModel;
+    else
+        delete config.fallbackModel;
+    if (openaiAuth)
+        config.openaiAuth = openaiAuth;
+    else
+        delete config.openaiAuth;
     applyModelSelection(config, model);
     saveConfig(config);
     console.log(chalk.green(`\n  Config saved to ${getConfigDir()}/config.json`));
-    if (memoryEnabled) {
-        console.log(chalk.dim(`  MemPalace: ENABLED — 7 memory_* tools available to the agent. Storage created on first write.`));
-    }
-    else {
-        console.log(chalk.dim(`  MemPalace: disabled. Re-enable anytime with /memory enable.`));
-    }
+    console.log(chalk.dim(`  Configured: /model, /fallback, /perm, and /swarm. Memory stays under /memory.`));
+    console.log();
+    return config;
     console.log();
     return config;
 }
@@ -494,6 +661,9 @@ function printResumedHistory(messages, sessionName) {
  *     and modeTag, so this is effectively a no-op there.
  */
 async function askWithDecoratedPrompt(rl, sessionTag, modeTag, promptGlyph, prefill = '') {
+    if (isFooterActive()) {
+        return askWithFooterPrompt(rl, prefill);
+    }
     const decorative = sessionTag + modeTag;
     if (decorative.length > 0) {
         process.stdout.write(decorative);
@@ -691,7 +861,10 @@ function parseSlashCommand(input) {
 //   { handled: true }              — local command, output printed to stdout
 //   { handled: false, injectPrompt } — LLM-driven, prompt ready to send
 export function handleSlashCommand(input, config, messages, session, mode) {
-    const { cmd, args } = parseSlashCommand(input);
+    const parsed = parseSlashCommand(input);
+    const resolved = resolveCommandEntry(parsed.cmd);
+    const cmd = resolved?.entry.command ?? parsed.cmd;
+    const args = parsed.args;
     switch (cmd) {
         // ── Help ──────────────────────────────────────────
         case '/help': {
@@ -715,6 +888,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(d('  ') + c('/theme [mode]') + d('     — toggle display mode (full/compact/minimal)'));
             console.log(d('  ') + c('/palette [id]') + d('     — switch color palette; run /palettes to list'));
             console.log(d('  ') + c('/palettes') + d('         — list available color palettes with preview'));
+            console.log(d('  ') + c('/footer [sub]') + d('    — customize the fixed bottom footer and startup prompt'));
             console.log(d('  ') + c('/clear') + d('            — clear conversation'));
             console.log(d('  ') + c('/back [n]') + d('         — rewind to before the nth most-recent user turn (no arg lists turns)'));
             console.log(d('  ') + c('/fork [name]') + d('      — branch current conversation; previous session reachable via /resume (alias: /branch)'));
@@ -742,9 +916,9 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(d('  ') + c('/keys [add|rm]') + d('    — multi-key rotation pool (e.g. several OpenRouter accounts)'));
             console.log(d('  ') + c('/route') + d('            — auto-route model based on next message'));
             console.log(h('\n  ── Modes ──'));
-            console.log(d('  ') + c('/mode [name]') + d('      — switch mode (dev/review/tdd/research/plan/debug/architect/hermes/design)'));
+            console.log(d('  ') + c('/mode [name]') + d('      — switch mode (dev/review/tdd/research/plan/debug/architect/sentience/design)'));
             console.log(d('  ') + c('/modes') + d('            — list all modes (read-only; use /mode <name> to switch)'));
-            console.log(d('  ') + c('/hermes') + d('           — alias for /mode hermes (self-improving learning loop)'));
+            console.log(d('  ') + c('/sentience') + d('        — self-improving learning loop (alias: /hermes)'));
             console.log(d('  ') + c('/design [task]') + d('    — switch to design mode (Stitch-powered UI generation); optional task to start immediately'));
             console.log(h('\n  ── Session ──'));
             console.log(d('  ') + c('/sessions') + d('         — list saved sessions'));
@@ -890,10 +1064,90 @@ export function handleSlashCommand(input, config, messages, session, mode) {
                 }
             }
             else {
-                const current = config.theme || 'full';
-                console.log(chalk.dim(`  Current theme: ${current}`));
+                return { handled: true, injectPrompt: '__PICK_APPEARANCE__' };
             }
             return { handled: true };
+        case '/footer': {
+            const input = args.trim();
+            const parts = input.split(/\s+/).filter(Boolean);
+            const sub = (parts[0] || '').toLowerCase();
+            config.footer = config.footer ?? { enabled: true, openingPrompt: '/model' };
+            const refreshFooter = () => {
+                const snapshot = buildFooterSnapshot(config, mode.current, session, process.cwd());
+                if (shouldUseFixedFooter(config))
+                    activateFooter(snapshot);
+                else
+                    deactivateFooter();
+                updateFooter(snapshot);
+            };
+            const printStatus = () => {
+                console.log(theme.header('\n  Footer'));
+                console.log(theme.dim(`  Enabled:        ${config.footer?.enabled === false ? 'off' : 'on'}`));
+                console.log(theme.dim(`  Version:        ${getCurrentVersion()}`));
+                console.log(theme.dim(`  Opening prompt: ${config.footer?.openingPrompt ?? '/model'}`));
+                console.log(theme.dim(`  Status row:     ${config.footer?.template || '(default)'}`));
+                console.log(theme.dim(`  Template keys:  {provider}, {model}, {permissions}, {session}, {mode}, {cwd}, {workspace}, {sandbox}, {cost}, {budget}, {activity}, {version}`));
+                console.log(theme.dim('\n  Commands:'));
+                console.log(theme.dim('    /footer on | off'));
+                console.log(theme.dim('    /footer text Provider {provider} | Model {model} | v{version}'));
+                console.log(theme.dim('    /footer opening /model     (or: /footer opening off)'));
+                console.log(theme.dim('    /footer clear              (clear custom status row)'));
+                console.log(theme.dim('    /footer reset              (default footer + /model opening prompt)'));
+            };
+            if (!sub) {
+                printStatus();
+                return { handled: true };
+            }
+            if (sub === 'on') {
+                config.footer.enabled = true;
+                saveConfig(config);
+                refreshFooter();
+                console.log(chalk.green('  Footer: on'));
+                return { handled: true };
+            }
+            if (sub === 'off') {
+                config.footer.enabled = false;
+                saveConfig(config);
+                refreshFooter();
+                console.log(chalk.green('  Footer: off'));
+                return { handled: true };
+            }
+            if (sub === 'reset') {
+                config.footer = { enabled: true, openingPrompt: '/model' };
+                saveConfig(config);
+                refreshFooter();
+                console.log(chalk.green('  Footer reset to defaults.'));
+                return { handled: true };
+            }
+            if (sub === 'clear') {
+                delete config.footer.template;
+                saveConfig(config);
+                refreshFooter();
+                console.log(chalk.green('  Footer status row: default'));
+                return { handled: true };
+            }
+            if (sub === 'opening') {
+                const value = input.slice(parts[0].length).trim();
+                config.footer.openingPrompt = /^(off|none|disable)$/i.test(value) ? '' : (value || '/model');
+                saveConfig(config);
+                refreshFooter();
+                console.log(chalk.green(`  Footer opening prompt: ${config.footer.openingPrompt || '(off)'}`));
+                return { handled: true };
+            }
+            const template = sub === 'text'
+                ? input.slice(parts[0].length).trim()
+                : input;
+            if (!template) {
+                printStatus();
+                return { handled: true };
+            }
+            config.footer.template = template;
+            saveConfig(config);
+            refreshFooter();
+            console.log(chalk.green('  Footer status row updated.'));
+            console.log(chalk.dim(`  ${template}`));
+            return { handled: true };
+        }
         // ── Clear ─────────────────────────────────────────
         case '/clear': {
             // Also reset the global state that's keyed to the conversation
@@ -1174,7 +1428,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             if (!target) {
                 const cur = config.fallbackModel ?? '(not set)';
                 console.log(chalk.dim(`  Current fallback model: ${cur}`));
-                console.log(chalk.dim(`  Used once per chain when the primary returns "unknown" provider errors.`));
+                console.log(chalk.dim(`  Used once per chain when the primary times out, returns empty text, or hits an unknown provider error.`));
                 console.log(chalk.dim(`  Set with: /fallback <model-id>  · disable with: /fallback off`));
                 return { handled: true };
             }
@@ -1187,18 +1441,19 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             config.fallbackModel = target;
             saveConfig(config);
             console.log(chalk.green(`  Fallback model: ${target}`));
-            console.log(chalk.dim(`  Will be tried automatically once per chain if ${config.model} returns a cryptic provider error.`));
+            console.log(chalk.dim(`  Will be tried automatically once per chain if ${config.model} times out, returns empty text, or hits an unknown provider error.`));
             return { handled: true };
         }
         case '/openrouter-free': {
             config.provider = PROVIDERS.openrouter.name;
             config.baseURL = PROVIDERS.openrouter.baseURL;
             applyModelSelection(config, PROVIDERS.openrouter.defaultModel);
-            config.fallbackModel = PROVIDERS.openrouter.defaultModel;
+            config.fallbackModel = undefined;
             saveConfig(config);
             resetClient();
             console.log(chalk.green('  OpenRouter free-tier mode enabled.'));
             console.log(chalk.dim(`  Model: ${config.model}`));
+            console.log(chalk.dim('  Fallback: disabled. Enable explicitly with /fallback <model-id>.'));
             console.log(chalk.dim('  The free router picks a currently available zero-cost model that supports the request shape.'));
             return { handled: true };
         }
@@ -1280,8 +1535,8 @@ export function handleSlashCommand(input, config, messages, session, mode) {
         }
         // ── Mode ──────────────────────────────────────────
         case '/mode':
-            if (args && MODES[args]) {
-                mode.current = args;
+            if (args && normalizeModeName(args)) {
+                mode.current = normalizeModeName(args);
                 const m = MODES[mode.current];
                 console.log(chalk.green(`  Mode: ${m.label} — ${m.description}`));
                 // Soft hint when switching mode with conversation history present.
@@ -1310,10 +1565,11 @@ export function handleSlashCommand(input, config, messages, session, mode) {
                 console.log(chalk.dim(`  Current: ${mode.current} (${MODES[mode.current].description})`));
             }
             return { handled: true };
-        // ── Hermes shorthand (inspired by nousresearch/hermes-agent) ──
+        // ── Sentience shorthand (/hermes remains a compatibility alias) ──
+        case '/sentience':
         case '/hermes': {
-            mode.current = 'hermes';
-            const m = MODES.hermes;
+            mode.current = 'sentience';
+            const m = MODES.sentience;
             console.log(chalk.cyan(`  Mode: ${m.label}`));
             console.log(chalk.dim(`  ${m.description}`));
             console.log(chalk.dim(`  Recall → user-model → parallelize → distill → persist → schedule.`));
@@ -1442,9 +1698,10 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             // mode.current is a { current: Mode } box (shared closure
             // ref) so mutation propagates to the hotkey listener +
             // prompt rendering automatically.
-            if (loaded.mode && loaded.mode !== mode.current) {
-                changes.push(`mode ${mode.current} → ${loaded.mode}`);
-                mode.current = loaded.mode;
+            const loadedMode = loaded.mode ? normalizeModeName(loaded.mode) : null;
+            if (loadedMode && loadedMode !== mode.current) {
+                changes.push(`mode ${mode.current} -> ${loadedMode}`);
+                mode.current = loadedMode;
             }
             // Adopt the resumed session's identity so subsequent
             // autosaves write to its file, not the current session's.
@@ -2802,9 +3059,7 @@ export function handleSlashCommand(input, config, messages, session, mode) {
         case '/palette': {
             const target = args.trim().toLowerCase();
             if (!target) {
-                console.log(chalk.dim(`  Current palette: ${getPaletteId()}`));
-                console.log(chalk.dim(`  Run /palettes to see all options.`));
-                return { handled: true };
+                return { handled: true, injectPrompt: '__PICK_APPEARANCE__' };
             }
             const resolved = resolvePaletteId(target);
             if (!resolved) {
@@ -3316,6 +3571,16 @@ async function main() {
         permissionMode: config.permissionMode,
     });
     const messages = [];
+    const syncFooter = () => {
+        const snapshot = buildFooterSnapshot(config, mode.current, session, process.cwd());
+        if (!nonInteractive && shouldUseFixedFooter(config)) {
+            activateFooter(snapshot);
+        }
+        else {
+            deactivateFooter();
+        }
+        updateFooter(snapshot);
+    };
     // Session start hook + memory persistence
     await runHooks({ event: 'SessionStart', sessionId: session.id, cwd: process.cwd(), permissionMode: config.permissionMode });
     const memoryContext = onSessionStart(session.id, process.cwd());
@@ -3361,6 +3626,17 @@ async function main() {
         console.log(theme.dim(`     Free-tier-safe switch: /openrouter-free`));
         console.log('');
     }
+    syncFooter();
+    startStartupUpdateCheck({
+        onUpdateStarted: (currentVersion, latestVersion) => {
+            deactivateFooter();
+            console.log(theme.info(`  Update available: cawdex ${currentVersion} -> ${latestVersion}. Downloading in the background; restart Cawdex to use it.`));
+            syncFooter();
+        },
+        onError: (error) => {
+            dbgEmit('debug', 'update.check.failed', { error: error.slice(0, 200) });
+        },
+    });
     let autoRoute = false;
     // ── F-key hotkey listener ────────────────────────────────
     // Voice / accessibility hotkeys — all on the F-row.
@@ -4202,6 +4478,7 @@ async function main() {
         });
         messages.push({ role: 'user', content: resolvedPrompt.prompt });
         try {
+            await saveWithSnapshot();
             await runQuery({
                 config,
                 messages,
@@ -4235,10 +4512,12 @@ async function main() {
             process.exit(1);
         }
     }
+    let firstInteractivePrompt = true;
     // Main REPL loop
     while (true) {
         let input;
         try {
+            syncFooter();
             // Screen-reader-aware prompt construction:
             //   - The Unicode prompt glyph (❯) gets re-substituted by the
             //     symbol→word filter on EVERY readline redraw (one per keystroke),
@@ -4260,7 +4539,9 @@ async function main() {
             // repaints the prompt line on every render — it needs both the
             // styled string (to write with color) and the visible-char
             // length (to position the cursor at end-of-filter).
-            const promptStyled = sessionTag + modeTag + theme.prompt(promptGlyph);
+            const promptStyled = isFooterActive()
+                ? theme.prompt('> ')
+                : sessionTag + modeTag + theme.prompt(promptGlyph);
             globalThis
                 .__cawdexPromptStyled = promptStyled;
             globalThis
@@ -4276,7 +4557,11 @@ async function main() {
             g.__cawdexQueuedInput = undefined;
             g.__cawdexSlashPrefillInput = undefined;
             const restoredDraft = normalizeTypeaheadDraftForPrompt(queued);
-            const prefill = slashPrefill || restoredDraft;
+            const openingPrompt = firstInteractivePrompt && isFooterActive()
+                ? (config.footer?.openingPrompt ?? '/model')
+                : '';
+            firstInteractivePrompt = false;
+            const prefill = slashPrefill || restoredDraft || openingPrompt;
             input = await askWithDecoratedPrompt(rl, sessionTag, modeTag, promptGlyph, prefill);
         }
         catch {
@@ -4342,9 +4627,11 @@ async function main() {
                 messages.push(...result.newMessages);
             }
             if (trimmed.startsWith('/config') && !result?.shouldExit) {
+                deactivateFooter();
                 config = await setupWizard(rl, config);
                 resetClient();
                 printThemedBanner(config.provider, config.model, mode.current, config.permissionMode, session.id, ALL_TOOLS.map((t) => t.name));
+                syncFooter();
                 continue;
             }
             if (trimmed === '/route') {
@@ -4402,6 +4689,10 @@ async function main() {
                     }
                     continue;
                 }
+                else if (result.injectPrompt === '__PICK_APPEARANCE__') {
+                    await runAppearanceWizard(rl, config);
+                    continue;
+                }
                 else if (result.injectPrompt === '__RESUME_PICK__') {
                     const sessions = listSessions();
                     if (sessions.length === 0) {
@@ -4466,9 +4757,9 @@ async function main() {
                         console.log(chalk.yellow('  /swarm: could not parse swarm payload.'));
                         continue;
                     }
-                    let plan = buildSwarmPlan(payload);
+                    let plan = buildSwarmPlan(payload, config.swarm);
                     if (payload.mode === 'auto') {
-                        plan = await runSwarmSetupWizard(rl, plan);
+                        plan = await runSwarmSetupWizard(rl, plan, config);
                     }
                     try {
                         const agents = resolveAgents(plan.agents);
@@ -4496,6 +4787,7 @@ async function main() {
                 else {
                     messages.push({ role: 'user', content: result.injectPrompt });
                 }
+                await saveWithSnapshot();
                 await runQuery({ config, messages, cwd: process.cwd(), rl, sessionId: session.id, mode: mode.current });
                 await saveWithSnapshot();
                 continue;
@@ -4524,6 +4816,7 @@ async function main() {
         }
         // Add user message and run query
         messages.push({ role: 'user', content: trimmed });
+        await saveWithSnapshot();
         await runQuery({
             config,
             messages,
@@ -4545,12 +4838,14 @@ async function main() {
     await runHooks({ event: 'SessionStop', sessionId: session.id, cwd: process.cwd(), permissionMode: config.permissionMode });
     // Final save
     await saveWithSnapshot();
+    deactivateFooter();
     console.log(chalk.dim(`\nSession saved: ${session.id}`));
     console.log(chalk.dim('Goodbye!\n'));
     rl.close();
     process.exit(0);
 }
 main().catch((err) => {
+    deactivateFooter();
     console.error(chalk.red(`Fatal: ${err.message || err}`));
     process.exit(1);
 });