@tiens.nguyen/gu-cli 1.0.784 → 1.0.785

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,13 @@ import {
   rankSlashCommands,
   slashMenuWindow,
 } from "./terminal-layout.mjs";
-import { completedFlush } from "./completed-flush.mjs";
+import { completedFlush, splitLiveStream } from "./completed-flush.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 +896,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 +1004,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 +2597,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 +2621,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 +2783,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 +2809,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 +2835,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 +3016,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;
@@ -3420,8 +3437,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 : "";
 }
@@ -3632,7 +3651,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 +3664,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 +7181,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 +9607,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 +9618,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 +9884,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 +9905,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 +10787,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
@@ -11660,7 +11772,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 +12354,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 +12375,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 +13014,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 };

package/gu_hooks.py

@@ -17,6 +17,18 @@ A hook that fails any other way, or runs past its timeout, is a warning — neve
 
 WHAT A HOOK SEES: its own env on a short whitelist of this process's (the worker's env carries gu's
 credentials), plus GU_PROJECT_DIR and GU_HOOK_EVENT. It runs in the project folder.
+
+CLAUDE CODE'S HOOKS (task #325). A folder that chose "Claude's skills" hands over hooks read from
+Claude Code's settings; their groups carry dialect "claude". Those commands were written for Claude
+Code, so gu speaks Claude's vocabulary TO THEM and to nobody else:
+    the event      SessionStart / UserPromptSubmit / PostToolUse / Stop, as "hook_event_name"
+    the tool       Edit, Write, Read, Grep, Glob, Bash — for the matcher AND in the input, with
+                   Claude's argument names (file_path, not path)
+    the fields     prompt (question), tool_response (tool_result), last_assistant_message (answer)
+    the answer     {"hookSpecificOutput": {"additionalContext": ...}} is read like gu's own shape
+Measured with a real Claude memory hook: given gu's names it never ran; given Claude's event names
+but gu's tool names and fields it ran and recorded nothing; given all of the above it recorded the
+lookups and edits (with line ranges) and gave the next session its memory back.
 """
 from __future__ import annotations
 
@@ -36,6 +48,62 @@ _ENV_KEEP = ("PATH", "HOME", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR", "TEMP", "TM
 _PLAIN_MATCHER = re.compile(r"^[A-Za-z0-9_\-| ,]*$")
 
 
+# ---- Claude Code's vocabulary (#325) -----------------------------------------------------------
+
+CLAUDE_EVENT = {"onStart": "SessionStart", "onAsk": "UserPromptSubmit",
+                "onToolDone": "PostToolUse", "onTurnEnd": "Stop"}
+
+
+def claude_tool(name: str, args: Any) -> tuple[str, dict]:
+    """gu's tool call as Claude Code would have named it. Unknown tools (mcp__server__tool, which
+    both spell the same way) pass through unchanged."""
+    a = dict(args) if isinstance(args, dict) else {}
+    path = a.get("path")
+    if name == "edit_file":
+        return "Edit", {"file_path": path, "old_string": a.get("old_string", ""),
+                        "new_string": a.get("new_string", "")}
+    if name == "edit_lines":
+        # No old text to give: the new text is what a hook looks for in the file.
+        return "Edit", {"file_path": path, "old_string": "", "new_string": a.get("new_content", ""),
+                        "start_line": a.get("start_line"), "end_line": a.get("end_line")}
+    if name == "create_file":
+        return "Write", {"file_path": path, "content": a.get("content", "")}
+    if name in ("read_file_lines", "read_text_file"):
+        out = {"file_path": path}
+        if a.get("start_line"):
+            out["offset"] = a.get("start_line")
+        return "Read", out
+    if name == "grep_repo":
+        return "Grep", {"pattern": a.get("pattern", ""), "path": path or "", "glob": a.get("glob", "")}
+    if name == "symbol_context":
+        return "Grep", {"pattern": a.get("name", ""), "path": path or ""}
+    if name == "list_dir":
+        return "Glob", {"pattern": (str(path or ".").rstrip("/\\") or ".") + "/*", "path": path or ""}
+    if name == "run_command":
+        return "Bash", {"command": a.get("command", "")}
+    return name, a
+
+
+def claude_payload(event: str, payload: dict) -> dict:
+    """One gu event's payload with Claude Code's field names."""
+    out = dict(payload)
+    if event == "onStart":
+        out.setdefault("source", "startup")
+    elif event == "onAsk":
+        out["prompt"] = out.pop("question", "")
+    elif event == "onToolDone":
+        out["tool_name"], out["tool_input"] = claude_tool(str(out.get("tool_name", "")), out.get("tool_input"))
+        out["tool_response"] = out.pop("tool_result", "")
+    elif event == "onTurnEnd":
+        out["last_assistant_message"] = out.pop("answer", "")
+        out["stop_hook_active"] = False
+    return out
+
+
+def is_claude(group: Any) -> bool:
+    return isinstance(group, dict) and group.get("dialect") == "claude"
+
+
 def matches(matcher: str | None, value: str) -> bool:
     """Empty or "*" = everything. Letters, digits, _ - and | = an exact list. Anything else = a regex."""
     m = (matcher or "").strip()
@@ -76,11 +144,24 @@ class HookRunner:
     def matcher_union(self, event: str) -> list[str]:
         return [g.get("matcher", "") for g in self.hooks.get(event) or [] if isinstance(g, dict)]
 
+    def wants_tool(self, name: str) -> bool:
+        """Does any onToolDone group name this tool — in gu's name for gu's hooks, in Claude Code's
+        for Claude's (a matcher "Edit|Write" means edit_file and create_file)."""
+        for g in self.hooks.get("onToolDone") or []:
+            # A group with nothing to run wraps no tool, whatever its matcher says.
+            if not isinstance(g, dict) or not any(isinstance(h, dict) and h.get("command") for h in g.get("hooks") or []):
+                continue
+            value = claude_tool(name, {})[0] if is_claude(g) else name
+            if matches(g.get("matcher"), value):
+                return True
+        return False
+
     def _env(self, event: str, extra: dict | None) -> dict:
         env = {k: os.environ[k] for k in _ENV_KEEP if k in os.environ}
         env.setdefault("PYTHONIOENCODING", "utf-8")
         env["GU_PROJECT_DIR"] = self.cwd or ""
         env["GU_HOOK_EVENT"] = event
