ikie-cli 0.1.41 → 0.1.43

package/dist/agent.d.ts

@@ -20,7 +20,7 @@ export interface AgentTurnStats {
     toolCalls: number;
     filesChanged: number;
 }
-export declare function estimateTokens(chars: number): number;
+export { estimateTokens } from './utils.js';
 /**
  * Extract the most useful upstream error message from an OpenAI SDK error.
  * The SDK wraps provider responses; we prefer the nested error.message if it exists.
@@ -79,6 +79,8 @@ export declare class Agent {
     private mode;
     private planSteps;
     private planStepIndex;
+    private thinkingStartTime;
+    private lastThinkingDuration;
     constructor(client: OpenAI, config: IkieConfig, systemPrompt: string);
     write(text: string): void;
     clearConversation(): void;
@@ -119,4 +121,6 @@ export declare class Agent {
     private checkPermission;
 }
 export declare const PLAN_MODE_ADDENDUM = "\n\n## PLAN MODE (read-only)\nYou are currently in **plan mode**. You have ONLY read-only tools (read_file,\nlist_dir, search_files, grep, fetch_url, web_search, use_skill, ask_user). You CANNOT write files, edit\nfiles, run shell commands, or change anything \u2014 those tools are unavailable and any\nattempt will be blocked.\n\nYour job is to investigate and produce a clear, actionable plan:\n- Explore the relevant files and understand the current state before proposing anything.\n- Do NOT describe changes as if you already made them. You haven't.\n- End your response with a concise plan: a short **## Plan** heading followed by\n  numbered steps. Name the specific files to change and what to change in each. Call\n  out risks, assumptions, or open questions.\n- Keep it tight \u2014 enough to execute from, not an essay.\n\nAfter you present the plan, the user will be asked whether to execute it. On approval,\nyou'll be switched to agent mode and asked to carry out exactly this plan.";
+export declare function isLightweightModel(model: string): boolean;
+export declare function buildLightweightSystemPrompt(prompt: string): string;
 export declare function buildSystemPrompt(projectContext: string, memoryContext: string, skillsCatalog?: string): string;

package/dist/agent.js

@@ -2,16 +2,16 @@ import chalk from 'chalk';
 import * as readline from 'node:readline';
 import { TOOL_DEFS, SAFE_TOOLS, PLAN_TOOLS, formatToolArgs, executeTool, isRestrictedPath, getMcpToolDefs } from './tools.js';
 import { IKIE_PORT } from './config.js';
+import { estimateTokens } from './utils.js';
 import { renderMarkdown, extractThinkTags } from './renderer.js';
 import { getSkill, renderSkill, mapAllowedTools } from './skills.js';
-import { c, toolLine, toolSuccessLine, toolErrorLine, toolOutputBlock, toolDiffBlock, InlineSpinner, CH, toolMeta } from './theme.js';
+import { c, toolLine, toolSuccessLine, toolErrorLine, toolOutputBlock, toolDiffBlock, InlineSpinner, CH, toolMeta, thinkingTime, actionLine, planStep, planTitle } from './theme.js';
 /** Default per-turn step budget — guards against runaway tool loops. */
 export const DEFAULT_MAX_STEPS = 60;
 /** Result synthesized for a tool call that never produced one (cancel/crash). */
 export const INTERRUPTED_TOOL_RESULT = 'Interrupted: this tool did not run to completion (the turn was cancelled).';
