@tiens.nguyen/gu-cli 1.0.783 → 1.0.785

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())

package/gu_skills.py

@@ -21,8 +21,11 @@ def clean_list(skills) -> list[dict]:
     out = []
     for s in skills or []:
         if isinstance(s, dict) and s.get("name") and s.get("path"):
-            out.append({"name": str(s["name"]), "description": str(s.get("description") or ""),
-                        "path": str(s["path"]), "dir": str(s.get("dir") or os.path.dirname(str(s["path"])))})
+            item = {"name": str(s["name"]), "description": str(s.get("description") or ""),
+                    "path": str(s["path"]), "dir": str(s.get("dir") or os.path.dirname(str(s["path"])))}
+            if s.get("source") == "claude":
+                item["source"] = "claude"  # written for Claude Code — see CLAUDE_NOTE
+            out.append(item)
     return out
 
 
@@ -53,10 +56,67 @@ def find(skills: list[dict], name: str) -> dict | None:
     return next((s for s in skills if s["name"] == n), None)
 
 
-def render(skill: dict, body: str) -> str:
+# A SKILL WRITTEN FOR CLAUDE CODE (task #325) names Claude Code's tools. The instructions are still
+# the instructions; only the tool names differ, and the model is told which of its own to use.
+CLAUDE_NOTE = (
+    "This skill was written for Claude Code, so it names Claude Code's tools. Use yours instead: "
+    "Bash → run_command · Read → read_file_lines / read_text_file · Edit → edit_file / edit_lines · "
+    "Write → create_file · Grep → grep_repo · Glob / LS → list_dir. Tools named mcp__<server>__<tool> "
+    "are the same here. Anything else it names that you do not have (Task, TodoWrite, WebFetch, "
+    "a subagent…): do that part yourself with the tools you do have, or say that you cannot. "
+    "A line written as !`command` was meant to be run before you read this — it was NOT run; "
+    "run it yourself only if the task needs its output."
+)
+
+_ARG_INDEX_RE = re.compile(r"\$ARGUMENTS\[(\d+)\]|\$(\d+)\b")
+
+
+def split_args(request: str) -> list[str]:
+    """`"hello world" second` → ["hello world", "second"] — Claude Code's quoting."""
+    out, cur, quote, any_ = [], "", "", False
+    for ch in request or "":
+        if quote:
+            if ch == quote:
+                quote = ""
+            else:
+                cur += ch
+        elif ch in "\"'":
+            quote, any_ = ch, True
+        elif ch.isspace():
+            if cur or any_:
+                out.append(cur)
+            cur, any_ = "", False
+        else:
+            cur += ch
+    if cur or any_:
+        out.append(cur)
+    return out
+
+
+def substitute(skill: dict, body: str, request: str | None) -> str:
+    """Claude Code's placeholders in a skill body: $ARGUMENTS, $ARGUMENTS[N] / $N, and the skill's
+    own folder. `request` is None when the agent picked the skill itself — there are no arguments
+    then, and the placeholders are left as written rather than emptied."""
+    out = body.replace("${CLAUDE_SKILL_DIR}", skill.get("dir", ""))
+    if request is None:
+        return out
+    args = split_args(request)
+
+    def one(m):
+        i = int(m.group(1) if m.group(1) is not None else m.group(2))
+        return args[i] if i < len(args) else ""
+
+    return _ARG_INDEX_RE.sub(one, out).replace("$ARGUMENTS", request)
+
+
+def render(skill: dict, body: str, request: str | None = None) -> str:
+    claude = skill.get("source") == "claude"
+    if claude:
+        body = substitute(skill, body, request)
     return (f'SKILL "{skill["name"]}" — follow these instructions for this task. Files the skill '
             f'mentions by relative path are in {skill["dir"]}.\n'
-            f"<skill>\n{body}\n</skill>")
+            + (CLAUDE_NOTE + "\n" if claude else "")
+            + f"<skill>\n{body}\n</skill>")
 
 
 def use_skill_text(skills: list[dict], name: str) -> str:

package/hooks-command.mjs

@@ -5,7 +5,7 @@
  *   approve     run this project's hooks (as they are now — an edit needs approving again)
  *   unapprove   stop running them
  */
-import { HOOK_EVENTS, describeHook, readHooks, approveProjectHooks, userSettingsPath } from "./hooks-config.mjs";
+import { HOOK_EVENTS, GU_TO_CLAUDE_EVENT, describeHook, readHooks, approveProjectHooks } from "./hooks-config.mjs";
 
 export const HOOKS_USAGE = "gu hooks [list|approve|unapprove]";
 