+        env["CLAUDE_PROJECT_DIR"] = self.cwd or ""  # what a hook written for Claude Code reads
         for k, v in (extra or {}).items():
             env[str(k)] = str(v)
         return env
@@ -91,13 +172,27 @@ class HookRunner:
             return res
         body = {"event": event, "session_id": self.session_id, "cwd": self.cwd or "", **payload}
         data = json.dumps(body, ensure_ascii=False, default=str)
+        claude_data = claude_match = None  # built once, and only if a Claude hook is there
         for group in self.hooks.get(event) or []:
-            if not isinstance(group, dict) or not matches(group.get("matcher"), match_value):
+            if not isinstance(group, dict):
+                continue
+            if is_claude(group):
+                if claude_data is None:
+                    cbody = claude_payload(event, payload)
+                    claude_match = str(cbody.get("tool_name", "")) if event == "onToolDone" else match_value
+                    claude_data = json.dumps({"hook_event_name": CLAUDE_EVENT[event],
+                                              "session_id": self.session_id, "cwd": self.cwd or "",
+                                              "permission_mode": "default", **cbody},
+                                             ensure_ascii=False, default=str)
+                value, stdin = claude_match, claude_data
+            else:
+                value, stdin = match_value, data
+            if not matches(group.get("matcher"), value):
                 continue
             for h in group.get("hooks") or []:
                 if not isinstance(h, dict) or (h.get("type") or "command") != "command" or not h.get("command"):
                     continue
-                self._one(event, h, data, res)
+                self._one(event, h, stdin, res)
         return res
 
     def _one(self, event: str, h: dict, data: str, res: HookResult) -> None:
@@ -143,6 +238,10 @@ class HookRunner:
                 res.blocked = str(obj.get("reason") or err or f"the {event} hook {label} said no")
                 return
             ctx = obj.get("additionalContext")
+            if not isinstance(ctx, str):
+                # Claude Code's shape: {"hookSpecificOutput": {"hookEventName", "additionalContext"}}
+                inner = obj.get("hookSpecificOutput")
+                ctx = inner.get("additionalContext") if isinstance(inner, dict) else None
             if isinstance(ctx, str) and ctx.strip():
                 res.context.append(ctx)
 
@@ -185,11 +284,10 @@ def wrap_tools(tools: list, runner: HookRunner, clip: int = 4000) -> int:
     context is appended to the tool's result; a block (exit 2) is appended as a message."""
     if not runner.has("onToolDone"):
         return 0
-    matchers = runner.matcher_union("onToolDone")
     n = 0
     for t in tools:
         name = getattr(t, "name", "")
-        if not name or name == "final_answer" or not any(matches(m, name) for m in matchers):
+        if not name or name == "final_answer" or not runner.wants_tool(name):
             continue
         orig = t.forward
         order = list((getattr(t, "inputs", None) or {}).keys())