@axplusb/kepler 1.0.10 → 2.0.2

package/src/context/symbol-indexer.mjs

@@ -0,0 +1,375 @@
+/**
+ * Symbol Indexer — AST-based code search using tree-sitter.
+ *
+ * Parses source files into symbols (functions, classes, methods) with
+ * signatures and line numbers. Indexes symbols in BM25 for search.
+ *
+ * Memory efficient: stores symbol signatures (~50 chars) not file chunks
+ * (~2000 chars). One tree-sitter parse per file, O(n) on file size.
+ *
+ * Usage:
+ *   const indexer = new SymbolIndexer();
+ *   await indexer.init();  // load WASM grammars once
+ *   indexer.indexFile('/path/to/file.py', content);
+ *   const results = indexer.search('find_ordering_name');
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { BM25Index } from './bm25.mjs';
+
+const GRAMMAR_DIR = new URL('./grammars/', import.meta.url).pathname;
+
+const LANG_MAP = {
+    '.py': 'python',
+    '.js': 'javascript',
+    '.mjs': 'javascript',
+    '.jsx': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+};
+
+/**
+ * @typedef {Object} Symbol
+ * @property {string} name
+ * @property {string} kind - 'function' | 'class' | 'method'
+ * @property {string} file - relative path
+ * @property {number} line
+ * @property {number} endLine
+ * @property {string} signature - e.g., "def find_ordering_name(self, name, opts)"
+ * @property {string} [parent] - parent class name if method
+ * @property {string} [docstring] - first line of docstring
+ */
+
+export class SymbolIndexer {
+    constructor() {
+        this._Parser = null;
+        this._languages = {};     // ext → Language
+        this._symbols = [];       // all extracted symbols
+        this._symbolMap = new Map(); // id → Symbol
+        this._bm25 = new BM25Index();
+        this._initialized = false;
+    }
+
+    /**
+     * Load tree-sitter WASM runtime + grammars. Call once per session.
+     * Lazy — only loads grammars for languages actually encountered.
+     */
+    async init() {
+        if (this._initialized) return;
+        try {
+            const TreeSitter = (await import('web-tree-sitter')).default;
+            await TreeSitter.init();
+            this._Parser = new TreeSitter();
+            this._TreeSitter = TreeSitter;
+            this._initialized = true;
+        } catch (e) {
+            // Fallback: tree-sitter not available, use regex parser
+            this._initialized = false;
+        }
+    }
+
+    async _getLanguage(ext) {
+        if (this._languages[ext]) return this._languages[ext];
+        const langName = LANG_MAP[ext];
+        if (!langName || !this._TreeSitter) return null;
+
+        // Try bundled WASM from tree-sitter-wasms package
+        const wasmPaths = [
+            path.join(GRAMMAR_DIR, `tree-sitter-${langName}.wasm`),
+        ];
+
+        // Also check node_modules
+        try {
+            const modPath = new URL(`../../node_modules/tree-sitter-wasms/out/tree-sitter-${langName}.wasm`, import.meta.url).pathname;
+            wasmPaths.push(modPath);
+        } catch { /* ignore */ }
+
+        for (const p of wasmPaths) {
+            try {
+                if (fs.existsSync(p)) {
+                    const lang = await this._TreeSitter.Language.load(p);
+                    this._languages[ext] = lang;
+                    return lang;
+                }
+            } catch { /* try next */ }
+        }
+        return null;
+    }
+
+    /**
+     * Index a single file. Extracts symbols and adds to BM25.
+     * @param {string} relPath - relative path (used as ID)
+     * @param {string} content - file content
+     */
+    async indexFile(relPath, content) {
+        const ext = path.extname(relPath).toLowerCase();
+        let symbols;
+
+        const lang = await this._getLanguage(ext);
+        if (lang && this._Parser) {
+            this._Parser.setLanguage(lang);
+            const tree = this._Parser.parse(content);
+            symbols = this._extractSymbols(tree.rootNode, relPath, ext);
+            tree.delete();
+        } else {
+            symbols = this._regexExtract(relPath, content, ext);
+        }
+
+        for (const sym of symbols) {
+            const id = `${sym.file}:${sym.line}:${sym.name}`;
+            this._symbols.push(sym);
+            this._symbolMap.set(id, sym);
+
+            // BM25 document: name + signature + parent + docstring
+            const text = [
+                sym.name,
+                sym.signature || '',
+                sym.parent ? `${sym.parent}.${sym.name}` : '',
+                sym.docstring || '',
+                sym.file,
+            ].join(' ');
+            this._bm25.addDocument(id, text);
+        }
+    }
+
+    /**
+     * Search for symbols matching a query.
+     * @param {string} query
+     * @param {number} [topK=10]
+     * @returns {Array<{symbol: Symbol, score: number}>}
+     */
+    search(query, topK = 10) {
+        const results = this._bm25.search(query, topK);
+        return results.map(r => ({
+            symbol: this._symbolMap.get(r.id),
+            score: r.score,
+            id: r.id,
+        })).filter(r => r.symbol);
+    }
+
+    /**
+     * Format search results for the agent.
+     */
+    formatResults(results) {
+        if (!results.length) return '';
+        return results.map(r => {
+            const s = r.symbol;
+            const parent = s.parent ? `${s.parent}.` : '';
+            const doc = s.docstring ? `  "${s.docstring}"` : '';
+            return `${s.file}:${s.line}  ${parent}${s.signature || s.name}${doc}`;
+        }).join('\n');
+    }
+
+    get symbolCount() { return this._symbols.length; }
+
+    // ── Tree-sitter extraction ──
+
+    _extractSymbols(node, file, ext) {
+        const symbols = [];
+        const langName = LANG_MAP[ext];
+
+        if (langName === 'python') {
+            this._walkPython(node, file, symbols, null);
+        } else if (langName === 'javascript' || langName === 'typescript') {
+            this._walkJS(node, file, symbols, null);
+        }
+        return symbols;
+    }
+
+    _walkPython(node, file, symbols, parentClass) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            const type = child.type;
+
+            if (type === 'class_definition') {
+                const nameNode = child.childForFieldName('name');
+                const name = nameNode?.text || '';
+                const bases = child.childForFieldName('superclasses')?.text || '';
+                symbols.push({
+                    name, kind: 'class', file,
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                    signature: `class ${name}${bases ? `(${bases})` : ''}`,
+                    docstring: this._pyDocstring(child),
+                });
+                // Recurse into class body for methods
+                const body = child.childForFieldName('body');
+                if (body) this._walkPython(body, file, symbols, name);
+            }
+
+            else if (type === 'function_definition') {
+                const nameNode = child.childForFieldName('name');
+                const name = nameNode?.text || '';
+                const params = child.childForFieldName('parameters')?.text || '()';
+                const returnType = child.childForFieldName('return_type')?.text || '';
+                const sig = `def ${name}${params}${returnType ? ' -> ' + returnType : ''}`;
+                symbols.push({
+                    name,
+                    kind: parentClass ? 'method' : 'function',
+                    file,
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                    signature: sig,
+                    parent: parentClass || undefined,
+                    docstring: this._pyDocstring(child),
+                });
+            }
+
+            else if (type === 'decorated_definition') {
+                // Unwrap decorator to get the actual definition
+                for (let j = 0; j < child.childCount; j++) {
+                    const inner = child.child(j);
+                    if (inner.type === 'function_definition' || inner.type === 'class_definition') {
+                        this._walkPython(child, file, symbols, parentClass);
+                        break;
+                    }
+                }
+            }
+
+            else {
+                // Recurse for module-level statements
+                if (!parentClass && child.childCount > 0) {
+                    this._walkPython(child, file, symbols, parentClass);
+                }
+            }
+        }
+    }
+
+    _pyDocstring(defNode) {
+        const body = defNode.childForFieldName('body');
+        if (!body || body.childCount === 0) return '';
+        const first = body.child(0);
+        if (first?.type === 'expression_statement') {
+            const expr = first.child(0);
+            if (expr?.type === 'string' || expr?.type === 'concatenated_string') {
+                const raw = expr.text;
+                // Extract first line of docstring
+                const content = raw.replace(/^['"`]{1,3}/, '').replace(/['"`]{1,3}$/, '');
+                const firstLine = content.split('\n')[0].trim();
+                return firstLine.slice(0, 120);
+            }
+        }
+        return '';
+    }
+
+    _walkJS(node, file, symbols, parentClass) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            const type = child.type;
+
+            if (type === 'class_declaration' || type === 'class') {
+                const nameNode = child.childForFieldName('name');
+                const name = nameNode?.text || '';
+                symbols.push({
+                    name, kind: 'class', file,
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                    signature: `class ${name}`,
+                });
+                const body = child.childForFieldName('body');
+                if (body) this._walkJS(body, file, symbols, name);
+            }
+
+            else if (type === 'function_declaration' || type === 'method_definition') {
+                const nameNode = child.childForFieldName('name');
+                const name = nameNode?.text || '';
+                const params = child.childForFieldName('parameters')?.text || '()';
+                symbols.push({
+                    name,
+                    kind: parentClass ? 'method' : 'function',
+                    file,
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                    signature: `${parentClass ? '' : 'function '}${name}${params}`,
+                    parent: parentClass || undefined,
+                });
+            }
+
+            else if (type === 'export_statement' || type === 'lexical_declaration') {
+                this._walkJS(child, file, symbols, parentClass);
+            }
+
+            else if (child.childCount > 0 && !parentClass) {
+                this._walkJS(child, file, symbols, parentClass);
+            }
+        }
+    }
+
+    // ── Regex fallback (no tree-sitter) ──
+
+    _regexExtract(file, content, ext) {
+        const symbols = [];
+        const lines = content.split('\n');
+        let currentClass = null;
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            const lineNum = i + 1;
+            const indent = line.length - line.trimStart().length;
+
+            // Python
+            if (ext === '.py') {
+                const classMatch = trimmed.match(/^class\s+(\w+)(?:\(([^)]*)\))?/);
+                if (classMatch) {
+                    currentClass = classMatch[1];
+                    symbols.push({
+                        name: currentClass, kind: 'class', file, line: lineNum,
+                        signature: `class ${currentClass}${classMatch[2] ? `(${classMatch[2]})` : ''}`,
+                    });
+                    continue;
+                }
+                const fnMatch = trimmed.match(/^(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
+                if (fnMatch) {
+                    const isMethod = indent >= 4 && currentClass;
+                    symbols.push({
+                        name: fnMatch[1],
+                        kind: isMethod ? 'method' : 'function',
+                        file, line: lineNum,
+                        signature: `def ${fnMatch[1]}(${fnMatch[2]})`,
+                        parent: isMethod ? currentClass : undefined,
+                    });
+                    continue;
+                }
+                if (indent === 0 && !trimmed.startsWith('#') && trimmed) {
+                    currentClass = null;
+                }
+            }
+
+            // JS/TS
+            if (['.js', '.mjs', '.ts', '.tsx', '.jsx'].includes(ext)) {
+                const fnMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+                if (fnMatch) {
+                    symbols.push({ name: fnMatch[1], kind: 'function', file, line: lineNum, signature: `function ${fnMatch[1]}(${fnMatch[2]})` });
+                }
+                const classMatch = trimmed.match(/^(?:export\s+)?class\s+(\w+)/);
+                if (classMatch) {
+                    symbols.push({ name: classMatch[1], kind: 'class', file, line: lineNum, signature: `class ${classMatch[1]}` });
+                }
+            }
+        }
+        return symbols;
+    }
+
+    // ── Serialization ──
+
+    toJSON() {
+        return {
+            symbols: this._symbols,
+            bm25: this._bm25.toJSON(),
+        };
+    }
+
+    static fromJSON(data) {
+        const indexer = new SymbolIndexer();
+        indexer._initialized = true; // don't need tree-sitter for search
+        indexer._symbols = data.symbols || [];
+        indexer._bm25 = BM25Index.fromJSON(data.bm25);
+        for (const sym of indexer._symbols) {
+            const id = `${sym.file}:${sym.line}:${sym.name}`;
+            indexer._symbolMap.set(id, sym);
+        }
+        return indexer;
+    }
+}

