@tiens.nguyen/gu-cli 1.0.872 → 1.0.873

package/coding-provider-setup.mjs

@@ -614,20 +614,24 @@ export function providerHost(url) {
  * KIND, so a second openai row is not even visible there. Add-only was a dead end and this is the
  * exit from it.
  *
- * OPENAI ROWS ONLY. An Ollama or MLX row is owned by its own flow ("change the Ollama server this
- * machine uses…"), which sets URL, models and roles together; editing one field of it from here
- * would half-configure a thing that has its own notion of complete.
+ * OPENAI AND OLLAMA ROWS (#243). Ollama rows — ollama.com, or a box added with "another URL…" —
+ * used to be left to "change the Ollama server this machine uses…"; #412 removed that menu, which
+ * left them with no editor at all: an ollama.com coder worked but could not be found here to change
+ * or remove. They are listed with `dialect: "ollama"`, and their model list and URL are handled in
+ * that dialect (/api/tags, serverTarget). MLX / "local" rows stay out: they are set up by gu itself.
  */
 export function manageableProviders(rows) {
   const out = [];
   const taken = new Set();
   for (const b of Array.isArray(rows) ? rows : []) {
     if (!b || typeof b !== "object") continue;
-    if (String(b.kind ?? "") !== "openai") continue;
+    const kind = String(b.kind ?? "");
+    if (kind !== "openai" && kind !== "ollama") continue;
     const url = String(b.url ?? "").trim();
     if (!url) continue;
-    // The same identity rule the API uses, so an id shown here is the id it will patch.
-    const id = String(b.id ?? "").trim() || (taken.has("openai") ? "" : "openai");
+    // The same identity rule the API uses, so an id shown here is the id it will patch: an id-less
+    // row is known by its kind, and only the first of each kind can be.
+    const id = String(b.id ?? "").trim() || (taken.has(kind) ? "" : kind);
     if (!id || taken.has(id)) continue;
     taken.add(id);
     out.push({
@@ -636,6 +640,7 @@ export function manageableProviders(rows) {
       model: String(b.defaultModel ?? "").trim(),
       host: providerHost(url),
       enabled: b.enabled !== false,
+      dialect: kind === "ollama" ? "ollama" : "openai",
     });
   }
   return out;

package/gu-repl.mjs

@@ -1038,6 +1038,7 @@ const COMMANDS = [
   { 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: "/skills-copy-to-claude", usage: "/skills-copy-to-claude [--dry-run] [name…]", desc: "copy gu's skills (.gonext) into Claude Code's folders (.claude), renamed to Claude's names, with their MCP servers" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -6232,7 +6233,7 @@ async function pickExtraModels(rest, preChecked = []) {
  *
  * Returns the model id, or null when the user cancelled.
  */
-async function chooseCodingModelFrom(ps, all, question, current) {
+async function chooseCodingModelFrom(ps, all, question, current, { back = false } = {}) {
   const { models: coders, filtered } = ps.codingModelCandidates(all);
   let list = coders;
   let showingAll = filtered === 0;
@@ -6247,7 +6248,8 @@ async function chooseCodingModelFrom(ps, all, question, current) {
       dim(`  ${question}  (${PICK_HINT})`) +
         (showingAll || !filtered ? "" : dim(`  ·  ${filtered} non-coding models hidden`))
     );
-    const idx = await pickFromList(rows, at >= 0 ? at : 0);
+    const idx = await pickFromList(rows, at >= 0 ? at : 0, { back });
+    if (idx === PICK_BACK) return BACK;
     if (idx < 0) return null;
     if (idx === list.length) {
       const typed = (await ask("   model name: ")).trim();
@@ -6275,11 +6277,12 @@ async function chooseCodingModelFrom(ps, all, question, current) {
  * stays available for the same reason it does there — a listed model may be unusable and an
  * unlisted one may be exactly right.
  */
-async function chooseFromModelList(all, question, current = 0) {
+async function chooseFromModelList(all, question, current = 0, { back = false } = {}) {
   const rows = [...all, "type a model name…"];
   const at = typeof current === "string" ? all.indexOf(current) : Number(current) || 0;
   console.log(dim(`   ${question}  (${PICK_HINT})`));
-  const idx = await pickFromList(rows, at >= 0 ? at : 0);
+  const idx = await pickFromList(rows, at >= 0 ? at : 0, { back });
+  if (idx === PICK_BACK) return BACK;
   if (idx < 0) return null;
   if (idx === all.length) {
     const typed = (await ask("   model name: ")).trim();
@@ -6288,51 +6291,65 @@ async function chooseFromModelList(all, question, current = 0) {
   return all[idx];
 }
 
-async function manageCodingProviders() {
+/**
+ * /model's provider manager. `back` (#242): opened from /model's list, so its first menu offers
+ * "← back" and returns BACK. Inside it, each sub-menu's "← back" returns HERE — re-read, because a
+ * step backed out of saves nothing but the list is cheap to trust fresh.
+ */
+async function manageCodingProviders({ back = false } = {}) {
   const ps = await import("./coding-provider-setup.mjs");
-  const settings = await withPendingStatus("reading your providers", fetchWorkerSettings);
-  if (!settings) {
-    console.log(red("   couldn't reach the API to read your current settings.\n"));
-    return;
-  }
-  const rows = ps.existingBackendRows(settings);
-  const providers = ps.manageableProviders(rows);
-  // NOTHING TO MANAGE IS NOT A MENU. Straight to the add flow, exactly as before.
-  if (providers.length === 0) {
-    await addServer({ role: "coding", dialect: "openai" });
-    return;
-  }
+  let selAt = 0;
+  for (;;) {
+    const settings = await withPendingStatus("reading your providers", fetchWorkerSettings);
+    if (!settings) {
+      console.log(red("   couldn't reach the API to read your current settings.\n"));
+      return;
+    }
+    const rows = ps.existingBackendRows(settings);
+    const providers = ps.manageableProviders(rows);
+    // NOTHING TO MANAGE IS NOT A MENU. Straight to the add flow, exactly as before.
+    if (providers.length === 0) return addServer({ role: "coding", dialect: "openai", back });
 
-  const labels = providers.map(
-    (p) =>
-      `${p.model || dim("(no model set)")}${dim(`  · ${p.host}`)}${p.enabled ? "" : dim("  · off")}`
-  );
-  const ADD = labels.length;
-  labels.push("add another provider — Claude API, OpenAI, Kimi…");
-  console.log(dim(`   Providers — pick one to change it, or add another  (${PICK_HINT}):`));
-  const idx = await pickFromList(labels, 0);
-  if (idx < 0) {
-    console.log(dim("   (cancelled)\n"));
-    return;
-  }
-  if (idx === ADD) {
-    await addServer({ role: "coding", dialect: "openai" });
-    return;
-  }
+    const labels = providers.map(
+      (p) =>
+        `${p.model || dim("(no model set)")}${dim(`  · ${p.host}`)}${p.enabled ? "" : dim("  · off")}`
+    );
+    const ADD = labels.length;
+    labels.push("add another provider — Claude API, OpenAI, Kimi…");
+    console.log(dim(`   Providers — pick one to change it, or add another  (${PICK_HINT}):`));
+    const idx = await pickFromList(labels, selAt, { back });
+    if (idx === PICK_BACK) return BACK;
+    if (idx < 0) {
+      console.log(dim("   (cancelled)\n"));
+      return;
+    }
+    selAt = idx;
+    if (idx === ADD) {
+      if ((await addServer({ role: "coding", dialect: "openai", back: true })) === BACK) continue;
+      return;
+    }
 
-  const p = providers[idx];
-  console.log("\n" + GUTTER + dim(`${p.host}  ·  ${p.model || "no model set"}`));
-  const action = await pickFromList(
-    [dim("keep it"), "change the model…", "change the URL…", "remove this provider…"],
-    1
-  );
-  if (action <= 0) {
-    console.log(dim("   (nothing changed)\n"));
-    return;
+    const p = providers[idx];
+    for (;;) {
+      console.log("\n" + GUTTER + dim(`${p.host}  ·  ${p.model || "no model set"}`));
+      const action = await pickFromList(
+        [dim("keep it"), "change the model…", "change the URL…", "remove this provider…"],
+        1,
+        { back: true }
+      );
+      if (action === PICK_BACK) break; // → the provider list
+      if (action <= 0) {
+        console.log(dim("   (nothing changed)\n"));
+        return;
+      }
+      let r;
+      if (action === 1) r = await changeProviderModel(ps, rows, p);
+      else if (action === 2) r = await changeProviderUrl(ps, rows, p);
+      else r = await removeCodingProvider(ps, rows, p);
+      if (r === BACK) continue; // → this provider's actions
+      return;
+    }
   }
-  if (action === 1) await changeProviderModel(ps, rows, p);
-  else if (action === 2) await changeProviderUrl(ps, rows, p);
-  else await removeCodingProvider(ps, rows, p);
 }
 
 /** Point a provider at a different model. */
@@ -6353,9 +6370,14 @@ async function changeProviderModel(ps, rows, p) {
     const r = await fetchCodingKey(p.id);
     return r.keyId && r.keyId !== inUse.id ? { key: "", name: "" } : { key: r.key, name: String(inUse.name ?? "") };
   });
+  // AN OLLAMA ROW (#243) lists through Ollama's own /api/tags, the way it was added.
+  const as = p.dialect === "ollama" ? await import("./add-server.mjs") : null;
+  const ollamaTarget = as ? as.serverTarget("ollama", p.url) : null;
   const probe = await withPendingStatus(`asking ${p.host} what it has`, async () => {
     try {
-      const lr = ps.modelListRequest(p.url, own.key); // the list's own dialect too (Claude's headers, #261)
+      const lr = ollamaTarget?.ok
+        ? as.listRequest(ollamaTarget, own.key)
+        : ps.modelListRequest(p.url, own.key); // the list's own dialect too (Claude's headers, #261)
       const res = await proxyFetch(lr.url, { headers: lr.headers, signal: AbortSignal.timeout(10_000) });
       if (!res.ok) return { status: res.status };
       return { body: await res.json().catch(() => null) };
@@ -6365,7 +6387,7 @@ async function changeProviderModel(ps, rows, p) {
   });
   let models = [];
   if (!probe.status && !probe.err) {
-    const parsed = ps.parseProviderModels(probe.body);
+    const parsed = ollamaTarget?.ok ? as.modelsForRole("coding", "ollama", probe.body) : ps.parseProviderModels(probe.body);
     // The CURRENT model stays in the list: after switching to another one it becomes a perfectly
     // good extra, and filtering it out here would make it unofferable without a second visit.
     models = parsed.models;
@@ -6384,7 +6406,8 @@ async function changeProviderModel(ps, rows, p) {
 
   let model = "";
   if (models.length) {
-    model = await chooseCodingModelFrom(ps, models, `Which model should ${p.host} use?`, p.model);
+    model = await chooseCodingModelFrom(ps, models, `Which model should ${p.host} use?`, p.model, { back: true });
+    if (model === BACK) return BACK;
     if (model === null) {
       console.log(dim("   (nothing changed)\n"));
       return;
@@ -6437,10 +6460,13 @@ async function changeProviderUrl(ps, rows, p) {
   // THE SAME PRESET LIST AS ADDING (#132), OpenAI-compatible ones only: an Ollama row has another
   // kind, and this flow keeps the row's id and kind. "type a URL…" is the default row, so Enter
   // still gets the old free-text question.
-  const urlPresets = ps.providerPresets("coding").filter((x) => (x.dialect ?? "openai") === "openai");
+  // An Ollama row (#243) is offered the Ollama presets (Ollama cloud) and keeps its kind too.
+  const dialect = p.dialect === "ollama" ? "ollama" : "openai";
+  const urlPresets = ps.providerPresets("coding").filter((x) => (x.dialect ?? "openai") === dialect);
   const urlRows = [...urlPresets.map((x) => `${x.name}${dim(`  · ${x.url}`)}`), "type a URL…"];
   console.log("\n" + GUTTER + dim(`Which provider?  (${PICK_HINT})`));
-  const upi = await pickFromList(urlRows, urlRows.length - 1);
+  const upi = await pickFromList(urlRows, urlRows.length - 1, { back: true });
+  if (upi === PICK_BACK) return BACK;
   if (upi < 0) {
     console.log(GUTTER + dim("(nothing changed)\n"));
     return;
@@ -6456,11 +6482,27 @@ async function changeProviderUrl(ps, rows, p) {
     console.log(GUTTER + dim("(nothing changed)\n"));
     return;
   }
-  const r = ps.normalizeProviderUrl(typed);
-  if (!r.ok) {
-    for (const l of ps.describeUrlProblem(r.why, typed)) console.log(GUTTER + dim(l));
-    console.log(GUTTER + dim("(nothing changed)\n"));
-    return;
+  let r;
+  if (dialect === "ollama") {
+    const as = await import("./add-server.mjs");
+    const t = as.serverTarget("ollama", typed);
+    r = t.ok ? { ok: true, url: t.url, host: t.host } : { ok: false, why: t.why };
+    if (!r.ok) {
+      console.log(GUTTER + dim(`"${typed}" is ${r.why} — try ollama.com, or host:port such as 192.168.1.5:11434`));
+      console.log(GUTTER + dim("(nothing changed)\n"));
+      return;
+    }
+    if (r.url === p.url) {
+      console.log(GUTTER + dim("(nothing changed)\n"));
+      return;
+    }
+  } else {
+    r = ps.normalizeProviderUrl(typed);
+    if (!r.ok) {
+      for (const l of ps.describeUrlProblem(r.why, typed)) console.log(GUTTER + dim(l));
+      console.log(GUTTER + dim("(nothing changed)\n"));
+      return;
+    }
   }
   const clash = rows.find(
     (b) => ps.ensureV1Root(String(b.url ?? "")) === r.url && !ps.manageableProviders([b]).some((x) => x.id === p.id)
@@ -6569,7 +6611,7 @@ async function removeCodingProvider(ps, rows, p) {
  *   model     skip listing and picking (/embed-model's curated list already chose; `plan` with it)
  *   newKey    ask for a key even if the server has one (the stored one was refused)
  */
-async function addServer({ role = "coding", dialect = "openai", url: presetUrl = "", model: presetModel = "", plan: presetPlan = null, newKey = false } = {}) {
+async function addServer({ role = "coding", dialect = "openai", url: presetUrl = "", model: presetModel = "", plan: presetPlan = null, newKey = false, back = false } = {}) {
   const as = await import("./add-server.mjs");
   const ps = await import("./coding-provider-setup.mjs");
   const sk = await import("./server-keys.mjs");
@@ -6591,166 +6633,180 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     ? ((await fetchAgentPayload([{ role: "user", content: "ping" }]).catch(() => null))?.codingChoices ?? null)
     : null;
 
-  // --- 1. the server --------------------------------------------------------------------
-  let target = null;
-  if (presetUrl) {
-    target = as.serverTarget(dialect, presetUrl);
-    if (!target.ok) {
-      console.log(red(`  "${presetUrl}" is ${target.why} — nothing changed.\n`));
-      return;
+  // STEPS 1–4 ARE ONE LOOP (#242): "← back" on the model list returns to "Which provider?", and
+  // "← back" there returns BACK to the menu that opened this (with `back`). Nothing is saved
+  // before step 5, so going back leaves nothing behind — a key typed on the way is dropped.
+  const providerPicker = !presetUrl && dialect === "openai";
+  const ec = role === "embed" ? await import("./embed-model-command.mjs") : null;
+  let target, host, found, need, key, keyName, typedKey, models, model;
+  for (;;) {
+    // --- 1. the server --------------------------------------------------------------------
+    target = null;
+    if (presetUrl) {
+      target = as.serverTarget(dialect, presetUrl);
+      if (!target.ok) {
+        console.log(red(`  "${presetUrl}" is ${target.why} — nothing changed.\n`));
+        return;
+      }
+    } else if (dialect === "openai") {
+      // THE HOSTED PROVIDERS BY NAME (#261): Claude, OpenAI, Kimi — then any other URL. One picker in
+      // the one add flow, so every role that adds a provider offers the same list (the embedder
+      // without Claude, which serves no embeddings).
+      const presets = ps.providerPresets(role);
+      const rowsShown = [...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`), "another URL…"];
+      // A preset names its own dialect (Ollama cloud is "ollama"); the rest are OpenAI-compatible.
+      console.log(dim(`   Which provider?  (${PICK_HINT})`));
+      const pi = await pickFromList(rowsShown, 0, { back });
+      if (pi === PICK_BACK) return BACK;
+      if (pi < 0) {
+        console.log(dim("   (nothing saved)\n"));
+        return;
+      }
+      if (pi < presets.length) target = as.serverTarget(presets[pi].dialect ?? "openai", presets[pi].url);
+    }
+    if (!target && !presetUrl) {
+      const dflt = as.defaultServerUrl(role, dialect, settings, existing);
+      console.log(dim(dialect === "ollama"
+        ? "   An Ollama server: this machine, a box on your network, or https://ollama.com (needs a key)."
+        : "   Any OpenAI-compatible endpoint: OpenRouter, Together, vLLM, LM Studio, …"));
+      // The address goes ABOVE, in full, and Enter's meaning is said out loud (46d1524e).
+      console.log(dim(dflt ? `  Enter uses ${dflt}  ·  Esc cancels\n` : "  Esc cancels.\n"));
+      for (let attempt = 0; attempt < 3 && !target; attempt++) {
+        const typed = await ask("   server URL: ");
+        if (typed === null || as.isCancelWord(typed)) break;
+        const raw = typed.trim() || dflt;
+        if (!raw) break;
+        const t = as.serverTarget(dialect, raw);
+        if (!t.ok) {
+          if (dialect === "openai") for (const l of ps.describeUrlProblem(t.why, raw)) console.log(GUTTER + dim(l));
+          else console.log(GUTTER + dim(`"${raw}" is ${t.why} — try host:port, e.g. 127.0.0.1:11434`));
+          continue;
+        }
+        // SAY WHAT WE ASSUMED: a scheme we supplied or a path we stripped is a guess, and a wrong
+        // guess shows up later as a timeout that reads like a dead server.
+        if (t.root !== raw && t.url !== raw) console.log(GUTTER + dim(`using ${t.root}`));
+        target = t;
+      }
     }
-  } else if (dialect === "openai") {
-    // THE HOSTED PROVIDERS BY NAME (#261): Claude, OpenAI, Kimi — then any other URL. One picker in
-    // the one add flow, so every role that adds a provider offers the same list (the embedder
-    // without Claude, which serves no embeddings).
-    const presets = ps.providerPresets(role);
-    const rowsShown = [...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`), "another URL…"];
-    // A preset names its own dialect (Ollama cloud is "ollama"); the rest are OpenAI-compatible.
-    console.log(dim(`   Which provider?  (${PICK_HINT})`));
-    const pi = await pickFromList(rowsShown, 0);
-    if (pi < 0) {
+    if (!target) {
       console.log(dim("   (nothing saved)\n"));
       return;
     }
-    if (pi < presets.length) target = as.serverTarget(presets[pi].dialect ?? "openai", presets[pi].url);
-  }
-  if (!target && !presetUrl) {
-    const dflt = as.defaultServerUrl(role, dialect, settings, existing);
-    console.log(dim(dialect === "ollama"
-      ? "   An Ollama server: this machine, a box on your network, or https://ollama.com (needs a key)."
-      : "   Any OpenAI-compatible endpoint: OpenRouter, Together, vLLM, LM Studio, …"));
-    // The address goes ABOVE, in full, and Enter's meaning is said out loud (46d1524e).
-    console.log(dim(dflt ? `  Enter uses ${dflt}  ·  Esc cancels\n` : "  Esc cancels.\n"));
-    for (let attempt = 0; attempt < 3 && !target; attempt++) {
-      const typed = await ask("   server URL: ");
-      if (typed === null || as.isCancelWord(typed)) break;
-      const raw = typed.trim() || dflt;
-      if (!raw) break;
-      const t = as.serverTarget(dialect, raw);
-      if (!t.ok) {
-        if (dialect === "openai") for (const l of ps.describeUrlProblem(t.why, raw)) console.log(GUTTER + dim(l));
-        else console.log(GUTTER + dim(`"${raw}" is ${t.why} — try host:port, e.g. 127.0.0.1:11434`));
-        continue;
-      }
-      // SAY WHAT WE ASSUMED: a scheme we supplied or a path we stripped is a guess, and a wrong
-      // guess shows up later as a timeout that reads like a dead server.
-      if (t.root !== raw && t.url !== raw) console.log(GUTTER + dim(`using ${t.root}`));
-      target = t;
+    host = target.host;
+    const refusal = as.roleRefusal(role, target);
+    if (refusal.length) {
+      for (const l of refusal) console.log(GUTTER + yellow(l));
+      console.log("");
+      return;
+    }
+    // Claude as the CODER: prompt caching needs Anthropic's SDK (#262) — offer it once, here.
+    if (target.claude && role === "coding") {
+      await md.ensureClaudeSdk({ log: (l) => console.log(GUTTER + dim(l.trim())), confirm: (q) => askYesNo(`  ${q}`, true) });
     }
-  }
-  if (!target) {
-    console.log(dim("   (nothing saved)\n"));
-    return;
-  }
-  const host = target.host;
-  const refusal = as.roleRefusal(role, target);
-  if (refusal.length) {
-    for (const l of refusal) console.log(GUTTER + yellow(l));
-    console.log("");
-    return;
-  }
-  // Claude as the CODER: prompt caching needs Anthropic's SDK (#262) — offer it once, here.
-  if (target.claude && role === "coding") {
-    await md.ensureClaudeSdk({ log: (l) => console.log(GUTTER + dim(l.trim())), confirm: (q) => askYesNo(`  ${q}`, true) });
-  }
-
-  // --- 2. the server's key --------------------------------------------------------------
-  // AN EXISTING SERVER IS REUSED, never stored twice (two rows for one URL would be two picker
-  // entries identical in everything a person can see) — its keys come with it.
-  const found = ps.providerRowForUrl(existing, target.url);
-  // THE ROW CAP BEFORE ANY QUESTION about a new server: exceeding it is a silent 200 with no row,
-  // and asking for a key and a model first would be the worst order to discover that in.
-  if (!found && existing.length >= ps.MAX_BACKENDS) {
-    console.log(yellow(`   ${ps.MAX_BACKENDS} servers is the limit — remove one in /model → manage providers first.\n`));
-    return;
-  }
-  const need = as.keyRequirement(target);
-  let key = "";
-  let keyName = "";
-  let typedKey = false;
-  if (found && !newKey) {
-    // A KEY BELONGS TO THE SERVER: one already saved is used, whichever model it was saved for.
-    const keys = await withPendingStatus(`reading the keys for ${host}`, () => fetchServerKeys(found.id));
-    const folderKeyId = role === "agent" ? sessionAgentKeyId : role === "embed" ? sessionEmbedKeyId : sessionCodingKeyId;
-    const inUse = sk.keyInUse(keys ?? [], found.id, folderKeyId);
-    if (inUse && inUse.backendId === found.id) {
-      key = (await fetchCodingKey(found.id)).key;
-      if (key) console.log(GUTTER + dim(`using the key "${inUse.name}" already saved for ${host}.`));
-    }
-  }
-  const askKey = async () => {
-    const t = await askServerKey({ host, optional: need === "optional" });
-    key = t.secret;
-    keyName = t.name;
-    typedKey = Boolean(t.secret);
-    return t.secret || need !== "required";
-  };
-  if (!key && (need !== "none" || newKey)) {
-    if (need === "required") console.log(GUTTER + dim(`${host} needs an API key.`));
-    if (!(await askKey())) return;
-  }
 
-  // --- 3. its models, listed with that key ----------------------------------------------
-  let models = [];
-  if (!presetModel) {
-    const list = () =>
-      withPendingStatus(`asking ${host} what it has`, async () => {
-        const req = as.listRequest(target, key);
-        try {
-          const res = await proxyFetch(req.url, { headers: req.headers, signal: AbortSignal.timeout(12_000) });
-          return res.ok ? { body: await res.json().catch(() => null) } : { status: res.status };
-        } catch (err) {
-          return { err };
+    // --- 2. the server's key --------------------------------------------------------------
+    // AN EXISTING SERVER IS REUSED, never stored twice (two rows for one URL would be two picker
+    // entries identical in everything a person can see) — its keys come with it.
+    found = ps.providerRowForUrl(existing, target.url);
+    // THE ROW CAP BEFORE ANY QUESTION about a new server: exceeding it is a silent 200 with no row,
+    // and asking for a key and a model first would be the worst order to discover that in.
+    if (!found && existing.length >= ps.MAX_BACKENDS) {
+      console.log(yellow(`   ${ps.MAX_BACKENDS} servers is the limit — remove one in /model → manage providers first.\n`));
+      return;
+    }
+    need = as.keyRequirement(target);
+    key = "";
+    keyName = "";
+    typedKey = false;
+    if (found && !newKey) {
+      // A KEY BELONGS TO THE SERVER: one already saved is used, whichever model it was saved for.
+      const keys = await withPendingStatus(`reading the keys for ${host}`, () => fetchServerKeys(found.id));
+      const folderKeyId = role === "agent" ? sessionAgentKeyId : role === "embed" ? sessionEmbedKeyId : sessionCodingKeyId;
+      const inUse = sk.keyInUse(keys ?? [], found.id, folderKeyId);
+      if (inUse && inUse.backendId === found.id) {
+        key = (await fetchCodingKey(found.id)).key;
+        if (key) console.log(GUTTER + dim(`using the key "${inUse.name}" already saved for ${host}.`));
+      }
+    }
+    const askKey = async () => {
+      const t = await askServerKey({ host, optional: need === "optional" });
+      key = t.secret;
+      keyName = t.name;
+      typedKey = Boolean(t.secret);
+      return t.secret || need !== "required";
+    };
+    if (!key && (need !== "none" || newKey)) {
+      if (need === "required") console.log(GUTTER + dim(`${host} needs an API key.`));
+      if (!(await askKey())) return;
+    }
+
+    // --- 3. its models, listed with that key ----------------------------------------------
+    models = [];
+    if (!presetModel) {
+      const list = () =>
+        withPendingStatus(`asking ${host} what it has`, async () => {
+          const req = as.listRequest(target, key);
+          try {
+            const res = await proxyFetch(req.url, { headers: req.headers, signal: AbortSignal.timeout(12_000) });
+            return res.ok ? { body: await res.json().catch(() => null) } : { status: res.status };
+          } catch (err) {
+            return { err };
+          }
+        });
+      let probe = await list();
+      // THE STORED KEY WAS REFUSED — ask for the right one once, rather than saving nothing.
+      if ((probe.status === 401 || probe.status === 403) && !typedKey && key) {
+        console.log(yellow(`   ${host} refused the stored key (HTTP ${probe.status}) — enter the right one.`));
+        if (!(await askKey()) || !key) return;
+        probe = await list();
+      }
+      if (probe.status || probe.err) {
+        const d = ps.describeProbeFailure(probe);
+        for (const l of d.lines) console.log(GUTTER + (d.fatal ? red(l) : yellow(l)));
+        // FATAL = THE KEY WAS REFUSED: storing a credential the server already rejected is storing
+        // a problem for later. Anything else is survivable — the model id can be typed.
+        if (d.fatal) {
+          console.log(GUTTER + dim("nothing was saved — check the key and try again.\n"));
+          return;
         }
-      });
-    let probe = await list();
-    // THE STORED KEY WAS REFUSED — ask for the right one once, rather than saving nothing.
-    if ((probe.status === 401 || probe.status === 403) && !typedKey && key) {
-      console.log(yellow(`   ${host} refused the stored key (HTTP ${probe.status}) — enter the right one.`));
-      if (!(await askKey()) || !key) return;
-      probe = await list();
-    }
-    if (probe.status || probe.err) {
-      const d = ps.describeProbeFailure(probe);
-      for (const l of d.lines) console.log(GUTTER + (d.fatal ? red(l) : yellow(l)));
-      // FATAL = THE KEY WAS REFUSED: storing a credential the server already rejected is storing
-      // a problem for later. Anything else is survivable — the model id can be typed.
-      if (d.fatal) {
-        console.log(GUTTER + dim("nothing was saved — check the key and try again.\n"));
-        return;
+        console.log(GUTTER + dim("carrying on — you can type the model id yourself."));
+      } else {
+        const parsed = as.modelsForRole(role, target.dialect, probe.body);
+        models = parsed.models;
+        for (const l of ps.describeModelProblem(parsed.why, { host, total: parsed.total })) console.log(GUTTER + dim(l));
+        const rn = ps.retiredNote(parsed.retired, host);
+        if (rn) console.log(GUTTER + dim(rn));
+        if (models.length) console.log(GUTTER + dim(`${host} offers ${models.length} model${models.length === 1 ? "" : "s"}`));
       }
-      console.log(GUTTER + dim("carrying on — you can type the model id yourself."));
-    } else {
-      const parsed = as.modelsForRole(role, target.dialect, probe.body);
-      models = parsed.models;
-      for (const l of ps.describeModelProblem(parsed.why, { host, total: parsed.total })) console.log(GUTTER + dim(l));
-      const rn = ps.retiredNote(parsed.retired, host);
-      if (rn) console.log(GUTTER + dim(rn));
-      if (models.length) console.log(GUTTER + dim(`${host} offers ${models.length} model${models.length === 1 ? "" : "s"}`));
     }
-  }
 
-  // --- 4. the model ---------------------------------------------------------------------
-  let model = presetModel;
-  const ec = role === "embed" ? await import("./embed-model-command.mjs") : null;
-  if (!model) {
-    if (models.length) {
-      const am = await import("./agent-model-command.mjs");
-      const current = role === "agent" ? am.currentAgentModel(settings) : role === "embed" ? ec.currentEmbedModel(settings) : sessionCodingLabel;
-      model = R.filterCoders
-        ? await chooseCodingModelFrom(ps, models, R.question, 0)
-        : await chooseFromModelList(models, R.question, Math.max(0, models.indexOf(current)));
-      if (model === null) {
-        console.log(dim("   (cancelled — nothing was saved)\n"));
+    // --- 4. the model ---------------------------------------------------------------------
+    model = presetModel;
+    if (!model) {
+      if (models.length) {
+        const am = await import("./agent-model-command.mjs");
+        const current = role === "agent" ? am.currentAgentModel(settings) : role === "embed" ? ec.currentEmbedModel(settings) : sessionCodingLabel;
+        const canBack = { back: providerPicker || back };
+        model = R.filterCoders
+          ? await chooseCodingModelFrom(ps, models, R.question, 0, canBack)
+          : await chooseFromModelList(models, R.question, Math.max(0, models.indexOf(current)), canBack);
+        if (model === BACK) {
+          if (providerPicker) continue; // → Which provider?
+          return BACK;
+        }
+        if (model === null) {
+          console.log(dim("   (cancelled — nothing was saved)\n"));
+          return;
+        }
+      } else {
+        model = String((await ask("   model name: ")) ?? "").trim();
+      }
+      if (!model) {
+        console.log(GUTTER + dim("(cancelled — nothing was saved)\n"));
         return;
       }
-    } else {
-      model = String((await ask("   model name: ")) ?? "").trim();
-    }
-    if (!model) {
-      console.log(GUTTER + dim("(cancelled — nothing was saved)\n"));
-      return;
     }
+    break;
   }
   // THE EMBEDDER'S RECOGNITION WALL: a different model invalidates every index, so the projects
   // that stop working are named BEFORE anything is saved. The same model is a pure server move.
@@ -7023,8 +7079,8 @@ async function chooseModel() {
       [dim("leave it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
       1
     );
-    if (go === 1) await manageCodingProviders();
-    else console.log("");
+    if (go === 1 && (await manageCodingProviders({ back: true })) === BACK) return chooseModel();
+    if (go !== 1) console.log("");
     return;
   }
   // Shown even with ONE model: "only one is available" often means the wrong server, and the
@@ -7037,8 +7093,8 @@ async function chooseModel() {
       [dim("keep it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
       0
     );
-    if (go === 1) await manageCodingProviders();
-    else console.log("");
+    if (go === 1 && (await manageCodingProviders({ back: true })) === BACK) return chooseModel();
+    if (go !== 1) console.log("");
     return;
   }
   const active = sessionCodingModel || def;
@@ -7073,7 +7129,7 @@ async function chooseModel() {
   }
   // The one appended entry sits past the last model.
   if (idx >= choices.length) {
-    await manageCodingProviders();
+    if ((await manageCodingProviders({ back: true })) === BACK) return chooseModel();
     return;
   }
   await applyChosenCoder(choices[idx], { def, tag: showTag ? tags[idx] : "" });
@@ -7619,6 +7675,91 @@ async function runSwitchSkillCommand(line) {
   if (barPinned()) paintBar();
 }
 
+/**
+ * /skills-copy-to-claude [--dry-run] [name…] — gu's skills into Claude Code's folders (#241):
+ * ~/.gonext/skills → ~/.claude/skills and ./.gonext/skills → ./.claude/skills, "gu-" names become
+ * "claude-", and a skill's MCP server goes into ~/.claude.json (skills-copy.mjs). Shows the plan,
+ * then asks; a Claude skill that differs is kept unless the user picks "replace" (backed up).
+ */
+async function runSkillsCopyCommand(line) {
+  const sc = await import("./skills-copy.mjs");
+  const words = line.trim().split(/\s+/).slice(1);
+  const dryRun = words.includes("--dry-run");
+  const names = words.filter((w) => !w.startsWith("--"));
+  const home = homedir();
+  const cwd = resolve(process.cwd());
+  const tilde = (p) => (p.startsWith(home) ? "~" + p.slice(home.length) : p.startsWith(cwd) ? "." + p.slice(cwd.length) : p);
+  const say = (l) => console.log(GUTTER + l);
+  console.log("");
+  let plan;
+  try {
+    plan = sc.planSkillsCopy({ cwd, home, names });
+  } catch (err) {
+    say(red(`couldn't read gu's skills — ${err.message}\n`));
+    return;
+  }
+  for (const w of plan.warnings) say(yellow(w));
+  if (plan.missing.length) say(yellow(`gu has no skill named ${plan.missing.join(", ")}`));
+  if (!plan.items.length) {
+    say(dim("gu has no skills to copy — ~/.gonext/skills and ./.gonext/skills have none.\n"));
+    return;
+  }
+  const word = { new: accent("new"), same: dim("already there"), differs: yellow("Claude's differs") };
+  say(bold("Copy gu's skills to Claude Code"));
+  for (const it of plan.items) {
+    const renamed = it.newName !== it.name ? dim(`  (was ${it.name})`) : "";
+    say(`  ${it.newName}${renamed}  ${word[it.status]}`);
+    say(dim(`    → ${tilde(it.to)}`));
+    for (const s of it.servers) {
+      say(dim(`    MCP server ${s.name} → ~/.claude.json${s.scope === "local" ? " (this folder)" : ""}  `) + word[s.status]);
+    }
+    if (it.guLines.length) {
+      say(yellow(`    SKILL.md line${it.guLines.length === 1 ? "" : "s"} ${it.guLines.join(", ")} still name${it.guLines.length === 1 ? "s" : ""} ~/.gonext — check the copy`));
+    }
+  }
+  const todo = plan.items.filter((i) => i.status !== "same" || i.servers.some((s) => s.status !== "same"));
+  const differs = plan.items.filter((i) => i.status === "differs" || i.servers.some((s) => s.status === "differs"));
+  if (!todo.length) {
+    say(dim("\n   Nothing to copy — Claude Code already has all of them.\n"));
+    return;
+  }
+  if (dryRun) {
+    say(dim("\n   --dry-run: nothing was written.\n"));
+    return;
+  }
+  const fresh = todo.length - differs.length;
+  const options = differs.length
+    ? [
+        ...(fresh ? [`Copy the ${fresh} new — keep Claude's own where it differs`] : []),
+        `Copy all — replace Claude's ${differs.length} (old one${differs.length === 1 ? "" : "s"} backed up)`,
+        "Cancel",
+      ]
+    : [`Copy ${todo.length === 1 ? "it" : `all ${todo.length}`}`, "Cancel"];
+  console.log(dim(`\n   ${PICK_HINT}:`));
+  const idx = await pickFromList(options, 0);
+  if (idx < 0 || options[idx] === "Cancel") {
+    console.log(dim("   (cancelled — nothing copied)\n"));
+    paintBar();
+    return;
+  }
+  const replace = options[idx].startsWith("Copy all — replace");
+  const r = sc.applySkillsCopy(plan, { replace, cwd, home });
+  const verb = { copied: "copied", replaced: "replaced", kept: "kept Claude's", already: "already there" };
+  for (const d of r.done) {
+    const mark = d.action === "copied" || d.action === "replaced" ? accent("✓") : dim("·");
+    say(`${mark} ${d.newName} ${dim(verb[d.action] + (d.action === "copied" || d.action === "replaced" ? " → " + tilde(d.to) : ""))}`);
+    if (d.backup) say(dim(`    Claude's old one: ${tilde(d.backup)}`));
+  }
+  for (const s of r.servers) {
+    if (s.action === "copied" || s.action === "replaced") say(`${accent("✓")} MCP server ${s.name} ${dim(verb[s.action] + " → ~/.claude.json")}`);
+  }
+  for (const e of r.errors) say(red(`✗ ${e}`));
+  say(dim("   A new Claude Code session loads them."));
+  say(dim("   In gu, /switch-skill claude makes this folder use them too."));
+  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
@@ -8594,13 +8735,14 @@ async function confirmEmbedSwitch(ec, current, chosen) {
 
 // WHICH EMBEDDER, ASKED ONCE. The model sub-flow of /embed-model: the curated picker, then the
 // shared recognition step. Returns { changed, chosen, plan }.
-async function pickEmbedModel(ec, current) {
+async function pickEmbedModel(ec, current, { back = false } = {}) {
   const rows = ec.embedChoiceRows(current);
   console.log(dim(`   Choose the embedder (${PICK_HINT}):`));
   const labels = rows.map(
     (r) => `${r.model}${r.dims ? dim(` · ${r.dims}d`) : ""}${dim(` · ${r.note}`)}` + (r.current ? accent(" (current)") : "")
   );
-  const idx = await pickFromList(labels, Math.max(0, rows.findIndex((r) => r.current)));
+  const idx = await pickFromList(labels, Math.max(0, rows.findIndex((r) => r.current)), { back });
+  if (idx === PICK_BACK) return BACK;
   if (idx < 0) {
     console.log(dim("   (cancelled)\n"));
     return { changed: false, chosen: "", plan: null };
@@ -8654,14 +8796,19 @@ async function chooseEmbedModel() {
   // EVERY ARM IS THE ONE ADD-SERVER SCREEN (task #245) — the same URL → key → models → save as
   // /model and /agent-model. The curated arm has already chosen the model (and passed the
   // recognition wall), so it only asks WHERE; the other two list what the server has.
+  // "← back" in any arm returns to this menu (#242).
   if (action === "model") {
-    const { changed, chosen, plan } = await pickEmbedModel(ec, current);
+    const picked = await pickEmbedModel(ec, current, { back: true });
+    if (picked === BACK) return chooseEmbedModel();
+    const { changed, chosen, plan } = picked;
     if (!changed) return;
     await addServer({ role: "embed", dialect: "ollama", model: chosen, plan });
     return;
   }
-  if (action === "ollama") return addServer({ role: "embed", dialect: "ollama" });
-  if (action === "provider") return addServer({ role: "embed", dialect: "openai" });
+  if (action === "ollama" || action === "provider") {
+    if ((await addServer({ role: "embed", dialect: action === "ollama" ? "ollama" : "openai", back: true })) === BACK) return chooseEmbedModel();
+    return;
+  }
 
   if (action === "key") {
     // THE SAME KEY MANAGER as /model's ctrl+k and /agent-model (task #245): this server's keys
@@ -8674,7 +8821,7 @@ async function chooseEmbedModel() {
       await addServer({ role: "embed", dialect: /\/v1\/?$/i.test(currentUrl) ? "openai" : "ollama", url: currentUrl, model: current, newKey: true });
       return;
     } else {
-      await manageServerKeys({ role: "embed", backendId: found.id, host: host || currentUrl, model: current });
+      if ((await manageServerKeys({ role: "embed", backendId: found.id, host: host || currentUrl, model: current, back: true })) === BACK) return chooseEmbedModel();
     }
     // The pre-#245 account-wide pick would shadow what was just chosen; the server decides now.
     if (String(settings.ragEmbedKeyId ?? "").trim()) await saveEmbedSettings({ ragEmbedKeyId: "" });
@@ -8758,7 +8905,7 @@ async function enterAgentProviderKey(row, host) {
 /**
  * #44: switch the agent to a provider already saved on this machine, or add a new one.
  */
-async function chooseAgentProvider() {
+async function chooseAgentProvider({ back = false } = {}) {
   const am = await import("./agent-model-command.mjs");
   const settings = await withPendingStatus("reading your providers", fetchWorkerSettings);
   if (!settings) {
@@ -8766,17 +8913,25 @@ async function chooseAgentProvider() {
     return;
   }
   const choices = am.agentProviderChoices(settings);
-  if (choices.length === 1) return addServer({ role: "agent", dialect: "openai" });
-  console.log(dim(`   Which OpenAI-compatible provider should the agent use?  (${PICK_HINT})`));
-  const idx = await pickFromList(choices.map((c) => c.label), 0);
-  if (idx < 0) {
-    console.log(dim("   (cancelled)\n"));
-    return;
+  if (choices.length === 1) return addServer({ role: "agent", dialect: "openai", back });
+  let at = 0;
+  for (;;) {
+    console.log(dim(`   Which OpenAI-compatible provider should the agent use?  (${PICK_HINT})`));
+    const idx = await pickFromList(choices.map((c) => c.label), at, { back });
+    if (idx === PICK_BACK) return BACK;
+    if (idx < 0) {
+      console.log(dim("   (cancelled)\n"));
+      return;
+    }
+    at = idx;
+    const pick = choices[idx];
+    // "← back" inside either screen returns to this list (#242).
+    const r = pick.action === "add"
+      ? await addServer({ role: "agent", dialect: "openai", back: true })
+      // A server already set up: the same screen, URL known — its key is reused, its models listed.
+      : await addServer({ role: "agent", dialect: String(pick.row.kind ?? "") === "ollama" ? "ollama" : "openai", url: String(pick.row.url ?? ""), back: true });
+    if (r !== BACK) return;
   }
-  const pick = choices[idx];
-  if (pick.action === "add") return addServer({ role: "agent", dialect: "openai" });
-  // A server already set up: the same screen, URL known — its key is reused, its models listed.
-  await addServer({ role: "agent", dialect: String(pick.row.kind ?? "") === "ollama" ? "ollama" : "openai", url: String(pick.row.url ?? "") });
 }
 
 /**
@@ -8886,13 +9041,21 @@ async function chooseAgentModel() {
     console.log(dim("   (cancelled)\n"));
     return;
   }
-  if (firstAction === "ollama") return addServer({ role: "agent", dialect: "ollama" });
-  if (firstAction === "provider") return chooseAgentProvider();
+  // "← back" in any of these returns to this menu (#242) — read again, as on a first open.
+  if (firstAction === "ollama") {
+    if ((await addServer({ role: "agent", dialect: "ollama", back: true })) === BACK) return chooseAgentModel();
+    return;
+  }
+  if (firstAction === "provider") {
+    if ((await chooseAgentProvider({ back: true })) === BACK) return chooseAgentModel();
+    return;
+  }
   if (firstAction === "key") {
     // Task #245: one key manager for every role — this server's keys, this folder's AGENT pick.
     const rowId = String(source.row?.id ?? "").trim() || String(source.row?.kind ?? "").trim();
     if (!rowId) return enterAgentProviderKey(source.row, listHost);
-    await manageServerKeys({ role: "agent", backendId: rowId, host: listHost, model: am.currentAgentModel(settings) });
+    const r = await manageServerKeys({ role: "agent", backendId: rowId, host: listHost, model: am.currentAgentModel(settings), back: true });
+    if (r === BACK) return chooseAgentModel();
     return;
   }
 
@@ -8924,7 +9087,8 @@ async function chooseAgentModel() {
   });
   // No other entries here any more (#44): the ways to change the provider are on the menu above,
   // where they can be seen, rather than after every model.
-  const idx = await pickFromList(labels, Math.max(0, rows.findIndex((r) => r.current)));
+  const idx = await pickFromList(labels, Math.max(0, rows.findIndex((r) => r.current)), { back: true });
+  if (idx === PICK_BACK) return chooseAgentModel();
   if (idx < 0) {
     console.log(dim("   (cancelled)\n"));
     return;
@@ -10217,7 +10381,7 @@ async function replaceCodingKey() {
  * `role` is "coding" | "agent" | "embed"; `backendId` the server's row id; `host` its name.
  * Returns the id now in use for this folder's role, or "" when nothing changed.
  */
-async function manageServerKeys({ role = "coding", backendId, host, model = "" }) {
+async function manageServerKeys({ role = "coding", backendId, host, model = "", back = false }) {
   const sk = await import("./server-keys.mjs");
   const { label: roleLabel } = sk.roleOf(role);
   const folderKeyId = role === "agent" ? sessionAgentKeyId : role === "embed" ? sessionEmbedKeyId : sessionCodingKeyId;
@@ -10240,8 +10404,9 @@ async function manageServerKeys({ role = "coding", backendId, host, model = "" }
   rows.push(dim("add a new key…"));
   console.log("\n" + GUTTER + dim(`Keys for ${host} — ${folderLabel()}'s ${roleLabel}${model ? ` (${model})` : ""}\n`));
   console.log(GUTTER + dim("Enter chooses · ctrl+d deletes the highlighted key\n"));
-  const picked = await pickFromList(rows, Math.max(0, keys.findIndex((k) => k.id === inUse?.id)), { allowDelete: true });
+  const picked = await pickFromList(rows, Math.max(0, keys.findIndex((k) => k.id === inUse?.id)), { allowDelete: true, back });
   const idx = picked?.index ?? -1;
+  if (idx === PICK_BACK) return BACK;
   if (idx < 0) {
     console.log(GUTTER + dim("(cancelled — nothing changed)\n"));
     paintBar();
@@ -11100,7 +11265,24 @@ function pickManyFromList(items, preChecked = [], { max = 0 } = {}) {
   });
 }
 
+/**
+ * "← back" (#242): with `opts.back`, a last row that returns to the menu this one was opened from.
+ * Choosing it resolves PICK_BACK (-2) — still < 0, so a caller that does not handle it reads it as a
+ * cancel and no existing picker can change meaning. Esc still cancels the whole command.
+ */
+const PICK_BACK = -2;
+const BACK_ROW = "← back";
+/** What a flow opened from another menu returns when the user chose "← back" at its first question. */
+const BACK = Symbol("back");
+
 function pickFromList(items, initialSel = 0, opts = {}) {
+  if (opts.back && process.stdin.isTTY && items.length) {
+    const n = items.length;
+    return pickFromList([...items, dim(BACK_ROW)], initialSel, { ...opts, back: false }).then((v) => {
+      if (v && typeof v === "object") return v.index === n ? { ...v, index: PICK_BACK } : v;
+      return v === n ? PICK_BACK : v;
+    });
+  }
   return new Promise((resolve) => {
     if (!process.stdin.isTTY || items.length === 0) {
       resolve(-1);
@@ -14535,6 +14717,10 @@ async function main() {
       await runSwitchSkillCommand(line);
       continue;
     }
+    if (line === "/skills-copy-to-claude" || line.startsWith("/skills-copy-to-claude ")) {
+      await runSkillsCopyCommand(line);
+      continue;
+    }
     if (line === "/hooks" || line.startsWith("/hooks ")) {
       const { runHooksCommand } = await import("./hooks-command.mjs");
       const style = { ok: accent, warn: yellow, dim };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.872",
+  "version": "1.0.873",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -134,6 +134,7 @@
     "update-verify.mjs",
     "skills.mjs",
     "skill-source.mjs",
+    "skills-copy.mjs",
     "shell-details.mjs",
     "proc-identity.mjs",
     "win-path.mjs",

package/skills-copy.mjs

@@ -0,0 +1,266 @@
+/**
+ * /skills-copy-to-claude — copy gu's skills into Claude Code's folders, under Claude's names (#241).
+ *
+ *   ~/.gonext/skills/<name>/          →  ~/.claude/skills/<claude-name>/
+ *   <project>/.gonext/skills/<name>/  →  <project>/.claude/skills/<claude-name>/
+ *   the skill's MCP server in ~/.gonext/mcp.json  →  ~/.claude.json
+ *       (user scope for a home skill, projects["<folder>"] for a project skill)
+ *
+ * The web-v2 Skills page's installer (#208, src/skills/email/install.mjs) puts a skill's files into
+ * ~/.gonext/skills/<name>/ and its MCP server into ~/.gonext/mcp.json. This is the same move in the
+ * other direction, so a skill set up for gu also works in Claude Code.
+ *
+ * NAMES. gu's own skills start with "gu-" where Claude's start with "claude-" (the memory skill is
+ * gu-session-memory-orchestration here and claude-session-memory-orchestration there). So "gu-"
+ * becomes "claude-" in the folder name, the frontmatter `name:` and the text. Other names stay.
+ *
+ * TEXT. Only SKILL.md is rewritten, and only what is certain: paths into the skill's own folder
+ * (they now point at the copy) and the old name. Other mentions of .gonext (gu's memory CLI, say)
+ * may have no Claude equivalent, so they are left as they are and REPORTED, never guessed.
+ *
+ * A COPY. Nothing under ~/.gonext changes. Claude's file ~/.claude.json is changed only through
+ * updateClaudeConfig, and only its mcpServers. A Claude skill that differs is kept unless the user
+ * chose "replace"; a replaced folder goes to ~/.gonext/skills-copy-backups/<time>/, never next to
+ * the others in .claude/skills, where Claude would load it as a second skill.
+ */
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, relative, resolve, sep } from "node:path";
+import { scanSkillsDir } from "./skills.mjs";
+import { readClaudeServers, readUserConfig, updateClaudeConfig } from "./mcp-config.mjs";
+
+export const BACKUP_DIR_NAME = "skills-copy-backups";
+
+/** Claude's name for a gu skill: "gu-" → "claude-", else the same. Kept within Claude's 64. */
+export function claudeSkillName(name) {
+  const n = String(name);
+  return n.startsWith("gu-") ? `claude-${n.slice(3)}`.slice(0, 64) : n;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * SKILL.md for Claude: its own-folder paths and its old name rewritten. → { text, guLines }
+ * guLines = line numbers (1-based) that still mention .gonext after the rewrite — for the user to check.
+ */
+export function rewriteSkillText(text, { from, to }) {
+  let out = String(text);
+  // ".gonext/skills/<from>" in any form (~/, $HOME/, an absolute home, ./, Windows backslashes).
+  const pathRe = new RegExp(`\\.gonext([\\\\/])skills\\1${escapeRe(from)}(?![a-z0-9-])`, "g");
+  out = out.replace(pathRe, (_m, s) => `.claude${s}skills${s}${to}`);
+  if (to !== from) {
+    // The name itself: in the frontmatter, as /<name>, in use_skill("<name>")…
+    const nameRe = new RegExp(`(?<![a-z0-9-])${escapeRe(from)}(?![a-z0-9-])`, "g");
+    out = out.replace(nameRe, to);
+  }
+  const guLines = out
+    .split("\n")
+    .map((l, i) => (/\.gonext\b/.test(l) ? i + 1 : 0))
+    .filter(Boolean);
+  return { text: out, guLines };
+}
+
+/**
+ * `p` inside `dir` → the same path inside `toDir`, else null. Slashes and (on Windows) case are
+ * ignored when comparing, and a leading ~ counts as the home folder.
+ */
+export function movePath(p, dir, toDir, { home = homedir(), platform = process.platform } = {}) {
+  if (typeof p !== "string" || !p) return null;
+  const expanded = /^~(?=$|[\\/])/.test(p) ? home + p.slice(1) : p;
+  const norm = (s) => {
+    const x = s.replace(/\\/g, "/").replace(/\/+$/, "");
+    return platform === "win32" ? x.toLowerCase() : x;
+  };
+  const a = norm(expanded);
+  const d = norm(dir);
+  if (a !== d && !a.startsWith(d + "/")) return null;
+  const rest = expanded.replace(/\\/g, "/").replace(/\/+$/, "").slice(d.length).replace(/^\//, "");
+  const s = platform === "win32" ? "\\" : "/";
+  const base = toDir.replace(/[\\/]+$/, "");
+  return rest ? base + s + rest.split("/").join(s) : base;
+}
+
+/** An MCP entry with every path into the skill folder moved to the copy. → { entry, linked } */
+export function moveServerEntry(entry, fromDir, toDir, opts) {
+  let linked = false;
+  const mv = (v) => {
+    const m = movePath(v, fromDir, toDir, opts);
+    if (m == null) return v;
+    linked = true;
+    return m;
+  };
+  const out = { ...entry };
+  if (typeof out.command === "string") out.command = mv(out.command);
+  if (Array.isArray(out.args)) out.args = out.args.map((a) => (typeof a === "string" ? mv(a) : a));
+  if (out.env && typeof out.env === "object") {
+    out.env = Object.fromEntries(Object.entries(out.env).map(([k, v]) => [k, typeof v === "string" ? mv(v) : v]));
+  }
+  if (typeof out.cwd === "string") out.cwd = mv(out.cwd);
+  return { entry: out, linked };
+}
+
+/** Every file of a folder (following links), as relative path → { data, mode }. .DS_Store left out. */
+function readTree(dir) {
+  const files = new Map();
+  const walk = (d) => {
+    for (const name of readdirSync(d)) {
+      if (name === ".DS_Store") continue;
+      const p = join(d, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue; // a dangling link
+      }
+      if (st.isDirectory()) walk(p);
+      else if (st.isFile()) files.set(relative(dir, p).split(sep).join("/"), { data: readFileSync(p), mode: st.mode & 0o777 });
+    }
+  };
+  walk(dir);
+  return files;
+}
+
+function sameTree(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [k, v] of a) {
+    const w = b.get(k);
+    if (!w || !w.data.equals(v.data)) return false;
+  }
+  return true;
+}
+
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+/**
+ * What would be copied. Reads only. `names` (gu's or Claude's names) narrows it to those skills.
+ *
+ * → { items: [{ name, newName, scope, from, to, status: "new"|"same"|"differs", guLines, files,
+ *               servers: [{ name, scope, entry, status }] }],
+ *     warnings, missing: names asked for that gu does not have }
+ */
+export function planSkillsCopy({ cwd = process.cwd(), home = homedir(), names = [], platform = process.platform } = {}) {
+  const dirs = [{ scope: "user", from: join(home, ".gonext", "skills"), to: join(home, ".claude", "skills") }];
+  if (cwd && resolve(cwd) !== resolve(home)) {
+    dirs.push({ scope: "project", from: join(cwd, ".gonext", "skills"), to: join(cwd, ".claude", "skills") });
+  }
+  const gu = readUserConfig(home);
+  const claude = readClaudeServers({ cwd, home });
+  const warnings = [];
+  if (gu.error) warnings.push(`~/.gonext/mcp.json is ${gu.error} — no MCP servers are copied with the skills`);
+  if (claude.error) warnings.push(`~/.claude.json is ${claude.error} — no MCP servers can be copied into it`);
+
+  const wanted = new Set(names.map((n) => String(n).replace(/^\//, "")));
+  const items = [];
+  for (const d of dirs) {
+    const scan = scanSkillsDir(d.from, d.scope);
+    warnings.push(...scan.warnings);
+    for (const s of scan.skills) {
+      const newName = claudeSkillName(s.name);
+      if (wanted.size && !wanted.has(s.name) && !wanted.has(newName)) continue;
+      const folder = s.dir.split(/[\\/]/).pop();
+      const to = join(d.to, newName);
+      const files = readTree(s.dir);
+      const md = files.get("SKILL.md");
+      const rewritten = rewriteSkillText(md.data.toString("utf8"), { from: s.name, to: newName });
+      // A folder named differently from its frontmatter name: rewrite its paths too.
+      const text = folder !== s.name ? rewriteSkillText(rewritten.text, { from: folder, to: newName }) : rewritten;
+      files.set("SKILL.md", { data: Buffer.from(text.text, "utf8"), mode: md.mode });
+
+      let status = "new";
+      if (existsSync(to)) status = sameTree(files, readTree(to)) ? "same" : "differs";
+
+      const servers = [];
+      if (!gu.error && !claude.error) {
+        const have = d.scope === "project" ? claude.local : claude.user;
+        for (const [sname, entry] of Object.entries(gu.mcpServers)) {
+          if (!isObj(entry)) continue;
+          const moved = moveServerEntry(entry, s.dir, to, { home, platform });
+          if (!moved.linked) continue;
+          const st = !(sname in have) ? "new" : sameJson(have[sname], moved.entry) ? "same" : "differs";
+          servers.push({ name: sname, scope: d.scope === "project" ? "local" : "user", entry: moved.entry, status: st });
+        }
+      }
+      items.push({ name: s.name, newName, scope: d.scope, from: s.dir, to, status, guLines: text.guLines, files, servers });
+    }
+  }
+  const have = new Set(items.flatMap((i) => [i.name, i.newName]));
+  const missing = [...wanted].filter((n) => !have.has(n));
+  return { items, warnings, missing };
+}
+
+function writeTree(dir, files) {
+  for (const [rel, f] of files) {
+    const p = join(dir, ...rel.split("/"));
+    mkdirSync(join(p, ".."), { recursive: true });
+    writeFileSync(p, f.data, { mode: f.mode || 0o644 });
+  }
+}
+
+/** Move a folder; across disks, copy then remove. */
+function moveDir(from, to) {
+  mkdirSync(join(to, ".."), { recursive: true });
+  try {
+    renameSync(from, to);
+  } catch {
+    cpSync(from, to, { recursive: true });
+    rmSync(from, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Do it. `replace` = also overwrite skills and servers Claude has in a different version (the old
+ * folder is backed up first). → { done: [{ name, newName, to, action, backup? }],
+ *                                 servers: [{ name, scope, action }], errors: string[] }
+ * action: "copied" | "replaced" | "kept" | "already"
+ */
+export function applySkillsCopy(plan, { replace = false, cwd = process.cwd(), home = homedir(), now = new Date() } = {}) {
+  const stamp = now.toISOString().replace(/[:.]/g, "-");
+  const backupRoot = join(home, ".gonext", BACKUP_DIR_NAME, stamp);
+  const done = [];
+  const servers = [];
+  const errors = [];
+  for (const it of plan.items) {
+    try {
+      if (it.status === "same") done.push({ name: it.name, newName: it.newName, to: it.to, action: "already" });
+      else if (it.status === "differs" && !replace) done.push({ name: it.name, newName: it.newName, to: it.to, action: "kept" });
+      else {
+        let backup;
+        if (it.status === "differs") {
+          backup = join(backupRoot, it.scope, it.newName);
+          moveDir(it.to, backup);
+        }
+        mkdirSync(it.to, { recursive: true });
+        writeTree(it.to, it.files);
+        done.push({ name: it.name, newName: it.newName, to: it.to, action: backup ? "replaced" : "copied", ...(backup ? { backup } : {}) });
+      }
+    } catch (err) {
+      errors.push(`${it.name}: ${err.message}`);
+      continue;
+    }
+    const write = it.servers.filter((s) => s.status === "new" || (s.status === "differs" && replace));
+    for (const s of it.servers) {
+      if (!write.includes(s)) servers.push({ name: s.name, scope: s.scope, action: s.status === "same" ? "already" : "kept" });
+    }
+    if (!write.length) continue;
+    try {
+      updateClaudeConfig((raw) => {
+        for (const s of write) {
+          let into;
+          if (s.scope === "local") {
+            raw.projects = isObj(raw.projects) ? raw.projects : {};
+            const key = resolve(cwd);
+            raw.projects[key] = isObj(raw.projects[key]) ? raw.projects[key] : {};
+            into = raw.projects[key];
+          } else into = raw;
+          into.mcpServers = isObj(into.mcpServers) ? into.mcpServers : {};
+          into.mcpServers[s.name] = s.entry;
+        }
+      }, home);
+      for (const s of write) servers.push({ name: s.name, scope: s.scope, action: s.status === "differs" ? "replaced" : "copied" });
+    } catch (err) {
+      errors.push(`MCP ${write.map((s) => s.name).join(", ")}: ${err.message}`);
+    }
+  }
+  return { done, servers, errors, backupRoot };
+}

package/skills.mjs

@@ -94,6 +94,9 @@ function isDir(p) {
 }
 
 /** One skills folder → { skills, warnings }. A folder that is not there is simply empty. */
+export function scanSkillsDir(dir, scope) {
+  return scanDir(dir, scope);
+}
 function scanDir(dir, scope) {
   const skills = [];
   const warnings = [];