ineedcodes 1.1.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ineedcodes",
-  "version": "1.1.0",
+  "version": "1.3.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.`;
 
@@ -155,6 +158,16 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
   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?.();
@@ -259,6 +272,15 @@ export async function runObjective(cfg, objective, cwd, history, hooks = {}, ext
             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/boost.js

@@ -0,0 +1,50 @@
+// boost.js: isolated execution in a git worktree (master prompt #19-20).
+// Work happens away from the user's tree; reconcile only after verification.
+
+import { spawnSync } from 'node:child_process';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+function git(args, cwd) {
+  const r = spawnSync('git', args, { cwd, encoding: 'utf8' });
+  return { ok: r.status === 0, out: ((r.stdout ?? '') + (r.stderr ?? '')).trim() };
+}
+
+export function boostAvailable(cwd) {
+  const inside = git(['rev-parse', '--is-inside-work-tree'], cwd);
+  return inside.ok && inside.out === 'true';
+}
+
+export function currentBranch(cwd) {
+  return git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd).out;
+}
+
+export function startBoost(cwd) {
+  const n = Date.now() % 1_000_000;
+  const dir = path.join(os.tmpdir(), 'ineed-boost-' + n);
+  const branch = 'ineed-boost-' + n;
+  const r = git(['worktree', 'add', '-b', branch, dir], cwd);
+  if (!r.ok) return { ok: false, error: r.out };
+  return { ok: true, dir, branch };
+}
+
+export function commitBoost(dir, message) {
+  git(['add', '-A'], dir);
+  const r = git(['commit', '-m', message, '--allow-empty'], dir);
+  return r.ok;
+}
+
+export function boostDiff(dir) {
+  const stat = git(['diff', 'HEAD~1', '--stat'], dir);
+  const files = git(['diff', 'HEAD~1', '--name-only'], dir);
+  return { stat: stat.out, files: files.out.split('\n').filter(Boolean) };
+}
+
+export function mergeBoost(cwd, branch) {
+  return git(['merge', '--no-edit', branch], cwd);
+}
+
+export function cleanupBoost(cwd, dir, branch) {
+  git(['worktree', 'remove', '--force', dir], cwd);
+  git(['branch', '-D', branch], cwd);
+}

package/src/cli.js

@@ -95,5 +95,12 @@ if (args.length > 0 && args[0] !== '--reset') {
   }
   const { startSession } = await import('./session.js');
   const wasFresh = fresh || process.env.INEED_FRESH === '1';
-  await startSession(cfg, { fresh: wasFresh });
+  let resumeHistory = null;
+  if (args[0] === '--resume' || args[0] === '-r') {
+    const { listSessions } = await import('./sessions.js');
+    const latest = listSessions()[0];
+    if (latest?.history?.length) { resumeHistory = latest.history; console.log(dim(`Resuming ${Math.floor(latest.history.length / 2)} turns.`)); }
+    else console.log(dim('No saved session found. Starting fresh.'));
+  }
+  await startSession(cfg, { fresh: wasFresh, resume: resumeHistory });
 }

package/src/config.js