package/src/core/approval.mjs

@@ -11,45 +11,42 @@
  */
 
 import { toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
+import {
+  classify as classifyTier,
+  TIERS,
+  requiresExplicitApproval,
+  requiresCheckpoint,
+  label as tierLabel,
+} from './risk-tier.mjs';
+import {
+  renderApprovalPrompt,
+  renderInlinePrompt,
+  defaultOptions as approvalOptions,
+} from '../ui/approval.mjs';
 
 // ── Tool Classification ──
+//
+// Risk tiering moved to src/core/risk-tier.mjs (PRD-055 §8.1). WRITE_TOOLS
+// stays here only because `planMode` blocks anything that writes.
 
 const WRITE_TOOLS = new Set([
     'shell', 'write_file', 'write_project', 'edit_file', 'delete_file',
     'validate_build', 'lint_check',
 ]);
 
-const NEVER_AUTO_APPROVE = new Set(['delete_file']);
-
-const FORCE_APPROVAL_SHELL = [
-    /\brm\s/,
-    /\bunlink\s/,
-    /\brmdir\s/,
-    /\bgit\s+clean/,
-    /\bgit\s+reset/,
-    /\bgit\s+push.*--force/,
-];
-
-const RISK_LEVELS = {
-    read_file: 'none', read_files: 'none', search_code: 'none',
-    search_files: 'none', list_files: 'none', get_file_info: 'none',
-    validate_file: 'none', validate_structure: 'none',
-    write_file: 'low', write_project: 'low', edit_file: 'low',
-    lint_check: 'low', validate_build: 'medium',
-    shell: 'medium',
-    delete_file: 'high',
-};
-
-function assessShellRisk(command) {
-    if (!command) return 'medium';
-    if (/rm\s+-r/i.test(command)) return 'high';
-    if (/git\s+(push|reset|clean|checkout\s+\.)/i.test(command)) return 'high';
-    if (/drop\s+(table|database)/i.test(command)) return 'high';
-    if (/sudo\s/i.test(command)) return 'high';
-    if (/^(ls|cat|head|tail|less|more|wc|file|stat|tree|find|grep|rg|ag|echo|printf|pwd|whoami|date|which|type|env|printenv|uname|hostname|id|df|du|uptime|free|top|ps|lsof)/i.test(command)) return 'low';
-    if (/^git\s+(status|log|diff|show|branch|tag|remote|stash\s+list|blame|shortlog|describe|rev-parse|ls-files|ls-tree)/i.test(command)) return 'low';
-    if (/^(npm\s+(test|run|list|ls|view|info|outdated|audit)|node\s+--check|python3?\s+-m\s+py_compile|cargo\s+(check|test|clippy))/i.test(command)) return 'low';
-    return 'medium';
+function defaultWhy(tier, tool, args) {
+    switch (tier) {
+        case TIERS.SHELL_DANGEROUS:
+            return `Shell command matches a high-risk pattern (rm -rf, sudo, force push, etc.). Confirm before running.`;
+        case TIERS.DESTRUCTIVE:
+            return `${tool} permanently mutates project state. Confirm before running.`;
+        case TIERS.SHELL_MEDIUM:
+            return `Mutates the workspace or environment (install, build, commit, push).`;
+        case TIERS.NETWORK:
+            return `Reaches an external network endpoint.`;
+        default:
+            return '';
+    }
 }
 
 // ── ANSI helpers ──
@@ -107,93 +104,146 @@ export class ApprovalManager {
         // Auto-approve everything in headless/autoApprove mode (no TTY prompts)
         if (this.autoApprove) {
             this.history.push({ tool: toolName, decision: 'auto', time: Date.now() });
-            return { approved: true };
+            return { approved: true, tier: classifyTier(toolName, args) };
         }
-        if (!WRITE_TOOLS.has(toolName) && !requireApproval) {
-            return { approved: true };
+
+        const tier = classifyTier(toolName, args);
+
+        // 'auto' tiers: read, shell-safe.
+        if (tier === TIERS.READ || tier === TIERS.SHELL_SAFE) {
+            this.history.push({ tool: toolName, decision: 'auto-tier', tier, time: Date.now() });
+            return { approved: true, tier };
+        }
+
+        // 'auto-with-undo' tier: local-edit. Checkpoint is taken by the tool
+        // executor before the edit; here we just approve.
+        if (tier === TIERS.LOCAL_EDIT) {
+            this.history.push({ tool: toolName, decision: 'auto-with-undo', tier, time: Date.now() });
+            return { approved: true, tier, requireCheckpoint: true };
         }
-        if (toolName === 'shell') {
-            const risk = assessShellRisk(args.command);
-            if (risk === 'low') {
-                this.history.push({ tool: toolName, decision: 'auto-safe', time: Date.now() });
-                return { approved: true };
+
+        // Honor approve-all / type-allow shortcuts for non-explicit tiers only.
+        if (!requiresExplicitApproval(tier)) {
+            if (this.approveAll) {
+                this.history.push({ tool: toolName, decision: 'auto-all', tier, time: Date.now() });
+                return { approved: true, tier };
             }
-            if (FORCE_APPROVAL_SHELL.some(p => p.test(args.command || ''))) {
-                return this._prompt(toolName, args, context);
+            if (this.approvedToolTypes.has(toolName)) {
+                this.history.push({ tool: toolName, decision: 'type-auto', tier, time: Date.now() });
+                return { approved: true, tier };
             }
         }
-        if (NEVER_AUTO_APPROVE.has(toolName)) {
-            return this._prompt(toolName, args, context);
-        }
-        if (this.approveAll) {
-            this.history.push({ tool: toolName, decision: 'auto', time: Date.now() });
-            return { approved: true };
-        }
-        if (this.approvedToolTypes.has(toolName)) {
-            this.history.push({ tool: toolName, decision: 'type-auto', time: Date.now() });
-            return { approved: true };
-        }
-        return this._prompt(toolName, args, context);
+
+        return this._prompt(toolName, args, { ...context, tier });
     }
 
     async _prompt(toolName, args, context = {}) {
-        const baseRisk = RISK_LEVELS[toolName] || 'medium';
-        const assessedRisk = toolName === 'shell' ? assessShellRisk(args.command) : baseRisk;
-        const risk = context.risk || assessedRisk;
-        const label = toolDisplayLabel(toolName);
+        const tier = context.tier || classifyTier(toolName, args);
+        const explicit = requiresExplicitApproval(tier);
+        const why = context.reason || context.why || defaultWhy(tier, toolName, args);
         const summary = toolDisplaySummary(toolName, args);
-        const isDestructive = risk === 'high';
-
-        write(`\n  ${isDestructive ? `${YELLOW}⚠${RST}` : `${CYAN}?${RST}`}  ${BOLD}Approval required${RST}\n`);
-        write(`  ${GRAY}Action${RST}  ${WHITE}${label}${RST}\n`);
-        if (summary) write(`  ${GRAY}Target${RST}  ${WHITE}${summary.slice(0, 160)}${RST}\n`);
-        write(`  ${GRAY}Risk${RST}    ${isDestructive ? YELLOW : CYAN}${risk}${RST}\n`);
-        if (context.reason) write(`  ${GRAY}Reason${RST}  ${DIM}${String(context.reason).slice(0, 160)}${RST}\n`);
-
-        if (isDestructive) {
-            write(`  ${DIM}Choose${RST}  ${WHITE}[y]${RST} allow once  ${WHITE}[n]${RST} deny  ${WHITE}[d]${RST} details\n`);
-        } else {
-            write(`  ${DIM}Choose${RST}  ${WHITE}[y]${RST} once  ${WHITE}[n]${RST} deny  ${WHITE}[t]${RST} this action  ${WHITE}[a]${RST} all  ${WHITE}[d]${RST} details\n`);
+        const options = approvalOptions(tier);
+
+        let selected = 0; // arrow-driven cursor
+        let printedHeight = 0;
+
+        // For TTYs we redraw in place on every arrow key so the prompt feels
+        // live. For non-TTYs / pipes we just print once and read a line.
+        const isInteractive = process.stdin.isTTY;
+        if (!isInteractive) {
+            write(explicit
+                ? renderApprovalPrompt({ tool: toolName, args, tier, why, selected, options }) + '\n'
+                : renderInlinePrompt({ tool: toolName, args, tier, why }) + '\n');
         }
 
-        const key = await this._readKey();
+        const drawExplicit = () => {
+            // Move up over the previous render before re-printing.
+            if (printedHeight > 0) {
+                write(`\x1b[${printedHeight}F`); // cursor to start of N lines above
+                write('\x1b[J');                   // clear from cursor to end of screen
+            }
+            const block = renderApprovalPrompt({ tool: toolName, args, tier, why, selected, options });
+            write(block + '\n');
+            printedHeight = block.split('\n').length;
+        };
 
-        switch (key) {
-            case 'y':
-            case 'Y':
-            case 'return':
+        if (isInteractive && explicit) drawExplicit();
+        if (isInteractive && !explicit) write(renderInlinePrompt({ tool: toolName, args, tier, why }) + '\n');
+
+        // ── Input loop ─────────────────────────────────────────────────
+        const choose = async () => {
+            for (;;) {
+                const k = await this._readKey();
+
+                if (k === 'up' || k === 'left') {
+                    if (!explicit || !isInteractive) continue;
+                    selected = (selected - 1 + options.length) % options.length;
+                    drawExplicit();
+                    continue;
+                }
+                if (k === 'down' || k === 'right' || k === 'tab') {
+                    if (!explicit || !isInteractive) continue;
+                    selected = (selected + 1) % options.length;
+                    drawExplicit();
+                    continue;
+                }
+                if (k === 'return') {
+                    return options[selected].value;
+                }
+                if (k === 'escape') return 'reject';
+
+                // Letter shortcut: match against option.key
+                if (typeof k === 'string' && k.length === 1) {
+                    const lower = k.toLowerCase();
+                    const idx = options.findIndex(o => o.key === lower);
+                    if (idx >= 0) {
+                        selected = idx;
+                        if (isInteractive && explicit) drawExplicit();
+                        return options[idx].value;
+                    }
+                }
+                // Anything else: ignore and re-read.
+            }
+        };
+
+        const value = await choose();
+
+        switch (value) {
+            case 'approve':
                 write(`  ${GREEN}✓${RST}  ${DIM}${toolName}${RST} ${DIM}${summary.slice(0, 60)}${RST}\n\n`);
-                this.history.push({ tool: toolName, decision: 'yes', time: Date.now() });
-                return { approved: true };
+                this.history.push({ tool: toolName, decision: 'yes', tier, time: Date.now() });
+                return { approved: true, tier };
 
-            case 'n':
-            case 'N':
-            case 'escape':
+            case 'reject':
                 write(`  ${RED}✗${RST}  ${DIM}denied${RST}\n\n`);
-                this.history.push({ tool: toolName, decision: 'no', time: Date.now() });
-                return { approved: false, reason: 'User denied' };
+                this.history.push({ tool: toolName, decision: 'no', tier, time: Date.now() });
+                return { approved: false, tier, reason: 'User denied' };
 
-            case 'a':
-            case 'A':
-                if (isDestructive) return this._prompt(toolName, args, context);
+            case 'allow-all':
+                if (explicit) return this._prompt(toolName, args, context);
                 this.approveAll = true;
                 write(`  ${GREEN}✓✓${RST} ${DIM}allow-all activated${RST}\n\n`);
-                this.history.push({ tool: toolName, decision: 'approve-all', time: Date.now() });
-                return { approved: true };
+                this.history.push({ tool: toolName, decision: 'approve-all', tier, time: Date.now() });
+                return { approved: true, tier };
 
-            case 't':
-            case 'T':
-                if (isDestructive) return this._prompt(toolName, args, context);
+            case 'allow-type':
+                if (explicit) return this._prompt(toolName, args, context);
                 this.approvedToolTypes.add(toolName);
                 write(`  ${GREEN}✓${RST}  ${DIM}always allow ${toolName}${RST}\n\n`);
-                this.history.push({ tool: toolName, decision: 'type-approve', time: Date.now() });
-                return { approved: true };
+                this.history.push({ tool: toolName, decision: 'type-approve', tier, time: Date.now() });
+                return { approved: true, tier };
 
-            case 'd':
-            case 'D':
-                write(`\n${DIM}${JSON.stringify(args, null, 2)}${RST}\n\n`);
+            case 'why':
+                write(`\n  ${DIM}${(context.reason || why).slice(0, 400)}${RST}\n\n`);
+                printedHeight = 0;
                 return this._prompt(toolName, args, context);
 
+            case 'edit':
+            case 'replan':
+                write(`  ${YELLOW}↩${RST}  ${DIM}reject with hint — rework the plan${RST}\n\n`);
+                this.history.push({ tool: toolName, decision: 'replan', tier, time: Date.now() });
+                return { approved: false, tier, reason: 'User asked to re-plan' };
+
             default:
                 return this._prompt(toolName, args, context);
         }
@@ -221,7 +271,16 @@ export class ApprovalManager {
                 const str = data.toString();
 
                 if (bytes[0] === 0x03) process.exit(0);
-                if (bytes[0] === 0x1b) { resolve('escape'); return; }
+                // Arrow keys: ESC [ A/B/C/D (3-byte CSI sequences)
+                if (bytes.length === 3 && bytes[0] === 0x1b && bytes[1] === 0x5b) {
+                    if (bytes[2] === 0x41) { resolve('up');    return; }
+                    if (bytes[2] === 0x42) { resolve('down');  return; }
+                    if (bytes[2] === 0x43) { resolve('right'); return; }
+                    if (bytes[2] === 0x44) { resolve('left');  return; }
+                }
+                // Bare Esc (single byte) — explicit reject signal
+                if (bytes.length === 1 && bytes[0] === 0x1b) { resolve('escape'); return; }
+                if (bytes[0] === 0x09) { resolve('tab'); return; }
                 if (str === '\r' || str === '\n') { resolve('return'); return; }
                 resolve(str);
             });