-export function estimateTokens(chars) {
-    return Math.max(1, Math.round(chars / 4));
-}
+// Re-export so existing callers that import from agent.ts still work.
+export { estimateTokens } from './utils.js';
 /**
  * Extract the most useful upstream error message from an OpenAI SDK error.
  * The SDK wraps provider responses; we prefer the nested error.message if it exists.
@@ -251,6 +251,8 @@ export class Agent {
     mode = 'agent';
     planSteps = [];
     planStepIndex = 0;
+    thinkingStartTime = 0;
+    lastThinkingDuration = 0;
     constructor(client, config, systemPrompt) {
         this.client = client;
         this.config = config;
@@ -337,9 +339,9 @@ export class Agent {
         this.planSteps = steps;
         this.planStepIndex = 0;
         if (steps.length > 0) {
-            this.write(`\n  ${c.primary.bold('Plan')} ${c.muted(`(${steps.length} steps)`)}\n`);
+            this.write(`\n${this.indent}${planTitle(steps.length)}\n\n`);
             for (let i = 0; i < steps.length; i++) {
-                this.write(`  ${c.muted('☐')} ${c.dim(steps[i])}\n`);
+                this.write(`${this.indent}${planStep(steps[i], false)}\n`);
             }
             this.write('\n');
         }
@@ -347,7 +349,7 @@ export class Agent {
     advancePlanStep() {
         if (this.planStepIndex < this.planSteps.length) {
             const step = this.planSteps[this.planStepIndex];
-            this.write(`  ${c.success('☑')} ${c.white(step)}\n`);
+            this.write(`${this.indent}${planStep(step, true)}\n`);
             this.planStepIndex++;
         }
     }
@@ -476,7 +478,15 @@ export class Agent {
                 if (remaining.length === 1) {
                     if (this.activeTurnStats)
                         this.activeTurnStats.toolCalls++;
-                    this.write(`\n${this.indent}${toolLine(remaining[0].name, formatToolArgs(remaining[0].name, inputs[0])).trimStart()}\n`);
+                    // Use clean action line for file edits
+                    if (remaining[0].name === 'edit_file' || remaining[0].name === 'write_file') {
+                        const filePath = String(inputs[0].path || '');
+                        const action = remaining[0].name === 'edit_file' ? 'Edit' : 'Write';
+                        this.write(`\n${this.indent}${actionLine(action, filePath)}\n`);
+                    }
+                    else {
+                        this.write(`\n${this.indent}${toolLine(remaining[0].name, formatToolArgs(remaining[0].name, inputs[0])).trimStart()}\n`);
+                    }
                     const result = await this.handleToolCall(remaining[0].name, remaining[0].id, inputs[0], opts);
                     pushResult(remaining[0].id, result);
                 }
@@ -499,9 +509,19 @@ export class Agent {
                     const groupSpinner = new InlineSpinner(`${toolPhaseLabel(remaining[0].name)} (${remaining.length} operations)`, t0, opts.signal);
                     groupSpinner.start();
                     const results = new Map();
+                    // Fail-fast flag for mutating tool batches: if a write/edit fails
+                    // with a critical error, skip subsequent tools in this batch to
+                    // prevent writing broken/incomplete code from a half-applied change.
+                    const isMutatingBatch = remaining[0].name === 'edit_file' || remaining[0].name === 'write_file';
+                    let batchAborted = false;
                     for (let i = 0; i < remaining.length; i++) {
                         if (opts.signal?.aborted)
                             break;
+                        // Fail-fast: skip remaining mutating ops after a critical failure.
+                        if (batchAborted) {
+                            results.set(i, 'Skipped: a previous tool in this batch failed — batch aborted to prevent inconsistent state.');
+                            continue;
+                        }
                         const tc = remaining[i];
                         try {
                             if (tc.name === 'read_file' && isRestrictedPath(String(inputs[i].path ?? ''))) {
@@ -514,13 +534,19 @@ export class Agent {
                             const result = tc.name === 'use_skill'
                                 ? await this.handleToolCall(tc.name, tc.id, inputs[i], opts)
                                 : await executeTool(tc.name, inputs[i], opts.signal);
-                            if (result.startsWith('Error'))
+                            if (result.startsWith('Error')) {
                                 errors++;
+                                // Trigger fail-fast only for mutating batches on critical errors.
+                                if (isMutatingBatch)
+                                    batchAborted = true;
+                            }
                             this.recordChangedFile(tc.name, inputs[i], result);
                             results.set(i, result);
                         }
                         catch (err) {
                             errors++;
+                            if (isMutatingBatch)
+                                batchAborted = true;
                             results.set(i, `Tool error: ${err}`);
                         }
                     }
@@ -597,9 +623,20 @@ export class Agent {
         if (this.activeTurnStats)
             this.activeTurnStats.modelCalls++;
         await this.throttleModelRequest();
+        // Start thinking timer
+        this.thinkingStartTime = Date.now();
         const state = { emitted: false };
         try {
-            return await this.callModelStreaming(opts, state);
+            const result = await this.callModelStreaming(opts, state);
+            // Record thinking duration
+            this.lastThinkingDuration = (Date.now() - this.thinkingStartTime) / 1000;
+            // Display thinking time if it was significant (>0.5s)
+            if (this.lastThinkingDuration > 0.5) {
+                this.write(`
+${this.indent}${thinkingTime(this.lastThinkingDuration)}
+`);
+            }
+            return result;
         }
         catch (err) {
             if (opts.signal?.aborted)
@@ -609,7 +646,14 @@ export class Agent {
             // and double-bill — surface the error instead.
             if (state.emitted)
                 throw err;
-            return await this.callModelNonStreaming(opts);
+            const result = await this.callModelNonStreaming(opts);
+            this.lastThinkingDuration = (Date.now() - this.thinkingStartTime) / 1000;
+            if (this.lastThinkingDuration > 0.5) {
+                this.write(`
+${this.indent}${thinkingTime(this.lastThinkingDuration)}
+`);
+            }
+            return result;
         }
     }
     buildParams() {
@@ -622,7 +666,11 @@ export class Agent {
         // Always include switch_mode so the agent can request a mode change.
         const switchModeTool = TOOL_DEFS.find(t => t.function.name === 'switch_mode');
         // Plan mode: only offer read-only tools, and steer toward proposing a plan.
-        let systemContent = this.systemPrompt;
+        // For lightweight/local models, use a condensed system prompt to preserve
+        // context window budget; full prompt is used for large capable models.
+        let systemContent = isLightweightModel(this.config.model)
+            ? buildLightweightSystemPrompt(this.systemPrompt)
+            : this.systemPrompt;
         if (this.mode === 'plan') {
             tools = tools.filter(t => PLAN_TOOLS.has(t.function.name) || t.function.name === 'switch_mode');
             if (switchModeTool && !tools.includes(switchModeTool))
@@ -1090,6 +1138,52 @@ Your job is to investigate and produce a clear, actionable plan:
 
 After you present the plan, the user will be asked whether to execute it. On approval,
 you'll be switched to agent mode and asked to carry out exactly this plan.`;
+export function isLightweightModel(model) {
+    const m = model.toLowerCase();
+    return (m.includes('haiku') ||
+        m.includes('flash') ||
+        m.includes('mini') ||
+        m.includes('llama') ||
+        m.includes('gemma') ||
+        m.includes('phi') ||
+        m.includes('qwen') ||
+        m.includes('local'));
+}
+export function buildLightweightSystemPrompt(prompt) {
+    const lines = prompt.split('\n');
+    const result = [];
+    let skipping = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Check if we should start/stop skipping a verbose section
+        if (line.startsWith('## Response Formatting') ||
+            line.startsWith('## Modern Design') ||
+            line.startsWith('## Tool-Use Discipline') ||
+            line.startsWith('## Tools Available') ||
+            line.startsWith('## MCP (Model Context Protocol) System')) {
+            skipping = true;
+            continue;
+        }
+        if (line.startsWith('## Identity') ||
+            line.startsWith('## Confidentiality') ||
+            line.startsWith('## Working Style') ||
+            line.startsWith('## Engineering Principles') ||
+            line.startsWith('## Approach') ||
+            line.startsWith('## Project Context') ||
+            line.startsWith('## Memory') ||
+            line.startsWith('## Available Skills')) {
+            skipping = false;
+        }
+        if (!skipping) {
+            result.push(line);
+        }
+    }
+    // Inject a condensed response formatting instruction at the top
+    const corePrompt = result.join('\n');
+    return `You are Ikie, an elite terminal coding assistant. Be direct, concise, and pragmatic. Use markdown in responses.
+
+${corePrompt}`;
+}
 export function buildSystemPrompt(projectContext, memoryContext, skillsCatalog = '') {
     const parts = [
         `You are Ikie, an elite agentic software engineer running in the terminal.

package/dist/context.d.ts

@@ -9,5 +9,5 @@ export interface ProjectContext {
     manifest?: string;
     instructions?: string;
 }
-export declare function detectProjectContext(): ProjectContext;
+export declare function detectProjectContext(projectRoot?: string): ProjectContext;
 export declare function formatContextForPrompt(ctx: ProjectContext): string;

package/dist/context.js

@@ -82,8 +82,8 @@ function readManifest(cwd) {
     }
     return undefined;
 }
-export function detectProjectContext() {
-    const cwd = process.cwd();
+export function detectProjectContext(projectRoot) {
+    const cwd = projectRoot || process.cwd();
     const name = basename(cwd);
     const types = detectTypes(cwd);
     let readme;

package/dist/index.js

@@ -5,6 +5,7 @@ import minimist from 'minimist';
 import { loadConfig, getApiKey, IKIE_API_BASE, IKIE_HOST, DEFAULT_MODEL, hasExplicitModel } from './config.js';
 import { detectProjectContext, formatContextForPrompt } from './context.js';
 import { loadAllMemory, formatMemoryForPrompt } from './memory.js';
+import { findProjectRoot } from './utils.js';
 import { discoverSkills, formatSkillsForPrompt } from './skills.js';
 import { buildSystemPrompt, Agent } from './agent.js';
 import { startREPL } from './repl.js';
@@ -203,11 +204,12 @@ ${errorLine('Not signed in.')}
         baseURL: config.baseURL ?? IKIE_API_BASE,
         timeout: 60000, // 60 seconds timeout to prevent indefinite hangs
     });
-    const projectCtx = detectProjectContext();
+    const projectRoot = findProjectRoot(process.cwd());
+    const projectCtx = detectProjectContext(projectRoot);
     const projectContextStr = formatContextForPrompt(projectCtx);
-    const memory = loadAllMemory();
+    const memory = loadAllMemory(projectRoot);
     const memoryStr = formatMemoryForPrompt(memory);
-    const skills = discoverSkills();
+    const skills = discoverSkills(projectRoot);
     const skillsStr = formatSkillsForPrompt(skills);
     const systemPrompt = buildSystemPrompt(projectContextStr, memoryStr, skillsStr);
     if (argv.verbose) {
@@ -219,9 +221,8 @@ ${errorLine('Not signed in.')}
     }
     const agent = new Agent(client, config, systemPrompt);
     // Connect configured MCP servers before the first turn.
-    const cwd = process.cwd();
     try {
-        await getMcpManager().connectAll(cwd);
+        await getMcpManager().connectAll(projectRoot);
     }
     catch {
         // Failures are recorded per-server; don't crash the REPL.

package/dist/memory.d.ts

@@ -1,14 +1,14 @@
 export declare function loadGlobalMemory(): string;
-export declare function loadProjectMemory(): string;
+export declare function loadProjectMemory(projectRoot?: string): string;
 export declare function saveGlobalMemory(content: string): void;
-export declare function saveProjectMemory(content: string): void;
+export declare function saveProjectMemory(content: string, projectRoot?: string): void;
 export declare function appendGlobalMemory(note: string): void;
-export declare function appendProjectMemory(note: string): void;
+export declare function appendProjectMemory(note: string, projectRoot?: string): void;
 export interface MemoryContext {
     global: string;
     project: string;
 }
-export declare function loadAllMemory(): MemoryContext;
+export declare function loadAllMemory(projectRoot?: string): MemoryContext;
 export declare function formatMemoryForPrompt(mem: MemoryContext): string;
-export declare function getProjectMemoryPath(): string;
+export declare function getProjectMemoryPath(projectRoot?: string): string;
 export declare function getGlobalMemoryPath(): string;

package/dist/memory.js

@@ -1,11 +1,16 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { GLOBAL_MEMORY_FILE } from './config.js';
-const PROJECT_MEMORY_DIR = '.ikie';
-const PROJECT_MEMORY_FILE = join(PROJECT_MEMORY_DIR, 'memory.md');
-function ensureProjectDir() {
-    if (!existsSync(PROJECT_MEMORY_DIR)) {
-        mkdirSync(PROJECT_MEMORY_DIR, { recursive: true });
+import { findProjectRoot } from './utils.js';
+function getProjectMemoryFile(projectRoot) {
+    const root = projectRoot || findProjectRoot(process.cwd());
+    return join(root, '.ikie', 'memory.md');
+}
+function ensureProjectDir(projectRoot) {
+    const root = projectRoot || findProjectRoot(process.cwd());
+    const dir = join(root, '.ikie');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
     }
 }
 export function loadGlobalMemory() {
@@ -17,10 +22,11 @@ export function loadGlobalMemory() {
     catch { }
     return '';
 }
-export function loadProjectMemory() {
+export function loadProjectMemory(projectRoot) {
     try {
-        if (existsSync(PROJECT_MEMORY_FILE)) {
-            return readFileSync(PROJECT_MEMORY_FILE, 'utf-8').trim();
+        const file = getProjectMemoryFile(projectRoot);
+        if (existsSync(file)) {
+            return readFileSync(file, 'utf-8').trim();
         }
     }
     catch { }
@@ -29,9 +35,9 @@ export function loadProjectMemory() {
 export function saveGlobalMemory(content) {
     writeFileSync(GLOBAL_MEMORY_FILE, content.trim() + '\n');
 }
-export function saveProjectMemory(content) {
-    ensureProjectDir();
-    writeFileSync(PROJECT_MEMORY_FILE, content.trim() + '\n');
+export function saveProjectMemory(content, projectRoot) {
+    ensureProjectDir(projectRoot);
+    writeFileSync(getProjectMemoryFile(projectRoot), content.trim() + '\n');
 }
 export function appendGlobalMemory(note) {
     const existing = loadGlobalMemory();
@@ -40,17 +46,17 @@ export function appendGlobalMemory(note) {
         : note.trim();
     saveGlobalMemory(updated);
 }
-export function appendProjectMemory(note) {
-    const existing = loadProjectMemory();
+export function appendProjectMemory(note, projectRoot) {
+    const existing = loadProjectMemory(projectRoot);
     const updated = existing
         ? `${existing}\n\n${note.trim()}`
         : note.trim();
-    saveProjectMemory(updated);
+    saveProjectMemory(updated, projectRoot);
 }
-export function loadAllMemory() {
+export function loadAllMemory(projectRoot) {
     return {
         global: loadGlobalMemory(),
-        project: loadProjectMemory(),
+        project: loadProjectMemory(projectRoot),
     };
 }
 export function formatMemoryForPrompt(mem) {
@@ -63,8 +69,8 @@ export function formatMemoryForPrompt(mem) {
     }
     return parts.join('\n\n');
 }
-export function getProjectMemoryPath() {
-    return resolve(PROJECT_MEMORY_FILE);
+export function getProjectMemoryPath(projectRoot) {
+    return resolve(getProjectMemoryFile(projectRoot));
 }
 export function getGlobalMemoryPath() {
     return GLOBAL_MEMORY_FILE;

package/dist/repl.js

@@ -1,7 +1,7 @@
 import * as readline from 'node:readline';
 import { execSync, exec } from 'child_process';
 import { restoreStdinListeners, extractUpstreamError } from './agent.js';
-import { c, PROMPT, CONTINUE_PROMPT, PROMPT_ARROW, printPromptHeader, promptHeaderText, modeTag, drawBanner, infoLine, successLine, errorLine, THEMES, setTheme, stripAnsi, contextRing, renderSlashMenu, supportsVT, CH, } from './theme.js';
+import { c, PROMPT, CONTINUE_PROMPT, PROMPT_ARROW, printPromptHeader, promptHeaderText, modeTag, drawBanner, infoLine, successLine, errorLine, THEMES, setTheme, stripAnsi, contextRing, renderSlashMenu, supportsVT, CH, planApprovalPrompt, planHeader, } from './theme.js';
 import { renderMarkdown } from './renderer.js';
 import { loadAllMemory } from './memory.js';
 import { HOME_DIR, saveConfig, DEFAULT_MODEL, IKIE_HOST, IKIE_API_BASE, isLoggedIn, getApiKey, loadConfig } from './config.js';
@@ -285,13 +285,15 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
                     }
                     else {
                         const { appendProjectMemory } = await import('./memory.js');
-                        appendProjectMemory(note);
+                        const { findProjectRoot } = await import('./utils.js');
+                        appendProjectMemory(note, findProjectRoot(process.cwd()));
                     }
                     console.log(successLine(`Saved to ${scope} memory.`));
                 }
             }
             else {
-                const mem = loadAllMemory();
+                const { findProjectRoot } = await import('./utils.js');
+                const mem = loadAllMemory(findProjectRoot(process.cwd()));
                 if (mem.global || mem.project) {
                     if (mem.global) {
                         console.log(`\n${c.primary.bold('Global Memory')} ${c.muted('(~/.ikie/memory.md)')}`);
@@ -469,6 +471,8 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
         }
         case 'skills': {
             const sub = (args[0] ?? 'list').toLowerCase();
+            const { findProjectRoot } = await import('./utils.js');
+            const projectRoot = findProjectRoot(process.cwd());
             const { discoverSkills, getSkill, listSkillFiles, installSkill, removeSkill } = await import('./skills.js');
             if (sub === 'install' || sub === 'add') {
                 const rest = args.slice(1).filter(a => a !== '--force');
@@ -517,7 +521,7 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
                     console.log(errorLine('Usage: /skills show <name>'));
                     return true;
                 }
-                const skill = getSkill(nameArg);
+                const skill = getSkill(nameArg, projectRoot);
                 if (!skill) {
                     console.log(errorLine(`No skill named "${nameArg}".`));
                     return true;
@@ -529,7 +533,7 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
                 console.log(renderMarkdown(skill.body || '(no instructions)'));
                 return true;
             }
-            const skills = discoverSkills();
+            const skills = discoverSkills(projectRoot);
             if (!skills.length) {
                 console.log(infoLine('No skills installed.'));
                 console.log(`\n  ${c.muted('Install one with')} ${c.warning('/skills install <git-url|path>')}`);
@@ -943,14 +947,12 @@ function confirmExecutePlan() {
             resolve(false);
             return;
         }
-        process.stdout.write(`\n  ${c.primary('▸')} ${c.white.bold('Plan ready.')} ${c.muted('Execute it now?')}  ` +
-            `${c.success.bold('y')} ${c.muted('yes')}   ${c.error.bold('n')} ${c.muted('keep planning')}\n` +
-            `  ${c.muted('❯')} `);
+        process.stdout.write(planApprovalPrompt());
         const onKey = (d) => {
             process.stdin.removeListener('data', onKey);
             const k = d.toString().toLowerCase();
             const yes = k === 'y' || k === '\r' || k === '\n';
-            process.stdout.write(yes ? c.success('y\n') : c.muted('n\n'));
+            process.stdout.write(yes ? c.success('y\n') : c.error('N\n'));
             resolve(yes);
         };
         process.stdin.on('data', onKey);
@@ -1130,6 +1132,30 @@ function parsePlanSteps(conversation) {
 }
 export async function startREPL(agent, config, projectContext, oneShot) {
     void HISTORY_FILE;
+    const setBracketedPaste = (on) => {
+        if (process.stdout.isTTY)
+            process.stdout.write(on ? '\x1b[?2004h' : '\x1b[?2004l');
+    };
+    const restoreTerminal = () => {
+        setBracketedPaste(false);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+    };
+    const onFatalError = (err) => {
+        restoreTerminal();
+        console.error('\n' + errorLine(`Uncaught exception: ${err instanceof Error ? err.stack || err.message : String(err)}`));
+        process.exit(1);
+    };
+    const onUnhandledRejection = (reason) => {
+        restoreTerminal();
+        console.error('\n' + errorLine(`Unhandled rejection: ${reason instanceof Error ? reason.stack || reason.message : String(reason)}`));
+        process.exit(1);
+    };
+    process.on('uncaughtException', onFatalError);
+    process.on('unhandledRejection', onUnhandledRejection);
+    process.on('exit', restoreTerminal);
     // Context window size — default 131072 (128k), updated silently from model info.
     let contextWindow = 131072;
     fetchModelsFromServer(config).then(models => {
@@ -1183,12 +1209,7 @@ export async function startREPL(agent, config, projectContext, oneShot) {
     // \x1b[200~ … \x1b[201~ markers. This lets a multi-chunk paste (a long
     // paragraph the TTY delivers across several reads) be coalesced into ONE
     // paste instead of being split into several. Disabled again on exit.
-    const setBracketedPaste = (on) => {
-        if (process.stdout.isTTY)
-            process.stdout.write(on ? '\x1b[?2004h' : '\x1b[?2004l');
-    };
     setBracketedPaste(true);
-    process.on('exit', () => setBracketedPaste(false));
     let multilineBuffer = '';
     let busy = false;
     let ctrlCCount = 0;
@@ -1648,6 +1669,10 @@ export async function startREPL(agent, config, projectContext, oneShot) {
         };
         process.stdin.on('data', cancelHandler);
         try {
+            // Display mode status for plan mode
+            if (agent.getMode() === 'plan') {
+                process.stdout.write(`\n${planHeader('plan mode', agent.getLastTurnStats().filesChanged)}\n\n`);
+            }
             await agent.send(userContent, {
                 autoApprove: config.autoApprove,
                 signal: abortController.signal,

package/dist/theme.d.ts

@@ -50,6 +50,9 @@ declare const CH: {
     cont: string;
     arrow: string;
     dot: string;
+    sparkle: string;
+    check: string;
+    box: string;
 };
 export { CH };
 /**
@@ -109,3 +112,54 @@ export declare function errorLine(msg: string): string;
 export declare function warnLine(msg: string): string;
 export declare function infoLine(msg: string): string;
 export declare function permissionPrompt(toolName: string, preview: string): string;
+/**
+ * Draw a rounded box around text (like command input in images)
+ */
+export declare function roundedBox(content: string, opts?: {
+    width?: number;
+    padding?: number;
+}): string;
+/**
+ * Status indicator with sparkle icon
+ */
+export declare function sparkleStatus(message: string, color?: keyof typeof c): string;
+/**
+ * Thinking time display
+ */
+export declare function thinkingTime(seconds: number): string;
+/**
+ * Action indicator (e.g., "✦ Edit src/api/checkout.ts")
+ */
+export declare function actionLine(action: string, target: string): string;
+/**
+ * Plan step display
+ */
+export declare function planStep(text: string, completed?: boolean): string;
+/**
+ * Plan header
+ */
+export declare function planHeader(mode: string, filesChanged?: number): string;
+/**
+ * Proposed plan title
+ */
+export declare function planTitle(stepCount: number): string;
+/**
+ * Bottom status bar (full width)
+ */
+export declare function bottomBar(leftText: string, rightText?: string): string;
+/**
+ * Code line with number and optional highlight
+ */
+export declare function codeLine(lineNum: number, code: string, highlight?: boolean): string;
+/**
+ * File edit header
+ */
+export declare function fileEditHeader(filePath: string): string;
+/**
+ * Approval prompt for plan execution
+ */
+export declare function planApprovalPrompt(): string;
+/**
+ * Command echo in rounded box
+ */
+export declare function commandBox(command: string): string;

