@holt-os/holt 0.4.0 → 0.5.1

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/workspace.ts
 import { homedir } from "os";
@@ -35,11 +36,11 @@ function createReader() {
     closed = true;
     while (waiters.length) waiters.shift()(null);
   });
-  const ask = (q) => new Promise((resolve) => {
+  const ask = (q) => new Promise((resolve3) => {
     if (q) process.stdout.write(q);
-    if (buffer.length) resolve(buffer.shift());
-    else if (closed) resolve(null);
-    else waiters.push(resolve);
+    if (buffer.length) resolve3(buffer.shift());
+    else if (closed) resolve3(null);
+    else waiters.push(resolve3);
   });
   return { ask, close: () => rl.close() };
 }
@@ -103,13 +104,24 @@ var BRAIN_SETUP = {
   gemini: { install: ["npm", "install", "-g", "@google/gemini-cli"], login: ["gemini"] }
 };
 var BRAIN_IDS = ["claude", "codex", "gemini"];
+var PROVIDERS = ["anthropic", "openai", "gemini"];
+var PROVIDER_MODEL_SUGGESTION = {
+  anthropic: "claude-sonnet-4-6",
+  openai: "gpt-5",
+  gemini: "gemini-2.5-flash"
+};
+var PROVIDER_ENV = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  gemini: "GEMINI_API_KEY"
+};
 function defaultConfig() {
   const brains = {};
   for (const id of BRAIN_IDS) {
     const d = BRAIN_DEFS[id];
     brains[id] = { id, label: d.label, command: d.command, args: [...d.args], enabled: false };
   }
-  return { version: 2, defaultBrain: null, brains };
+  return { version: 3, defaultBrain: null, brains, apiBrains: [], outputFormat: "markdown" };
 }
 function loadConfig() {
   const path = wsConfigPath();
@@ -117,8 +129,15 @@ function loadConfig() {
   try {
     const cfg = JSON.parse(readFileSync2(path, "utf8"));
     const base = defaultConfig();
-    for (const id of BRAIN_IDS) if (!cfg.brains?.[id]) cfg.brains[id] = base.brains[id];
-    return cfg;
+    const brains = cfg.brains ?? {};
+    for (const id of BRAIN_IDS) if (!brains[id]) brains[id] = base.brains[id];
+    return {
+      version: 3,
+      defaultBrain: cfg.defaultBrain ?? null,
+      brains,
+      apiBrains: Array.isArray(cfg.apiBrains) ? cfg.apiBrains : [],
+      outputFormat: cfg.outputFormat === "html" ? "html" : "markdown"
+    };
   } catch {
     return null;
   }
@@ -127,6 +146,47 @@ function saveConfig(cfg) {
   ensureWsDir();
   writeFileSync2(wsConfigPath(), JSON.stringify(cfg, null, 2) + "\n", "utf8");
 }
+function isReservedBrainId(id) {
+  return BRAIN_IDS.includes(id.toLowerCase());
+}
+function findApiBrain(cfg, id) {
+  return cfg.apiBrains.find((b) => b.id === id);
+}
+function credentialsPath() {
+  return join2(GLOBAL_DIR, "credentials.json");
+}
+function readCredentials() {
+  try {
+    return JSON.parse(readFileSync2(credentialsPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredential(provider, key) {
+  mkdirSync2(GLOBAL_DIR, { recursive: true });
+  const creds = readCredentials();
+  creds[provider] = key;
+  writeFileSync2(credentialsPath(), JSON.stringify(creds, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+}
+function resolveApiKey(brain) {
+  if (brain.keyEnv) {
+    const v = process.env[brain.keyEnv];
+    if (v && v.trim()) return v.trim();
+  }
+  const creds = readCredentials();
+  const stored = creds[brain.provider];
+  if (stored && stored.trim()) return stored.trim();
+  const std = process.env[PROVIDER_ENV[brain.provider]];
+  if (std && std.trim()) return std.trim();
+  return null;
+}
+function keyHint(brain) {
+  const parts = [];
+  if (brain.keyEnv) parts.push(`set env var ${brain.keyEnv}`);
+  parts.push(`set ${PROVIDER_ENV[brain.provider]}`);
+  parts.push("or store a key via /setting > connect API brain");
+  return parts.join(", ");
+}
 
 // src/brains.ts
 import { spawn, spawnSync } from "child_process";
@@ -159,12 +219,12 @@ function renderPrompt(history, message, memory = []) {
   return parts.join("\n");
 }
 function runBrain(brain, prompt, onChunk) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     let child;
     try {
       child = spawn(brain.command, [...brain.args, prompt], { stdio: ["ignore", "pipe", "pipe"] });
     } catch (e) {
-      resolve({ ok: false, text: `Could not launch "${brain.command}": ${e.message}` });
+      resolve3({ ok: false, text: `Could not launch "${brain.command}": ${e.message}` });
       return;
     }
     let out = "";
@@ -177,26 +237,26 @@ function runBrain(brain, prompt, onChunk) {
     child.stderr.on("data", (d) => {
       err += d.toString();
     });
-    child.on("error", (e) => resolve({ ok: false, text: `Could not run "${brain.command}": ${e.message}` }));
+    child.on("error", (e) => resolve3({ ok: false, text: `Could not run "${brain.command}": ${e.message}` }));
     child.on("close", (code) => {
       const text = out.trim();
-      if (code === 0 && text) resolve({ ok: true, text });
-      else resolve({ ok: false, text: err.trim() || text || `"${brain.command}" exited with code ${code}` });
+      if (code === 0 && text) resolve3({ ok: true, text });
+      else resolve3({ ok: false, text: err.trim() || text || `"${brain.command}" exited with code ${code}` });
     });
   });
 }
 
 // src/alias.ts
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
 var START = "# >>> holt launch alias >>>";
 var END = "# <<< holt launch alias <<<";
 function rcFile() {
   const shell = process.env.SHELL || "";
-  if (shell.includes("zsh")) return join2(homedir2(), ".zshrc");
-  if (shell.includes("bash")) return join2(homedir2(), ".bashrc");
-  return join2(homedir2(), ".profile");
+  if (shell.includes("zsh")) return join3(homedir2(), ".zshrc");
+  if (shell.includes("bash")) return join3(homedir2(), ".bashrc");
+  return join3(homedir2(), ".profile");
 }
 function installAlias(name) {
   const file = rcFile();
@@ -239,30 +299,30 @@ function removeAlias() {
 // src/install.ts
 import { spawn as spawn2 } from "child_process";
 function runInteractive(cmd, args) {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     let child;
     try {
       child = spawn2(cmd, args, { stdio: "inherit" });
     } catch {
-      resolve(-1);
+      resolve3(-1);
       return;
     }
-    child.on("error", () => resolve(-1));
-    child.on("close", (code) => resolve(code ?? -1));
+    child.on("error", () => resolve3(-1));
+    child.on("close", (code) => resolve3(code ?? -1));
   });
 }
 
 // src/memory.ts
-import { appendFileSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync, statSync } from "fs";
-import { join as join3 } from "path";
+import { appendFileSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync3, rmSync, statSync } from "fs";
+import { join as join4 } from "path";
 import { randomUUID } from "crypto";
 var OLLAMA_URL = process.env.HOLT_OLLAMA_URL || "http://127.0.0.1:11434";
 var EMBED_MODEL = process.env.HOLT_EMBED_MODEL || "nomic-embed-text";
 function memDir() {
-  return join3(wsHoltDir(), "memory");
+  return join4(wsHoltDir(), "memory");
 }
 function memPath() {
-  return join3(memDir(), "turns.jsonl");
+  return join4(memDir(), "turns.jsonl");
 }
 function newSessionId() {
   return randomUUID().slice(0, 8);
@@ -313,7 +373,7 @@ function loadTurns() {
   return out;
 }
 function appendTurn(t) {
-  mkdirSync2(memDir(), { recursive: true });
+  mkdirSync3(memDir(), { recursive: true });
   appendFileSync(memPath(), JSON.stringify(t) + "\n", "utf8");
 }
 function clearMemory() {
@@ -382,11 +442,162 @@ async function backfillEmbeddings(onProgress) {
     done++;
     if (onProgress) onProgress(done, missing.length);
   }
-  mkdirSync2(memDir(), { recursive: true });
+  mkdirSync3(memDir(), { recursive: true });
   writeFileSync4(memPath(), turns.map((t) => JSON.stringify(t)).join("\n") + "\n", "utf8");
   return { embedded, total: missing.length };
 }
 
+// src/commands/setting.ts
+function printStatus(cfg) {
+  console.log("\n" + c.accent("Holt settings") + c.dim("  (this folder)"));
+  for (const id of BRAIN_IDS) {
+    const b = cfg.brains[id];
+    const tags = [
+      b.enabled ? c.green("enabled") : isInstalled(b.command) ? c.dim("installed, off") : c.dim("not installed"),
+      cfg.defaultBrain === id ? c.accent("default") : ""
+    ].filter(Boolean).join("  ");
+    console.log(`  ${id.padEnd(10)} ${b.label.padEnd(16)} ${tags}`);
+  }
+  if (cfg.apiBrains.length) {
+    console.log(c.dim("  api brains:"));
+    for (const a of cfg.apiBrains) {
+      const key = resolveApiKey(a) ? c.green("key ok") : c.red("no key");
+      const def = cfg.defaultBrain === a.id ? c.accent("default") : "";
+      console.log(`  ${a.id.padEnd(10)} ${`${a.provider}/${a.model}`.padEnd(30)} ${key}  ${def}`);
+    }
+  }
+  console.log(c.dim(`  output format: ${cfg.outputFormat}`));
+  console.log(c.dim(`  launch command: ${currentAlias() || "holt (default)"}`));
+  console.log("\n  " + c.dim("[d] default brain   [t] toggle brain   [c] connect API brain   [x] remove API brain   [a] launch command   [enter] done"));
+}
+async function connectApiBrain(ask, cfg) {
+  let provider = null;
+  for (let tries = 0; tries < 3 && !provider; tries++) {
+    const provRaw = (await ask(`  provider [${PROVIDERS.join("/")}] (enter for ${PROVIDERS[0]}, or "skip"): `) ?? "skip").trim().toLowerCase();
+    if (provRaw === "skip" || provRaw === "q" || provRaw === "n" || provRaw === "no") {
+      console.log(c.dim('  skipped. Add one later with "holt setting" then "c".'));
+      return null;
+    }
+    if (provRaw === "") provider = PROVIDERS[0];
+    else if (PROVIDERS.includes(provRaw)) provider = provRaw;
+    else console.log(c.dim(`  "${provRaw}" is not a provider. Type one of: ${PROVIDERS.join(", ")}`));
+  }
+  if (!provider) {
+    console.log(c.dim('  skipped after three tries. Add one later with "holt setting" then "c".'));
+    return null;
+  }
+  const suggestion = PROVIDER_MODEL_SUGGESTION[provider];
+  const modelRaw = (await ask(`  model (enter for ${suggestion}): `) ?? "").trim();
+  const model = modelRaw || suggestion;
+  const idRaw = (await ask("  short name for this brain (e.g. sonnet): ") ?? "").trim();
+  if (!idRaw) {
+    console.log(c.dim("  cancelled (no name)."));
+    return null;
+  }
+  if (isReservedBrainId(idRaw)) {
+    console.log(c.red(`  "${idRaw}" is reserved for a CLI brain. Pick another name.`));
+    return null;
+  }
+  if (findApiBrain(cfg, idRaw)) {
+    console.log(c.red(`  an API brain named "${idRaw}" already exists.`));
+    return null;
+  }
+  console.log(c.dim("  key: paste a raw key (stored locally, mode 600), or type the name of an env var that holds it."));
+  const keyRaw = (await ask("  key or env var name: ") ?? "").trim();
+  let keyEnv;
+  if (!keyRaw) {
+    console.log(c.dim("  no key given now. You can set the standard env var later."));
+  } else if (/^[A-Z][A-Z0-9_]*$/.test(keyRaw)) {
+    keyEnv = keyRaw;
+    console.log(c.dim(`  will read the key from env var ${keyEnv}.`));
+  } else {
+    saveCredential(provider, keyRaw);
+    console.log(c.green(`  key stored in ~/.holt/credentials.json (mode 600).`));
+  }
+  const brain = { id: idRaw, provider, model, ...keyEnv ? { keyEnv } : {} };
+  cfg.apiBrains.push(brain);
+  const resolvable = resolveApiKey(brain);
+  console.log(c.green(`  connected "${idRaw}" -> ${provider}/${model}.`) + (resolvable ? "" : c.dim(" (no key resolves yet)")));
+  return brain;
+}
+function selectableIds(cfg) {
+  return [...BRAIN_IDS.filter((id) => cfg.brains[id].enabled), ...cfg.apiBrains.map((a) => a.id)];
+}
+async function runSettings(ask) {
+  let cfg = loadConfig() ?? defaultConfig();
+  while (true) {
+    printStatus(cfg);
+    const raw = await ask("  > ");
+    const choice = (raw ?? "").trim().toLowerCase();
+    if (raw === null || choice === "" || choice === "q") break;
+    if (choice === "d") {
+      const options = selectableIds(cfg);
+      if (options.length === 0) {
+        console.log(c.dim('  No brains ready. Toggle a CLI brain on ("t") or connect an API brain ("c").'));
+        continue;
+      }
+      const pick = (await ask(`  default brain [${options.join("/")}]: `) ?? "").trim();
+      if (options.includes(pick)) {
+        cfg.defaultBrain = pick;
+        const label = BRAIN_IDS.includes(pick) ? cfg.brains[pick].label : pick;
+        console.log(c.green(`  default set to ${label}`));
+      } else console.log(c.dim("  unchanged."));
+    } else if (choice === "t") {
+      const pick = (await ask(`  toggle which brain [${BRAIN_IDS.join("/")}]: `) ?? "").trim();
+      if (BRAIN_IDS.includes(pick)) {
+        if (!cfg.brains[pick].enabled && !isInstalled(cfg.brains[pick].command)) {
+          console.log(c.dim(`  ${cfg.brains[pick].label} is not installed. Run "holt init" to install it.`));
+        } else {
+          cfg.brains[pick].enabled = !cfg.brains[pick].enabled;
+          if (!cfg.brains[pick].enabled && cfg.defaultBrain === pick) cfg.defaultBrain = selectableIds(cfg)[0] ?? null;
+          if (cfg.brains[pick].enabled && !cfg.defaultBrain) cfg.defaultBrain = pick;
+          console.log(c.dim(`  ${cfg.brains[pick].label} is now ${cfg.brains[pick].enabled ? "on" : "off"}.`));
+        }
+      } else console.log(c.dim("  unchanged."));
+    } else if (choice === "c") {
+      await connectApiBrain(ask, cfg);
+      if (!cfg.defaultBrain && cfg.apiBrains.length) cfg.defaultBrain = cfg.apiBrains[cfg.apiBrains.length - 1]?.id ?? null;
+    } else if (choice === "x") {
+      if (cfg.apiBrains.length === 0) {
+        console.log(c.dim("  no API brains to remove."));
+        continue;
+      }
+      const pick = (await ask(`  remove which API brain [${cfg.apiBrains.map((a) => a.id).join("/")}]: `) ?? "").trim();
+      const idx = cfg.apiBrains.findIndex((a) => a.id === pick);
+      if (idx >= 0) {
+        cfg.apiBrains.splice(idx, 1);
+        if (cfg.defaultBrain === pick) cfg.defaultBrain = selectableIds(cfg)[0] ?? null;
+        console.log(c.dim(`  removed "${pick}". (its stored key, if any, stays in ~/.holt/credentials.json)`));
+      } else console.log(c.dim("  unchanged."));
+    } else if (choice === "a") {
+      const name = (await ask("  launch command (blank to reset to holt): ") ?? "").trim();
+      if (name && name !== "holt") {
+        if (isInstalled(name)) console.log(c.dim(`  note: "${name}" already exists; the alias will shadow it in new shells.`));
+        const r = installAlias(name);
+        console.log(r.ok ? c.green(`  alias "${name}" -> holt chat added to ${r.file} (run: source ${r.file})`) : c.red("  " + r.message));
+      } else {
+        removeAlias();
+        console.log(c.dim("  reset to holt."));
+      }
+    } else {
+      console.log(c.dim("  pick d, t, c, x, a, or press enter to finish."));
+    }
+    saveConfig(cfg);
+  }
+  saveConfig(cfg);
+  return cfg;
+}
+async function setting() {
+  const { ask, close } = createReader();
+  if (!await ensureTrusted(ask)) {
+    close();
+    return;
+  }
+  await runSettings(ask);
+  close();
+  console.log("");
+}
+
 // src/commands/init.ts
 function parseBrains(raw, found) {
   const s = raw.trim().toLowerCase();
@@ -422,16 +633,25 @@ async function init() {
     const a = (await ask(`  ${BRAIN_DEFS[id].label} is not installed. Sign in after install? [Y/n] `) ?? "").trim().toLowerCase();
     if (a !== "n" && a !== "no") loginWanted.add(id);
   }
+  const connectedApiBrains = [];
+  const apiAns = (await ask("\nAlso connect a direct API brain (raw key, no CLI needed)? [y/N] ") ?? "").trim().toLowerCase();
+  if (apiAns === "y" || apiAns === "yes") {
+    const holder = defaultConfig();
+    const brain = await connectApiBrain(ask, holder);
+    if (brain) connectedApiBrains.push(brain);
+  }
   const defPick = chosen.includes("claude") ? "claude" : chosen[0];
   const dans = (await ask(`
 Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
   const defaultBrain = chosen.includes(dans) ? dans : defPick;
   const aliasAns = (await ask('Launch command? Type a custom word like "ai", or press enter to keep "holt": ') ?? "").trim();
   let aliasNote = "";
+  let aliasRcFile = "";
   if (aliasAns && aliasAns !== "holt") {
     if (isInstalled(aliasAns)) console.log(c.dim(`  note: "${aliasAns}" already exists; the alias will shadow it in new shells.`));
     const r = installAlias(aliasAns);
-    aliasNote = r.ok ? c.green(`  alias "${aliasAns}" -> holt chat added to ${r.file} (run: source ${r.file})`) : c.red("  " + r.message);
+    if (r.ok) aliasRcFile = r.file;
+    aliasNote = r.ok ? c.green(`  alias "${aliasAns}" -> holt chat added to ${r.file}`) : c.red("  " + r.message);
   }
   let wantMemorySetup = false;
   const embedReady = await embeddingsAvailable();
@@ -482,102 +702,472 @@ Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
   }
   const cfg = loadConfig() ?? defaultConfig();
   for (const id of BRAIN_IDS) cfg.brains[id].enabled = chosen.includes(id) && isInstalled(BRAIN_DEFS[id].command);
-  cfg.defaultBrain = cfg.brains[defaultBrain].enabled ? defaultBrain : BRAIN_IDS.find((id) => cfg.brains[id].enabled) ?? null;
+  for (const b of connectedApiBrains) if (!cfg.apiBrains.some((a) => a.id === b.id)) cfg.apiBrains.push(b);
+  cfg.defaultBrain = cfg.brains[defaultBrain].enabled ? defaultBrain : BRAIN_IDS.find((id) => cfg.brains[id].enabled) ?? cfg.apiBrains[0]?.id ?? null;
   saveConfig(cfg);
   console.log("\n" + c.green("Saved to ./.holt/config.json"));
   if (aliasNote) console.log(aliasNote);
-  if (cfg.defaultBrain) console.log("Start chatting:  " + c.accent(aliasAns && aliasAns !== "holt" ? aliasAns : "holt chat") + "\n");
-  else console.log(c.dim('No brain is ready yet. Install one, then run "holt init" again.\n'));
+  if (cfg.defaultBrain) {
+    if (aliasRcFile) {
+      console.log("\nStart chatting:");
+      console.log("  " + c.accent(`source ${aliasRcFile}`) + c.dim("   (once; new terminals will not need it)"));
+      console.log("  " + c.accent(aliasAns) + "\n");
+      console.log(c.dim("  Or right now, without sourcing: holt chat\n"));
+    } else {
+      console.log("Start chatting:  " + c.accent("holt chat") + "\n");
+    }
+  } else {
+    console.log(c.dim('No brain is ready yet. Install one, then run "holt init" again.\n'));
+  }
 }
 
 // src/commands/chat.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
-// src/commands/setting.ts
-function printStatus(cfg) {
-  console.log("\n" + c.accent("Holt settings") + c.dim("  (this folder)"));
-  for (const id of BRAIN_IDS) {
-    const b = cfg.brains[id];
-    const tags = [
-      b.enabled ? c.green("enabled") : isInstalled(b.command) ? c.dim("installed, off") : c.dim("not installed"),
-      cfg.defaultBrain === id ? c.accent("default") : ""
-    ].filter(Boolean).join("  ");
-    console.log(`  ${id.padEnd(7)} ${b.label.padEnd(16)} ${tags}`);
+// src/apibrain.ts
+function parseSSELines(buffer) {
+  const normalized = buffer.replace(/\r\n/g, "\n");
+  const parts = normalized.split("\n\n");
+  const rest = parts.pop() ?? "";
+  const events = parts.filter((p) => p.trim() !== "");
+  return { events, rest };
+}
+function dataLines(event) {
+  const out = [];
+  for (const line of event.split("\n")) {
+    const t = line.replace(/\r$/, "");
+    if (t.startsWith("data:")) out.push(t.slice(5).replace(/^ /, ""));
   }
-  console.log(c.dim(`  launch command: ${currentAlias() || "holt (default)"}`));
-  console.log("\n  " + c.dim("[d] default brain   [t] toggle brain   [a] launch command   [enter] done"));
+  return out;
 }
-async function runSettings(ask) {
-  let cfg = loadConfig() ?? defaultConfig();
-  while (true) {
-    printStatus(cfg);
-    const raw = await ask("  > ");
-    const choice = (raw ?? "").trim().toLowerCase();
-    if (raw === null || choice === "" || choice === "q") break;
-    if (choice === "d") {
-      const enabled = BRAIN_IDS.filter((id) => cfg.brains[id].enabled);
-      if (enabled.length === 0) {
-        console.log(c.dim('  No enabled brains. Toggle one on first with "t".'));
-        continue;
+function extractDelta(provider, json) {
+  const j = json;
+  if (provider === "anthropic") {
+    if (j["type"] === "content_block_delta") {
+      const delta = j["delta"];
+      if (delta && delta.type === "text_delta" && typeof delta.text === "string") return delta.text;
+    }
+    return "";
+  }
+  if (provider === "openai") {
+    const choices = j["choices"];
+    const content = choices?.[0]?.delta?.content;
+    return typeof content === "string" ? content : "";
+  }
+  const candidates = j["candidates"];
+  const parts = candidates?.[0]?.content?.parts;
+  if (!Array.isArray(parts)) return "";
+  return parts.map((p) => typeof p.text === "string" ? p.text : "").join("");
+}
+function buildRequest(brain, key, prompt) {
+  if (brain.provider === "anthropic") {
+    return {
+      url: "https://api.anthropic.com/v1/messages",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": key,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: brain.model,
+        max_tokens: 4096,
+        stream: true,
+        messages: [{ role: "user", content: prompt }]
+      })
+    };
+  }
+  if (brain.provider === "openai") {
+    return {
+      url: "https://api.openai.com/v1/chat/completions",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify({
+        model: brain.model,
+        stream: true,
+        messages: [{ role: "user", content: prompt }]
+      })
+    };
+  }
+  return {
+    url: `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(brain.model)}:streamGenerateContent?alt=sse`,
+    headers: {
+      "content-type": "application/json",
+      "x-goog-api-key": key
+    },
+    body: JSON.stringify({ contents: [{ parts: [{ text: prompt }] }] })
+  };
+}
+async function runApiBrain(brain, prompt, onChunk) {
+  const key = resolveApiKey(brain);
+  if (!key) {
+    return {
+      ok: false,
+      text: `No API key for "${brain.id}" (${brain.provider}). Fix: ${keyHint(brain)}. Standard env var: ${PROVIDER_ENV[brain.provider]}.`
+    };
+  }
+  const spec = buildRequest(brain, key, prompt);
+  let res;
+  try {
+    res = await fetch(spec.url, { method: "POST", headers: spec.headers, body: spec.body });
+  } catch (e) {
+    return { ok: false, text: `Could not reach ${brain.provider}: ${e.message}` };
+  }
+  if (!res.ok) {
+    let body = "";
+    try {
+      body = await res.text();
+    } catch {
+    }
+    return { ok: false, text: `${brain.provider} error ${res.status}: ${body.slice(0, 200)}` };
+  }
+  if (!res.body) {
+    let body = "";
+    try {
+      body = await res.text();
+    } catch {
+    }
+    return { ok: false, text: `${brain.provider} returned no stream. Body: ${body.slice(0, 200)}` };
+  }
+  const decoder = new TextDecoder();
+  let carry = "";
+  let text = "";
+  try {
+    for await (const chunk of res.body) {
+      carry += decoder.decode(chunk, { stream: true });
+      const { events, rest } = parseSSELines(carry);
+      carry = rest;
+      for (const ev of events) {
+        for (const payload of dataLines(ev)) {
+          if (payload === "[DONE]") continue;
+          let json;
+          try {
+            json = JSON.parse(payload);
+          } catch {
+            continue;
+          }
+          const piece = extractDelta(brain.provider, json);
+          if (piece) {
+            text += piece;
+            if (onChunk) onChunk(piece);
+          }
+        }
       }
-      const pick = (await ask(`  default brain [${enabled.join("/")}]: `) ?? "").trim();
-      if (enabled.includes(pick)) {
-        cfg.defaultBrain = pick;
-        console.log(c.green(`  default set to ${cfg.brains[pick].label}`));
-      } else console.log(c.dim("  unchanged."));
-    } else if (choice === "t") {
-      const pick = (await ask(`  toggle which brain [${BRAIN_IDS.join("/")}]: `) ?? "").trim();
-      if (BRAIN_IDS.includes(pick)) {
-        if (!cfg.brains[pick].enabled && !isInstalled(cfg.brains[pick].command)) {
-          console.log(c.dim(`  ${cfg.brains[pick].label} is not installed. Run "holt init" to install it.`));
-        } else {
-          cfg.brains[pick].enabled = !cfg.brains[pick].enabled;
-          if (!cfg.brains[pick].enabled && cfg.defaultBrain === pick) cfg.defaultBrain = BRAIN_IDS.find((id) => cfg.brains[id].enabled) ?? null;
-          if (cfg.brains[pick].enabled && !cfg.defaultBrain) cfg.defaultBrain = pick;
-          console.log(c.dim(`  ${cfg.brains[pick].label} is now ${cfg.brains[pick].enabled ? "on" : "off"}.`));
+    }
+  } catch (e) {
+    if (text) return { ok: true, text };
+    return { ok: false, text: `Stream from ${brain.provider} failed: ${e.message}` };
+  }
+  if (carry.trim()) {
+    for (const payload of dataLines(carry)) {
+      if (payload === "[DONE]") continue;
+      try {
+        const piece = extractDelta(brain.provider, JSON.parse(payload));
+        if (piece) {
+          text += piece;
+          if (onChunk) onChunk(piece);
         }
-      } else console.log(c.dim("  unchanged."));
-    } else if (choice === "a") {
-      const name = (await ask("  launch command (blank to reset to holt): ") ?? "").trim();
-      if (name && name !== "holt") {
-        if (isInstalled(name)) console.log(c.dim(`  note: "${name}" already exists; the alias will shadow it in new shells.`));
-        const r = installAlias(name);
-        console.log(r.ok ? c.green(`  alias "${name}" -> holt chat added to ${r.file} (run: source ${r.file})`) : c.red("  " + r.message));
-      } else {
-        removeAlias();
-        console.log(c.dim("  reset to holt."));
+      } catch {
       }
-    } else {
-      console.log(c.dim("  pick d, t, a, or press enter to finish."));
     }
-    saveConfig(cfg);
   }
-  saveConfig(cfg);
-  return cfg;
+  const trimmed = text.trim();
+  if (trimmed) return { ok: true, text: trimmed };
+  return { ok: false, text: `${brain.provider} returned an empty reply.` };
 }
-async function setting() {
-  const { ask, close } = createReader();
-  if (!await ensureTrusted(ask)) {
-    close();
-    return;
+
+// src/output.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join5 } from "path";
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderInline(text) {
+  const codes = [];
+  let s = text.replace(/`([^`]+)`/g, (_m, code) => {
+    codes.push(`<code>${escapeHtml(code)}</code>`);
+    return `\0${codes.length - 1}\0`;
+  });
+  s = escapeHtml(s);
+  s = s.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, label, url) => {
+    const safe = url.replace(/"/g, "%22");
+    return `<a href="${safe}">${label}</a>`;
+  });
+  s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  s = s.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  s = s.replace(/(\d+)/g, (_m, i) => codes[Number(i)] ?? "");
+  return s;
+}
+function markdownToHtmlBody(md) {
+  const lines = md.replace(/\r\n/g, "\n").split("\n");
+  const out = [];
+  let i = 0;
+  let listOpen = false;
+  let paragraph = [];
+  const flushParagraph = () => {
+    if (paragraph.length) {
+      out.push(`<p>${renderInline(paragraph.join(" "))}</p>`);
+      paragraph = [];
+    }
+  };
+  const closeList = () => {
+    if (listOpen) {
+      out.push("</ul>");
+      listOpen = false;
+    }
+  };
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const fence = line.match(/^```(.*)$/);
+    if (fence) {
+      flushParagraph();
+      closeList();
+      const code = [];
+      i++;
+      while (i < lines.length && !/^```/.test(lines[i] ?? "")) {
+        code.push(lines[i] ?? "");
+        i++;
+      }
+      i++;
+      out.push(`<pre><code>${escapeHtml(code.join("\n"))}</code></pre>`);
+      continue;
+    }
+    const h = line.match(/^(#{1,3})\s+(.*)$/);
+    if (h) {
+      flushParagraph();
+      closeList();
+      const level = (h[1] ?? "#").length;
+      out.push(`<h${level}>${renderInline((h[2] ?? "").trim())}</h${level}>`);
+      i++;
+      continue;
+    }
+    const li = line.match(/^\s*[-*]\s+(.*)$/);
+    if (li) {
+      flushParagraph();
+      if (!listOpen) {
+        out.push("<ul>");
+        listOpen = true;
+      }
+      out.push(`<li>${renderInline((li[1] ?? "").trim())}</li>`);
+      i++;
+      continue;
+    }
+    if (line.trim() === "") {
+      flushParagraph();
+      closeList();
+      i++;
+      continue;
+    }
+    closeList();
+    paragraph.push(line.trim());
+    i++;
   }
-  await runSettings(ask);
-  close();
-  console.log("");
+  flushParagraph();
+  closeList();
+  return out.join("\n");
+}
+function wrapHtmlPage(body, title = "Holt reply") {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>
+  :root { --bg:#0f1115; --fg:#e7e9ee; --accent:#f0b91e; }
+  * { box-sizing: border-box; }
+  body { margin:0; padding:2rem 1.25rem; background:var(--bg); color:var(--fg);
+         font:16px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif; }
+  main { max-width: 760px; margin: 0 auto; }
+  h1,h2,h3 { color:var(--accent); line-height:1.25; margin:1.4em 0 .5em; }
+  h1 { font-size:1.6rem; } h2 { font-size:1.3rem; } h3 { font-size:1.1rem; }
+  a { color:var(--accent); }
+  code { background:#1b1e26; padding:.1em .35em; border-radius:4px; font-size:.9em; }
+  pre { background:#1b1e26; padding:1rem; border-radius:8px; overflow:auto; }
+  pre code { background:none; padding:0; }
+  ul { padding-left:1.3rem; }
+  p { margin:.7em 0; }
+</style>
+</head>
+<body>
+<main>
+${body}
+</main>
+</body>
+</html>
+`;
+}
+function renderReply(reply, format) {
+  if (format === "html") return wrapHtmlPage(markdownToHtmlBody(reply));
+  return reply.endsWith("\n") ? reply : reply + "\n";
+}
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+function saveReply(reply, format, name) {
+  const ext = format === "html" ? ".html" : ".md";
+  let base = (name ?? "").trim();
+  if (!base) base = `holt-reply-${timestamp()}`;
+  if (!/\.[a-z0-9]+$/i.test(base)) base += ext;
+  const path = join5(process.cwd(), base);
+  writeFileSync5(path, renderReply(reply, format), "utf8");
+  return path;
+}
+
+// src/skills.ts
+import { readFileSync as readFileSync5, readdirSync, existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+function skillsRoot(scope) {
+  return scope === "workspace" ? join6(wsHoltDir(), "skills") : join6(GLOBAL_DIR, "skills");
+}
+function sanitizeName(name) {
+  return (name || "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function parseFrontmatter(md) {
+  const text = md.replace(/^/, "");
+  const lines = text.split("\n");
+  let start = 0;
+  while (start < lines.length && lines[start].trim() === "") start++;
+  if (start >= lines.length || lines[start].trim() !== "---") {
+    return { data: {}, body: text.trim() };
+  }
+  const data = {};
+  let i = start + 1;
+  let closed = false;
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") {
+      closed = true;
+      i++;
+      break;
+    }
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    if (!key) continue;
+    let value = line.slice(idx + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    data[key.toLowerCase()] = value;
+  }
+  if (!closed) {
+    return { data: {}, body: text.trim() };
+  }
+  return { data, body: lines.slice(i).join("\n").trim() };
+}
+function readSkill(dir, folder, scope) {
+  const file = join6(dir, "SKILL.md");
+  if (!existsSync5(file)) return null;
+  let raw = "";
+  try {
+    raw = readFileSync5(file, "utf8");
+  } catch {
+    return null;
+  }
+  const { data, body } = parseFrontmatter(raw);
+  const name = sanitizeName(data.name || folder) || folder;
+  let description = data.description || "";
+  if (!description) {
+    const firstLine2 = body.split("\n").map((l) => l.trim()).find((l) => l.length > 0) || "";
+    description = firstLine2.replace(/^#+\s*/, "");
+  }
+  return { name, description, dir, scope };
+}
+function listScope(scope) {
+  const root = skillsRoot(scope);
+  if (!existsSync5(root)) return [];
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const folder of entries) {
+    const dir = join6(root, folder);
+    try {
+      if (!statSync2(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const skill = readSkill(dir, folder, scope);
+    if (skill) out.push(skill);
+  }
+  return out;
+}
+function listSkills() {
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of listScope("global")) byName.set(s.name, s);
+  for (const s of listScope("workspace")) byName.set(s.name, s);
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function loadSkill(name) {
+  const want = sanitizeName(name);
+  const skill = listSkills().find((s) => s.name === want);
+  if (!skill) return null;
+  let raw = "";
+  try {
+    raw = readFileSync5(join6(skill.dir, "SKILL.md"), "utf8");
+  } catch {
+    return null;
+  }
+  const { body } = parseFrontmatter(raw);
+  return { skill, body };
+}
+function skillsPromptBlock() {
+  const skills = listSkills();
+  if (skills.length === 0) return "";
+  const lines = [
+    `Skills available to this user (invoked with "/skill <name>"). When the user invokes a skill, follow that skill's instructions:`,
+    ...skills.map((s) => `- ${s.name}: ${s.description || "(no description)"}`)
+  ];
+  return lines.join("\n");
+}
+function resolveSkillInvocation(line) {
+  const trimmed = line.trim();
+  const m = trimmed.match(/^\/skill\s+(\S+)\s*([\s\S]*)$/i);
+  if (!m) return null;
+  const name = m[1];
+  const input = (m[2] || "").trim();
+  const loaded = loadSkill(name);
+  if (!loaded) return null;
+  const prompt = [
+    loaded.body,
+    "",
+    "Apply the skill above to this request:",
+    input || "Introduce what you can do with this skill."
+  ].join("\n");
+  return { prompt, skillName: loaded.skill.name };
 }
 
 // src/commands/chat.ts
 function help() {
   console.log(c.dim([
     "  commands:",
-    "    /brain [name]     switch brain (claude, codex, gemini). context is kept.",
+    "    /brain [name]     switch brain (CLI or API). context is kept.",
     "    /memory [query]   memory stats, or preview what a query would recall",
-    "    /setting          configure brains and your launch command",
+    '    /skill [name] [input]  run a skill, or list them. "holt skill" manages them.',
+    "    /output [fmt]     show or set output format: markdown | html",
+    "    /save [name]      save the last reply to a file in this folder",
+    "    /setting          configure brains, API brains, and your launch command",
     "    /clear            forget this session so far (saved memory stays)",
     "    /help             this list",
     "    /exit             leave"
   ].join("\n")));
 }
+function resolveActive(cfg, id) {
+  if (BRAIN_IDS.includes(id)) {
+    const b = cfg.brains[id];
+    return { kind: "cli", id, label: b.label };
+  }
+  const api = findApiBrain(cfg, id);
+  if (api) return { kind: "api", id, label: `${id} (api: ${api.provider}/${api.model})`, brain: api };
+  return null;
+}
 async function chat() {
   const { ask, close } = createReader();
   if (!await ensureTrusted(ask)) {
@@ -596,25 +1186,44 @@ async function chat() {
     console.log(c.dim('\nSetup done. Run "holt chat" to start talking.\n'));
     return;
   }
-  let current = cfg.defaultBrain;
+  let active = resolveActive(cfg, cfg.defaultBrain);
+  if (!active) {
+    const fallback = BRAIN_IDS.find((id) => cfg.brains[id].enabled) ?? cfg.apiBrains[0]?.id ?? null;
+    active = fallback ? resolveActive(cfg, fallback) : null;
+    if (!active) {
+      close();
+      console.log(c.dim('\nNo brain is ready. Run "holt setting".\n'));
+      return;
+    }
+  }
   const session = newSessionId();
   const history = [];
+  let lastReply = "";
   const embedOk = await embeddingsAvailable();
   const stats = memStats();
-  console.log("\n" + c.accent("Holt") + c.dim(`  brain: ${cfg.brains[current].label}`));
+  console.log("\n" + c.accent("Holt") + c.dim(`  brain: ${active.label}`));
   console.log(c.dim(
     `Memory: ${stats.turns} moments from ${stats.sessions} session${stats.sessions === 1 ? "" : "s"} in this folder (recall: ${embedOk ? "embeddings via local Ollama" : "keyword match"}).`
   ));
   if (embedOk && stats.withEmbeddings < stats.turns) {
     console.log(c.dim(`  ${stats.turns - stats.withEmbeddings} older moments lack embeddings. Run "holt memory embed" to upgrade them.`));
   }
-  console.log(c.dim("Type a message. Commands: /brain  /memory  /setting  /clear  /help  /exit\n"));
+  console.log(c.dim("Type a message. Commands: /brain  /memory  /output  /save  /setting  /clear  /help  /exit\n"));
   while (true) {
     const raw = await ask(c.accent("\u203A "));
     if (raw === null) break;
     const line = raw.trim();
     if (!line) continue;
-    if (line.startsWith("/")) {
+    let promptOverride = null;
+    if (/^\/skills?\s+\S/.test(line)) {
+      const inv = resolveSkillInvocation(line.replace(/^\/skills\b/, "/skill"));
+      if (!inv) {
+        console.log(c.dim('  no such skill. Try "holt skill list".'));
+        continue;
+      }
+      promptOverride = inv.prompt;
+      console.log(c.dim(`  running skill "${inv.skillName}"...`));
+    } else if (line.startsWith("/")) {
       const parts = line.slice(1).split(/\s+/);
       const cmd = (parts[0] || "").toLowerCase();
       const rest = parts.slice(1).join(" ");
@@ -641,46 +1250,100 @@ async function chat() {
         }
         continue;
       }
+      if (cmd === "output") {
+        const want = arg;
+        if (want === "markdown" || want === "md") {
+          cfg.outputFormat = "markdown";
+          saveConfig(cfg);
+          console.log(c.green("  output format: markdown"));
+        } else if (want === "html") {
+          cfg.outputFormat = "html";
+          saveConfig(cfg);
+          console.log(c.green("  output format: html"));
+        } else if (want) console.log(c.dim("  usage: /output markdown | html"));
+        else console.log(c.dim(`  output format: ${cfg.outputFormat}  (change with /output markdown | html)`));
+        continue;
+      }
+      if (cmd === "save") {
+        if (!lastReply) {
+          console.log(c.dim("  nothing to save yet. Ask something first."));
+          continue;
+        }
+        try {
+          const path = saveReply(lastReply, cfg.outputFormat, rest || void 0);
+          console.log(c.green(`  saved ${cfg.outputFormat} to ${path}`));
+        } catch (e) {
+          console.log(c.red(`  could not save: ${e.message}`));
+        }
+        continue;
+      }
       if (cmd === "setting" || cmd === "settings") {
         cfg = await runSettings(ask);
-        if (!cfg.brains[current].enabled && cfg.defaultBrain) current = cfg.defaultBrain;
-        console.log(c.dim(`  brain: ${cfg.brains[current].label}`));
+        const next = cfg.defaultBrain ? resolveActive(cfg, cfg.defaultBrain) : null;
+        const stillValid = resolveActive(cfg, active.id);
+        active = stillValid ?? next ?? active;
+        console.log(c.dim(`  brain: ${active.label}`));
         continue;
       }
       if (cmd === "brain") {
-        const enabled = BRAIN_IDS.filter((id) => cfg.brains[id].enabled);
-        if (arg && enabled.includes(arg)) {
-          current = arg;
-          const turns = Math.floor(history.length / 2);
-          console.log(c.green(`  switched to ${cfg.brains[current].label}. Context kept (${turns} turn${turns === 1 ? "" : "s"}).`));
+        const cliEnabled = BRAIN_IDS.filter((id) => cfg.brains[id].enabled);
+        const apiIds = cfg.apiBrains.map((a) => a.id);
+        const all = [...cliEnabled, ...apiIds];
+        if (arg && all.includes(arg)) {
+          const next = resolveActive(cfg, arg);
+          if (next) {
+            active = next;
+            const turns = Math.floor(history.length / 2);
+            console.log(c.green(`  switched to ${active.label}. Context kept (${turns} turn${turns === 1 ? "" : "s"}).`));
+          }
         } else if (arg) {
-          console.log(c.dim(`  "${arg}" is not available. Installed: ${enabled.join(", ") || "none"}`));
+          console.log(c.dim(`  "${arg}" is not available. Available: ${all.join(", ") || "none"}`));
         } else {
-          console.log(c.dim("  brains: " + enabled.map((id) => id === current ? c.accent(id + " (current)") : id).join("  ")));
+          const cfgRef = cfg;
+          const activeId = active.id;
+          const labels = all.map((id) => {
+            const a = findApiBrain(cfgRef, id);
+            const shown = a ? `${id} (api: ${a.provider}/${a.model})` : id;
+            return id === activeId ? c.accent(shown + " (current)") : shown;
+          });
+          console.log(c.dim("  brains: " + labels.join("   ")));
           console.log(c.dim("  usage: /brain <name>"));
         }
         continue;
       }
+      if (cmd === "skill" || cmd === "skills") {
+        const names = listSkills().map((s) => s.name);
+        console.log(c.dim("  skills: " + (names.join("  ") || "none") + "   usage: /skill <name> [input]"));
+        continue;
+      }
       console.log(c.dim(`  unknown command: /${cmd}  (try /help)`));
       continue;
     }
-    const brain = cfg.brains[current];
-    if (!isInstalled(brain.command)) {
-      console.log(c.red(`  ${brain.label} (${brain.command}) is not on your PATH. Use /brain to switch or /setting.`));
+    if (active.kind === "cli" && !isInstalled(cfg.brains[active.id].command)) {
+      console.log(c.red(`  ${active.label} (${cfg.brains[active.id].command}) is not on your PATH. Use /brain to switch or /setting.`));
+      continue;
+    }
+    if (active.kind === "api" && !resolveApiKey(active.brain)) {
+      console.log(c.red(`  ${active.label} has no API key. Use /setting to add one, or /brain to switch.`));
       continue;
     }
     const remembered = await recall(line, session, 4);
-    const label = remembered.length ? `${brain.label} is thinking (recalled ${remembered.length} moment${remembered.length === 1 ? "" : "s"})...` : `${brain.label} is thinking...`;
+    const label = remembered.length ? `${active.label} is thinking (recalled ${remembered.length} moment${remembered.length === 1 ? "" : "s"})...` : `${active.label} is thinking...`;
     console.log(c.dim(`  ${label}`) + "\n");
+    const skillsBlock = skillsPromptBlock();
+    const base = renderPrompt(history, line, remembered);
+    const prompt = promptOverride ?? (skillsBlock ? skillsBlock + "\n\n" + base : base);
     let streamed = false;
-    const res = await runBrain(brain, renderPrompt(history, line, remembered), (chunk) => {
+    const onChunk = (chunk) => {
       streamed = true;
       process.stdout.write(chunk);
-    });
+    };
+    const res = active.kind === "cli" ? await runBrain(cfg.brains[active.id], prompt, onChunk) : await runApiBrain(active.brain, prompt, onChunk);
     if (res.ok) {
       if (!streamed) console.log(res.text);
       if (!res.text.endsWith("\n")) console.log("");
       console.log("");
+      lastReply = res.text;
       history.push({ role: "user", content: line });
       history.push({ role: "assistant", content: res.text });
       const now = Date.now();
@@ -793,8 +1456,959 @@ async function memoryCmd(sub, rest = []) {
   close();
 }
 
+// src/commands/skill.ts
+import {
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync6,
+  readFileSync as readFileSync6,
+  existsSync as existsSync6,
+  readdirSync as readdirSync2,
+  statSync as statSync3,
+  rmSync as rmSync2,
+  cpSync,
+  mkdtempSync
+} from "fs";
+import { join as join7, resolve } from "path";
+import { tmpdir } from "os";
+import { spawnSync as spawnSync2 } from "child_process";
+function usage() {
+  console.log(c.dim([
+    "",
+    "  " + c.accent("holt skill") + c.dim(" - manage SKILL.md skills"),
+    "",
+    "  holt skill list                     list installed skills",
+    "  holt skill show <name>              print a skill",
+    "  holt skill create <name> [--global] scaffold a new skill",
+    "  holt skill add <source> [--global]  install from a git URL or local path",
+    "  holt skill remove <name>            delete a skill",
+    "",
+    "  --global installs into ~/.holt/skills (available in every folder).",
+    "  Without it, skills live in this folder at ./.holt/skills.",
+    ""
+  ].join("\n")));
+}
+var SKILL_TEMPLATE = (name) => [
+  "---",
+  `name: ${name}`,
+  "description: One sentence on what this skill does and when to use it.",
+  "---",
+  "",
+  `# ${name}`,
+  "",
+  "## When to use",
+  "",
+  "Describe the situations where this skill applies.",
+  "",
+  "## Instructions",
+  "",
+  "1. Step one.",
+  "2. Step two.",
+  "3. Step three.",
+  "",
+  "## Example",
+  "",
+  "Show a short example of the skill in action.",
+  ""
+].join("\n");
+function isGitUrl(s) {
+  return s.includes("://") || s.endsWith(".git") || s.startsWith("git@");
+}
+function findSkillDir(root) {
+  if (existsSync6(join7(root, "SKILL.md"))) return root;
+  let subs = [];
+  try {
+    subs = readdirSync2(root).filter((f) => {
+      try {
+        return statSync3(join7(root, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return null;
+  }
+  const withSkill = subs.filter((f) => existsSync6(join7(root, f, "SKILL.md")));
+  if (withSkill.length === 1) return join7(root, withSkill[0]);
+  return null;
+}
+function cmdList() {
+  const skills = listSkills();
+  if (skills.length === 0) {
+    console.log(c.dim('\n  No skills yet. Create one with "holt skill create <name>".\n'));
+    return;
+  }
+  const nameW = Math.max(4, ...skills.map((s) => s.name.length));
+  const scopeW = Math.max(5, ...skills.map((s) => s.scope.length));
+  console.log("\n" + c.accent("Skills") + c.dim("  (workspace shadows global on name clash)"));
+  console.log(
+    "  " + c.dim("name".padEnd(nameW)) + "  " + c.dim("scope".padEnd(scopeW)) + "  " + c.dim("description")
+  );
+  for (const s of skills) {
+    const desc = s.description.length > 68 ? s.description.slice(0, 67) + "\u2026" : s.description;
+    console.log(
+      "  " + c.bold(s.name.padEnd(nameW)) + "  " + (s.scope === "workspace" ? c.cyan(s.scope.padEnd(scopeW)) : c.dim(s.scope.padEnd(scopeW))) + "  " + (desc || c.dim("(no description)"))
+    );
+  }
+  console.log(c.dim("\n  holt skill show <name>   print a skill"));
+  console.log(c.dim("  In chat: /skill <name> [input]   run a skill\n"));
+}
+function cmdShow(name) {
+  if (!name) {
+    console.log(c.dim("\n  Usage: holt skill show <name>\n"));
+    return;
+  }
+  const loaded = loadSkill(name);
+  if (!loaded) {
+    console.log(c.dim(`
+  No skill named "${sanitizeName(name)}". Try "holt skill list".
+`));
+    return;
+  }
+  const { skill, body } = loaded;
+  console.log("\n" + c.accent(skill.name) + c.dim(`  (${skill.scope})`));
+  if (skill.description) console.log("  " + skill.description);
+  console.log(c.dim("  " + join7(skill.dir, "SKILL.md")));
+  console.log("");
+  console.log(c.dim(body));
+  console.log("");
+}
+function cmdCreate(name, global) {
+  const clean = sanitizeName(name || "");
+  if (!clean) {
+    console.log(c.dim("\n  Usage: holt skill create <name> [--global]\n"));
+    return;
+  }
+  const scope = global ? "global" : "workspace";
+  const dir = join7(skillsRoot(scope), clean);
+  if (existsSync6(dir)) {
+    console.log(c.red(`
+  A ${scope} skill named "${clean}" already exists.`));
+    console.log(c.dim("  " + dir + "\n"));
+    return;
+  }
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync6(join7(dir, "SKILL.md"), SKILL_TEMPLATE(clean), "utf8");
+  console.log(c.green(`
+  Created ${scope} skill "${clean}".`));
+  console.log(c.dim("  " + join7(dir, "SKILL.md")));
+  console.log(c.dim('  Edit it, then run it in chat with "/skill ' + clean + '".\n'));
+}
+function cmdAdd(source, global) {
+  if (!source) {
+    console.log(c.dim("\n  Usage: holt skill add <git-url|path> [--global]\n"));
+    return;
+  }
+  const scope = global ? "global" : "workspace";
+  let fetched = "";
+  let tempDir = "";
+  try {
+    if (isGitUrl(source)) {
+      tempDir = mkdtempSync(join7(tmpdir(), "holt-skill-"));
+      console.log(c.dim(`
+  Cloning ${source} ...`));
+      const res = spawnSync2("git", ["clone", "--depth", "1", source, tempDir], { stdio: "ignore" });
+      if (res.status !== 0) {
+        console.log(c.red("  Clone failed. Check the URL and that git is installed.\n"));
+        return;
+      }
+      fetched = tempDir;
+    } else {
+      fetched = resolve(source);
+      if (!existsSync6(fetched)) {
+        console.log(c.red(`
+  No such path: ${fetched}
+`));
+        return;
+      }
+    }
+    const skillDir = findSkillDir(fetched);
+    if (!skillDir) {
+      console.log(c.red("\n  Could not find a SKILL.md at the source root or in a single subfolder.\n"));
+      return;
+    }
+    let skillName = "";
+    try {
+      const { data } = parseFrontmatter(readFileSync6(join7(skillDir, "SKILL.md"), "utf8"));
+      skillName = sanitizeName(data.name || "");
+    } catch {
+      skillName = "";
+    }
+    if (!skillName) skillName = sanitizeName(skillDir.split(/[\\/]/).pop() || "");
+    if (!skillName) {
+      console.log(c.red("\n  Could not determine a valid skill name.\n"));
+      return;
+    }
+    const dest = join7(skillsRoot(scope), skillName);
+    if (existsSync6(dest)) {
+      console.log(c.red(`
+  A ${scope} skill named "${skillName}" already exists.`));
+      console.log(c.dim("  " + dest + "\n"));
+      return;
+    }
+    mkdirSync4(skillsRoot(scope), { recursive: true });
+    cpSync(skillDir, dest, { recursive: true });
+    const nestedGit = join7(dest, ".git");
+    if (existsSync6(nestedGit)) rmSync2(nestedGit, { recursive: true, force: true });
+    console.log(c.green(`
+  Installed ${scope} skill "${skillName}".`));
+    console.log(c.dim("  " + join7(dest, "SKILL.md") + "\n"));
+  } finally {
+    if (tempDir && existsSync6(tempDir)) {
+      try {
+        rmSync2(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+async function cmdRemove(name, ask) {
+  const clean = sanitizeName(name || "");
+  if (!clean) {
+    console.log(c.dim("\n  Usage: holt skill remove <name>\n"));
+    return;
+  }
+  const wsDir = join7(skillsRoot("workspace"), clean);
+  const globalDir = join7(skillsRoot("global"), clean);
+  const target = existsSync6(wsDir) ? wsDir : existsSync6(globalDir) ? globalDir : "";
+  if (!target) {
+    console.log(c.dim(`
+  No skill named "${clean}" found.
+`));
+    return;
+  }
+  const scope = target === wsDir ? "workspace" : "global";
+  const a = (await ask(`
+  Delete ${scope} skill "${clean}"? [y/N] `) ?? "").trim().toLowerCase();
+  if (a === "y" || a === "yes") {
+    rmSync2(target, { recursive: true, force: true });
+    console.log(c.green("  Removed.\n"));
+  } else {
+    console.log(c.dim("  Kept.\n"));
+  }
+}
+async function skillCmd(sub, rest = []) {
+  const { ask, close } = createReader();
+  if (!await ensureTrusted(ask)) {
+    close();
+    return;
+  }
+  const global = rest.includes("--global");
+  const args = rest.filter((a) => a !== "--global");
+  const action = (sub || "").toLowerCase();
+  try {
+    switch (action) {
+      case "list":
+      case "ls":
+        cmdList();
+        break;
+      case "show":
+      case "view":
+        cmdShow(args[0]);
+        break;
+      case "create":
+      case "new":
+        cmdCreate(args[0], global);
+        break;
+      case "add":
+      case "install":
+        cmdAdd(args[0], global);
+        break;
+      case "remove":
+      case "rm":
+      case "delete":
+        await cmdRemove(args[0], ask);
+        break;
+      default:
+        usage();
+    }
+  } finally {
+    close();
+  }
+}
+
+// src/commands/graph.ts
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
+import { join as join8, dirname, resolve as resolve2 } from "path";
+import { spawn as spawn3 } from "child_process";
+
+// src/graphview.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "that",
+  "have",
+  "this",
+  "with",
+  "from",
+  "they",
+  "what",
+  "when",
+  "your",
+  "would",
+  "there",
+  "their",
+  "will",
+  "about",
+  "which",
+  "them",
+  "then",
+  "than",
+  "were",
+  "been",
+  "being",
+  "into",
+  "over",
+  "some",
+  "such",
+  "only",
+  "also",
+  "because",
+  "these",
+  "those",
+  "here",
+  "more",
+  "most",
+  "other",
+  "want",
+  "need",
+  "like",
+  "just",
+  "make",
+  "made",
+  "does",
+  "done",
+  "each",
+  "very",
+  "much",
+  "many",
+  "could",
+  "should",
+  "shall",
+  "must",
+  "might",
+  "even",
+  "still",
+  "while",
+  "where",
+  "good",
+  "know",
+  "take",
+  "them",
+  "thing",
+  "things",
+  "okay",
+  "yeah",
+  "sure",
+  "help",
+  "please",
+  "thanks",
+  "lets"
+]);
+function cosine2(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+}
+function firstLine(s, max = 60) {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > max ? flat.slice(0, max - 1).trimEnd() + "\u2026" : flat;
+}
+function words(s) {
+  return s.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 3 && !STOPWORDS.has(w) && !/^\d+$/.test(w));
+}
+var SEMANTIC_MIN = 0.55;
+var SEMANTIC_PAIR_CAP = 300;
+var SEMANTIC_TURN_CAP = 2e3;
+var CONCEPT_CAP = 40;
+var CONCEPT_MIN_TURNS = 2;
+function buildGraph(turns) {
+  const nodes = [];
+  const edges = [];
+  for (const t of turns) {
+    nodes.push({
+      id: t.id,
+      kind: "turn",
+      label: firstLine(t.content),
+      role: t.role,
+      session: t.session,
+      ts: t.ts,
+      content: t.content
+    });
+  }
+  const bySession = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    const arr = bySession.get(t.session);
+    if (arr) arr.push(t);
+    else bySession.set(t.session, [t]);
+  }
+  for (const arr of bySession.values()) {
+    for (let i = 1; i < arr.length; i++) {
+      const prev = arr[i - 1];
+      const cur = arr[i];
+      edges.push({ source: prev.id, target: cur.id, kind: "sequential", width: 1 });
+    }
+  }
+  if (turns.length <= SEMANTIC_TURN_CAP) {
+    const withEmb = turns.filter((t) => Array.isArray(t.emb) && t.emb.length > 0);
+    const pairs = [];
+    for (let i = 0; i < withEmb.length; i++) {
+      const a = withEmb[i];
+      for (let j = i + 1; j < withEmb.length; j++) {
+        const b = withEmb[j];
+        const sim = cosine2(a.emb, b.emb);
+        if (sim >= SEMANTIC_MIN) pairs.push({ source: a.id, target: b.id, sim });
+      }
+    }
+    pairs.sort((x, y) => y.sim - x.sim);
+    for (const p of pairs.slice(0, SEMANTIC_PAIR_CAP)) {
+      const width = 1.5 + (p.sim - SEMANTIC_MIN) / (1 - SEMANTIC_MIN) * 3.5;
+      edges.push({ source: p.source, target: p.target, kind: "semantic", width: Math.round(width * 100) / 100 });
+    }
+  }
+  const conceptTurns = /* @__PURE__ */ new Map();
+  for (const t of turns) {
+    for (const w of new Set(words(t.content))) {
+      const set = conceptTurns.get(w);
+      if (set) set.add(t.id);
+      else conceptTurns.set(w, /* @__PURE__ */ new Set([t.id]));
+    }
+  }
+  const concepts = [...conceptTurns.entries()].filter(([, ids]) => ids.size >= CONCEPT_MIN_TURNS).sort((a, b) => b[1].size - a[1].size || a[0].localeCompare(b[0])).slice(0, CONCEPT_CAP);
+  for (const [word, ids] of concepts) {
+    const cid = "concept:" + word;
+    nodes.push({ id: cid, kind: "concept", label: word, freq: ids.size });
+    for (const turnId of ids) {
+      edges.push({ source: cid, target: turnId, kind: "concept", width: 1 });
+    }
+  }
+  return { nodes, edges };
+}
+function escapeForScript(json) {
+  return json.replace(/<\/(script)/gi, "<\\/$1").replace(/<!--/g, "<\\!--");
+}
+function escapeHtml2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderGraphHtml(graph2, meta) {
+  const dataJson = escapeForScript(JSON.stringify(graph2));
+  const wsSafe = escapeHtml2(meta.workspace);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Holt memory graph</title>
+<style>
+  :root {
+    --bg: #0f1115;
+    --panel: #171a21;
+    --text: #e7e9ee;
+    --muted: #9aa3b2;
+    --amber: #f0b91e;
+    --cyan: #35d0d6;
+    --violet: #9a8cff;
+    --line: #232733;
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; height: 100%; }
+  body {
+    background: var(--bg); color: var(--text); overflow: hidden;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    -webkit-font-smoothing: antialiased;
+  }
+  header {
+    position: fixed; top: 0; left: 0; right: 0; z-index: 5;
+    display: flex; align-items: center; gap: 16px;
+    padding: 10px 16px; background: rgba(15,17,21,0.82);
+    border-bottom: 1px solid var(--line); backdrop-filter: blur(6px);
+  }
+  .wordmark { color: var(--amber); font-weight: 700; font-size: 18px; letter-spacing: 1px; }
+  .ws { color: var(--muted); font-size: 12px; max-width: 34vw; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .stats { color: var(--muted); font-size: 12px; margin-left: auto; }
+  .stats b { color: var(--text); font-weight: 600; }
+  #search {
+    background: var(--panel); border: 1px solid var(--line); color: var(--text);
+    border-radius: 6px; padding: 6px 10px; font: inherit; font-size: 13px; width: 220px;
+  }
+  #search:focus { outline: none; border-color: var(--amber); }
+  #stage { position: fixed; inset: 0; display: block; }
+  #tooltip {
+    position: fixed; z-index: 8; pointer-events: none; display: none;
+    background: var(--panel); border: 1px solid var(--line); border-radius: 6px;
+    padding: 6px 9px; font-size: 12px; max-width: 320px; color: var(--text);
+    box-shadow: 0 6px 20px rgba(0,0,0,0.5);
+  }
+  #tooltip .t-meta { color: var(--muted); font-size: 11px; margin-top: 3px; }
+  #panel {
+    position: fixed; top: 0; right: 0; bottom: 0; z-index: 7; width: 380px; max-width: 92vw;
+    background: var(--panel); border-left: 1px solid var(--line);
+    transform: translateX(100%); transition: transform 160ms ease;
+    display: flex; flex-direction: column; padding: 18px; overflow-y: auto;
+  }
+  #panel.open { transform: translateX(0); }
+  #panel .p-close { position: absolute; top: 12px; right: 14px; cursor: pointer; color: var(--muted); font-size: 18px; border: none; background: none; }
+  #panel .p-close:hover { color: var(--text); }
+  .chip { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: var(--muted); margin-bottom: 4px; }
+  .chip .dot { width: 10px; height: 10px; border-radius: 50%; display: inline-block; }
+  #p-role { font-size: 13px; color: var(--amber); text-transform: uppercase; letter-spacing: 1px; margin: 2px 0 10px; }
+  #p-content { white-space: pre-wrap; word-break: break-word; line-height: 1.5; font-size: 13px; color: var(--text); }
+  #p-time { color: var(--muted); font-size: 12px; margin-top: 14px; }
+  #legend {
+    position: fixed; left: 12px; bottom: 12px; z-index: 6;
+    background: rgba(23,26,33,0.85); border: 1px solid var(--line); border-radius: 8px;
+    padding: 10px 12px; font-size: 12px; color: var(--muted);
+  }
+  #legend .row { display: flex; align-items: center; gap: 8px; margin: 3px 0; }
+  #legend .swatch { width: 11px; height: 11px; border-radius: 50%; }
+  #hint { position: fixed; right: 12px; bottom: 12px; z-index: 6; color: var(--muted); font-size: 11px; opacity: 0.7; }
+  #empty { position: fixed; inset: 0; display: none; align-items: center; justify-content: center; color: var(--muted); }
+</style>
+</head>
+<body>
+<header>
+  <span class="wordmark">Holt</span>
+  <span class="ws" title="${wsSafe}">${wsSafe}</span>
+  <input id="search" type="search" placeholder="search memory..." autocomplete="off" spellcheck="false" />
+  <span class="stats"><b>${meta.turns}</b> turns &middot; <b>${meta.sessions}</b> sessions &middot; <b>${meta.concepts}</b> concepts &middot; <b>${meta.edges}</b> edges</span>
+</header>
+
+<canvas id="stage"></canvas>
+
+<div id="tooltip"></div>
+
+<aside id="panel">
+  <button class="p-close" id="p-close" aria-label="close">&times;</button>
+  <div class="chip"><span class="dot" id="p-dot"></span><span id="p-session"></span></div>
+  <div id="p-role"></div>
+  <div id="p-content"></div>
+  <div id="p-time"></div>
+</aside>
+
+<div id="legend">
+  <div class="row"><span class="swatch" style="background:var(--amber)"></span>you</div>
+  <div class="row"><span class="swatch" style="background:var(--cyan)"></span>assistant</div>
+  <div class="row"><span class="swatch" style="background:var(--violet)"></span>concept</div>
+  <div class="row"><span class="swatch" style="background:var(--line);border:1px solid var(--muted)"></span>ring = session</div>
+</div>
+<div id="hint">drag to pan &middot; wheel to zoom &middot; click a node &middot; Esc to clear</div>
+<div id="empty">This graph has no nodes yet.</div>
+
+<script id="graph-data" type="application/json">${dataJson}</script>
+<script>
+(function () {
+  "use strict";
+  var DATA = JSON.parse(document.getElementById("graph-data").textContent);
+  var nodes = DATA.nodes || [];
+  var edges = DATA.edges || [];
+
+  var canvas = document.getElementById("stage");
+  var ctx = canvas.getContext("2d");
+  var tooltip = document.getElementById("tooltip");
+  var panel = document.getElementById("panel");
+  var searchBox = document.getElementById("search");
+  var reduceMotion = window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+  if (!nodes.length) { document.getElementById("empty").style.display = "flex"; return; }
+
+  // ---- color per session (distinct hues) ----
+  var sessionList = [];
+  nodes.forEach(function (n) { if (n.session && sessionList.indexOf(n.session) < 0) sessionList.push(n.session); });
+  function sessionHue(session) {
+    var i = sessionList.indexOf(session);
+    if (i < 0) i = 0;
+    return (i * 137.508) % 360; // golden-angle spread
+  }
+
+  // ---- index + degree ----
+  var byId = {};
+  nodes.forEach(function (n) { byId[n.id] = n; n._deg = 0; });
+  var links = [];
+  edges.forEach(function (e) {
+    var s = byId[e.source], t = byId[e.target];
+    if (!s || !t) return;
+    s._deg++; t._deg++;
+    links.push({ s: s, t: t, kind: e.kind, width: e.width });
+  });
+
+  function radiusOf(n) {
+    var base = n.kind === "concept" ? 3 : 5;
+    return base + Math.min(9, Math.sqrt(n._deg) * 1.6);
+  }
+
+  // ---- initial layout: spread on a spiral so physics has somewhere to start ----
+  nodes.forEach(function (n, i) {
+    var ang = i * 2.399963;
+    var rad = 22 * Math.sqrt(i);
+    n.x = Math.cos(ang) * rad;
+    n.y = Math.sin(ang) * rad;
+    n.vx = 0; n.vy = 0;
+  });
+
+  // ---- physics ----
+  var REPULSION = 5200, SPRING = 0.02, GRAVITY = 0.015, DAMP = 0.86;
+  var restLen = { sequential: 60, semantic: 45, concept: 70 };
+
+  function step() {
+    var i, j, n, m, dx, dy, d2, d, f;
+    // repulsion (all pairs; fine for the sizes Holt produces)
+    for (i = 0; i < nodes.length; i++) {
+      n = nodes[i];
+      for (j = i + 1; j < nodes.length; j++) {
+        m = nodes[j];
+        dx = n.x - m.x; dy = n.y - m.y;
+        d2 = dx * dx + dy * dy || 0.01;
+        if (d2 > 90000) continue; // ignore far-apart pairs
+        d = Math.sqrt(d2);
+        f = REPULSION / d2;
+        var ux = dx / d, uy = dy / d;
+        n.vx += ux * f; n.vy += uy * f;
+        m.vx -= ux * f; m.vy -= uy * f;
+      }
+    }
+    // springs
+    for (i = 0; i < links.length; i++) {
+      var lk = links[i];
+      dx = lk.t.x - lk.s.x; dy = lk.t.y - lk.s.y;
+      d = Math.sqrt(dx * dx + dy * dy) || 0.01;
+      var rest = restLen[lk.kind] || 60;
+      f = (d - rest) * SPRING;
+      var ax = (dx / d) * f, ay = (dy / d) * f;
+      lk.s.vx += ax; lk.s.vy += ay;
+      lk.t.vx -= ax; lk.t.vy -= ay;
+    }
+    // gravity to center + integrate
+    var moved = 0;
+    for (i = 0; i < nodes.length; i++) {
+      n = nodes[i];
+      n.vx -= n.x * GRAVITY; n.vy -= n.y * GRAVITY;
+      n.vx *= DAMP; n.vy *= DAMP;
+      if (n === dragNode) continue;
+      n.x += n.vx; n.y += n.vy;
+      moved += Math.abs(n.vx) + Math.abs(n.vy);
+    }
+    return moved / nodes.length;
+  }
+
+  // ---- view transform ----
+  var view = { x: 0, y: 0, scale: 1 };
+  var W = 0, H = 0, dpr = Math.max(1, window.devicePixelRatio || 1);
+  function resize() {
+    W = window.innerWidth; H = window.innerHeight;
+    canvas.width = Math.floor(W * dpr); canvas.height = Math.floor(H * dpr);
+    canvas.style.width = W + "px"; canvas.style.height = H + "px";
+  }
+  window.addEventListener("resize", resize);
+  resize();
+  view.x = W / 2; view.y = H / 2;
+
+  function worldToScreen(x, y) { return { x: x * view.scale + view.x, y: y * view.scale + view.y }; }
+  function screenToWorld(x, y) { return { x: (x - view.x) / view.scale, y: (y - view.y) / view.scale }; }
+
+  // ---- selection + search state ----
+  var selected = null;         // a node id
+  var highlightSet = null;     // Set of ids to emphasise (search or concept click)
+  var query = "";
+
+  function roleColor(n) {
+    if (n.kind === "concept") return "#9a8cff";
+    return n.role === "user" ? "#f0b91e" : "#35d0d6";
+  }
+
+  function matchesQuery(n) {
+    if (!query) return false;
+    var hay = (n.label || "") + " " + (n.content || "");
+    return hay.toLowerCase().indexOf(query) >= 0;
+  }
+
+  function draw() {
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.clearRect(0, 0, W, H);
+
+    // edges
+    for (var i = 0; i < links.length; i++) {
+      var lk = links[i];
+      var a = worldToScreen(lk.s.x, lk.s.y), b = worldToScreen(lk.t.x, lk.t.y);
+      var dim = 0.16;
+      if (highlightSet) {
+        if (highlightSet.has(lk.s.id) || highlightSet.has(lk.t.id)) dim = 0.55; else dim = 0.05;
+      } else {
+        dim = lk.kind === "semantic" ? 0.4 : lk.kind === "concept" ? 0.14 : 0.22;
+      }
+      ctx.globalAlpha = dim;
+      ctx.lineWidth = Math.max(0.4, lk.width * view.scale * 0.5);
+      ctx.strokeStyle = lk.kind === "semantic" ? "#35d0d6" : lk.kind === "concept" ? "#9a8cff" : "#4a5262";
+      ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y); ctx.stroke();
+    }
+    ctx.globalAlpha = 1;
+
+    // nodes
+    for (var k = 0; k < nodes.length; k++) {
+      var n = nodes[k];
+      var p = worldToScreen(n.x, n.y);
+      var r = radiusOf(n) * view.scale;
+      var isHot = (highlightSet && highlightSet.has(n.id)) || (query && matchesQuery(n));
+      var faded = (highlightSet && !highlightSet.has(n.id)) || (query && !matchesQuery(n));
+      ctx.globalAlpha = faded ? 0.18 : 1;
+
+      // session ring
+      if (n.kind === "turn") {
+        ctx.beginPath();
+        ctx.arc(p.x, p.y, r + 2.4, 0, Math.PI * 2);
+        ctx.strokeStyle = "hsl(" + sessionHue(n.session) + ",70%,58%)";
+        ctx.lineWidth = 1.6; ctx.stroke();
+      }
+
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, r, 0, Math.PI * 2);
+      ctx.fillStyle = roleColor(n);
+      ctx.fill();
+
+      if (n.id === selected || isHot) {
+        ctx.lineWidth = 2; ctx.strokeStyle = "#ffffff"; ctx.stroke();
+      }
+
+      // concept labels always; turn labels when zoomed in
+      if (n.kind === "concept" || view.scale > 1.4) {
+        ctx.globalAlpha = faded ? 0.25 : 0.9;
+        ctx.fillStyle = "#e7e9ee";
+        ctx.font = (n.kind === "concept" ? 11 : 10) + "px ui-monospace, monospace";
+        ctx.fillText(n.label, p.x + r + 4, p.y + 3);
+      }
+    }
+    ctx.globalAlpha = 1;
+  }
+
+  // ---- animation loop with auto-settle ----
+  var settleTicks = 0, running = true;
+  function frame() {
+    var m = step();
+    draw();
+    if (m < 0.05) { settleTicks++; } else { settleTicks = 0; }
+    if (settleTicks > 30 && !dragNode) { running = false; return; } // rest
+    requestAnimationFrame(frame);
+  }
+  function kick() { if (!running) { running = true; settleTicks = 0; requestAnimationFrame(frame); } }
+
+  if (reduceMotion) {
+    for (var s = 0; s < 400; s++) step(); // settle off-screen
+    draw();
+  } else {
+    requestAnimationFrame(frame);
+  }
+
+  // ---- hit testing ----
+  function nodeAt(sx, sy) {
+    for (var i = nodes.length - 1; i >= 0; i--) {
+      var n = nodes[i];
+      var p = worldToScreen(n.x, n.y);
+      var r = radiusOf(n) * view.scale + 3;
+      var dx = sx - p.x, dy = sy - p.y;
+      if (dx * dx + dy * dy <= r * r) return n;
+    }
+    return null;
+  }
+
+  // ---- pointer: pan, drag node, hover ----
+  var dragNode = null, panning = false, last = { x: 0, y: 0 }, downAt = null, moved = false;
+
+  canvas.addEventListener("mousedown", function (e) {
+    var n = nodeAt(e.clientX, e.clientY);
+    downAt = { x: e.clientX, y: e.clientY }; moved = false;
+    if (n) { dragNode = n; } else { panning = true; }
+    last = { x: e.clientX, y: e.clientY };
+    kick();
+  });
+  window.addEventListener("mousemove", function (e) {
+    if (Math.abs(e.clientX - (downAt ? downAt.x : e.clientX)) + Math.abs(e.clientY - (downAt ? downAt.y : e.clientY)) > 3) moved = true;
+    if (dragNode) {
+      var w = screenToWorld(e.clientX, e.clientY);
+      dragNode.x = w.x; dragNode.y = w.y; dragNode.vx = 0; dragNode.vy = 0;
+      kick();
+    } else if (panning) {
+      view.x += e.clientX - last.x; view.y += e.clientY - last.y;
+      last = { x: e.clientX, y: e.clientY };
+      if (!running) draw();
+    } else {
+      var hov = nodeAt(e.clientX, e.clientY);
+      if (hov) {
+        canvas.style.cursor = "pointer";
+        var when = hov.ts ? new Date(hov.ts).toISOString().slice(0, 10) : "";
+        var meta = hov.kind === "concept"
+          ? ("concept &middot; in " + (hov.freq || 0) + " turns")
+          : (esc(hov.session || "") + (when ? " &middot; " + when : ""));
+        tooltip.innerHTML = "<div>" + esc(hov.label) + "</div><div class='t-meta'>" + meta + "</div>";
+        tooltip.style.display = "block";
+        tooltip.style.left = (e.clientX + 14) + "px";
+        tooltip.style.top = (e.clientY + 14) + "px";
+      } else {
+        canvas.style.cursor = "default";
+        tooltip.style.display = "none";
+      }
+    }
+  });
+  window.addEventListener("mouseup", function (e) {
+    if (!moved) {
+      var n = nodeAt(e.clientX, e.clientY);
+      if (n) onNodeClick(n); else clearSelection();
+    }
+    dragNode = null; panning = false; downAt = null;
+    if (!running) draw();
+  });
+
+  // ---- wheel zoom, cursor-anchored ----
+  canvas.addEventListener("wheel", function (e) {
+    e.preventDefault();
+    var before = screenToWorld(e.clientX, e.clientY);
+    var factor = Math.exp(-e.deltaY * 0.0015);
+    view.scale = Math.max(0.15, Math.min(6, view.scale * factor));
+    var after = screenToWorld(e.clientX, e.clientY);
+    view.x += (after.x - before.x) * view.scale;
+    view.y += (after.y - before.y) * view.scale;
+    if (!running) draw();
+  }, { passive: false });
+
+  // ---- clicks ----
+  function neighbors(id) {
+    var set = new Set([id]);
+    for (var i = 0; i < links.length; i++) {
+      if (links[i].s.id === id) set.add(links[i].t.id);
+      if (links[i].t.id === id) set.add(links[i].s.id);
+    }
+    return set;
+  }
+  function onNodeClick(n) {
+    selected = n.id;
+    if (n.kind === "concept") {
+      highlightSet = neighbors(n.id); // light up its connected turns
+      closePanel();
+    } else {
+      highlightSet = null;
+      openPanel(n);
+    }
+    if (!running) draw();
+  }
+  function clearSelection() {
+    selected = null; highlightSet = null; closePanel();
+    if (!running) draw();
+  }
+
+  // ---- side panel ----
+  function openPanel(n) {
+    document.getElementById("p-session").textContent = n.session || "";
+    document.getElementById("p-dot").style.background = "hsl(" + sessionHue(n.session) + ",70%,58%)";
+    document.getElementById("p-role").textContent = n.role || "";
+    document.getElementById("p-role").style.color = roleColor(n);
+    document.getElementById("p-content").textContent = n.content || n.label || "";
+    document.getElementById("p-time").textContent = n.ts ? new Date(n.ts).toLocaleString() : "";
+    panel.classList.add("open");
+  }
+  function closePanel() { panel.classList.remove("open"); }
+  document.getElementById("p-close").addEventListener("click", clearSelection);
+
+  // ---- search ----
+  searchBox.addEventListener("input", function () {
+    query = searchBox.value.trim().toLowerCase();
+    if (!running) draw();
+  });
+
+  // ---- keyboard ----
+  window.addEventListener("keydown", function (e) {
+    if (e.key === "Escape") {
+      searchBox.value = ""; query = "";
+      clearSelection();
+      searchBox.blur();
+    }
+  });
+
+  function esc(s) { return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
+})();
+</script>
+</body>
+</html>
+`;
+}
+
+// src/commands/graph.ts
+function parseArgs(args) {
+  const opts = { open: true };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--no-open") opts.open = false;
+    else if (a === "--out") opts.out = args[++i];
+    else if (a && a.startsWith("--out=")) opts.out = a.slice("--out=".length);
+  }
+  return opts;
+}
+function openInBrowser(path) {
+  try {
+    let cmd;
+    let cmdArgs;
+    if (process.platform === "darwin") {
+      cmd = "open";
+      cmdArgs = [path];
+    } else if (process.platform === "win32") {
+      cmd = "cmd";
+      cmdArgs = ["/c", "start", "", path];
+    } else {
+      cmd = "xdg-open";
+      cmdArgs = [path];
+    }
+    const child = spawn3(cmd, cmdArgs, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function graph(args = []) {
+  const { ask, close } = createReader();
+  if (!await ensureTrusted(ask)) {
+    close();
+    return;
+  }
+  close();
+  const opts = parseArgs(args);
+  const turns = loadTurns();
+  if (turns.length === 0) {
+    console.log(c.dim('\n  No memory in this folder yet. Have a chat first with "holt chat", then come back.\n'));
+    return;
+  }
+  const g = buildGraph(turns);
+  const conceptCount = g.nodes.filter((n) => n.kind === "concept").length;
+  const sessions = new Set(turns.map((t) => t.session)).size;
+  const html = renderGraphHtml(g, {
+    workspace: workspace(),
+    turns: turns.length,
+    sessions,
+    concepts: conceptCount,
+    edges: g.edges.length
+  });
+  const outPath = opts.out ? resolve2(opts.out) : join8(wsHoltDir(), "graph.html");
+  mkdirSync5(dirname(outPath), { recursive: true });
+  writeFileSync7(outPath, html, "utf8");
+  console.log("\n" + c.accent("Memory graph built") + c.dim("  (this folder)"));
+  console.log(`  nodes    ${g.nodes.length}  (${turns.length} turns, ${conceptCount} concepts)`);
+  console.log(`  edges    ${g.edges.length}`);
+  console.log(`  file     ${outPath}`);
+  if (opts.open) {
+    openInBrowser(outPath);
+    console.log(c.dim("\n  Opening in your browser...\n"));
+  } else {
+    console.log(c.dim("\n  Open it in any browser to explore.\n"));
+  }
+}
+
 // src/cli.ts
-var VERSION = "0.4.0";
+var VERSION = "0.5.1";
 var BANNER = `
   \u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
@@ -810,14 +2424,17 @@ Usage: holt <command>
 Commands:
   init            Trust this folder, choose and install brains, sign in, set defaults
   chat            Start a session. It remembers past sessions in this folder
-  memory          Inspect memory: holt memory [search <query> | clear]
-  setting         Configure brains and your launch command (per folder)
+  memory          Inspect memory: holt memory [search <query> | embed | clear]
+  graph           See your memory as an interactive knowledge graph in the browser
+  skill           Manage skills: holt skill [list | show | create | add | remove]
+  setting         Configure brains, API brains, and your launch command (per folder)
   login <brain>   Sign in to a brain: claude, codex, or gemini
   version         Print the Holt version
   help            Show this help
 
 Holt runs in the folder you launch it from and asks to trust it first.
-Brains are the agent CLIs on your machine: claude (Claude Code), codex, gemini.
+Brains are agent CLIs on your machine (claude, codex, gemini) or direct
+API connections you add in settings.
 
 Docs: https://productsdecoded.com/holt
 Repo: https://github.com/holt-os/holt
@@ -852,6 +2469,13 @@ async function main() {
     case "memory":
       await memoryCmd(process.argv[3], process.argv.slice(4));
       break;
+    case "skill":
+    case "skills":
+      await skillCmd(process.argv[3], process.argv.slice(4));
+      break;
+    case "graph":
+      await graph(process.argv.slice(3));
+      break;
     default:
       console.log(`
   Unknown command: "${cmd}"`);