@element47/ag 4.4.5 → 4.5.2

package/dist/cli/repl.js

@@ -1,8 +1,9 @@
-import { createInterface } from 'node:readline';
+import { createInterface, emitKeypressEvents } from 'node:readline';
 import { loadConfig, saveConfig, configPath } from '../core/config.js';
 import { searchRegistry, installSkill, removeSkill, formatInstalls } from '../core/registry.js';
 import { C, renderMarkdown } from '../core/colors.js';
 import { VERSION } from '../core/version.js';
+import { inferPattern } from '../core/permissions.js';
 function truncateCommand(command, maxLen = 80) {
     const firstLine = command.split('\n')[0];
     if (firstLine.length <= maxLen) {
@@ -19,29 +20,90 @@ function formatToolSummary(toolName, args) {
         default: return `${toolName}(${JSON.stringify(args).slice(0, 80)})`;
     }
 }
+function promptQuestion(prompt, sharedRl) {
+    if (sharedRl) {
+        // Shared readline already manages terminal — no raw mode changes needed
+        return new Promise(resolve => sharedRl.question(prompt, resolve));
+    }
+    // Fallback: create a temporary readline; exit raw mode so it can work properly
+    const wasRaw = process.stdin.isTTY && process.stdin.isRaw;
+    if (wasRaw)
+        process.stdin.setRawMode(false);
+    return new Promise(resolve => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        rl.question(prompt, a => { rl.close(); resolve(a); });
+    }).finally(() => { if (wasRaw)
+        process.stdin.setRawMode(true); });
+}
+const SIMPLE_OPTS = `    ${C.cyan}y${C.reset}/${C.cyan}n${C.reset} > `;
+const FULL_OPTS = `    ${C.cyan}y${C.reset}/${C.cyan}n${C.reset}  ${C.dim}a${C.reset}=${C.dim}always  ${C.dim}p${C.reset}=${C.dim}project  ${C.dim}d${C.reset}=${C.dim}deny session  ${C.dim}D${C.reset}=${C.dim}deny project${C.reset} > `;
 export function createConfirmCallback(sharedRl) {
     const cb = async (toolName, args) => {
-        // Stop any active spinner before prompting
+        // Stop any active spinner before prompting — clear line to avoid garbled output
         if (cb.pauseSpinner) {
             cb.pauseSpinner();
             cb.pauseSpinner = null;
         }
+        process.stderr.write('\x1b[K'); // ensure current line is clear
         const summary = formatToolSummary(toolName, args);
-        if (sharedRl) {
-            return new Promise(resolve => {
-                sharedRl.question(`  ${C.yellow}?${C.reset} ${C.dim}${summary}${C.reset} ${C.yellow}(y/n)${C.reset} `, answer => {
-                    resolve(answer.trim().toLowerCase() === 'n' ? 'deny' : 'allow');
-                });
-            });
+        process.stderr.write(`  ${C.yellow}?${C.reset} ${C.dim}${summary}${C.reset}\n`);
+        const answer = await promptQuestion(SIMPLE_OPTS, sharedRl);
+        if (answer.trim().toLowerCase() === 'n') {
+            process.stderr.write(`  ${C.red}−${C.reset} ${C.dim}Denied${C.reset}\n`);
+            return 'deny';
+        }
+        return 'allow';
+    };
+    cb.pauseSpinner = null;
+    return cb;
+}
+export function createPermissionCallback(pm, sharedRl) {
+    const cb = async (toolName, args, permissionKey) => {
+        // Check permission rules first
+        const decision = pm.check(toolName, args, permissionKey);
+        if (decision === 'allow')
+            return 'allow';
+        if (decision === 'deny')
+            return 'deny';
+        // Stop any active spinner before prompting — clear line to avoid garbled output
+        if (cb.pauseSpinner) {
+            cb.pauseSpinner();
+            cb.pauseSpinner = null;
+        }
+        process.stderr.write('\x1b[K'); // ensure current line is clear
+        const summary = formatToolSummary(toolName, args);
+        const pattern = inferPattern(toolName, args, permissionKey);
+        process.stderr.write(`  ${C.yellow}?${C.reset} ${C.dim}${summary}${C.reset}\n`);
+        const answer = await promptQuestion(FULL_OPTS, sharedRl);
+        // Check for uppercase D before lowercasing
+        const raw = answer.trim();
+        if (raw === 'D') {
+            pm.addRule({ pattern, effect: 'deny' }, 'project');
+            pm.save('project');
+            process.stderr.write(`  ${C.red}−${C.reset} ${C.dim}Saved deny to .ag/permissions.json: ${pattern}${C.reset}\n`);
+            return 'deny';
+        }
+        const choice = raw.toLowerCase();
+        switch (choice) {
+            case 'a':
+                pm.addRule({ pattern, effect: 'allow' }, 'session');
+                process.stderr.write(`  ${C.green}+${C.reset} ${C.dim}Session rule: ${pattern}${C.reset}\n`);
+                return 'allow';
+            case 'p':
+                pm.addRule({ pattern, effect: 'allow' }, 'project');
+                pm.save('project');
+                process.stderr.write(`  ${C.green}+${C.reset} ${C.dim}Saved to .ag/permissions.json: ${pattern}${C.reset}\n`);
+                return 'allow';
+            case 'n':
+                process.stderr.write(`  ${C.red}−${C.reset} ${C.dim}Denied: ${pattern}${C.reset}\n`);
+                return 'deny';
+            case 'd':
+                pm.addRule({ pattern, effect: 'deny' }, 'session');
+                process.stderr.write(`  ${C.red}−${C.reset} ${C.dim}Session deny: ${pattern}${C.reset}\n`);
+                return 'deny';
+            default: // 'y' or anything else = allow once
+                return 'allow';
         }
-        // Fallback: create a temporary readline (non-REPL usage)
-        const rl = createInterface({ input: process.stdin, output: process.stderr });
-        return new Promise(resolve => {
-            rl.question(`  ${C.yellow}?${C.reset} ${C.dim}${summary}${C.reset} ${C.yellow}(y/n)${C.reset} `, answer => {
-                rl.close();
-                resolve(answer.trim().toLowerCase() === 'n' ? 'deny' : 'allow');
-            });
-        });
     };
     cb.pauseSpinner = null;
     return cb;
@@ -57,6 +119,86 @@ function startSpinner(label) {
     }, 80);
     return () => { clearInterval(id); process.stderr.write('\x1b[A\x1b[K'); };
 }