@@ -6,6 +6,7 @@ import * as path from 'node:path';
 
 export const CONFIG_DIR = process.env.INEED_CONFIG_DIR || path.join(os.homedir(), '.ineedcodes');
 export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export { CONFIG_DIR as configDirPath };
 
 export function loadConfig() {
   try {
@@ -25,6 +26,7 @@ export function normalize(c) {
     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/session.js

@@ -8,10 +8,36 @@ 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 { saveSession, listSessions, loadSession } from './sessions.js';
+import * as boost from './boost.js';
 import { mcpConfigured } from './mcp.js';
 
 const plain = s => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 
+// Context compaction (master prompt #32): when the saved conversation grows past the
+// cap, summarize the oldest half into a factual checkpoint and drop the raw turns.
+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;
+  const cut = Math.floor(history.length / 2);
+  const old = history.slice(0, cut);
+  const rest = history.slice(cut);
+  const digest = old.map(m => `${m.role}: ${String(m.content ?? '').replaceAll('\n', ' ').slice(0, 160)}`).join('\n');
+  try {
+    const { chat } = await import('./provider.js');
+    const msg = await chat({ ...cfg, reasoning: 'low' }, [
+      { role: 'user', content: `Summarize this conversation into a factual checkpoint: goals, decisions, files touched, unresolved work. Max 12 lines. No prose flourish.\n---\n${digest.slice(0, 10_000)}` }
+    ]);
+    const summary = String(msg.content ?? '').trim();
+    if (summary.length > 20) {
+      hooks.onNote?.(`compacted ${cut} turns into a checkpoint (${(size / 1000).toFixed(0)}k -> ${((summary.length + rest.reduce((n, m) => n + (m.content?.length ?? 0) + 24, 0)) / 1000).toFixed(0)}k chars)`);
+      return [{ role: 'user', content: '[conversation checkpoint] ' + summary }, { role: 'assistant', content: 'Checkpoint noted. Continuing from there.' }, ...rest];
+    }
+  } catch {}
+  return history.slice(-10); // provider unavailable: keep the newest turns
+}
+
 function wrapLines(text, width) {
   const out = [];
   for (const raw of String(text).split('\n')) {
@@ -32,9 +58,9 @@ function wrapLines(text, width) {
   return out;
 }
 
-export async function startSession(cfg, { fresh = false } = {}) {
+export async function startSession(cfg, { fresh = false, resume = null } = {}) {
   const state = normalize(cfg);
-  let history = [];
+  let history = resume?.length ? [...resume] : [];
   let busy = false;
   let activeRun = null;
   let mode = state.mode;
@@ -42,8 +68,11 @@ 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;
+  let sessionId = null;
+  let lastBoost = null;
 
   // ONE readline, ONE line dispatcher for the whole session
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -78,48 +107,67 @@ export async function startSession(cfg, { fresh = false } = {}) {
     if (TUI) drawStatus();
   }
 
+  function hooksForRun(stopSpinner) {
+    let spinner = null;
+    const stop = () => { spinner?.stop(); spinner = null; };
+    return {
+      spinnerStop: stop,
+      onMemoryStart: () => { stop(); spinner = startSpinner('recalling memory'); },
+      onMemoryEnd: () => stop(),
+      onThinkingStart: () => { stop(); spinner = startSpinner('thinking'); },
+      onThinkingEnd: () => stop(),
+      onWorkStart: label => { stop(); spinner = startSpinner(label || 'working'); },
+      onWorkEnd: () => stop(),
+      onTool: (name, input2) => { stop(); say(cyan('  ● ' + name) + gray(' ' + trunc(JSON.stringify(input2), 90))); },
+      onResult: out => { say(gray('    ' + trunc(out, 110))); },
+      onText: t => { stop(); },
+      onTodos: list => {
+        stop();
+        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) => { stop(); say(cyan('  ◆ spawn ' + id) + gray(` role=${input.role ?? '?'} task=${trunc(String(input.objective ?? ''), 70)}`)); },
+      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),
+      onSteer: list => { for (const s of list) say(yellow('  ↳ steer: ') + s); },
+      onApprove: async (cat, name, input2) => {
+        stop();
+        say(yellow('  ⚠ approval needed') + ' ' + cyan(name) + gray(' ' + trunc(JSON.stringify(input2), 80)));
+        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.'));
+        return false;
+      },
+      approved,
+      onRunStart: c => { activeRun = c; },
+      onRunEnd: () => { activeRun = null; stop(); }
+    };
+  }
+
   async function runTask(input) {
     busy = true;
-    let lastStreamed = '';
     if (TUI) tuiUserLine(input);
-    let spinner = null;
-    const stopSpinner = () => { spinner?.stop(); spinner = null; };
+    const hooks = hooksForRun();
+    const stopSpinner = hooks.spinnerStop;
     try {
-      const res = await runObjective(state, input, process.cwd(), history, {
-        onMemoryStart: () => { stopSpinner(); spinner = startSpinner('recalling memory'); },
-        onMemoryEnd: () => stopSpinner(),
-        onThinkingStart: () => { stopSpinner(); spinner = startSpinner('thinking'); },
-        onThinkingEnd: () => stopSpinner(),
-        onWorkStart: label => { stopSpinner(); spinner = startSpinner(label || 'working'); },
-        onWorkEnd: () => stopSpinner(),
-        onTool: (name, input2) => { stopSpinner(); say(cyan('  ● ' + name) + gray(' ' + trunc(JSON.stringify(input2), 90))); },
-        onResult: out => { say(gray('    ' + trunc(out, 110))); },
-        onText: t => { stopSpinner(); lastStreamed = t; },
-        onTodos: list => {
-          stopSpinner();
-          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))); },
-        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 c = a.trim().toLowerCase();
-          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.'));
-          return false;
-        },
-        approved,
-        onRunStart: c => { activeRun = c; },
-        onRunEnd: () => { activeRun = null; stopSpinner(); }
-      });
+      const res = await runObjective(state, input, process.cwd(), history, hooks);
       history = pushTurn(history, input, res);
       stopSpinner();
+      try { history = await compactHistory(state, history, { onNote: n => say(dim('  ◇ ' + n)) }); } catch {}
+      try { sessionId = saveSession({ id: sessionId, cwd: process.cwd(), model: state.model, history }); } catch {}
       if (res.aborted) {
         say(yellow('  ■ Stopped') + dim(' - partly done. Ask me to continue.'));
       } else {
@@ -132,6 +180,7 @@ export async function startSession(cfg, { fresh = false } = {}) {
     } catch (err) {
       stopSpinner();
       history = pushTurn(history, input, { answer: '(task failed: ' + err.message + ')' });
+      try { sessionId = saveSession({ id: sessionId, cwd: process.cwd(), model: state.model, history }); } catch {}
       say(red('  ✗ ' + err.message) + dim('  context kept.'));
     } finally {
       busy = false;
@@ -143,6 +192,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) {
@@ -159,12 +210,17 @@ export async function startSession(cfg, { fresh = false } = {}) {
       say('  ' + cyan('/build') + '    build mode: real changes (default)');
       say('  ' + cyan('/reason') + '   toggle reasoning low/high');
       say('  ' + cyan('/perm') + '     permissions: /perm auto | /perm safe | /perm');
+      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('/resume') + '   bring back a saved conversation');
       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': () => {
@@ -185,7 +241,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']();
@@ -247,6 +308,95 @@ 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 === '/boost cancel') {
+      if (!lastBoost) { say(dim('No boost run to cancel.')); return; }
+      const { dir, branch } = lastBoost;
+      boost.cleanupBoost(process.cwd(), dir, branch);
+      lastBoost = null;
+      say(yellow('Boost worktree and branch removed.'));
+      return;
+    }
+    if (input === '/boost' || input.startsWith('/boost ')) {
+      const objective = input.slice(6).trim();
+      if (!objective) {
+        say(box([
+          bold('Boost') + dim('  isolated execution in a git worktree'),
+          dim('/boost <objective>') + '  run the task away from your tree, review, then merge',
+          dim('/boost cancel') + '        remove the last boost worktree'
+        ]));
+        return;
+      }
+      busy = true;
+      try {
+        if (!boost.boostAvailable(process.cwd())) { say(yellow('Boost needs a git repository (with a commit).')); return; }
+        const b = boost.startBoost(process.cwd());
+        if (!b.ok) { say(red('Boost failed: ' + b.error)); return; }
+        lastBoost = b;
+        say(cyan(`  ⚡ boost ${b.branch}`) + dim(` worktree at ${b.dir}`));
+        const res = await runObjective(state, objective, b.dir, [], { ...hooksForRun(), skipMemory: true });
+        say((res.aborted ? yellow('  ■ Stopped') : green('  ⚡ Boost task done')) + dim(` in ${b.branch}`));
+        boost.commitBoost(b.dir, 'boost: ' + objective.slice(0, 80));
+        const d = boost.boostDiff(b.dir);
+        if (d.files.length) {
+          say(box([bold('Boost changes'), ...d.files.map(f => '  ' + f)]));
+          const a = await ask(`   [y] merge into ${boost.currentBranch(process.cwd())} · [n] keep worktree: `);
+          if (/^y/i.test(a.trim())) {
+            const m = boost.mergeBoost(process.cwd(), b.branch);
+            if (m.ok) { say(green('Merged into your branch.')); boost.cleanupBoost(process.cwd(), b.dir, b.branch); lastBoost = null; }
+            else { say(red('Merge conflict, worktree kept: ' + m.out)); }
+          } else {
+            say(dim('Worktree kept: ' + b.dir + ' (' + b.branch + '). /boost cancel removes it.'));
+          }
+        } else {
+          say(dim('No file changes came out of the boost run.'));
+          boost.cleanupBoost(process.cwd(), b.dir, b.branch);
+          lastBoost = null;
+        }
+      } catch (err) {
+        say(red('  ✗ boost failed: ' + err.message));
+      } finally {
+        busy = false;
+        await afterTask();
+      }
+      return;
+    }
+    if (input === '/resume') {
+      busy = true;
+      const list = listSessions();
+      if (!list.length) { say(yellow('No saved sessions yet.')); busy = false; return afterTask(); }
+      list.slice(0, 5).forEach((s, i) => {
+        const first = String(s.history?.find(m => m.role === 'user')?.content ?? '').replaceAll('\n', ' ').slice(0, 70);
+        say(`   ${i + 1}. ${new Date(s.time).toLocaleString()} · ${Math.floor((s.history?.length ?? 0) / 2)} turns · ${first}`);
+      });
+      const pick = await ask('   Resume which? [1]: ');
+      const n = Number(pick) || 1;
+      const s = loadSession(list[n - 1]?.id);
+      if (s?.history?.length) {
+        history = s.history;
+        sessionId = s.id;
+        say(green(`Resumed ${Math.floor(s.history.length / 2)} turns. Continue where we left off.`));
+      } else say(red('Could not load that session.'));
+      busy = false;
+      return afterTask();
+    }
     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"]}}'));

package/src/sessions.js

@@ -0,0 +1,31 @@
+// sessions.js: session persistence. Conversation checkpoints live outside the repo,
+// under the config dir, so users can leave and resume work (master prompt #34).
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { CONFIG_DIR as configDirPath } from './config.js';
+const DIR = path.join(configDirPath, 'sessions');
+
+
+export function saveSession(data) {
+  fs.mkdirSync(DIR, { recursive: true });
+  const id = data.id || 's_' + Date.now();
+  fs.writeFileSync(path.join(DIR, id + '.json'), JSON.stringify({ ...data, id, time: Date.now() }, null, 2), { mode: 0o600 });
+  return id;
+}
+
+export function listSessions() {
+  try {
+    return fs.readdirSync(DIR)
+      .filter(f => f.endsWith('.json'))
+      .map(f => { try { return JSON.parse(fs.readFileSync(path.join(DIR, f), 'utf8')); } catch { return null; } })
+      .filter(Boolean)
+      .sort((a, b) => b.time - a.time)
+      .slice(0, 20);
+  } catch { return []; }
+}
+
+export function loadSession(id) {
+  if (!id) return null;
+  try { return JSON.parse(fs.readFileSync(path.join(DIR, id + '.json'), 'utf8')); } catch { return null; }
+}

package/src/ui.js

@@ -1,6 +1,6 @@
 // ui.js: terminal helpers. No dependencies, respects NO_COLOR and non-TTY.
 
-export const VERSION = '1.1.0';
+export const VERSION = '1.3.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);