@hncode/hncode 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hncode/hncode",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
   "type": "module",
   "main": "src/index.js",

package/src/agent-task.js

@@ -176,3 +176,81 @@ export function statusColor(status) {
   if (status === 'completed') return 'gray';
   return 'red';
 }
+
+// ---- background-task transcript card (mirrors kimi-code) --------------------
+// A background task reports its lifecycle as a one-line card in the transcript:
+//
+//     ● agent task completed in background (review the diff)
+//     ✗ bash task failed in background (npm test · exit 1)
+//
+// `phase` drives the bullet colour (started / completed / failed); `headline`
+// and the dim `detail` carry the rest. Ported from kimi-code's
+// formatBackgroundTaskTranscript (apps/kimi-code/src/tui/utils/background-task-status.ts)
+// so the two tools read the same way.
+
+const BG_DETAIL_MAX = 240;
+
+function bgTruncate(value) {
+  if (value === undefined || value === null) return undefined;
+  const collapsed = String(value).trim().replace(/\s+/g, ' ');
+  if (!collapsed) return undefined;
+  return collapsed.length <= BG_DETAIL_MAX ? collapsed : collapsed.slice(0, BG_DETAIL_MAX - 1) + '…';
+}
+
+export function backgroundTaskPhase(status) {
+  if (status === 'running') return 'started';
+  if (status === 'completed') return 'completed';
+  return 'failed';   // failed / timed_out / killed / lost
+}
+
+function bgSubject(kind) {
+  if (kind === 'agent') return 'agent task';
+  if (kind === 'question') return 'question task';
+  return 'bash task';
+}
+
+function bgHeadline(status, kind) {
+  const subject = bgSubject(kind);
+  switch (status) {
+    case 'running': return `${subject} started in background`;
+    case 'completed': return `${subject} completed in background`;
+    case 'failed': return `${subject} failed in background`;
+    case 'timed_out': return `${subject} timed out`;
+    case 'killed': return `${subject} stopped`;
+    case 'lost': return `${subject} lost`;
+    default: return `${subject} ${status}`;
+  }
+}
+
+function bgDetail(task) {
+  const parts = [];
+  const description = bgTruncate(task.description);
+  if (description !== undefined) parts.push(description);
+
+  if (task.status === 'completed' || task.status === 'failed') {
+    if (task.kind === 'process' && task.exitCode !== null && task.exitCode !== undefined) {
+      parts.push(`exit ${task.exitCode}`);
+    }
+  }
+  if (task.status === 'killed') {
+    const reason = bgTruncate(task.stopReason);
+    parts.push(reason !== undefined ? `stopped — ${reason}` : 'stopped');
+  }
+  if (task.status === 'failed') {
+    const reason = bgTruncate(task.stopReason);
+    if (reason !== undefined) parts.push(reason);
+  }
+  if (task.status === 'timed_out') parts.push('timed out');
+  if (task.status === 'lost') parts.push('session restarted before completion');
+
+  return parts.length ? parts.join(' · ') : undefined;
+}
+
+// Build the card payload for a task snapshot.
+export function backgroundTaskCard(task) {
+  return {
+    phase: backgroundTaskPhase(task.status),
+    headline: bgHeadline(task.status, task.kind),
+    detail: bgDetail(task),
+  };
+}

package/src/agent.js

@@ -24,20 +24,10 @@ function hashKey(s) {
   return h.toString(36) + '-' + str.length.toString(36);
 }
 
-// ---- completion guard --------------------------------------------------------
-// A turn is only complete when the model ends it with an actual answer. Models
-// do stop mid-task: the stream ends right after a reasoning block, or with an
-// empty assistant message, and the caller would report "done" for unfinished
-// work. When that happens we tell the model what it did and give it more steps.
-// Bounded, so a model that insists on stopping cannot loop forever.
-export const MAX_NUDGES = 5;
 
-export function nudgeMessage(why) {
-  return `[hncode] Your turn ended without a final answer: ${why}. `
-    + 'This usually means the task is not finished. If the work IS complete, reply with a short '
-    + 'summary of what changed and how you verified it. Otherwise keep going with the tools right '
-    + 'now — do not stop silently.';
-}
+// Final instruction appended to the system prompt (see SYSTEM_PROMPT).
+// (The wording lives in SYSTEM_PROMPT itself, under "Finishing a turn".)
+
 
 // Final instruction appended to the system prompt (see SYSTEM_PROMPT).
 // (The wording lives in SYSTEM_PROMPT itself, under "Finishing a turn".)
