@nguyenhuumanh/vyen 0.2.23 → 0.3.0

package/dist/cli.js

@@ -1,76 +1,31 @@
 import { parseArgs } from 'node:util';
 import { createInterface } from 'node:readline/promises';
 import { stdin, stdout, stderr } from 'node:process';
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, fstatSync, readFileSync, statSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { DEFAULT_GATEWAY_URL, EFFORT_LEVELS, configPath, dataDir, legacyConfigDir, legacyDataDir, configDir, loadConfig, normalizeGatewayUrl, resolveApiKey, resolveRuntime, saveConfig, } from './config.js';
+import { DEFAULT_GATEWAY_URL, EFFORT_LEVELS, configPath, configDir, dataDir, legacyConfigDir, legacyDataDir, loadConfig, normalizeGatewayUrl, resolveApiKey, resolveRuntime, saveConfig, } from './config.js';
 import { safeError } from './errors.js';
 import { VERSION } from './version.js';
-import { InputCancelledError, padEndVisible, sliceVisible, terminalText as cleanTerminal, TerminalUI, visibleLength } from './tui.js';
+import { HELP } from './help.js';
+import { InputCancelledError, terminalText as cleanTerminal, TerminalUI } from './tui.js';
 import { EFFORT_DESCRIPTIONS, parseEffortInput, runSetupWizard } from './setup.js';
 import { discoverModels, formatModelBadge, resolveModelCapabilities } from './provider.js';
-const HELP = `vyen cli ${VERSION} — independent coding harness
-
-Usage: vyen [options] [prompt]
-       vyen resume [ID|latest|number]
-       vyen setup
-       vyen init --provider openai-compatible --base-url URL --model MODEL [--effort LEVEL]
-       vyen doctor | sessions
-       vyen mcp list | check [name] | get <name> | add <name> ... | remove <name> | import-codex [name...]
-
-Options:
-  -p, --prompt TEXT          Run one task (or pipe a prompt on stdin)
-  -C, --cwd DIRECTORY        Workspace (defaults to current directory)
-      --provider NAME        openai-compatible | openai-responses | anthropic
-      --base-url URL         Provider API root, usually ending in /v1
-      --model NAME           Exact model ID from your provider
-      --effort LEVEL         Reasoning effort: low | medium | high | xhigh | max
-      --key-env NAME         Credential variable (default VYEN_API_KEY)
-      --resume ID|latest     Resume a saved session in this workspace
-      --yes                 Approve file changes and shell commands automatically
-      --read-only           Read tools and research agents; no writes or shell
-      --json                Emit NDJSON events instead of terminal output
-      --no-tui              Use plain readline instead of the full-screen UI
-      --no-mcp              Disable configured MCP servers for this run
-      --no-subagents        Disable delegation tools for this run
-      --inline-reasoning MODE leading-think (default) | off
-      --show-reasoning      Separate reasoning events / labeled stderr output
-      --context-window N    Actual model context window (default 128000)
-      --max-output-tokens N  Per-request output limit (default 16384)
-      --run-token-budget N   Run token budget (default 0 = unlimited)
-      --timeout-ms N        Model request deadline (default 300000)
-  -h, --help                Show help
-  -v, --version             Show version
-
-Interactive commands:
-  /help, /setup, /model, /effort, /mode, /auto, /view, /transcript, /copy, /btw,
-  /goal, /recap, /skills, /memories, /presets, /mention, /cd, /pwd, /mcp, /subagents,
-  /plan, /revert, /undo, /checkpoints, /todo, /compact, /diff, /review, /fork, /rename,
-  /delete, /export, /init, /status, /tools, /sessions, /debug-config, /warnings, /doctor, /clear, /exit, or !<cmd>.
-Shortcuts: Shift+Tab mode, Ctrl+T transcript, Ctrl+O copy, Alt+. / Alt+, effort, Tab autocomplete, Esc Esc rewind, Ctrl+C cancel.
-API keys are read from environment variables or ~/.config/vyen/credentials.json.
-Shell commands run as your OS user; approvals are not an OS sandbox.
-`;
+import { bashApprovalPrefix, isApprovedBashPrefix } from './approval.js';
+/**
+ * Welcome lines shown when a session opens. Plain text (it is also printed in readline mode); the
+ * TUI recognises the `◆ vyen v…` title and styles the block quietly. No box: lines wrap freely at
+ * any width, so long model IDs and paths never break an outline.
+ */
 export function welcomeBanner(model, provider, baseUrl, effort, cwd, sessionId, mode) {
-    const inner = 67;
-    const fit = (text, cols) => visibleLength(text) <= cols ? padEndVisible(text, cols) : padEndVisible(`${sliceVisible(text, cols - 1)}…`, cols);
-    const line = (content) => `│${fit(content, inner)}│`;
-    const field = (label, value) => line(`   ${label.padEnd(10)} ${value}`);
-    const left = ` ◆ vyen  v${VERSION}`;
-    const right = `${mode === 'auto' ? 'auto-approve' : mode} · effort ${effort ?? 'default'} `;
-    const gap = Math.max(1, inner - visibleLength(left) - visibleLength(right));
     const host = baseUrl.replace(/^https?:\/\//, '').replace(/\/+$/, '');
+    const home = process.env.HOME;
+    const workspace = home && cwd.startsWith(`${home}/`) ? `~${cwd.slice(home.length)}` : cwd;
     return [
-        `╭${'─'.repeat(inner)}╮`,
-        line(`${left}${' '.repeat(gap)}${right}`),
-        line(''),
-        field('model', model),
-        field('gateway', `${host} · ${provider}`),
-        field('workspace', cwd),
-        field('session', sessionId.slice(0, 8)),
-        line(''),
-        line('   /help commands · @ files · $ skills · ! shell · shift+tab mode'),
-        `╰${'─'.repeat(inner)}╯`,
+        `◆ vyen v${VERSION}`,
+        `  model ${model}   effort ${effort ?? 'default'}   mode ${mode === 'auto' ? 'auto-approve' : mode}`,
+        `  gateway ${host} (${provider})`,
+        `  workspace ${workspace}   session ${sessionId.slice(0, 8)}`,
+        '  /help commands   @ files   $ skills   ! shell   shift+tab mode',
         '',
     ].join('\n');
 }
@@ -105,6 +60,13 @@ export function readGitBranch(cwd) {
     }
     return undefined;
 }
+/** Short folder name for lists: the last path segment (home shown as ~). */
+function folderLabel(cwd) {
+    const clean = cwd.replace(/[\\/]+$/, '');
+    if (process.env.HOME && clean === process.env.HOME)
+        return '~';
+    return clean.split(/[\\/]/).pop() || clean;
+}
 function formatRelativeTime(isoDate) {
     const ts = Date.parse(isoDate);
     if (!Number.isFinite(ts))
@@ -162,31 +124,120 @@ export function extractCopyableFromMessages(messages, selector = '') {
     }
     return { text: assistantOutputs[assistantOutputs.length - 1], label: 'last response' };
 }