@@ -13,7 +13,9 @@ function printGroups(hooks, print, indent = "  ") {
   for (const ev of HOOK_EVENTS) {
     for (const g of hooks[ev] ?? []) {
       const on = g.matcher ? `  (tools: ${g.matcher})` : "";
-      for (const h of g.hooks) print(`${indent}${ev.padEnd(11)} ${describeHook(h)}${on}`);
+      // A Claude Code hook is listed under the name it has in Claude's file.
+      const name = g.dialect === "claude" ? GU_TO_CLAUDE_EVENT[ev] : ev;
+      for (const h of g.hooks) print(`${indent}${name.padEnd(g.dialect === "claude" ? 16 : 11)} ${describeHook(h)}${on}`);
     }
   }
 }
@@ -24,33 +26,36 @@ export async function runHooksCommand(words, { cwd = process.cwd(), print = cons
     if (sub === "list" || sub === "ls") {
       const r = readHooks({ cwd });
       for (const w of r.warnings) print(w, "warn");
+      const claude = r.source === "claude";
       const nUser = Object.keys(r.user).length;
       const nProj = Object.keys(r.project).length;
+      if (claude) print("Claude Code's hooks (/switch-skill) — gu runs them with Claude's event and tool names.", "dim");
       if (!nUser && !nProj) {
-        print("No hooks.");
-        print(`Add them under "hooks" in ${userSettingsPath()} — events: ${HOOK_EVENTS.join(", ")}.`, "dim");
-        return 0;
+        print(claude ? `No hooks gu can run in ${r.userFile} or ${r.projectFile}.` : "No hooks.");
+        if (!claude) print(`Add them under "hooks" in ${r.userFile} — events: ${HOOK_EVENTS.join(", ")}.`, "dim");
       }
       if (nUser) {
-        print(`Yours (${userSettingsPath()}):`, "ok");
+        print(`Yours (${r.userFile}):`, "ok");
         printGroups(r.user, (l) => print(l, "dim"));
       }
       if (nProj) {
         print(
           r.projectApproved
-            ? "This project's (./.gonext/settings.json) — approved:"
-            : "This project's (./.gonext/settings.json) — NOT running until you approve them:",
+            ? `This project's (${r.projectFile}) — approved:`
+            : `This project's (${r.projectFile}) — NOT running until you approve them:`,
           r.projectApproved ? "ok" : "warn"
         );
         printGroups(r.project, (l) => print(l, "dim"));
         if (!r.projectApproved) print("Check the commands above, then:  /hooks approve", "dim");
       }
+      // What Claude Code would run and gu does not — a guard nobody runs must not look active.
+      for (const n of r.notes) print(n, "warn");
       return 0;
     }
     if (sub === "approve" || sub === "unapprove") {
       const r = readHooks({ cwd });
       if (!Object.keys(r.project).length) {
-        print("This folder has no hooks of its own (./.gonext/settings.json).", "warn");
+        print(`This folder has no hooks of its own (${r.projectFile}).`, "warn");
         return 1;
       }
       approveProjectHooks({ cwd, approve: sub === "approve" });

package/hooks-config.mjs

@@ -18,6 +18,21 @@
  * them for that folder — and the approval is of their exact content (a hash): an edited hooks
  * block needs approving again. The approval lives in YOUR settings file, never the project's.
  *
+ * CLAUDE CODE'S HOOKS (#325). A folder that chose "Claude's skills" (/switch-skill) reads its hooks
+ * from Claude Code's own settings instead:
+ *   ~/.claude/settings.json                                       yours
+ *   <project>/.claude/settings.json, .claude/settings.local.json  the project's — approved here first
+ * Those are filed under CLAUDE's event names and match CLAUDE's tool names, and the commands expect
+ * Claude's input. So each group is marked `dialect: "claude"`, and the agent speaks Claude's
+ * vocabulary to it (gu_hooks.py): SessionStart / UserPromptSubmit / PostToolUse / Stop at gu's four
+ * moments, Edit / Write / Read / Grep / Glob / Bash for gu's tools, Claude's field names on stdin.
+ * Tested with a real Claude memory hook: with the folder switched and nothing translated it never
+ * ran; with only the event names translated it ran and recorded nothing.
+ * What gu cannot honour is SAID, never skipped in silence: an event gu has no moment for
+ * (PreToolUse — a guard someone may be relying on), a hook that is not a command, a hook limited by
+ * an `if` rule gu cannot evaluate. Read-only: gu never writes Claude's settings files; the approval
+ * of a project's hooks is still kept in ~/.gonext/settings.json.
+ *
  * THE SESSION. onStart fires on the first turn of a gu session. The terminal writes a new session
  * id into the folder's session file when it starts (and on /reset); sessionForTurn reads it back so
  * the agent can tell "new session" from "next turn" with nothing added to the API.
@@ -26,6 +41,7 @@ import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { resolveSkillSource, sessionFileFor, sourceDirName } from "./skill-source.mjs";
 
 export const HOOK_EVENTS = ["onStart", "onAsk", "onToolDone", "onTurnEnd"];
 /** Claude Code's names → gu's. Only used to tell the user what to rename. */
@@ -36,8 +52,13 @@ export const CLAUDE_EVENT_NAMES = {
   Stop: "onTurnEnd",
 };
 
-export const userSettingsPath = (home = homedir()) => join(home, ".gonext", "settings.json");
-export const projectSettingsPath = (cwd) => join(cwd, ".gonext", "settings.json");
+/** gu's moment → Claude Code's event: the name a Claude hook is filed under, and is told it is. */
+export const GU_TO_CLAUDE_EVENT = Object.fromEntries(Object.entries(CLAUDE_EVENT_NAMES).map(([c, g]) => [g, c]));
+
+export const userSettingsPath = (home = homedir(), source = "gu") => join(home, sourceDirName(source), "settings.json");
+export const projectSettingsPath = (cwd, source = "gu") => join(cwd, sourceDirName(source), "settings.json");
+/** Claude Code's per-project file that is not committed — still a file in the project's folder. */
+export const projectLocalSettingsPath = (cwd) => join(cwd, ".claude", "settings.local.json");
 
 const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 
@@ -56,11 +77,54 @@ function readJson(file) {
   }
 }
 
-/** A settings file's hooks, cleaned: only gu events, only command hooks. → { hooks, warnings } */
-export function cleanHooks(raw, where) {
+/**
+ * A settings file's hooks, cleaned: only gu events, only command hooks. → { hooks, warnings, notes }
+ *
+ * `source: "claude"` reads the file as Claude Code wrote it: the keys are Claude's event names, the
+ * result is filed under gu's four moments with `dialect: "claude"` on every group. `notes` name
+ * what was left out and why — said by /hooks, not at every start.
+ */
+export function cleanHooks(raw, where, source = "gu") {
   const hooks = {};
   const warnings = [];
-  if (!isObj(raw)) return { hooks, warnings };
+  const notes = [];
+  if (!isObj(raw)) return { hooks, warnings, notes };
+  if (source === "claude") {
+    for (const [event, groups] of Object.entries(raw)) {
+      const gu = CLAUDE_EVENT_NAMES[event];
+      const list = Array.isArray(groups) ? groups.filter(isObj) : [];
+      if (!gu) {
+        const n = list.reduce((a, g) => a + (Array.isArray(g.hooks) ? g.hooks.length : 0), 0);
+        if (n) notes.push(`${where}: ${n} ${event} hook${n === 1 ? "" : "s"} — gu has no such moment, so ${n === 1 ? "it is" : "they are"} NOT run here.`);
+        continue;
+      }
+      for (const g of list) {
+        const hs = [];
+        for (const h of Array.isArray(g.hooks) ? g.hooks : []) {
+          if (!isObj(h)) continue;
+          const type = String(h.type ?? "command");
+          if (type !== "command") {
+            notes.push(`${where}: a ${event} hook of type "${type}" — gu runs command hooks only. Not run here.`);
+            continue;
+          }
+          if (!String(h.command ?? "").trim()) continue;
+          if (h.if !== undefined) {
+            // Narrowed by a permission rule gu cannot evaluate: running it everywhere would be wrong.
+            notes.push(`${where}: a ${event} hook limited by if: ${JSON.stringify(h.if)} — gu cannot evaluate that. Not run here.`);
+            continue;
+          }
+          hs.push({
+            type: "command",
+            command: String(h.command),
+            ...(Array.isArray(h.args) ? { args: h.args.map(String) } : {}),
+            ...(Number.isFinite(h.timeout) && h.timeout > 0 ? { timeout: h.timeout } : {}),
+          });
+        }
+        if (hs.length) (hooks[gu] ??= []).push({ matcher: String(g.matcher ?? ""), hooks: hs, dialect: "claude" });
+      }
+    }
+    return { hooks, warnings, notes };
+  }
   for (const [event, groups] of Object.entries(raw)) {
     if (!HOOK_EVENTS.includes(event)) {
       const gu = CLAUDE_EVENT_NAMES[event];
@@ -87,7 +151,7 @@ export function cleanHooks(raw, where) {
     }
     if (kept.length) hooks[event] = kept;
   }
-  return { hooks, warnings };
+  return { hooks, warnings, notes };
 }
 
 /** The exact content being approved — any edit changes it. */
@@ -95,36 +159,72 @@ export function hooksFingerprint(hooks) {
   return createHash("sha256").update(JSON.stringify(hooks ?? {})).digest("hex").slice(0, 16);
 }
 
-/** → { user, project, projectApproved, projectPending, warnings } */
-export function readHooks({ cwd, home = homedir() } = {}) {
+/** How each source's files are NAMED to the user (labels in messages — not paths to open). */
+const FILE_LABELS = {
+  gu: { user: "~/.gonext/settings.json", project: ".gonext/settings.json", shown: "./.gonext/settings.json" },
+  claude: { user: "~/.claude/settings.json", project: ".claude/settings.json", shown: "./.claude/settings.json" },
+};
+
+/** Where a folder's approval is kept in gu's settings: one slot per folder and per source. */
+const approvalKey = (cwd, source) => resolve(cwd) + (source === "claude" ? "#claude" : "");
+
+/** Two hook maps, one after the other (Claude's project file, then its local one). */
+function mergeHooks(a, b) {
+  const out = { ...a };
+  for (const [ev, groups] of Object.entries(b)) out[ev] = [...(out[ev] ?? []), ...groups];
+  return out;
+}
+
+/**
+ * `source` = whose hooks ("gu" | "claude"); left out, it is the folder's own choice.
+ * → { user, project, projectApproved, projectPending, warnings, notes, source, userFile, projectFile }
+ */
+export function readHooks({ cwd, home = homedir(), source } = {}) {
+  const src = resolveSkillSource({ source, cwd, home });
+  const label = FILE_LABELS[src];
   const warnings = [];
-  const u = readJson(userSettingsPath(home));
-  if (u.error) warnings.push(`${userSettingsPath(home)} is ${u.error} — its hooks are skipped`);
-  const user = cleanHooks(u.data?.hooks, "~/.gonext/settings.json");
+  const notes = [];
+  const userFile = userSettingsPath(home, src);
+  const u = readJson(userFile);
+  if (u.error) warnings.push(`${userFile} is ${u.error} — its hooks are skipped`);
+  const user = cleanHooks(u.data?.hooks, label.user, src);
   warnings.push(...user.warnings);
-  let project = { hooks: {}, warnings: [] };
+  notes.push(...user.notes);
+  let project = {};
   let projectApproved = false;
-  if (cwd && resolve(projectSettingsPath(cwd)) !== resolve(userSettingsPath(home))) {
-    const p = readJson(projectSettingsPath(cwd));
-    if (p.error) warnings.push(`${projectSettingsPath(cwd)} is ${p.error} — its hooks are skipped`);
-    project = cleanHooks(p.data?.hooks, ".gonext/settings.json");
-    warnings.push(...project.warnings);
-    const approved = u.data?.approvedProjectHooks?.[resolve(cwd)];
-    projectApproved = Object.keys(project.hooks).length > 0 && approved === hooksFingerprint(project.hooks);
+  if (cwd && resolve(projectSettingsPath(cwd, src)) !== resolve(userFile)) {
+    const files = [[projectSettingsPath(cwd, src), label.project]];
+    if (src === "claude") files.push([projectLocalSettingsPath(cwd), ".claude/settings.local.json"]);
+    for (const [file, where] of files) {
+      const p = readJson(file);
+      if (p.error) warnings.push(`${file} is ${p.error} — its hooks are skipped`);
+      const cleaned = cleanHooks(p.data?.hooks, where, src);
+      warnings.push(...cleaned.warnings);
+      notes.push(...cleaned.notes);
+      project = mergeHooks(project, cleaned.hooks);
+    }
+    // gu's OWN settings file holds the approval, whichever source the hooks came from.
+    const own = src === "gu" ? u : readJson(userSettingsPath(home));
+    const approved = own.data?.approvedProjectHooks?.[approvalKey(cwd, src)];
+    projectApproved = Object.keys(project).length > 0 && approved === hooksFingerprint(project);
   }
-  const hasProject = Object.keys(project.hooks).length > 0;
+  const hasProject = Object.keys(project).length > 0;
   return {
     user: user.hooks,
-    project: project.hooks,
+    project,
     projectApproved,
     projectPending: hasProject && !projectApproved,
     warnings,
+    notes,
+    source: src,
+    userFile,
+    projectFile: label.shown,
   };
 }
 
 /** What one turn runs: yours first, then the project's when approved. */
-export function hooksForTurn({ cwd, home = homedir() } = {}) {
-  const r = readHooks({ cwd, home });
+export function hooksForTurn({ cwd, home = homedir(), source } = {}) {
+  const r = readHooks({ cwd, home, source });
   const out = {};
   for (const ev of HOOK_EVENTS) {
     const groups = [...(r.user[ev] ?? []), ...(r.projectApproved ? r.project[ev] ?? [] : [])];
@@ -134,15 +234,15 @@ export function hooksForTurn({ cwd, home = homedir() } = {}) {
 }
 
 /** Approve (or withdraw) this folder's hooks, as they are right now. */
-export function approveProjectHooks({ cwd, home = homedir(), approve = true }) {
-  const r = readHooks({ cwd, home });
-  const file = userSettingsPath(home);
+export function approveProjectHooks({ cwd, home = homedir(), approve = true, source }) {
+  const r = readHooks({ cwd, home, source });
+  const file = userSettingsPath(home); // gu's own, always — Claude's settings are never written
   const { data, error } = readJson(file);
   if (error) throw new Error(`${file} is ${error} — fix or remove it first`);
   const raw = data ?? {};
   raw.approvedProjectHooks = isObj(raw.approvedProjectHooks) ? raw.approvedProjectHooks : {};
-  if (approve) raw.approvedProjectHooks[resolve(cwd)] = hooksFingerprint(r.project);
-  else delete raw.approvedProjectHooks[resolve(cwd)];
+  if (approve) raw.approvedProjectHooks[approvalKey(cwd, r.source)] = hooksFingerprint(r.project);
+  else delete raw.approvedProjectHooks[approvalKey(cwd, r.source)];
   mkdirSync(dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
   writeFileSync(tmp, JSON.stringify(raw, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
@@ -152,11 +252,8 @@ export function approveProjectHooks({ cwd, home = homedir(), approve = true }) {
 
 /* ---------------------------------------------------------------- the session ------------ */
 
-/** The terminal's per-folder session file — the same name gu-repl.mjs uses. */
-export function sessionFileFor(cwd, home = homedir()) {
-  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 32);
-  return join(home, ".gonext", "sessions", `${hash}.json`);
-}
+/** The terminal's per-folder session file — the same name gu-repl.mjs uses (skill-source.mjs). */
+export { sessionFileFor };
 
 /** → { id, startedAt } | null. null = no terminal session (the web, or an older terminal). */
 export function sessionForTurn(cwd, home = homedir()) {

package/mcp-command.mjs

@@ -31,6 +31,7 @@ import {
   removeServer,
   setDisabled,
   userConfigPath,
+  userServersPath,
   SERVER_NAME_RE,
 } from "./mcp-config.mjs";
 
@@ -146,15 +147,20 @@ export async function runMcpCommand(words, { cwd = process.cwd(), print = consol
     switch (sub) {
       case "list":
       case "ls": {
-        const { servers, warnings } = listServers({ cwd });
+        const { servers, warnings, source } = listServers({ cwd });
         for (const x of warnings) print(x, "warn");
         if (!servers.length) {
-          print("No MCP servers yet.");
+          print(source === "claude" ? `No MCP servers in Claude Code's setup (${userServersPath(undefined, source)}, ./.mcp.json).` : "No MCP servers yet.");
           print(`Add one:  /mcp add   (or in a shell: ${ADD_USAGE})`, "dim");
           return 0;
         }
         const results = await probe(servers.filter((s) => s.runnable), { cwd });
-        print(`MCP servers — yours in ${userConfigPath()}, this folder's in ./.mcp.json`, "dim");
+        print(
+          source === "claude"
+            ? `MCP servers — Claude Code's: yours in ${userServersPath(undefined, source)}, this folder's in ./.mcp.json  (/switch-skill)`
+            : `MCP servers — yours in ${userConfigPath()}, this folder's in ./.mcp.json`,
+          "dim"
+        );
         for (const s of servers) {
           print(statusLine(s, results[s.name]), results[s.name]?.ok ? "ok" : undefined);
           if (!s.error) print(`    ${describeServer(s)}`, "dim");
@@ -233,8 +239,8 @@ export async function runMcpCommand(words, { cwd = process.cwd(), print = consol
           print(`"${name}" is this project's (./.mcp.json) — it will not start here any more. Edit that file to delete it.`);
           return 0;
         }
-        const found = removeServer({ name });
-        print(found ? `Removed "${name}".` : `No MCP server named "${name}" in ${userConfigPath()}.`, found ? "ok" : "warn");
+        const found = removeServer({ name, cwd });
+        print(found ? `Removed "${name}".` : `No MCP server named "${name}" in ${userServersPath(undefined, listServers({ cwd }).source)}.`, found ? "ok" : "warn");
         return found ? 0 : 1;
       }
       case "enable":