ineedcodes 1.4.0 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ineedcodes",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Your terminal, now autonomous. Just say what you want, ineed does the rest.",
   "license": "MIT",
   "type": "module",

package/src/agent.js

@@ -3,6 +3,7 @@
 import { chat } from './provider.js';
 import { TOOLS, runTool, shellRun, isDestructive, GIT_TOOL_DEFS, runGitTool } from './tools.js';
 import { fetchUrl, webSearch } from './web.js';
+import { PROC_TOOL_DEFS, runProcTool } from './processes.js';
 import { trunc, gray, cyan, dim } from './ui.js';
 import { getMemoryProvider } from './memory.js';
 import * as path from 'node:path';
@@ -30,6 +31,8 @@ Rules:
 - Prefer targeted edits (edit_file) over full rewrites (write_file). Work only inside the current folder.
 - Never push to remotes or delete data without being asked.
 - Destructive commands are always blocked. Ask the user to run those themselves.
+- Explain to match the user's depth preference (short: results only; normal: what changed and why; deep: also the reasoning and trade-offs).
+- Suggest "boost" (isolated git-worktree run) when a task involves major refactoring, repeated failed fixes, or architecture changes, by telling the user to run /boost. Do not start it yourself.
 - Some actions need user approval. A tool result starting with "Denied" means the user said no: do not retry the same call, explain what you wanted instead.
 - For objectives with 3 or more steps, keep a checklist with the todo tool and update statuses as you go (in_progress for what you are doing now).
 - A "[steer from the user, newer than the objective]" message is a live steer: it is newer than the original objective. Adapt to it immediately; if it changes direction, change course without redoing finished work.
