koneck 2.29.0 → 2.30.0-next.2

package/dist/ink-chat.js

@@ -9,9 +9,10 @@ import { loadMemory } from './memory.js';
 import { loadKoneckConfig, saveKoneckConfig, setConfigKey, configKeyDescriptions, CONFIG_FILE, CONFIG_SCHEMA, stepValue, displayValue } from './config-store.js';
 import { PROVIDERS, resolveProvider, getApiKey, addUserProvider, userProvidersPath, needsNoCredential, servesLocally } from './providers.js';
 import { resolveEndpoint, normaliseEndpoint, withEndpoint, savedEndpoints, shortSource, resolveModelChoice, withModel } from './endpoints.js';
-import { loadProjectConfig, loadGlobalConfig } from './config.js';
-import { listCheckpoints, revertCheckpoint, snapshotTree, filesTouchedBy } from './checkpoint.js';
+import { loadProjectConfig, loadGlobalConfig, saveGlobalConfig, withoutStoredApiKey } from './config.js';
+import { listCheckpoints, revertCheckpoint, previewCheckpoint, snapshotTree, filesTouchedBy, createWorkspaceCheckpoint, checkpointScope } from './checkpoint.js';
 import { fileDiff, diffSummary } from './diff-view.js';
+import { untrackedPatches } from './git-diff.js';
 import { listWorkspaceEntries, filterEntries, activeReference } from './workspace-files.js';
 import { isSlashCommand, findMentions, shortenMentions } from './mentions.js';
 import { bar, humanTokens, humanDuration, diffStatSince, modelInfoFrom, contextWindowFor, recordStatus, classifyResponse, stateLabel, readModelStatus, computeUiWidth, } from './usage.js';
@@ -33,7 +34,7 @@ const VERSION = (() => {
     }
 })();
 import { startBus, listSessions as listBusSessions, resolveTarget, deliver, } from './session-bus.js';
-import { MODES as MODE_SPECS, modeSpec, decide, loadRules, saveRules, addRule, commandPrefixSuggestion, describeRule, } from './permissions.js';
+import { MODES as MODE_SPECS, modeSpec, decide, loadRules, saveRules, addRule, commandPrefixSuggestion, describeRule, ruleMatches, toolRisk, isReadOnlyCommand, } from './permissions.js';
 import { AskQueue } from './ask-queue.js';
 import { planSummary } from './plan.js';
 import { logoFor } from './logo.js';
@@ -43,9 +44,12 @@ import { renderTrajectory } from './trajectory.js';
 import { describeSandbox, resolveSandbox } from './sandbox.js';
 import { doctorChecks, doctorReport } from './doctor.js';
 import { runQualityGate } from './quality-gate.js';
+import { runPreflight, preflightReport, isPreflightReady } from './preflight.js';
 import { listAuditEvents } from './audit.js';
 import { initializePolicy, loadPolicy, POLICY_FILE } from './policy.js';
 import { isWorkspaceTrusted, trustWorkspace, untrustWorkspace } from './workspace-trust.js';
+import { loadMCPConfig } from './mcp.js';
+import { renameSymbol, extractInterface, moveSymbol } from './refactor.js';
 const CYAN = '#54D7E7';
 const GREEN = '#9BCB8F';
 const CRIMSON = '#E8878D';
@@ -263,6 +267,10 @@ export function liveReplyLines(termRows) {
     const rows = termRows && termRows > 0 ? termRows : 24;
     return rows < 12 ? 1 : 2;
 }
