@tiens.nguyen/gu-cli 1.0.784 → 1.0.786

package/completed-flush.mjs

@@ -103,3 +103,50 @@ export function completedFlush({
   const steps = tail.slice(0, close);
   return steps ? { kind: "steps", text: steps } : { kind: "none", text: "" };
 }
+
+/**
+ * WHILE THE JOB IS STILL RUNNING: which of the newly arrived text is the turn's WORK (step lines
+ * and thoughts, inside <think>…</think>) and which is the ANSWER (outside it). Task #326.
+ *
+ * An agent turn's stream is `<think>steps…</think>answer`. The answer is the caller's to print —
+ * once, wrapped, from the completed resultText. completedFlush has always stopped at </think> for
+ * that reason, but the RUNNING poll did not: it fed everything to the step printer. So whenever
+ * the answer's chunk was polled before the job flipped to "completed" (any answer long enough to
+ * be posted on its own), every paragraph of it was printed as a "●" step bullet — and then the
+ * whole answer again under "recap:". Reported as the answer appearing twice; short answers escaped
+ * only because their chunk and the completion arrived in the same poll.
+ *
+ * `state` is carried from poll to poll: { inThink, held }. `held` is the start of a tag cut in two
+ * by a poll boundary ("</thi" + "nk>"), kept back until the rest arrives.
+ * → { parts: [{ inside, text }], state } — the tags themselves are dropped.
+ */
+export function splitLiveStream(fresh, state = {}) {
+  let text = String(state.held ?? "") + String(fresh ?? "");
+  let inThink = Boolean(state.inThink);
+  const parts = [];
+  const push = (inside, t) => {
+    if (!t) return;
+    const last = parts[parts.length - 1];
+    if (last && last.inside === inside) last.text += t;
+    else parts.push({ inside, text: t });
+  };
+  // Hold back a tail that could be the beginning of a tag.
+  let held = "";
+  const lt = text.lastIndexOf("<");
+  if (lt >= 0 && lt > text.length - 8) {
+    const tail = text.slice(lt).toLowerCase();
+    if ("<think>".startsWith(tail) || "</think>".startsWith(tail)) {
+      held = text.slice(lt);
+      text = text.slice(0, lt);
+    }
+  }
+  const re = /<(\/?)think>/gi;
+  let at = 0;
+  for (let m; (m = re.exec(text)); ) {
+    push(inThink, text.slice(at, m.index));
+    inThink = m[1] !== "/";
+    at = m.index + m[0].length;
+  }
+  push(inThink, text.slice(at));
+  return { parts, state: { inThink, held } };
+}

package/gonext_agent_chat.py

@@ -7782,7 +7782,7 @@ def run_agent_chat(cfg):
     _skill_call = _skills_mod.invocation(task_text, _skills)
     if _skill_call:
         _sk, _sk_body, _sk_req = _skill_call
-        task_text = (_skills_mod.render(_sk, _sk_body) + "\n\nThe user's request: "
+        task_text = (_skills_mod.render(_sk, _sk_body, _sk_req) + "\n\nThe user's request: "
                      + (_sk_req or "(nothing more — do what the skill describes)"))
         _log(f"skill invoked: {_sk['name']}")
 

package/gu-repl.mjs

@@ -23,8 +23,6 @@
  * Requires the worker daemon to be running (it claims the job).
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
-import { appendFileSync as __afs } from "node:fs";
-const __dbg = (...a) => { try { __afs("/private/tmp/claude-501/-Users-joseph-Projects-gonext/bf6ac2f6-435f-4150-a01e-cea31d8ff4d2/scratchpad/r321/dbg.log", a.map((x) => JSON.stringify(x)).join(" ") + "\n"); } catch {} };
 import { readFile, mkdir, writeFile, unlink, rename } from "node:fs/promises";
 import { readStepTokens, readTurnCache } from "./step-tokens.mjs";
 import { snapshotInput, restoreInput, replaceStoppedQuestion, restoredQuestionLetGo, stopNoteLines } from "./turn-stop.mjs";
@@ -128,12 +126,14 @@ import {
   rankSlashCommands,
   slashMenuWindow,
 } from "./terminal-layout.mjs";
-import { completedFlush } from "./completed-flush.mjs";
+import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
+import { isScaffoldStep, isGroupableStep, stepGroupRows, relativizePaths } from "./step-group.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
 import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
 import { unapprovedProjectServers } from "./mcp-command.mjs";
 import { readHooks } from "./hooks-config.mjs";
+import { readSkillSource, sourceLabel, SKILL_SOURCE_KEY } from "./skill-source.mjs";
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
 import { IMAGE_NEEDS_CLAUDE, coderTakesImagesFor, clipboardImageToFile, fitImageNotice, imageMarkersForDisplay, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
@@ -897,6 +897,7 @@ const COMMANDS = [
   { name: "/new", desc: "start a new conversation in this folder — the old one is kept (archived); the folder's settings stay" },
   { name: "/hooks", usage: "/hooks [list|approve|unapprove]", desc: "hooks: commands gu runs on onStart, onAsk, onToolDone, onTurnEnd — list them, approve this project's" },
   { name: "/mcp", usage: "/mcp [list|tools|add|remove|enable|disable|approve|allow|disallow|reconnect]", desc: "MCP servers: see which connect, add one (asks step by step), choose which tools run without asking" },
+  { name: "/switch-skill", usage: "/switch-skill [claude|gu]", desc: "whose skills, MCP servers and hooks this folder uses — Claude Code's (.claude) or gu's own (.gonext)" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -1004,7 +1005,6 @@ const OUT_RESTORE = "\x1b8";
 const OUT_SAVE = "\x1b7";
 /** Draw in-place UI that lives in the SCROLLING area (status block, pickers, menus). */
 const regionUi = (seq) => {
-  if (/\n/.test(seq)) __dbg("regionUi with newline", { nl: (seq.match(/\n/g) || []).length, head: seq.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").slice(0, 60), at: new Error().stack.split("\n").slice(2, 5).map((x) => x.trim().slice(0, 80)) });
   if (!barPinned()) {
     ui(seq);
     return;
@@ -2598,9 +2598,15 @@ const viewportHeight = () => Math.max(1, viewportRows() - barReserved);
  * Set by the active turn (it owns `statusShown`/`shownRows`), null between turns.
  */
 let liveOverlayRows = null;
-/** Rows the TRANSCRIPT actually gets: the scrolling area, less any live block under it. */
+/**
+ * Rows the TRANSCRIPT actually gets: the scrolling area, less any live block under it — and less
+ * the blank rows a closed picker or a shrunk zone left below the content (#321's pad, #324).
+ * Those rows hold nothing, exactly like the live block's: every screen-row → line mapping that
+ * forgot them was off by that many rows. Reported as the question echo landing on the line above
+ * it: the slash menu and the hover put rows BACK from a view that sat `pad` rows too low.
+ */
 const transcriptRows = () =>
-  Math.max(1, viewportHeight() - (liveOverlayRows ? liveOverlayRows() : 0));
+  Math.max(1, viewportHeight() - (liveOverlayRows ? liveOverlayRows() : 0) - livePad());
 // Rows the frozen zone occupies: the zone's head (the separator and the blank under it — see
 // INPUT_HEAD_ROWS) + the input line, then the bar's own rows (which grow by one under
 // --verbose). Everything that reserves, measures or paints the zone MUST use this — reserving
@@ -2616,10 +2622,23 @@ function pinBar() {
   const rows = frozenRowCount();
   // Re-cutting keeps the OUTPUT position that is already in the save slot (preserveCaret:false);
   // paintBar() below puts the caret back on the input line.
-  if (barPinned()) ui(scrollRegionSeq(viewportRows(), rows, { preserveCaret: false }));
+  const first = !barPinned();
+  if (!first) ui(scrollRegionSeq(viewportRows(), rows, { preserveCaret: false }));
   else ui(reserveRowsSeq(viewportRows(), rows) + OUT_SAVE); // …and remember where output goes
   barReserved = rows;
-  paintBar();
+  if (!first) {
+    paintBar();
+    return;
+  }
+  // THE FIRST PIN TAKES THE SCREEN INTO gu's HANDS (#321, #324): one repaint from the transcript,
+  // which also puts the OUTPUT POSITION at the end of the content. reserveRowsSeq leaves it on
+  // the region's LAST row — right when the screen is full, but after a short banner the content
+  // ends near the top, and every later height change is planned from where the content ends
+  // (zoneResizePlan). Left at the bottom, the two disagreed: the region was cut above the saved
+  // position and the next line — the question's echo — was written rows away from its place, on
+  // top of the line printed before it. No pad survives a repaint: the screen IS the model now.
+  padRows = 0;
+  paintLiveTail(); // ends in paintBar
 }
 /** Give the rows back and clear them — every exit path must reach this. */
 function unpinBar() {
@@ -2765,14 +2784,12 @@ function paintBar() {
   // re-cut the region before painting, or its top rows would land inside the scrolling area.
   const prev = barReserved;
   const regrew = zone.rows.length !== prev;
-  if (regrew) { const v = viewportSlice(screenRows(), 0, viewportHeight()).rows; __dbg("MODEL AT REGROW", v.map((r) => r.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 50))); }
-  if (regrew) __dbg("ANY regrow", { prev, now: zone.rows.length, scrolledBack: scrolledBack(), rows: displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length, pad: padRows, vp: viewportRows() });
   if (regrew) {
     // #321: MOVE THE SCREEN LIKE A TERMINAL, never repaint it from the transcript — a repaint put
     // lines the terminal had already scrolled away back on screen, and the next output scrolled
     // them into the scrollback AGAIN (the banner and the update notice repeated after an update;
     // "auto-test off" doubled). See zoneResizePlan.
-    const live = prev > 0 && !scrolledBack();
+    const live = !scrolledBack();
     let plan = null;
     let rows = 0;
     if (live) {
@@ -2793,7 +2810,6 @@ function paintBar() {
       ui(clear);
     }
     if (live) setPad(plan.pad, rows);
-    __dbg("regrow", { prev, now: zone.rows.length, rows, plan, live });
     barReserved = zone.rows.length;
   }
   const top = viewportRows() - zone.rows.length + 1;
@@ -2820,10 +2836,9 @@ function paintBar() {
     paintFrozenRowsSeq(zone.rows, viewportRows(), { preserveCaret: false }) +
       parkCaretSeq(zone.caretRow, zone.caretCol)
   );
-  // THE FIRST PIN only: before it, the screen is whatever setup printed, and one repaint puts the
-  // view in gu's hands. Every later height change moved the screen above (#321) — a repaint here
-  // is what filled the scrollback with copies. Recurses at most once (paintLiveTail → paintBar).
-  if (regrew && !scrolledBack() && prev === 0) paintLiveTail();
+  // NO REPAINT HERE: a height change moved the screen above (#321) — repainting it from the
+  // transcript is what filled the scrollback with copies. The one repaint is pinBar's, on the
+  // first pin.
 }
 /** Bytes that put the caret back on text row `row` (0-based) at 1-based `col`. */
 const parkCaretSeq = (row, col) => `\x1b[${inputRowAbs + Math.max(0, row | 0)};${col}H`;
@@ -3002,6 +3017,9 @@ let liveSelection = null;
 let padRows = 0;
 let padAnchor = 0;
 const currentPad = (rowCount) => (padRows > 0 ? Math.max(0, padRows - Math.max(0, rowCount - padAnchor)) : 0);
+/** The pad right now — free when there is none, which is nearly always. */
+const livePad = () =>
+  padRows > 0 ? currentPad(displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length) : 0;
 function setPad(n, rowCount) {
   padRows = Math.max(0, n | 0);
   padAnchor = rowCount;
@@ -3263,14 +3281,27 @@ const hoverCtl = createHoverController({
   afterPaint: () => paintBar(),
 });
 
-/** One block's rows, painted: dim normally, full-bright while the pointer is on it. */
-const paintThoughtRows = (block, hovered) => {
+/**
+ * One block's rows, painted: dim normally, full-bright while the pointer is on it.
+ *
+ * TWO KINDS OF BLOCK share the registry, the hover and the click (#326): a THOUGHT (prose) and a
+ * group of the turn's look-ups (`kind: "steps"`, see step-group.mjs) — "searched code 3× · read
+ * lines 2×", one row until it is clicked open. They differ only in how their rows are made, so
+ * that is the one place they are told apart.
+ */
+const paintThoughtRows = (block, hovered, collapsed = block.collapsed) => {
+  const paint = (r) => (hovered ? hoverThought(r) : dim(r));
+  if (block.kind === "steps") {
+    return stepGroupRows(block.items, { width: thoughtWidth(), collapsed }).map(
+      (r) => (r.head ? markLine(dim(BULLET)) : GUTTER) + paint(r.text)
+    );
+  }
   const rows = thoughtBlockRows(block.prose, {
     width: thoughtWidth(),
-    collapsed: block.collapsed,
+    collapsed,
     lines: THOUGHT_COLLAPSED_LINES,
   });
-  return rows.map((r) => GUTTER + (hovered ? hoverThought(r) : dim(r)));
+  return rows.map((r) => GUTTER + paint(r));
 };
 
 /** Width available to a thought row: the screen, less the gutter it hangs in. */
@@ -3311,7 +3342,7 @@ function printThoughtBlock(raw, before) {
   // between, so the two really are continuous — grow it rather than start a new one. Any
   // bullet, blank or answer in between breaks contiguity, and a separate block is then right.
   const prev = thoughtBlocks[thoughtBlocks.length - 1];
-  if (prev && prev.collapsed && prev.to === transcript.dropped() + transcript.length() - 2) {
+  if (prev && !prev.kind && prev.collapsed && prev.to === transcript.dropped() + transcript.length() - 2) {
     const merged = prev.prose.replace(/\s+$/, "") + " " + prose;
     const grown = thoughtBlockRows(merged, {
       width: thoughtWidth(),
@@ -3420,8 +3451,10 @@ let copyBadgeTimer = null;
 /** The transcript row currently under the viewport row `row`, as it should look. */
 function viewportRowText(row) {
   const width = Math.max(20, process.stdout.columns || 80);
+  // The view as it is ON SCREEN — pad rows included (#324), or every row comes back `pad` too low.
   const rows = displayRows(transcript.lines(), width - 1);
-  const view = viewportSlice(rows, scrollOffset, viewportHeight());
+  const pad = currentPad(rows.length);
+  const view = viewportSlice(pad ? [...rows, ...Array(pad).fill("")] : rows, scrollOffset, viewportHeight());
   const line = view.rows[row - 1];
   return typeof line === "string" ? line : "";
 }
@@ -3588,12 +3621,7 @@ function hoverThoughtAtRow(row) {
 
 /** Swap one recorded block for its other form and repaint from the transcript. */
 function toggleThoughtBlock(block) {
-  const next = thoughtBlockRows(block.prose, {
-    width: thoughtWidth(),
-    collapsed: !block.collapsed,
-    lines: THOUGHT_COLLAPSED_LINES,
-  });
-  const painted = next.map((r) => GUTTER + dim(r));
+  const painted = paintThoughtRows(block, false, !block.collapsed);
   const newEnd = transcript.replaceRange(block.from, block.to, painted);
   if (newEnd === null) {
     // Scrolled out of the buffer — the block is gone, and so is the thing to toggle.
@@ -3632,7 +3660,9 @@ function paintLiveTail() {
   // painted row down by the block's height so a selection highlight lands N rows away from the
   // text it belongs to. Between turns the block is gone, transcriptRows() === viewportHeight(),
   // and this is the behaviour it always had.
-  const height = transcriptRows();
+  // The pad rows are part of the screen (screenRows has them) but not of the transcript's rows.
+  const pad = livePad();
+  const height = transcriptRows() + pad;
   const view = viewportSlice(screenRows(), 0, height);
   ui(paintViewportSeq(view.rows, height, width, clipVisible, { preserveCaret: false }));
   // Park the caret at the end of the last printed line AND SAVE IT: the tail we just repainted
@@ -3643,8 +3673,9 @@ function paintLiveTail() {
   // that slot with the caret parked on the INPUT LINE. The next line printed after any scroll
   // round trip was then written at the prompt's column inside the frozen zone — on screen, a
   // question indented three columns to the right of every other line.
-  const lastRow = Math.max(1, view.rows.length);
-  const lastCol = Math.min(width, visibleLen(view.rows[view.rows.length - 1] ?? "") + 1);
+  // …the last CONTENT row: output continues above the pad, which it then fills (#324).
+  const lastRow = Math.max(1, view.rows.length - pad);
+  const lastCol = Math.min(width, visibleLen(view.rows[lastRow - 1] ?? "") + 1);
   ui(`\x1b[${lastRow};${lastCol}H` + OUT_SAVE);
   paintBar();
 }
@@ -7159,6 +7190,82 @@ async function afterStoppedTurn({ taskLine, submittedInput, turnStartMs, stopped
   if (barPinned()) paintBar();
 }
 
+/**
+ * /switch-skill — whose skills, MCP servers and hooks THIS FOLDER uses (task #325): Claude Code's,
+ * read where Claude keeps them (~/.claude, ./.claude, ~/.claude.json), or gu's own (~/.gonext,
+ * ./.gonext). One choice for all three — a skill names its MCP server's tools and the hooks feed
+ * the same database, so they only make sense together. Stored in the folder's session file, which
+ * the worker reads for every turn (skill-source.mjs): it holds from the next question, no restart.
+ */
+async function runSwitchSkillCommand(line) {
+  const cwd = resolve(process.cwd());
+  const current = readSkillSource(cwd);
+  const arg = (line.trim().split(/\s+/)[1] ?? "").toLowerCase();
+  const where = (src) => (src === "claude" ? "~/.claude, ./.claude, ~/.claude.json" : "~/.gonext, ./.gonext");
+  let pick = "";
+  console.log("");
+  if (arg) {
+    pick = /^claude/.test(arg) ? "claude" : arg === "gu" ? "gu" : "";
+    if (!pick) {
+      console.log(GUTTER + yellow(`"${arg}" is not one of them — /switch-skill claude  or  /switch-skill gu\n`));
+      return;
+    }
+  } else {
+    const options = ["claude", "gu"];
+    console.log(dim(`  Whose skills, MCP servers and hooks this folder uses  (${PICK_HINT}):`));
+    const idx = await pickFromList(
+      options.map((o) => sourceLabel(o) + dim(`  · ${where(o)}`) + (o === current ? dim("  · in use") : "")),
+      Math.max(0, options.indexOf(current))
+    );
+    if (idx < 0) {
+      console.log(dim("  (cancelled)\n"));
+      paintBar();
+      return;
+    }
+    pick = options[idx];
+  }
+  try {
+    await updateSessionFile(cwd, (raw) => {
+      raw[SKILL_SOURCE_KEY] = pick;
+      raw.updatedAt = new Date().toISOString();
+    });
+  } catch (err) {
+    console.log(GUTTER + red(`couldn't save the choice — ${err.message}. Nothing changed.\n`));
+    return;
+  }
+  _skillScan = { at: 0, skills: [] }; // the "/" menu and Tab follow at once
+  const say = (l) => console.log(GUTTER + l);
+  say(accent(`✓ ${pick === current ? "this folder uses" : "this folder now uses"} ${sourceLabel(pick)}`));
+  say(dim(`  skills, MCP servers and hooks are read from ${where(pick)}`));
+  // What was found there — and what was not, said rather than shown as an empty list.
+  try {
+    const sk = discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES });
+    const mcp = listMcpServers({ cwd: process.cwd() });
+    const hk = readHooks({ cwd: process.cwd() });
+    const nHooks = (h) => Object.values(h).reduce((a, groups) => a + groups.reduce((b, g) => b + g.hooks.length, 0), 0);
+    const count = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+    const running = mcp.servers.filter((x) => x.runnable).length;
+    say(dim(`  ${count(sk.skills.length, "skill")}${sk.skills.length ? ` (${sk.skills.map((x) => "/" + x.name).join(", ")})` : ""} · ${count(running, "MCP server")} · ${count(nHooks(hk.user) + (hk.projectApproved ? nHooks(hk.project) : 0), "hook")}`));
+    // Nothing there at all is a normal state, not a fault: say so, and that gu needs none of it.
+    if (!sk.skills.length && !mcp.servers.length && !nHooks(hk.user) && !nHooks(hk.project) && !hk.notes.length) {
+      say(dim("  Nothing is set up there yet — gu works the same without any of them."));
+    }
+    for (const w of [...sk.warnings, ...mcp.warnings, ...hk.warnings]) say(yellow("  " + w));
+    const unsupported = mcp.servers.filter((x) => x.error);
+    if (unsupported.length) say(yellow(`  ${count(unsupported.length, "MCP server")} cannot run here: ${unsupported.map((x) => `${x.name} (${x.error})`).join("; ")}`));
+    const waiting = mcp.servers.filter((x) => x.scope === "project" && !x.approved && !x.error);
+    if (waiting.length) say(yellow(`  ${count(waiting.length, "project MCP server")} waiting for your approval: ${waiting.map((x) => x.name).join(", ")} — /mcp approve <name>`));
+    if (hk.projectPending) say(yellow(`  this folder's ${hk.projectFile.replace(/^\.\//, "")} has hooks that will not run until you approve them — /hooks approve`));
+    if (hk.notes.length) say(yellow(`  ${count(hk.notes.length, "hook")} in Claude's settings ${hk.notes.length === 1 ? "is" : "are"} NOT run by gu — /hooks says which and why`));
+    if (pick === "claude" && (nHooks(hk.user) || nHooks(hk.project))) say(dim("  Claude's hooks get Claude's event and tool names from gu, so they record here as they do there."));
+  } catch (err) {
+    say(yellow(`  (could not read it back: ${err.message})`));
+  }
+  say(dim(`  It holds from your next question. ${pick === "claude" ? "/switch-skill gu" : "/switch-skill claude"} switches back.`));
+  console.log("");
+  if (barPinned()) paintBar();
+}
+
 /**
  * /undo — put back what a stopped turn changed (task #302): the last stopped turn's run, or the
  * run named. Shows exactly what it will do and asks first — a file edited by hand since the turn
@@ -9509,6 +9616,8 @@ let forgetActiveStatus = null;
 // Ctrl+T reveal the full Thought from the KEYBOARD, so the feature doesn't depend on the mouse
 // capture that would block scrolling (see hoverMouse).
 let toggleActiveThought = null;
+/** #324: the screen under the Yes/No picker when it opened — the list picker's bookkeeping (#321). */
+let approvalOpenedOver = null;
 function drawApprovalOptions(redraw) {
   // Two option lines, redrawn in place. On redraw the cursor sits one row below "No";
   // step up 2 rows, clear+rewrite both, landing back where we started.
@@ -9518,11 +9627,24 @@ function drawApprovalOptions(redraw) {
   // each and the \x1b[2A count stays exact — which is why a resize can simply redraw here.
   const yes = approvalSel === 0 ? accent("▸ Yes") : dim("  Yes");
   const no = approvalSel === 1 ? accent("▸ No") : dim("  No");
+  if (!redraw && barPinned() && !scrolledBack()) {
+    const content = displayRows(transcript.lines(), Math.max(20, process.stdout.columns || 80) - 1).length;
+    approvalOpenedOver = { content, pad: currentPad(content), height: viewportHeight() };
+  }
   regionUi((redraw ? "\x1b[2A" : "") + "\x1b[K" + GUTTER + yes + "\n\x1b[K" + GUTTER + no + "\n");
 }
 function finishApproval(allow) {
   if (!approvalActive) return;
   approvalActive = false;
+  // #324: on a full screen the two option rows SCROLLED the conversation up by two, and the one
+  // result line below takes only one of them back — the content now ends a row above the region's
+  // bottom. Unrecorded, every row put back from the transcript afterwards (the slash menu, a
+  // hover) was drawn one row low, over its neighbour. Same account as a closed list picker.
+  const over = approvalOpenedOver;
+  approvalOpenedOver = null;
+  if (over && barPinned() && !scrolledBack() && over.height === viewportHeight()) {
+    setPad(blockClosedPad({ contentRows: over.content, pad: over.pad, height: over.height, blockRows: 2 }), over.content);
+  }
   // Settle the picker: overwrite the two option lines with a single result line.
   process.stdout.write("\x1b[2A\x1b[J" + GUTTER + (allow ? accent("▸ Yes — running it") : red("▸ No — skipped")) + "\n");
   const r = approvalResolve;
@@ -9771,7 +9893,6 @@ function drawList(redraw) {
   if (!redraw && barPinned() && !scrolledBack()) {
     const content = displayRows(transcript.lines(), width - 1).length;
     listOpenedOver = { content, pad: currentPad(content), height: viewportHeight() };
-    __dbg("picker open", listOpenedOver, { lastLines: transcript.lines().slice(-3) });
     listMaxRows = 0;
   }
   listMaxRows = Math.max(listMaxRows, physicalRows(rows, width));
@@ -9793,8 +9914,6 @@ function finishList(index) {
   // higher with blank rows under it — remember them, so nothing repaints those lines back on screen.
   if (listOpenedOver && barPinned() && !scrolledBack() && listOpenedOver.height === viewportHeight()) {
     setPad(blockClosedPad({ contentRows: listOpenedOver.content, pad: listOpenedOver.pad, height: listOpenedOver.height, blockRows: listMaxRows }), listOpenedOver.content);
-    { const v = viewportSlice(screenRows(), 0, viewportHeight()).rows; __dbg("MODEL VIEW", v.map((r) => r.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 60))); }
-    __dbg("picker closed", { ...listOpenedOver, blockRows: listMaxRows, newPad: padRows, nowRows: displayRows(transcript.lines(), width - 1).length });
   }
   listOpenedOver = null;
   listMaxRows = 0;
@@ -10677,6 +10796,8 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // completed resultText really EXTENDS what we streamed (an old worker replaces it
   // with the shorter bare answer, which must not be sliced by shownChars).
   let seenRaw = "";
+  // #326: where the live stream is relative to the <think> fence, carried from poll to poll.
+  let liveSplit = { inThink: false, held: "" };
 
   // --- Live in-progress ("blinking") bullet -------------------------------------------
   // The agent's raw Thought/code stream is SUPPRESSED (see the ~~~-fence handling in
@@ -11151,6 +11272,67 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   const openBullet = () => {
     if (!lastWasBlank) process.stdout.write("\n");
   };
+  // THE TURN'S LOOK-UPS AS ONE LINE (#326, step-group.mjs). `stepGroup` is the group still OPEN:
+  // the next look-up joins it and its row is rewritten where it sits. It stays open only while
+  // nothing but thoughts has been printed under it — an edit card, a command's result, a failure,
+  // an approval or the answer ends it, and the next look-up starts a new group below them.
+  let stepGroup = null;
+  const turnCwd = resolve(process.cwd());
+  /** The last finished transcript line — where a block must end to still be the tail. */
+  const transcriptTail = () => transcript.dropped() + transcript.length() - 2;
+  /** Is the open group still followed by nothing but thought blocks? */
+  const stepGroupStillOpen = () => {
+    if (!stepGroup || !barPinned() || scrolledBack()) return false;
+    let end = stepGroup.to;
+    const at = thoughtBlocks.indexOf(stepGroup);
+    if (at < 0) return false; // dropped from the registry (it is capped): no longer ours to rewrite
+    for (let i = at + 1; i < thoughtBlocks.length; i++) {
+      if (thoughtBlocks[i].from !== end + 1) return false;
+      end = thoughtBlocks[i].to;
+    }
+    return end === transcriptTail();
+  };
+  const addLookupStep = (text) => {
+    if (stepGroupStillOpen()) {
+      stepGroup.items.push(text);
+      const painted = paintThoughtRows(stepGroup, hoverCtl.hovered === stepGroup);
+      const newEnd = transcript.replaceRange(stepGroup.from, stepGroup.to, painted);
+      if (newEnd !== null) {
+        const delta = newEnd - stepGroup.to;
+        stepGroup.to = newEnd;
+        if (delta === 0) {
+          // Collapsed: one row before, one row after — rewrite that row and nothing else.
+          ui(thoughtBlockRepaintSeq(stepGroup));
+          paintBar();
+        } else {
+          // Open (the user clicked it mid-turn): it grew, and what is under it moved down.
+          for (const b of thoughtBlocks) {
+            if (b !== stepGroup && b.from > stepGroup.from) {
+              b.from += delta;
+              b.to += delta;
+            }
+          }
+          hoverCtl.reset();
+          paintLiveTail();
+        }
+        return;
+      }
+      stepGroup.items.pop(); // scrolled out of the buffer: it is history now — start a new one
+    }
+    stepGroup = null;
+    const block = { kind: "steps", from: 0, to: 0, items: [text], collapsed: true };
+    const painted = paintThoughtRows(block, false);
+    openBullet();
+    process.stdout.write(painted.join("\n") + "\n");
+    block.to = transcriptTail();
+    block.from = block.to - painted.length + 1;
+    // Unpinned (a window too short for the zone, or piped): nothing can be rewritten in place, so
+    // every look-up is its own line, as it always was — and there is no click to register for.
+    if (!barPinned()) return;
+    thoughtBlocks.push(block);
+    if (thoughtBlocks.length > 200) thoughtBlocks = thoughtBlocks.slice(-200);
+    stepGroup = block;
+  };
   // Chars of the CURRENT trailing (newline-less) `carry` line already flushed live — lets
   // a long plain-reply answer stream character-by-character instead of waiting for a "\n"
   // that might not arrive until the very end (most short replies have none at all).
@@ -11370,6 +11552,12 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       }
       // Skip the status-clear for a BUFFERED plain reply (STREAM_PLAIN_REPLY=false): nothing
       // prints yet, so the thinking ticker should keep animating until completion.
+      // #326: the turn's own machinery ("Starting 1 MCP server(s)…", "Composing answer…", the
+      // retrieval tally the group line now carries) is live status, not history. --verbose keeps it.
+      if (!plainReplyFlow && !REPL_VERBOSE && isScaffoldStep(line)) {
+        lastContentAt = Date.now();
+        continue;
+      }
       if (alreadyFlushed === 0 && !(plainReplyFlow && !STREAM_PLAIN_REPLY)) onContent();
       if (plainReplyFlow) {
         // Plain-reply content IS the answer. When STREAMING, print it live (default colour) and
@@ -11397,8 +11585,17 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         // one thing not to miss), and a neutral/informational step keeps the dim ● . The marker
         // hangs in the gutter (markLine); a long bullet wraps with every continuation row
         // re-indented to the SAME gutter, so it shares one text column with the prompt/answer.
-        const st = classifyBullet(line.trim());
-        const bRows = wrapBlock(line.trim(), GUTTER, process.stdout.columns || 80);
+        // Paths under this folder are shown relative to it (#326): the folder is on the bar.
+        const stepText = relativizePaths(line.trim(), turnCwd);
+        // A LOOK-UP joins the turn's open group — one counted row, a click away from the lines
+        // it stands for — instead of printing a line of its own.
+        if (isGroupableStep(stepText, bulletKind(stepText))) {
+          addLookupStep(stepText);
+          lastWasBlank = false;
+          continue;
+        }
+        const st = classifyBullet(stepText);
+        const bRows = wrapBlock(stepText, GUTTER, process.stdout.columns || 80);
         // One empty line above EVERY bullet now (see openBullet), which SUBSUMES the old
         // special case that opened only the turn's final phase — opensAnswerPhase's blank is
         // just one of these. Still idempotent, so it cannot double the seam the caller owns.
@@ -11660,7 +11857,15 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         if (seenRaw.length < 4096) {
           seenRaw = (seenRaw + text.slice(shownChars)).slice(0, 4096);
         }
-        consume(text.slice(shownChars));
+        // #326: only the turn's WORK is shown live — the step lines and thoughts inside
+        // <think>. What follows the fence is the ANSWER, which the caller prints once from the
+        // completed text; fed to the step printer it came out as "●" bullets and then again
+        // under "recap:". A plain chat reply is the exception: its live stream IS its output.
+        const live = splitLiveStream(text.slice(shownChars), liveSplit);
+        liveSplit = live.state;
+        for (const part of live.parts) {
+          if (part.inside || plainReplyFlow) consume(part.text);
+        }
         shownChars = text.length;
       }
       // Interactive command-approval gate: the agent paused on a risky command. Show the
@@ -12234,7 +12439,11 @@ async function main() {
         const nSkills = currentSkills().length;
         const nMcp = listMcpServers({ cwd: process.cwd() }).servers.filter((x) => x.runnable).length;
         const bits = [nSkills ? `${nSkills} skill${nSkills === 1 ? "" : "s"}` : "", nMcp ? `${nMcp} MCP server${nMcp === 1 ? "" : "s"}` : ""].filter(Boolean);
-        if (bits.length) statusRows.push(dim(bits.join(" · ") + "  (/help · /mcp)"));
+        // #325: say whose they are when this folder uses Claude Code's — even when there are none.
+        const claudes = readSkillSource(process.cwd()) === "claude";
+        if (bits.length || claudes) {
+          statusRows.push(dim((claudes ? "Claude's: " : "") + (bits.join(" · ") || "no skills or MCP servers") + (claudes ? "  (/switch-skill · /mcp)" : "  (/help · /mcp)")));
+        }
       } catch {
         /* a broken file is reported below; the banner is not the place to fail */
       }
@@ -12251,7 +12460,7 @@ async function main() {
       for (const w of hk.warnings) console.log(GUTTER + yellow(w));
       if (hk.projectPending) {
         console.log(
-          GUTTER + yellow("This folder's .gonext/settings.json has hooks that will not run until you approve them.") +
+          GUTTER + yellow(`This folder's ${hk.projectFile.replace(/^\.\//, "")} has hooks that will not run until you approve them.`) +
             "\n" + GUTTER + dim("  /hooks shows the commands · /hooks approve")
         );
       }
@@ -12890,6 +13099,10 @@ async function main() {
       await runMcpSlashCommand(line);
       continue;
     }
+    if (line === "/switch-skill" || line.startsWith("/switch-skill ")) {
+      await runSwitchSkillCommand(line);
+      continue;
+    }
     if (line === "/hooks" || line.startsWith("/hooks ")) {
       const { runHooksCommand } = await import("./hooks-command.mjs");
       const style = { ok: accent, warn: yellow, dim };