@@ -199,7 +189,6 @@ export class Agent {
     let toolCalls = [];
     let emittedEnd = false;
     let thought = '';
-    let nudges = 0;
     // decide whether running out of steps actually left the turn unfinished.
     let hadToolCallsOnFinalStep = false;
 
@@ -252,8 +241,6 @@ export class Agent {
     // No step cap: the loop runs until the model produces a final answer, the
     // user interrupts (Esc / Ctrl-C), or an error ends the turn. maxSteps is
     // kept only for callers that explicitly request a bound (0/undefined = none).
-    // Runaway safety comes from the completion guard (MAX_NUDGES) and the user's
-    // ability to interrupt, not from a fixed tool-round budget.
     const stepLimit = (this.maxSteps > 0) ? this.maxSteps : Infinity;
     for (let step = 0; step < stepLimit; step++) {
       // Process any steer messages collected during the previous step
@@ -278,36 +265,90 @@ export class Agent {
       // preserved rather than simply discarded.
       const maxCtx = this.cfg.maxContextTokens || 512000;
       let usedNow = estimateMessagesTokens(this.messages, this.cfg);
-      if (maxCtx > 0 && usedNow >= maxCtx * 0.85) {
+      if (this.cfg.autoCompact !== false && maxCtx > 0 && usedNow >= maxCtx * 0.85) {
         const before = usedNow;
         // SHELL HOOK: PreCompact — a chance to back up the transcript before the
         // older half is summarized away. Never blocks (the trim must go ahead).
         await runShellHooks(this.hookConfig, 'PreCompact',
           { tokens: usedNow, messages: this.messages }, this.cfg.workspace);
-        const keepN = Math.max(1, Math.ceil(this.messages.length * 0.2));
-        const keep = this.messages.slice(-keepN);
-        const dropped = this.messages.slice(0, this.messages.length - keepN);
-        this.messages = keep;
-        // Ask the model to summarize what was trimmed so far, then prepend it
-        // as a system message so the model retains the conversation arc.
+        // Tell the TUI the trim is under way. Summarizing is a full model
+        // round-trip, so without this the UI sat silent for seconds mid-turn
+        // with no sign anything was happening.
+        this.onEvent({ type: 'compacting', before: usedNow, keep: 0, dropped: 0 });
+        //
+        // ORDER: SUMMARIZE FIRST, THEN TRIM. The summary is generated from the
+        // FULL history so the summarizing model can see what just happened — the
+        // most recent exchange is what tells it what the session is doing now.
+        // Trimming first and summarizing the leftovers summarized only the OLD
+        // part and lost the information the summary needed most.
+        //
+        // The transcript fed to the summarizer is BOUNDED: the full history can
+        // itself exceed the window, in which case the call fails and the trim
+        // would drop everything with nothing to show for it. Keep the MOST RECENT
+        // messages within the budget — they carry the live state — and clip any
+        // single oversized message.
+        const SUMMARY_INPUT_CHARS = 120_000;
+        const perMsgCap = 8_000;
+        const summaryParts = [];
+        let summaryChars = 0;
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+          const m = this.messages[i];
+          const raw = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
+          const clipped = raw.length > perMsgCap ? raw.slice(0, perMsgCap) + '\n…[clipped]' : raw;
+          const line = `${m.role}: ${clipped}`;
+          if (summaryChars + line.length > SUMMARY_INPUT_CHARS) break;
+          summaryChars += line.length;
+          summaryParts.unshift(line);
+        }
         let summary = '';
-        if (dropped.length > 0) {
+        if (this.messages.length > 0) {
           const summaryPrompt = [
             { role: 'system', content: 'Summarize the conversation history that follows. Capture the user\'s goals, the key decisions made, files created/modified, and the current state of any ongoing work. Be concise but thorough.' },
-            ...dropped,
+            { role: 'user', content: summaryParts.join('\n\n') },
           ];
           const cfgCopy = { ...this.cfg, maxOutputTokens: Math.min(this.cfg.maxOutputTokens || 4096, 2048) };
           const llm = new LLM(cfgCopy);
           try { summary = await llm.requestText(summaryPrompt); } catch { summary = ''; }
-          if (summary) {
-            this.messages = [{
-              role: 'system',
-              content: `[hncode] Earlier conversation context was auto-compacted to stay within the context window. Summary of what was trimmed:\n\n${summary}`,
-            }, ...this.messages];
-          }
         }
+        // NOW trim. Keep under a TOKEN budget, not a message count: sizes vary by
+        // orders of magnitude (one Read result can dwarf fifty short turns), so a
+        // fixed 20%-of-messages slice could still leave the request above the
+        // threshold or throw away far more than needed. Walk backwards until the
+        // retained tail reaches ~30% of the window; always keep at least the last
+        // two so the newest exchange survives.
+        const keepBudget = Math.max(1, Math.floor(maxCtx * 0.3));
+        let keepFrom = this.messages.length;
+        let keptTokens = 0;
+        while (keepFrom > 0) {
+          const n = this.messages.length - keepFrom;   // already-kept count
+          if (n >= 2 && keptTokens >= keepBudget) break;
+          const cand = this.messages[keepFrom - 1];
+          const t = estimateMessagesTokens([cand], this.cfg) - estimateMessagesTokens([], this.cfg);
+          // Always take at least the last two messages, however big they are.
+          if (n >= 2 && keptTokens + t > keepBudget) break;
+          keptTokens += t;
+          keepFrom--;
+        }
+        // BOUNDARY FIX: never let the kept slice START on a `tool` message whose
+        // assistant(toolCalls) was dropped — most APIs reject a tool result with
+        // no preceding call. Pull the boundary back over any leading tool rows.
+        while (keepFrom > 0 && keepFrom < this.messages.length && this.messages[keepFrom].role === 'tool') {
+          keepFrom--;
+        }
+        const keep = this.messages.slice(keepFrom);
+        const droppedCount = keepFrom;
+        // Final shape: SUMMARY + the most recent messages.
+        // ALWAYS prepend a marker, even when summarization failed. Silently
+        // dropping history left the model (and the user) with no idea that context
+        // was lost; a one-line note makes the gap explicit.
+        this.messages = [{
+          role: 'system',
+          content: summary
+            ? `[hncode] Earlier conversation context was auto-compacted to stay within the context window. Summary of the conversation so far:\n\n${summary}`
+            : `[hncode] ${droppedCount} earlier message(s) were dropped to stay within the context window, and no summary could be generated. Their detail is no longer available.`,
+        }, ...keep];
         usedNow = estimateMessagesTokens(this.messages, this.cfg);
-        this.onEvent({ type: 'compacted', before, after: usedNow, kept: keepN });
+        this.onEvent({ type: 'compacted', before, after: usedNow, kept: keep.length });
       }
       // Live context gauge: report the estimated size of the request about to be
       // sent, so the TUI's context readout is refreshed at every step rather than
@@ -363,18 +404,8 @@ export class Agent {
         for (const msg of steers) this.messages.push({ role: 'user', content: msg });
         continue;
       } else if (!hasText) {
-        if (nudges < MAX_NUDGES) {
-          nudges++;
-          const why = thought.trim()
-            ? 'your last output was reasoning/thinking only, with no answer text'
-            : 'your final message was empty';
-          this.onEvent({ type: 'nudge', reason: why, attempt: nudges, max: MAX_NUDGES });
-          const last = this.messages[this.messages.length - 1];
-          const body = nudgeMessage(why);
-          if (last && last.role === 'user' && typeof last.content === 'string') last.content += '\n\n' + body;
-          else this.messages.push({ role: 'user', content: body });
-          continue;
-        }
+        // No tool calls and no answer text: the model stopped without saying
+        // anything. End the turn.
         break;
       } else {
         // The model produced its answer. A steer typed WHILE that answer was
@@ -512,7 +543,6 @@ export class Agent {
       this.onEvent({
         type: 'incomplete',
         reason: 'the step budget was exhausted while tools were still being called',
-        usedNudges: nudges,
       });
     }
     if (!emittedEnd && this.onEvent) this.onEvent({ type: 'done' });

package/src/config.js

@@ -286,6 +286,12 @@ const b = baseUrl.replace(/\/+$/, '');
     autoUpdate: process.env.HNCODE_AUTO_UPDATE
       ? /^(1|true|yes|on)$/i.test(process.env.HNCODE_AUTO_UPDATE)
       : (root.auto_update === true || root.auto_update === 'true'),
+    // AUTO-COMPACTION (/auto-compact): when true, the agent summarizes older
+    // history once a request reaches 85% of the model context. Default ON. Set
+    // `auto_compact = false` (or HNCODE_AUTO_COMPACT=0) to turn it off.
+    autoCompact: process.env.HNCODE_AUTO_COMPACT
+      ? /^(1|true|yes|on)$/i.test(process.env.HNCODE_AUTO_COMPACT)
+      : !(root.auto_compact === false || root.auto_compact === 'false'),
     // PROMPT CACHE (/cache): explicit cache breakpoints for long stable prefixes.
     // Default ON — it only ever adds provider-recognised markers, and an
     // unsupported field on a non-caching gateway is filtered out in cache.js.

package/src/git.js

@@ -329,4 +329,173 @@ export function statuslineInfo(cwd) {
     deletions: unstaged.deletions + staged.deletions,
     changed: unstaged.files + staged.files,
   };
-}
+}
+// ---- diff / log / push / stash / rebase -------------------------------------
+// Thin wrappers over `git` for the TUI's slash commands. Each returns
+// { ok, ... } and never throws, so a command handler can just print the result.
+
+// Working-tree diff. `staged` shows the index, `path` limits to one file.
+// `stat` returns only the summary line (cheap); otherwise the patch, bounded so a
+// huge change cannot flood the transcript.
+export function diffText(cwd, opts = {}) {
+  const args = ['diff'];
+  if (opts.staged) args.push('--cached');
+  const paths = opts.path ? [opts.path] : [];
+  if (opts.stat) args.push('--stat');
+  const r = runGit(paths.length ? args.concat(['--', ...paths]) : args, cwd);
+  if (!r.ok) return { ok: false, error: r.stderr.trim() || r.error || 'git diff failed', text: '' };
+  let text = r.stdout;
+  if (text.length > 200 * 1024) text = text.slice(0, 200 * 1024) + '\n... [diff truncated]';
+  return { ok: true, text, empty: !text.trim(), error: null };
+}
+
+// Commit history, one commit per line: `<short-sha> <date> <subject>`.
+// `count` defaults to 15; `path` limits to a file's history.
+export function logText(cwd, opts = {}) {
+  const n = Math.max(1, Math.min(500, Number(opts.count) || 15));
+  const args = ['log', `-${n}`, '--pretty=format:%h %ad %s', '--date=short'];
+  if (opts.path) args.push('--', opts.path);
+  const r = runGit(args, cwd);
+  if (!r.ok) return { ok: false, error: r.stderr.trim() || r.error || 'git log failed', text: '' };
+  return { ok: true, text: r.stdout.trim(), empty: !r.stdout.trim(), error: null };
+}
+
+// Push the current (or a named) branch. This is an OUTBOUND operation, so the
+// caller must have confirmed first. `setUpstream` adds -u when the branch has no
+// upstream yet. `force` is opt-in only.
+export function push(cwd, opts = {}) {
+  const branch = String(opts.branch || '').trim();
+  const remote = String(opts.remote || 'origin').trim();
+  const args = ['push'];
+  if (opts.setUpstream) args.push('-u');
+  if (opts.force) args.push('--force-with-lease');   // safer than --force
+  args.push(remote);
+  if (branch) args.push(branch);
+  const r = runGit(args, cwd, { timeoutMs: 120_000 });
+  if (!r.ok) return { ok: false, error: r.stderr.trim() || r.error || 'git push failed', output: r.stdout.trim() };
+  return { ok: true, output: (r.stdout + r.stderr).trim(), error: null };
+}
+
+// Does the branch have an upstream? Used to decide whether push needs -u.
+export function hasUpstream(cwd, branch) {
+  const b = branch || currentBranch(cwd);
+  if (!b) return false;
+  const r = runGit(['rev-parse', '--abbrev-ref', `${b}@{upstream}`], cwd);
+  return r.ok;
+}
+
+// Commits the local branch is ahead/behind its upstream, e.g. "ahead 2, behind 0".
+export function aheadBehind(cwd, branch) {
+  const b = branch || currentBranch(cwd);
+  if (!b) return '';
+  const r = runGit(['rev-list', '--left-right', '--count', `${b}...${b}@{upstream}`], cwd);
+  if (!r.ok) return '';
+  const [ahead, behind] = r.stdout.trim().split(/\s+/);
+  const parts = [];
+  if (Number(ahead)) parts.push(`ahead ${ahead}`);
+  if (Number(behind)) parts.push(`behind ${behind}`);
+  return parts.join(', ');
+}
+
+// ---- stash ------------------------------------------------------------------
+
+export function stashList(cwd) {
+  const r = runGit(['stash', 'list'], cwd);
+  return r.ok ? r.stdout.split('\n').filter(Boolean) : [];
+}
+
+export function stashPush(cwd, message) {
+  const args = ['stash', 'push'];
+  if (message) args.push('-m', String(message));
+  const r = runGit(args, cwd);
+  return r.ok ? { ok: true, output: r.stdout.trim(), error: null }
+    : { ok: false, error: r.stderr.trim() || r.error || 'git stash failed' };
+}
+
+export function stashPop(cwd) {
+  const r = runGit(['stash', 'pop'], cwd);
+  return r.ok ? { ok: true, output: r.stdout.trim(), error: null }
+    : { ok: false, error: r.stderr.trim() || r.error || 'git stash pop failed' };
+}
+
+// ---- rebase -----------------------------------------------------------------
+
+// Rebase the current branch onto `onto`. Returns the git output; on conflict the
+// caller shows git's own message (the user resolves it outside, or with a prompt).
+export function rebase(cwd, onto) {
+  const target = String(onto || '').trim();
+  if (!target) return { ok: false, error: 'a target branch is required' };
+  const r = runGit(['rebase', target], cwd, { timeoutMs: 120_000 });
+  if (!r.ok) return { ok: false, error: (r.stderr || r.stdout).trim() || 'git rebase failed' };
+  return { ok: true, output: r.stdout.trim(), error: null };
+}
+
+// ---- async variants (never block the event loop) ----------------------------
+// `runGit` uses spawnSync: on the STARTUP path that freezes the TUI before its
+// first paint, and a cold `git` was measured at ~80-100ms per call (×4 calls).
+// The async form below runs the same command off the main thread, so the frame
+// draws immediately and the badge fills in when the data arrives.
+
+export function runGitAsync(args, cwd, opts = {}) {
+  return new Promise((resolve) => {
+    let child;
+    const timeout = opts.timeoutMs || 30_000;
+    try {
+      child = cp.spawn('git', [...GIT_ENV, ...args], {
+        cwd: cwd || process.cwd(),
+        windowsHide: true,
+        env: { ...process.env, LC_ALL: 'C.UTF-8', LANG: 'C.UTF-8' },
+      });
+    } catch (e) {
+      resolve({ ok: false, stdout: '', stderr: '', code: null, error: e.message });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let done = false;
+    const finish = (r) => { if (!done) { done = true; clearTimeout(timer); resolve(r); } };
+    const timer = setTimeout(() => {
+      try { child.kill(); } catch {}
+      finish({ ok: false, stdout: '', stderr: '', code: null, error: 'git timed out' });
+    }, timeout);
+    if (child.stdout) child.stdout.on('data', (d) => { stdout += d.toString('utf8'); });
+    if (child.stderr) child.stderr.on('data', (d) => { stderr += d.toString('utf8'); });
+    child.on('error', (e) => finish({ ok: false, stdout: '', stderr: '', code: null, error: e.message }));
+    child.on('close', (code) => finish({ ok: code === 0, stdout, stderr, code, error: null }));
+  });
+}
+
+// Async twin of statuslineInfo(). Same shape, same parser — only the four git
+// invocations are concurrent instead of blocking. Each sub-call fails soft, so a
+// non-repo (or a missing git) yields null exactly like the sync version.
+export async function statuslineInfoAsync(cwd) {
+  const inside = await runGitAsync(['rev-parse', '--is-inside-work-tree'], cwd);
+  if (!inside.ok) return null;
+
+  const stat = async (args) => {
+    const r = await runGitAsync(['diff', ...args, '--shortstat'], cwd);
+    if (!r.ok) return { files: 0, insertions: 0, deletions: 0 };
+    const s = r.stdout.trim();
+    const files = /(\d+) files? changed/.exec(s);
+    const ins = /(\d+) insertions?\(\+\)/.exec(s);
+    const del = /(\d+) deletions?\(-\)/.exec(s);
+    return {
+      files: files ? Number(files[1]) : 0,
+      insertions: ins ? Number(ins[1]) : 0,
+      deletions: del ? Number(del[1]) : 0,
+    };
+  };
+
+  const [branchRes, unstaged, staged] = await Promise.all([
+    runGitAsync(['rev-parse', '--abbrev-ref', 'HEAD'], cwd),
+    stat([]),
+    stat(['--cached']),
+  ]);
+  const branch = branchRes.ok ? branchRes.stdout.trim() : '';
+  return {
+    branch: branch || '',
+    insertions: unstaged.insertions + staged.insertions,
+    deletions: unstaged.deletions + staged.deletions,
+    changed: unstaged.files + staged.files,
+  };
+}

package/src/index.js

@@ -356,35 +356,46 @@ export async function main(argv) {
     await loadPlugins(cfg.pluginDir);
   }
 
-  // Connect configured MCP servers and register their tools, so a headless
-  // `-p` run and the TUI both see them. Failures are reported but never fatal:
-  // an unreachable server must not stop the session from starting.
-  if (cfg.mcp !== false) {
+  // Connect configured MCP servers and register their tools.
+  //
+  // This is a FUNCTION rather than an inline block because the two modes want
+  // different timing:
+  //   * headless (`-p`) MUST wait — the prompt runs immediately and its model
+  //     request has to see the MCP tools in the tool list.
+  //   * the TUI must NOT wait — connecting can take seconds (8s per wedged
+  //     server), and blocking the first paint for that is unacceptable. The TUI
+  //     starts this in the background and reports the result as a notice.
+  // Failures are reported but never fatal: an unreachable server must not stop
+  // the session from starting.
+  const connectMcp = async () => {
+    if (cfg.mcp === false) return { servers: [], toolCount: 0 };
     try {
       const mcp = await import('./mcp.js');
       const { API } = await import('./plugin.js');
       const mcpCfg = mcp.loadMcpConfig(cfg.workspace);
-      if (Object.keys(mcpCfg.servers).length) {
-        const res = await mcp.connectAll(mcpCfg, (spec) => API.registerTool(spec));
-        mcp.setLiveConnections(res.servers);
-        if (process.env.HNCODE_MCP_VERBOSE === '1') {
-          for (const s of res.servers) {
-            console.error(s.ok ? `[hncode-mcp] ${s.name}: ${s.toolCount} tool(s)` : `[hncode-mcp] ${s.name}: ${s.error}`);
-          }
+      if (!Object.keys(mcpCfg.servers).length) return { servers: [], toolCount: 0 };
+      const res = await mcp.connectAll(mcpCfg, (spec) => API.registerTool(spec));
+      mcp.setLiveConnections(res.servers);
+      if (process.env.HNCODE_MCP_VERBOSE === '1') {
+        for (const s of res.servers) {
+          console.error(s.ok ? `[hncode-mcp] ${s.name}: ${s.toolCount} tool(s)` : `[hncode-mcp] ${s.name}: ${s.error}`);
         }
       }
+      return res;
     } catch (e) {
       console.error(`hncode: MCP setup failed: ${e.message}`);
+      return { servers: [], toolCount: 0 };
     }
-  }
+  };
 
-  // headless prompt
+  // headless prompt: MCP must be live BEFORE the request goes out.
   if (args.prompt) {
     const format = args['output-format'];
     if (!isValidFormat(format)) {
       console.error(`hncode: unknown --output-format "${format}". Use one of: ${FORMATS.join(', ')}.`);
       return EXIT.CONFIG;
     }
+    await connectMcp();
     let session = null;
     if (args.session) session = typeof args.session === 'string' ? sess.loadSession(args.session) : sess.latestSession(undefined, undefined, { skipEmpty: true });
     else if (args.continue) session = sess.latestSession(undefined, undefined, { skipEmpty: true });
@@ -408,6 +419,9 @@ export async function main(argv) {
     // Remote control: expose a local socket so a script can queue a prompt or
     // query status on the running session (see ci.js).
     control: args.control === true ? '' : (typeof args.control === 'string' ? args.control : null),
+    // MCP runs in the BACKGROUND once the TUI is up (see startTUI): connecting
+    // can take seconds and must not delay the first paint.
+    mcpConnect: connectMcp,
     session: loadOrCreateSession(args, cfg),
   };
   await startTui(opts);

package/src/mcp.js

@@ -32,6 +32,11 @@ import cp from 'node:child_process';
 export const PROTOCOL_VERSION = '2024-11-05';
 export const CLIENT_INFO = { name: 'hncode', version: '0.3.1' };
 
+// How long a server gets to complete the initialize + tools/list handshake. This
+// runs BEFORE the TUI opens, so it is deliberately short: a wedged server should
+// cost a few seconds, not the 30s a tool call is allowed.
+export const CONNECT_TIMEOUT_MS = 8_000;
+
 // Live connections made at startup, shared by every consumer of the MCP client
 // (the CLI startup and the TUI's /mcp). Kept in this module rather than passed
 // around so the status view can always see the real state.
@@ -222,7 +227,10 @@ export function parseSseForId(body, id) {
 // Connect to one server, handshake, and list its tools.
 // Returns { ok, tools, error, serverInfo, transport, isHttp } — never throws.
 export async function connectServer(name, def, opts = {}) {
-  const timeoutMs = opts.timeoutMs || 30_000;
+  // CONNECT_TIMEOUT (not the 30s tool-call timeout): this runs during startup, so
+  // a wedged server must not hold the session hostage. 8s is generous for a
+  // handshake while keeping a dead server's cost to single-digit seconds.
+  const timeoutMs = opts.timeoutMs || CONNECT_TIMEOUT_MS;
   let transport;
   const isHttp = !!def.url;
   try {
@@ -314,16 +322,15 @@ export function toHncodeSpec(server, tool, transport, isHttp) {
 // Connect every configured server and register its tools through the plugin API.
 // Returns { servers: [...], toolCount }.
 export async function connectAll(config, registerTool, opts = {}) {
-  const servers = [];
-  let toolCount = 0;
   const only = opts.only;
-  for (const [name, def] of Object.entries((config && config.servers) || {})) {
-    if (only && !only.includes(name)) continue;
+  const entries = Object.entries((config && config.servers) || {}).filter(([name]) => !only || only.includes(name));
+  // Connect in PARALLEL. This runs on the startup path, before the TUI opens, so
+  // a serial loop meant one slow/wedged server delayed every later one — N dead
+  // servers cost N × timeout before the user saw anything. Runs concurrently, the
+  // whole set costs the SLOWEST single server instead of their sum.
+  const results = await Promise.all(entries.map(async ([name, def]) => {
     const conn = await connectServer(name, def, opts);
-    if (!conn.ok) {
-      servers.push({ name, ok: false, toolCount: 0, error: conn.error, serverInfo: {} });
-      continue;
-    }
+    if (!conn.ok) return { name, ok: false, toolCount: 0, error: conn.error, serverInfo: {} };
     let registered = 0;
     let err = null;
     for (const tool of conn.tools) {
@@ -336,11 +343,12 @@ export async function connectAll(config, registerTool, opts = {}) {
         err = err || `tool "${tool.name}": ${e.message}`;
       }
     }
-    toolCount += registered;
-    servers.push({ name, ok: true, toolCount: registered, error: err, serverInfo: conn.serverInfo, transport: conn.transport, isHttp: conn.isHttp });
-  }
-  return { servers, toolCount };
+    return { name, ok: true, toolCount: registered, error: err, serverInfo: conn.serverInfo, transport: conn.transport, isHttp: conn.isHttp };
+  }));
+  const toolCount = results.reduce((n, r) => n + (r.toolCount || 0), 0);
+  return { servers: results, toolCount };
 }
+// Disconnect every connected server (kills stdio children). HTTP needs nothing.
 
 // Disconnect every connected server (kills stdio children). HTTP needs nothing.
 export function disconnectAll(connections) {

package/src/tui.js

@@ -34,7 +34,7 @@ import * as upd from './update.js';
 import { renderTasksBrowser, handleTasksBrowserKey, visibleTasks } from './tasks-browser.js';
 import { renderTaskOutputViewer, handleViewerKey, makeViewerState } from './task-output-viewer.js';
 import { renderSwarmProgress } from './swarm-progress.js';
-import { sortedTasks, getTask, settleTask, STATUS_LABEL } from './agent-task.js';
+import { sortedTasks, getTask, settleTask, STATUS_LABEL, backgroundTaskCard } from './agent-task.js';
 import { localVersion } from './version.js';
 import { listSkills, readSkill, importSkill, deleteSkill, skillPrompt, skillCompletions, normalizeSkillName, SKILL_PREFIX, skillsDir } from './skills.js';
 import { loadHooks, describeHooks, runShellHooks, HOOK_EVENTS } from './hooks.js';
@@ -97,11 +97,18 @@ export const COMMANDS = [
   { name: 'branch', desc: 'List, create, or switch git branches', priority: 62, argumentHint: '[list | <name> | -c <name>]' },
   { name: 'worktree', desc: 'List, add, or remove git worktrees for parallel work', priority: 60, argumentHint: '[list | add <dir> [branch] | remove <dir>]' },
   { name: 'pr', desc: 'Show the URL to open a pull request for the current branch', priority: 60, argumentHint: '[base]' },
+  { name: 'add', aliases: ['stage'], desc: 'Stage changes (all by default, or given paths)', priority: 62, argumentHint: '[<path> ...]' },
+  { name: 'diff', desc: 'Show uncommitted changes', priority: 62, argumentHint: '[--staged] [<path>]' },
+  { name: 'log', desc: 'Show recent commits', priority: 62, argumentHint: '[count] [<path>]' },
+  { name: 'push', desc: 'Push the current branch (asks first)', priority: 62, argumentHint: '[branch] [-f]' },
+  { name: 'stash', desc: 'Stash changes: list / push / pop', priority: 60, argumentHint: '[list | push [msg] | pop]' },
+  { name: 'rebase', desc: 'Rebase the current branch onto another (asks first)', priority: 60, argumentHint: '<branch>' },
   { name: 'cache', desc: 'Toggle prompt caching for long stable prefixes (saves input tokens)', priority: 58, argumentHint: '[on|off]' },
   { name: 'logout', aliases: ['disconnect'], desc: 'Log out of a configured provider', priority: 40 },
   { name: 'feedback', aliases: ['bug'], desc: 'Send feedback to the maintainers', priority: 60 },
   { name: 'update', desc: 'Check for and install a newer version', priority: 40, argumentHint: '[-y]' },
   { name: 'auto-update', desc: 'Toggle automatic background updates (check at startup + every 30 min)', priority: 40, argumentHint: '[on|off]' },
+  { name: 'auto-compact', aliases: ['autocompact'], desc: 'Toggle automatic context compaction at 85% of the window', priority: 40, argumentHint: '[on|off]' },
   { name: 'version', desc: 'Show version information', priority: 20 },
   { name: 'exit', aliases: ['quit', 'q'], desc: 'Exit the application', priority: 20 },
 ].sort((a, b) => (b.priority || 0) - (a.priority || 0) || a.name.localeCompare(b.name));
@@ -1561,6 +1568,37 @@ function messageLines(msg, width, workspace, expanded, spin, pulseStart) {
     return out;
   }
 
+  // A BACKGROUND TASK lifecycle card (kimi-style):
+  //     ● agent task completed in background (review the diff)
+  //     ✗ bash task failed in background (npm test · exit 1)
+  // The bullet is `●` normally and `✗` for a failure; the colour follows the
+  // phase. The task's conclusion sits underneath, indented, and is capped like
+  // a tool result so one chatty subagent cannot flood the transcript.
+  if (msg.role === 'bg_task') {
+    const card = msg.card || { phase: 'completed', headline: 'background task finished', detail: undefined };
+    const tone = card.phase === 'started' ? C.cyan : card.phase === 'completed' ? C.green : C.red;
+    const bullet = card.phase === 'failed' ? '✗ ' : '● ';
+    const out = [];
+    const detail = card.detail ? col(` (${card.detail})`, C.gray) : '';
+    out.push({ text: col(bullet, tone) + col(card.headline, tone) + detail, ind: '', raw: true });
+    const body = String(msg.text || '').trim();
+    if (body) {
+      const indent = '  ';
+      const avail = Math.max(1, width - visualCol(indent));
+      const lines = body.replace(/\r\n/g, '\n').split('\n');
+      const MAX = expanded ? 200 : 6;
+      for (const ln of lines.slice(0, MAX)) {
+        for (const w of (ln === '' ? [''] : wrapWords(ln, avail))) {
+          out.push({ text: col(w, C.gray), ind: indent, raw: true });
+        }
+      }
+      if (lines.length > MAX) {
+        out.push({ text: col(`… ${lines.length - MAX} more lines, ctrl+o to expand`, C.gray), ind: indent, raw: true });
+      }
+    }
+    return out;
+  }
+
   // Tool output: a single "↳ " marker on the first line, then the output
   // indented by 2 columns. Long output is capped (kimi caps result previews
   // too) so one command cannot flood the whole transcript.
@@ -2607,11 +2645,22 @@ export function refreshGitInfo(state, opts = {}) {
   if (!force && state.running) return;
   state._gitCwd = cwd;
   state._gitAt = now;
-  try {
-    state._gitInfo = gitmod.statuslineInfo(cwd);
-  } catch {
-    state._gitInfo = null;   // a git failure must never break rendering
-  }
+  // ASYNC: does not block the caller. On the startup path this is what lets the
+  // first frame draw immediately — the badge appears a moment later when git
+  // answers, instead of freezing the TUI behind four spawnSync calls. `seq`
+  // discards a stale reply if another refresh started while this one ran.
+  const seq = (state._gitSeq = (state._gitSeq || 0) + 1);
+  gitmod.statuslineInfoAsync(cwd)
+    .then((info) => {
+      if (state._gitSeq !== seq) return;      // superseded by a newer refresh
+      state._gitInfo = info;
+      if (typeof state._requestRender === 'function') state._requestRender();
+    })
+    .catch(() => {
+      if (state._gitSeq !== seq) return;
+      state._gitInfo = null;   // a git failure must never break rendering
+      if (typeof state._requestRender === 'function') state._requestRender();
+    });
 }
 
 // ---- pure frame composer (no TTY side effects) ----
@@ -3987,7 +4036,8 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
           { label: 'provider', sub: 'manage AI providers' },
           { label: 'statusline', sub: 'configure status line items' },
           { label: 'add-dir', sub: 'add an additional workspace directory' },
-          { label: 'auto-update', sub: 'check npm for updates at startup + every 30 min' },
+          { label: 'auto-update', sub: `check npm for updates at startup + every 30 min — currently ${cfg.autoUpdate ? 'on' : 'off'}` },
+          { label: 'auto-compact', sub: `summarize older history at 85% of the window — currently ${cfg.autoCompact === false ? 'off' : 'on'}` },
         ],
         onPick: (it) => { dispatch(it.label, '', state, cfg, session, h, submit, stdout); return true; },
       });
@@ -4858,6 +4908,22 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
         : 'Auto-update OFF');
       return;
     }
+    case 'auto-compact': {
+      // Toggle /auto-compact. Persists to config.toml so it survives restarts.
+      const a = raw.toLowerCase();
+      let want;
+      if (a === 'on') want = true;
+      else if (a === 'off') want = false;
+      else want = cfg.autoCompact === false;   // flip from the current state
+      try { setConfigString('auto_compact', want ? 'true' : 'false'); }
+      catch (e) { appErr('Could not write config.toml: ' + e.message); return; }
+      cfg.autoCompact = want;
+      cfg.raw.auto_compact = want;
+      app(want
+        ? 'Auto-compaction ON — older history is summarized once a request reaches 85% of the context window'
+        : 'Auto-compaction OFF — history is no longer trimmed automatically (use /compact manually)');
+      return;
+    }
     case 'update': {
       // Manual update check. This is the ONLY place an update is ever reported;
       // the automatic background check stays completely silent.
@@ -4928,28 +4994,35 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
     case 'statusline':
       openPicker({
         title: 'Status line items',
-        items: [
-          { label: 'permission mode', kind: 'toggle', isOn: state.slMode !== false },
-          { label: 'model name', kind: 'toggle', isOn: state.slModel !== false },
-          { label: 'thinking effort', kind: 'toggle', isOn: state.slEffort !== false },
-          { label: 'current directory', kind: 'toggle', isOn: state.slCwd !== false },
-          { label: 'git branch & diff', kind: 'toggle', isOn: state.slGit !== false },
-          { label: 'background tasks', kind: 'toggle', isOn: state.slTasks !== false },
-          { label: 'rotating tips', kind: 'toggle', isOn: state.slTips !== false },
-        ],
+        items: (() => {
+          // `sub` must be set here, not only in onPick: the picker renders
+          // item.sub, so without an initial value every toggle showed a blank
+          // state until the user toggled it once.
+          const toggles = [
+            ['permission mode', 'slMode'],
+            ['model name', 'slModel'],
+            ['thinking effort', 'slEffort'],
+            ['current directory', 'slCwd'],
+            ['git branch & diff', 'slGit'],
+            ['background tasks', 'slTasks'],
+            ['rotating tips', 'slTips'],
+          ];
+          return toggles.map(([label, key]) => {
+            const isOn = state[key] !== false;
+            return { label, key, kind: 'toggle', isOn, sub: isOn ? 'on' : 'off' };
+          });
+        })(),
         hint: '↑↓ navigate · Enter toggle · Esc close',
         onPick: (it) => {
           it.isOn = !it.isOn;
           it.sub = it.isOn ? 'on' : 'off';
-          const key = { 'permission mode': 'slMode', 'model name': 'slModel', 'thinking effort': 'slEffort', 'current directory': 'slCwd', 'git branch & diff': 'slGit', 'background tasks': 'slTasks', 'rotating tips': 'slTips' }[it.label];
-          state[key] = it.isOn;
-          if (key === 'slGit') refreshGitInfo(state, { force: true });
+          state[it.key] = it.isOn;
+          if (it.key === 'slGit') refreshGitInfo(state, { force: true });
           app(`Status line: ${it.label} → ${it.isOn ? 'shown' : 'hidden'}`);
           return false;
         },
       });
       return;
-
     case 'export-md': {
       const msgs = session.messages || [];
       if (!msgs.length) { appErr('Nothing to export (empty session).'); return; }
@@ -5220,6 +5293,122 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
       h.openPanel('hncode — git', lines);
       return;
     }
+    case 'add': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      // `/add` stages everything (`git add -A`); `/add <path> ...` stages just
+      // those paths. This is the explicit staging step /commit does implicitly.
+      const paths = raw.split(/\s+/).filter(Boolean);
+      const r = gitmod.stage(paths, cwd);
+      if (!r.ok) { appErr(`git add failed: ${r.error}`); return; }
+      const staged = gitmod.stagedFiles(cwd);
+      app(paths.length ? `Staged ${paths.length} path(s).` : 'Staged all changes.');
+      say(`Index now holds ${staged.length} file(s):\n` + staged.map((f) => '  ' + f).join('\n'));
+      return;
+    }
+    case 'diff': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const staged = /--staged|--cached/.test(raw);
+      const path = raw.replace(/--staged|--cached/g, '').trim();
+      const r = gitmod.diffText(cwd, { staged, path: path || undefined });
+      if (!r.ok) { appErr(`git diff failed: ${r.error}`); return; }
+      if (r.empty) { say(staged ? 'No staged changes.' : 'No uncommitted changes.'); return; }
+      say((staged ? 'Staged changes' : 'Uncommitted changes') + (path ? ` in ${path}` : '') + ':\n' + r.text);
+      return;
+    }
+    case 'log': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const count = parts[0] && /^\d+$/.test(parts[0]) ? parts.shift() : undefined;
+      const path = parts.join(' ') || undefined;
+      const r = gitmod.logText(cwd, { count, path });
+      if (!r.ok) { appErr(`git log failed: ${r.error}`); return; }
+      if (r.empty) { say('No commits yet.'); return; }
+      say(`Recent commits${path ? ` for ${path}` : ''}:\n` + r.text);
+      return;
+    }
+    case 'push': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const force = parts.includes('-f') || parts.includes('--force');
+      const branchArg = parts.find((x) => !x.startsWith('-')) || '';
+      const branch = branchArg || gitmod.currentBranch(cwd);
+      const upstream = gitmod.hasUpstream(cwd, branch);
+      const state2 = gitmod.aheadBehind(cwd, branch);
+      const detail = `${branch}${upstream ? '' : ' (no upstream — will set one)'}${state2 ? ` — ${state2}` : ''}`;
+      // Push is OUTBOUND: always confirm first, and say exactly what will happen.
+      h.openPicker({
+        title: `Push ${branch}?`,
+        items: [
+          { label: 'Push', sub: `git push ${force ? '--force-with-lease ' : ''}origin ${detail}` },
+          { label: 'Cancel', sub: 'do not push' },
+        ],
+        searchable: false,
+        hint: '↑↓ navigate · Enter select · Esc cancel',
+        onPick: (it) => {
+          if (it.label !== 'Push') { app('Push cancelled.'); return true; }
+          const r = gitmod.push(cwd, { branch: branchArg || undefined, force, setUpstream: !upstream });
+          if (!r.ok) appErr(`Push failed: ${r.error}`);
+          else { app(`Pushed ${branch}.`); say(`git push output:\n${r.output}`); }
+          return true;
+        },
+      });
+      return;
+    }
+    case 'stash': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const parts = raw.split(/\s+/).filter(Boolean);
+      const sub = (parts[0] || '').toLowerCase();
+      if (!sub || sub === 'list') {
+        const list = gitmod.stashList(cwd);
+        say(list.length ? `Stashes (${list.length}):\n` + list.map((s) => '  ' + s).join('\n') : 'No stashes.');
+        return;
+      }
+      if (sub === 'push' || sub === 'save') {
+        const msg = parts.slice(1).join(' ') || undefined;
+        const r = gitmod.stashPush(cwd, msg);
+        if (!r.ok) { appErr(`git stash failed: ${r.error}`); return; }
+        app('Stashed changes.'); say(r.output || 'Changes stashed.');
+        return;
+      }
+      if (sub === 'pop') {
+        const r = gitmod.stashPop(cwd);
+        if (!r.ok) { appErr(`git stash pop failed: ${r.error}`); return; }
+        app('Restored from stash.'); say(r.output || 'Stash popped.');
+        return;
+      }
+      appErr('Usage: /stash [list] | push [message] | pop');
+      return;
+    }
+    case 'rebase': {
+      const cwd = state.cwd || cfg.workspace || process.cwd();
+      if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
+      const onto = String(raw || '').trim();
+      if (!onto) { appErr('Usage: /rebase <branch>'); return; }
+      const cur = gitmod.currentBranch(cwd);
+      // Rewrites history on the current branch: confirm before running.
+      h.openPicker({
+        title: `Rebase ${cur} onto ${onto}?`,
+        items: [
+          { label: 'Rebase', sub: `git rebase ${onto}` },
+          { label: 'Cancel', sub: 'leave the branch as is' },
+        ],
+        searchable: false,
+        hint: '↑↓ navigate · Enter select · Esc cancel',
+        onPick: (it) => {
+          if (it.label !== 'Rebase') { app('Rebase cancelled.'); return true; }
+          const r = gitmod.rebase(cwd, onto);
+          if (!r.ok) appErr(`Rebase failed (resolve conflicts, then /rebase --continue or git rebase --abort): ${r.error}`);
+          else { app(`Rebased ${cur} onto ${onto}.`); say(r.output || 'Rebase complete.'); }
+          return true;
+        },
+      });
+      return;
+    }
     case 'commit': {
       const cwd = state.cwd || cfg.workspace || process.cwd();
       if (!gitmod.isRepo(cwd)) { appErr(`Not a git repository: ${cwd}`); return; }
@@ -5477,6 +5666,11 @@ function commandPathsAreInside(state, cmd, cwd) {
 function applyModel(state, cfg, next) {
   cfg.model = next.model; cfg.innerModel = next.innerModel; cfg.provider = next.provider;
   cfg.baseUrl = next.baseUrl; cfg.endpoint = next.endpoint; cfg.apiKey = next.apiKey; cfg.protocol = next.protocol;
+  // Carry the resolved context window over too. resolveProvider/resolveModelArg
+  // compute `maxContextTokens` for the NEW model, but it lives on the returned
+  // object — without copying it here, cfg (and the gauge below) kept the previous
+  // model's window after a switch.
+  if (next.maxContextTokens != null) cfg.maxContextTokens = next.maxContextTokens;
   state.model = cfg.model; state.provider = cfg.provider;
   state.modelLabel = modelLabel(cfg) || cfg.model || '';
   state.seenThinking = false;
@@ -5784,6 +5978,9 @@ export async function startTUI(opts) {
     if (out) stdout.write(out);
   }
   function renderFrame() { paintNow(); }
+  // Let module-level helpers (refreshGitInfo) ask for a repaint once their async
+  // data lands, without holding a reference to this closure.
+  state._requestRender = renderFrame;
   // No frame-rate cap: paint on the next event-loop turn. Calls made within the
   // same tick still coalesce (paintScheduled), so a burst of stream deltas
   // produces one frame per tick at full speed instead of being throttled to
@@ -6151,11 +6348,46 @@ export async function startTUI(opts) {
   // and doing it lazily on the first Ctrl+Shift+V made the shortcut look dead.
   warmClipboard();
   setTip(state);
-  // Populate the git badge before the first paint so the status line is correct
-  // immediately (from then on the 15s timer / turn-end keep it current).
+  // Fill the git badge — asynchronously, AFTER the first paint. It used to run
+  // before renderFrame() with a blocking spawnSync git, which added ~330ms to
+  // startup; now the frame draws at once and the badge appears when git answers.
   refreshGitInfo(state, { force: true });
   renderFrame();
 
+  // MCP: connect in the BACKGROUND, now that the UI is on screen. Each server
+  // gets up to CONNECT_TIMEOUT_MS, so doing this before the first paint would
+  // stall the whole TUI; instead we start it and report the outcome as a notice
+  // ("MCP: connected to …") when it lands. Tools registered here become visible
+  // to the model on its next turn.
+  if (typeof opts.mcpConnect === 'function') {
+    Promise.resolve()
+      .then(() => opts.mcpConnect())
+      .then((res) => {
+        const servers = (res && res.servers) || [];
+        if (!servers.length) return;
+        // The notice line is a SINGLE status-line row, so report all servers in
+        // one message — looping notice() per server only left the last one
+        // visible. Failures are listed too, and the whole notice turns red when
+        // any server failed.
+        const okServers = servers.filter((s) => s.ok);
+        const bad = servers.filter((s) => !s.ok);
+        const parts = [];
+        if (okServers.length) {
+          const tools = okServers.reduce((n, s) => n + (s.toolCount || 0), 0);
+          const names = okServers.map((s) => s.name).join(', ');
+          parts.push(`MCP connected: ${names} (${tools} tool${tools === 1 ? '' : 's'})`);
+        }
+        if (bad.length) {
+          parts.push(`MCP failed: ${bad.map((s) => s.name).join(', ')}`);
+        }
+        notice(parts.join(' · '), bad.length ? 'error' : 'info');
+        // A connecting server may have changed the tool list; repaint so any
+        // tool-count readout is current.
+        renderFrame();
+      })
+      .catch(() => { /* MCP must never break the session */ });
+  }
+
   const tipTimer = setInterval(() => { setTip(state); renderFrame(); }, TIP_INTERVAL);
   // Git badge: a fixed 15s cadence. Deliberately NOT tied to the frame loop (that
   // spawned git per keystroke) and NOT run mid-turn (the agent is still writing;
@@ -8094,16 +8326,19 @@ export async function startTUI(opts) {
           renderSoon();
           return;
         }
+        if (e.type === 'compacting') {
+          // In-progress notice: the summary below is a full model round-trip, so
+          // show that work is happening instead of leaving the turn silent.
+          addChat({ role: 'system', text: `Context at ${fmtTokens(e.before || 0)} — auto-compacting…` });
+          renderSoon();
+          return;
+        }
         if (e.type === 'compacted') {
           state.ctxTokens = e.after || state.ctxTokens;
           state.ctxPercent = usagePercent(state.ctxTokens, state.ctxMax || 1);
           addChat({ role: 'system', text: `Context auto-compacted (${fmtTokens(e.before || 0)} → ${fmtTokens(e.after || 0)} tokens).` });
           return;
         }
-        if (e.type === 'nudge') {
-          // Silent internal signal - don't show to user
-          return;
-        }
         if (e.type === 'incomplete') {
           // Orange: this is a warning, not ordinary system output.
           addChat({ role: 'warn', text: `Stopped: ${e.reason}. The task may be unfinished — send another message to continue.` });
@@ -8127,8 +8362,16 @@ export async function startTUI(opts) {
         if (e.type === 'aborted') {
           const t = [...state.chat].reverse().find((m) => m.role === 'thinking' && m.pending);
           if (t) t.pending = false;
+          // Settle any RUNNING tool rows too. A tool that was mid-flight when the
+          // user hit Esc never gets its tool_result, so its `pending` stayed true
+          // and the `Using <Tool>` name kept pulsing forever. Clearing it drops the
+          // name to plain cyan immediately.
+          for (const m of state.chat) {
+            if (m.role === 'tool' && m.pending) { m.pending = false; m.failed = true; }
+          }
           // Use a special role that won't show the ✓ icon
           state.chat.push({ role: 'aborted', text: C.red + 'interrupted' + C.reset });
+          renderFrame();
           return;
         }
         if (e.type === 'steer') {
@@ -8299,12 +8542,12 @@ export async function startTUI(opts) {
     if (agent.ctx) {
       agent.ctx._onBackgroundTaskDone = (task) => {
         if (!task) return;
-        const status = task.status || 'completed';
-        const head = status === 'completed'
-          ? `[background agent finished: ${task.taskId}]`
-          : `[background agent ${status}: ${task.taskId}${task.stopReason ? ' - ' + task.stopReason : ''}]`;
+        // kimi-style lifecycle card: bullet colour by phase, a headline naming
+        // the kind (agent / bash / question task) and what happened, and a dim
+        // detail line. The task's conclusion is kept as the expandable body.
+        const card = backgroundTaskCard(task);
         const body = String(task.output || '').trim();
-        addChat({ role: 'system', text: body ? `${head}\n${body}` : head });
+        addChat({ role: 'bg_task', card, text: body });
       };
     }
     await agent.run();
@@ -8630,6 +8873,10 @@ export async function startTUI(opts) {
       failed: !!(m && m.failed),
     };
     if (m && Array.isArray(m.diff)) out.diff = m.diff;
+    // Keep `card`: a background-task lifecycle card carries its phase/headline/
+    // detail here (see the `bg_task` renderer). Dropping it left the row with the
+    // fallback text instead of what actually happened.
+    if (m && m.card) out.card = m.card;
     return out;
   }
 

package/src/update.js

@@ -10,26 +10,48 @@
 // resolve to a status string, never throw to the caller. The TUI calls them from
 // timers / startup without awaiting.
 
-import { spawn, execSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { localVersion } from './version.js';
 
 const PKG_NAME = '@hncode/hncode';
+// Spawn npm portably. On Windows npm is a `.cmd` shim, and Node refuses to spawn
+// a `.cmd` directly (EINVAL) — it must go through a shell. Using
+// `cmd.exe /c npm ...` keeps that behaviour while avoiding `shell: true`, which
+// Node warns about (with a shell, args are concatenated rather than escaped).
+function spawnNpm(args, opts) {
+  if (process.platform === 'win32') return spawn('cmd.exe', ['/c', 'npm', ...args], opts);
+  return spawn('npm', args, opts);
+}
 // How often the auto-check runs once we are past the startup check.
 export const AUTO_UPDATE_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
 export { localVersion };
 
 // Latest version published to npm, or '' if the registry is unreachable /
 // not installed / not a package.
-export function remoteVersion() {
-  try {
-    const out = execSync(`npm view ${PKG_NAME} version --silent`, {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      timeout: 15000,
-    }).toString().trim();
-    return out || '';
-  } catch {
-    return '';
-  }
+//
+// ASYNC on purpose: `execSync` blocks the whole event loop, so a cold `npm view`
+// (measured at ~15s on a slow registry, vs ~2s warm) froze the TUI — no key
+// handling, no repaint — for the entire duration. `spawn` runs the same command
+// off the main thread, and the timeout kills it rather than waiting it out.
+export function remoteVersion(timeoutMs = 10000) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawnNpm(['view', PKG_NAME, 'version', '--silent'], {
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+    } catch {
+      resolve('');
+      return;
+    }
+    let out = '';
+    let done = false;
+    const finish = (v) => { if (!done) { done = true; clearTimeout(timer); resolve(v); } };
+    const timer = setTimeout(() => { try { child.kill(); } catch {} finish(''); }, timeoutMs);
+    if (child.stdout) child.stdout.on('data', (d) => { out += d.toString(); });
+    child.on('error', () => finish(''));
+    child.on('close', () => finish((out || '').trim()));
+  });
 }
 
 // Parse a semver-ish "x.y.z" (ignore prerelease tags) into comparable numbers.
@@ -55,10 +77,9 @@ export function updateBackground() {
   return new Promise((resolve) => {
     try {
       // `npm install -g` needs to run detached; no need to wait here.
-      const child = spawn('npm', ['install', '-g', `${PKG_NAME}@latest`], {
+      const child = spawnNpm(['install', '-g', `${PKG_NAME}@latest`], {
         detached: true,
         stdio: 'ignore',
-        shell: process.platform === 'win32', // npm is npm.cmd on Windows
       });
       child.unref();
       child.on('error', (e) => resolve({ ok: false, error: e.message }));
@@ -77,7 +98,7 @@ export function updateBackground() {
 export async function checkAndUpdate() {
   const local = localVersion();
   if (!local) return { status: 'none', message: "can't read local version" };
-  const remote = remoteVersion();
+  const remote = await remoteVersion();
   if (!remote) return { status: 'none', message: 'npm registry unreachable' };
 
   if (isNewer(remote, local)) {