ineedcodes 1.0.2 → 1.2.0

package/README.md

@@ -64,8 +64,12 @@ The agent decides what it needs: list files, read code, search, edit, run shell
 | `/plan` | read-only mode, the agent suggests but changes nothing |
 | `/build` | default mode, the agent makes real changes |
 | `/reason` | toggle reasoning effort low/high |
-| `/clear` | forget the current conversation |
+| `/perm` | permission modes: `/perm auto`, `/perm safe` |
+| `/memory` | durable memory status, `/memory on\|off` |
+| `/mcp` | list MCP servers and their tools |
 | `/setup` | redo provider setup |
+| `/config` | show provider config, API key hidden |
+| `/clear` | forget the current conversation |
 | `/exit` | quit |
 
 Shortcuts are optional. Normal language always works.
@@ -94,13 +98,42 @@ Not a chatbot that prints code. A loop that does the work, checks the results, a
 | `write_file` | create files |
 | `edit_file` | targeted patch, not a rewrite |
 | `delete_file` | remove a file |
+| `todo` | visible checklist for multi-step work |
+| `spawn_agent` | delegate to a focused sub-agent |
 | `shell` | build, test, install, git, anything |
 
+### Multi-agent
+
+Big tasks get delegated. The lead agent spawns workers with a role that fits:
+
+| role | can |
+|---|---|
+| `research` | read and report, nothing else, runs in parallel |
+| `review` | inspect code, report findings, runs in parallel |
+| `test` | run tests and commands, no source edits |
+| `implement` | make the change, verify it |
+| `debug` | find the root cause, fix it |
+
+Workers report back with status, summary, evidence, files changed, and commands run. The lead reconciles everything and answers you.
+
+### MCP (Model Context Protocol)
+
+Connect any MCP server and its tools appear in the agent automatically. Create `~/.ineedcodes/mcp.json`:
+
+```json
+{
+  "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] }
+}
+```
+
+Restart ineed, and every tool from that server is callable. Check what is loaded with `/mcp` inside a session.
+
 ### Safety
 
 - Secrets (.env, ssh keys, pem files) never enter the model context.
 - Destructive shell commands are refused.
 - Everything is jailed to your working directory.
+- Edits and shell commands ask for your approval first (`/perm auto` relaxes this).
 - Plan mode lets you preview intent before any change.
 
 ## Works with any provider

package/package.json

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

package/src/agent.js

@@ -4,6 +4,7 @@ import { chat } from './provider.js';
 import { TOOLS, runTool, shellRun, isDestructive } from './tools.js';
 import { trunc, gray, cyan, dim } from './ui.js';
 import { getMemoryProvider } from './memory.js';
+import * as path from 'node:path';
 
 export const MAX_STEPS = 30;
 export const MAX_HISTORY_CHARS = 30_000;
@@ -17,6 +18,8 @@ Rules:
 - Destructive commands are always blocked. Ask the user to run those themselves.
 - 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.