+/** Clipboard helpers in preference order for the current platform (Termux, Wayland, X11, macOS, Windows). */
+export function clipboardCandidates(platform = process.platform, env = process.env) {
+    if (platform === 'win32') {
+        return [{ bin: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-Command', '[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())'] }];
+    }
+    if (platform === 'darwin')
+        return [{ bin: 'pbcopy', args: [] }];
+    const candidates = [];
+    if (env.TERMUX_VERSION || env.PREFIX?.includes('com.termux'))
+        candidates.push({ bin: 'termux-clipboard-set', args: [] });
+    if (env.WAYLAND_DISPLAY)
+        candidates.push({ bin: 'wl-copy', args: [] });
+    candidates.push({ bin: 'xclip', args: ['-selection', 'clipboard'] }, { bin: 'xsel', args: ['--clipboard', '--input'] });
+    return candidates;
+}
 async function copyTextToClipboard(text) {
     let copied = false;
     if (stdout.isTTY && text.length <= 100_000) {
+        // OSC 52 works over SSH and in most modern terminals, even without a clipboard helper.
         const b64 = Buffer.from(text, 'utf8').toString('base64');
         stdout.write(`\x1b]52;c;${b64}\x07`);
         copied = true;
     }
+    const { spawn } = await import('node:child_process');
+    const { childEnv } = await import('./process.js');
+    for (const cmd of clipboardCandidates()) {
+        try {
+            await new Promise((resolve, reject) => {
+                const child = spawn(cmd.bin, cmd.args, { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true, env: childEnv() });
+                const timer = setTimeout(() => { child.kill(); reject(new Error('clipboard helper timed out')); }, 3000);
+                child.on('error', error => { clearTimeout(timer); reject(error); });
+                child.on('close', code => { clearTimeout(timer); if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`exit ${code}`)); });
+                child.stdin.on('error', () => { });
+                child.stdin.end(text, 'utf8');
+            });
+            return true;
+        }
+        catch {
+            // try the next helper
+        }
+    }
+    return copied;
+}
+/**
+ * Piped data is read only from a real pipe or file (`cmd | vyen -p ...`, `vyen -p ... < file`).
+ * Sockets and inherited descriptors that never close (IDE/agent spawns, CI runners) are ignored so
+ * `-p` can never hang waiting for an EOF that does not come.
+ */
+function pipedStdin() {
+    if (stdin.isTTY)
+        return false;
     try {
-        const { spawn } = await import('node:child_process');
-        const cmd = process.platform === 'win32'
-            ? { bin: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-Command', '[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())'] }
-            : process.platform === 'darwin'
-                ? { bin: 'pbcopy', args: [] }
-                : { bin: 'xclip', args: ['-selection', 'clipboard'] };
-        await new Promise((resolve, reject) => {
-            const child = spawn(cmd.bin, cmd.args, { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true });
-            child.on('error', reject);
-            child.on('close', code => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))));
-            child.stdin.end(text, 'utf8');
-        });
-        return true;
+        const info = fstatSync(0);
+        return info.isFIFO() || info.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readStdinLimited(limit) {
+    let bytes = 0;
+    const chunks = [];
+    for await (const chunk of stdin) {
+        const buffer = Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > limit)
+            throw new Error(`Piped input exceeds ${Math.round(limit / 1024)} KiB.`);
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/** Environment problems `vyen doctor` reports in addition to its pass/fail checks. */
+async function doctorWarnings(config, baseUrl, modelIds) {
+    const warnings = [];
+    const [major, minor] = process.versions.node.split('.').map(Number);
+    if (major < 22 || (major === 22 && minor < 16))
+        warnings.push(`Node ${process.version} is older than the supported 22.16.`);
+    const insecure = insecureBaseUrlWarning(baseUrl);
+    if (insecure)
+        warnings.push(insecure);
+    if (config.model && modelIds.length > 0 && !modelIds.includes(config.model)) {
+        warnings.push(`Model "${config.model}" is not listed by ${baseUrl}/models.`);
+    }
+    if (process.platform !== 'win32') {
+        const { credentialsPath } = await import('./config.js');
+        try {
+            const mode = statSync(credentialsPath()).mode & 0o777;
+            if (mode & 0o077)
+                warnings.push(`${credentialsPath()} is readable by other users (mode ${mode.toString(8)}); run: chmod 600 "${credentialsPath()}"`);
+        }
+        catch {
+            // no stored credentials
+        }
+    }
+    return warnings;
+}
+/** API keys sent over plain HTTP are readable by anyone on the network path (except loopback). */
+export function insecureBaseUrlWarning(baseUrl) {
+    if (!baseUrl)
+        return undefined;
+    try {
+        const url = new URL(baseUrl);
+        const loopback = ['localhost', '127.0.0.1', '[::1]', '::1'].includes(url.hostname) || url.hostname.endsWith('.localhost');
+        if (url.protocol === 'http:' && !loopback) {
+            return `Warning: ${url.host} uses plain http; your API key is sent unencrypted. Use https:// unless this is a trusted local network.`;
+        }
     }
     catch {
-        return copied;
+        // invalid URLs are rejected by config validation
     }
+    return undefined;
 }
 export async function main(argv = process.argv.slice(2)) {
     let apiKey;
@@ -263,6 +314,7 @@ export async function main(argv = process.argv.slice(2)) {
                 'inline-reasoning': { type: 'string' }, 'show-reasoning': { type: 'boolean' },
                 'context-window': { type: 'string' }, 'max-output-tokens': { type: 'string' },
                 'run-token-budget': { type: 'string' }, 'timeout-ms': { type: 'string' },
+                'output-last-message': { type: 'string', short: 'o' },
             } });
         jsonOutput = values.json === true;
         if (values.help) {
@@ -292,10 +344,10 @@ export async function main(argv = process.argv.slice(2)) {
             dataDir: dataDir(),
         });
         if (migration.error) {
-            stderr.write(`vyen: could not migrate the legacy goon data (${migration.error}). Copy ${legacyConfigDir()} to ${configDir()} manually.\n`);
+            stderr.write(`vyen: could not migrate the legacy goon data (${migration.error}). Copy ${legacyConfigDir()} to ${configDir()} manually.\\n`);
         }
         else if (migration.copied.length) {
-            stderr.write(`vyen: migrated ${migration.copied.length} entries from ${legacyConfigDir()} to ${configDir()}: ${migration.copied.join(', ')}\n`);
+            stderr.write(`vyen: migrated ${migration.copied.length} entries from ${legacyConfigDir()} to ${configDir()}: ${migration.copied.join(', ')}\\n`);
         }
         let config = await loadConfig(overrides);
         if (positionals[0] === 'mcp') {
@@ -383,16 +435,17 @@ export async function main(argv = process.argv.slice(2)) {
             const discovered = await discoverModels(targetUrl, resolvedKey ?? '', config.provider);
             const modelIds = discovered.map((m) => m.id);
             const modelAvailable = config.model ? (modelIds.length === 0 || modelIds.includes(config.model)) : false;
+            const warnings = await doctorWarnings(config, targetUrl, modelIds);
             stdout.write(JSON.stringify({ version: VERSION, node: process.version, platform: process.platform, arch: process.arch,
                 config: configPath(), provider: config.provider, model: config.model ?? null, effort: config.effort ?? 'default',
                 baseUrl: config.baseUrl ?? 'provider default', credentialVariable: config.keyEnv, credentialPresent: Boolean(resolvedKey),
-                bash, ripgrep: rg, searchFallback: !rg, data: dataDir(), networkTested: true,
-                discoveredModels: modelIds, modelAvailable }, null, 2) + '\n');
+                bash, ripgrep: rg, searchFallback: !rg, data: dataDir(), networkTested: true, gatewayReachable: modelIds.length > 0,
+                discoveredModels: modelIds, modelAvailable, warnings }, null, 2) + '\n');
             if (!bash || !config.model || !resolvedKey)
                 process.exitCode = 1;
             return;
         }
