@tiens.nguyen/gu-cli 1.0.739 → 1.0.741

package/gonext_agent_chat.py

@@ -4764,6 +4764,9 @@ _RAG_SKIP_DIRS = {
     # .github, .vscode or .claude — those carry CI config, editor settings and project
     # instructions a coding agent legitimately benefits from reading.
     ".claude-memory", ".specstory", ".aider.tags.cache.v3", ".goose",
+    # gu's OWN memory store (the memory skill's .gu-memory/, task #269): the agent reaches it
+    # through the memory MCP tools, which query it — not by grepping raw checkpoint markdown.
+    ".gu-memory",
 }
 # Machine-generated files that are TEXT but never worth reading. A lockfile is the whole
 # problem in miniature: in the reported Next.js project package-lock.json is 239KB while every
@@ -6695,6 +6698,9 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline
         _emit({"type": "step", "text": "Awaiting your choice: compact the context?"})
     elif command.startswith("__S3SETUP__::"):
         _emit({"type": "step", "text": "Awaiting your choice: set up S3, or save on this computer?"})
+    elif command.startswith("__MCPTOOL__::"):
+        _srv, _, _rest = command[len("__MCPTOOL__::"):].partition("\t")
+        _emit({"type": "step", "text": f"Awaiting your approval: MCP tool {_srv}/{_rest.split(chr(9))[0]}"})
     else:
         _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
     deadline = _t.time() + max(30, int(deadline_s))  # per-call; risky=180s, __MAXSTEP__ long
@@ -7073,6 +7079,12 @@ def run_agent_chat(cfg):
     # risky command and asks the user via the API instead of hard-blocking it.
     _job_id = (cfg.get("jobId") or "").strip()
     _interactive_approval = bool(cfg.get("interactiveApproval"))