@@ -93,7 +96,8 @@ async function runWorker(cfg, spec, cwd, depth, hooks) {
     const res = await runObjective(cfg, objective, cwd, [], {}, {
       depth: depth + 1,
       toolFilter: role.tools,
-      worker: { id: spec.id, role: roleName, prompt: role.prompt }
+      worker: { id: spec.id, role: roleName, prompt: role.prompt },
+      modelOverride: cfg.models?.[roleName] ?? cfg.models?.worker ?? null
     });
     return { id: spec.id, role: roleName, status: res.aborted ? 'incomplete' : 'completed', summary: res.answer || '(no output)', files: res.changed, commands: res.ran };
   } catch (err) {
@@ -124,8 +128,11 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
   let tools = plan ? TOOLS.filter(t => t.allowedInPlan) : [...TOOLS, SPAWN_TOOL];
   // first-class git wrappers (read ones always, mutating ones gated by permEdit)
   tools.push(...GIT_TOOL_DEFS.filter(t => plan ? !t.mutating : true));
+  // background process tools (build mode only)
+  if (!plan) tools.push(...PROC_TOOL_DEFS);
   if (extra.toolFilter) tools = tools.filter(t => (extra.toolFilter).includes(t.name));
   const canAsk = typeof hooks.onApprove === 'function';
+  const roleCfg = extra.modelOverride ? { ...cfg, model: extra.modelOverride } : cfg;
 
   // MCP: load configured servers once per top-level objective, expose their tools
   let mcpManager = null;
@@ -158,6 +165,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
 
   const workerPrefix = extra.worker ? `You are ${extra.worker.id} (${extra.worker.role} worker) spawned by the lead agent. ${extra.worker.prompt}\n` : '';
   const projectInstructions = extra.worker ? '' : loadProjectInstructions(cwd);
+  const depthNote = extra.worker ? '' : (cfg.explain === 'short' ? '\nAnswer style: short. Give results, skip explanations unless asked.' : cfg.explain === 'deep' ? '\nAnswer style: deep. Include reasoning, trade-offs, and what you ruled out.' : '');
   const skills = extra.worker ? [] : listSkills(cwd);
   const skillsBlock = skills.length ? `\nInstalled skills (follow a skill's instructions when the user invokes it by name or clearly asks for what it does):\n${skills.map(s => `- ${s.name} (${s.scope}): ${s.description}`).join('\n')}` : '';
   const invokedSkill = !extra.worker
@@ -166,7 +174,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
   const messages = [
     {
       role: 'system',
-      content: `${workerPrefix ? workerPrefix + '\n' : ''}${SYSTEM}\nWorking directory: ${cwd}\nMode: ${plan ? 'plan (read only, suggest what to change, do not change anything)' : 'build'}`
+      content: `${workerPrefix ? workerPrefix + '\n' : ''}${SYSTEM}${depthNote}\nWorking directory: ${cwd}\nMode: ${plan ? 'plan (read only, suggest what to change, do not change anything)' : 'build'}`
         + (recalled ? `\nRelevant memory from previous sessions with this user (durable facts, may be stale):\n${recalled}` : '')
         + (projectInstructions ? `\nProject instructions for this repository (follow them):\n${projectInstructions}` : '')
         + skillsBlock
@@ -177,6 +185,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
   const changed = new Set();
   const ran = [];
   const todos = [];
+  const usage = { input: 0, output: 0 };
   let answer = '';
   let lastShown = '';
   try {
@@ -195,7 +204,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
       let msg;
       try {
         hooks.onThinkingStart?.();
-        msg = await chat(cfg, messages, tools, ctrl.signal);
+        msg = await chat(roleCfg, messages, tools, ctrl.signal, hooks.onDelta);
         hooks.onThinkingEnd?.();
       } catch (err) {
         hooks.onThinkingEnd?.();
@@ -203,6 +212,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
         throw err;
       }
       messages.push(msg);
+      if (msg._usage) { usage.input += msg._usage.input; usage.output += msg._usage.output; hooks.onUsage?.({ ...usage }); }
       if (msg.content && msg.content !== lastShown) {
         hooks.onText?.(msg.content);
         lastShown = msg.content;
@@ -216,7 +226,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
             await memory.store(`project ${cwd}: ${objective.slice(0, 150)} -> ${answer.slice(0, 300)}`);
           } catch {}
         }
-        return { answer, changed: [...changed], ran, todos: [...todos], aborted: false };
+        return { answer, changed: [...changed], ran, todos: [...todos], usage: { ...usage }, aborted: false };
       }
       // spawn_agent pre-pass: read-only workers run in parallel (max 4), writers sequentially
       const spawnResults = new Map();
@@ -269,9 +279,31 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
             result = allowedNow ? runGitTool(call.function?.name, input, cwd) : { output: `Denied: the user did not approve ${call.function?.name}.` };
           }
         } else if (call.function?.name === 'fetch_url') {
-          result = await fetchUrl(input.url);
+          if (cfg.permNet === 'ask' && !hooks.approved?.has('net') && canAsk) {
+            const verdict = await hooks.onApprove('net', 'fetch_url', input);
+            if (verdict === 'always') hooks.approved?.add('net');
+            if (!verdict) result = { output: 'Denied: the user did not approve network access.' };
+          }
+          if (!result) result = await fetchUrl(input.url);
         } else if (call.function?.name === 'web_search') {
-          result = await webSearch(cfg, input.query);
+          if (cfg.permNet === 'ask' && !hooks.approved?.has('net') && canAsk) {
+            const verdict = await hooks.onApprove('net', 'web_search', input);
+            if (verdict === 'always') hooks.approved?.add('net');
+            if (!verdict) result = { output: 'Denied: the user did not approve network access.' };
+          }
+          if (!result) result = await webSearch(cfg, input.query);
+        } else if (call.function?.name?.startsWith('process_')) {
+          if (plan) result = { output: 'Refused: plan mode is read only.' };
+          else {
+            const def = PROC_TOOL_DEFS.find(t => t.name === call.function?.name);
+            let allowedNow = !def.mutating || cfg.permShell === 'allow' || hooks.approved?.has('shell');
+            if (!allowedNow && canAsk) {
+              const verdict = await hooks.onApprove('shell', call.function?.name, input);
+              if (verdict === 'always') hooks.approved?.add('shell');
+              allowedNow = Boolean(verdict);
+            }
+            result = allowedNow ? runProcTool(call.function?.name, input) : { output: `Denied: the user did not approve ${call.function?.name}.` };
+          }
         } else if (call.function?.name === 'shell') {
           if (plan) result = { output: 'Refused: plan mode is read only. Switch to build mode with /build.' };
           else if (isDestructive(String(input.command ?? ''))) {
@@ -333,7 +365,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
     hooks.onRunEnd?.();
   }
   const stopped = ctrl.signal.aborted;
-  return { answer, changed: [...changed], ran, todos: [...todos], aborted: true, stopped };
+  return { answer, changed: [...changed], ran, todos: [...todos], usage: { ...usage }, aborted: true, stopped };
 }
 
 export function pushTurn(history, objective, result) {

package/src/config.js

@@ -26,9 +26,17 @@ export function normalize(c) {
     mode: c.mode === 'plan' ? 'plan' : 'build',
     memory: c.memory !== false,
     mcp: c.mcp !== false,
+    tui: c.tui === true ? true : c.tui === false ? false : null,
     humanize: c.humanize !== false,
+    stream: c.stream === true,
+    searchUrl: c.searchUrl ? String(c.searchUrl) : '',
+    explain: ['short', 'deep'].includes(c.explain) ? c.explain : 'normal',
     permEdit: c.permEdit === 'allow' ? 'allow' : 'ask',
-    permShell: c.permShell === 'allow' ? 'allow' : 'ask'
+    permShell: c.permShell === 'allow' ? 'allow' : 'ask',
+    permNet: c.permNet === 'ask' ? 'ask' : 'allow',
+    models: (c.models && typeof c.models === 'object' && !Array.isArray(c.models))
+      ? Object.fromEntries(Object.entries(c.models).map(([k, v]) => [k, String(v)]))
+      : {}
   };
 }
 