package/dist/theme.js

@@ -284,8 +284,8 @@ const IS_WIN = process.platform === 'win32';
 /** True when the terminal supports VT100 escape sequences (cursor save/restore, etc). */
 export const supportsVT = !IS_WIN;
 const CH = IS_WIN
-    ? { tl: '+-', prompt: '-> ', cont: '|  ', arrow: '>', dot: 'o' }
-    : { tl: '╭─', prompt: '╰─❯', cont: '│  ', arrow: '❯', dot: '●' };
+    ? { tl: '+-', prompt: '-> ', cont: '|  ', arrow: '>', dot: 'o', sparkle: '*', check: 'v', box: '[ ]' }
+    : { tl: '╭─', prompt: '╰─❯', cont: '│  ', arrow: '❯', dot: '●', sparkle: '✦', check: '✓', box: '☐' };
 export { CH };
 /**
  * Builds the prompt header line (e.g. `╭─ ikie · agent theme aurora in <cwd>`)
@@ -297,7 +297,16 @@ export function promptHeaderText(mode = 'agent') {
     const branch = getGitBranchFast();
     const gitSegment = branch ? ` ${c.muted('on')} ${c.secondary(branch)}` : '';
     const themeSegment = ` ${c.muted('theme')} ${c.secondary(activeTheme.name)}`;
-    return `${c.primary(CH.tl)} ${c.primary.bold('ikie')} ${c.muted('·')} ${modeTag(mode)}${gitSegment}${themeSegment} ${c.muted('in')} ${c.accent(cwdName)}`;
+    const leftStr = `${c.primary(CH.tl)} ${c.primary.bold('ikie')} ${c.muted('·')} ${modeTag(mode)}${gitSegment}${themeSegment} ${c.muted('in')} ${c.accent(cwdName)}`;
+    const rightStr = `${mode} · shift+tab to toggle`;
+    const cols = process.stdout.columns ?? 80;
+    const leftLen = stripAnsi(leftStr).length;
+    const rightLen = rightStr.length;
+    const space = cols - leftLen - rightLen - 1; // -1 safety to prevent soft-wrap
+    if (space > 0) {
+        return `${leftStr}${' '.repeat(space)}${c.dim(rightStr)}`;
+    }
+    return leftStr;
 }
 export function printPromptHeader(mode = 'agent') {
     process.stdout.write(`\n${promptHeaderText(mode)}\n`);
@@ -667,3 +676,127 @@ export function permissionPrompt(toolName, preview) {
         `${c.muted.bold('!')} ${c.muted('never')}\n` +
         `  ${c.muted(CH.arrow)} `);
 }
+// ──────────────────────────────────────────────────────────────────────────────
+// Modern UX Components
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Draw a rounded box around text (like command input in images)
+ */
+export function roundedBox(content, opts) {
+    const cols = opts?.width ?? Math.min(process.stdout.columns ?? 80, 120);
+    const padding = opts?.padding ?? 1;
+    const innerWidth = cols - 4 - (padding * 2);
+    const lines = content.split('\n').flatMap(line => {
+        if (stripAnsi(line).length <= innerWidth)
+            return [line];
+        // Simple wrapping for long lines
+        const chunks = [];
+        let current = '';
+        for (const word of line.split(' ')) {
+            if (stripAnsi(current + ' ' + word).length > innerWidth) {
+                if (current)
+                    chunks.push(current);
+                current = word;
+            }
+            else {
+                current = current ? current + ' ' + word : word;
+            }
+        }
+        if (current)
+            chunks.push(current);
+        return chunks;
+    });
+    const tl = '╭';
+    const tr = '╮';
+    const bl = '╰';
+    const br = '╯';
+    const h = '─';
+    const v = '│';
+    const pad = ' '.repeat(padding);
+    const top = c.muted(`${tl}${h.repeat(cols - 2)}${tr}`);
+    const bottom = c.muted(`${bl}${h.repeat(cols - 2)}${br}`);
+    const contentLines = lines.map(line => {
+        const visible = stripAnsi(line).length;
+        const spaces = innerWidth - visible;
+        return `${c.muted(v)}${pad}${line}${' '.repeat(spaces)}${pad}${c.muted(v)}`;
+    });
+    return [top, ...contentLines, bottom].join('\n');
+}
+/**
+ * Status indicator with sparkle icon
+ */
+export function sparkleStatus(message, color) {
+    const sparkleColor = color ? c[color] : c.warning;
+    return `${sparkleColor(CH.sparkle)} ${c.muted(message)}`;
+}
+/**
+ * Thinking time display
+ */
+export function thinkingTime(seconds) {
+    return sparkleStatus(`Thought for ${seconds.toFixed(1)}s`, 'warning');
+}
+/**
+ * Action indicator (e.g., "✦ Edit src/api/checkout.ts")
+ */
+export function actionLine(action, target) {
+    return `${c.warning(CH.sparkle)} ${c.white(action)} ${c.accent(target)}`;
+}
+/**
+ * Plan step display
+ */
+export function planStep(text, completed = false) {
+    const icon = completed ? c.success(CH.check) : c.muted(CH.box);
+    return `${icon} ${completed ? c.white(text) : c.dim(text)}`;
+}
+/**
+ * Plan header
+ */
+export function planHeader(mode, filesChanged = 0) {
+    return sparkleStatus(`${mode} · read-only · ${filesChanged} files changed`, 'warning');
+}
+/**
+ * Proposed plan title
+ */
+export function planTitle(stepCount) {
+    return `${c.white('Proposed plan')} ${c.muted('·')} ${c.secondary(`${stepCount} steps`)}`;
+}
+/**
+ * Bottom status bar (full width)
+ */
+export function bottomBar(leftText, rightText) {
+    const cols = process.stdout.columns ?? 80;
+    const left = stripAnsi(leftText);
+    const right = rightText ? stripAnsi(rightText) : '';
+    const spacing = cols - left.length - right.length;
+    return (c.muted(leftText) +
+        ' '.repeat(Math.max(0, spacing)) +
+        (rightText ? c.dim(rightText) : ''));
+}
+/**
+ * Code line with number and optional highlight
+ */
+export function codeLine(lineNum, code, highlight = false) {
+    const num = c.dim(String(lineNum).padStart(4) + ' ');
+    const content = highlight ? chalk.bgHex('#1a3a2e')(code) : code;
+    return `${num} ${content}`;
+}
+/**
+ * File edit header
+ */
+export function fileEditHeader(filePath) {
+    return actionLine('Edit', filePath);
+}
+/**
+ * Approval prompt for plan execution
+ */
+export function planApprovalPrompt() {
+    return `
+${c.muted('Approve to run in agent mode?')} ${c.success.bold('[y')}/${c.error('N]')}
+`;
+}
+/**
+ * Command echo in rounded box
+ */
+export function commandBox(command) {
+    return roundedBox(`${c.primary('>')} ${c.white(command)}`);
+}

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Estimate the number of tokens in a string.
+ *
+ * Heuristic rationale:
+ *   - Prose English:  ~4 chars / token  (GPT BPE baseline)
+ *   - Code/symbols:   ~3 chars / token  (more tokens per char due to operators,
+ *                                        punctuation, identifiers broken at sub-word
+ *                                        boundaries by BPE tokenisers)
+ *
+ * We classify a string as "code-heavy" when the density of typical code
+ * characters (braces, semicolons, brackets, operators, indentation runs) is
+ * above a threshold.  This gives a noticeably better estimate for tool outputs
+ * and file contents while remaining O(n) and zero-dependency.
+ *
+ * The function is designed as a drop-in for a proper BPE tokeniser:
+ * swap the body for `tiktoken.encode(text).length` when you want exactness.
+ */
+export declare function estimateTokens(chars: number, text?: string): number;
+/**
+ * Walk up the directory tree from `startDir`, looking for a `.git` directory
+ * or a `package.json` file.  Returns the absolute path of the detected root,
+ * or `startDir` itself if nothing is found (graceful fallback).
+ *
+ * This lets `ikie` be invoked from a deeply nested subdirectory and still
+ * resolve project-scoped memory/config files correctly.
+ */
+export declare function findProjectRoot(startDir: string): string;