+// ── Context breakdown bar ────────────────────────────────────────────────────
+// ANSI 256-color codes for distinct, readable segment colors
+const SEGMENT_COLORS = [
+    '\x1b[38;5;75m', // blue
+    '\x1b[38;5;114m', // green
+    '\x1b[38;5;179m', // gold
+    '\x1b[38;5;204m', // pink
+    '\x1b[38;5;141m', // purple
+    '\x1b[38;5;80m', // teal
+    '\x1b[38;5;215m', // orange
+    '\x1b[38;5;109m', // steel
+    '\x1b[38;5;168m', // magenta
+    '\x1b[38;5;150m', // lime
+];
+function renderContextBreakdown(parts, contextLength, actualPromptTokens) {
+    const nc = 'NO_COLOR' in process.env || !process.stderr.isTTY;
+    const R = nc ? '' : '\x1b[0m';
+    const DIM = nc ? '' : '\x1b[2m';
+    const totalChars = parts.reduce((sum, p) => sum + p.chars, 0);
+    if (totalChars === 0)
+        return `${DIM}No context data yet.${R}`;
+    // Use actual tokens when available; fall back to char estimate
+    const hasActual = actualPromptTokens !== null && actualPromptTokens > 0;
+    const totalTokens = hasActual ? actualPromptTokens : Math.ceil(totalChars / 4);
+    const prefix = hasActual ? '' : '~';
+    const BAR_WIDTH = 50;
+    const lines = [];
+    // ── Compute segments: proportional share of chars → scaled to total tokens ──
+    const segments = [];
+    let assignedBlocks = 0;
+    for (let i = 0; i < parts.length; i++) {
+        const pct = (parts[i].chars / totalChars) * 100;
+        const tokens = Math.round((parts[i].chars / totalChars) * totalTokens);
+        const blocks = Math.max(pct >= 1 ? 1 : 0, Math.round((parts[i].chars / totalChars) * BAR_WIDTH));
+        const color = nc ? '' : SEGMENT_COLORS[i % SEGMENT_COLORS.length];
+        segments.push({ label: parts[i].label, tokens, pct, color, blockCount: blocks });
+        assignedBlocks += blocks;
+    }
+    // Adjust to fit BAR_WIDTH exactly
+    if (assignedBlocks > BAR_WIDTH && segments.length > 0) {
+        const largest = segments.reduce((a, b) => a.blockCount > b.blockCount ? a : b);
+        largest.blockCount -= (assignedBlocks - BAR_WIDTH);
+    }
+    else if (assignedBlocks < BAR_WIDTH && segments.length > 0) {
+        const largest = segments.reduce((a, b) => a.blockCount > b.blockCount ? a : b);
+        largest.blockCount += (BAR_WIDTH - assignedBlocks);
+    }
+    // ── Segmented bar ──
+    let bar = '';
+    for (const seg of segments) {
+        bar += `${seg.color}${'█'.repeat(Math.max(0, seg.blockCount))}${R}`;
+    }
+    if (contextLength) {
+        const usedPct = Math.round((totalTokens / contextLength) * 100);
+        const usedBlocks = segments.reduce((s, seg) => s + seg.blockCount, 0);
+        const freeBlocks = BAR_WIDTH - usedBlocks;
+        if (freeBlocks > 0)
+            bar += `${DIM}${'░'.repeat(freeBlocks)}${R}`;
+        lines.push(`  ${bar}  ${DIM}${prefix}${formatTokensShort(totalTokens)}/${formatTokensShort(contextLength)} (${usedPct}%)${R}`);
+    }
+    else {
+        lines.push(`  ${bar}  ${DIM}${prefix}${formatTokensShort(totalTokens)} tokens${R}`);
+    }
+    // ── Legend ──
+    lines.push('');
+    for (const seg of segments) {
+        const pctStr = seg.pct < 1 ? '<1' : Math.round(seg.pct).toString();
+        lines.push(`  ${seg.color}█${R} ${seg.label.padEnd(18)} ${DIM}${pctStr.padStart(3)}%  ${prefix}${formatTokensShort(seg.tokens)}${R}`);
+    }
+    return lines.join('\n');
+}
+function formatTokensShort(n) {
+    if (n < 1000)
+        return `${n}`;
+    if (n < 10000)
+        return `${(n / 1000).toFixed(1)}K`;
+    if (n < 1000000)
+        return `${Math.round(n / 1000)}K`;
+    return `${(n / 1000000).toFixed(1)}M`;
+}
 function maskKey(key) {
     if (key.length <= 8)
         return '****';
@@ -65,12 +207,21 @@ function maskKey(key) {
 export class REPL {
     agent;
     rl;
+    pm;
     confirmCb;
-    constructor(agent, confirmCb) {
+    constructor(agent, pm, confirmCb) {
         this.agent = agent;
+        this.pm = pm ?? null;
         this.rl = createInterface({ input: process.stdin, output: process.stderr });
         // Rebind the confirm callback to use the shared readline
-        if (confirmCb) {
+        if (confirmCb && pm) {
+            const shared = createPermissionCallback(pm, this.rl);
+            shared.pauseSpinner = confirmCb.pauseSpinner;
+            this.confirmCb = shared;
+            this.agent.setConfirmToolCall(shared);
+        }
+        else if (confirmCb) {
+            // Fallback: no permission manager, use basic confirm
             const shared = createConfirmCallback(this.rl);
             shared.pauseSpinner = confirmCb.pauseSpinner;
             this.confirmCb = shared;
@@ -83,16 +234,28 @@ export class REPL {
     async start() {
         const stats = this.agent.getStats();
         const skills = this.agent.getSkills();
+        console.error('');
         console.error(`${C.bold}ag v${VERSION}${C.reset} ${C.dim}(${this.agent.getModel()} via OpenRouter)${C.reset}`);
+        const customTools = this.agent.getTools().filter(t => !t.isBuiltin);
         const loaded = [
             stats.globalMemory && 'global',
             stats.projectMemory && 'project',
             stats.planCount > 0 && `${stats.planCount} plan(s)`,
             skills.length > 0 && `${skills.length} skill(s)`,
+            customTools.length > 0 && `${customTools.length} tool(s)`,
         ].filter(Boolean);
         if (loaded.length > 0) {
             console.error(`${C.dim}Loaded: ${loaded.join(', ')}${C.reset}`);
         }
+        for (const t of customTools) {
+            const desc = t.description.slice(0, 60) + (t.description.length > 60 ? '...' : '');
+            console.error(`  ${C.green}+${C.reset} ${C.cyan}${t.name}${C.reset}  ${C.dim}${desc}${C.reset}`);
+        }
+        for (const f of this.agent.getToolFailures()) {
+            const label = f.name ?? f.file;
+            const reason = f.reason.split('\n')[0].slice(0, 60) + (f.reason.length > 60 ? '...' : '');
+            console.error(`  ${C.red}−${C.reset} ${C.cyan}${label}${C.reset}  ${C.red}${reason}${C.reset}`);
+        }
         const activePlan = this.agent.getActivePlanName();
         if (activePlan) {
             const label = activePlan.replace(/^\d{4}-\d{2}-\d{2}T[\d-]+-?/, '').replace(/-/g, ' ').trim() || activePlan;
@@ -113,12 +276,15 @@ export class REPL {
             }
             catch { /* proceed without — fallback handled by tracker */ }
         }
-        tracker.estimateFromChars(this.agent.getSystemPromptSize());
+        tracker.estimateFromChars(this.agent.getTotalContextChars());
         const ctxLine = this.agent.getContextUsage();
         console.error(`${C.dim}Commands: /help${C.reset}`);
         if (ctxLine)
             console.error(ctxLine);
         console.error('');
+        // Enable keypress events on stdin for interrupt detection
+        if (process.stdin.isTTY)
+            emitKeypressEvents(process.stdin);
         while (true) {
             try {
                 const input = await this.ask(`${C.green}you>${C.reset} `);
@@ -129,111 +295,159 @@ export class REPL {
                     continue;
                 }
                 let hitMaxIterations = false;
-                const processStream = async (stream) => {
+                let interrupted = false;
+                const runAgent = async (message) => {
+                    const controller = new AbortController();
+                    let activeSpinnerStop = null;
+                    // ── Escape key listener: immediate visual feedback ──
+                    const onKeypress = (_ch, key) => {
+                        if (key?.name === 'escape') {
+                            // 1. Clear whatever spinner is showing
+                            if (activeSpinnerStop) {
+                                activeSpinnerStop();
+                                activeSpinnerStop = null;
+                            }
+                            // 2. Show "interrupting..." spinner immediately (sync)
+                            activeSpinnerStop = startSpinner(`${C.yellow}interrupting...${C.reset}`);
+                            // 3. Signal abort (async propagation begins)
+                            controller.abort();
+                        }
+                    };
+                    if (process.stdin.isTTY) {
+                        process.stdin.setRawMode(true);
+                        process.stdin.on('keypress', onKeypress);
+                        process.stdin.resume();
+                    }
                     let hasText = false;
                     let hadTools = false;
-                    let stopSpinnerFn = null;
                     let lineBuf = '';
-                    // Keep confirm callback's pauseSpinner in sync with current spinner
                     const setSpinner = (fn) => {
-                        stopSpinnerFn = fn;
+                        activeSpinnerStop = fn;
                         if (this.confirmCb)
                             this.confirmCb.pauseSpinner = fn;
                     };
                     const clearSpinner = () => {
-                        if (stopSpinnerFn) {
-                            stopSpinnerFn();
+                        if (activeSpinnerStop) {
+                            activeSpinnerStop();
                             setSpinner(null);
                         }
                     };
-                    // Render completed lines as markdown, write them out
                     const flushLines = (final) => {
                         const parts = lineBuf.split('\n');
-                        // Keep the last partial line in the buffer (unless final flush)
                         lineBuf = final ? '' : (parts.pop() || '');
                         for (let i = 0; i < parts.length; i++) {
-                            const rendered = renderMarkdown(parts[i]);
-                            process.stderr.write(rendered + '\n');
+                            process.stderr.write(renderMarkdown(parts[i]) + '\n');
                         }
                         if (final && lineBuf) {
                             process.stderr.write(renderMarkdown(lineBuf));
                             lineBuf = '';
                         }
                     };
-                    for await (const chunk of stream) {
-                        switch (chunk.type) {
-                            case 'thinking':
-                                clearSpinner();
-                                if (hasText) {
-                                    flushLines(true);
-                                    process.stderr.write('\n');
-                                    hasText = false;
-                                }
-                                setSpinner(startSpinner(chunk.content || 'thinking'));
-                                break;
-                            case 'text':
-                                clearSpinner();
-                                if (!hasText) {
-                                    if (hadTools)
+                    try {
+                        for await (const chunk of this.agent.chatStream(message, controller.signal)) {
+                            switch (chunk.type) {
+                                case 'thinking':
+                                    clearSpinner();
+                                    if (hasText) {
+                                        flushLines(true);
                                         process.stderr.write('\n');
-                                    process.stderr.write(`${C.bold}agent>${C.reset} `);
-                                    hasText = true;
-                                }
-                                lineBuf += (chunk.content || '');
-                                if (lineBuf.includes('\n'))
-                                    flushLines(false);
-                                break;
-                            case 'tool_start': {
-                                clearSpinner();
-                                if (hasText) {
-                                    flushLines(true);
-                                    process.stderr.write('\n');
-                                    hasText = false;
+                                        hasText = false;
+                                    }
+                                    setSpinner(startSpinner(chunk.content || 'thinking'));
+                                    break;
+                                case 'text':
+                                    clearSpinner();
+                                    if (!hasText) {
+                                        if (hadTools)
+                                            process.stderr.write('\n');
+                                        process.stderr.write(`${C.bold}agent>${C.reset} `);
+                                        hasText = true;
+                                    }
+                                    lineBuf += (chunk.content || '');
+                                    if (lineBuf.includes('\n'))
+                                        flushLines(false);
+                                    break;
+                                case 'tool_start': {
+                                    clearSpinner();
+                                    if (hasText) {
+                                        flushLines(true);
+                                        process.stderr.write('\n');
+                                        hasText = false;
+                                    }
+                                    const cmdPreview = truncateCommand(chunk.content || '', 60);
+                                    setSpinner(startSpinner(`[${chunk.toolName}] ${cmdPreview}`));
+                                    break;
                                 }
-                                const cmdPreview = truncateCommand(chunk.content || '', 60);
-                                setSpinner(startSpinner(`[${chunk.toolName}] ${cmdPreview}`));
-                                break;
-                            }
-                            case 'tool_end': {
-                                clearSpinner();
-                                hadTools = true;
-                                // Resolve label at tool_end time — skills may have been activated during this batch
-                                let endLabel = chunk.toolName || '';
-                                const activeSkills = this.agent.getActiveSkillNames();
-                                if (endLabel === 'bash' && activeSkills.length > 0) {
-                                    endLabel = `${endLabel} via ${activeSkills[activeSkills.length - 1]}`;
+                                case 'tool_end': {
+                                    clearSpinner();
+                                    hadTools = true;
+                                    let endLabel = chunk.toolName || '';
+                                    const activeSkills = this.agent.getActiveSkillNames();
+                                    if (endLabel === 'bash' && activeSkills.length > 0) {
+                                        endLabel = `${endLabel} via ${activeSkills[activeSkills.length - 1]}`;
+                                    }
+                                    const icon = chunk.success ? `${C.green}✓` : `${C.red}✗`;
+                                    const preview = (chunk.content || '').slice(0, 150).split('\n')[0];
+                                    process.stderr.write(`  ${icon} ${C.dim}[${endLabel}]${C.reset} ${C.dim}${preview}${(chunk.content || '').length > 150 ? '...' : ''}${C.reset}\n`);
+                                    break;
                                 }
-                                const icon = chunk.success ? `${C.green}✓` : `${C.red}✗`;
-                                const preview = (chunk.content || '').slice(0, 150).split('\n')[0];
-                                process.stderr.write(`  ${icon} ${C.dim}[${endLabel}]${C.reset} ${C.dim}${preview}${(chunk.content || '').length > 150 ? '...' : ''}${C.reset}\n`);
-                                break;
+                                case 'done':
+                                    clearSpinner();
+                                    if (hasText) {
+                                        flushLines(true);
+                                        process.stderr.write('\n\n');
+                                    }
+                                    else if (!hadTools)
+                                        process.stderr.write(`${C.bold}agent>${C.reset} ${renderMarkdown(chunk.content || '')}\n\n`);
+                                    break;
+                                case 'max_iterations':
+                                    clearSpinner();
+                                    hitMaxIterations = true;
+                                    break;
+                                case 'interrupted':
+                                    clearSpinner();
+                                    interrupted = true;
+                                    if (hasText) {
+                                        flushLines(true);
+                                        process.stderr.write('\n');
+                                    }
+                                    const summary = chunk.content || 'stopped';
+                                    process.stderr.write(`  ${C.yellow}⚡ Interrupted${C.reset} ${C.dim}(${summary})${C.reset}\n\n`);
+                                    break;
                             }
-                            case 'done':
-                                clearSpinner();
-                                if (hasText) {
-                                    flushLines(true);
-                                    process.stderr.write('\n\n');
-                                }
-                                else if (!hadTools)
-                                    process.stderr.write(`${C.bold}agent>${C.reset} ${renderMarkdown(chunk.content || '')}\n\n`);
-                                break;
-                            case 'max_iterations':
-                                clearSpinner();
-                                hitMaxIterations = true;
-                                break;
+                        }
+                        clearSpinner();
+                    }
+                    catch (e) {
+                        clearSpinner();
+                        // AbortError from fetch is handled inside chatStream; re-throw others
+                        if (!(e instanceof DOMException && e.name === 'AbortError'))
+                            throw e;
+                        if (!interrupted) {
+                            interrupted = true;
+                            process.stderr.write(`  ${C.yellow}⚡ Interrupted${C.reset}\n\n`);
+                        }
+                    }
+                    finally {
+                        if (process.stdin.isTTY) {
+                            process.stdin.removeListener('keypress', onKeypress);
+                            process.stdin.setRawMode(false);
                         }
                     }
-                    clearSpinner();
                 };
-                await processStream(this.agent.chatStream(input));
-                while (hitMaxIterations) {
+                await runAgent(input);
+                while (hitMaxIterations && !interrupted) {
                     console.error(`${C.yellow}Reached iteration limit.${C.reset}`);
                     const answer = await this.ask(`${C.yellow}Continue? (y/n)>${C.reset} `);
                     if (answer.trim().toLowerCase() !== 'y')
                         break;
                     hitMaxIterations = false;
-                    await processStream(this.agent.chatStream('continue where you left off'));
+                    await runAgent('continue where you left off');
                 }
+                // Re-estimate if API didn't return usage (ensures bar reflects current state)
+                const tracker = this.agent.getContextTracker();
+                if (!tracker.getUsedTokens())
+                    tracker.estimateFromChars(this.agent.getTotalContextChars());
                 const ctx = this.agent.getContextUsage();
                 if (ctx)
                     console.error(ctx);
@@ -261,7 +475,7 @@ export class REPL {
                 console.error(`  ${C.cyan}/plan${C.reset}                  Show current plan`);
                 console.error(`  ${C.cyan}/plan list${C.reset}             List all plans`);
                 console.error(`  ${C.cyan}/plan use <name>${C.reset}       Activate an older plan`);
-                console.error(`  ${C.cyan}/context${C.reset}               Show context window usage`);
+                console.error(`  ${C.cyan}/context${C.reset}               Show context breakdown + usage`);
                 console.error(`  ${C.cyan}/context compact${C.reset}       Force context compaction now`);
                 console.error(`  ${C.cyan}/config${C.reset}                Show config + file paths`);
                 console.error(`  ${C.cyan}/config set <k> <v>${C.reset}    Set a config value`);
@@ -271,6 +485,11 @@ export class REPL {
                 console.error(`  ${C.cyan}/skill search [query]${C.reset}  Search skills.sh`);
                 console.error(`  ${C.cyan}/skill add <source>${C.reset}    Install skill from registry`);
                 console.error(`  ${C.cyan}/skill remove <name>${C.reset}   Uninstall a skill`);
+                console.error(`  ${C.cyan}/permissions${C.reset}            Show permission rules`);
+                console.error(`  ${C.cyan}/permissions allow <p>${C.reset}  Add allow rule (session)`);
+                console.error(`  ${C.cyan}/permissions deny <p>${C.reset}   Add deny rule (session)`);
+                console.error(`  ${C.cyan}/permissions save${C.reset}       Save session rules to project`);
+                console.error(`  ${C.cyan}/permissions clear${C.reset}      Clear session rules`);
                 console.error(`  ${C.cyan}/exit${C.reset}                  Exit`);
                 console.error('');
                 break;
@@ -318,7 +537,7 @@ export class REPL {
                         }
                         catch { /* proceed without */ }
                     }
-                    tracker.estimateFromChars(this.agent.getSystemPromptSize());
+                    tracker.estimateFromChars(this.agent.getTotalContextChars());
                     const ctxLine = this.agent.getContextUsage();
                     console.error(`${C.yellow}Model set to: ${this.agent.getModel()} (saved)${C.reset}`);
                     if (ctxLine)
@@ -427,6 +646,11 @@ export class REPL {
                 else {
                     console.error(`${C.bold}Context Window${C.reset}`);
                     console.error(this.agent.getContextDetails());
+                    console.error('');
+                    console.error(`${C.bold}Breakdown${C.reset}`);
+                    const breakdown = this.agent.getContextBreakdown();
+                    const tracker = this.agent.getContextTracker();
+                    console.error(renderContextBreakdown(breakdown, tracker.getContextLength(), tracker.getUsedTokens()));
                 }
                 console.error('');
                 break;
@@ -462,12 +686,16 @@ export class REPL {
                         // Apply immediately: toggle confirmation prompts in this session
                         if (parsed) {
                             this.agent.setConfirmToolCall(null);
+                            this.confirmCb = null;
                             console.error(`${C.green}Auto-approve enabled — tool calls will no longer prompt.${C.reset}`);
                         }
                         else {
-                            const freshCb = createConfirmCallback(this.rl);
+                            const freshCb = this.pm
+                                ? createPermissionCallback(this.pm, this.rl)
+                                : createConfirmCallback(this.rl);
                             if (this.confirmCb)
                                 freshCb.pauseSpinner = this.confirmCb.pauseSpinner;
+                            this.confirmCb = freshCb;
                             this.agent.setConfirmToolCall(freshCb);
                             console.error(`${C.yellow}Auto-approve disabled — tool calls will prompt again.${C.reset}`);
                         }
@@ -491,9 +719,12 @@ export class REPL {
                         this.agent.setModel('anthropic/claude-sonnet-4.6');
                     }
                     if (key === 'autoApprove') {
-                        const freshCb = createConfirmCallback(this.rl);
+                        const freshCb = this.pm
+                            ? createPermissionCallback(this.pm, this.rl)
+                            : createConfirmCallback(this.rl);
                         if (this.confirmCb)
                             freshCb.pauseSpinner = this.confirmCb.pauseSpinner;
+                        this.confirmCb = freshCb;
                         this.agent.setConfirmToolCall(freshCb);
                     }
                     console.error(`${C.yellow}Config: ${key} removed${C.reset}\n`);
@@ -533,7 +764,8 @@ export class REPL {
                 const tools = this.agent.getTools();
                 console.error(`${C.bold}Tools (${tools.length}):${C.reset}`);
                 for (const t of tools) {
-                    console.error(`  ${C.cyan}${t.name}${C.reset}  ${C.dim}${t.description.slice(0, 60)}${t.description.length > 60 ? '...' : ''}${C.reset}`);
+                    const prefix = t.isBuiltin ? ' ' : `${C.green}+${C.reset}`;
+                    console.error(`  ${prefix} ${C.cyan}${t.name}${C.reset}  ${C.dim}${t.description.slice(0, 60)}${t.description.length > 60 ? '...' : ''}${C.reset}`);
                 }
                 console.error('');
                 break;
@@ -606,6 +838,69 @@ export class REPL {
                 }
                 break;
             }
+            // ── /permissions ────────────────────────────────────────────────────
+            case 'permissions':
+            case 'perms': {
+                if (!this.pm) {
+                    console.error(`${C.dim}Permissions not available (auto-approve mode).${C.reset}\n`);
+                    break;
+                }
+                const subCmd = args[0]?.toLowerCase();
+                if (subCmd === 'allow' && args[1]) {
+                    const pattern = args.slice(1).join(' ');
+                    this.pm.addRule({ pattern, effect: 'allow' }, 'session');
+                    console.error(`${C.green}+ Session allow: ${pattern}${C.reset}\n`);
+                }
+                else if (subCmd === 'deny' && args[1]) {
+                    const pattern = args.slice(1).join(' ');
+                    this.pm.addRule({ pattern, effect: 'deny' }, 'session');
+                    console.error(`${C.green}+ Session deny: ${pattern}${C.reset}\n`);
+                }
+                else if (subCmd === 'save') {
+                    const scope = args[1]?.toLowerCase() === 'global' ? 'global' : 'project';
+                    this.pm.save(scope);
+                    console.error(`${C.yellow}Saved to ${scope} permissions.${C.reset}\n`);
+                }
+                else if (subCmd === 'clear') {
+                    const scope = args[1]?.toLowerCase();
+                    if (scope === 'project' || scope === 'global') {
+                        this.pm.clear(scope);
+                        this.pm.save(scope);
+                        console.error(`${C.yellow}Cleared ${scope} permissions.${C.reset}\n`);
+                    }
+                    else {
+                        this.pm.clear('session');
+                        console.error(`${C.yellow}Cleared session permissions.${C.reset}\n`);
+                    }
+                }
+                else if (subCmd === 'remove' && args[1]) {
+                    const pattern = args.slice(1).join(' ');
+                    const removed = this.pm.removeRule(pattern, 'session')
+                        || this.pm.removeRule(pattern, 'project')
+                        || this.pm.removeRule(pattern, 'global');
+                    if (removed) {
+                        console.error(`${C.yellow}Removed: ${pattern}${C.reset}\n`);
+                    }
+                    else {
+                        console.error(`${C.dim}No matching rule found.${C.reset}\n`);
+                    }
+                }
+                else {
+                    // List all rules
+                    const rules = this.pm.getRules();
+                    if (rules.length === 0) {
+                        console.error(`${C.dim}No permission rules. Approve with (a)lways or (p)roject to add rules.${C.reset}\n`);
+                        break;
+                    }
+                    console.error(`${C.bold}Permission Rules:${C.reset}`);
+                    for (const r of rules) {
+                        const icon = r.effect === 'allow' ? `${C.green}✓` : `${C.red}✗`;
+                        console.error(`  ${icon} ${C.dim}[${r.scope}]${C.reset} ${r.effect} ${C.cyan}${r.pattern}${C.reset}`);
+                    }
+                    console.error('');
+                }
+                break;
+            }
             // ── /exit ─────────────────────────────────────────────────────────
             case 'exit':
             case 'quit':