+    # Skills and MCP servers (task #269). The worker scans ~/.gonext/skills, ~/.gonext/mcp.json and
+    # this folder's .gonext/skills + .mcp.json for every turn; none present = neither appears
+    # anywhere in the prompt. Names only here — a skill's body is read when it is used.
+    import gu_skills as _skills_mod
+    _skills = _skills_mod.clean_list(cfg.get("skills"))
+    _mcp_cfg = cfg.get("mcp") if isinstance(cfg.get("mcp"), dict) else {}
 
     def _ask_s3_setup() -> bool:
         """Private mode, a file to hand over, no S3 of the user's own (task #252): ask in the
@@ -7230,6 +7242,40 @@ def run_agent_chat(cfg):
     # below. Otherwise the keyword router matches URLs/"api"/"GET" from prior turns
     # and fires the agent on trivial replies like "thanks" or "good".
     latest_user_text = task_text
+    # `/<skill> request` typed in the terminal (task #269): the skill's instructions go in with
+    # the request, for this turn only — the history keeps the short line the user typed.
+    _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: "
+                     + (_sk_req or "(nothing more — do what the skill describes)"))
+        _log(f"skill invoked: {_sk['name']}")
+
+    # HOOKS (task #270): onStart on the first turn of a gu session, onAsk on every question. What
+    # they print goes in beside the task; exit 2 from onAsk stops the turn before any model call.
+    import gu_hooks as _hooks_mod
+    _hooks = _hooks_mod.from_cfg(cfg, _log)
+    _hook_context = ""
+    if _hooks:
+        _hr_parts, _hr_warn = [], []
+        if _hooks.has("onStart") and _hooks_mod.is_new_session(_hooks.cwd or "", _hooks.session_id):
+            _r = _hooks.run("onStart", {"source": "startup"})
+            _hr_parts.append(_r.text)
+            _hr_warn += _r.warnings
+        if _hooks.has("onAsk"):
+            _r = _hooks.run("onAsk", {"question": latest_user_text})
+            _hr_warn += _r.warnings
+            if _r.blocked:
+                _emit({"type": "final", "text": f"Stopped by your onAsk hook: {_r.blocked}"})
+                return
+            _hr_parts.append(_r.text)
+        for _w in _hr_warn:
+            _emit({"type": "step", "text": f"⚠ {_w}"})
+        _hook_context = "\n\n".join(p for p in _hr_parts if p.strip())
+        if _hook_context:
+            _log(f"hooks added {len(_hook_context)} chars of context")
+            task_text += ("\n\nCONTEXT FROM YOUR gu HOOKS (onStart/onAsk — background, not the "
+                          f"request itself):\n{_hook_context}")
 
     # Walk prior turns newest-first, keeping condensed lines until the budget is
     # spent, then restore chronological (oldest→newest) order.
@@ -7862,6 +7908,11 @@ def run_agent_chat(cfg):
         needs_agent = True
     else:
         needs_agent = _route(latest_user_text, agent_base_url, agent_api_key, agent_model_id)
+    # A skill the user typed is work to DO with tools — plain chat cannot follow one.
+    if not needs_agent and _skill_call:
+        _log("router → YES (skill invoked)")
+        _emit({"type": "step", "text": "→ Agent mode (skill)"})
+        needs_agent = True
     # A pending email awaiting 'confirm' must reach the agent even though a bare
     # 'confirm' / 'send it' is not a network keyword — otherwise the send never fires.
     if not needs_agent and _email_confirm_pending():
@@ -8128,7 +8179,10 @@ def run_agent_chat(cfg):
         # told to manage; a model that believes otherwise turns "own the environment" into
         # "write the user instructions for owning it" — see _machine_context.
         + _machine_context(_sys_platform(), _sys_arch(), _WS_ACTIVE or "")
-        + "WORK LIKE A SENIOR DEVELOPER — you OWN the task until it DEMONSTRABLY works:\n"
+        # "the task you were GIVEN": ownership is of the request, not of everything it mentions.
+        # `create task "only keep logo on flash screen"` asks for a RECORD; read as "own the logo
+        # change", the agent saved the task and then went on to do it (scaffold rule 8).
+        + "WORK LIKE A SENIOR DEVELOPER — you OWN the task you were GIVEN until it DEMONSTRABLY works:\n"
         "    * OUTCOME over exit code: a command exiting 0 is NOT the goal. After any "
         "state-changing step (start/build/install/edit), VERIFY the intended EFFECT "
         "(server responds, artifact exists, test green, file contains the change) before "
@@ -8270,6 +8324,7 @@ def run_agent_chat(cfg):
         "When you have enough to answer, call final_answer(<your answer>) in a code block. "
         "Prefer FEWER steps, and never repeat a tool call that already succeeded.\n\n"
         "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
+        + _skills_mod.prompt_block(_skills)
         + _rag_tool_block + _ws_tool_block + _auto_test_block +
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
@@ -8383,8 +8438,9 @@ def run_agent_chat(cfg):
         # Task #90: ~25-token echo of the autonomy contract at the highest-attention spot
         # (recency — right next to the task), reinforcing the full directive that lives in
         # the cached reference above. Workspace/coding mode only.
-        + ("Remember: FINISH it yourself — fix blockers, VERIFY the outcome, then "
-           "final_answer with evidence; never hand the task back.\n"
+        + ("Remember: FINISH what was asked yourself — fix blockers, VERIFY the outcome, then "
+           "final_answer with evidence; never hand the task back. If it only asks to RECORD work "
+           "(create a task, a note, a plan), recording it IS the task — do not start the work.\n"
            if _WS_AVAILABLE else "")
         + "\nTASK (answer THIS, choose the tool that fits it):\n"
         f"{task_text}\n"
@@ -12405,6 +12461,67 @@ def run_agent_chat(cfg):
             # (S3 indexing) isn't configured.
             if not _RAG_AVAILABLE:
                 agent_tools += [list_dir, read_text_file]
+        # SKILLS (task #269): only offered when at least one exists, like every tool above.
+        if _skills:
+            @tool
+            def use_skill(name: str) -> str:
+                """Load a skill's full instructions by its name from the SKILLS list. Call it FIRST when the task matches a skill, then follow what it returns.
+
+                Args:
+                    name: the skill's name, exactly as listed under SKILLS
+                """
+                return _skills_mod.use_skill_text(_skills, name)
+
+            agent_tools.append(use_skill)
+        # MCP SERVERS (task #269): every tool of every server that starts, named
+        # mcp__<server>__<tool>. A server that does not start is a note for this turn, not a
+        # failure of it. Each call passes _mcp_approve first. Not for the between-turns index job,
+        # which calls no model and would start the servers for nothing.
+        _mcp_servers = [s for s in (_mcp_cfg.get("servers") or [])
+                        if isinstance(s, dict) and s.get("name") and s.get("command")]
+        if _mcp_servers and not cfg.get("ragIndexOnly"):
+            import atexit as _atexit
+            import gu_mcp as _mcp_mod
+            from smolagents import Tool as _SmolTool
+            _mcp_turn_allowed: set = set()
+
+            def _mcp_approve(server: str, tool_name: str, args: dict):
+                """deny → allow → ask (Claude Code's order). The rules are re-read from the file on
+                every call: an "Always allow" answered a moment ago was written there."""
+                allow, deny = _mcp_mod.read_rules(_mcp_cfg.get("configPath"),
+                                                  _mcp_cfg.get("allow") or [], _mcp_cfg.get("deny") or [])
+                verdict = _mcp_mod.decide(allow, deny, server, tool_name)
+                if verdict == "deny":
+                    return False, (f"MCP tool {server}/{tool_name} is blocked by a deny rule in "
+                                   "~/.gonext/mcp.json. Do not call it again; carry on without it.")
+                if verdict == "allow" or (server, tool_name) in _mcp_turn_allowed:
+                    return True, ""
+                if not (_interactive_approval and _job_id and worker_api_base and worker_api_key):
+                    return False, (f"MCP tool {server}/{tool_name} needs the user's approval and this "
+                                   "session cannot ask. Tell the user to allow it in the gu terminal "
+                                   f"(/mcp allow {server}), then carry on without it.")
+                preview = json.dumps(args, ensure_ascii=False, default=str)
+                if len(preview) > 240:
+                    preview = preview[:240] + "…"
+                ok = _ws_request_approval(worker_api_base, worker_api_key, _job_id,
+                                          f"__MCPTOOL__::{server}\t{tool_name}\t{preview}", "")
+                if ok:
+                    _mcp_turn_allowed.add((server, tool_name))
+                    return True, ""
+                return False, (f"The user declined MCP tool {server}/{tool_name}. Do not call it again "
+                               "this turn; carry on without it or ask the user.")
+
+            _emit({"type": "step", "text": f"Starting {len(_mcp_servers)} MCP server(s)…"})
+            _mcp_conn, _mcp_notes = _mcp_mod.connect_all(_mcp_servers, _WS_ACTIVE or None, log=_log)
+            _atexit.register(lambda: [c.close() for c, _t in _mcp_conn])
+            for _note in _mcp_notes:
+                _emit({"type": "step", "text": _note})
+            agent_tools += _mcp_mod.build_tools(_mcp_conn, _SmolTool, _mcp_approve)
+        # onToolDone (task #270): after every tool the hooks' matchers name — MCP tools included.
+        if _hooks:
+            _n_wrapped = _hooks_mod.wrap_tools(agent_tools, _hooks)
+            if _n_wrapped:
+                _log(f"onToolDone hooks on {_n_wrapped} tool(s)")
         # Fill in the numbered tool list now that the REAL tool objects exist — see
         # _render_numbered_tool_list and the {{TOOL_LIST}} placeholder left in tool_hint.
         task_with_hint = task_with_hint.replace(
@@ -12579,6 +12696,12 @@ def run_agent_chat(cfg):
         final_text = _strip_tool_tags(str(result).strip()) or "[No result]"
         _log(f"done (deterministic, no summarizer call): {len(final_text)} chars")
         _emit({"type": "final", "text": final_text})
+        # onTurnEnd (task #270): after the answer is out, so a slow hook never delays it.
+        if _hooks and _hooks.has("onTurnEnd"):
+            _te = _hooks.run("onTurnEnd", {"question": latest_user_text, "answer": final_text,
+                                           "partial": bool(_maxsteps_partial.get("hit"))})
+            for _w in _te.warnings:
+                _log(f"onTurnEnd: {_w}")
         # Clear the step checkpoint ONLY on a genuinely complete finish (the model's own
         # final_answer, or a deterministic PDF delivery) — that content is now in the
         # answer pushed to conversation history, so the raw trace is no longer needed.

package/gu-cli.mjs

@@ -33,6 +33,40 @@ import { createRequire } from "node:module";
 import dotenv from "dotenv";
 import OpenAI from "openai";
 import { resolvePython } from "./platform-tools.mjs";
+import { skillsForTurn } from "./skills.mjs";
+import { mcpForTurn } from "./mcp-config.mjs";
+import { hooksForTurn, sessionForTurn } from "./hooks-config.mjs";
+
+/** The `skills` / `mcp` fields of one job's agent config (task #269). A broken config is a log
+ *  line, never a failed turn — the turn runs without them. */
+function skillsAndMcpForJob(cwd) {
+  const out = {};
+  try {
+    const skills = skillsForTurn({ cwd });
+    if (skills.length) out.skills = skills;
+  } catch (e) {
+    console.log(`[gu-worker] skills skipped: ${e?.message || e}`);
+  }
+  try {
+    const mcp = mcpForTurn({ cwd });
+    if (mcp.servers.length) out.mcp = mcp;
+  } catch (e) {
+    console.log(`[gu-worker] MCP servers skipped: ${e?.message || e}`);
+  }
+  // Hooks (task #270): yours, plus the project's once approved; and the terminal session this
+  // turn belongs to, so the agent knows when onStart is due.
+  try {
+    const hooks = hooksForTurn({ cwd });
+    if (Object.keys(hooks).length) {
+      out.hooks = hooks;
+      const session = sessionForTurn(cwd);
+      if (session) out.hookSession = session;
+    }
+  } catch (e) {
+    console.log(`[gu-worker] hooks skipped: ${e?.message || e}`);
+  }
+  return out;
+}
 
 const WORKER_DIR = dirname(fileURLToPath(import.meta.url));
 
@@ -223,6 +257,26 @@ if (args[0] === "token") {
   process.exit(0);
 }
 
+if (args[0] === "mcp") {
+  // #269. MCP servers from a shell — `claude mcp add`'s shape. Same code as /mcp in the terminal UI.
+  const { runMcpCommand } = await import("./mcp-command.mjs");
+  const code = await runMcpCommand(args.slice(1), {
+    cwd: process.cwd(),
+    print: (line, kind) => (kind === "warn" ? console.error(line) : console.log(line)),
+  });
+  process.exit(code);
+}
+
+if (args[0] === "hooks") {
+  // #270. Hooks from a shell — same code as /hooks in the terminal UI.
+  const { runHooksCommand } = await import("./hooks-command.mjs");
+  const code = await runHooksCommand(args.slice(1), {
+    cwd: process.cwd(),
+    print: (line, kind) => (kind === "warn" ? console.error(line) : console.log(line)),
+  });
+  process.exit(code);
+}
+
 if (args[0] === "full-log") {
   // #250. An administrator switches Enable Full Log (#249) from a terminal — after typing an admin
   // token minted on the web admin page. Same code as /full-log in the terminal UI.
@@ -3836,6 +3890,10 @@ async function runAgentChatJob(job) {
       // Task #134: set when the terminal's folder is on ANOTHER machine. The agent surfaces
       // it to the user — a silent downgrade to "no file tools" would just look broken.
       ...(remoteWorkspace ? { remoteWorkspace } : {}),
+      // Skills and MCP servers (task #269), read from disk for EVERY job so an edited, added or
+      // deleted SKILL.md / server takes effect on the next turn with no restart. The project's
+      // own ones only when its folder is on this machine. None = the keys are absent.
+      ...skillsAndMcpForJob(terminalActiveWs && wsExistsHere ? terminalActiveWs : null),
     });
     // Agent run time budget (task #81). Default 60 min; user-configurable in web Settings
     // (agentTimeoutMinutes → payload.agentTimeoutMs). Multi-step ReAct on a 14B/31B with a

package/gu-repl.mjs

@@ -35,7 +35,7 @@ import { dirname, join, resolve, basename } from "node:path";
 import { fileURLToPath } from "node:url";
 import { PassThrough } from "node:stream";
 import { createInterface } from "node:readline";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import dotenv from "dotenv";
 // Pure layout arithmetic for every in-place block (bottom bar, live status, pickers) — kept
@@ -117,8 +117,14 @@ import {
   identityRow,
   CANCEL_LINE,
   shouldCancelPrompt,
+  rankSlashCommands,
+  slashMenuWindow,
 } from "./terminal-layout.mjs";
 import { completedFlush } from "./completed-flush.mjs";
+import { discoverSkills, matchSkillCommand } from "./skills.mjs";
+import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
+import { unapprovedProjectServers } from "./mcp-command.mjs";
+import { readHooks } from "./hooks-config.mjs";
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
 import {
@@ -532,7 +538,7 @@ const argv = process.argv.slice(2);
 // process.argv and exits inside its own subcommand branch, before it ever starts polling.
 const CLI_SUBCOMMANDS = [
   "status", "start", "stop", "restart", "logs", "doctor", "login", "set", "rag",
-  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log",
+  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log", "mcp", "hooks",
 ];
 // `gu logz` USED TO START THE REPL (task #181). Silently: an unrecognised word was not in
 // the list, so it fell through to "no subcommand given" and a full agent session opened in that
@@ -807,6 +813,8 @@ const COMMANDS = [
   { name: "/doctor", desc: "check every configured model ANSWERS — especially the embedder, which a turn only reaches after several steps" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
   { name: "/full-log", usage: "/full-log [on|off|status] [account]", desc: "administrators: Enable Full Log for an account — asks for an admin token from the web admin page first" },
+  { 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: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -814,22 +822,50 @@ const COMMANDS = [
 // terminal-layout.mjs — their handlers are below, above the unknown-command guard. Not
 // imported here: nothing in the REPL reads the list, the tests do (task #153).
 const COMMAND_NAMES = COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]);
+// SKILLS ARE COMMANDS TOO (task #269): each ~/.gonext/skills/<name>/SKILL.md (and this folder's
+// .gonext/skills) is /<name>, in Tab-completion and /help like any other. Scanned from disk — kept
+// for 2s only, because the overlay asks on every keystroke — so a skill added, edited or DELETED
+// while gu runs shows up (or quietly disappears) without a restart. A built-in name always wins.
+let _skillScan = { at: 0, skills: [] };
+function currentSkills() {
+  if (Date.now() - _skillScan.at > 2000) {
+    try {
+      _skillScan = { at: Date.now(), skills: discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES }).skills };
+    } catch {
+      _skillScan = { at: Date.now(), skills: [] };
+    }
+  }
+  return _skillScan.skills;
+}
+const skillCommands = () =>
+  currentSkills()
+    .filter((s) => s.slash)
+    .map((s) => ({ name: `/${s.name}`, usage: `/${s.name} [request]`, desc: `skill — ${firstSentence(s.description)}`, skill: true }));
+/** A skill's description is written for the MODEL and often runs a paragraph; /help shows one line. */
+function firstSentence(text, max = 100) {
+  const one = String(text ?? "").split(/(?<=[.!?])\s/)[0].trim();
+  return one.length > max ? one.slice(0, max - 1).trimEnd() + "…" : one;
+}
+const allCommands = () => [...COMMANDS, ...skillCommands()];
+const allCommandNames = () => [...COMMAND_NAMES, ...skillCommands().map((c) => c.name)];
 // Tab-completion: when the line starts with "/", complete against the command names.
 function slashCompleter(line) {
   if (!line.startsWith("/")) return [[], line];
-  const hits = COMMAND_NAMES.filter((n) => n.startsWith(line));
-  return [hits.length ? hits : COMMAND_NAMES, line];
+  const names = allCommandNames();
+  const hits = names.filter((n) => n.startsWith(line));
+  return [hits.length ? hits : names, line];
 }
 // Commands whose name/alias matches the typed prefix (all when prefix is "" or "/").
 function filteredCommands(prefix = "") {
   const p = (prefix ?? "").trim();
-  const m = COMMANDS.filter(
+  const cmds = allCommands();
+  const m = cmds.filter(
     (c) =>
       !p ||
       p === "/" ||
       [c.name, ...(c.aliases ?? [])].some((n) => n.startsWith(p))
   );
-  return m.length ? m : COMMANDS;
+  return m.length ? m : cmds;
 }
 // Display rows for a filtered command set; row `sel` (if >=0) is highlighted (❯ + bold).
 function hintRows(cmds, sel) {
@@ -1648,14 +1684,28 @@ function slashOverlaySeq(line, cursor, menu, cols) {
 }
 
 // Redraw the input line AND the command menu below it, fully in place.
+// A short WINDOW over the ranked matches, not the whole registry (task #271): a bare "/" used to
+// draw every command and skill at once. ↑/↓ move through ALL matches and the window follows.
+let slashTop = 0;
+function slashMenuRows(cmds, sel, win, line) {
+  if (!cmds.length) {
+    return [dim(`  no command matches ${line.trim().split(/\s+/)[0]} — /help lists them all`)];
+  }
+  const rows = hintRows(cmds.slice(win.from, win.to), sel - win.from);
+  if (win.above) rows.splice(1, 0, dim(`  ⋯ ${win.above} more above`));
+  if (win.below) rows.push(dim(`  ⋯ ${win.below} more — keep typing to narrow`));
+  return rows;
+}
 function renderSlashOverlay(sel) {
   const line = rl.line;
-  const cmds = filteredCommands(line);
+  const cmds = rankSlashCommands(allCommands(), line);
   slashNames = cmds.map((c) => c.name);
   if (sel >= cmds.length) sel = cmds.length - 1;
   slashSel = sel;
   slashPrefix = line;
-  const menu = hintRows(cmds, sel);
+  const win = slashMenuWindow(cmds.length, sel, slashTop);
+  slashTop = win.top;
+  const menu = slashMenuRows(cmds, sel, win, line);
   if (!slashOverlayActive) {
     slashOverlayActive = true;
     slashNeutralizeHistory();
@@ -1680,6 +1730,7 @@ function closeSlashOverlay() {
   slashOverlayActive = false;
   slashHintRows = 0;
   slashSel = -1;
+  slashTop = 0;
   slashNames = [];
   slashRestoreHistory();
 }
@@ -4404,6 +4455,23 @@ async function loadSessionUnfinishedTask(cwd) {
  * `mutate` receives the parsed object and may return a replacement or mutate in place.
  */
 let _sessionWrite = Promise.resolve();
+/**
+ * Mark the start of a gu session in this folder's session file (task #270). The worker reads the
+ * id back (hooks-config.mjs sessionForTurn) and the agent runs onStart hooks on the first turn it
+ * sees it — which is how "a session started" reaches the agent with nothing added to the API.
+ */
+async function startHookSession(cwd) {
+  try {
+    await updateSessionFile(cwd, (s) => {
+      s.hookSessionId = randomUUID();
+      s.hookSessionStartedAt = new Date().toISOString();
+      return s;
+    });
+  } catch {
+    /* no session file = no onStart this time, never a failed start */
+  }
+}
+
 async function updateSessionFile(cwd, mutate) {
   const run = async () => {
     let raw = {};
@@ -7185,6 +7253,21 @@ async function runFullLogCommand(line) {
   console.log("");
 }
 
+/**
+ * /mcp (#269) — the same code as `gu mcp`. `/mcp add` alone asks step by step; its questions go
+ * through ask(), whose label is drawn in the frozen row (a readline prompt alone is invisible there).
+ */
+async function runMcpSlashCommand(line) {
+  const { runMcpCommand, splitWords } = await import("./mcp-command.mjs");
+  const style = { ok: accent, warn: yellow, dim };
+  await runMcpCommand(splitWords(line).slice(1), {
+    cwd: process.cwd(),
+    ask: (label) => ask(label + " "),
+    print: (l, kind) => console.log(GUTTER + (style[kind] ?? ((x) => x))(l)),
+  });
+  console.log("");
+}
+
 async function runProxyCommand(line) {
   const cmd = await import("./proxy-command.mjs");
   const store = await import("./proxy-store.mjs");
@@ -8250,6 +8333,10 @@ const COMPACT_PREFIX = "__COMPACT__::";
 // Private mode, a file to hand over, and no S3 of the user's own (task #252): set it up now, or
 // save the file on this computer. Allow = S3 is now set up AND passed its test.
 const S3SETUP_PREFIX = "__S3SETUP__::";
+// An MCP tool about to run for the first time (task #269): "<server>\t<tool>\t<args preview>".
+// "Always" writes an allow rule to ~/.gonext/mcp.json — the agent re-reads that file before every
+// call, so it counts from the next call of this same turn, and for every turn after.
+const MCPTOOL_PREFIX = "__MCPTOOL__::";
 async function approvalPrompt(command) {
   // Wipe the live "thinking" status block BEFORE any picker draws, and stop the ticker from
   // redrawing it (the tick early-returns while a picker is active) — otherwise the block
@@ -8307,6 +8394,29 @@ async function approvalPrompt(command) {
     );
     return { allow: idx === 0, dontAsk: false };
   }
+  if (command.startsWith(MCPTOOL_PREFIX)) {
+    const [server = "", tool = "", preview = ""] = command.slice(MCPTOOL_PREFIX.length).split("\t");
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write(
+      "\n" + yellow(`⚙ Allow the MCP tool ${server}/${tool}?`) + dim("  (no answer in ~3 min = No)") + "\n" +
+        (preview ? dim("  " + preview) + "\n" : "")
+    );
+    const idx = await pickFromList(
+      ["Yes", `Yes, and always allow ${server}/${tool}`, `Yes, and always allow every ${server} tool`, "No"],
+      0,
+      { timeoutMs: 170000, timeoutIndex: 3 }
+    );
+    if (idx === 1 || idx === 2) {
+      const rule = idx === 1 ? `mcp__${server}__${tool}` : `mcp__${server}__*`;
+      try {
+        addAllowRule({ rule });
+        process.stdout.write(dim(`  (won't ask again: ${rule} — undo with /mcp disallow ${server})\n`));
+      } catch (e) {
+        process.stdout.write(yellow(`  could not save that (${e?.message || e}) — allowed this once\n`));
+      }
+    }
+    return { allow: idx >= 0 && idx <= 2, dontAsk: false };
+  }
   const isMax = command.startsWith(MAXSTEP_PREFIX);
   if (isMax) {
     const label = command.slice(MAXSTEP_PREFIX.length);
@@ -10665,8 +10775,42 @@ async function main() {
         const plan = acct.plan ? (acct.pro ? accent(acct.plan) : dim(acct.plan)) : "";
         statusRows.push(acct.email ? dim(`account ${acct.email}`) + (plan ? dim(" · ") + plan : "") : dim("plan ") + plan);
       }
+      // Skills and MCP servers (task #269) — one row, only when there are any.
+      try {
+        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)"));
+      } catch {
+        /* a broken file is reported below; the banner is not the place to fail */
+      }
       console.log(renderBanner(statusRows));
     }
+    // Skills and MCP (task #269): say what is BROKEN or WAITING, and nothing when all is well. A
+    // deleted skill is not broken — it is simply gone, and says nothing.
+    try {
+      for (const w of discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES }).warnings) {
+        console.log(GUTTER + yellow(w));
+      }
+      // Hooks (task #270): a Claude Code event name, a broken file, or project hooks waiting.
+      const hk = readHooks({ cwd: process.cwd() });
+      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.") +
+            "\n" + GUTTER + dim("  /hooks shows the commands · /hooks approve")
+        );
+      }
+      const waiting = unapprovedProjectServers(process.cwd());
+      if (waiting.length) {
+        console.log(
+          GUTTER + yellow(`This folder's .mcp.json names ${waiting.length} MCP server(s) that will not start until you approve them: ${waiting.map((x) => x.name).join(", ")}`) +
+            "\n" + GUTTER + dim("  /mcp shows the command each one runs · /mcp approve <name>")
+        );
+      }
+    } catch {
+      /* never block startup on this */
+    }
     // Task #127, Phase 3: if the base chat model server isn't answering, offer to set it up
     // (download + start mlx_lm.server). BC3: only runs when NOTHING answers — an already-up
     // model is left untouched, and this is skipped entirely. Interactive TTYs only.
@@ -10966,6 +11110,8 @@ async function main() {
 
   const cwd = resolve(process.cwd());
   const history = await loadSession(cwd);
+  // A new gu session (task #270): the agent runs onStart hooks on the first turn it sees this id.
+  await startHookSession(cwd);
   if (history.length > 0) {
     const turns = history.filter((m) => m.role === "user").length;
     console.log(
@@ -11220,6 +11366,20 @@ async function main() {
       await runFullLogCommand(line);
       continue;
     }
+    if (line === "/mcp" || line.startsWith("/mcp ")) {
+      await runMcpSlashCommand(line);
+      continue;
+    }
+    if (line === "/hooks" || line.startsWith("/hooks ")) {
+      const { runHooksCommand } = await import("./hooks-command.mjs");
+      const style = { ok: accent, warn: yellow, dim };
+      await runHooksCommand(line.split(/\s+/).slice(1), {
+        cwd: process.cwd(),
+        print: (l, kind) => console.log(GUTTER + (style[kind] ?? ((x) => x))(l)),
+      });
+      console.log("");
+      continue;
+    }
     if (line === "/proxy" || line.startsWith("/proxy ")) {
       await runProxyCommand(line);
       continue;
@@ -11312,6 +11472,7 @@ async function main() {
     if (line === "/reset" || line === "/new") {
       history.length = 0;
       await clearSession(cwd);
+      await startHookSession(cwd); // a fresh session: onStart hooks run again (#270)
       console.log(GUTTER + dim("Session cleared — starting fresh.\n"));
       continue;
     }
@@ -11381,7 +11542,10 @@ async function main() {
     }
     // Any OTHER "/…" is a typo/unknown command — don't send it to the agent as a
     // question; point the user at /help (all real commands were handled above).
-    if (line.startsWith("/")) {
+    // …EXCEPT a skill (task #269): "/<skill> request" goes to the agent as typed, and the agent
+    // loads that skill's SKILL.md for the turn. Checked against the disk NOW, so a skill deleted a
+    // moment ago is an unknown command like any other, not an error.
+    if (line.startsWith("/") && !matchSkillCommand(line, currentSkills())) {
       const cmd = line.split(/\s+/)[0];
       console.log(GUTTER + dim(`unknown command: ${cmd} — type /help (or / then Tab) to list commands\n`));
       continue;