-        const { SessionStore, sameWorkspace, retargetSessionWorkspace } = await import('./session.js');
+        const { SessionStore, sameWorkspace, GOAL_USAGE, goalStatusLabel, formatGoalUsageSummary, formatGoalStatusIndicator, formatGoalSummaryLines, parseGoalDraftArgs, retargetSessionWorkspace, } = await import('./session.js');
         if (positionals[0] === 'sessions') {
             const list = await SessionStore.list(join(dataDir(), 'sessions'));
             stdout.write(values.json ? JSON.stringify(list) + '\n' : list.map(s => `${s.id}  ${s.updatedAt}  ${s.model}${s.title ? `  [${s.title}]` : ''}  ${s.cwd}`).join('\n') + '\n');
@@ -415,6 +468,12 @@ export async function main(argv = process.argv.slice(2)) {
         if (values.prompt && promptPositionals.length)
             throw new Error('Use either --prompt or positional prompt text.');
         let prompt = values.prompt ?? (promptPositionals.length ? promptPositionals.join(' ') : undefined);
+        if (prompt && pipedStdin()) {
+            // `git diff | vyen -p "review"` / `vyen -p "explain" < log`: attach piped data as context.
+            const piped = await readStdinLimited(1024 * 1024);
+            if (piped.trim())
+                prompt = `${prompt}\n\n<stdin>\n${piped.replace(/\s+$/, '')}\n</stdin>`;
+        }
         if (!prompt && !stdin.isTTY) {
             let bytes = 0;
             const chunks = [];
@@ -434,24 +493,48 @@ export async function main(argv = process.argv.slice(2)) {
             config = await runSetupWizard(config);
         }
         const interactive = !prompt;
+        const outputLastMessage = typeof values['output-last-message'] === 'string' ? values['output-last-message'] : undefined;
+        if (outputLastMessage && interactive)
+            throw new Error('--output-last-message requires a prompt (-p or piped input).');
         let viewMode = config.viewMode ?? (config.showReasoning ? 'verbose' : 'normal');
         if (interactive && !jsonOutput) {
             config.showReasoning = true;
         }
         let runtime = await resolveRuntime(config, values.cwd ?? process.cwd());
         apiKey = runtime.apiKey;
+        const insecureWarning = insecureBaseUrlWarning(runtime.baseUrl);
+        if (insecureWarning && !jsonOutput)
+            stderr.write(`vyen: ${insecureWarning}\n`);
         const sessionsRootDir = join(runtime.dataDir, 'sessions');
         if (launchResumePicker && !resumeTarget) {
-            const existingList = await SessionStore.list(sessionsRootDir);
-            const inWorkspace = existingList.filter(s => sameWorkspace(s.cwd, runtime.cwd));
-            const nonEmpty = inWorkspace.filter(s => (s.messagesCount ?? 0) > 0);
-            // Never auto-select a session from another workspace: SessionStore.open
-            // rejects it, which would turn "vyen resume" into a hard failure.
-            const best = nonEmpty[0] ?? inWorkspace[0];
-            if (best) {
-                resumeTarget = best.id;
-                if (inWorkspace.length <= 1)
-                    launchResumePicker = false;
+            // `vyen resume` works from any folder: with one saved session it resumes it directly,
+            // otherwise the picker opens (This folder / All projects) on a fresh, discardable session.
+            const resumable = (await SessionStore.list(sessionsRootDir)).filter(s => (s.messagesCount ?? 0) > 0 || Boolean(s.title));
+            if (resumable.length === 1) {
+                resumeTarget = resumable[0].id;
+                launchResumePicker = false;
+            }
+            else if (!resumable.length) {
+                launchResumePicker = false;
+            }
+        }
+        if (resumeTarget && resumeTarget !== 'latest' && !values.cwd) {
+            // Resuming by ID from another folder switches to that session's workspace instead of failing
+            // with "belongs to a different workspace" (an explicit --cwd still wins).
+            const all = await SessionStore.list(sessionsRootDir);
+            const wanted = resumeTarget.toLowerCase();
+            const isIndex = /^\d{1,3}$/.test(wanted);
+            const match = all.find(s => s.id.toLowerCase() === wanted)
+                ?? (!isIndex && wanted.length >= 4
+                    ? all.find(s => sameWorkspace(s.cwd, runtime.cwd) && s.id.toLowerCase().startsWith(wanted)) ?? all.find(s => s.id.toLowerCase().startsWith(wanted))
+                    : undefined);
+            if (match && !sameWorkspace(match.cwd, runtime.cwd)) {
+                const { realpath } = await import('node:fs/promises');
+                const folder = await realpath(match.cwd).catch(() => undefined);
+                if (folder) {
+                    runtime = await resolveRuntime(config, folder);
+                    resumeTarget = match.id;
+                }
             }
         }
         let store = await SessionStore.open(sessionsRootDir, runtime, resumeTarget);
@@ -460,9 +543,9 @@ export async function main(argv = process.argv.slice(2)) {
         let manager;
         let subagents;
         let controller;
-        // The MCP phase has its own abort scope. Sharing one controller let a
-        // harness rebuild during a run replace the run's signal, so Ctrl+C could
-        // no longer cancel the request that was actually in flight.
+        // The MCP phase has its own abort scope. Sharing one controller let a harness
+        // rebuild during a run replace the run's signal, so Ctrl+C could no longer
+        // cancel the request that was actually in flight.
         let mcpController;
         let denied = false, exiting = false, terminating = false, starting = true;
         let mode = values['read-only']
@@ -474,6 +557,14 @@ export async function main(argv = process.argv.slice(2)) {
                     : (config.approvalMode ?? 'ask');
         let prePlanMode = values.yes || config.approvalMode === 'auto' ? 'auto' : 'ask';
         const sessionAllowedTools = new Set();
+        const sessionAllowedBashPrefixes = new Set();
+        // Terminal bell when vyen needs the user (approval, question) or a long turn finishes, so a
+        // developer who switched windows notices. Disable with VYEN_NOTIFY=0.
+        const notifyEnabled = process.env.VYEN_NOTIFY !== '0' && process.env.VYEN_NOTIFY !== 'off';
+        const notifyAttention = () => {
+            if (notifyEnabled && stdout.isTTY && !jsonOutput)
+                stdout.write('\x07');
+        };
         const stop = () => {
             if (starting)
                 process.exitCode = 130;
@@ -521,12 +612,13 @@ export async function main(argv = process.argv.slice(2)) {
             else if (stdin.isTTY)
                 rl = createInterface({ input: stdin, output: stderr, terminal: true });
             rl?.on('SIGINT', stop);
-            const { estimatedTokens } = await import('./context.js');
+            const { estimatedTokens, buildGoalContinuationPrompt, buildGoalObjectiveUpdatedPrompt, buildUserGoalContextMessage, } = await import('./context.js');
             const syncTuiHeader = (resetContext = false) => {
                 if (!tui)
                     return;
                 tui.setWorkspace(runtime.cwd, readGitBranch(runtime.cwd));
                 tui.setContextWindow(runtime.contextWindow);
+                tui.setGoal(store.session.goal);
                 if (resetContext) {
                     tui.setContextUsage(store.session.messages.length ? estimatedTokens(store.session.messages, '') : undefined);
                 }
@@ -535,6 +627,22 @@ export async function main(argv = process.argv.slice(2)) {
             const display = (text) => tui ? tui.write(text) : stderr.write(cleanTerminal(text));
             const question = (label, signal, remember = false) => tui ? tui.question(label, signal, remember)
                 : rl ? rl.question(label, { signal }) : Promise.reject(new Error('Input requires a TTY.'));
+            // Plain readline mode: read a secret without echoing it.
+            const questionHidden = async (label) => {
+                if (!rl)
+                    return question(label);
+                const writer = rl;
+                const original = writer._writeToOutput;
+                stderr.write(label);
+                writer._writeToOutput = (text) => { if (/^[\r\n]+$/.test(text))
+                    original.call(rl, text); };
+                try {
+                    return await rl.question('');
+                }
+                finally {
+                    writer._writeToOutput = original;
+                }
+            };
             let reasoningSource;
             const emit = (event) => {
                 if (event.type === 'stopped')
@@ -585,6 +693,8 @@ export async function main(argv = process.argv.slice(2)) {
                     stderr.write(`\n[${event.name}]\n`);
                 else if (event.type === 'todo')
                     stderr.write(`\n[todo: ${event.todos.filter(t => t.status === 'completed').length}/${event.todos.length} completed]\n`);
+                else if (event.type === 'goal')
+                    stderr.write(`\n[${event.goal ? formatGoalStatusIndicator(event.goal) : 'Goal cleared'}]\n`);
                 else if (event.type === 'plan_exit')
                     stderr.write('\n[Plan approved — exited plan mode]\n');
                 else if (event.type === 'compaction')
@@ -595,9 +705,13 @@ export async function main(argv = process.argv.slice(2)) {
             const { ToolRegistry, formatTodos, applyPermissionMode } = await import('./tools.js');
             const { Subagents } = await import('./subagents.js');
             const { Harness } = await import('./harness.js');
-            const buildHarness = async (currentMode) => {
+            const buildHarness = async (currentMode, options = {}) => {
                 const reg = new ToolRegistry(runtime.cwd, async (request) => {
-                    if (mode === 'auto' || currentMode === 'auto' || sessionAllowedTools.has(request.tool))
+                    // Only the live mode counts. The mode captured when this harness was built must not keep
+                    // auto-approving after the user switches back to ask/plan (Shift+Tab, /mode, /auto off).
+                    if (mode === 'auto' || sessionAllowedTools.has(request.tool))
+                        return true;
+                    if (request.tool === 'bash' && isApprovedBashPrefix(request.input, sessionAllowedBashPrefixes))
                         return true;
                     if (!rl && !tui)
                         return false;
@@ -625,17 +739,28 @@ export async function main(argv = process.argv.slice(2)) {
                         rawPreview = JSON.stringify(request.input, null, 2);
                     }
                     const preview = cleanTerminal(rawPreview.split(runtime.apiKey).join('[REDACTED]').slice(0, 8000));
-                    const approvalBlock = `\n▲ Allow ${request.tool}?\n${preview}\n`;
+                    const prefix = request.tool === 'bash' ? bashApprovalPrefix(request.input) : undefined;
+                    const fullCommand = request.input && typeof request.input === 'object' ? String(request.input.command ?? '').trim().split(/\s+/).join(' ') : '';
+                    const prefixHint = !prefix ? ''
+                        : prefix === fullCommand
+                            ? `\n  p = always allow exactly "${prefix}" in this session`
+                            : `\n  p = always allow "${prefix} …" in this session (simple arguments inside the workspace only)`;
+                    const approvalBlock = `\n▲ Allow ${request.tool}?\n${preview}${prefixHint}\n`;
+                    const label = prefix ? '[y/N/p(refix)/a(lways)] ' : '[y/N/a(lways)] ';
+                    notifyAttention();
                     const reply = tui
-                        ? (await tui.askTransient(approvalBlock, '[y/N/a(lways)] ', request.signal)).trim().toLowerCase()
-                        : (display(approvalBlock), (await question('[y/N/a(lways)] ', request.signal)).trim().toLowerCase());
+                        ? (await tui.askTransient(approvalBlock, label, request.signal)).trim().toLowerCase()
+                        : (display(approvalBlock), (await question(label, request.signal)).trim().toLowerCase());
                     if (reply === 'a' || reply === 'always') {
                         sessionAllowedTools.add(request.tool);
                         return true;
                     }
+                    if (prefix && (reply === 'p' || reply === 'prefix')) {
+                        sessionAllowedBashPrefixes.add(prefix);
+                        return true;
+                    }
                     return reply === 'y' || reply === 'yes';
                 });
-                // One mechanism maps a permission mode onto a registry.
                 applyPermissionMode(reg, currentMode);
                 if (rl || tui) {
                     reg.askUser = async (questions, callSignal) => {
@@ -661,11 +786,17 @@ export async function main(argv = process.argv.slice(2)) {
                         return out;
                     };
                 }
-                if (!values['no-mcp'] && manager) {
+                // Running MCP servers are reused across harness rebuilds (effort, model, session switches);
+                // they restart only when asked to (/mcp reload) or when the workspace directory changed.
+                const reuseMcp = !values['no-mcp'] && manager?.connected && !options.reconnectMcp && manager.cwd === runtime.cwd;
+                if (reuseMcp) {
+                    manager.attach(reg);
+                }
+                else if (!values['no-mcp'] && manager) {
                     await manager.close();
                     manager = undefined;
                 }
-                if (!values['no-mcp']) {
+                if (!values['no-mcp'] && !reuseMcp) {
                     const { loadMcpConfig, McpManager } = await import('./mcp.js');
                     mcpController = new AbortController();
                     try {
@@ -703,7 +834,7 @@ export async function main(argv = process.argv.slice(2)) {
                 if (nextMode === 'plan' && mode !== 'plan')
                     prePlanMode = mode;
                 mode = nextMode;
-                applyPermissionMode(tools, nextMode);
+                applyPermissionMode(tools, mode);
                 tui?.setMode(mode);
                 config.approvalMode = mode;
                 void saveConfig(config).catch(() => { });
@@ -713,6 +844,41 @@ export async function main(argv = process.argv.slice(2)) {
                 display(`\n[Mode switched to: ${label}]\n`);
             };
             let { tools, harness } = await buildHarness(mode);
+            let rebuildPending = false;
+            const rebuildHarness = async (options = {}) => {
+                const built = await buildHarness(mode, options);
+                tools = built.tools;
+                harness = built.harness;
+            };
+            // Rebuilding closes the MCP servers and subagents the running turn uses, so while a turn is
+            // active the rebuild waits until it ends (the new settings apply from the next turn).
+            const requestRebuild = async () => {
+                if (controller || harness.busy) {
+                    rebuildPending = true;
+                    return false;
+                }
+                rebuildPending = false;
+                await rebuildHarness();
+                return true;
+            };
+            const applyPendingRebuild = async () => {
+                if (rebuildPending && !controller && !harness.busy) {
+                    rebuildPending = false;
+                    await rebuildHarness();
+                }
+            };
+            const applyEffort = async (next) => {
+                config = await loadConfig({ ...config, effort: next });
+                await saveConfig(config);
+                runtime = await resolveRuntime(config, runtime.cwd);
+                tui?.setEffort(runtime.effort);
+                syncTuiHeader();
+                const applied = await requestRebuild();
+                const suffix = applied ? '' : ' (applies from the next turn)';
+                if (tui)
+                    tui.setNotice(`Reasoning effort: ${runtime.effort ?? 'default'}${suffix}`);
+                display(`\n[Reasoning effort set to: ${runtime.effort ?? 'default'}${suffix}]\n`);
+            };
             if (tui) {
                 void tools.files.listWorkspaceFiles().then(files => tui?.setWorkspaceFiles(files)).catch(() => { });
                 tui.onCopy = async () => {
@@ -736,17 +902,7 @@ export async function main(argv = process.argv.slice(2)) {
                     const ring = [undefined, ...EFFORT_LEVELS];
                     const curIdx = ring.indexOf(runtime.effort);
                     const nextEffort = ring[(curIdx + direction + ring.length) % ring.length];
-                    void (async () => {
-                        config = await loadConfig({ ...config, effort: nextEffort });
-                        await saveConfig(config);
-                        runtime = await resolveRuntime(config, runtime.cwd);
-                        tui?.setEffort(runtime.effort);
-                        syncTuiHeader();
-                        const built = await buildHarness(mode);
-                        tools = built.tools;
-                        harness = built.harness;
-                        display(`\n[Reasoning effort set to: ${runtime.effort ?? 'default'}]\n`);
-                    })();
+                    void applyEffort(nextEffort).catch(error => display(`\n[Effort change failed: ${safeError(error, apiKey)}]\n`));
                 };
             }
             const renderResumedHistory = (showBanner = true) => {
@@ -762,6 +918,9 @@ export async function main(argv = process.argv.slice(2)) {
                                 : Array.isArray(m.content)
                                     ? m.content.map(p => ('text' in p && typeof p.text === 'string' ? p.text : p.type === 'image' ? '[Image]' : '')).filter(Boolean).join(' ')
                                     : '';
+                            if (rawText.startsWith('<codex_internal_context source="')) {
+                                continue;
+                            }
                             const cleaned = rawText
                                 .replace(/<referenced_file\s+path="([^"]+)"[\s\S]*?<\/referenced_file>/g, '[@$1]')
                                 .replace(/\r?\n/g, ' ')
@@ -799,7 +958,7 @@ export async function main(argv = process.argv.slice(2)) {
                     return;
                 }
                 const lines = [
-                    `\n╭─── Resumed Session ${store.session.id.slice(0, 8)}${store.session.title ? ` (${store.session.title})` : ''} · ${msgs.length} messages · ${store.session.checkpoints?.length ?? 0} checkpoints ───╮`,
+                    `\n↻ Resumed session ${store.session.id.slice(0, 8)}${store.session.title ? ` (${store.session.title})` : ''}: ${msgs.length} messages, ${store.session.checkpoints?.length ?? 0} checkpoints`,
                 ];
                 const previewMsgs = msgs.filter(m => m.role === 'user' || m.role === 'assistant').slice(-6);
                 for (const m of previewMsgs) {
@@ -808,13 +967,15 @@ export async function main(argv = process.argv.slice(2)) {
                         : Array.isArray(m.content)
                             ? m.content.map(p => ('text' in p && typeof p.text === 'string' ? p.text : p.type === 'tool-call' ? `[tool:${p.toolName}]` : '')).filter(Boolean).join(' ')
                             : '';
+                    if (text.startsWith('<codex_internal_context source="')) {
+                        continue;
+                    }
                     const cleaned = text.replace(/<referenced_file[\s\S]*?<\/referenced_file>/g, '[attached file]').replace(/\s+/g, ' ').trim();
                     if (cleaned) {
-                        lines.push(`  ${m.role === 'user' ? '▸ You' : '◆ Vyen'}: ${cleaned.slice(0, 140)}${cleaned.length > 140 ? '…' : ''}`);
+                        lines.push(`  ${m.role === 'user' ? '›' : '◆'} ${cleaned.slice(0, 140)}${cleaned.length > 140 ? '…' : ''}`);
                     }
                 }
-                lines.push('╰──────────────────────────────────────────────────────────────────────────────────╯\n');
-                display(lines.join('\n'));
+                display(`${lines.join('\n')}\n`);
             };
             starting = false;
             if (jsonOutput)
@@ -825,20 +986,43 @@ export async function main(argv = process.argv.slice(2)) {
             }
             else
                 display(`vyen · ${runtime.model} · session ${store.session.id}\n`);
-            const run = async (input) => {
+            let goalContinuationDeferred = false;
+            const runTurn = async (input, opts) => {
                 if (Buffer.byteLength(input) > 1024 * 1024)
                     throw new Error('Prompt exceeds 1 MiB.');
+                await applyPendingRebuild();
                 denied = false;
+                let aborted = false;
+                let hadError = false;
+                let outText = '';
+                const turnStarted = Date.now();
                 controller = new AbortController();
                 tui?.setStatus('Running');
                 if (tui) {
                     tui.markTurnStart();
-                    tui.write(`\n> ${input}\n`);
+                    if (opts?.isGoalContinuation) {
+                        const g = store.session.goal;
+                        const stepLabel = opts.continuationStep && opts.continuationStep > 1 ? ` · turn ${opts.continuationStep}` : '';
+                        const statusInd = g ? formatGoalStatusIndicator(g) : 'Pursuing goal';
+                        tui.write(`\n◆ ${statusInd}${stepLabel}${g ? ` — ${g.objective}` : ''}\n`);
+                    }
+                    else {
+                        tui.write(`\n> ${input}\n`);
+                    }
+                }
+                else if (opts?.isGoalContinuation && !jsonOutput) {
+                    const g = store.session.goal;
+                    const stepLabel = opts.continuationStep && opts.continuationStep > 1 ? ` · turn ${opts.continuationStep}` : '';
+                    display(`\n[◆ Pursuing goal${stepLabel}${g ? `: ${g.objective}` : ''}]\n`);
                 }
                 try {
-                    const text = await harness.run(input, controller.signal);
+                    outText = await harness.run(input, controller.signal);
+                    if (outputLastMessage) {
+                        const { writeFile } = await import('node:fs/promises');
+                        await writeFile(resolve(outputLastMessage), outText.endsWith('\n') ? outText : `${outText}\n`, 'utf8');
+                    }
                     if (jsonOutput)
-                        stdout.write(JSON.stringify({ type: 'done', text, denied, sessionId: store.session.id }) + '\n');
+                        stdout.write(JSON.stringify({ type: 'done', text: outText, denied, sessionId: store.session.id }) + '\n');
                     else if (tui)
                         tui.write('\n');
                     else
@@ -847,21 +1031,99 @@ export async function main(argv = process.argv.slice(2)) {
                         process.exitCode = 2;
                 }
                 catch (error) {
+                    aborted = controller.signal.aborted;
+                    hadError = true;
                     if (!interactive)
-                        process.exitCode = controller.signal.aborted ? terminating ? 143 : 130 : 1;
+                        process.exitCode = aborted ? terminating ? 143 : 130 : 1;
                     const message = safeError(error, apiKey);
                     if (jsonOutput)
                         stdout.write(JSON.stringify({ type: 'error', message }) + '\n');
                     else
                         display(`\n${message}\n`);
+                    if (aborted && !exiting && !terminating && store.session.goal?.status === 'active') {
+                        goalContinuationDeferred = true;
+                        if (tui)
+                            tui.setNotice('Goal continuation paused after interrupt — run /goal resume to continue.');
+                        else
+                            display('[Goal continuation paused after interrupt — run /goal resume to continue.]\n');
+                    }
                 }
                 finally {
                     controller = undefined;
+                    if (interactive && Date.now() - turnStarted >= 15_000)
+                        notifyAttention();
                     tui?.setStatus('Ready');
                     syncTuiHeader();
                     if (tui)
                         void tools.files.listWorkspaceFiles().then(files => tui?.setWorkspaceFiles(files)).catch(() => { });
                 }
+                return { aborted, hadError, text: outText };
+            };
+            const continueGoalIfIdle = async () => {
+                if (controller || exiting || terminating || denied || tools.planMode)
+                    return;
+                let consecutiveEmptyTurns = 0;
+                for (let step = 1;; step++) {
+                    if (exiting || terminating || denied || tools.planMode || goalContinuationDeferred)
+                        break;
+                    if (tui?.hasQueuedPrompts())
+                        break;
+                    const g = store.session.goal;
+                    if (!g || g.status !== 'active')
+                        break;
+                    if (g.tokenBudget !== undefined && (g.tokensUsed ?? 0) >= g.tokenBudget) {
+                        g.status = 'budget_limited';
+                        g.updatedAt = new Date().toISOString();
+                        await store.save();
+                        syncTuiHeader();
+                        const summary = formatGoalStatusIndicator(g);
+                        if (tui)
+                            tui.setNotice(summary);
+                        else if (!jsonOutput)
+                            display(`\n[${summary}]\n`);
+                        break;
+                    }
+                    const contPrompt = buildGoalContinuationPrompt(g, !tools.planMode && !tools.readOnly);
+                    const res = await runTurn(contPrompt, { isGoalContinuation: true, continuationStep: step });
+                    if (res.aborted || res.hadError || denied)
+                        break;
+                    const afterGoal = store.session.goal;
+                    if (!afterGoal || afterGoal.status !== 'active') {
+                        if (afterGoal) {
+                            const summary = formatGoalStatusIndicator(afterGoal);
+                            if (tui)
+                                tui.setNotice(summary);
+                            if (!jsonOutput)
+                                display(`\n[${summary} — ${afterGoal.objective}]\n`);
+                        }
+                        break;
+                    }
+                    if (!res.text.trim()) {
+                        consecutiveEmptyTurns++;
+                        if (consecutiveEmptyTurns >= 3) {
+                            afterGoal.status = 'blocked';
+                            afterGoal.updatedAt = new Date().toISOString();
+                            await store.save();
+                            syncTuiHeader();
+                            const summary = formatGoalStatusIndicator(afterGoal);
+                            if (tui)
+                                tui.setNotice(summary);
+                            if (!jsonOutput)
+                                display(`\n[${summary} — stalled after 3 empty continuation turns]\n`);
+                            break;
+                        }
+                    }
+                    else {
+                        consecutiveEmptyTurns = 0;
+                    }
+                }
+            };
+            const run = async (input) => {
+                goalContinuationDeferred = false;
+                const res = await runTurn(input);
+                if (!res.aborted && !res.hadError && !denied && store.session.goal?.status === 'active') {
+                    await continueGoalIfIdle();
+                }
             };
             const executeImmediateCommand = async (rawCmd) => {
                 const cmdInput = rawCmd.trim();
@@ -886,7 +1148,7 @@ export async function main(argv = process.argv.slice(2)) {
                         '  /view [normal|verbose|transcript] Switch view: normal (hide thinking) | verbose | transcript\n' +
                         '  /copy [last|code|<N>]             Copy last response, code block, or Nth response (or press Ctrl+O)\n' +
                         '  /btw <question>, /side <question> Ask an ephemeral side question without modifying history\n' +
-                        '  /goal [<objective>|pause|resume|complete|clear] Set or inspect session goal & token usage\n' +
+                        '  /goal [--budget <N>] [<obj>|edit|pause|resume|complete|clear] Autonomous goal loop (Codex /goal)\n' +
                         '  /recap                            Generate a live summary of current session progress\n' +
                         '  /skills [list|<name>]             List or inspect SKILL.md skills (use $skill-name in prompt)\n' +
                         '  /memories [list|add <text>|rm <id>|clear] Manage persistent user memories across sessions\n' +
@@ -894,14 +1156,16 @@ export async function main(argv = process.argv.slice(2)) {
                         '  /mention <filepath>               Insert @filepath mention into the composer\n' +
                         '  /cd <dir>, /pwd                   Change or show active workspace directory\n' +
                         '  /mode [ask|auto|plan|readonly]    Switch approval mode (or press Shift+Tab)\n' +
-                        '  /setup, /config                   Interactive provider, URL, key, model & effort setup\n' +
+                        '  /setup, /config, /provider        Interactive provider, URL, key, model & effort setup\n' +
+                        '  /key                              Replace the stored API key (input hidden)\n' +
+                        '  /prompts [show <name>]            List custom prompt files; run one with /prompts:<name> [args]\n' +
                         '  /model [id] [--effort=<level>]    Discover/pick model from /models or set model ID\n' +
                         '  /effort [low|medium|high|xhigh|max|default] Switch reasoning effort (or Alt+./Alt+,)\n' +
                         '  /plan [off|execute|<prompt>]      Enter/exit Plan Mode or execute approved plan\n' +
                         '  /revert, /undo [code|msg|both] [N] Rewind last N turns & restore prompt to composer (or press Esc Esc)\n' +
                         '  /checkpoints                      Interactive picker to rewind to any earlier turn checkpoint\n' +
                         '  /todo [clear]                     View or clear the current task checklist\n' +
-                        '  /resume [latest|<number>|<id>]    Interactive session picker or hot-swap to saved session\n' +
+                        '  /resume [latest|<number>|<id>]    Pick a session from this folder or all projects (←→ / Tab switch)\n' +
                         '  /new [title]                      Start a fresh session in this workspace\n' +
                         '  /delete [<id>|current]            Delete a saved session or current session\n' +
                         '  /compact [focus instructions]     Summarize & archive earlier context history\n' +
@@ -956,10 +1220,8 @@ export async function main(argv = process.argv.slice(2)) {
                     void (async () => {
                         try {
                             const res = await harness.askSideQuestion(questionText, AbortSignal.timeout(runtime.timeoutMs));
-                            display(`\n╭─── Side Answer (/btw) ──────────────────────────────────────────╮\n` +
-                                `  Q: ${questionText}\n` +
-                                `  A: ${res.text.split('\n').join('\n     ')}\n` +
-                                `╰─────────────────────────────────────────────────────────────────╯\n`);
+                            // A "◇" cell with indented lines renders as one quiet block in the TUI.
+                            display(`\n◇ Side answer: ${questionText}\n${res.text.split('\n').map(line => `  ${line}`).join('\n')}\n`);
                             if (tui)
                                 tui.setNotice('Side question (/btw) answered (history unchanged).');
                         }
@@ -976,57 +1238,201 @@ export async function main(argv = process.argv.slice(2)) {
                     if (!arg) {
                         const g = store.session.goal;
                         if (!g) {
-                            display('No active session goal. Set one with: /goal <objective>\n');
+                            display(`No active session goal.\n${GOAL_USAGE}\n`);
                         }
                         else {
-                            const elapsedSec = Math.max(0, Math.floor((Date.now() - Date.parse(g.createdAt)) / 1000));
-                            const mins = Math.floor(elapsedSec / 60);
-                            const secs = elapsedSec % 60;
-                            const spentTokens = Math.max(0, store.session.tokens - (g.tokensAtStart ?? 0));
-                            display(`\nSession Goal [${g.status.toUpperCase()}]:\n` +
-                                `  Objective : ${g.objective}\n` +
-                                `  Elapsed   : ${mins > 0 ? `${mins}m ${secs}s` : `${secs}s`} (since ${g.createdAt.slice(11, 19)})\n` +
-                                `  Tokens    : ${spentTokens} tokens used since goal start\n`);
+                            display(`\n${formatGoalSummaryLines(g, store.session.tokens)}\n`);
                         }
                         return true;
                     }
                     if (lower === 'clear' || lower === 'off' || lower === 'none') {
+                        if (!store.session.goal) {
+                            display('No active session goal.\n');
+                            return true;
+                        }
                         store.session.goal = undefined;
+                        harness.addContextMessage({
+                            role: 'user',
+                            content: buildUserGoalContextMessage({ cleared: true }),
+                        });
                         await store.save();
+                        syncTuiHeader();
                         if (tui)
-                            tui.setNotice('Cleared session goal.');
-                        display('Cleared session goal.\n');
+                            tui.setNotice('Goal cleared.');
+                        display('Goal cleared.\n');
                         return true;
                     }
                     if (lower === 'pause' || lower === 'resume' || lower === 'complete' || lower === 'done') {
-                        if (!store.session.goal) {
-                            display('No session goal set yet. Use: /goal <objective>\n');
+                        const g = store.session.goal;
+                        if (!g) {
+                            display(`No session goal set yet.\n${GOAL_USAGE}\n`);
+                            return true;
+                        }
+                        const nextStatus = lower === 'pause' ? 'paused' : lower === 'resume' ? 'active' : 'complete';
+                        if (nextStatus === 'active' && g.status === 'budget_limited' && g.tokenBudget !== undefined && (g.tokensUsed ?? 0) >= g.tokenBudget) {
+                            g.tokenBudget = undefined;
+                        }
+                        g.status = nextStatus;
+                        g.updatedAt = now;
+                        if (nextStatus === 'active')
+                            goalContinuationDeferred = false;
+                        harness.addContextMessage({
+                            role: 'user',
+                            content: buildUserGoalContextMessage({ status: nextStatus }),
+                        });
+                        await store.save();
+                        syncTuiHeader();
+                        const indicator = formatGoalStatusIndicator(g);
+                        if (tui)
+                            tui.setNotice(indicator);
+                        display(`\n${formatGoalSummaryLines(g, store.session.tokens)}\n`);
+                        if (nextStatus === 'active' && !controller) {
+                            if (mode === 'plan') {
+                                display('Note: Plan mode is active. Switch to ask or auto mode (/mode ask or /auto) to pursue the goal autonomously.\n');
+                            }
+                            else {
+                                await continueGoalIfIdle();
+                            }
+                        }
+                        return true;
+                    }
+                    if (lower === 'edit' || lower.startsWith('edit ')) {
+                        const g = store.session.goal;
+                        if (!g) {
+                            display(`No session goal set yet.\n${GOAL_USAGE}\n`);
+                            return true;
+                        }
+                        const editRest = arg.slice(4).trim();
+                        if (!editRest) {
+                            if (controller) {
+                                display('Usage while working: /goal edit <objective>\n');
+                                return true;
+                            }
+                            return false;
+                        }
+                        const parsedEdit = parseGoalDraftArgs(editRest);
+                        if ('error' in parsedEdit) {
+                            display(`${parsedEdit.error}\n`);
                             return true;
                         }
-                        store.session.goal.status =
-                            lower === 'pause' ? 'paused' : lower === 'resume' ? 'active' : 'complete';
-                        store.session.goal.updatedAt = now;
+                        if (parsedEdit.tokenBudget !== undefined) {
+                            g.tokenBudget = parsedEdit.tokenBudget;
+                            if (g.status === 'budget_limited' && (g.tokensUsed ?? 0) < parsedEdit.tokenBudget) {
+                                g.status = 'active';
+                            }
+                        }
+                        if (parsedEdit.objective) {
+                            g.objective = parsedEdit.objective;
+                        }
+                        g.updatedAt = now;
+                        harness.addContextMessage({
+                            role: 'user',
+                            content: buildUserGoalContextMessage({
+                                ...(parsedEdit.objective ? { objective: g.objective } : {}),
+                                status: g.status,
+                            }),
+                        });
+                        if (parsedEdit.objective) {
+                            harness.addContextMessage({
+                                role: 'user',
+                                content: buildGoalObjectiveUpdatedPrompt(g),
+                            });
+                        }
                         await store.save();
-                        display(`Session goal status updated to: ${store.session.goal.status} (${store.session.goal.objective})\n`);
+                        syncTuiHeader();
+                        if (tui)
+                            tui.setNotice(formatGoalStatusIndicator(g));
+                        display(`\n${formatGoalSummaryLines(g, store.session.tokens)}\n`);
+                        if (g.status === 'active' && !controller && mode !== 'plan') {
+                            goalContinuationDeferred = false;
+                            await continueGoalIfIdle();
+                        }
+                        return true;
+                    }
+                    const parsed = parseGoalDraftArgs(arg);
+                    if ('error' in parsed) {
+                        display(`${parsed.error}\n`);
+                        return true;
+                    }
+                    if (!parsed.objective) {
+                        if (parsed.tokenBudget !== undefined && store.session.goal) {
+                            const g = store.session.goal;
+                            g.tokenBudget = parsed.tokenBudget;
+                            if (g.status === 'budget_limited' && (g.tokensUsed ?? 0) < parsed.tokenBudget) {
+                                g.status = 'active';
+                            }
+                            g.updatedAt = now;
+                            await store.save();
+                            syncTuiHeader();
+                            if (tui)
+                                tui.setNotice(formatGoalStatusIndicator(g));
+                            display(`\n${formatGoalSummaryLines(g, store.session.tokens)}\n`);
+                            if (g.status === 'active' && !controller && mode !== 'plan') {
+                                goalContinuationDeferred = false;
+                                await continueGoalIfIdle();
+                            }
+                            return true;
+                        }
+                        display(`${GOAL_USAGE}\n`);
                         return true;
                     }
+                    const hadExistingGoal = Boolean(store.session.goal);
                     store.session.goal = {
-                        objective: arg,
+                        goalId: `goal_${Date.now().toString(36)}`,
+                        objective: parsed.objective,
                         status: 'active',
                         createdAt: now,
                         updatedAt: now,
                         tokensAtStart: store.session.tokens,
+                        tokensUsed: 0,
+                        timeUsedSeconds: 0,
+                        ...(parsed.tokenBudget !== undefined ? { tokenBudget: parsed.tokenBudget } : {}),
                     };
+                    goalContinuationDeferred = false;
+                    harness.addContextMessage({
+                        role: 'user',
+                        content: buildUserGoalContextMessage({ objective: parsed.objective, status: 'active' }),
+                    });
+                    if (controller && hadExistingGoal) {
+                        harness.addContextMessage({
+                            role: 'user',
+                            content: buildGoalObjectiveUpdatedPrompt(store.session.goal),
+                        });
+                    }
                     await store.save();
+                    syncTuiHeader();
                     if (tui)
-                        tui.setNotice(`Goal active: ${arg.slice(0, 60)}`);
-                    display(`Active session goal set: ${arg}\n`);
+                        tui.setNotice(formatGoalStatusIndicator(store.session.goal));
+                    display(`\n${formatGoalSummaryLines(store.session.goal, store.session.tokens)}\n`);
+                    if (mode === 'plan') {
+                        display('Note: Plan mode is active. Switch to ask or auto mode (/mode ask or /auto) to pursue the goal autonomously.\n');
+                    }
+                    else if (!controller) {
+                        await continueGoalIfIdle();
+                    }
                     return true;
                 }
                 if (cmdInput === '/pwd' || cmdInput === '/cwd') {
                     display(`Workspace directory: ${runtime.cwd}\n`);
                     return true;
                 }
+                if (cmdInput === '/prompts' || cmdInput === '/prompts list' || cmdInput.startsWith('/prompts show ')) {
+                    const { discoverPrompts } = await import('./prompts.js');
+                    const prompts = await discoverPrompts(runtime.cwd);
+                    if (cmdInput.startsWith('/prompts show ')) {
+                        const name = cmdInput.slice('/prompts show '.length).trim().replace(/^prompts:/, '');
+                        const found = prompts.find(p => p.name.toLowerCase() === name.toLowerCase());
+                        display(found ? `\n/prompts:${found.name} (${found.path}):\n${found.body.slice(0, 4000)}\n` : `Prompt "${name}" not found. Run /prompts to list them.\n`);
+                        return true;
+                    }
+                    if (!prompts.length) {
+                        display('No prompt files found. Create e.g. .vyen/prompts/review.md or ~/.config/vyen/prompts/review.md,\nthen run /prompts:review [args] ($ARGUMENTS and $1..$9 are substituted).\n');
+                    }
+                    else {
+                        display(`Custom prompts (${prompts.length}) — run with /prompts:<name> [args]:\n${prompts.map(p => `  /prompts:${p.name.padEnd(20)} [${p.scope}] ${p.description}`).join('\n')}\n`);
+                    }
+                    return true;
+                }
                 if (cmdInput === '/skills' || cmdInput.startsWith('/skills ')) {
                     const { discoverSkills } = await import('./context.js');
                     const { readFile } = await import('node:fs/promises');
@@ -1306,11 +1712,8 @@ export async function main(argv = process.argv.slice(2)) {
                         display(`Invalid effort "${arg}". Choose from: low, medium, high, xhigh, max, default.\n`);
                         return true;
                     }
-                    config = await loadConfig({ ...config, effort: isClear ? undefined : parsed });
-                    await saveConfig(config);
-                    runtime = await resolveRuntime(config, runtime.cwd);
-                    tui?.setEffort(runtime.effort);
-                    display(`Reasoning effort set to: ${runtime.effort ?? 'default'}\n`);
+                    // Previously only the saved config changed; the running harness kept the old effort.
+                    await applyEffort(isClear ? undefined : parsed);
                     return true;
                 }
                 if (cmdInput === '/todo' || cmdInput.startsWith('/todo ')) {
@@ -1436,11 +1839,10 @@ export async function main(argv = process.argv.slice(2)) {
                     return true;
                 }
                 if (cmdInput === '/status') {
-                    const { estimatedTokens } = await import('./context.js');
                     const usedEst = estimatedTokens(store.session.messages, '');
                     const pct = Math.min(100, Math.round((usedEst / runtime.contextWindow) * 100));
                     const goalLine = store.session.goal
-                        ? `Goal           [${store.session.goal.status}] ${store.session.goal.objective}\n`
+                        ? `Goal           [${goalStatusLabel(store.session.goal.status)}] ${store.session.goal.objective} (${formatGoalUsageSummary(store.session.goal)})\n`
                         : '';
                     display(`Session        ${store.session.id}${store.session.title ? ` (${store.session.title})` : ''}\n` +
                         goalLine +
@@ -1502,10 +1904,15 @@ export async function main(argv = process.argv.slice(2)) {
                     const cmd = sanitizeBashCommand(rawShell);
                     const { runCommand } = await import('./process.js');
                     display(`\n$ ${cmd}\n`);
+                    // When idle, Ctrl+C cancels this command instead of quitting vyen.
+                    const shellController = new AbortController();
+                    const ownsController = !controller;
+                    if (ownsController)
+                        controller = shellController;
                     try {
-                        const res = await runCommand('bash', ['-c', cmd], { cwd: runtime.cwd, signal: AbortSignal.timeout(60_000), timeoutMs: 60_000 });
+                        const res = await runCommand('bash', ['-c', cmd], { cwd: runtime.cwd, signal: AbortSignal.any([shellController.signal, AbortSignal.timeout(600_000)]), timeoutMs: 600_000 });
                         display(`${res.output || '(no output)'}\n[Exit code: ${res.code}]\n`);
-                        store.session.messages.push({
+                        harness.addContextMessage({
                             role: 'user',
                             content: `<user_shell_command>\n<command>${cmd}</command>\n<result>\nExit code: ${res.code}\n${res.output.slice(0, 8000)}\n</result>\n</user_shell_command>`,
                         });
@@ -1514,6 +1921,10 @@ export async function main(argv = process.argv.slice(2)) {
                     catch (error) {
                         display(`Shell command failed: ${safeError(error, apiKey)}\n`);
                     }
+                    finally {
+                        if (ownsController && controller === shellController)
+                            controller = undefined;
+                    }
                     return true;
                 }
                 return false;
@@ -1526,6 +1937,8 @@ export async function main(argv = process.argv.slice(2)) {
                         if (cmd.startsWith('/revert') || cmd.startsWith('/undo') || cmd === '/checkpoints') {
                             controller?.abort(new Error('Interrupted for revert.'));
                         }
+                        // Previously only the notice was shown and the command was silently dropped.
+                        tui?.queuePrompt(cmd);
                         tui?.setNotice(`Queued command "${cmd}" to run as soon as current step finishes.`);
                     }
                 };
@@ -1553,17 +1966,70 @@ export async function main(argv = process.argv.slice(2)) {
                     }
                     if (!input)
                         continue;
+                    await applyPendingRebuild();
                     if (await executeImmediateCommand(input)) {
                         if (exiting)
                             break;
                         continue;
                     }
-                    if (input === '/setup' || input === '/config') {
+                    if (input.toLowerCase() === '/goal edit') {
+                        const g = store.session.goal;
+                        if (!g) {
+                            display(`No session goal set yet.\n${GOAL_USAGE}\n`);
+                            continue;
+                        }
+                        const promptBlock = `\n◇ Edit Goal Objective\n  Current: ${g.objective}\n`;
+                        const nextObj = tui
+                            ? (await tui.askTransient(promptBlock, 'New objective (Enter to cancel): ', undefined, { escHint: 'cancel' })).trim()
+                            : (display(promptBlock), (await question('New objective (Enter to cancel): ')).trim());
+                        if (!nextObj) {
+                            if (tui)
+                                tui.setNotice('Cancelled /goal edit.');
+                            else
+                                display('Cancelled /goal edit.\n');
+                            continue;
+                        }
+                        await executeImmediateCommand(`/goal edit ${nextObj}`);
+                        continue;
+                    }
+                    if (input === '/key') {
+                        const { saveCredential } = await import('./config.js');
+                        const entered = (tui
+                            ? await tui.question(`New API key for ${runtime.keyEnv} (hidden, Esc to cancel): `, undefined, false, { escCancels: true, mask: true }).catch(() => '')
+                            : await questionHidden(`New API key for ${runtime.keyEnv} (hidden): `)).trim();
+                        if (!entered) {
+                            display('API key unchanged.\n');
+                            continue;
+                        }
+                        await saveCredential(runtime.keyEnv, entered);
+                        if (process.env[runtime.keyEnv]?.trim()) {
+                            display(`Saved to credentials.json, but ${runtime.keyEnv} is set in the environment and takes precedence.\n`);
+                        }
+                        runtime = await resolveRuntime(config, runtime.cwd);
+                        apiKey = runtime.apiKey;
+                        await rebuildHarness();
+                        display(`API key for ${runtime.keyEnv} updated (${entered.slice(0, 4)}…${entered.slice(-2)}).\n`);
+                        continue;
+                    }
+                    if (input.startsWith('/prompts:')) {
+                        const { discoverPrompts, expandPromptTemplate } = await import('./prompts.js');
+                        const match = /^\/prompts:([A-Za-z0-9][A-Za-z0-9_.-]*)\s*([\s\S]*)$/.exec(input);
+                        const prompts = await discoverPrompts(runtime.cwd);
+                        const found = match ? prompts.find(p => p.name.toLowerCase() === match[1].toLowerCase()) : undefined;
+                        if (!found) {
+                            display(`Prompt "${match?.[1] ?? input.slice(9)}" not found. Run /prompts to list them.\n`);
+                            continue;
+                        }
+                        await run(expandPromptTemplate(found.body, match[2]));
+                        continue;
+                    }
+                    if (input === '/setup' || input === '/config' || input === '/provider') {
                         try {
                             config = await runSetupWizard(config, {
                                 write: text => display(text),
                                 // Esc cancels the whole wizard (nothing is persisted until the final step).
                                 ask: label => (tui ? tui.question(label, undefined, false, { escCancels: true }) : question(label)),
+                                askSecret: label => (tui ? tui.question(label, undefined, false, { escCancels: true, mask: true }) : questionHidden(label)),
                             });
                         }
                         catch (error) {
@@ -1582,9 +2048,7 @@ export async function main(argv = process.argv.slice(2)) {
                         tui?.setTitle(`${runtime.model} · ${store.session.id.slice(0, 8)}`);
                         tui?.setEffort(runtime.effort);
                         syncTuiHeader();
-                        const built = await buildHarness(mode);
-                        tools = built.tools;
-                        harness = built.harness;
+                        await rebuildHarness();
                         continue;
                     }
                     if (input === '/model' || input.startsWith('/model ')) {
@@ -1652,9 +2116,7 @@ export async function main(argv = process.argv.slice(2)) {
                         tui?.setTitle(`${runtime.model} · ${store.session.id.slice(0, 8)}`);
                         tui?.setEffort(runtime.effort);
                         syncTuiHeader();
-                        const built = await buildHarness(mode);
-                        tools = built.tools;
-                        harness = built.harness;
+                        await rebuildHarness();
                         display(`Active model: ${runtime.model} (ctx: ${Math.round(runtime.contextWindow / 1024)}k · out: ${Math.round(runtime.maxOutputTokens / 1000)}k · ${caps.supportsVision === false ? 'text-only' : 'vision'} · effort: ${runtime.effort ?? 'default'})\n`);
                         continue;
                     }
@@ -1682,9 +2144,7 @@ export async function main(argv = process.argv.slice(2)) {
                         runtime = await resolveRuntime(config, runtime.cwd);
                         tui?.setEffort(runtime.effort);
                         syncTuiHeader();
-                        const built = await buildHarness(mode);
-                        tools = built.tools;
-                        harness = built.harness;
+                        await rebuildHarness();
                         display(`Reasoning effort set to: ${runtime.effort ?? 'default'}\n`);
                         continue;
                     }
@@ -1771,9 +2231,12 @@ export async function main(argv = process.argv.slice(2)) {
                         const parts = raw ? raw.split(/\s+/) : [];
                         let scope = 'both';
                         let steps = 1;
+                        let force = false;
                         for (const p of parts) {
                             const lp = p.toLowerCase();
-                            if (lp === 'code' || lp === 'files' || lp === 'file' || lp === 'source')
+                            if (lp === '--force' || lp === '-f' || lp === 'force')
+                                force = true;
+                            else if (lp === 'code' || lp === 'files' || lp === 'file' || lp === 'source')
                                 scope = 'code';
                             else if (lp === 'msg' || lp === 'messages' || lp === 'chat')
                                 scope = 'messages';
@@ -1786,7 +2249,16 @@ export async function main(argv = process.argv.slice(2)) {
                             }
                         }
                         try {
-                            const res = await harness.revert({ steps, scope });
+                            const res = await harness.revert({ steps, scope, force });
+                            // Files edited after the agent's turn are never overwritten silently.
+                            const keptNote = res.conflictFiles.length
+                                ? `\n⚠ Kept ${res.conflictFiles.length} file(s) changed after that turn: ${res.conflictFiles.join(', ')} (use /revert ${steps} ${scope} --force to overwrite)\n`
+                                : '';
+                            const lostNote = res.unrecoverableFiles.length
+                                ? `\n⚠ Backup pruned (session size limit), not restored: ${res.unrecoverableFiles.join(', ')}\n`
+                                : '';
+                            if (keptNote || lostNote)
+                                display(keptNote + lostNote);
                             if (tui) {
                                 tui.setTokens(store.session.tokens);
                                 syncTuiHeader(true);
@@ -1831,26 +2303,6 @@ export async function main(argv = process.argv.slice(2)) {
                         }
                         continue;
                     }
-                    if (input === '/todo' || input.startsWith('/todo ')) {
-                        const arg = input.slice(5).trim().toLowerCase();
-                        if (arg === 'clear' || arg === 'reset') {
-                            tools.todos = [];
-                            store.session.todos = [];
-                            await store.save();
-                            tui?.event({ type: 'todo', todos: [] });
-                            display('Cleared todo checklist.\n');
-                        }
-                        else {
-                            display(`\n${formatTodos(tools.todos)}\n`);
-                        }
-                        continue;
-                    }
-                    if (input === '/fork' || input.startsWith('/fork ')) {
-                        const title = input.slice(5).trim() || undefined;
-                        const forkedId = await store.forkToNewFile(title);
-                        display(`Forked current session (${store.session.messages.length} messages) -> new session ID: ${forkedId}\nSwitch to it now with: /resume ${forkedId.slice(0, 8)} (or vyen --resume ${forkedId.slice(0, 8)})\n`);
-                        continue;
-                    }
                     if (input === '/new' || input.startsWith('/new ')) {
                         const newTitle = input.slice(4).trim() || undefined;
                         const sessionsRoot = join(runtime.dataDir, 'sessions');
@@ -1863,9 +2315,7 @@ export async function main(argv = process.argv.slice(2)) {
                         store = newStore;
                         await oldStore.discardIfEmpty();
                         await oldStore.close();
-                        const built = await buildHarness(mode);
-                        tools = built.tools;
-                        harness = built.harness;
+                        await rebuildHarness();
                         tui?.clear();
                         tui?.setTitle(store.session.title ? `${runtime.model} · ${store.session.title}` : `${runtime.model} · ${store.session.id.slice(0, 8)}`);
                         tui?.setTokens(0);
@@ -1878,73 +2328,114 @@ export async function main(argv = process.argv.slice(2)) {
                     if (input === '/resume' || input.startsWith('/resume ')) {
                         const sessionsRoot = join(runtime.dataDir, 'sessions');
                         const allList = await SessionStore.list(sessionsRoot);
-                        const wsList = allList.filter(s => sameWorkspace(s.cwd, runtime.cwd));
-                        const rawPool = wsList.length ? wsList : allList;
-                        const nonEmptyPool = rawPool.filter(s => (s.messagesCount ?? 0) > 0 || Boolean(s.title));
-                        const candidates = nonEmptyPool.length ? nonEmptyPool : rawPool;
+                        const resumable = (s) => (s.messagesCount ?? 0) > 0 || Boolean(s.title);
+                        const projectSessions = allList.filter(resumable);
+                        const folderSessions = projectSessions.filter(s => sameWorkspace(s.cwd, runtime.cwd));
                         let arg = input.slice(7).trim();
+                        let targetId;
                         if (!arg) {
-                            if (!candidates.length) {
-                                display('No saved sessions found.\n');
+                            if (!projectSessions.length) {
+                                display('No saved sessions yet. Sessions appear here after the first prompt.\n');
                                 continue;
                             }
-                            const rows = candidates.slice(0, 15).map((s, idx) => {
-                                const numStr = String(idx + 1).padStart(2, ' ');
-                                const currentTag = s.id === store.session.id ? ' • current' : '';
-                                const msgTag = `${s.messagesCount ?? 0} msgs`;
-                                const ageTag = formatRelativeTime(s.updatedAt);
-                                const rawLabel = s.title ? `[${s.title}] ${s.preview ?? ''}`.trim() : s.preview ? s.preview : '(empty session)';
-                                const label = rawLabel.replace(/\s+/g, ' ').slice(0, 64);
-                                return `  ${numStr}. ${s.id.slice(0, 8)} · ${ageTag.padEnd(8)} · ${msgTag.padEnd(8)} · ${label}${currentTag}`;
-                            });
-                            const pickerBlock = `\n◇ Resume saved session · ${candidates.length} in workspace\n${rows.join('\n')}\n`;
-                            const promptText = `Resume [1-${Math.min(15, candidates.length)}, latest, ID prefix, or Esc/q to cancel]: `;
-                            const choice = tui
-                                ? (await tui.askTransient(pickerBlock, promptText, undefined, { escHint: 'cancel' })).trim()
-                                : (display(pickerBlock), (await question(promptText)).trim());
-                            if (!choice || choice.toLowerCase() === 'q' || choice.toLowerCase() === 'cancel' || choice === '0') {
-                                if (tui)
-                                    tui.setNotice('Cancelled /resume.');
-                                else
-                                    display('Cancelled /resume.\n');
-                                continue;
+                            if (tui) {
+                                // Two tabs so a developer who does not remember the folder can still find a session.
+                                const toItem = (s, showFolder) => ({
+                                    id: s.id,
+                                    label: `${s.id === store.session.id ? '(current) ' : ''}${s.title ? `${s.title}: ` : ''}${s.preview ?? '(no prompt yet)'}`,
+                                    meta: [showFolder ? folderLabel(s.cwd) : '', formatRelativeTime(s.updatedAt), `${s.messagesCount ?? 0} msgs`].filter(Boolean).join('   '),
+                                    detail: `${s.cwd}   ${s.id.slice(0, 8)}   ${s.model}`,
+                                    search: `${s.cwd} ${s.model} ${s.title ?? ''}`,
+                                });
+                                const picked = await tui.pick('Resume', [
+                                    { label: 'This folder', items: folderSessions.map(s => toItem(s, false)), empty: 'No sessions in this folder yet. Press → for all projects.' },
+                                    { label: 'All projects', items: projectSessions.map(s => toItem(s, true)) },
+                                ], { initialTab: folderSessions.length ? 0 : 1, action: 'resume' });
+                                if (!picked) {
+                                    tui.setNotice('Resume cancelled.');
+                                    continue;
+                                }
+                                targetId = picked.item.id;
                             }
-                            arg = choice;
-                        }
-                        const num = Number(arg);
-                        if (Number.isInteger(num) && num >= 1 && num <= candidates.length) {
-                            arg = candidates[num - 1].id;
+                            else {
+                                // Readline mode: a numbered list; "a" switches between this folder and all projects.
+                                let showAll = folderSessions.length === 0;
+                                for (;;) {
+                                    const pool = showAll ? projectSessions : folderSessions;
+                                    const rows = pool.slice(0, 20).map((s, idx) => `  ${String(idx + 1).padStart(2)}  ${(s.title ?? s.preview ?? '(no prompt yet)').replace(/\s+/g, ' ').slice(0, 60)}   ${showAll ? `${folderLabel(s.cwd)}   ` : ''}${formatRelativeTime(s.updatedAt)}`);
+                                    display(`\n${showAll ? 'All projects' : 'This folder'} (${pool.length})\n${rows.join('\n') || '  (none)'}\n`);
+                                    const choice = (await question(`Resume [number, ID prefix, a = ${showAll ? 'this folder' : 'all projects'}, Enter = cancel]: `)).trim();
+                                    if (choice.toLowerCase() === 'a') {
+                                        showAll = !showAll;
+                                        continue;
+                                    }
+                                    const n = Number(choice);
+                                    targetId = Number.isInteger(n) && n >= 1 && n <= pool.length ? pool[n - 1].id : choice || undefined;
+                                    break;
+                                }
+                                if (!targetId) {
+                                    display('Resume cancelled.\n');
+                                    continue;
+                                }
+                            }
+                            arg = targetId;
                         }
                         try {
-                            const targetMatch = arg === 'latest'
-                                ? candidates.find(s => s.id !== store.session.id && (s.messagesCount ?? 0) > 0)?.id
-                                    ?? candidates.find(s => s.id !== store.session.id)?.id
-                                    ?? candidates[0]?.id
-                                : candidates.find(s => s.id === arg || s.id.toLowerCase().startsWith(arg.toLowerCase()))?.id
-                                    ?? allList.find(s => s.id === arg || s.id.toLowerCase().startsWith(arg.toLowerCase()))?.id
-                                    ?? arg;
+                            const candidates = folderSessions.length ? folderSessions : projectSessions;
+                            const num = Number(arg);
+                            const prefix = arg.toLowerCase();
+                            const targetMatch = Number.isInteger(num) && num >= 1 && num <= candidates.length && !/^[0-9a-f]{4,}$/i.test(arg)
+                                ? candidates[num - 1].id
+                                : arg === 'latest'
+                                    ? candidates.find(s => s.id !== store.session.id)?.id ?? candidates[0]?.id
+                                    : allList.find(s => s.id.toLowerCase() === prefix)?.id
+                                        ?? folderSessions.find(s => s.id.toLowerCase().startsWith(prefix))?.id
+                                        ?? allList.find(s => s.id.toLowerCase().startsWith(prefix))?.id
+                                        ?? arg;
                             if (targetMatch === store.session.id) {
                                 display(`Already in session ${store.session.id.slice(0, 8)}.\n`);
                                 renderResumedHistory();
                                 continue;
                             }
-                            const newStore = await SessionStore.open(sessionsRoot, runtime, targetMatch, store.session.id);
+                            // A session from another project brings its workspace with it.
+                            const target = allList.find(s => s.id === targetMatch);
+                            const previousRuntime = runtime;
+                            const switching = target !== undefined && !sameWorkspace(target.cwd, runtime.cwd);
+                            if (switching) {
+                                const { realpath } = await import('node:fs/promises');
+                                const folder = await realpath(target.cwd).catch(() => undefined);
+                                if (!folder) {
+                                    display(`Cannot resume: the session's folder no longer exists (${target.cwd}).\n`);
+                                    continue;
+                                }
+                                runtime = await resolveRuntime(config, folder);
+                            }
+                            let newStore;
+                            try {
+                                newStore = await SessionStore.open(sessionsRoot, runtime, targetMatch, store.session.id);
+                            }
+                            catch (error) {
+                                runtime = previousRuntime;
+                                throw error;
+                            }
                             const oldStore = store;
                             store = newStore;
                             await oldStore.discardIfEmpty();
                             await oldStore.close();
-                            const built = await buildHarness(mode);
-                            tools = built.tools;
-                            harness = built.harness;
+                            await rebuildHarness(switching ? { reconnectMcp: true } : {});
                             if (tui) {
                                 tui.clear();
                                 display(welcomeBanner(runtime.model, runtime.provider, runtime.baseUrl, runtime.effort, runtime.cwd, store.session.id, mode));
+                                if (switching)
+                                    void tools.files.listWorkspaceFiles().then(files => tui?.setWorkspaceFiles(files)).catch(() => { });
                             }
                             tui?.setTitle(store.session.title ? `${runtime.model} · ${store.session.title}` : `${runtime.model} · ${store.session.id.slice(0, 8)}`);
                             tui?.setTokens(store.session.tokens);
                             syncTuiHeader(true);
                             tui?.event({ type: 'todo', todos: store.session.todos ?? [] });
                             renderResumedHistory();
+                            if (switching)
+                                display(`Workspace switched to ${runtime.cwd}\n`);
                             if (!store.session.messages.length) {
                                 display(`Resumed session ${store.session.id.slice(0, 8)} (0 messages).\n`);
                             }
@@ -1954,57 +2445,6 @@ export async function main(argv = process.argv.slice(2)) {
                         }
                         continue;
                     }
-                    if (input.startsWith('/rename ')) {
-                        const newTitle = input.slice(8).trim();
-                        if (newTitle) {
-                            store.session.title = newTitle;
-                            await store.save();
-                            tui?.setTitle(`${runtime.model} · ${newTitle}`);
-                            display(`Session renamed to: ${newTitle}\n`);
-                        }
-                        continue;
-                    }
-                    if (input === '/export' || input.startsWith('/export ')) {
-                        const { writeFile } = await import('node:fs/promises');
-                        const outName = input.slice(7).trim() || `vyen-session-${store.session.id.slice(0, 8)}.md`;
-                        const targetFile = await tools.files.path(outName);
-                        const lines = [
-                            `# Vyen Session ${store.session.title ?? store.session.id}`,
-                            `- **Model**: ${runtime.model} (${runtime.provider})`,
-                            `- **Updated**: ${store.session.updatedAt}`,
-                            '',
-                        ];
-                        for (const m of store.session.messages) {
-                            lines.push(`## ${m.role.toUpperCase()}`);
-                            lines.push(typeof m.content === 'string' ? m.content : JSON.stringify(m.content, null, 2));
-                            lines.push('');
-                        }
-                        await writeFile(targetFile, lines.join('\n'), 'utf8');
-                        display(`Exported session transcript to ${outName}\n`);
-                        continue;
-                    }
-                    if (input.startsWith('!')) {
-                        const cmd = input.slice(1).trim();
-                        if (!cmd) {
-                            display('Usage: !<command> (runs a shell command directly in workspace and records output in session context)\n');
-                            continue;
-                        }
-                        const { runCommand } = await import('./process.js');
-                        display(`\n$ ${cmd}\n`);
-                        try {
-                            const res = await runCommand('bash', ['-c', cmd], { cwd: runtime.cwd, signal: AbortSignal.timeout(60_000), timeoutMs: 60_000 });
-                            display(`${res.output || '(no output)'}\n[Exit code: ${res.code}]\n`);
-                            store.session.messages.push({
-                                role: 'user',
-                                content: `<user_shell_command>\n<command>${cmd}</command>\n<result>\nExit code: ${res.code}\n${res.output.slice(0, 8000)}\n</result>\n</user_shell_command>`,
-                            });
-                            await store.save();
-                        }
-                        catch (error) {
-                            display(`Shell command failed: ${safeError(error, apiKey)}\n`);
-                        }
-                        continue;
-                    }
                     if (input === '/compact' || input.startsWith('/compact ')) {
                         const focus = input.slice(8).trim() || undefined;
                         controller = new AbortController();
@@ -2027,9 +2467,7 @@ export async function main(argv = process.argv.slice(2)) {
                         tui?.setStatus('Running');
                         try {
                             const res = await harness.recap(controller.signal);
-                            display(`\n╭─── Session Recap (/recap) ──────────────────────────────────────╮\n` +
-                                `${res.text}\n` +
-                                `╰─────────────────────────────────────────────────────────────────╯\n`);
+                            display(`\n◇ Session recap\n${res.text.split('\n').map(line => `  ${line}`).join('\n')}\n`);
                         }
                         catch (error) {
                             display(`Recap failed: ${safeError(error, apiKey)}\n`);
@@ -2056,22 +2494,20 @@ export async function main(argv = process.argv.slice(2)) {
                             }
                             const real = await realpath(candidate).catch(() => candidate);
                             runtime = { ...runtime, cwd: real };
-                            // Checkpoints hold paths relative to the workspace they were taken
-                            // in; after a workspace change they would restore another
-                            // project's files, so they are dropped.
                             const workspaceChanged = retargetSessionWorkspace(store, real);
                             await store.save();
-                            const built = await buildHarness(mode);
-                            tools = built.tools;
-                            harness = built.harness;
+                            await rebuildHarness({ reconnectMcp: true });
+                            if (workspaceChanged) {
+                                display(`Changed workspace directory to: ${real}. Turn checkpoints were cleared; /revert can no longer undo the previous workspace.\n`);
+                            }
+                            else {
+                                display(`Changed workspace directory to: ${real}\n`);
+                            }
                             if (tui) {
                                 void tools.files.listWorkspaceFiles().then(files => tui?.setWorkspaceFiles(files)).catch(() => { });
                                 syncTuiHeader();
                                 tui.setNotice(`Changed directory to: ${real}`);
                             }
-                            display(workspaceChanged
-                                ? `Changed workspace directory to: ${real}. Turn checkpoints were cleared; /revert can no longer undo the previous workspace.\n`
-                                : `Changed workspace directory to: ${real}\n`);
                         }
                         catch (error) {
                             display(`Failed to change directory: ${safeError(error, apiKey)}\n`);
@@ -2087,9 +2523,7 @@ export async function main(argv = process.argv.slice(2)) {
                             store = await SessionStore.open(sessionsRoot, runtime);
                             await oldStore.close();
                             await SessionStore.deleteSession(sessionsRoot, oldId);
-                            const built = await buildHarness(mode);
-                            tools = built.tools;
-                            harness = built.harness;
+                            await rebuildHarness();
                             tui?.clear();
                             tui?.setTitle(`${runtime.model} · ${store.session.id.slice(0, 8)}`);
                             tui?.setTokens(0);
@@ -2165,9 +2599,7 @@ export async function main(argv = process.argv.slice(2)) {
                         const sub = (subArgs[0] ?? 'list').toLowerCase();
                         const { loadMcpConfig, saveMcpConfig, importCodexMcpServers } = await import('./mcp.js');
                         if (sub === 'reload' || sub === 'reconnect') {
-                            const built = await buildHarness(mode);
-                            tools = built.tools;
-                            harness = built.harness;
+                            await rebuildHarness({ reconnectMcp: true });
                             display(`Reloaded MCP servers (${manager?.tools.length ?? 0} MCP tools active).\n`);
                             continue;
                         }
@@ -2179,9 +2611,7 @@ export async function main(argv = process.argv.slice(2)) {
                                 }
                                 else {
                                     display(`Imported ${res.imported.length} MCP server(s) into ${res.path}: ${res.imported.join(', ')}\n`);
-                                    const built = await buildHarness(mode);
-                                    tools = built.tools;
-                                    harness = built.harness;
+                                    await rebuildHarness({ reconnectMcp: true });
                                     display(`Active MCP tools: ${manager?.tools.length ?? 0}\n`);
                                 }
                             }
@@ -2203,16 +2633,12 @@ export async function main(argv = process.argv.slice(2)) {
                             }
                             delete cfg.servers[target];
                             await saveMcpConfig(cfg);
-                            const built = await buildHarness(mode);
-                            tools = built.tools;
-                            harness = built.harness;
+                            await rebuildHarness({ reconnectMcp: true });
                             display(`Removed MCP server "${target}" (${manager?.tools.length ?? 0} MCP tools active).\n`);
                             continue;
                         }
                         if (sub === 'check') {
-                            const built = await buildHarness(mode);
-                            tools = built.tools;
-                            harness = built.harness;
+                            await rebuildHarness({ reconnectMcp: true });
                             for (const st of manager?.statuses ?? []) {
                                 display(`  ${st.name}: ${st.status}${st.status === 'ok' ? ` (${st.toolCount} tools)` : st.error ? ` — ${st.error}` : ''}\n`);
                             }
@@ -2243,62 +2669,6 @@ export async function main(argv = process.argv.slice(2)) {
                         await run(`Use a subagent (spawn_agent + wait_agent, or delegate_task / delegate_edit as appropriate) to execute the following task and report the result:\n\n${rest}`);
                         continue;
                     }
-                    if (input === '/tools') {
-                        const names = Object.keys(tools.schemas());
-                        display(names.map(n => `  ${tools.isReadOnly(n) ? '● [read]' : '◆ [exec]'} ${n}`).join('\n') + '\n');
-                        continue;
-                    }
-                    if (input === '/sessions') {
-                        const list = await SessionStore.list(join(runtime.dataDir, 'sessions'));
-                        display((list.length ? list.map(s => {
-                            const cur = s.id === store.session.id ? ' [current]' : '';
-                            const label = s.title ? ` [${s.title}]` : s.preview ? ` "${s.preview}"` : '';
-                            return `  ${s.id.slice(0, 8)}${cur}  (${s.messagesCount ?? 0} msgs)  ${s.updatedAt}  ${s.model}${label}  ${s.cwd}`;
-                        }).join('\n') : '  No saved sessions.') + '\n');
-                        continue;
-                    }
-                    if (input === '/doctor') {
-                        const { runCommand } = await import('./process.js');
-                        const ok = async (cmd) => {
-                            try {
-                                return (await runCommand(cmd, ['--version'], { cwd: runtime.cwd, signal: AbortSignal.timeout(5000), timeoutMs: 5000 })).code === 0;
-                            }
-                            catch {
-                                return false;
-                            }
-                        };
-                        const [b, r, discovered] = await Promise.all([
-                            ok('bash'),
-                            ok('rg'),
-                            discoverModels(runtime.baseUrl, runtime.apiKey, runtime.provider),
-                        ]);
-                        const modelInList = discovered.some((m) => m.id === runtime.model);
-                        const gatewayStatus = discovered.length > 0
-                            ? `OK (${discovered.length} models: ${discovered.map((m) => m.id).join(', ')} · active model ${modelInList ? 'verified' : 'NOT listed'})`
-                            : 'Unreachable or no /models response';
-                        display(`Provider: ${runtime.provider} | Model: ${runtime.model} | Effort: ${runtime.effort ?? 'default'} | BaseURL: ${runtime.baseUrl}\n` +
-                            `Bash: ${b ? 'OK' : 'Missing'} | Ripgrep: ${r ? 'OK' : 'JS fallback'} | API Key: Configured\n` +
-                            `Gateway (/models): ${gatewayStatus}\n`);
-                        continue;
-                    }
-                    if (input === '/status') {
-                        const { estimatedTokens } = await import('./context.js');
-                        const usedEst = estimatedTokens(store.session.messages, '');
-                        const pct = Math.min(100, Math.round((usedEst / runtime.contextWindow) * 100));
-                        display(`Session        ${store.session.id}${store.session.title ? ` (${store.session.title})` : ''}\n` +
-                            `Provider       ${runtime.provider} (${runtime.baseUrl})\n` +
-                            `Model          ${runtime.model}\n` +
-                            `Effort         ${runtime.effort ?? 'default'}\n` +
-                            `Mode           ${mode}\n` +
-                            `View           ${viewMode}\n` +
-                            `Workspace      ${runtime.cwd}\n` +
-                            `Checkpoints    ${store.session.checkpoints?.length ?? 0} turn(s)\n` +
-                            `Context usage  ~${usedEst} / ${runtime.contextWindow} tokens (${pct}%)\n` +
-                            `Compactions    ${store.session.compactions}\n` +
-                            `Session tokens ${store.session.tokens}\n` +
-                            `MCP tools      ${manager?.tools.length ?? 0}\n`);
-                        continue;
-                    }
                     await run(input);
                 }
             }