+/** Sampling cadence for live stream refs: quick enough to read, slow enough not to flash. */
+export function liveRefreshDelay(idleForMs) {
+    return idleForMs < 2_000 ? 500 : 1_000;
+}
 const SPINNER = G.spinner;
 /**
  * A highlight that sweeps left to right through the word, so the label itself looks like it is
@@ -512,11 +520,22 @@ const COMMANDS = [
     { cmd: '/endpoint', desc: "Show or change this provider's URL, e.g. a remote Ollama" },
     { cmd: '/redraw', desc: 'Repaint the terminal — same as ctrl+L' },
     { cmd: '/key', desc: 'Enter an API key for the current provider' },
+    { cmd: '/logout', desc: 'Forget Koneck-stored API credentials; keep preferences' },
     { cmd: '/model', desc: 'Show or set the model by name' },
     { cmd: '/provider', desc: 'Show or switch provider' },
     { cmd: '/status', desc: 'Provider, model, mode, tokens, cost, workspace' },
+    { cmd: '/permissions', desc: 'Show or set approval posture: on or off' },
+    { cmd: '/worktree', desc: 'Show or set isolated-worktree default for future CLI tasks' },
+    { cmd: '/goal', desc: 'Set, inspect, or clear the session’s persistent outcome' },
     { cmd: '/doctor', desc: 'Check the active provider, workspace, and developer tools' },
-    { cmd: '/revert', desc: 'Undo file edits KONECK made' },
+    { cmd: '/context', desc: 'Show the active model context-window source and limit' },
+    { cmd: '/mcp', desc: 'Show configured MCP integrations and live tools' },
+    { cmd: '/init', desc: 'Create or refresh KONECK.md project instructions' },
+    { cmd: '/rename', desc: 'Safely rename a TypeScript symbol across the workspace' },
+    { cmd: '/extract', desc: 'Extract a TypeScript class interface' },
+    { cmd: '/move', desc: 'Move a TypeScript symbol and update imports' },
+    { cmd: '/checkpoint', desc: 'Create or list whole-workspace restore points' },
+    { cmd: '/revert', desc: 'Restore an edit checkpoint or named workspace snapshot' },
     { cmd: '/sessions', desc: 'List running KONECK sessions and their state' },
     { cmd: '/send', desc: 'Hand work to another session: /send <repo> <instruction>' },
     { cmd: '/ask', desc: 'Ask another session and wait: /ask <repo> <question>' },
@@ -547,9 +566,14 @@ const COMMANDS = [
     { cmd: '/diff', desc: 'Show uncommitted git changes' },
     { cmd: '/changes', desc: 'Summarize staged, unstaged, and untracked changes' },
     { cmd: '/quality', desc: 'Run the detected lint and test checks' },
+    { cmd: '/preflight', desc: 'Run the deterministic ready-to-review gate' },
+    { cmd: '/ship', desc: 'Run readiness checks, then an enforced read-only review' },
     { cmd: '/audit', desc: 'Show recent redacted tool activity' },
     { cmd: '/policy', desc: 'Show or initialize workspace safety rules' },
     { cmd: '/trust', desc: 'Show, persist, or revoke this workspace trust grant' },
+    { cmd: '/review', desc: 'Review the complete working tree for defects (/review --fix)' },
+    { cmd: '/code-review', desc: 'Alias for /review' },
+    { cmd: '/security-review', desc: 'Audit the complete working tree for security risks' },
     { cmd: '/verify', desc: 'Run the project test command' },
     { cmd: '/rewind', desc: 'Drop the last exchange from history' },
     { cmd: '/copy', desc: 'Copy the last response to the clipboard' },
@@ -559,6 +583,25 @@ const COMMANDS = [
     { cmd: '/exit', desc: 'Save and exit' },
     { cmd: '/quit', desc: 'Save and exit (alias of /exit)' },
 ];
+/** Logical families for the searchable command palette; headers reuse an existing row. */
+export function commandGroup(command) {
+    if (command === '/help')
+        return 'Start here';
+    if (new Set(['/connect', '/endpoint', '/key', '/logout', '/model', '/models', '/provider', '/doctor', '/context', '/mcp']).has(command))
+        return 'Connection';
+    if (new Set(['/goal', '/permissions', '/worktree', '/mode', '/effort', '/config', '/policy', '/trust']).has(command))
+        return 'Control';
+    if (new Set(['/init', '/rename', '/extract', '/move', '/checkpoint', '/revert', '/diff', '/changes', '/quality', '/preflight', '/ship', '/review', '/code-review', '/security-review', '/verify']).has(command))
+        return 'Workspace';
+    if (new Set(['/sessions', '/history', '/resume', '/save', '/name', '/fork', '/archive', '/rewind', '/clear', '/reset', '/new', '/exit', '/quit']).has(command))
+        return 'Sessions';
+    if (new Set(['/send', '/ask', '/agents', '/subtask', '/aside', '/queue']).has(command))
+        return 'Collaboration';
+    if (new Set(['/usage', '/tokens', '/cost', '/memory', '/activity', '/trajectory', '/audit']).has(command))
+        return 'Insight';
+    return 'Interface';
+}
+const COMMAND_GROUP_ORDER = ['Start here', 'Workspace', 'Connection', 'Control', 'Collaboration', 'Insight', 'Sessions', 'Interface'];
 /** How hard the model is asked to think. Shown in the /effort picker and the footer. */
 const EFFORT_BLURB = {
     low: 'Brief answers, fewest tokens, fastest turnaround',
@@ -566,6 +609,12 @@ const EFFORT_BLURB = {
     high: 'Thorough — covers edge cases, costs more tokens',
     max: 'Most rigorous analysis available; slowest and priciest',
 };
+/** Stable, grouped command inventory. Filtering preserves this order while ranking exact matches. */
+export function commandPaletteItems(commands = COMMANDS) {
+    return commands
+        .map(c => ({ value: c.cmd, label: c.cmd, desc: c.desc, group: commandGroup(c.cmd) }))
+        .sort((a, b) => COMMAND_GROUP_ORDER.indexOf(a.group) - COMMAND_GROUP_ORDER.indexOf(b.group));
+}
 // Bracketed paste. A terminal that has it enabled wraps pasted text in these markers, which is
 // the only reliable way to tell a paste from very fast typing. Ink strips the leading escape of
 // the opening marker before handing input to useInput, so the literal it sees is "[200~".
@@ -597,7 +646,6 @@ const MAX_DIFF_FILES = 4;
 /** The tabs of the usage pane, in the order they are shown. */
 const USAGE_TABS = ['settings', 'session', 'context', 'models', 'limits'];
 const MIN_REPLY_WIDTH = 24; // below this a table cannot render legibly anyway
-const PICKER_MIN_ROWS = 6;
 const PICKER_MAX_ROWS = 16;
 /**
  * Number of choices to keep visible in a palette.
@@ -606,8 +654,14 @@ const PICKER_MAX_ROWS = 16;
  * files, sessions, and providers equally easy to scan; on short terminals it yields space to
  * the composer and the rest remains available through search and paging.
  */
-export function pickerRowLimit(kind, itemCount, terminalRows) {
-    const terminalBudget = Math.max(PICKER_MIN_ROWS, terminalRows - 8);
+export function pickerRowLimit(kind, itemCount, terminalRows, reservedRows) {
+    // In ordinary scrollback this is not a fixed overlay: it can extend into the terminal's normal
+    // scroll region, so shrinking a command picker just because a pane has ten rows is needless
+    // friction. Only alternate-screen callers pass a reservation, because that is a fixed frame
+    // and overflow there makes Ink clear/repaint the entire screen.
+    const terminalBudget = reservedRows === undefined
+        ? PICKER_MAX_ROWS
+        : Math.max(1, (terminalRows && terminalRows > 0 ? terminalRows : 24) - reservedRows);
     // Keep kind in the signature: it documents that this is the common policy for *every* picker
     // and lets a future picker opt into a different policy without duplicating this calculation.
     void kind;
@@ -681,6 +735,23 @@ export function commandSuggestion(command, commands = COMMANDS.map(item => item.
     }
     return distance <= maxDistance ? best : undefined;
 }
+/**
+ * Keep a mistyped command palette useful. A normal search never invents a result; only when it
+ * finds none do we surface one close, known command, clearly labelled as a recovery suggestion.
+ * Enter still requires the user to select it, so this cannot turn `/revertx` into an undo.
+ */
+export function commandPaletteMatches(items, query) {
+    const matches = filterPickerItems([...items], query);
+    if (matches.length > 0 || query.trim() === '')
+        return matches;
+    const suggestion = commandSuggestion('/' + query.trim().replace(/^\//, ''), items.map(item => item.value));
+    const match = suggestion ? items.find(item => item.value === suggestion) : undefined;
+    return match ? [{ ...match, desc: `${match.desc} · suggested for /${query.trim().replace(/^\//, '')}` }] : [];
+}
+/** The draft restored after an unknown-command typo; it is intentionally not executed for them. */
+export function recoveredCommandDraft(suggestion, arg) {
+    return arg ? `${suggestion} ${arg}` : suggestion;
+}
 /** Keep a small, useful recall buffer without repeating the same submitted task. */
 export function appendDraftHistory(history, draft, limit = 100) {
     const entry = draft.trim();
@@ -696,10 +767,12 @@ export function appendDraftHistory(history, draft, limit = 100) {
  * would otherwise renumber the rows beneath it in one of the two paths and not the other.
  */
 export function askOptions(tool, prefix) {
-    const options = [
-        { key: '1', label: 'allow once', rule: null, allow: true },
-        { key: '2', label: `always allow ${tool} in this workspace`, rule: { tool }, allow: true },
-    ];
+    const options = [{ key: '1', label: 'allow once', rule: null, allow: true }];
+    // A native AST operation can follow references into arbitrary import sites, so a broad
+    // workspace-level grant would be far less specific than the operation just reviewed.
+    if (tool !== 'native_refactor') {
+        options.push({ key: '2', label: `always allow ${tool} in this workspace`, rule: { tool }, allow: true });
+    }
     if (prefix) {
         options.push({
             key: '3',
@@ -754,7 +827,7 @@ export function humanBytes(bytes) {
  */
 export function sessionTitle(meta) {
     if (meta.name)
-        return meta.name;
+        return redactSecrets(meta.name);
     const task = redactSecrets(meta.task ?? '').replace(/\s+/g, ' ').trim();
     if (!task || task === '(chat session)')
         return meta.id;
@@ -801,12 +874,209 @@ export function pickerLabelWidth(labels, descs, width) {
 const COMMANDS_THAT_MUST_WAIT = new Set([
     '/clear', '/reset', '/new', '/retry', // would wipe the history or begin a new turn
     '/model', '/provider', '/connect', '/key', '/endpoint', '/baseurl', // rebuild the session
+    '/logout', // drops this session's runtime credential
     '/resume', '/fork', // replace it
     '/revert', // undo files the turn may still be writing
-    '/init', '/setup',
+    '/init', '/setup', '/checkpoint', '/rename', '/extract', '/move', '/ship',
 ]);
 /** Commands that cannot do anything useful without an argument, so they are offered for editing. */
-const COMMANDS_NEEDING_ARGUMENT = new Set(['/send', '/ask', '/aside']);
+const COMMANDS_NEEDING_ARGUMENT = new Set(['/send', '/ask', '/aside', '/rename', '/extract', '/move']);
+/**
+ * The project brief is deliberately a normal agent turn, rather than a separate hidden client.
+ * It therefore uses the connected model, honours workspace policy and checkpoints its write just
+ * like every other edit.  `--force` is required when a maintainer's existing brief is present.
+ */
+export function initWorkspaceTask(force = false) {
+    return `Create ${force ? 'a refreshed' : 'a new'} KONECK.md in the repository root. Inspect the project first, then write a concise, accurate briefing for future coding agents. Include: overview, stack, layout, install/build/test/lint commands, conventions, important files, and practical gotchas. Do not invent facts. ${force ? 'Replace the existing KONECK.md after preserving any useful project-specific guidance.' : 'Do not overwrite an existing KONECK.md.'}`;
+}
+/** Human-readable MCP state without ever displaying configured environment values. */
+export function mcpStatusText(configured, connected) {
+    if (configured.length === 0) {
+        return 'No MCP servers are configured. Add servers to `.koneck/mcp.json`, then start a new session.';
+    }
+    const lines = configured.map(name => {
+        const server = connected.find(candidate => candidate.name === name);
+        if (!server)
+            return `**OFFLINE**  ${name} — could not connect when this session started`;
+        const names = server.tools.map(tool => tool.name);
+        const shown = names.slice(0, 12);
+        const suffix = names.length > shown.length ? `, +${names.length - shown.length} more` : '';
+        return `**ONLINE**   ${name} — ${names.length} tool${names.length === 1 ? '' : 's'}${shown.length ? `\n             ${shown.join(', ')}${suffix}` : ''}`;
+    });
+    return `**MCP integrations** — session capability snapshot\n\n${lines.join('\n\n')}\n\nMCP servers connect when a session starts. Use \`/reset\` after changing \`.koneck/mcp.json\`.`;
+}
+/** The review brief makes findings useful in a terminal, and keeps the default path read-only. */
+export function reviewTask(kind, fix = false) {
+    if (kind === 'security') {
+        return 'Perform a read-only security review of the complete current working tree. Inspect staged, unstaged, and untracked changes with git and the relevant source. Look for injection, authorization failures, secret exposure, unsafe deserialization, path traversal, SSRF, XSS, CSRF, insecure defaults, and dependency or configuration risks. Report only actionable findings, ordered by severity, with file:line evidence, exploit path, and remediation. State clearly if no findings are supported. Do not edit files.';
+    }
+    return fix
+        ? 'Review the complete current working tree for correctness, regressions, edge cases, maintainability, and missing tests. Inspect staged, unstaged, and untracked changes with git and the relevant source. Fix only high-confidence defects you can verify, then report each finding or fix with file:line evidence and the verification performed. Do not make unrelated refactors.'
+        : 'Perform a read-only review of the complete current working tree. Inspect staged, unstaged, and untracked changes with git and the relevant source. Find correctness bugs, regressions, edge cases, maintainability risks, and missing tests. Report only actionable findings, ordered by severity, with file:line evidence, impact, and a concrete recommendation. State clearly if no findings are supported. Do not edit files.';
+}
+/** The execution brief can be detailed without impersonating a user in the transcript. */
+export function taskTranscriptLabel(task, generatedLabel) {
+    return generatedLabel ?? task;
+}
+/** The summary model gets useful context, never an accidental credential from the transcript. */
+export function handoffSummaryInput(transcript) {
+    return redactSecrets(transcript);
+}
+/**
+ * `/aside` is a concurrent read-only investigation. Keep this allowlist deliberately smaller
+ * than the general read-risk class: `remember` mutates KONECK memory, and any unknown/MCP tool
+ * must be treated as consequential until its effect has been explicitly classified.
+ */
+const ASIDE_READ_TOOLS = new Set([
+    'read_files', 'list_dir', 'glob_search', 'grep_search', 'fetch_url', 'web_search',
+    'git_status', 'git_diff', 'git_log',
+]);
+export function asideAllowsTool(tool) {
+    return ASIDE_READ_TOOLS.has(tool);
+}
+/**
+ * Reviews are promises of observation, not a request that the model happens to obey. Keep that
+ * promise at the approval boundary. This intentionally does not reuse `toolRisk(tool) ===
+ * 'read'`: `remember` and `plan` are classified that way for normal agent ergonomics but still
+ * mutate KONECK state. A review must leave both the workspace and the session unchanged.
+ */
+const REVIEW_READ_TOOLS = new Set([
+    'read_files', 'list_dir', 'glob_search', 'grep_search', 'git_status', 'git_diff', 'git_log',
+]);
+export function readOnlyReviewAllows(tool, args) {
+    if (REVIEW_READ_TOOLS.has(tool))
+        return true;
+    if (tool !== 'execute_command')
+        return false;
+    try {
+        return isReadOnlyCommand(String(JSON.parse(args).command ?? ''));
+    }
+    catch {
+        return false;
+    }
+}
+/** A goal is compact enough to preserve context room, but rich enough to guide a long session. */
+export function normalizeSessionGoal(value) {
+    return value.trim().replace(/\s+/g, ' ').slice(0, 600);
+}
+/** Copy for the deliberate second step before a whole-workspace rollback. */
+export function workspaceRestoreConfirmation(id, label) {
+    return (`Workspace restore point ${id}\n  ${label.slice(0, 80)}\n\n` +
+        'This will restore every changed tracked and non-ignored file to that saved workspace state. ' +
+        'KONECK will first create an undo checkpoint.\n\n' +
+        `Review with \`/diff\`, then run \`/revert ${id} --confirm\` to proceed.`);
+}
+/** Keep a large recovery report inspectable without turning it into a terminal-sized wall. */
+export function checkpointPathSummary(paths, limit = 8) {
+    if (paths.length <= limit)
+        return paths.join(', ');
+    return `${paths.slice(0, Math.max(1, limit)).join(', ')}, … +${paths.length - Math.max(1, limit)} more`;
+}
+/** `/checkpoint list` is a safe discovery alias, never a snapshot called "list". */
+export function isCheckpointListCommand(arg) {
+    return arg.trim().toLowerCase() === 'list';
+}
+/** Parses the compact quoted argument form used by native structural refactor commands. */
+export function parseCommandArguments(input) {
+    const out = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+    const flush = () => { if (current !== '') {
+        out.push(current);
+        current = '';
+    } };
+    for (const char of input.trim()) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            else
+                current += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            flush();
+            continue;
+        }
+        current += char;
+    }
+    if (escaped)
+        current += '\\';
+    if (quote)
+        return null;
+    flush();
+    return out;
+}
+/**
+ * Native AST refactors can update arbitrary import sites. A restrictive policy must be enforced
+ * before that fan-out, rather than pretending the few command arguments describe every write.
+ */
+export function nativeRefactorPolicyReason(policy) {
+    if (!policy)
+        return null;
+    if ((policy.allowedWritePaths?.length ?? 0) > 0 || (policy.protectedPaths?.length ?? 0) > 0) {
+        return 'workspace policy constrains write paths, but a native refactor may rewrite import sites beyond its explicit arguments';
+    }
+    if ((policy.requireApprovalFor ?? []).some(tool => ['write_file', 'apply_diff', 'search_replace', 'move_file', 'delete_file'].includes(tool))) {
+        return 'workspace policy requires approval for writes; use a normal agent task so each write can be approved';
+    }
+    return null;
+}
+/** A restore report must distinguish a completed operation from an already-matching snapshot. */
+export function workspaceRestoreWasNoop(result) {
+    return result.restored.length + result.deleted.length + result.skipped.length === 0;
+}
+/** Whether Ink must stop for a confirmation instead of letting a tool run. */
+export function inkApprovalDecision(requireApproval, mode, tool, argsJson, rules, policyRequiresApproval = false) {
+    const base = decide(mode, tool, argsJson, rules);
+    if (base !== 'allow')
+        return base;
+    // A repository policy is an explicit boundary, not a suggestion a prior standing rule may
+    // silently erase. It remains stronger than this session's convenience posture.
+    if (policyRequiresApproval)
+        return 'ask';
+    if (!requireApproval)
+        return 'allow';
+    if (toolRisk(tool) === 'read')
+        return 'allow';
+    if (tool === 'execute_command') {
+        try {
+            if (isReadOnlyCommand(String(JSON.parse(argsJson).command ?? '')))
+                return 'allow';
+        }
+        catch { /* malformed calls are confirmed */ }
+    }
+    return rules.some(rule => ruleMatches(rule, tool, argsJson)) ? 'allow' : 'ask';
+}
+/** A context report names the evidence for its denominator instead of pretending every model fits. */
+export function contextStatusText(model, sessionPromptTokens, configuredLimit, detected) {
+    const known = detected?.limit ?? configuredLimit ?? contextWindowFor(model);
+    const source = detected?.source === 'provider' ? 'reported by the connected provider'
+        : detected ? detected.source
+            : configuredLimit ? 'configured by you'
+                : known ? 'KONECK model reference'
+                    : '';
+    if (!known) {
+        return `**Context window**\n\nModel: ${model}\nLimit: unknown — this provider did not report one and KONECK has no reliable reference.\n\nSet \`/config contextTokens <n>\` only when you know the serving limit. KONECK will otherwise avoid guessing.`;
+    }
+    const ratio = sessionPromptTokens > 0 ? sessionPromptTokens / known : 0;
+    const headroom = Math.max(0, known - sessionPromptTokens);
+    const pressure = ratio >= 1 ? `at least ${Math.round(ratio * 100)}%` : `${Math.round(ratio * 100)}%`;
+    return `**Context window**\n\nModel: ${model}\nLimit: ${known.toLocaleString()} tokens (${source})\nSession prompt total: ${sessionPromptTokens.toLocaleString()} tokens\n\nThe session total is ${pressure} of one window; prompts are rebuilt each turn, so it is a pressure signal rather than the exact next-request size. Estimated one-window headroom: ${headroom.toLocaleString()} tokens.\n\nUse \`/usage context\` for the live context panel, or \`/config contextTokens <n>\` when you know a more accurate serving limit.`;
+}
 export function commandRunsWhileBusy(cmd) {
     return !COMMANDS_THAT_MUST_WAIT.has(cmd.toLowerCase());
 }
@@ -829,8 +1099,19 @@ Slash commands:
   /endpoint <url>       Point this provider somewhere else, e.g.
                         /endpoint http://192.168.1.50:11434/v1
   /key                  Enter an API key for the current provider
+  /logout               Forget Koneck-stored API credentials; environment keys are untouched
   /status               Provider, model, mode, tokens, cost, CWD
+  /permissions [on|off] Show or set approval for writes and commands in this session
+  /worktree [on|off]    Set isolated Git-worktree default for future CLI-run tasks
+  /goal [text|clear]    Keep one outcome in view for this session, or remove it
   /doctor               Diagnose the active provider, workspace, and developer tools
+  /context              Show the model context window KONECK is planning around
+  /mcp                  Show MCP integrations and the tools live in this session
+  /init [--force]       Create KONECK.md; --force refreshes an existing briefing
+  /rename <old> <new>   Native TypeScript rename; saves a restore point first
+  /extract <file> <Class> Extract a class interface; saves a restore point first
+  /move <symbol> <from> <to> Move a TypeScript declaration; saves a restore point first
+  /checkpoint [name|list] Save a whole-workspace restore point, or list all restore points
   /clear /reset /new    Clear conversation history
   /cancel               Stop the current task; keeps the composer text
   /retry                Run the last non-secret task again
@@ -848,14 +1129,19 @@ Slash commands:
   /diff                 Show uncommitted git changes
   /changes              Summarize staged, unstaged, and untracked changes
   /quality              Run the detected lint and test checks
+  /preflight            Check patch integrity and detected quality gates before review/commit
+  /ship                 Run preflight, then a read-only full-workspace review when it passes
   /audit [count]        Show recent redacted tool activity
   /policy [init]        Show or create workspace safety rules
   /trust [always|forget] Show, persist, or revoke this workspace trust grant
+  /review [--fix]        Review all workspace changes; --fix applies verified fixes only
+  /code-review [--fix]   Alias for /review
+  /security-review       Read-only security audit of all workspace changes
   /verify               Run project test command
   /agents               How parallel sub-agents are configured
   /subtask <task>       Run a task in an isolated sub-agent
   /rewind               Undo last exchange (chat history only)
-  /revert [list|<id>]   Undo file edits KONECK made — restores from a checkpoint
+  /revert [list|<id>]   Restore an edit checkpoint; add --preview to inspect first
   /save                 Save session to disk
   /sessions             List recent saved sessions
   /exit /quit           Save and exit
@@ -872,6 +1158,30 @@ Keyboard:
  * Only on a real terminal. A pipe has no cursor to move and no rows to fill, and writing the
  * enter-alternate-screen sequence into a log file is how a captured session becomes unreadable.
  */
+/**
+ * Whether a chunk of terminal input is a mouse report rather than typing.
+ *
+ * Two encodings. SGR (`ESC [ < button ; col ; row M`) is what KONECK asks for, and the older X10
+ * form (`ESC [ M` followed by three raw bytes) is what a terminal may send anyway — a session that
+ * had tracking enabled by something else, or one that ignores the SGR request. Both are recognised
+ * with and without the leading escape, because the escape can arrive in a previous read.
+ *
+ * Deliberately generous: a false positive swallows one keystroke, and a false negative pastes
+ * "[<0;30;38M" into whatever you were writing.
+ */
+export function looksLikeMouseReport(input) {
+    if (!input)
+        return false;
+    const ESC = String.fromCharCode(27);
+    // SGR: the form KONECK enables. Matched anywhere, since a burst can carry several.
+    if (input.includes(ESC + '[<') || input.includes('[<')) {
+        return /(?:\u001b)?\[<\d+;\d+;\d+[Mm]/.test(input);
+    }
+    // X10: three bytes after ESC [ M, any of which can be unprintable.
+    if (input.includes(ESC + '[M') || input.startsWith('[M'))
+        return true;
+    return false;
+}
 export function defaultAltScreen(stdout = process.stdout, env = process.env) {
     if (!stdout.isTTY)
         return false;
@@ -886,6 +1196,9 @@ export function defaultAltScreen(stdout = process.stdout, env = process.env) {
 function App({ config: initialConfig, clearFrame }) {
     const { exit } = useApp();
     const [cfg, setCfg] = useState(initialConfig);
+    // Tool approval callbacks belong to a session created on an earlier render. Keep the control
+    // posture live so turning approval on during a turn governs its next consequential tool call.
+    const cfgRef = useRef(initialConfig);
     // Live activity accumulates in a ref and is painted by the 100 ms ticker. Mutating a ref
     // instead of calling setState per token keeps a Raspberry Pi from re-rendering on every chunk.
     const sayRef = useRef(''); // narration not yet committed
@@ -1090,8 +1403,10 @@ function App({ config: initialConfig, clearFrame }) {
      * reads dozens of times a minute, and a question per call would teach anyone to hit yes without
      * looking, which is worse than not asking at all.
      */
-    async function approveTool(tool, args) {
-        const verdict = decide(modeRef.current, tool, args, rulesRef.current);
+    async function approveTool(tool, args, policyRequiresApproval = false) {
+        if (readOnlyReviewRef.current)
+            return readOnlyReviewAllows(tool, args);
+        const verdict = inkApprovalDecision(cfgRef.current.requireApproval, modeRef.current, tool, args, rulesRef.current, policyRequiresApproval);
         if (verdict === 'allow')
             return true;
         if (verdict === 'deny')
@@ -1113,6 +1428,8 @@ function App({ config: initialConfig, clearFrame }) {
                 showNextAsk();
         });
     }
+    /** The endpoint's answer wins over a catalogue or name-based reference. */
+    const [detectedContext, setDetectedContext] = useState(null);
     const sessionOpts = {
         approve: approveTool,
         onPlan: (next) => {
@@ -1180,6 +1497,7 @@ function App({ config: initialConfig, clearFrame }) {
             lastActivityRef.current = Date.now();
         },
         onAgentProgress: (list) => { agentsRef.current = list; setAgents(list); },
+        onWindowDetected: (limit, source) => setDetectedContext({ limit, source }),
         onTokens: (s) => {
             realTokRef.current = Math.max(0, s.completionTokens - tokBaseRef.current);
         },
@@ -1196,11 +1514,23 @@ function App({ config: initialConfig, clearFrame }) {
     const historyDraftRef = useRef('');
     /** Last agent task eligible for one-command recovery; never populated from secret-looking input. */
     const retryTaskRef = useRef(null);
+    /** A command may start a detailed agent brief without putting implementation prose in user history. */
+    const generatedTaskRef = useRef(null);
+    /** Applies only while a generated review is in flight, never to the user's next task. */
+    const readOnlyReviewRef = useRef(false);
     /** Caret offset into `draft`. Kept beside it so every edit can place the caret deliberately. */
     const [caret, setCaret] = useState(0);
     const [busy, setBusy] = useState(false);
     const [agentState, setAgentState] = useState('ready');
     const [mode, setMode] = useState('auto');
+    const [goal, setGoal] = useState(null);
+    // A command can change the goal while a turn is finishing. The autosave callback from that
+    // earlier turn must save the latest intent, not the state snapshot it originally captured.
+    const goalRef = useRef(null);
+    function setSessionGoal(next) {
+        goalRef.current = next;
+        setGoal(next);
+    }
     /**
      * Permissions granted for this workspace, and the question currently on screen.
      *
@@ -1476,7 +1806,9 @@ function App({ config: initialConfig, clearFrame }) {
     const [picker, setPicker] = useState(null);
     const [pickIndex, setPickIndex] = useState(0);
     const [pickQuery, setPickQuery] = useState('');
-    const visiblePickerItems = React.useMemo(() => (picker ? filterPickerItems(picker.items, pickQuery) : []), [picker, pickQuery]);
+    const visiblePickerItems = React.useMemo(() => (picker ? (picker.kind === 'command'
+        ? commandPaletteMatches(picker.items, pickQuery)
+        : filterPickerItems(picker.items, pickQuery)) : []), [picker, pickQuery]);
     const [inboxTick, setInboxTick] = useState(0);
     // One object, not three separate states. Ink throttles its writes with leading and trailing
     // edges, so three setState calls in a tick let a single logical frame be written twice — which
@@ -1579,10 +1911,15 @@ function App({ config: initialConfig, clearFrame }) {
         for (const { from, payload } of queued) {
             addRow({ role: 'steps', steps: [{ kind: 'say',
                         text: `Handoff from ${from.repoName} (${from.cwd})\n\n${payload.summary}` +
+                            (payload.goal ? `\n\nMission: ${payload.goal}` : '') +
                             (payload.changedFiles.length ? `\n\nChanged: ${payload.changedFiles.join(', ')}` : '') }] });
         }
         const combined = queued.map(q => `[Handoff from the KONECK session in ${q.from.repoName} (${q.from.cwd})]\n` +
             `Context: ${q.payload.summary}\n` +
+            (q.payload.goal ? `Sender's mission: ${q.payload.goal}\n` : '') +
+            (q.payload.senderPosture
+                ? `Sender's posture (context only; keep this session's own controls): ${q.payload.senderPosture.mode} mode · ${q.payload.senderPosture.effort} effort · approval ${q.payload.senderPosture.requireApproval ? 'on' : 'off'}\n`
+                : '') +
             (q.payload.changedFiles.length ? `Files they changed: ${q.payload.changedFiles.join(', ')}\n` : '') +
             `Your task: ${q.payload.instruction}`).join('\n\n');
         submitDraft(combined);
@@ -1596,8 +1933,8 @@ function App({ config: initialConfig, clearFrame }) {
         busyStart.current = Date.now();
         wordTimer.current = 0;
         // The frame rate is the flicker rate. Every tick makes Ink update the live region, so network
-        // activity must be sampled for a human reader rather than mirrored frame-for-frame. A third
-        // of a second keeps streamed prose feeling live; an idle tool only needs a once-a-second
+        // activity must be sampled for a human reader rather than mirrored frame-for-frame. Half a
+        // second keeps streamed prose feeling live; an idle tool only needs a once-a-second
         // heartbeat. This is particularly important in terminals that repaint an ANSI line update as
         // a flash.
         let timer;
@@ -1622,9 +1959,9 @@ function App({ config: initialConfig, clearFrame }) {
         };
         const currentDelay = () => {
             const idleFor = Date.now() - lastActivityRef.current;
-            return idleFor < 2_000 ? 350 : 1_000;
+            return liveRefreshDelay(idleFor);
         };
-        timer = setTimeout(tick, 350);
+        timer = setTimeout(tick, liveRefreshDelay(0));
         return () => clearTimeout(timer);
     }, [busy]);
     // A queued prompt runs the moment the agent is free again. Keyed on `busy` rather than done
@@ -1697,11 +2034,22 @@ function App({ config: initialConfig, clearFrame }) {
         setDraft(recalled);
         setCaret(recalled.length);
     }
+    /**
+     * Starts a normal agent turn while preserving the short command the developer actually chose in
+     * the transcript and recall history. This keeps /review and /init inspectable instead of
+     * exposing their long internal instruction as a fake user message.
+     */
+    function submitGeneratedTask(task, label, readOnly = false) {
+        generatedTaskRef.current = { task, label, readOnly };
+        submitDraft(task);
+    }
     async function getSession() {
         return activeSession.p;
     }
     async function resetSession(newCfg) {
         const c = newCfg ?? cfg;
+        cfgRef.current = c;
+        setDetectedContext(null);
         activeSession.p = createAgentSession({ ...c, silent: true, ...sessionOpts });
         if (newCfg)
             setCfg(newCfg);
@@ -1763,6 +2111,10 @@ function App({ config: initialConfig, clearFrame }) {
             ...(existing?.name ? { name: existing.name } : {}),
             ...(existing?.archived ? { archived: existing.archived } : {}),
             ...(existing?.forkedFrom ? { forkedFrom: existing.forkedFrom } : {}),
+            ...(goalRef.current ? { goal: goalRef.current } : {}),
+            mode,
+            effort,
+            requireApproval: cfgRef.current.requireApproval,
             id, task, provider: cfg.provider, model: cfg.model,
             cwd: cfg.cwd, startedAt: startedAtRef.current,
             turns: live.turns, totalTokens: live.totalTokens,
@@ -1781,12 +2133,12 @@ function App({ config: initialConfig, clearFrame }) {
                 .filter(st => ['write_file', 'search_replace', 'apply_diff', 'move_file', 'delete_file'].includes(st.name))
                 .map(st => st.detail)
                 .filter(Boolean)))].slice(0, 12);
-        const transcript = rows
+        const transcript = handoffSummaryInput(rows
             .filter(r => r.role === 'user' || r.role === 'agent')
             .filter(r => !(r.role === 'user' && (r.text ?? '').startsWith('/')))
             .slice(-8)
             .map(r => `${r.role === 'user' ? 'User' : 'Agent'}: ${(r.text ?? '').slice(0, 400)}`)
-            .join('\n');
+            .join('\n'));
         let summary = transcript.trim()
             ? transcript.slice(0, 600)
             : 'The sending session has not done any work yet; this is a fresh instruction.';
@@ -1809,7 +2161,13 @@ function App({ config: initialConfig, clearFrame }) {
             }
             catch { /* the raw tail is a serviceable fallback */ }
         }
-        return { summary, changedFiles: changed, instruction };
+        return {
+            summary,
+            changedFiles: changed,
+            instruction,
+            ...(goalRef.current ? { goal: goalRef.current } : {}),
+            senderPosture: { mode: modeRef.current, effort, requireApproval: cfgRef.current.requireApproval },
+        };
     }
     /**
      * Replaces the live conversation with a saved one. The agent session is rebuilt from the
@@ -1819,6 +2177,25 @@ function App({ config: initialConfig, clearFrame }) {
     async function resumeSession(id) {
         try {
             const { meta, messages } = await loadSession(cfg.cwd, id);
+            // A resume is a continuation, not just a message import. If it silently swaps in today's
+            // model or loosens yesterday's careful mode, the copied transcript has a different meaning.
+            const provider = meta.provider || cfg.provider;
+            const restoredCfg = {
+                ...cfg,
+                provider,
+                model: meta.model || cfg.model,
+                baseURL: endpointFor(provider).url,
+                ...(typeof meta.requireApproval === 'boolean' ? { requireApproval: meta.requireApproval } : {}),
+            };
+            cfgRef.current = restoredCfg;
+            setCfg(restoredCfg);
+            if (meta.mode && MODES.includes(meta.mode)) {
+                modeRef.current = meta.mode;
+                setMode(meta.mode);
+            }
+            if (meta.effort && ['low', 'medium', 'high', 'max'].includes(meta.effort)) {
+                setEffort(meta.effort);
+            }
             // The plan comes back with the conversation. Without it the model reads its own history
             // and writes a new plan from scratch, which is the forgetting this was built to stop.
             const restoredPlan = meta.plan?.steps?.length
@@ -1829,9 +2206,10 @@ function App({ config: initialConfig, clearFrame }) {
                         ...(st.note ? { note: st.note } : {}),
                     })), updatedAt: Date.now() }
                 : undefined;
-            activeSession.p = createAgentSession({ ...cfg, silent: true, ...sessionOpts }, messages, { turns: meta.turns, totalTokens: meta.totalTokens }, restoredPlan);
+            activeSession.p = createAgentSession({ ...restoredCfg, silent: true, ...sessionOpts }, messages, { turns: meta.turns, totalTokens: meta.totalTokens }, restoredPlan);
             if (restoredPlan)
                 setPlan(restoredPlan);
+            setSessionGoal(meta.goal ?? null);
             setSessionId(id); // continue this session rather than forking a new one
             resumedIdRef.current = id;
             startedAtRef.current = meta.startedAt ?? startedAtRef.current;
@@ -1852,6 +2230,7 @@ function App({ config: initialConfig, clearFrame }) {
             addSystem(`Resumed ${id}\n` +
                 `  ${meta.turns} turns, ${meta.totalTokens.toLocaleString()} tokens\n` +
                 `  originally: ${meta.provider}/${meta.model}\n` +
+                `  posture: ${meta.mode ?? 'auto'} mode · ${meta.effort ?? 'medium'} effort · approval ${typeof meta.requireApproval === 'boolean' ? (meta.requireApproval ? 'on' : 'off') : 'current'}\n` +
                 `  task: ${meta.task.slice(0, 90)}\n\n` +
                 `The agent has the full history; carry on where it left off.`);
         }
@@ -1892,6 +2271,7 @@ function App({ config: initialConfig, clearFrame }) {
             case 'baseURL': return endpointFor(cfg.provider).url;
             case 'effort': return effort;
             case 'requireApproval': return cfg.requireApproval;
+            case 'useWorktree': return cfg.useWorktree;
             case 'maxTurns': return cfg.maxTurns;
             case 'agentConcurrency': return cfg.agentConcurrency;
             case 'maxWidth': return configMaxWidth;
@@ -1973,6 +2353,7 @@ function App({ config: initialConfig, clearFrame }) {
             }
             case 'maxTurns':
             case 'requireApproval':
+            case 'useWorktree':
             case 'agentConcurrency':
             case 'budget': {
                 // These shape the session itself, so it is rebuilt on the new values.
@@ -2016,8 +2397,9 @@ function App({ config: initialConfig, clearFrame }) {
             const { runAgent } = await import('./engine.js');
             const result = await runAgent(question, {
                 ...cfg, ci: true, silent: true,
-                // A side question answers from what it is told; it must not edit files behind the
-                // running task's back, so it is given no reason to and kept to a couple of turns.
+                // This is enforced at the engine approval boundary, not left as a prompt suggestion:
+                // a concurrent side question cannot edit, run a command, persist memory, or call MCP.
+                approve: async (tool) => asideAllowsTool(tool),
                 maxTurns: Math.min(cfg.maxTurns, 3),
             });
             const last = [...result.messages].reverse()
@@ -2259,7 +2641,9 @@ function App({ config: initialConfig, clearFrame }) {
                     `Endpoint   : ${endpoint}\n` +
                     `Model      : ${cfg.model}\n` +
                     `Mode       : ${modeSpec(mode).label} — ${modeSpec(mode).blurb}\n` +
+                    `Goal       : ${goalRef.current ?? 'none'}\n` +
                     `Approval   : ${cfg.requireApproval ? 'on' : 'off'}\n` +
+                    `Worktree   : ${cfg.useWorktree ? 'default on for next CLI task' : 'off'}\n` +
                     // Said here because a sandbox nobody can confirm is a sandbox nobody should rely on,
                     // and on a machine with no way to confine commands the honest line is the important one.
                     `Sandbox    : ${describeSandbox(resolveSandbox(cfg.sandbox, cfg.cwd, cfg.addDirs ?? []))}\n` +
@@ -2269,6 +2653,79 @@ function App({ config: initialConfig, clearFrame }) {
                     `Cost       : ${costStr}`);
                 return;
             }
+            case '/goal': {
+                const raw = arg.trim();
+                if (!raw) {
+                    addSystem(goalRef.current
+                        ? `**Session goal**\n\n${goalRef.current}\n\nRun \`/goal clear\` to remove it.`
+                        : 'No session goal is set. Use `/goal <outcome>` to keep a long-running objective in view.');
+                    return;
+                }
+                if (raw.toLowerCase() === 'clear') {
+                    setSessionGoal(null);
+                    addSystem('Session goal cleared.');
+                    return;
+                }
+                const next = normalizeSessionGoal(raw);
+                setSessionGoal(next);
+                addSystem(`Session goal set:\n\n> ${next}\n\n` +
+                    'KONECK will include this outcome with future tasks in this session. It is saved with the session.');
+                return;
+            }
+            case '/context': {
+                addSystem(contextStatusText(cfg.model, stats.promptTokens, cfg.contextTokens, detectedContext));
+                return;
+            }
+            case '/permissions': {
+                const choice = arg.trim().toLowerCase();
+                if (!choice) {
+                    addSystem(`**Approval posture**\n\n` +
+                        `Session approval: ${cfg.requireApproval ? 'on — KONECK asks before writes and non-read-only commands' : 'off — KONECK follows the selected mode and workspace policy'}\n` +
+                        `Mode: ${modeSpec(mode).label} — ${modeSpec(mode).blurb}\n\n` +
+                        '`/permissions on` keeps you in control of every consequential action.\n' +
+                        '`/permissions off` removes the extra session gate; workspace policy and plan mode still win.');
+                    return;
+                }
+                if (choice !== 'on' && choice !== 'off') {
+                    addSystem('Usage: `/permissions [on|off]`');
+                    return;
+                }
+                const next = choice === 'on';
+                const merged = { ...cfg, requireApproval: next };
+                cfgRef.current = merged;
+                setCfg(merged);
+                // A turn has a captured config. Rebuild only while idle; changing the promise mid-turn
+                // would detach its callbacks. The approval callback reads the live cfg for this turn,
+                // and the rebuilt session makes the new posture durable for every later turn.
+                if (!busy)
+                    await resetSession(merged);
+                addSystem(next
+                    ? 'Approval on. KONECK will ask in this interface before writes and consequential commands. Read-only inspection stays uninterrupted.'
+                    : 'Approval off. KONECK follows the selected mode and workspace policy; plan mode and policy blocks still cannot be bypassed.');
+                return;
+            }
+            case '/worktree': {
+                const option = arg.trim().toLowerCase();
+                if (option && option !== 'on' && option !== 'off') {
+                    addSystem('Usage: `/worktree [on|off]`');
+                    return;
+                }
+                if (!option) {
+                    addSystem(`Worktree isolation default: ${cfg.useWorktree ? 'on' : 'off'}\n` +
+                        'It applies when Koneck starts a new top-level CLI task. This active chat remains in its current workspace.');
+                    return;
+                }
+                const enabled = option === 'on';
+                const saved = { ...(await loadKoneckConfig()), useWorktree: enabled };
+                await saveKoneckConfig(saved);
+                setStored(saved);
+                const next = { ...cfg, useWorktree: enabled };
+                cfgRef.current = next;
+                setCfg(next);
+                addSystem(`Worktree isolation default ${enabled ? 'on' : 'off'}. ` +
+                    'It will apply to the next top-level CLI task; this active chat stays in its current workspace.');
+                return;
+            }
             case '/doctor': {
                 // A session can change provider, endpoint, or workspace after startup. Running the same
                 // checks here, against the *active* provider, means a diagnosis describes this session
@@ -2285,6 +2742,120 @@ function App({ config: initialConfig, clearFrame }) {
                 }
                 return;
             }
+            case '/mcp': {
+                const configured = await loadMCPConfig(cfg.cwd);
+                const session = await activeSession.p.catch(() => null);
+                addSystem(mcpStatusText(Object.keys(configured?.servers ?? {}), session?.mcpServers ?? []));
+                return;
+            }
+            case '/init': {
+                const option = arg.trim().toLowerCase();
+                if (option && option !== '--force') {
+                    addSystem('Usage: `/init` creates KONECK.md. Use `/init --force` to refresh an existing file.');
+                    return;
+                }
+                const force = option === '--force';
+                const briefing = path.join(cfg.cwd, 'KONECK.md');
+                const exists = await fsp.access(briefing).then(() => true).catch(() => false);
+                if (exists && !force) {
+                    addSystem('`KONECK.md` already exists. Its guidance is protected. Run `/init --force` to ask KONECK to refresh it.');
+                    return;
+                }
+                addSystem(exists
+                    ? 'Refreshing `KONECK.md` with the current workspace context…'
+                    : 'Creating a workspace briefing in `KONECK.md`…');
+                // Command palette selection temporarily owns `busy`; defer until it releases that small
+                // command frame, so the generated task starts as a regular tracked agent turn.
+                setTimeout(() => submitGeneratedTask(initWorkspaceTask(force), force ? '/init --force' : '/init'), 0);
+                return;
+            }
+            case '/logout': {
+                const stored = await loadGlobalConfig();
+                const hadStoredKey = Boolean(stored.apiKey);
+                await saveGlobalConfig(withoutStoredApiKey(stored));
+                // The runtime key may have come from `/key`, setup, or global config. Dropping it and
+                // rebuilding lets a deliberate environment credential take over without retaining a
+                // stale in-memory secret in the active session.
+                const cleared = { ...cfg, apiKey: undefined };
+                cfgRef.current = cleared;
+                setCfg(cleared);
+                await resetSession(cleared);
+                addSystem(hadStoredKey
+                    ? 'Koneck-stored API key cleared. Provider and model preferences were kept. Environment credentials were not changed.'
+                    : 'No Koneck-stored API key was present. Any environment credentials were left untouched; this session’s temporary key was cleared.');
+                return;
+            }
+            case '/checkpoint': {
+                const label = arg.trim();
+                if (isCheckpointListCommand(label)) {
+                    await handleCommand('/revert', 'list');
+                    return;
+                }
+                try {
+                    const checkpoint = await createWorkspaceCheckpoint(cfg.cwd, label || 'manual restore point');
+                    addSystem(checkpoint
+                        ? `Restore point saved: ${checkpoint.id}\n  ${checkpoint.label}\n\nReview with \`/diff\`, then use \`/revert ${checkpoint.id} --confirm\` to restore this workspace state.`
+                        : 'A whole-workspace restore point needs a git repository. File edits made by KONECK are still checkpointed automatically.');
+                }
+                catch (e) {
+                    addSystem(`Could not create restore point: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                return;
+            }
+            case '/rename':
+            case '/extract':
+            case '/move': {
+                const parts = parseCommandArguments(arg);
+                const expected = cmd === '/rename' ? 2 : cmd === '/extract' ? 2 : 3;
+                const usage = cmd === '/rename' ? '/rename <old> <new>'
+                    : cmd === '/extract' ? '/extract <file> <Class>'
+                        : '/move <symbol> <from> <to>';
+                if (!parts || parts.length !== expected) {
+                    addSystem(`Usage: \`${usage}\`\n\nUse quotes around a path containing spaces.`);
+                    return;
+                }
+                const policyReason = nativeRefactorPolicyReason(await loadPolicy(cfg.cwd));
+                if (policyReason) {
+                    addSystem(`Native refactor blocked: ${policyReason}.\n\nUse a normal coding task instead; KONECK will enforce the policy for each proposed write.`);
+                    return;
+                }
+                const approved = await approveTool('native_refactor', JSON.stringify({ command: `${cmd} ${arg}` }));
+                if (!approved) {
+                    addSystem(`Refused: ${cmd}. No files were changed.`);
+                    return;
+                }
+                const label = `before ${cmd} ${redactSecrets(arg).slice(0, 96)}`;
+                let checkpoint = null;
+                try {
+                    checkpoint = await createWorkspaceCheckpoint(cfg.cwd, label);
+                }
+                catch { /* Git is optional */ }
+                addSystem(`Running native TypeScript refactor: ${cmd}…`);
+                try {
+                    if (cmd === '/rename') {
+                        const result = await renameSymbol(parts[0], parts[1], cfg.cwd, { announce: false });
+                        addSystem(`Renamed \`${parts[0]}\` → \`${parts[1]}\` in ${result.filesChanged.length} file(s) (${result.occurrences} occurrence(s)).` +
+                            (checkpoint
+                                ? `\n\nRestore point: \`${checkpoint.id}\` — undo with \`/revert ${checkpoint.id} --confirm\`.`
+                                : '\n\nNo Git restore point was available. Run `/preflight` before committing.'));
+                    }
+                    else if (cmd === '/extract') {
+                        await extractInterface(parts[0], parts[1], cfg.cwd, { announce: false });
+                        addSystem(`Extracted interface for \`${parts[1]}\` from \`${parts[0]}\`.` +
+                            (checkpoint ? `\n\nRestore point: \`${checkpoint.id}\` — run \`/preflight\`, or \`/revert ${checkpoint.id} --confirm\` to undo.` : '\n\nRun `/preflight` before committing.'));
+                    }
+                    else {
+                        await moveSymbol(parts[0], parts[1], parts[2], cfg.cwd, { announce: false });
+                        addSystem(`Moved \`${parts[0]}\` from \`${parts[1]}\` to \`${parts[2]}\` and updated imports.` +
+                            (checkpoint ? `\n\nRestore point: \`${checkpoint.id}\` — run \`/preflight\`, or \`/revert ${checkpoint.id} --confirm\` to undo.` : '\n\nRun `/preflight` before committing.'));
+                    }
+                }
+                catch (e) {
+                    addSystem(`Native refactor failed: ${e instanceof Error ? e.message : String(e)}` +
+                        (checkpoint ? `\n\nNothing was automatically reverted. Your pre-refactor restore point is \`${checkpoint.id}\`.` : ''));
+                }
+                return;
+            }
             case '/clear':
             case '/reset':
             case '/new': {
@@ -2297,6 +2868,7 @@ function App({ config: initialConfig, clearFrame }) {
                 startedAtRef.current = new Date().toISOString();
                 setRows([{ role: 'header' }]);
                 setPlan(null);
+                setSessionGoal(null);
                 setStats({ turns: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 });
                 addSystem('Conversation cleared. The previous session is kept; /resume lists it.');
                 return;
@@ -2586,9 +3158,10 @@ function App({ config: initialConfig, clearFrame }) {
             }
             case '/diff': {
                 try {
-                    const [unstaged, staged] = await Promise.all([
+                    const [unstaged, staged, untracked] = await Promise.all([
                         execa('git', ['diff', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
                         execa('git', ['diff', '--cached', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
+                        untrackedPatches(cfg.cwd),
                     ]);
                     if (unstaged.exitCode !== 0 || staged.exitCode !== 0) {
                         addSystem('Not a git repository.');
@@ -2597,8 +3170,12 @@ function App({ config: initialConfig, clearFrame }) {
                     const sections = [
                         (staged.all ?? '').trim() ? `**Staged**\n\n${(staged.all ?? '').trim()}` : '',
                         (unstaged.all ?? '').trim() ? `**Unstaged**\n\n${(unstaged.all ?? '').trim()}` : '',
+                        untracked.patches.length ? `**Untracked**\n\n${untracked.patches.join('\n\n')}` : '',
                     ].filter(Boolean);
-                    addSystem(sections.length ? sections.join('\n\n') : 'No staged or unstaged changes. `/changes` also shows untracked files.');
+                    const omissions = untracked.omitted.length
+                        ? `\n\nUntracked files not rendered: ${untracked.omitted.join(', ')}`
+                        : '';
+                    addSystem(sections.length ? sections.join('\n\n') + omissions : 'No staged, unstaged, or renderable untracked changes. `/changes` shows the complete file list.' + omissions);
                 }
                 catch {
                     addSystem('Not a git repository.');
@@ -2636,6 +3213,47 @@ function App({ config: initialConfig, clearFrame }) {
                 }
                 return;
             }
+            case '/review':
+            case '/code-review':
+            case '/security-review': {
+                const security = cmd === '/security-review';
+                const option = arg.trim().toLowerCase();
+                if ((security && option) || (!security && option && option !== '--fix')) {
+                    addSystem(security ? 'Usage: `/security-review`' : 'Usage: `/review [--fix]`');
+                    return;
+                }
+                try {
+                    const [status, patch] = await Promise.all([
+                        execa('git', ['status', '--short'], { cwd: cfg.cwd, all: true, reject: false }),
+                        // HEAD deliberately includes both staged and unstaged edits. The old legacy command
+                        // used plain `git diff`, so its review silently omitted work about to be committed.
+                        execa('git', ['diff', 'HEAD', '--no-ext-diff'], { cwd: cfg.cwd, all: true, reject: false }),
+                    ]);
+                    if (status.exitCode !== 0 || patch.exitCode !== 0) {
+                        addSystem('Reviews need a git repository in this workspace.');
+                        return;
+                    }
+                    if (!(status.all ?? '').trim()) {
+                        addSystem('Working tree is clean — there is nothing to review.');
+                        return;
+                    }
+                    const fix = option === '--fix';
+                    addSystem(security
+                        ? '**Security review** — inspecting all current workspace changes…'
+                        : fix
+                            ? '**Review + verified fixes** — inspecting all current workspace changes…'
+                            : '**Code review** — inspecting all current workspace changes…');
+                    // As with /init, the palette's short command frame must finish before this becomes the
+                    // normal tracked agent turn. The agent reads the repository itself instead of receiving
+                    // an unbounded diff pasted into the prompt.
+                    const label = security ? '/security-review' : fix ? '/review --fix' : '/review';
+                    setTimeout(() => submitGeneratedTask(reviewTask(security ? 'security' : 'code', fix), label, !fix), 0);
+                }
+                catch {
+                    addSystem('Reviews need a git repository in this workspace.');
+                }
+                return;
+            }
             case '/quality': {
                 // The engine uses this exact gate after a coding turn. Exposing it in chat gives the user
                 // the same independent proof on demand, without the legacy TUI writing over Ink's frame.
@@ -2664,6 +3282,40 @@ function App({ config: initialConfig, clearFrame }) {
                 }
                 return;
             }
+            case '/preflight': {
+                addSystem('**Preflight** — checking patch integrity and detected quality gates…');
+                try {
+                    const result = await runPreflight(cfg.cwd);
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(preflightReport(result));
+                }
+                catch (e) {
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(`Preflight could not finish: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                return;
+            }
+            case '/ship': {
+                if (arg.trim()) {
+                    addSystem('Usage: `/ship` — runs preflight, then starts an enforced read-only review if the gate passes.');
+                    return;
+                }
+                addSystem('**Ship check** — running deterministic readiness checks…');
+                try {
+                    const result = await runPreflight(cfg.cwd);
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(preflightReport(result));
+                    if (!isPreflightReady(result))
+                        return;
+                    addSystem('**Ship review** — readiness passed. Inspecting the complete workspace in enforced read-only mode…');
+                    setTimeout(() => submitGeneratedTask(reviewTask('code'), '/ship', true), 0);
+                }
+                catch (e) {
+                    setRows(prev => prev.slice(0, -1));
+                    addSystem(`Ship check could not finish: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                return;
+            }
             case '/audit': {
                 const requested = Number.parseInt(arg, 10);
                 const limit = Number.isFinite(requested) ? Math.max(1, Math.min(requested, 100)) : 20;
@@ -2911,6 +3563,13 @@ function App({ config: initialConfig, clearFrame }) {
                         await resetSession(next);
                         addSystem(`Sub-agent concurrency is now ${resolveAgentConcurrency(next.agentConcurrency)}.`);
                     }
+                    if (key === 'useWorktree' && ['true', 'false', '1', '0', 'yes', 'no'].includes(val.toLowerCase())) {
+                        const enabled = ['true', '1', 'yes'].includes(val.toLowerCase());
+                        const next = { ...cfg, useWorktree: enabled };
+                        cfgRef.current = next;
+                        setCfg(next);
+                        addSystem(`Worktree isolation default ${enabled ? 'on' : 'off'} for future top-level CLI tasks; this active chat stays in its current workspace.`);
+                    }
                     return;
                 }
                 if (key) {
@@ -2923,6 +3582,7 @@ function App({ config: initialConfig, clearFrame }) {
                 const descs = configKeyDescriptions();
                 const live = {
                     provider: cfg.provider, model: cfg.model, effort, requireApproval: cfg.requireApproval,
+                    useWorktree: cfg.useWorktree,
                     maxTurns: cfg.maxTurns, budget: cfg.budget, baseURL: cfg.baseURL,
                     maxWidth: configMaxWidth ?? `(not set - filling ${termCols} columns)`,
                     agentConcurrency: resolveAgentConcurrency(cfg.agentConcurrency),
@@ -3107,25 +3767,50 @@ function App({ config: initialConfig, clearFrame }) {
                     addSystem('Checkpoints (newest first):\n' +
                         points.map(c => {
                             const when = new Date(c.timestamp).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-                            return `  ${c.id}  ${when}  ${c.files.length} file(s)  ${c.label.slice(0, 48)}`;
+                            return `  ${c.id}  ${when}  ${checkpointScope(c)}  ${c.label.slice(0, 48)}`;
                         }).join('\n') +
                         '\n\n/revert          undo the most recent edit' +
-                        '\n/revert <id>     undo a specific checkpoint');
+                        '\n/revert <id>     undo a specific checkpoint' +
+                        '\n/revert <id> --preview  inspect files that would change' +
+                        '\n/revert <id> --confirm  restore a named workspace snapshot');
                     return;
                 }
-                const target = arg ? points.find(c => c.id === arg) : points[0];
+                const revertArgs = arg.trim().split(/\s+/).filter(Boolean);
+                const confirmed = revertArgs.includes('--confirm');
+                const preview = revertArgs.includes('--preview');
+                const targetId = revertArgs.find(value => value !== '--confirm' && value !== '--preview');
+                const target = targetId ? points.find(c => c.id === targetId) : points[0];
                 if (!target) {
-                    addSystem(`No checkpoint "${arg}". Use /revert list to see them.`);
+                    addSystem(`No checkpoint "${targetId ?? arg}". Use /revert list to see them.`);
+                    return;
+                }
+                if (preview) {
+                    const effect = await previewCheckpoint(cfg.cwd, target);
+                    const lines = [`Preview ${checkpointScope(target)} ${target.id} — "${target.label.slice(0, 60)}"`];
+                    lines.push(effect.changes.length
+                        ? `  would change (${effect.changes.length}): ${checkpointPathSummary(effect.changes)}`
+                        : '  already matches this restore point; no user files would change');
+                    if (effect.skipped.length)
+                        lines.push(`  cannot restore (${effect.skipped.length}): ${checkpointPathSummary(effect.skipped)}`);
+                    lines.push(`\nApply with /revert ${target.id}${target.tree ? ' --confirm' : ''}`);
+                    addSystem(lines.join('\n'));
+                    return;
+                }
+                if (target.tree && !confirmed) {
+                    addSystem(workspaceRestoreConfirmation(target.id, target.label));
                     return;
                 }
                 const r = await revertCheckpoint(cfg.cwd, target);
-                const lines = [`Reverted checkpoint ${target.id} — "${target.label.slice(0, 60)}"`];
+                const lines = [`Restored ${checkpointScope(target)} ${target.id} — "${target.label.slice(0, 60)}"`];
+                if (target.tree && workspaceRestoreWasNoop(r)) {
+                    lines.push('  already matched the saved workspace state; no files changed');
+                }
                 if (r.restored.length)
-                    lines.push(`  restored: ${r.restored.join(', ')}`);
+                    lines.push(`  restored (${r.restored.length}): ${checkpointPathSummary(r.restored)}`);
                 if (r.deleted.length)
-                    lines.push(`  removed (did not exist before): ${r.deleted.join(', ')}`);
+                    lines.push(`  removed (${r.deleted.length}, did not exist before): ${checkpointPathSummary(r.deleted)}`);
                 if (r.skipped.length)
-                    lines.push(`  skipped (too large to snapshot): ${r.skipped.join(', ')}`);
+                    lines.push(`  skipped (${r.skipped.length}): ${checkpointPathSummary(r.skipped)}`);
                 if (r.undoId)
                     lines.push(`\nTo undo this revert: /revert ${r.undoId}`);
                 addSystem(lines.join('\n'));
@@ -3152,8 +3837,13 @@ function App({ config: initialConfig, clearFrame }) {
                 {
                     const suggestion = commandSuggestion(cmd);
                     addSystem(suggestion
-                        ? `Unknown command: ${cmd}. Did you mean \`${suggestion}\`?`
+                        ? `Unknown command: ${cmd}. Did you mean \`${suggestion}\`? It is ready in the composer; press Enter to run it.`
                         : `Unknown command: ${cmd}. Type /help for the full list.`);
+                    if (suggestion) {
+                        const recovered = recoveredCommandDraft(suggestion, arg);
+                        setDraft(recovered);
+                        setCaret(recovered.length);
+                    }
                 }
         }
     }
@@ -3188,6 +3878,19 @@ function App({ config: initialConfig, clearFrame }) {
         setCaret(c => c + token.length);
     }
     useInput((input, key) => {
+        // ── Mouse reports are not typing ────────────────────────────────────────
+        //
+        // Ink hands any escape sequence it does not recognise to the application as `input`, and a
+        // wheel notch or a click is such a sequence. Reported as clicking or scrolling pasting
+        // "[<0;30;38M[<64;37;39M…" into the composer — which is exactly what happened, because every
+        // branch below that appends `input` to the draft did so.
+        //
+        // The previous attempt at this only excused mouse reports from the rule that returns the view
+        // to the tail. That fixed the scroll and left the sequence being typed, and the test I wrote
+        // checked only that the scroll happened. Swallowed here instead: the wheel is read from stdin
+        // directly, so nothing below needs mouse data at all.
+        if (looksLikeMouseReport(input))
+            return;
         // ── Bracketed paste ─────────────────────────────────────────────────────
         // This runs before every other branch. A paste carries newlines, and any handler that treats
         // a newline as "submit" would fire partway through one.
@@ -3260,9 +3963,9 @@ function App({ config: initialConfig, clearFrame }) {
             // wheel notch arrived here as a keystroke and snapped the view straight back to the bottom:
             // the scroll worked and was undone in the same frame, which looked exactly like the wheel
             // doing nothing at all.
-            const isMouseReport = input.includes('\u001b[<') || input.includes('[<');
-            if (scrollBack > 0 && !isMouseReport
-                && (key.return || (input && !key.ctrl && !key.meta)))
+            // Mouse reports never reach here — they are swallowed at the top of this handler — so any
+            // input at this point really is somebody typing.
+            if (scrollBack > 0 && (key.return || (input && !key.ctrl && !key.meta)))
                 setScrollBack(0);
         }
         // Asked and waiting. Nothing else can be typed until it is answered, because whatever the
@@ -3334,12 +4037,12 @@ function App({ config: initialConfig, clearFrame }) {
                 return;
             }
             if (key.pageDown) {
-                const jump = pickerRowLimit(picker.kind, list.length, termRows);
+                const jump = pickerRowLimit(picker.kind, list.length, ...(altScreen ? [termRows, 13] : []));
                 setPickIndex(i => Math.min(i + jump, Math.max(0, list.length - 1)));
                 return;
             }
             if (key.pageUp) {
-                const jump = pickerRowLimit(picker.kind, list.length, termRows);
+                const jump = pickerRowLimit(picker.kind, list.length, ...(altScreen ? [termRows, 13] : []));
                 setPickIndex(i => Math.max(0, i - jump));
                 return;
             }
@@ -3652,7 +4355,7 @@ function App({ config: initialConfig, clearFrame }) {
         if (input === '/' && draft === '') {
             setDraft('/');
             setCaret(1);
-            openPicker('command', COMMANDS.map(c => ({ value: c.cmd, label: c.cmd, desc: c.desc })));
+            openPicker('command', commandPaletteItems());
             return;
         }
         // A held key arrives as one chunk that Ink does not recognise as a key at all: five
@@ -3721,10 +4424,16 @@ function App({ config: initialConfig, clearFrame }) {
             const task = expandPastes(shown, pastesRef.current).trim();
             if (!task)
                 return;
+            const generated = generatedTaskRef.current?.task === task ? generatedTaskRef.current : null;
+            if (generated)
+                generatedTaskRef.current = null;
+            // This flag is intentionally attached to one generated task rather than the session mode.
+            // A review must be unable to mutate; the next user-authored task must retain their posture.
+            const readOnlyReview = generated?.readOnly === true;
             // A recalled secret is just as dangerous as a saved one. Secret-looking input is sent only
             // when the user explicitly submits it, and never retained for Up-arrow recall.
             if (!containsSecret(task)) {
-                draftHistoryRef.current = appendDraftHistory(draftHistoryRef.current, shown);
+                draftHistoryRef.current = appendDraftHistory(draftHistoryRef.current, taskTranscriptLabel(shown, generated?.label));
             }
             historyIndexRef.current = null;
             historyDraftRef.current = '';
@@ -3742,7 +4451,7 @@ function App({ config: initialConfig, clearFrame }) {
                     'written into the session log.');
             }
             const mentions = findMentions(task, pathKind);
-            const forDisplay = pasteForDisplay(mentions.length ? shortenMentions(task, mentions) : task);
+            const forDisplay = taskTranscriptLabel(pasteForDisplay(mentions.length ? shortenMentions(task, mentions) : task), generated?.label);
             addRow({ role: 'user', text: forDisplay });
             if (isSlashCommand(task)) {
                 const spaceIdx = task.indexOf(' ');
@@ -3754,6 +4463,7 @@ function App({ config: initialConfig, clearFrame }) {
             }
             if (!containsSecret(task))
                 retryTaskRef.current = task;
+            readOnlyReviewRef.current = readOnlyReview;
             setBusy(true);
             setAgentState('processing');
             const started = Date.now();
@@ -3777,7 +4487,10 @@ function App({ config: initialConfig, clearFrame }) {
                 const outTokBefore = stats.completionTokens;
                 try {
                     const active = await getSession();
-                    const prefix = modeSpec(mode).prefix + (effort !== 'medium' ? `[Effort: ${effort}]\n` : '');
+                    const persistentGoal = goalRef.current;
+                    const prefix = (persistentGoal ? `[Persistent session goal: ${persistentGoal}]\n` : '') +
+                        modeSpec(mode).prefix +
+                        (effort !== 'medium' ? `[Effort: ${effort}]\n` : '');
                     const controller = new AbortController();
                     abortRef.current = controller;
                     await active.send(prefix + task, controller.signal);
@@ -3874,6 +4587,7 @@ function App({ config: initialConfig, clearFrame }) {
                 }
                 finally {
                     abortRef.current = null;
+                    readOnlyReviewRef.current = false;
                     setBusy(false);
                 }
             })();
@@ -4122,10 +4836,11 @@ function App({ config: initialConfig, clearFrame }) {
                     const window = modelCatalog.find(m => m.id === cfg.model)?.contextLength ?? contextWindowFor(cfg.model);
                     lines.push('**Context window**', '');
                     if (window) {
-                        // Prompt tokens on the last turn approximate what is resident: history plus system
-                        // prompt plus tool results, which is exactly what fills a window.
+                        // This is cumulative across the session, not a made-up claim about the next request.
+                        // It is still useful as a pressure signal: every long turn re-sends most of the
+                        // history, but only the provider can count the exact request after compaction.
                         const used = stats.promptTokens;
-                        lines.push(...meter(used / window, `${humanTokens(used)} of ${humanTokens(window)} · ${cfg.model}`));
+                        lines.push(...meter(Math.min(1, used / window), `${humanTokens(used)} session prompt total · ${humanTokens(window)} window · ${cfg.model}`));
                         if (used / window > 0.7) {
                             lines.push('Close to the window. `/clear` starts fresh,');
                             lines.push('`/rewind` drops just the last exchange.');
@@ -4141,7 +4856,7 @@ function App({ config: initialConfig, clearFrame }) {
                         lines.push('so there is nothing honest to draw a bar against.');
                     }
                     lines.push('');
-                    lines.push(`Last turn sent ${humanTokens(stats.promptTokens)} and received ${humanTokens(stats.completionTokens)}.`);
+                    lines.push(`Session total: ${humanTokens(stats.promptTokens)} prompt · ${humanTokens(stats.completionTokens)} completion.`);
                 }
                 if (usagePane === 'models') {
                     const statuses = readModelStatus();
@@ -4251,7 +4966,11 @@ function App({ config: initialConfig, clearFrame }) {
                 return (_jsx(Box, { marginTop: 1, justifyContent: "flex-end", children: _jsx(Panel, { width: Math.min(barWidth, 62), color: AMBER, title: "KONECK \u00B7 updates & guide", children: lines }) }));
             })(), picker && (() => {
                 const list = visiblePickerItems;
-                const pickerRows = pickerRowLimit(picker.kind, list.length, termRows);
+                // In the alternate screen, the picker shares a fixed frame with a bordered composer and
+                // footer. They consume six rows and the picker itself has six non-choice rows (margin,
+                // border, title/search and pager), so reserve thirteen in total. Letting 16 choices into
+                // a 24-row frame made Ink reflow the live region and visibly blink on every keypress.
+                const pickerRows = pickerRowLimit(picker.kind, list.length, ...(altScreen ? [termRows, 13] : []));
                 // Keep the highlighted row inside the visible window as the selection moves.
                 const start = Math.max(0, Math.min(pickIndex - Math.floor(pickerRows / 2), list.length - pickerRows));
                 const shown = list.slice(Math.max(0, start), Math.max(0, start) + pickerRows);