package/src/humanize.js

@@ -63,7 +63,7 @@ function humanizeHtmlTextNodes(html, fn) {
 
 async function humanizeWithModel(cfg, text, kind, signal) {
   const prompt = (kind === 'html'
-    ? `Below is the text content of an HTML page. Rewrite ONLY the marketing copy so it reads like a human wrote it: drop AI cliches ("game-changer", "cutting-edge", "unlock", "seamless"), filler openers, and excessive enthusiasm. Never use em dashes. Keep the message, facts, product names, numbers, and language (id vs en) exactly. Reply with ONLY the rewritten text, same line structure. If nothing needs changing, reply with the text unchanged.`
+    ? `Below is the text content of an HTML page. Rewrite ONLY the marketing copy so it reads like a human wrote it: drop AI cliches ("game-changer", "cutting-edge", "unlock", "seamless"), filler openers, and excessive enthusiasm. Never use em dashes. Keep the message, facts, product names, numbers, and the original language exactly. Reply with ONLY the rewritten text, same line structure. If nothing needs changing, reply with the text unchanged.`
     : `Rewrite the text below so it reads like a human wrote it: drop AI cliches and filler, keep it natural and direct. Never use em dashes. Keep the message, facts, names, numbers, and language exactly. Keep the same line structure. Reply with ONLY the rewritten text. If nothing needs changing, reply with it unchanged.`)
     + `\n---\n${text.slice(0, 8000)}`;
   const msg = await chat({ ...cfg, reasoning: 'low' }, [{ role: 'user', content: prompt }], undefined, signal);

package/src/processes.js

@@ -0,0 +1,104 @@
+// processes.js: background process tools (master prompt #25). Start dev servers or
+// long commands, list them, tail their logs, stop them. Zero dependencies.
+
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+const registry = new Map(); // name -> { child, logPath, command, started, exited }
+const LOG_DIR = path.join(os.tmpdir(), 'ineed-procs');
+
+function cleanExit() {
+  for (const [, e] of registry) { try { if (!e.exited) e.child.kill('SIGKILL'); } catch {} }
+}
+process.on('exit', cleanExit);
+
+const okName = n => /^[a-zA-Z0-9_-]{1,40}$/.test(String(n));
+
+export const PROC_TOOL_DEFS = [
+  {
+    name: 'process_start',
+    description: 'Start a long-running command in the background (dev server, watcher). Output goes to a log file.',
+    parameters: { type: 'object', properties: { name: { type: 'string' }, command: { type: 'string' } }, required: ['name', 'command'] },
+    proc: true, mutating: true
+  },
+  {
+    name: 'process_status',
+    description: 'List background processes with pid, command, and log path.',
+    parameters: { type: 'object', properties: {} },
+    proc: true
+  },
+  {
+    name: 'process_output',
+    description: 'Show the last lines of a background process log.',
+    parameters: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+    proc: true
+  },
+  {
+    name: 'process_stop',
+    description: 'Stop one background process by name.',
+    parameters: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+    proc: true, mutating: true
+  }
+];
+
+export function runProcTool(name, input) {
+  const n = String(input.name ?? '');
+  if (name !== 'process_status' && !okName(n)) return { output: 'Error: name must be letters, digits, _ or - (max 40).' };
+
+  if (name === 'process_start') {
+    const command = String(input.command ?? '').trim();
+    if (!command) return { output: 'Error: empty command.' };
+    if (registry.has(n) && !registry.get(n).exited) {
+      return { output: `Error: "${n}" is already running (pid ${registry.get(n).child.pid}). Stop it first.` };
+    }
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+    const logPath = path.join(LOG_DIR, n + '.log');
+    const out = fs.openSync(logPath, 'a');
+    let child;
+    try {
+      child = spawn(command, { cwd: os.homedir(), shell: true, stdio: ['ignore', out, out], env: { ...process.env, NO_COLOR: '1' } });
+    } catch (err) {
+      fs.closeSync(out);
+      return { output: `Error: ${err.message}` };
+    }
+    fs.closeSync(out);
+    const entry = { child, logPath, command: command.slice(0, 120), started: Date.now(), exited: false };
+    registry.set(n, entry);
+    child.on('exit', () => { entry.exited = true; });
+    return { output: `Started "${n}" (pid ${child.pid}). log: ${logPath}` };
+  }
+
+  if (name === 'process_status') {
+    if (!registry.size) return { output: 'No background processes.' };
+    return {
+      output: [...registry.entries()].map(([name, e]) =>
+        `${name}: pid ${e.child.pid}${e.exited ? ' (exited)' : ' (running)'} cmd: ${e.command} log: ${e.logPath}`
+      ).join('\n')
+    };
+  }
+
+  if (name === 'process_output') {
+    const e = registry.get(n);
+    if (!e) return { output: `Error: no process named "${n}".` };
+    try {
+      const log = fs.readFileSync(e.logPath, 'utf8');
+      return { output: log.split('\n').slice(-40).join('\n') || '(log empty)' };
+    } catch { return { output: '(log empty)' }; }
+  }
+
+  if (name === 'process_stop') {
+    const e = registry.get(n);
+    if (!e) return { output: `Error: no process named "${n}".` };
+    try { e.child.kill('SIGKILL'); } catch {}
+    registry.delete(n);
+    return { output: `Stopped "${n}".` };
+  }
+
+  return { output: `Unknown process tool: ${name}` };
+}
+
+export function stopAllProcs() {
+  for (const [, e] of registry) { try { if (!e.exited) e.child.kill('SIGKILL'); } catch {} }
+}

package/src/provider.js

@@ -30,9 +30,10 @@ export async function fetchModels(cfg, signal) {
   return [...new Set(ids)];
 }
 
-export async function chat(cfg, messages, tools, signal) {
+export async function chat(cfg, messages, tools, signal, onDelta) {
   const body = { model: cfg.model, messages, temperature: 0.2 };
   if (cfg.reasoning === 'high') body.reasoning_effort = 'high';
+  if (cfg.stream === true) body.stream = true;
   if (tools?.length) body.tools = tools.map(t => ({
     type: 'function',
     function: { name: t.name, description: t.description, parameters: t.parameters }
@@ -65,15 +66,74 @@ export async function chat(cfg, messages, tools, signal) {
     // provider does not know reasoning_effort: retry once without it
     if (body.reasoning_effort && (res.status === 400 || res.status === 422)) {
       delete body.reasoning_effort;
+      delete body.stream;
       const retry = await request(`${cfg.baseUrl}/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) }, signal);
       if (!retry.ok) throw new Error(`HTTP ${retry.status}: ${(await retry.text()).slice(0, 200)}`);
       return parseMessage(await retry.json());
     }
+    // provider does not stream: fall back to a plain call instead of failing
+    if (body.stream && (res.status === 400 || res.status === 404 || res.status === 422)) {
+      delete body.stream;
+      res = await request(`${cfg.baseUrl}/chat/completions`, { method: 'POST', headers, body: JSON.stringify(body) }, signal);
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${(await res.text()).slice(0, 200)}`);
+      return parseMessage(await res.json());
+    }
     throw new Error(`HTTP ${res.status}: ${text.slice(0, 200)}`);
   }
+  if (body.stream) return readStream(res, onDelta);
   return parseMessage(await res.json());
 }
 
+// SSE stream: accumulate content and tool_calls, emit text deltas as they arrive.
+async function readStream(res, onDelta) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let content = '';
+  const toolCalls = [];
+  let usage = null;
+  let role = 'assistant';
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!line.startsWith('data:')) continue;
+      const payload = line.slice(5).trim();
+      if (payload === '[DONE]') continue;
+      let ev;
+      try { ev = JSON.parse(payload); } catch { continue; }
+      if (ev.usage) usage = ev.usage;
+      const d = ev.choices?.[0]?.delta;
+      if (!d) continue;
+      if (d.role) role = d.role;
+      if (d.content) {
+        content += d.content;
+        onDelta?.(d.content);
+      }
+      for (const tc of d.tool_calls ?? []) {
+        const i = tc.index ?? 0;
+        toolCalls[i] ??= { id: tc.id ?? ('call_' + i), type: 'function', function: { name: '', arguments: '' } };
+        if (tc.id) toolCalls[i].id = tc.id;
+        if (tc.function?.name) toolCalls[i].function.name += tc.function.name;
+        if (tc.function?.arguments) toolCalls[i].function.arguments += tc.function.arguments;
+      }
+    }
+  }
+  const msg = { role, content, ...(toolCalls.length ? { tool_calls: toolCalls } : {}) };
+  if (usage) msg._usage = { input: usage.prompt_tokens ?? 0, output: usage.completion_tokens ?? 0 };
+  return msg;
+}
+
 function parseMessage(json) {
-  return json.choices?.[0]?.message ?? { role: 'assistant', content: '', tool_calls: [] };
+  const msg = json.choices?.[0]?.message ?? { role: 'assistant', content: '', tool_calls: [] };
+  // surface token usage when the provider returns it (OpenAI-style usage block)
+  if (json.usage) msg._usage = {
+    input: json.usage.prompt_tokens ?? 0,
+    output: json.usage.completion_tokens ?? 0
+  };
+  return msg;
 }

package/src/session.js

@@ -10,9 +10,15 @@ import { wizard } from './wizard.js';
 import { getMemoryProvider, ICMAdapter } from './memory.js';
 import { saveSession, listSessions, loadSession } from './sessions.js';
 import * as boost from './boost.js';
+import { spawnSync } from 'node:child_process';
 import { mcpConfigured } from './mcp.js';
 import { listSkills, findSkill } from './skills.js';
 
+function currentBranch(cwd) {
+  const r = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+
 const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 
 // Context compaction (master prompt #32): when the saved conversation grows past the
@@ -20,7 +26,7 @@ const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 const COMPACT_CHARS = 24_000;
 async function compactHistory(cfg, history, hooks = {}) {
   const size = history.reduce((n, m) => n + (m.content?.length ?? 0) + 24, 0);
-  if (size < COMPACT_CHARS || history.length < 6) return history;
+  if ((!hooks.force && size < COMPACT_CHARS) || history.length < 6) return history;
   const cut = Math.floor(history.length / 2);
   const old = history.slice(0, cut);
   const rest = history.slice(cut);
@@ -71,14 +77,27 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   const pendingLines = [];
   const steerQueue = [];      // notes typed while a task runs, injected mid-task
 
-  const TUI = process.stdout.isTTY && !process.env.NO_COLOR;
+  // Full-screen TUI: great in ANSI terminals (Linux/macOS/Windows Terminal), but
+  // legacy Windows consoles garble alt-screen sequences. Auto: on everywhere except
+  // win32; force with config "tui": true, disable with "tui": false.
+  const TUI = process.stdout.isTTY && !process.env.NO_COLOR
+    && (state.tui === true || (state.tui === null && process.platform !== 'win32'));
   let sessionId = null;
   let lastBoost = null;
+  let usage = { input: 0, output: 0 };
 
   // ONE readline, ONE line dispatcher for the whole session
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   let handleRef = null;
   const ask = makeInput(rl, l => handleRef?.(l));
+  // EOF (Ctrl+D or closed pipe): exit cleanly, unless a task is still running
+  rl.on('close', () => {
+    if (!busy) doExit();
+    else {
+      const wait = setInterval(() => { if (!busy) { clearInterval(wait); doExit(); } }, 200);
+      setTimeout(() => { clearInterval(wait); doExit(); }, 30_000);
+    }
+  });
 
   const say = TUI ? lines => tuiPrint(lines) : (lines => console.log(lines));
 
@@ -108,6 +127,19 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
     if (TUI) drawStatus();
   }
 
+  let lastStreamedForHooks = '';
+  let streamFlushTimer = null;
+  let streamFlushedCount = 0;
+  let streamBaseLines = null;
+
+  function flushStreamed() {
+    if (!TUI || !lastStreamedForHooks) return;
+    if (streamBaseLines === null) streamBaseLines = chatLines.length;
+    chatLines.length = streamBaseLines; // re-render the growing answer in place
+    for (const l of wrapLines(lastStreamedForHooks, Math.max(10, (process.stdout.columns || 80) - 4))) chatLines.push(l);
+    redrawChat();
+  }
+
   function hooksForRun(stopSpinner) {
     let spinner = null;
     const stop = () => { spinner?.stop(); spinner = null; };
@@ -122,6 +154,13 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       onTool: (name, input2) => { stop(); say(cyan('  ● ' + name) + gray(' ' + trunc(JSON.stringify(input2), 90))); },
       onResult: out => { say(gray('    ' + trunc(out, 110))); },
       onText: t => { stop(); },
+      onDelta: chunk => {
+        // stream into the chat buffer; the full text lands on flushStreamed()
+        lastStreamedForHooks += chunk;
+        if (TUI && !streamFlushTimer) {
+          streamFlushTimer = setTimeout(() => { streamFlushTimer = null; flushStreamed(); }, 120);
+        }
+      },
       onTodos: list => {
         stop();
         const mark = s => s === 'completed' ? green('✔') : s === 'in_progress' ? cyan('▸') : dim('○');
@@ -131,8 +170,9 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       onAgentEnd: (id, r) => { stop(); say((r.status === 'completed' ? green('  ◆ ' + id + ' done') : yellow('  ◆ ' + id + ' ' + r.status)) + gray(' ' + trunc(String(r.summary ?? '').replaceAll('\n', ' '), 90))); },
       onMCP: names => { if (names.length) say(dim('  MCP tools available: ' + names.join(', '))); },
       onMCPResult: (name, out) => { say(gray('    mcp result: ' + trunc(out, 100))); },
-      onNote: note => { stop(); say(dim('  ◇ ' + note)); },
-      drainSteer: () => steerQueue.splice(0),
+        onNote: note => { stop(); say(dim('  ◇ ' + note)); },
+        onUsage: u => { usage = u; if (TUI) drawStatus(); },
+        drainSteer: () => steerQueue.splice(0),
       onSteer: list => { for (const s of list) say(yellow('  ↳ steer: ') + s); },
       onApprove: async (cat, name, input2) => {
         stop();
@@ -160,11 +200,14 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
 
   async function runTask(input) {
     busy = true;
+    lastStreamedForHooks = '';
+    streamFlushedCount = 0;
     if (TUI) tuiUserLine(input);
     const hooks = hooksForRun();
     const stopSpinner = hooks.spinnerStop;
     try {
       const res = await runObjective(state, input, process.cwd(), history, hooks);
+      if (lastStreamedForHooks && TUI) process.stdout.write('\n');
       history = pushTurn(history, input, res);
       stopSpinner();
       try { history = await compactHistory(state, history, { onNote: n => say(dim('  ◇ ' + n)) }); } catch {}
@@ -174,7 +217,9 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       } else {
         const rows = [green(bold('■ Done'))];
         if (res.changed?.length) rows.push(dim('  files: ') + res.changed.join(', '));
-        if (res.answer) String(res.answer).split('\n').slice(0, 14).forEach(l => rows.push('  ' + l));
+        const answerIsStreamed = lastStreamedForHooks && res.answer === lastStreamedForHooks;
+        if (res.answer && !answerIsStreamed) String(res.answer).split('\n').slice(0, 14).forEach(l => rows.push('  ' + l));
+        else if (answerIsStreamed) rows.push(dim('  (streamed above)'));
         else if (!res.changed?.length) rows.push(dim('  (no output)'));
         say(box(rows));
       }
@@ -214,6 +259,9 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       say('  ' + cyan('/boost') + '    isolated git-worktree run: /boost <objective>');
       say('  ' + cyan('/config') + '   show provider config (key hidden)');
       say('  ' + cyan('/memory') + '   memory status, /memory on|off to toggle');
+      say('  ' + cyan('/status') + '   everything about this session at a glance');
+      say('  ' + cyan('/compact') + '  shrink the conversation into a checkpoint');
+      say('  ' + cyan('/depth') + '    answer depth: /depth short|normal|deep');
       say('  ' + cyan('/resume') + '   bring back a saved conversation');
       say('  ' + cyan('/skills') + '   list installed skills, /skills <name> shows one');
       say('  ' + cyan('/mcp') + '     list MCP servers and their tools');
@@ -310,6 +358,47 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
       busy = false;
       return afterTask();
     }
+    if (input === '/status') {
+      say(box([
+        bold('Status'),
+        dim('model') + '      ' + state.model,
+        dim('mode') + '       ' + mode + dim(' / reasoning ' + state.reasoning + ' / depth ' + state.explain),
+        dim('perms') + '       edit:' + state.permEdit + ' shell:' + state.permShell + ' net:' + state.permNet,
+        dim('memory') + '      ' + (state.memory === false ? 'off' : 'on (icm)'),
+        dim('humanizer') + '   ' + (state.humanize === false ? 'off' : 'on'),
+        dim('mcp') + '        ' + (mcpConfigured() ? 'configured' : 'not configured'),
+        dim('tokens') + '      ' + (usage.input || usage.output ? usage.input + ' in / ' + usage.output + ' out' : '-'),
+        dim('session') + '     ' + (sessionId ?? 'not saved yet'),
+        dim('cwd') + '        ' + process.cwd()
+      ]));
+      return;
+    }
+    if (input === '/compact') {
+      busy = true;
+      say(dim('   Compacting conversation...'));
+      const before = history.reduce((n, m) => n + (m.content?.length ?? 0) + 24, 0);
+      history = await compactHistory(state, history, { force: true, onNote: n => say(dim('  ◇ ' + n)) });
+      const after = history.reduce((n, m) => n + (m.content?.length ?? 0) + 24, 0);
+      say(after < before ? green(`   Compact: ${(before / 1024).toFixed(1)}k -> ${(after / 1024).toFixed(1)}k chars.`) : dim('   Conversation too small to compact further.'));
+      busy = false;
+      return afterTask();
+    }
+    if (input === '/depth' || input.startsWith('/depth ')) {
+      const arg = input.split(/\s+/)[1];
+      if (['short', 'normal', 'deep'].includes(arg)) {
+        Object.assign(state, normalize({ ...state, explain: arg }));
+        saveConfig(state);
+        say(green('Explanation depth: ' + arg));
+      } else {
+        say(box([
+          bold('Explanation depth'),
+          dim('/depth short') + '   results only',
+          dim('/depth normal') + ' what changed and why (default)',
+          dim('/depth deep') + '   reasoning, trade-offs, ruled-out paths'
+        ]));
+      }
+      return;
+    }
     if (input === '/humanizer' || input.startsWith('/humanizer ')) {
       const arg = input.split(/\s+/)[1];
       if (arg === 'on' || arg === 'off') {
@@ -452,7 +541,9 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   }
 
   const plainPrompt = () => {
-    rl.setPrompt(`\n[${mode}/${state.reasoning}] ${bold(green('ineed'))} ${green('❯')} `);
+    const branch = currentBranch(process.cwd());
+    const tok = usage.input || usage.output ? ` ${usage.output >= 1000 ? (usage.output / 1000).toFixed(1) + 'k' : usage.output} tok` : '';
+    rl.setPrompt(`\n[${mode}/${state.reasoning}] ${bold(green('ineed'))}${branch ? ' ' + gray('(' + branch + ')') : ''}${tok} ${green('❯')} `);
     rl.prompt();
   };
 
@@ -462,7 +553,7 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
           green(bold('Welcome to ineed!')),
           '  You are all set: any OpenAI-compatible provider, any folder.',
           '  Type what you want in normal language, for example:',
-          dim('    "buatkan landing page beranimasi di folder ini"'),
+          dim('    "create an animated landing page in this folder"'),
           dim('    "fix the failing tests and tell me what was wrong"'),
           dim('    "explain this repository like I am a beginner"'),
           '  ' + dim('Helpers: /help commands · /perm auto or safe · /model · /memory on|off')
@@ -509,9 +600,16 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
 
   function drawStatus() {
     const cols = process.stdout.columns || 80;
-    const left = ` ${bold(green('ineed'))} ${dim(`v${VERSION}`)}`;
+    const branch = currentBranch(process.cwd());
+    const ctxK = (history.reduce((n, m) => n + (m.content?.length ?? 0) + 24, 0) / 1024).toFixed(1) + 'k';
+    const tok = usage.input || usage.output ? ` ${dim(usage.output >= 1000 ? (usage.output / 1000).toFixed(1) + 'k' : usage.output + '')} tok` : '';
+    const left = ` ${bold(green('ineed'))} ${dim(`v${VERSION}`)}${branch ? ' ' + cyan('(' + branch + ')') : ''}`;
     const mid = ` ${dim(state.model)}`;
-    const right = ` ${mode === 'plan' ? yellow('plan') : green('build')} ${dim('/')} ${dim(state.reasoning)} ${dim('/')} ${state.memory === false ? dim('mem:off') : dim('mem:on')} `;
+    const right =
+      ` ${mode === 'plan' ? yellow('plan') : green('build')} ${dim('/')} ${dim(state.reasoning)}` +
+      ` ${dim('/')} ${dim(ctxK + ' ctx')}${tok}` +
+      ` ${dim('/')} ${dim('mem:' + (state.memory === false ? 'off' : 'on'))}` +
+      ` ${dim('/')} ${mode === 'plan' ? dim('perm') : state.permEdit === 'ask' ? green('perm:ask') : dim('perm:auto')} `;
     screen.at(statusRow, 1);
     screen.clearLine();
     process.stdout.write(dim('─'.repeat(Math.max(0, cols - plain(left).length - plain(mid).length - plain(right).length))) + left + mid + right);
@@ -539,10 +637,10 @@ export async function startSession(cfg, { fresh = false, resume = null } = {}) {
     redrawChat();
   }
 
-  function tuiUserLine(input) {
+  const tuiUserLine = input => {
     for (const l of wrapLines(userBubble(input), Math.max(10, (process.stdout.columns || 80) - 4))) chatLines.push(l);
     redrawChat();
-  }
+  };
 
   const layout = () => {
     const rows = process.stdout.rows || 24;

package/src/ui.js

@@ -1,6 +1,6 @@
 // ui.js: terminal helpers. No dependencies, respects NO_COLOR and non-TTY.
 
-export const VERSION = '1.4.0';
+export const VERSION = '1.5.1';
 
 const USE_COLOR = process.stdout.isTTY && !process.env.NO_COLOR;
 const wrap = (code, t) => USE_COLOR ? `\x1b[${code}m${t}\x1b[0m` : String(t);