+- When building web pages or UI: commit to one coherent style; restrained palette (1 primary, 1 accent, neutral background); a real Google Fonts pairing; no emoji as icons (use inline SVG); cursor-pointer on clickables; visible focus states; text contrast at least 4.5:1; responsive at 375, 768, 1024, 1440px; respect prefers-reduced-motion; avoid generic AI purple/pink gradients and default template blue.
 - When the objective is done, verify it (run the tests, read the file back, whatever proves it), then reply with the final result in this shape:
   What changed, what you ran, the evidence you saw.`;
 
@@ -30,15 +33,106 @@ export function trimHistory(history) {
   return history.slice(start);
 }
 
-export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
+// ── multi-agent: roles, task packets, worker execution ──
+const ROLES = {
+  research: {
+    readonly: true,
+    tools: ['list_files', 'read_file', 'search_text', 'todo'],
+    prompt: 'You are a research worker. Gather facts and report them. Change nothing.'
+  },
+  review: {
+    readonly: true,
+    tools: ['list_files', 'read_file', 'search_text', 'todo'],
+    prompt: 'You are a review worker. Inspect the code for correctness, bugs, and quality. Report findings, change nothing.'
+  },
+  test: {
+    readonly: false,
+    tools: ['list_files', 'read_file', 'search_text', 'shell', 'todo'],
+    prompt: 'You are a test worker. Run the relevant tests or commands and report the evidence. Do not modify source files.'
+  },
+  implement: {
+    readonly: false,
+    tools: null, // all tools
+    prompt: 'You are an implementation worker. Make the change the lead asked for, verify it works, and report what you did.'
+  },
+  debug: {
+    readonly: false,
+    tools: null, // all tools
+    prompt: 'You are a debugging worker. Find the root cause, fix it if you can, and report cause plus evidence.'
+  }
+};
+
+let workerSeq = 0;
+
+function workerResultText(r) {
+  const files = r.files?.length ? ` files: ${r.files.join(', ')};` : '';
+  const cmds = r.commands?.length ? ` ran ${r.commands.length} command(s);` : '';
+  return `Worker ${r.id} [${r.status}]: ${String(r.summary).slice(0, 800)}.${files}${cmds}`;
+}
+
+async function runWorker(cfg, spec, cwd, depth, hooks) {
+  const roleName = ROLES[spec.input.role] ? spec.input.role : 'research';
+  const role = ROLES[roleName];
+  const objective = String(spec.input.objective ?? '')
+    + (spec.input.context ? `\nContext from lead agent: ${String(spec.input.context).slice(0, 1_000)}` : '');
+  try {
+    const res = await runObjective(cfg, objective, cwd, [], {}, {
+      depth: depth + 1,
+      toolFilter: role.tools,
+      worker: { id: spec.id, role: roleName, prompt: role.prompt }
+    });
+    return { id: spec.id, role: roleName, status: res.aborted ? 'incomplete' : 'completed', summary: res.answer || '(no output)', files: res.changed, commands: res.ran };
+  } catch (err) {
+    return { id: spec.id, role: roleName, status: 'failed', summary: err.message, files: [], commands: [] };
+  }
+}
+
+const SPAWN_TOOL = {
+  name: 'spawn_agent',
+  description: 'Spawn a focused sub-agent worker. Roles: research (read only), review (read only), test (runs commands, does not edit), implement (edits), debug (finds and fixes). Read-only workers can run in parallel.',
+  parameters: {
+    type: 'object',
+    properties: {
+      role: { type: 'string', enum: Object.keys(ROLES) },
+      objective: { type: 'string', description: 'the exact task for this worker' },
+      context: { type: 'string', description: 'relevant context: files, errors, constraints' }
+    },
+    required: ['role', 'objective']
+  },
+  allowedInPlan: true
+};
+
+export async function runObjective(cfg, objective, cwd, history, hooks = {}, extra = {}) {
   const ctrl = new AbortController();
   hooks.onRunStart?.(ctrl);
   const plan = cfg.mode === 'plan';
-  const tools = plan ? TOOLS.filter(t => t.allowedInPlan) : TOOLS;
+  const depth = extra.depth ?? 0;
+  let tools = plan ? TOOLS.filter(t => t.allowedInPlan) : [...TOOLS, SPAWN_TOOL];
+  if (extra.toolFilter) tools = tools.filter(t => (extra.toolFilter).includes(t.name));
   const canAsk = typeof hooks.onApprove === 'function';
 
+  // MCP: load configured servers once per top-level objective, expose their tools
+  let mcpManager = null;
+  const mcpMap = new Map();
+  if (depth === 0 && !plan && cfg.mcp !== false) {
+    try {
+      const { McpManager, mcpConfigured } = await import('./mcp.js');
+      if (mcpConfigured()) {
+        mcpManager = new McpManager();
+        const errors = await mcpManager.loadFromConfig();
+        errors.forEach(e => hooks.onText?.(dim(e)));
+        const mcpTools = await mcpManager.allTools();
+        const names = new Set(tools.map(t => t.name));
+        for (const t of mcpTools) {
+          if (!names.has(t.name)) { tools.push(t); mcpMap.set(t.name, t.mcp); names.add(t.name); }
+        }
+        hooks.onMCP?.(mcpTools.map(t => t.name));
+      }
+    } catch {}
+  }
+
   // recall durable memory before meaningful work (rule 12/15: MemoryProvider abstraction)
-  const memory = getMemoryProvider(cfg);
+  const memory = extra.skipMemory ? null : getMemoryProvider(cfg);
   let recalled = '';
   if (memory) {
     hooks.onMemoryStart?.();
@@ -46,10 +140,11 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
     hooks.onMemoryEnd?.(recalled);
   }
 
+  const workerPrefix = extra.worker ? `You are ${extra.worker.id} (${extra.worker.role} worker) spawned by the lead agent. ${extra.worker.prompt}\n` : '';
   const messages = [
     {
       role: 'system',
-      content: `${SYSTEM}\nWorking directory: ${cwd}\nMode: ${plan ? 'plan (read only, suggest what to change, do not change anything)' : 'build'}`
+      content: `${workerPrefix ? workerPrefix + '\n' : ''}${SYSTEM}\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}` : '')
     },
     ...trimHistory(history),
@@ -63,6 +158,16 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
   try {
     for (let step = 0; step < MAX_STEPS; step++) {
       if (ctrl.signal.aborted) break;
+      // steering: notes typed while the task runs join the conversation here
+      if (hooks.drainSteer) {
+        const steer = hooks.drainSteer();
+        if (steer.length) {
+          for (const s of steer) {
+            messages.push({ role: 'user', content: `[steer from the user, newer than the objective] ${s}` });
+          }
+          hooks.onSteer?.(steer);
+        }
+      }
       let msg;
       try {
         hooks.onThinkingStart?.();
@@ -89,12 +194,44 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
         }
         return { answer, changed: [...changed], ran, todos: [...todos], aborted: false };
       }
+      // spawn_agent pre-pass: read-only workers run in parallel (max 4), writers sequentially
+      const spawnResults = new Map();
+      const spawnCalls = calls.filter(c => c.function?.name === 'spawn_agent');
+      if (spawnCalls.length && depth === 0) {
+        const specs = spawnCalls.map(c => {
+          let input = {};
+          try { input = JSON.parse(c.function?.arguments || '{}'); } catch {}
+          const role = ROLES[input.role] ? input.role : 'research';
+          return { call: c, input, role, id: `${role}-${++workerSeq}` };
+        });
+        const runOne = async s => {
+          hooks.onAgentStart?.(s.id, s.input);
+          const r = await runWorker(cfg, s, cwd, depth, hooks);
+          hooks.onAgentEnd?.(s.id, r);
+          spawnResults.set(s.call.id, r);
+        };
+        const readonly = specs.filter(s => ROLES[s.role].readonly).slice(0, 4);
+        const writers = specs.filter(s => !ROLES[s.role].readonly);
+        for (let i = 0; i < readonly.length; i += 4) {
+          await Promise.all(readonly.slice(i, i + 4).map(runOne));
+        }
+        for (const s of writers) await runOne(s);
+      }
+
       for (const call of calls) {
         let input = {};
         try { input = JSON.parse(call.function?.arguments || '{}'); } catch {}
         hooks.onTool?.(call.function?.name, input);
         let result;
-        if (call.function?.name === 'shell') {
+        if (spawnResults.has(call.id)) {
+          result = { output: workerResultText(spawnResults.get(call.id)) };
+        } else if (call.function?.name === 'spawn_agent') {
+          result = { output: 'Refused: workers cannot spawn more agents.' };
+        } else if (mcpMap.has(call.function?.name)) {
+          const m = mcpMap.get(call.function?.name);
+          result = await mcpManager.call(m.server, m.tool, input);
+          hooks.onMCPResult?.(call.function?.name, result.output);
+        } 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 ?? ''))) {
             result = { output: 'Refused: that command is destructive. Run it yourself if you are sure.' };
@@ -112,7 +249,7 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
             ran.push(String(input.command ?? '').slice(0, 120));
           }
         } else {
-          if (plan && !TOOLS.find(t => t.name === call.function?.name)?.allowedInPlan) {
+          if (plan && !tools.find(t => t.name === call.function?.name)) {
             result = { output: 'Refused: plan mode is read only. Switch to build mode with /build.' };
           } else if (call.function?.name === 'todo') {
             const list = Array.isArray(input.todos) ? input.todos : [];
@@ -135,6 +272,15 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}) {
             if (allowedNow && !plan && isEdit
               && !/^(Refused|Error|Denied)/.test(String(result.output))) {
               changed.add(String(input.path ?? ''));
+              // humanizer pass: prose files only (html/md/txt), code never touched (rule 21)
+              if (name === 'write_file' && cfg.humanize !== false) {
+                const abs = path.resolve(cwd, String(input.path ?? ''));
+                try {
+                  const { humanizeFile } = await import('./humanize.js');
+                  const hr = await humanizeFile(cfg, abs, ctrl.signal, { skipModel: false });
+                  if (hr.changed) hooks.onNote?.(`humanized copy in ${String(input.path)}`);
+                } catch {}
+              }
             }
           }
         }

package/src/config.js

@@ -24,6 +24,8 @@ export function normalize(c) {
     reasoning: c.reasoning === 'high' ? 'high' : 'low',
     mode: c.mode === 'plan' ? 'plan' : 'build',
     memory: c.memory !== false,
+    mcp: c.mcp !== false,
+    humanize: c.humanize !== false,
     permEdit: c.permEdit === 'allow' ? 'allow' : 'ask',
     permShell: c.permShell === 'allow' ? 'allow' : 'ask'
   };

package/src/humanize.js

@@ -0,0 +1,139 @@
+// humanize.js: post-processing pass for prose content. Scope is strict:
+// it rewrites marketing/marketing-adjacent copy inside HTML pages and plain prose files
+// (landing pages, posts, README-style text). It never touches code, attributes, URLs,
+// JSON, YAML, or technical values. Meaning and facts are preserved.
+
+import * as fs from 'node:fs';
+import { chat } from './provider.js';
+
+const PROSE_EXT = new Set(['.html', '.htm', '.md', '.markdown', '.txt']);
+const CODE_EXT = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.json', '.yaml', '.yml', '.css', '.scss', '.py', '.rb', '.go', '.rs', '.java', '.php', '.sh', '.sql', '.toml', '.xml', '.svg']);
+
+export function isHumanizableFile(absPath) {
+  const ext = absPath.slice(absPath.lastIndexOf('.')).toLowerCase();
+  if (CODE_EXT.has(ext)) return false;
+  return PROSE_EXT.has(ext);
+}
+
+// Rule-based cleanups that are safe everywhere inside prose text nodes.
+const RULES = [
+  [/ ?\u2014 ?/g, ', '],
+  [/ ?\u2013 ?/g, ', '],
+  [/\bgame-?changer\b/gi, 'a real improvement'],
+  [/\bcutting-?edge\b/gi, 'new'],
+  [/\brevolutionar(y|ily)\b/gi, 'genuinely new'],
+  [/\bseamless(ly)?\b/gi, 'smooth'],
+  [/\bunlock(ing)? the (full )?potential\b/gi, 'get more out of it'],
+  [/\btake .{0,20} to the next level\b/gi, 'go further'],
+  [/\bdive (deep )?into\b/gi, 'look at'],
+  [/\blet.s (get )?started\b/gi, 'here is how'],
+  [/\bworld-?class\b/gi, 'top'],
+  [/\bblazing(ly)? (fast|quick)\b/gi, 'fast'],
+  [/\bwhisper-?quiet\b/gi, 'quiet'],
+  [/\bwe understand that\b/gi, ''],
+  [/\bin today.s (fast-?paced )?(digital|modern) world\b/gi, ''],
+  [/\blook no further\b/gi, ''],
+  [/\bdreams? (come|become) (true|reality)\b/gi, 'happens'],
+  [/\bempower(s|ing|ed)?\b/gi, 'help'],
+  [/\bcrucial|pivotal\b/gi, 'important'],
+  [/\bmost importantly,?/gi, ''],
+  [/!{2,}/g, '!']
+];
+
+function applyRules(text) {
+  let out = text;
+  for (const [re, to] of RULES) out = out.replace(re, to);
+  out = out.replace(/[ \t]{2,}/g, ' ');
+  out = out.replace(/ +([.,!?])/g, '$1');
+  out = out.replace(/ \n/g, '\n');
+  return out;
+}
+
+// Extract copy blocks from HTML: between > and < (text nodes). Tag names, attributes,
+// scripts, styles, and comments are left byte-identical.
+function humanizeHtmlTextNodes(html, fn) {
+  return html.replace(/(<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<!--[\s\S]*?-->)/gi, m => '\x00BLOCK' + Buffer.from(m).toString('base64') + '\x00')
+    .replace(/>([^<>]+)</g, (m, text) => {
+      if (!/[a-zA-Z]/.test(text)) return m;
+      const next = fn(text);
+      return next === text ? m : '>' + next + '<';
+    })
+    .replace(/\x00BLOCK([A-Za-z0-9+/=]+)\x00/g, (_, b64) => Buffer.from(b64, 'base64').toString());
+}
+
+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.`
+    : `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);
+  const out = String(msg.content ?? '').trim();
+  return out || text;
+}
+
+export async function humanizeFile(cfg, absPath, signal, hooks = {}) {
+  if (!isHumanizableFile(absPath)) return { changed: false, reason: 'not a prose file' };
+  let src;
+  try { src = fs.readFileSync(absPath, 'utf8'); } catch (err) { return { changed: false, reason: err.message }; }
+  if (src.length < 40) return { changed: false, reason: 'too short' };
+
+  const ext = absPath.slice(absPath.lastIndexOf('.')).toLowerCase();
+  const isHtml = ext === '.html' || ext === '.htm';
+  const kind = isHtml ? 'html' : 'text';
+
+  // step 1: deterministic rules
+  let next = isHtml
+    ? humanizeHtmlTextNodes(src, applyRules)
+    : applyRules(src);
+
+  // step 2: model pass (skipped in plan mode or when no hooks provide a provider)
+  const before = next;
+  if (cfg?.apiKey && !hooks.skipModel) {
+    try {
+      if (isHtml) {
+        next = humanizeHtmlTextNodes(next, t => t); // normalize markers once
+        const plain = next; // model sees text-node friendly form already
+        const rewritten = await humanizeWithModel(cfg, stripTagsForPrompt(plain), kind, signal);
+        // sanity: refuse junk replies (too short or structure-destroying)
+        const okLen = rewritten.length >= Math.max(20, plain.length * 0.4);
+        if (okLen) next = applyModelToTextNodes(next, rewritten);
+        else hooks.onNote?.('humanizer model pass skipped: reply looked wrong');
+      } else {
+        const rewritten = await humanizeWithModel(cfg, next, kind, signal);
+        if (rewritten.length >= Math.max(20, next.length * 0.4)) next = rewritten;
+        else hooks.onNote?.('humanizer model pass skipped: reply looked wrong');
+      }
+      // final sanitization: the model pass may reintroduce cliches or em dashes
+      next = isHtml ? humanizeHtmlTextNodes(next, applyRules) : applyRules(next);
+    } catch (err) {
+      hooks.onNote?.(`humanizer model pass skipped: ${err.message}`);
+    }
+  }
+
+  if (next !== src && next.trim()) {
+    fs.writeFileSync(absPath, next);
+    return { changed: true, before, after: next };
+  }
+  return { changed: false, reason: 'already clean' };
+}
+
+function stripTagsForPrompt(html) {
+  return html.replace(/<[^>]+>/g, '\n').replace(/\n{2,}/g, '\n').trim();
+}
+
+// Map model-rewritten plain text back onto HTML text nodes: greedy line pairing.
+// Structure is preserved; if pairing fails, the node text is left unchanged.
+function applyModelToTextNodes(html, modelText) {
+  const lines = modelText.split('\n').map(l => l.trim()).filter(Boolean);
+  let li = 0;
+  return html.replace(/>([^<>]+)</g, (m, text) => {
+    const trimmed = text.trim();
+    if (li < lines.length && /[a-zA-Z]/.test(trimmed) && trimmed.length > 2) {
+      const candidate = lines[li++];
+      if (candidate && candidate !== trimmed && candidate.length > 2) {
+        return '>' + text.replace(trimmed, candidate) + '<';
+      }
+    }
+    return m;
+  });
+}

package/src/mcp.js

@@ -0,0 +1,203 @@
+// mcp.js: minimal MCP client. Connects MCP servers over stdio using JSON-RPC 2.0,
+// lists their tools, and lets the agent call them like native tools.
+// Servers are configured in ~/.ineedcodes/mcp.json: { "name": { "command": "...", "args": ["..."] } }
+
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+export const MCP_CONFIG_FILE = process.env.INEED_MCP_CONFIG
+  || path.join(os.homedir(), '.ineedcodes', 'mcp.json');
+
+let nextId = 1;
+
+class McpServer {
+  constructor(name, spec) {
+    this.name = name;
+    this.spec = spec;
+    this.child = null;
+    this.buffer = '';
+    this.pending = new Map(); // id -> resolve
+    this.tools = [];
+    this.dead = false;
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let child;
+      try {
+        child = spawn(this.spec.command, this.spec.args ?? [], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env, NO_COLOR: '1' }
+        });
+      } catch (err) {
+        this.dead = true;
+        return reject(new Error(`cannot start MCP server ${this.name}: ${err.message}`));
+      }
+      this.child = child;
+      child.stdout.on('data', chunk => {
+        this.buffer += chunk.toString();
+        let idx;
+        while ((idx = this.buffer.indexOf('\n')) >= 0) {
+          const line = this.buffer.slice(0, idx).trim();
+          this.buffer = this.buffer.slice(idx + 1);
+          if (!line) continue;
+          let msg;
+          try { msg = JSON.parse(line); } catch { continue; }
+          if (msg.id && this.pending.has(msg.id)) {
+            const r = this.pending.get(msg.id);
+            this.pending.delete(msg.id);
+            r(msg);
+          }
+        }
+      });
+      child.stderr.on('data', () => {}); // servers log freely; never leaks into the model
+      child.on('error', err => {
+        this.dead = true;
+        if (!settled) { settled = true; reject(new Error(`MCP server ${this.name}: ${err.message}`)); }
+      });
+      child.on('close', code => {
+        this.dead = true;
+        for (const r of this.pending.values()) r({ error: { message: `MCP server ${this.name} exited (code ${code})` } });
+        this.pending.clear();
+      });
+      const fail = setTimeout(() => {
+        if (!settled) { settled = true; reject(new Error(`MCP server ${this.name} did not answer initialize (10s)`)); }
+      }, 10_000);
+      this.request('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: { name: 'ineed', version: '1.1.0' }
+      }).then(init => {
+        if (init.error) throw new Error(init.error.message ?? 'initialize failed');
+        this.notify('notifications/initialized', {});
+        clearTimeout(fail);
+        settled = true;
+        resolve(this);
+      }).catch(err => {
+        clearTimeout(fail);
+        settled = true;
+        this.kill();
+        reject(err);
+      });
+    });
+  }
+
+  request(method, params) {
+    if (this.dead) return Promise.resolve({ error: { message: `MCP server ${this.name} is not running` } });
+    const id = nextId++;
+    return new Promise(resolve => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve({ error: { message: `MCP server ${this.name} timed out on ${method}` } });
+      }, 60_000);
+      this.pending.set(id, msg => { clearTimeout(timer); resolve(msg); });
+      try {
+        this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        resolve({ error: { message: `MCP write failed: ${err.message}` } });
+      }
+    });
+  }
+
+  notify(method, params) {
+    try { this.child?.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n'); } catch {}
+  }
+
+  async listTools() {
+    const res = await this.request('tools/list', {});
+    if (res.error) return [];
+    this.tools = (res.result?.tools ?? []).map(t => ({
+      name: t.name,
+      description: t.description ?? '',
+      inputSchema: t.inputSchema ?? { type: 'object', properties: {} }
+    }));
+    return this.tools;
+  }
+
+  async callTool(name, args) {
+    const res = await this.request('tools/call', { name, arguments: args ?? {} });
+    if (res.error) return { output: `Error: MCP ${this.name}/${name}: ${res.error.message}` };
+    const parts = res.result?.content ?? [];
+    const text = parts.filter(p => p.type === 'text').map(p => p.text).join('\n');
+    return { output: (res.result?.isError ? 'Error: ' : '') + (text || '(empty result)') };
+  }
+
+  kill() {
+    this.dead = true;
+    try { this.child?.kill('SIGKILL'); } catch {}
+  }
+}
+
+export class McpManager {
+  constructor() {
+    this.servers = new Map();
+  }
+
+  async loadFromConfig() {
+    let cfg;
+    try { cfg = JSON.parse(fs.readFileSync(MCP_CONFIG_FILE, 'utf8')); } catch { return []; }
+    const errors = [];
+    for (const [name, spec] of Object.entries(cfg)) {
+      if (!spec?.command) { errors.push(`mcp: ${name} has no command`); continue; }
+      if (this.servers.has(name)) continue;
+      try {
+        const server = new McpServer(name, spec);
+        await server.start();
+        this.servers.set(name, server);
+      } catch (err) {
+        errors.push(err.message);
+      }
+    }
+    return errors;
+  }
+
+  // native-style tool descriptors, namespaced mcp_<server>_<tool>
+  async allTools() {
+    const out = [];
+    for (const [serverName, server] of this.servers) {
+      for (const t of await server.listTools()) {
+        out.push({
+          name: `mcp_${serverName}_${t.name}`.slice(0, 64).replace(/[^a-zA-Z0-9_]/g, '_'),
+          description: `[MCP ${serverName}] ${t.description}`.trim(),
+          parameters: jsonSchemaToParameters(t.inputSchema),
+          mcp: { server: serverName, tool: t.name },
+          allowedInPlan: false
+        });
+      }
+    }
+    return out;
+  }
+
+  hasTools() {
+    for (const s of this.servers.values()) if (!s.dead && s.tools.length) return true;
+    return this.servers.size > 0;
+  }
+
+  async call(serverName, toolName, args) {
+    const server = this.servers.get(serverName);
+    if (!server) return { output: `Error: unknown MCP server ${serverName}` };
+    if (server.dead) return { output: `Error: MCP server ${serverName} is not running` };
+    return server.callTool(toolName, args);
+  }
+
+  killAll() {
+    for (const s of this.servers.values()) s.kill();
+    this.servers.clear();
+  }
+}
+
+function jsonSchemaToParameters(schema) {
+  // OpenAI function parameters are JSON Schema; pass through with light sanitation
+  const s = schema && typeof schema === 'object' ? schema : { type: 'object' };
+  if (s.type !== 'object') return { type: 'object', properties: {} };
+  return { type: 'object', properties: s.properties ?? {}, required: s.required ?? [] };
+}
+
+export function mcpConfigured() {
+  try { return Object.keys(JSON.parse(fs.readFileSync(MCP_CONFIG_FILE, 'utf8'))).length > 0; } catch { return false; }
+}

package/src/session.js

@@ -8,6 +8,7 @@ import { fetchModels } from './provider.js';
 import { makeInput, bold, dim, red, green, yellow, cyan, gray, trunc, BANNER, logo, box, startSpinner, VERSION, RULE, userBubble, screen } from './ui.js';
 import { wizard } from './wizard.js';
 import { getMemoryProvider, ICMAdapter } from './memory.js';
+import { mcpConfigured } from './mcp.js';
 
 const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 
@@ -41,6 +42,7 @@ export async function startSession(cfg, { fresh = false } = {}) {
   let closed = false;
   const approved = new Set(); // session-wide "always allow" grants
   const pendingLines = [];
+  const steerQueue = [];      // notes typed while a task runs, injected mid-task
 
   const TUI = process.stdout.isTTY && !process.env.NO_COLOR;
 
@@ -99,11 +101,26 @@ export async function startSession(cfg, { fresh = false } = {}) {
           const mark = s => s === 'completed' ? green('✔') : s === 'in_progress' ? cyan('▸') : dim('○');
           say(box([bold('To-do'), ...list.map(t => '  ' + mark(t.status) + ' ' + t.content)]));
         },
+        onAgentStart: (id, input) => { stopSpinner(); say(cyan('  ◆ spawn ' + id) + gray(` role=${input.role ?? '?'} task=${trunc(String(input.objective ?? ''), 70)}`)); },
+        onAgentEnd: (id, r) => { stopSpinner(); 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 => { stopSpinner(); say(dim('  ◇ ' + note)); },
+        drainSteer: () => steerQueue.splice(0),
+        onSteer: list => { for (const s of list) say(yellow('  ↳ steer: ') + s); },
         onApprove: async (cat, name, input2) => {
           stopSpinner();
           say(yellow('  ⚠ approval needed') + ' ' + cyan(name) + gray(' ' + trunc(JSON.stringify(input2), 80)));
-          const a = await ask('     [y] once · [a] always for ' + cat + ' · [n] no: ');
+          const a = await ask('     [y] once · [a] this session · [s] always (save) · [n] no: ');
           const c = a.trim().toLowerCase();
+          if (c === 's' || c === 'save') {
+            approved.add(cat);
+            if (cat === 'edit') Object.assign(state, normalize({ ...state, permEdit: 'allow' }));
+            if (cat === 'shell') Object.assign(state, normalize({ ...state, permShell: 'allow' }));
+            saveConfig(state);
+            say(dim('     always allowed, saved to config. /perm safe to undo.'));
+            return 'always';
+          }
           if (c === 'a' || c === 'always') { approved.add(cat); say(dim('     always allowed for this session.')); return 'always'; }
           if (c === 'y' || c === 'yes') return true;
           say(dim('     denied.'));
@@ -138,6 +155,8 @@ export async function startSession(cfg, { fresh = false } = {}) {
 
   async function afterTask() {
     if (closed) return;
+    // notes typed near the end that never reached the model become follow-up tasks
+    if (steerQueue.length) pendingLines.unshift(...steerQueue.splice(0));
     if (TUI) { drawStatus(); scrollRegion(); return; }
     plainPrompt();
     while (!busy && !closed) {
@@ -156,9 +175,13 @@ export async function startSession(cfg, { fresh = false } = {}) {
       say('  ' + cyan('/perm') + '     permissions: /perm auto | /perm safe | /perm');
       say('  ' + cyan('/config') + '   show provider config (key hidden)');
       say('  ' + cyan('/memory') + '   memory status, /memory on|off to toggle');
+      say('  ' + cyan('/mcp') + '     list MCP servers and their tools');
+      say('  ' + cyan('/humanizer') + ' natural-writing pass for pages and posts (on/off)');
       say('  ' + cyan('/clear') + '    forget this conversation');
       say('  ' + cyan('/setup') + '    redo provider setup');
       say('  ' + cyan('/reset') + '    clear saved config');
+      say('  ' + cyan('/help') + '     this list. Type normally to work, steer mid-task anytime');
+      say(dim('  while a task runs: your text is a live steer, /stop cancels it'));
       say('  ' + cyan('/exit') + '     quit');
     },
     '/config': () => {
@@ -179,7 +202,12 @@ export async function startSession(cfg, { fresh = false } = {}) {
 
   async function handle(input) {
     if (!input) return;
-    if (busy) { pendingLines.push(input); return; }
+    if (busy) {
+      if (input === '/stop') { activeRun?.abort(); say(dim('  (stopping...')); return; }
+      if (input.startsWith('/')) { pendingLines.push(input); return; }
+      steerQueue.push(input);
+      return;
+    }
     if (['/exit', '/quit', 'exit', 'quit'].includes(input)) return doExit();
     if (input === '/help' || input === '?') return commands['/help']();
     if (input === '/config') return commands['/config']();
@@ -241,6 +269,47 @@ export async function startSession(cfg, { fresh = false } = {}) {
       busy = false;
       return afterTask();
     }
+    if (input === '/humanizer' || input.startsWith('/humanizer ')) {
+      const arg = input.split(/\s+/)[1];
+      if (arg === 'on' || arg === 'off') {
+        Object.assign(state, normalize({ ...state, humanize: arg === 'on' }));
+        saveConfig(state);
+        say(arg === 'on'
+          ? green('Humanizer: on') + dim(' - web pages and posts get a natural-writing pass after they are written.')
+          : yellow('Humanizer: off') + dim(' - files are written exactly as the model produces them.'));
+        return;
+      }
+      say(box([
+        bold('Humanizer') + dim('  ' + (state.humanize === false ? 'off' : 'on')),
+        dim('scope') + '      .html .htm .md .txt (web pages, posts, docs)',
+        dim('never touches') + '  code, tags, attributes, URLs, JSON, technical values',
+        dim('toggle') + '      /humanizer on | /humanizer off'
+      ]));
+      return;
+    }
+    if (input === '/mcp' || input === '/mcp reload') {
+      if (!mcpConfigured()) {
+        say(yellow('No MCP servers configured.') + dim(' Add them to ~/.ineedcodes/mcp.json, e.g.: {"context7":{"command":"npx","args":["-y","@upstash/context7-mcp"]}}'));
+        return;
+      }
+      busy = true;
+      try {
+        const { McpManager } = await import('./mcp.js');
+        const mgr = new McpManager();
+        const errors = await mgr.loadFromConfig();
+        for (const e of errors) say(red('  ✗ ' + e));
+        const tools = await mgr.allTools();
+        if (tools.length) {
+          say(green(`  ${mgr.servers.size} MCP server(s), ${tools.length} tool(s):`));
+          for (const t of tools) say('  ' + cyan(t.name) + gray(' ' + trunc(t.description, 90)));
+        } else if (!errors.length) {
+          say(yellow('  Servers connected but exposed no tools.'));
+        }
+        mgr.killAll();
+      } catch (err) { say(red('  ✗ ' + err.message)); }
+      busy = false;
+      return afterTask();
+    }
     if (input === '/setup' || input === '/reset') {
       clearConfig();
       say(dim('Config cleared. Running setup...'));

package/src/ui.js

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