package/dist/utils.js

@@ -0,0 +1,77 @@
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+// ── Token estimation ──────────────────────────────────────────────────────────
+/**
+ * Estimate the number of tokens in a string.
+ *
+ * Heuristic rationale:
+ *   - Prose English:  ~4 chars / token  (GPT BPE baseline)
+ *   - Code/symbols:   ~3 chars / token  (more tokens per char due to operators,
+ *                                        punctuation, identifiers broken at sub-word
+ *                                        boundaries by BPE tokenisers)
+ *
+ * We classify a string as "code-heavy" when the density of typical code
+ * characters (braces, semicolons, brackets, operators, indentation runs) is
+ * above a threshold.  This gives a noticeably better estimate for tool outputs
+ * and file contents while remaining O(n) and zero-dependency.
+ *
+ * The function is designed as a drop-in for a proper BPE tokeniser:
+ * swap the body for `tiktoken.encode(text).length` when you want exactness.
+ */
+export function estimateTokens(chars, text) {
+    if (chars <= 0)
+        return 1;
+    let charsPerToken = 4; // prose default
+    if (text && text.length > 0) {
+        // Count code-characteristic characters
+        let codeChars = 0;
+        for (let i = 0; i < text.length; i++) {
+            const c = text.charCodeAt(i);
+            // { } ( ) [ ] ; : = < > ! & | ^ ~ + - * / \ . , @ # % ` and tab
+            if (c === 123 || c === 125 || // { }
+                c === 40 || c === 41 || // ( )
+                c === 91 || c === 93 || // [ ]
+                c === 59 || c === 58 || // ; :
+                c === 61 || c === 60 || c === 62 || // = < >
+                c === 33 || c === 38 || c === 124 || // ! & |
+                c === 94 || c === 126 || c === 43 || // ^ ~ +
+                c === 45 || c === 42 || c === 47 || // - * /
+                c === 92 || c === 46 || c === 44 || // \ . ,
+                c === 64 || c === 35 || c === 37 || // @ # %
+                c === 96 || c === 9 // ` tab
+            ) {
+                codeChars++;
+            }
+        }
+        const codeDensity = codeChars / text.length;
+        if (codeDensity > 0.12) {
+            charsPerToken = 3; // code-heavy — more tokens per char
+        }
+    }
+    return Math.max(1, Math.round(chars / charsPerToken));
+}
+// ── Project root detection ────────────────────────────────────────────────────
+/**
+ * Walk up the directory tree from `startDir`, looking for a `.git` directory
+ * or a `package.json` file.  Returns the absolute path of the detected root,
+ * or `startDir` itself if nothing is found (graceful fallback).
+ *
+ * This lets `ikie` be invoked from a deeply nested subdirectory and still
+ * resolve project-scoped memory/config files correctly.
+ */
+export function findProjectRoot(startDir) {
+    let current = startDir;
+    // Safety cap: don't walk more than 20 levels to avoid infinite loops on
+    // pathological setups or file systems where the root is never reached.
+    for (let depth = 0; depth < 20; depth++) {
+        if (existsSync(join(current, '.git')) ||
+            existsSync(join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break; // reached filesystem root
+        current = parent;
+    }
+    return startDir; // fallback — treat cwd as the project root
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikie-cli",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "Agentic coding CLI — your terminal AI pair programmer",
   "type": "module",
   "bin": {