@holt-os/holt 0.14.2 → 0.15.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync } from "fs";
 import { join as join2 } from "path";
 
 // src/workspace.ts
@@ -11,6 +11,13 @@ import { mkdirSync, readFileSync, writeFileSync } from "fs";
 
 // src/ui.ts
 import readline from "readline";
+var quiet = false;
+function setQuietMode(q) {
+  quiet = q;
+}
+function isQuietMode() {
+  return quiet;
+}
 var on = process.stdout.isTTY && !process.env.NO_COLOR;
 var wrap = (code) => (s) => on ? `\x1B[${code}m${s}\x1B[0m` : s;
 var c = {
@@ -162,10 +169,24 @@ function ensureWsDir() {
 }
 
 // src/config.ts
+var PROVIDER_WIRE = {
+  anthropic: "anthropic",
+  openai: "openai",
+  gemini: "gemini",
+  kimi: "openai",
+  grok: "openai"
+};
+var PROVIDER_BASE_URL = {
+  openai: "https://api.openai.com/v1",
+  kimi: "https://api.moonshot.ai/v1",
+  grok: "https://api.x.ai/v1"
+};
 var WIKI_DEFAULT_LOCAL_MODEL = "qwen2.5:7b";
 var BRAIN_DEFS = {
   claude: { label: "Claude Code", command: "claude", args: ["-p"] },
-  codex: { label: "Codex (OpenAI)", command: "codex", args: ["exec"] },
+  // --skip-git-repo-check: codex exec otherwise refuses to run in folders that
+  // are not git repositories, which is nearly every non-developer folder.
+  codex: { label: "Codex (OpenAI)", command: "codex", args: ["exec", "--skip-git-repo-check"] },
   gemini: { label: "Gemini CLI", command: "gemini", args: ["-p"] }
 };
 var BRAIN_SETUP = {
@@ -174,16 +195,20 @@ 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 PROVIDERS = ["anthropic", "openai", "gemini", "kimi", "grok"];
 var PROVIDER_MODEL_SUGGESTION = {
   anthropic: "claude-sonnet-4-6",
   openai: "gpt-5",
-  gemini: "gemini-2.5-flash"
+  gemini: "gemini-2.5-flash",
+  kimi: "kimi-k2-turbo-preview",
+  grok: "grok-4"
 };
 var PROVIDER_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
-  gemini: "GEMINI_API_KEY"
+  gemini: "GEMINI_API_KEY",
+  kimi: "MOONSHOT_API_KEY",
+  grok: "XAI_API_KEY"
 };
 function defaultConfig() {
   const brains = {};
@@ -201,14 +226,25 @@ function defaultConfig() {
     wiki: { maintainer: "brain", localModel: WIKI_DEFAULT_LOCAL_MODEL }
   };
 }
+var lastConfigRepair = null;
 function loadConfig() {
   const path = wsConfigPath();
   if (!existsSync2(path)) return null;
+  let raw;
   try {
-    const cfg = JSON.parse(readFileSync2(path, "utf8"));
+    raw = readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const cfg = JSON.parse(raw);
     const base = defaultConfig();
     const brains = cfg.brains ?? {};
     for (const id of BRAIN_IDS) if (!brains[id]) brains[id] = base.brains[id];
+    const cx = brains.codex;
+    if (cx && cx.command === "codex" && Array.isArray(cx.args) && !cx.args.includes("--skip-git-repo-check")) {
+      cx.args = [...cx.args, "--skip-git-repo-check"];
+    }
     const wikiIn = cfg.wiki ?? {};
     const wiki = {
       maintainer: wikiIn.maintainer === "local" ? "local" : "brain",
@@ -227,6 +263,18 @@ function loadConfig() {
       wiki
     };
   } catch {
+    const backup2 = `${path}.broken-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:T]/g, "")}`;
+    try {
+      renameSync(path, backup2);
+      lastConfigRepair = backup2;
+      if (!isQuietMode()) {
+        console.error(
+          c.red("\n  Your Holt settings file was damaged, so it was moved aside.") + c.dim(`
+  Saved at: ${backup2}`) + c.dim("\n  Holt will set this folder up fresh; your memory is untouched.\n")
+        );
+      }
+    } catch {
+    }
     return null;
   }
 }
@@ -310,7 +358,7 @@ function renderPrompt(history, message, memory = []) {
 function looksLikeAuthError(text) {
   try {
     if (!text) return false;
-    const re = /run\s+\/login|not\s+logged\s+in|invalid\s+api\s+key|please\s+(?:log|sign)\s+in|authentication\s+(?:failed|required)|unauthorized|session\s+(?:has\s+)?expired|no\s+api\s+key|login\s+required|credit\s+balance\s+is\s+too\s+low/i;
+    const re = /run\s+\/login|not\s+logged\s+in|invalid\s+api\s+key|please\s+(?:log|sign)\s+in|authentication\s+(?:failed|required)|unauthorized|session\s+(?:has\s+)?expired|no\s+api\s+key|login\s+required|credit\s+balance\s+is\s+too\s+low|set\s+an\s+auth\s+method|GEMINI_API_KEY/i;
     return re.test(text);
   } catch {
     return false;
@@ -967,7 +1015,8 @@ function dataLines(event) {
   }
   return out;
 }
-function extractDelta(provider, json) {
+function extractDelta(providerIn, json) {
+  const provider = PROVIDER_WIRE[providerIn];
   const j = json;
   if (provider === "anthropic") {
     if (j["type"] === "content_block_delta") {
@@ -987,7 +1036,8 @@ function extractDelta(provider, json) {
   return parts.map((p) => typeof p.text === "string" ? p.text : "").join("");
 }
 function buildRequest(brain, key, prompt) {
-  if (brain.provider === "anthropic") {
+  const wire = PROVIDER_WIRE[brain.provider];
+  if (wire === "anthropic") {
     return {
       url: "https://api.anthropic.com/v1/messages",
       headers: {
@@ -1003,9 +1053,10 @@ function buildRequest(brain, key, prompt) {
       })
     };
   }
-  if (brain.provider === "openai") {
+  if (wire === "openai") {
+    const base = (brain.baseUrl ?? PROVIDER_BASE_URL[brain.provider] ?? "https://api.openai.com/v1").replace(/\/$/, "");
     return {
-      url: "https://api.openai.com/v1/chat/completions",
+      url: `${base}/chat/completions`,
       headers: {
         "content-type": "application/json",
         authorization: `Bearer ${key}`
@@ -2220,9 +2271,9 @@ Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
 }
 
 // src/commands/launch.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync11, existsSync as existsSync11, mkdirSync as mkdirSync10, copyFileSync as copyFileSync2 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join12, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync12, existsSync as existsSync12, mkdirSync as mkdirSync11, copyFileSync as copyFileSync2 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join13, dirname as dirname6 } from "path";
 
 // src/scheduler.ts
 import { homedir as homedir3 } from "os";
@@ -2363,11 +2414,340 @@ function ensureLogsDir() {
   mkdirSync7(logsDir(), { recursive: true });
 }
 
+// src/skillcompiler.ts
+import {
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync8,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync8,
+  readdirSync as readdirSync2,
+  statSync as statSync3,
+  rmSync as rmSync4,
+  cpSync
+} from "fs";
+import { join as join9, dirname as dirname3 } from "path";
+import { homedir as homedir4 } from "os";
+import { createHash as createHash2 } from "crypto";
+var MARKER = "holt-managed skill";
+var CODEX_PREFIX = "holt-";
+function manifestPath(ws = workspace()) {
+  return join9(wsHoltDir(ws), "skill-commands.json");
+}
+function emptyManifest() {
+  return { version: 1, brains: {} };
+}
+function readManifest(ws = workspace()) {
+  const p = manifestPath(ws);
+  if (!existsSync8(p)) return emptyManifest();
+  try {
+    const parsed = JSON.parse(readFileSync10(p, "utf8"));
+    const brains = parsed.brains && typeof parsed.brains === "object" ? parsed.brains : {};
+    return { version: 1, brains };
+  } catch {
+    return emptyManifest();
+  }
+}
+function writeManifest(m, ws = workspace()) {
+  mkdirSync8(wsHoltDir(ws), { recursive: true });
+  writeFileSync8(manifestPath(ws), JSON.stringify(m, null, 2) + "\n", "utf8");
+}
+function hashString(s) {
+  return createHash2("sha256").update(s).digest("hex");
+}
+function hashDir(dir) {
+  const h = createHash2("sha256");
+  const walk = (rel) => {
+    const abs = join9(dir, rel);
+    let entries;
+    try {
+      entries = readdirSync2(abs).sort();
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      const childRel = rel ? join9(rel, name) : name;
+      const childAbs = join9(dir, childRel);
+      let st;
+      try {
+        st = statSync3(childAbs);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        h.update("D:" + childRel + "\n");
+        walk(childRel);
+      } else {
+        h.update("F:" + childRel + "\n");
+        try {
+          h.update(readFileSync10(childAbs));
+        } catch {
+        }
+      }
+    }
+  };
+  walk("");
+  return h.digest("hex");
+}
+function readSkillSource(skill) {
+  const file = join9(skill.dir, "SKILL.md");
+  let raw = "";
+  try {
+    raw = readFileSync10(file, "utf8");
+  } catch {
+    return null;
+  }
+  const { data, body } = parseFrontmatter(raw);
+  const description = (data.description || skill.description || "").trim();
+  return { name: skill.name, description, body: body.trim() };
+}
+function tomlBasicString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, " ").trim();
+}
+function tomlMultiline(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"""/g, '\\"\\"\\"');
+}
+function renderGeminiToml(src) {
+  const instructions = src.body || src.description;
+  if (!instructions.trim()) return null;
+  const prompt = [
+    instructions,
+    "",
+    "Apply the skill above to this request:",
+    "{{args}}"
+  ].join("\n");
+  const lines = [
+    `# ${MARKER}: ${src.name}`,
+    "# Generated by Holt from a SKILL.md. Edit the skill, not this file: Holt",
+    '# will overwrite it on the next launch. Delete via "holt skill remove".'
+  ];
+  if (src.description) lines.push(`description = "${tomlBasicString(src.description)}"`);
+  lines.push('prompt = """');
+  lines.push(tomlMultiline(prompt));
+  lines.push('"""');
+  return lines.join("\n") + "\n";
+}
+function renderCodexPrompt(src) {
+  const instructions = src.body || src.description;
+  if (!instructions.trim()) return null;
+  const front = ["---"];
+  if (src.description) front.push(`description: ${src.description.replace(/\n/g, " ").trim()}`);
+  front.push("argument-hint: [request]");
+  front.push("---");
+  const parts = [
+    front.join("\n"),
+    "",
+    `<!-- ${MARKER}: ${src.name} (generated by Holt from a SKILL.md; do not edit) -->`,
+    "",
+    instructions,
+    "",
+    "Apply the skill above to this request:",
+    "",
+    "$ARGUMENTS",
+    ""
+  ];
+  return parts.join("\n");
+}
+function claudeSkillsDir(ws) {
+  return join9(ws, ".claude", "skills");
+}
+function geminiCommandsDir(ws) {
+  return join9(ws, ".gemini", "commands");
+}
+function codexPromptsDir() {
+  return join9(homedir4(), ".codex", "prompts");
+}
+function fileIsOurs(path) {
+  try {
+    return readFileSync10(path, "utf8").includes(MARKER);
+  } catch {
+    return false;
+  }
+}
+function emptyResult() {
+  return { written: [], skippedExisting: [], skippedUnexpressible: [], removed: [] };
+}
+function priorEntry(m, brain, path) {
+  return (m.brains[brain] || []).find((e) => e.path === path);
+}
+function compileForBrain(brain, ws = workspace()) {
+  const res = emptyResult();
+  const manifest = readManifest(ws);
+  const prior = manifest.brains[brain] || [];
+  const nextEntries = [];
+  let skills;
+  try {
+    skills = listSkills();
+  } catch {
+    return res;
+  }
+  const enabledNames = new Set(skills.map((s) => s.name));
+  for (const skill of skills) {
+    try {
+      if (brain === "claude") {
+        compileClaude(skill, ws, manifest, res, nextEntries);
+      } else if (brain === "gemini") {
+        compileGemini(skill, ws, manifest, res, nextEntries);
+      } else {
+        compileCodex(skill, manifest, res, nextEntries);
+      }
+    } catch {
+      res.skippedUnexpressible.push(skill.name);
+    }
+  }
+  for (const e of prior) {
+    if (enabledNames.has(e.skill) && nextEntries.some((n) => n.path === e.path)) continue;
+    if (removeArtifact(e.path)) res.removed.push(e.path);
+  }
+  manifest.brains[brain] = nextEntries;
+  try {
+    writeManifest(manifest, ws);
+  } catch {
+  }
+  return res;
+}
+function compileClaude(skill, ws, manifest, res, next) {
+  const dest = join9(claudeSkillsDir(ws), skill.name);
+  const known = priorEntry(manifest, "claude", dest);
+  if (existsSync8(dest) && !known) {
+    res.skippedExisting.push(dest);
+    return;
+  }
+  const srcHash = hashDir(skill.dir);
+  if (known && known.hash === srcHash && existsSync8(dest)) {
+    next.push(known);
+    return;
+  }
+  if (existsSync8(dest)) rmSync4(dest, { recursive: true, force: true });
+  mkdirSync8(dirname3(dest), { recursive: true });
+  cpSync(skill.dir, dest, { recursive: true });
+  next.push({ skill: skill.name, path: dest, hash: hashDir(dest) });
+  res.written.push(dest);
+}
+function compileGemini(skill, ws, manifest, res, next) {
+  const src = readSkillSource(skill);
+  if (!src) {
+    res.skippedUnexpressible.push(skill.name);
+    return;
+  }
+  const content = renderGeminiToml(src);
+  if (content === null) {
+    res.skippedUnexpressible.push(skill.name);
+    return;
+  }
+  const dest = join9(geminiCommandsDir(ws), `${skill.name}.toml`);
+  writeTextArtifact("gemini", skill.name, dest, content, manifest, res, next);
+}
+function compileCodex(skill, manifest, res, next) {
+  const src = readSkillSource(skill);
+  if (!src) {
+    res.skippedUnexpressible.push(skill.name);
+    return;
+  }
+  const content = renderCodexPrompt(src);
+  if (content === null) {
+    res.skippedUnexpressible.push(skill.name);
+    return;
+  }
+  const dest = join9(codexPromptsDir(), `${CODEX_PREFIX}${skill.name}.md`);
+  writeTextArtifact("codex", skill.name, dest, content, manifest, res, next);
+}
+function writeTextArtifact(brain, skillName, dest, content, manifest, res, next) {
+  const known = priorEntry(manifest, brain, dest);
+  if (existsSync8(dest) && !known && !fileIsOurs(dest)) {
+    res.skippedExisting.push(dest);
+    return;
+  }
+  const hash = hashString(content);
+  if (existsSync8(dest)) {
+    let cur = "";
+    try {
+      cur = readFileSync10(dest, "utf8");
+    } catch {
+      cur = "";
+    }
+    if (hashString(cur) === hash) {
+      next.push({ skill: skillName, path: dest, hash });
+      return;
+    }
+  }
+  mkdirSync8(dirname3(dest), { recursive: true });
+  writeFileSync8(dest, content, "utf8");
+  next.push({ skill: skillName, path: dest, hash });
+  res.written.push(dest);
+}
+function removeArtifact(path) {
+  try {
+    if (!existsSync8(path)) return false;
+    rmSync4(path, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function syncSkillCommands(brain, ws = workspace()) {
+  let res;
+  try {
+    res = compileForBrain(brain, ws);
+  } catch {
+    return;
+  }
+  reportQuiet(brain, res);
+}
+function syncAllBrains(enabled, ws = workspace()) {
+  for (const brain of enabled) {
+    try {
+      const res = compileForBrain(brain, ws);
+      reportQuiet(brain, res);
+    } catch {
+    }
+  }
+}
+function removeSkillArtifacts(skillName, ws = workspace()) {
+  const manifest = readManifest(ws);
+  let removed = 0;
+  for (const brain of Object.keys(manifest.brains)) {
+    const entries = manifest.brains[brain] || [];
+    const keep = [];
+    for (const e of entries) {
+      if (e.skill === skillName) {
+        if (removeArtifact(e.path)) removed++;
+      } else {
+        keep.push(e);
+      }
+    }
+    manifest.brains[brain] = keep;
+  }
+  try {
+    writeManifest(manifest, ws);
+  } catch {
+  }
+  return removed;
+}
+var BRAIN_LABEL = {
+  claude: "Claude Code",
+  gemini: "Gemini CLI",
+  codex: "Codex"
+};
+function reportQuiet(brain, res) {
+  const changed = res.written.length + res.removed.length;
+  if (changed === 0 && res.skippedExisting.length === 0) return;
+  const label = BRAIN_LABEL[brain];
+  const parts = [];
+  if (res.written.length) parts.push(`${res.written.length} synced`);
+  if (res.removed.length) parts.push(`${res.removed.length} removed`);
+  if (parts.length) {
+    console.log(c.dim(`  Skills as ${label} commands: ${parts.join(", ")}.`));
+  }
+  for (const p of res.skippedExisting) {
+    console.log(c.dim(`  Skipped ${p} (already exists and not written by Holt).`));
+  }
+}
+
 // src/commands/hook.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, existsSync as existsSync9, mkdirSync as mkdirSync9, copyFileSync, realpathSync as realpathSync2, appendFileSync as appendFileSync2, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync10, existsSync as existsSync10, mkdirSync as mkdirSync10, copyFileSync, realpathSync as realpathSync2, appendFileSync as appendFileSync2, statSync as statSync5 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { join as join10, dirname as dirname3 } from "path";
-import { homedir as homedir4 } from "os";
+import { join as join11, dirname as dirname4 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/facts.ts
 var MIN_EXCHANGES_FOR_EXTRACTION = 3;
@@ -2483,15 +2863,15 @@ async function extractAndSaveFacts(active, cfg, history, session) {
 
 // src/wiki.ts
 import {
-  readFileSync as readFileSync10,
-  writeFileSync as writeFileSync8,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync8,
-  rmSync as rmSync4,
-  readdirSync as readdirSync2,
-  statSync as statSync3
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync9,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync9,
+  rmSync as rmSync5,
+  readdirSync as readdirSync3,
+  statSync as statSync4
 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { totalmem } from "os";
 
 // src/localmodel.ts
@@ -2546,28 +2926,28 @@ function pullHint(model) {
 
 // src/wiki.ts
 function wikiDir() {
-  return join9(wsHoltDir(), "wiki");
+  return join10(wsHoltDir(), "wiki");
 }
 function wikiStatePath() {
-  return join9(wikiDir(), ".state.json");
+  return join10(wikiDir(), ".state.json");
 }
 function wikiIndexPath() {
-  return join9(wikiDir(), "index.md");
+  return join10(wikiDir(), "index.md");
 }
 function pagePath(slug) {
-  return join9(wikiDir(), `${slug}.md`);
+  return join10(wikiDir(), `${slug}.md`);
 }
 function loadState() {
   try {
-    const s = JSON.parse(readFileSync10(wikiStatePath(), "utf8"));
+    const s = JSON.parse(readFileSync11(wikiStatePath(), "utf8"));
     return { lastSyncTs: typeof s.lastSyncTs === "number" ? s.lastSyncTs : 0, updatedAt: s.updatedAt ?? 0 };
   } catch {
     return { lastSyncTs: 0, updatedAt: 0 };
   }
 }
 function saveState(s) {
-  mkdirSync8(wikiDir(), { recursive: true });
-  writeFileSync8(wikiStatePath(), JSON.stringify(s, null, 2) + "\n", "utf8");
+  mkdirSync9(wikiDir(), { recursive: true });
+  writeFileSync9(wikiStatePath(), JSON.stringify(s, null, 2) + "\n", "utf8");
 }
 function saveSyncMarker(ts) {
   saveState({ lastSyncTs: ts, updatedAt: Date.now() });
@@ -2577,19 +2957,19 @@ function isPageFile(name) {
 }
 function listPageSlugs() {
   const dir = wikiDir();
-  if (!existsSync8(dir)) return [];
+  if (!existsSync9(dir)) return [];
   try {
-    return readdirSync2(dir).filter(isPageFile).map((f) => f.slice(0, -3)).sort();
+    return readdirSync3(dir).filter(isPageFile).map((f) => f.slice(0, -3)).sort();
   } catch {
     return [];
   }
 }
 function readPage(slug) {
   const p = pagePath(slug);
-  if (!existsSync8(p)) return null;
+  if (!existsSync9(p)) return null;
   let raw = "";
   try {
-    raw = readFileSync10(p, "utf8");
+    raw = readFileSync11(p, "utf8");
   } catch {
     return null;
   }
@@ -2631,8 +3011,8 @@ function renderPage(pg) {
   return fm;
 }
 function writePage(pg) {
-  mkdirSync8(wikiDir(), { recursive: true });
-  writeFileSync8(pagePath(pg.slug), renderPage(pg), "utf8");
+  mkdirSync9(wikiDir(), { recursive: true });
+  writeFileSync9(pagePath(pg.slug), renderPage(pg), "utf8");
 }
 var WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
 function extractLinks(body) {
@@ -2909,8 +3289,8 @@ function renderIndex(pages) {
   return lines.join("\n");
 }
 function writeIndex(pages) {
-  mkdirSync8(wikiDir(), { recursive: true });
-  writeFileSync8(wikiIndexPath(), renderIndex(pages), "utf8");
+  mkdirSync9(wikiDir(), { recursive: true });
+  writeFileSync9(wikiIndexPath(), renderIndex(pages), "utf8");
 }
 var WIKI_SESSION = "wiki";
 function wikiRowId(slug) {
@@ -2925,9 +3305,9 @@ async function indexPagesForRecall(pages) {
     if (pages.length === 0) return;
     const slugs = new Set(pages.map((p) => sanitizeName(p.slug).slice(0, 24)));
     const kept = dropWikiRows(slugs);
-    mkdirSync8(join9(wsHoltDir(), "memory"), { recursive: true });
-    writeFileSync8(
-      join9(wsHoltDir(), "memory", "turns.jsonl"),
+    mkdirSync9(join10(wsHoltDir(), "memory"), { recursive: true });
+    writeFileSync9(
+      join10(wsHoltDir(), "memory", "turns.jsonl"),
       kept.map((t) => JSON.stringify(t)).join("\n") + (kept.length ? "\n" : ""),
       "utf8"
     );
@@ -2949,9 +3329,9 @@ ${pg.body}`.slice(0, 4e3);
 function clearWikiRecallRows() {
   try {
     const kept = loadTurns().filter((t) => t.session !== WIKI_SESSION);
-    mkdirSync8(join9(wsHoltDir(), "memory"), { recursive: true });
-    writeFileSync8(
-      join9(wsHoltDir(), "memory", "turns.jsonl"),
+    mkdirSync9(join10(wsHoltDir(), "memory"), { recursive: true });
+    writeFileSync9(
+      join10(wsHoltDir(), "memory", "turns.jsonl"),
       kept.map((t) => JSON.stringify(t)).join("\n") + (kept.length ? "\n" : ""),
       "utf8"
     );
@@ -2959,14 +3339,14 @@ function clearWikiRecallRows() {
   }
 }
 function wipeWiki() {
-  if (existsSync8(wikiDir())) rmSync4(wikiDir(), { recursive: true, force: true });
+  if (existsSync9(wikiDir())) rmSync5(wikiDir(), { recursive: true, force: true });
 }
 function wikiStats() {
   const slugs = listPageSlugs();
   let bytes = 0;
   for (const slug of slugs) {
     try {
-      bytes += statSync3(pagePath(slug)).size;
+      bytes += statSync4(pagePath(slug)).size;
     } catch {
     }
   }
@@ -3005,26 +3385,26 @@ var HOOK_CMD = {
   capture: "holt hook capture"
 };
 function globalSettingsPath() {
-  return join10(homedir4(), ".claude", "settings.json");
+  return join11(homedir5(), ".claude", "settings.json");
 }
 function projectSettingsPath() {
-  return join10(process.cwd(), ".claude", "settings.json");
+  return join11(process.cwd(), ".claude", "settings.json");
 }
 function readSettings(path) {
-  if (!existsSync9(path)) return {};
+  if (!existsSync10(path)) return {};
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     throw new Error(`could not parse ${path} (not valid JSON) - leaving it untouched`);
   }
 }
 function writeSettings(path, settings) {
-  mkdirSync9(dirname3(path), { recursive: true });
-  writeFileSync9(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  mkdirSync10(dirname4(path), { recursive: true });
+  writeFileSync10(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
 function backup(path) {
-  if (!existsSync9(path)) return null;
+  if (!existsSync10(path)) return null;
   const dest = `${path}.holt-bak`;
   try {
     copyFileSync(path, dest);
@@ -3114,7 +3494,7 @@ function remove(rest) {
   const paths = project ? [projectSettingsPath()] : [globalSettingsPath(), projectSettingsPath()];
   let touchedAny = false;
   for (const path of paths) {
-    if (!existsSync9(path)) continue;
+    if (!existsSync10(path)) continue;
     let settings;
     try {
       settings = readSettings(path);
@@ -3144,7 +3524,7 @@ function status(rest) {
   ];
   console.log(c.accent("  Holt ambient hooks"));
   for (const e of entries) {
-    if (!existsSync9(e.path)) {
+    if (!existsSync10(e.path)) {
       console.log(c.dim(`  ${e.label.padEnd(8)} ${e.path}  (no settings file)`));
       continue;
     }
@@ -3194,7 +3574,7 @@ function parseHookInput(raw) {
   }
 }
 function enterFolder(cwd) {
-  if (!cwd || !existsSync9(cwd)) return null;
+  if (!cwd || !existsSync10(cwd)) return null;
   try {
     const real = realpathSync2(cwd);
     process.chdir(real);
@@ -3205,13 +3585,13 @@ function enterFolder(cwd) {
 }
 function guardTrusted(real) {
   if (!isTrusted(real)) return false;
-  if (!existsSync9(memDir())) return false;
+  if (!existsSync10(memDir())) return false;
   return true;
 }
 function hookLog(msg) {
   try {
-    mkdirSync9(GLOBAL_DIR, { recursive: true });
-    appendFileSync2(join10(GLOBAL_DIR, "hooks.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+    mkdirSync10(GLOBAL_DIR, { recursive: true });
+    appendFileSync2(join11(GLOBAL_DIR, "hooks.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `, "utf8");
   } catch {
   }
@@ -3219,18 +3599,18 @@ function hookLog(msg) {
 function fileBytes(path) {
   if (!path) return 0;
   try {
-    return statSync4(path).size;
+    return statSync5(path).size;
   } catch {
     return 0;
   }
 }
 var THROTTLE_MIN_NEW_EXCHANGES = 2;
 function hookStatePath() {
-  return join10(GLOBAL_DIR, "hook-state.json");
+  return join11(GLOBAL_DIR, "hook-state.json");
 }
 function readHookState() {
   try {
-    const parsed = JSON.parse(readFileSync11(hookStatePath(), "utf8"));
+    const parsed = JSON.parse(readFileSync12(hookStatePath(), "utf8"));
     if (!parsed || typeof parsed !== "object") return {};
     return parsed;
   } catch {
@@ -3243,10 +3623,10 @@ function lastProcessedExchanges(state, sessionId) {
 }
 function saveHookState(sessionId, exchanges) {
   try {
-    mkdirSync9(GLOBAL_DIR, { recursive: true });
+    mkdirSync10(GLOBAL_DIR, { recursive: true });
     const state = readHookState();
     state[sessionId] = { lastExchanges: exchanges };
-    writeFileSync9(hookStatePath(), JSON.stringify(state, null, 2) + "\n", "utf8");
+    writeFileSync10(hookStatePath(), JSON.stringify(state, null, 2) + "\n", "utf8");
   } catch {
   }
 }
@@ -3320,7 +3700,7 @@ function readTranscript(path) {
   const out = [];
   let raw;
   try {
-    raw = readFileSync11(path, "utf8");
+    raw = readFileSync12(path, "utf8");
   } catch {
     return out;
   }
@@ -3348,28 +3728,28 @@ function readTranscript(path) {
   return out;
 }
 function resolveCommandPath(command) {
-  if (command.startsWith("/") && existsSync9(command)) return command;
+  if (command.startsWith("/") && existsSync10(command)) return command;
   try {
     const shell = process.env.SHELL || "/bin/sh";
     const res = spawnSync3(shell, ["-lc", "command -v " + command], { encoding: "utf8" });
     if (res.status === 0) {
       const p = (res.stdout || "").trim().split("\n")[0]?.trim();
-      if (p && p.startsWith("/") && existsSync9(p)) return p;
+      if (p && p.startsWith("/") && existsSync10(p)) return p;
     }
   } catch {
   }
-  const home = homedir4();
+  const home = homedir5();
   const dirs = [
-    join10(home, ".local", "bin"),
+    join11(home, ".local", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join10(home, ".npm-global", "bin"),
+    join11(home, ".npm-global", "bin"),
     "/usr/bin",
     "/bin"
   ];
   for (const dir of dirs) {
-    const candidate = join10(dir, command);
-    if (existsSync9(candidate)) return candidate;
+    const candidate = join11(dir, command);
+    if (existsSync10(candidate)) return candidate;
   }
   return null;
 }
@@ -3443,7 +3823,7 @@ async function capture() {
       let bytes = 0;
       let lines = 0;
       try {
-        const rawT = readFileSync11(data.transcript_path, "utf8");
+        const rawT = readFileSync12(data.transcript_path, "utf8");
         bytes = Buffer.byteLength(rawT, "utf8");
         lines = countLines(rawT);
       } catch {
@@ -3541,8 +3921,8 @@ async function hook(sub, rest = []) {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/output.ts
-import { writeFileSync as writeFileSync10 } from "fs";
-import { join as join11, isAbsolute } from "path";
+import { writeFileSync as writeFileSync11 } from "fs";
+import { join as join12, isAbsolute } from "path";
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -3682,8 +4062,8 @@ function saveReply(reply, format, name) {
     throw new Error('name must be a plain file name in this folder (no "/", "\\", or "..").');
   }
   if (!/\.[a-z0-9]+$/i.test(base)) base += ext;
-  const path = join11(process.cwd(), base);
-  writeFileSync10(path, renderReply(reply, format), "utf8");
+  const path = join12(process.cwd(), base);
+  writeFileSync11(path, renderReply(reply, format), "utf8");
   return path;
 }
 
@@ -3711,12 +4091,12 @@ async function login(which) {
 }
 
 // src/access.ts
-import { existsSync as existsSync10, realpathSync as realpathSync3, statSync as statSync5 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, resolve as resolve2, sep } from "path";
+import { existsSync as existsSync11, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname5, isAbsolute as isAbsolute2, resolve as resolve2, sep } from "path";
 function expandHome(p) {
-  if (p === "~") return homedir5();
-  if (p.startsWith("~/")) return resolve2(homedir5(), p.slice(2));
+  if (p === "~") return homedir6();
+  if (p.startsWith("~/")) return resolve2(homedir6(), p.slice(2));
   return p;
 }
 function isInside(child, parent) {
@@ -3727,7 +4107,7 @@ function isInside(child, parent) {
 function resolveExisting(token) {
   const expanded = expandHome(token);
   const abs = isAbsolute2(expanded) ? expanded : resolve2(process.cwd(), expanded);
-  if (!existsSync10(abs)) return null;
+  if (!existsSync11(abs)) return null;
   try {
     return realpathSync3(abs);
   } catch {
@@ -3736,9 +4116,9 @@ function resolveExisting(token) {
 }
 function containingDir(absPath) {
   try {
-    return statSync5(absPath).isDirectory() ? absPath : dirname4(absPath);
+    return statSync6(absPath).isDirectory() ? absPath : dirname5(absPath);
   } catch {
-    return dirname4(absPath);
+    return dirname5(absPath);
   }
 }
 function resolveGrantDir(token) {
@@ -3881,6 +4261,9 @@ async function chat() {
   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.`));
   }
+  if (!embedOk) {
+    console.log(c.dim('  Recall works, but semantic memory is off. "holt doctor --fix" turns it on.'));
+  }
   console.log(c.dim("Type a message. Commands: /brain  /memory  /output  /save  /allow  /setting  /clear  /help  /exit"));
   showStatus();
   while (true) {
@@ -4166,13 +4549,13 @@ var CONTEXT_MARKER = "<!-- holt-managed identity -->";
 function brandContextFile(id) {
   const name = CONTEXT_FILE[id];
   if (!name) return null;
-  const path = join12(workspace(), name);
+  const path = join13(workspace(), name);
   try {
-    if (existsSync11(path)) {
-      const cur = readFileSync12(path, "utf8");
+    if (existsSync12(path)) {
+      const cur = readFileSync13(path, "utf8");
       if (!cur.includes(CONTEXT_MARKER)) return null;
     }
-    writeFileSync11(path, `${CONTEXT_MARKER}
+    writeFileSync12(path, `${CONTEXT_MARKER}
 # Holt
 
 ${HOLT_IDENTITY}
@@ -4183,11 +4566,11 @@ ${HOLT_IDENTITY}
   }
 }
 function brandStatusLine() {
-  const path = join12(workspace(), ".claude", "settings.json");
+  const path = join13(workspace(), ".claude", "settings.json");
   let settings = {};
   try {
-    if (existsSync11(path)) {
-      const parsed = JSON.parse(readFileSync12(path, "utf8"));
+    if (existsSync12(path)) {
+      const parsed = JSON.parse(readFileSync13(path, "utf8"));
       if (parsed && typeof parsed === "object") settings = parsed;
     }
   } catch {
@@ -4195,13 +4578,13 @@ function brandStatusLine() {
   }
   if (settings.statusLine) return false;
   try {
-    if (existsSync11(path)) copyFileSync2(path, `${path}.holt-bak`);
+    if (existsSync12(path)) copyFileSync2(path, `${path}.holt-bak`);
     settings.statusLine = {
       type: "command",
       command: `${resolveHoltPath()} statusline`
     };
-    mkdirSync10(dirname5(path), { recursive: true });
-    writeFileSync11(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+    mkdirSync11(dirname6(path), { recursive: true });
+    writeFileSync12(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
     return true;
   } catch {
     return false;
@@ -4223,7 +4606,7 @@ function resolveTarget(cfg) {
 async function ensureSetup() {
   const ws = workspace();
   if (!isTrusted(ws)) trustDir(ws);
-  mkdirSync10(memDir(), { recursive: true });
+  mkdirSync11(memDir(), { recursive: true });
   if (!hooksAlreadyInstalled()) {
     try {
       await hook("install", []);
@@ -4233,8 +4616,8 @@ async function ensureSetup() {
 }
 function hooksAlreadyInstalled() {
   try {
-    const p = join12(homedir6(), ".claude", "settings.json");
-    return existsSync11(p) && readFileSync12(p, "utf8").includes("holt hook");
+    const p = join13(homedir7(), ".claude", "settings.json");
+    return existsSync12(p) && readFileSync13(p, "utf8").includes("holt hook");
   } catch {
     return false;
   }
@@ -4283,6 +4666,7 @@ async function launch() {
     if (ctx) console.log(c.dim(`  Holt identity: ${ctx}`));
   }
   if (target.id === "claude") brandStatusLine();
+  syncSkillCommands(target.id);
   const interactive = INTERACTIVE_ARGS[target.id];
   const args = [...interactive, ...flags];
   console.log(c.dim('  Starting your Holt session. Type "exit" to leave.\n'));
@@ -4291,7 +4675,7 @@ async function launch() {
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync12, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
 import { basename } from "path";
 async function memoryCmd(sub, rest = []) {
   const { ask, close } = createReader();
@@ -4339,12 +4723,12 @@ async function memoryCmd(sub, rest = []) {
     return;
   }
   if (action === "facts") {
-    if (!existsSync12(factsMdPath())) {
+    if (!existsSync13(factsMdPath())) {
       console.log(c.dim("\n  No facts distilled yet. They form when you end a chat session.\n"));
       close();
       return;
     }
-    const body = readFileSync13(factsMdPath(), "utf8").trim();
+    const body = readFileSync14(factsMdPath(), "utf8").trim();
     console.log("\n" + body + "\n");
     close();
     return;
@@ -4358,6 +4742,9 @@ async function memoryCmd(sub, rest = []) {
     }
     const hits = await recall(q, "__none__", 8);
     console.log("");
+    if (!await embeddingsAvailable()) {
+      console.log(c.dim('  (memory is in keyword mode; run "holt doctor --fix" to turn semantic recall back on)'));
+    }
     if (hits.length === 0) console.log(c.dim("  Nothing relevant found."));
     else for (const h of hits) {
       const when = new Date(h.turn.ts).toISOString().slice(0, 10);
@@ -4458,8 +4845,8 @@ function globalCmd(act, rest) {
 }
 
 // src/commands/wiki.ts
-import { existsSync as existsSync13, readFileSync as readFileSync14 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync15 } from "fs";
+import { join as join14 } from "path";
 import { spawn as spawn3 } from "child_process";
 function titleToSlug(title) {
   return proposeSlug(title);
@@ -4652,7 +5039,7 @@ function listCmd() {
   for (const slug of slugs) {
     const pg = readPage(slug);
     if (!pg) continue;
-    const size = existsSync13(join13(wikiDir(), slug + ".md")) ? (readFileSync14(join13(wikiDir(), slug + ".md"), "utf8").length / 1024).toFixed(1) : "0.0";
+    const size = existsSync14(join14(wikiDir(), slug + ".md")) ? (readFileSync15(join14(wikiDir(), slug + ".md"), "utf8").length / 1024).toFixed(1) : "0.0";
     console.log(`  ${c.cyan(pg.title.padEnd(28).slice(0, 28))} ${c.dim(pg.updated || "          ")}  ${size} KB`);
   }
   console.log("");
@@ -4670,7 +5057,7 @@ function showCmd(name) {
 `));
     return;
   }
-  const raw = readFileSync14(join13(wikiDir(), slug + ".md"), "utf8");
+  const raw = readFileSync15(join14(wikiDir(), slug + ".md"), "utf8");
   console.log("\n" + raw.trim() + "\n");
 }
 async function statusCmd(cfg) {
@@ -4740,8 +5127,8 @@ function setupCmd(cfg) {
 `));
 }
 function openCmd() {
-  const target = existsSync13(wikiIndexPath()) ? wikiIndexPath() : wikiDir();
-  if (!existsSync13(target)) {
+  const target = existsSync14(wikiIndexPath()) ? wikiIndexPath() : wikiDir();
+  if (!existsSync14(target)) {
     console.log(c.dim('\n  No wiki yet. Run "holt wiki sync" first.\n'));
     return;
   }
@@ -4828,29 +5215,29 @@ async function wikiCmd(sub, rest = []) {
 
 // src/commands/skill.ts
 import {
-  mkdirSync as mkdirSync12,
-  writeFileSync as writeFileSync13,
-  readFileSync as readFileSync16,
-  existsSync as existsSync15,
-  readdirSync as readdirSync3,
-  statSync as statSync7,
-  rmSync as rmSync5,
-  cpSync,
+  mkdirSync as mkdirSync13,
+  writeFileSync as writeFileSync14,
+  readFileSync as readFileSync17,
+  existsSync as existsSync16,
+  readdirSync as readdirSync4,
+  statSync as statSync8,
+  rmSync as rmSync6,
+  cpSync as cpSync2,
   mkdtempSync
 } from "fs";
-import { join as join15, resolve as resolve4, sep as sep2, isAbsolute as isAbsolute4 } from "path";
+import { join as join16, resolve as resolve4, sep as sep2, isAbsolute as isAbsolute4 } from "path";
 import { tmpdir } from "os";
 import { spawnSync as spawnSync4 } from "child_process";
 
 // src/registry.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync11, statSync as statSync6 } from "fs";
-import { join as join14, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync13, existsSync as existsSync15, mkdirSync as mkdirSync12, statSync as statSync7 } from "fs";
+import { join as join15, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
 import { pathToFileURL, fileURLToPath as fileURLToPath2 } from "url";
 var DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/holt-os/registry/main/registry.json";
 var REGISTRY_REPO_URL = "https://github.com/holt-os/registry";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 function registryCachePath() {
-  return join14(GLOBAL_DIR, "registry-cache.json");
+  return join15(GLOBAL_DIR, "registry-cache.json");
 }
 function registryUrl() {
   const env = (process.env.HOLT_REGISTRY_URL || "").trim();
@@ -4889,8 +5276,8 @@ function parseRegistry(text) {
 function readCache() {
   try {
     const path = registryCachePath();
-    if (!existsSync14(path)) return null;
-    const raw = JSON.parse(readFileSync15(path, "utf8"));
+    if (!existsSync15(path)) return null;
+    const raw = JSON.parse(readFileSync16(path, "utf8"));
     if (!raw || typeof raw.fetchedAt !== "number" || typeof raw.url !== "string") return null;
     const registry = coerceRegistry(raw.registry);
     if (!registry) return null;
@@ -4901,9 +5288,9 @@ function readCache() {
 }
 function writeCache(url, registry) {
   try {
-    mkdirSync11(GLOBAL_DIR, { recursive: true });
+    mkdirSync12(GLOBAL_DIR, { recursive: true });
     const body = { fetchedAt: Date.now(), url, registry };
-    writeFileSync12(registryCachePath(), JSON.stringify(body, null, 2) + "\n", "utf8");
+    writeFileSync13(registryCachePath(), JSON.stringify(body, null, 2) + "\n", "utf8");
   } catch {
   }
 }
@@ -4921,10 +5308,10 @@ function localPathFor(loc) {
 var UNREACHABLE_MSG = "no registry reachable; set HOLT_REGISTRY_URL or the community registry is not live yet";
 function loadLocal(path) {
   try {
-    if (!existsSync14(path)) {
+    if (!existsSync15(path)) {
       return { registry: null, fromCache: false, error: UNREACHABLE_MSG };
     }
-    const registry = parseRegistry(readFileSync15(path, "utf8"));
+    const registry = parseRegistry(readFileSync16(path, "utf8"));
     if (!registry) {
       return { registry: null, fromCache: false, error: "registry file is not valid JSON" };
     }
@@ -4993,6 +5380,12 @@ function buildPublishEntry(input) {
 }
 
 // src/commands/skill.ts
+function enabledBrains() {
+  const cfg = loadConfig();
+  if (!cfg) return [...BRAIN_IDS];
+  const on2 = BRAIN_IDS.filter((b) => cfg.brains[b].enabled);
+  return on2.length ? on2 : [...BRAIN_IDS];
+}
 function usage() {
   console.log(c.dim([
     "",
@@ -5053,12 +5446,12 @@ function resolveSubpathDir(fetched, subpath) {
   return target;
 }
 function findSkillDir(root) {
-  if (existsSync15(join15(root, "SKILL.md"))) return root;
+  if (existsSync16(join16(root, "SKILL.md"))) return root;
   let subs = [];
   try {
-    subs = readdirSync3(root).filter((f) => {
+    subs = readdirSync4(root).filter((f) => {
       try {
-        return statSync7(join15(root, f)).isDirectory();
+        return statSync8(join16(root, f)).isDirectory();
       } catch {
         return false;
       }
@@ -5066,8 +5459,8 @@ function findSkillDir(root) {
   } catch {
     return null;
   }
-  const withSkill = subs.filter((f) => existsSync15(join15(root, f, "SKILL.md")));
-  if (withSkill.length === 1) return join15(root, withSkill[0]);
+  const withSkill = subs.filter((f) => existsSync16(join16(root, f, "SKILL.md")));
+  if (withSkill.length === 1) return join16(root, withSkill[0]);
   return null;
 }
 function cmdList() {
@@ -5108,7 +5501,7 @@ function cmdShow(name) {
   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("  " + join15(skill.dir, "SKILL.md")));
+  console.log(c.dim("  " + join16(skill.dir, "SKILL.md")));
   console.log("");
   console.log(c.dim(body));
   console.log("");
@@ -5120,19 +5513,19 @@ function cmdCreate(name, global) {
     return;
   }
   const scope = global ? "global" : "workspace";
-  const dir = join15(skillsRoot(scope), clean);
-  if (existsSync15(dir)) {
+  const dir = join16(skillsRoot(scope), clean);
+  if (existsSync16(dir)) {
     console.error(c.red(`
   A ${scope} skill named "${clean}" already exists.`));
     console.error(c.dim("  " + dir + "\n"));
     process.exitCode = 1;
     return;
   }
-  mkdirSync12(dir, { recursive: true });
-  writeFileSync13(join15(dir, "SKILL.md"), SKILL_TEMPLATE(clean), "utf8");
+  mkdirSync13(dir, { recursive: true });
+  writeFileSync14(join16(dir, "SKILL.md"), SKILL_TEMPLATE(clean), "utf8");
   console.log(c.green(`
   Created ${scope} skill "${clean}".`));
-  console.log(c.dim("  " + join15(dir, "SKILL.md")));
+  console.log(c.dim("  " + join16(dir, "SKILL.md")));
   console.log(c.dim('  Edit it, then run it in chat with "/skill ' + clean + '".\n'));
 }
 function installFromSource(source, scope) {
@@ -5141,7 +5534,7 @@ function installFromSource(source, scope) {
   let tempDir = "";
   try {
     if (isGitUrl(base)) {
-      tempDir = mkdtempSync(join15(tmpdir(), "holt-skill-"));
+      tempDir = mkdtempSync(join16(tmpdir(), "holt-skill-"));
       console.log(c.dim(`
   Cloning ${base} ...`));
       const res = spawnSync4("git", ["clone", "--depth", "1", base, tempDir], { stdio: "ignore" });
@@ -5153,7 +5546,7 @@ function installFromSource(source, scope) {
       fetched = tempDir;
     } else {
       fetched = resolve4(base);
-      if (!existsSync15(fetched)) {
+      if (!existsSync16(fetched)) {
         console.error(c.red(`
   No such path: ${fetched}
 `));
@@ -5171,7 +5564,7 @@ function installFromSource(source, scope) {
         process.exitCode = 1;
         return false;
       }
-      if (!existsSync15(target) || !statSync7(target).isDirectory()) {
+      if (!existsSync16(target) || !statSync8(target).isDirectory()) {
         console.error(c.red(`
   Subpath "${subpath}" does not exist in the source.
 `));
@@ -5191,7 +5584,7 @@ function installFromSource(source, scope) {
     }
     let skillName = "";
     try {
-      const { data } = parseFrontmatter(readFileSync16(join15(skillDir, "SKILL.md"), "utf8"));
+      const { data } = parseFrontmatter(readFileSync17(join16(skillDir, "SKILL.md"), "utf8"));
       skillName = sanitizeName(data.name || "");
     } catch {
       skillName = "";
@@ -5202,26 +5595,26 @@ function installFromSource(source, scope) {
       process.exitCode = 1;
       return false;
     }
-    const dest = join15(skillsRoot(scope), skillName);
-    if (existsSync15(dest)) {
+    const dest = join16(skillsRoot(scope), skillName);
+    if (existsSync16(dest)) {
       console.error(c.red(`
   A ${scope} skill named "${skillName}" already exists.`));
       console.error(c.dim("  " + dest + "\n"));
       process.exitCode = 1;
       return false;
     }
-    mkdirSync12(skillsRoot(scope), { recursive: true });
-    cpSync(skillDir, dest, { recursive: true });
-    const nestedGit = join15(dest, ".git");
-    if (existsSync15(nestedGit)) rmSync5(nestedGit, { recursive: true, force: true });
+    mkdirSync13(skillsRoot(scope), { recursive: true });
+    cpSync2(skillDir, dest, { recursive: true });
+    const nestedGit = join16(dest, ".git");
+    if (existsSync16(nestedGit)) rmSync6(nestedGit, { recursive: true, force: true });
     console.log(c.green(`
   Installed ${scope} skill "${skillName}".`));
-    console.log(c.dim("  " + join15(dest, "SKILL.md") + "\n"));
+    console.log(c.dim("  " + join16(dest, "SKILL.md") + "\n"));
     return true;
   } finally {
-    if (tempDir && existsSync15(tempDir)) {
+    if (tempDir && existsSync16(tempDir)) {
       try {
-        rmSync5(tempDir, { recursive: true, force: true });
+        rmSync6(tempDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5234,8 +5627,8 @@ async function cmdAdd(source, global, refresh) {
   }
   const scope = global ? "global" : "workspace";
   const { base } = splitSubpath(source);
-  if (isGitUrl(base) || existsSync15(resolve4(base))) {
-    installFromSource(source, scope);
+  if (isGitUrl(base) || existsSync16(resolve4(base))) {
+    if (installFromSource(source, scope)) syncAllBrains(enabledBrains());
     return;
   }
   const { registry, error } = await loadRegistry({ refresh });
@@ -5256,7 +5649,7 @@ async function cmdAdd(source, global, refresh) {
   }
   console.log(c.dim(`
   Resolved "${hit.name}" -> ${hit.source}`));
-  installFromSource(hit.source, scope);
+  if (installFromSource(hit.source, scope)) syncAllBrains(enabledBrains());
 }
 async function cmdSearch(query, refresh) {
   const { registry, error, fromCache } = await loadRegistry({ refresh });
@@ -5306,7 +5699,7 @@ function cmdPublish(name) {
     }
     let raw = "";
     try {
-      raw = readFileSync16(join15(loaded.skill.dir, "SKILL.md"), "utf8");
+      raw = readFileSync17(join16(loaded.skill.dir, "SKILL.md"), "utf8");
     } catch {
       console.error(c.red("\n  Could not read the skill's SKILL.md.\n"));
       process.exitCode = 1;
@@ -5316,14 +5709,14 @@ function cmdPublish(name) {
     skillName = sanitizeName(data.name || loaded.skill.name);
     description = (data.description || loaded.skill.description || "").trim();
   } else {
-    const file = join15(process.cwd(), "SKILL.md");
-    if (!existsSync15(file)) {
+    const file = join16(process.cwd(), "SKILL.md");
+    if (!existsSync16(file)) {
       console.error(c.red("\n  No SKILL.md in the current directory, and no skill name given."));
       console.error(c.dim("  Usage: holt skill publish [<name>]\n"));
       process.exitCode = 1;
       return;
     }
-    const { data } = parseFrontmatter(readFileSync16(file, "utf8"));
+    const { data } = parseFrontmatter(readFileSync17(file, "utf8"));
     skillName = sanitizeName(data.name || process.cwd().split(/[\\/]/).pop() || "");
     description = (data.description || "").trim();
     sourceHint = process.cwd();
@@ -5359,11 +5752,11 @@ async function cmdRemove(name, ask) {
     console.log(c.dim("\n  Usage: holt skill remove <name>\n"));
     return;
   }
-  const wsDir = join15(skillsRoot("workspace"), clean);
-  const globalDir = join15(skillsRoot("global"), clean);
-  const target = existsSync15(wsDir) ? wsDir : existsSync15(globalDir) ? globalDir : "";
+  const wsDir = join16(skillsRoot("workspace"), clean);
+  const globalDir = join16(skillsRoot("global"), clean);
+  const target = existsSync16(wsDir) ? wsDir : existsSync16(globalDir) ? globalDir : "";
   if (!target) {
-    if (existsSync15(join15(skillsRoot("builtin"), clean))) {
+    if (existsSync16(join16(skillsRoot("builtin"), clean))) {
       console.error(c.red(`
   "${clean}" is a built-in skill and cannot be removed; it ships inside Holt.`));
       console.error(c.dim("  Override it instead: create a workspace or global skill with the same name.\n"));
@@ -5380,7 +5773,9 @@ async function cmdRemove(name, ask) {
   const a = (await ask(`
   Delete ${scope} skill "${clean}"? [y/N] `) ?? "").trim().toLowerCase();
   if (a === "y" || a === "yes") {
-    rmSync5(target, { recursive: true, force: true });
+    rmSync6(target, { recursive: true, force: true });
+    removeSkillArtifacts(clean);
+    syncAllBrains(enabledBrains());
     console.log(c.green("  Removed.\n"));
   } else {
     console.log(c.dim("  Kept.\n"));
@@ -5436,8 +5831,8 @@ async function skillCmd(sub, rest = []) {
 }
 
 // src/commands/graph.ts
-import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync13, existsSync as existsSync16 } from "fs";
-import { join as join17, dirname as dirname7, resolve as resolve5 } from "path";
+import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, existsSync as existsSync17 } from "fs";
+import { join as join18, dirname as dirname8, resolve as resolve5 } from "path";
 import { spawn as spawn4 } from "child_process";
 
 // src/communities.ts
@@ -6234,8 +6629,8 @@ function renderGraphHtml(graph2, meta) {
 }
 
 // src/ingest.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync17, statSync as statSync8 } from "fs";
-import { join as join16, relative, sep as sep3, extname, dirname as dirname6, basename as basename2 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync18, statSync as statSync9 } from "fs";
+import { join as join17, relative, sep as sep3, extname, dirname as dirname7, basename as basename2 } from "path";
 var CODE_EXT = /* @__PURE__ */ new Set([
   "js",
   "jsx",
@@ -6297,7 +6692,7 @@ function ingestFolder(root, want = { code: true, docs: true }) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = readdirSync4(dir).sort((a, b) => a.localeCompare(b));
+      entries = readdirSync5(dir).sort((a, b) => a.localeCompare(b));
     } catch {
       skipped.unreadable++;
       continue;
@@ -6308,10 +6703,10 @@ function ingestFolder(root, want = { code: true, docs: true }) {
         skipped.hitFileCap = true;
         break;
       }
-      const full = join16(dir, name);
+      const full = join17(dir, name);
       let st;
       try {
-        st = statSync8(full);
+        st = statSync9(full);
       } catch {
         skipped.unreadable++;
         continue;
@@ -6341,7 +6736,7 @@ function ingestFolder(root, want = { code: true, docs: true }) {
       }
       let content;
       try {
-        content = readFileSync17(full, "utf8");
+        content = readFileSync18(full, "utf8");
       } catch {
         skipped.unreadable++;
         continue;
@@ -6475,7 +6870,7 @@ function resolvePySpec(f, spec, byId) {
   return null;
 }
 function toPosixDir(id) {
-  const d = toPosix(dirname6(id));
+  const d = toPosix(dirname7(id));
   return d === "" || d === "." ? "." : d;
 }
 var MD_LINK_RE = /\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g;
@@ -6647,7 +7042,7 @@ async function graph(args = []) {
   const ingestCode = opts.code;
   const ingestDocs = opts.docs;
   const turns = loadTurns();
-  const includeWiki = opts.wiki !== void 0 ? opts.wiki : existsSync16(wikiDir());
+  const includeWiki = opts.wiki !== void 0 ? opts.wiki : existsSync17(wikiDir());
   const wikiPages = includeWiki ? wikiGraphPages() : [];
   let fileNodeCount = 0;
   let docNodeCount = 0;
@@ -6677,9 +7072,9 @@ async function graph(args = []) {
   if (codeGraph) assignCommunities(g);
   if (opts.report) {
     const md = renderReport(g, { workspace: workspace() });
-    const reportPath = opts.out ? resolve5(opts.out) : join17(workspace(), "GRAPH_REPORT.md");
-    mkdirSync13(dirname7(reportPath), { recursive: true });
-    writeFileSync14(reportPath, md, "utf8");
+    const reportPath = opts.out ? resolve5(opts.out) : join18(workspace(), "GRAPH_REPORT.md");
+    mkdirSync14(dirname8(reportPath), { recursive: true });
+    writeFileSync15(reportPath, md, "utf8");
     const communities = new Set(g.nodes.map((n) => n.community ?? "0")).size;
     console.log("\n" + c.accent("Graph report written") + c.dim("  (this folder)"));
     console.log(`  nodes        ${g.nodes.length}  (${fileNodeCount} files, ${docNodeCount} docs)`);
@@ -6699,9 +7094,9 @@ async function graph(args = []) {
     concepts: conceptCount,
     edges: g.edges.length
   });
-  const outPath = opts.out ? resolve5(opts.out) : join17(wsHoltDir(), "graph.html");
-  mkdirSync13(dirname7(outPath), { recursive: true });
-  writeFileSync14(outPath, html, "utf8");
+  const outPath = opts.out ? resolve5(opts.out) : join18(wsHoltDir(), "graph.html");
+  mkdirSync14(dirname8(outPath), { recursive: true });
+  writeFileSync15(outPath, html, "utf8");
   console.log("\n" + c.accent("Memory graph built") + c.dim("  (this folder)"));
   const parts = [`${turns.length} turns`, `${conceptCount} concepts`];
   if (wikiCount) parts.push(`${wikiCount} wiki pages`);
@@ -6989,7 +7384,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.14.2";
+var VERSION = "0.15.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -7111,7 +7506,7 @@ async function statusline() {
 }
 
 // src/commands/run.ts
-import { writeFileSync as writeFileSync15 } from "fs";
+import { writeFileSync as writeFileSync16 } from "fs";
 import { resolve as resolve6 } from "path";
 var USAGE3 = [
   "  holt run <task> [options]",
@@ -7133,7 +7528,7 @@ function parseArgs2(args) {
   let out;
   let noStore = false;
   let noRecall = false;
-  let quiet = false;
+  let quiet2 = false;
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === "--brain") {
@@ -7153,12 +7548,12 @@ function parseArgs2(args) {
       continue;
     }
     if (a === "--quiet") {
-      quiet = true;
+      quiet2 = true;
       continue;
     }
     words2.push(a);
   }
-  return { task: words2.join(" ").trim(), brainId, out, noStore, noRecall, quiet };
+  return { task: words2.join(" ").trim(), brainId, out, noStore, noRecall, quiet: quiet2 };
 }
 async function run(args) {
   const p = parseArgs2(args);
@@ -7203,7 +7598,7 @@ async function run(args) {
   if (p.out) {
     const target = resolve6(process.cwd(), p.out);
     try {
-      writeFileSync15(target, result.text, "utf8");
+      writeFileSync16(target, result.text, "utf8");
       process.stderr.write(c.dim(`saved to ${target}`) + "\n");
     } catch (e) {
       process.stderr.write(c.red(`Could not write ${target}: ${e.message}`) + "\n");
@@ -7214,8 +7609,8 @@ async function run(args) {
 
 // src/commands/schedule.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { writeFileSync as writeFileSync16, mkdirSync as mkdirSync14, rmSync as rmSync6, existsSync as existsSync17 } from "fs";
-import { dirname as dirname8 } from "path";
+import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync15, rmSync as rmSync7, existsSync as existsSync18 } from "fs";
+import { dirname as dirname9 } from "path";
 function parseAdd(rest) {
   const positional = [];
   const opts = { notify: false };
@@ -7238,8 +7633,8 @@ function parseAdd(rest) {
 }
 function installDarwin(job, holtPath) {
   const path = plistPath(job.id);
-  mkdirSync14(dirname8(path), { recursive: true });
-  writeFileSync16(path, buildLaunchdPlist(job, holtPath), "utf8");
+  mkdirSync15(dirname9(path), { recursive: true });
+  writeFileSync17(path, buildLaunchdPlist(job, holtPath), "utf8");
   const res = spawnSync5("launchctl", ["load", "-w", path], { encoding: "utf8" });
   if (res.status === 0) {
     console.log(c.green("  Loaded into launchd."));
@@ -7327,10 +7722,10 @@ function listCmd2() {
 }
 function removeDarwin(id) {
   const path = plistPath(id);
-  if (existsSync17(path)) {
+  if (existsSync18(path)) {
     spawnSync5("launchctl", ["unload", path], { encoding: "utf8" });
     try {
-      rmSync6(path);
+      rmSync7(path);
     } catch {
     }
   }
@@ -7390,29 +7785,29 @@ async function schedule(sub, rest = []) {
 
 // src/commands/routine.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { writeFileSync as writeFileSync18, mkdirSync as mkdirSync16, rmSync as rmSync7, existsSync as existsSync18 } from "fs";
-import { dirname as dirname9, resolve as resolve7 } from "path";
+import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync17, rmSync as rmSync8, existsSync as existsSync19 } from "fs";
+import { dirname as dirname10, resolve as resolve7 } from "path";
 
 // src/routines.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync17, mkdirSync as mkdirSync15 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16 } from "fs";
+import { join as join19 } from "path";
 function sanitizeRoutineName(name) {
   return (name || "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
 }
 function routinesPath() {
-  return join18(GLOBAL_DIR, "routines.json");
+  return join19(GLOBAL_DIR, "routines.json");
 }
 function loadRoutines() {
   try {
-    const raw = JSON.parse(readFileSync18(routinesPath(), "utf8"));
+    const raw = JSON.parse(readFileSync19(routinesPath(), "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function saveRoutines(routines) {
-  mkdirSync15(GLOBAL_DIR, { recursive: true });
-  writeFileSync17(routinesPath(), JSON.stringify(routines, null, 2) + "\n", "utf8");
+  mkdirSync16(GLOBAL_DIR, { recursive: true });
+  writeFileSync18(routinesPath(), JSON.stringify(routines, null, 2) + "\n", "utf8");
 }
 function findRoutine(name) {
   const want = sanitizeRoutineName(name);
@@ -7472,8 +7867,8 @@ function routineJobId(name) {
 }
 function installDarwin2(job, holtPath) {
   const path = plistPath(job.id);
-  mkdirSync16(dirname9(path), { recursive: true });
-  writeFileSync18(path, buildLaunchdPlist(job, holtPath), "utf8");
+  mkdirSync17(dirname10(path), { recursive: true });
+  writeFileSync19(path, buildLaunchdPlist(job, holtPath), "utf8");
   const res = spawnSync6("launchctl", ["load", "-w", path], { encoding: "utf8" });
   if (res.status === 0) {
     console.log(c.green("  Loaded into launchd."));
@@ -7517,10 +7912,10 @@ function installSchedule(r) {
 }
 function removeScheduleDarwin(id) {
   const path = plistPath(id);
-  if (existsSync18(path)) {
+  if (existsSync19(path)) {
     spawnSync6("launchctl", ["unload", path], { encoding: "utf8" });
     try {
-      rmSync7(path);
+      rmSync8(path);
     } catch {
     }
   }
@@ -7648,7 +8043,7 @@ function buildRoutinePrompt(r) {
   return { prompt };
 }
 async function runCmd(rest) {
-  let quiet = false;
+  let quiet2 = false;
   let outOverride;
   let notifyOverride = false;
   let brainOverride;
@@ -7656,7 +8051,7 @@ async function runCmd(rest) {
   for (let i = 0; i < rest.length; i++) {
     const a = rest[i];
     if (a === void 0) continue;
-    if (a === "--quiet") quiet = true;
+    if (a === "--quiet") quiet2 = true;
     else if (a === "--notify") notifyOverride = true;
     else if (a === "--out") outOverride = rest[++i];
     else if (a === "--brain") brainOverride = rest[++i];
@@ -7697,7 +8092,7 @@ async function runCmd(rest) {
   let streamed = false;
   const result = await runTask(built.prompt, {
     ...brainId ? { brainId } : {},
-    onChunk: quiet ? void 0 : (ch) => {
+    onChunk: quiet2 ? void 0 : (ch) => {
       streamed = true;
       process.stdout.write(ch);
     }
@@ -7708,13 +8103,13 @@ async function runCmd(rest) {
     process.exitCode = 1;
     return;
   }
-  if (!quiet && !streamed) process.stdout.write(result.text);
-  if (!quiet && (streamed || result.text) && !result.text.endsWith("\n")) process.stdout.write("\n");
+  if (!quiet2 && !streamed) process.stdout.write(result.text);
+  if (!quiet2 && (streamed || result.text) && !result.text.endsWith("\n")) process.stdout.write("\n");
   if (outTarget) {
     const target = resolve7(routine2.workspace, outTarget);
     try {
-      writeFileSync18(target, result.text, "utf8");
-      if (!quiet) process.stderr.write(c.dim(`saved to ${target}`) + "\n");
+      writeFileSync19(target, result.text, "utf8");
+      if (!quiet2) process.stderr.write(c.dim(`saved to ${target}`) + "\n");
     } catch (e) {
       process.stderr.write(c.red(`Could not write ${target}: ${e.message}`) + "\n");
       process.exitCode = 1;
@@ -7851,7 +8246,7 @@ async function routine(sub, rest = []) {
 }
 
 // src/commands/notify.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 async function notify(args) {
   const nonFlag = args.filter((a) => a !== "-" && !a.startsWith("--"));
   const wantsStdin = args.includes("-") || !process.stdin.isTTY;
@@ -7884,12 +8279,16 @@ async function notify(args) {
 }
 function readStdin3() {
   try {
-    return readFileSync19(0, "utf8");
+    return readFileSync20(0, "utf8");
   } catch {
     return "";
   }
 }
 
+// src/commands/doctor.ts
+import { spawn as spawn5, spawnSync as spawnSync7 } from "child_process";
+import { existsSync as existsSync20 } from "fs";
+
 // src/specs.ts
 import os from "os";
 var BYTES_PER_GB = 1024 ** 3;
@@ -8009,10 +8408,63 @@ function good(text) {
 function warn(text) {
   console.log("  " + c.red(text));
 }
-async function doctor() {
+async function ollamaTags() {
+  const url = process.env.HOLT_OLLAMA_URL || "http://127.0.0.1:11434";
+  try {
+    const res = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(1500) });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return (data.models ?? []).map((m) => String(m.name ?? ""));
+  } catch {
+    return null;
+  }
+}
+async function fixSemanticMemory(fixed) {
+  let tags = await ollamaTags();
+  if (tags === null) {
+    if (!isInstalled("ollama")) {
+      note("Ollama is not installed, so there is nothing to start.");
+      note(
+        process.platform === "darwin" ? 'Install it with: brew install ollama   (then run "holt doctor --fix" again)' : 'Install it from https://ollama.com/download, then run "holt doctor --fix" again.'
+      );
+      return false;
+    }
+    note("Ollama is installed but not running. Starting it...");
+    try {
+      const child = spawn5("ollama", ["serve"], { detached: true, stdio: "ignore" });
+      child.unref();
+    } catch {
+      warn('Could not start Ollama. Start it yourself (open the Ollama app or run "ollama serve").');
+      return false;
+    }
+    for (let i = 0; i < 16 && tags === null; i++) {
+      await new Promise((r) => setTimeout(r, 500));
+      tags = await ollamaTags();
+    }
+    if (tags === null) {
+      warn('Ollama did not come up. Open the Ollama app once, then run "holt doctor --fix" again.');
+      return false;
+    }
+    fixed.push("Started the Ollama daemon.");
+  }
+  if (!tags.some((t) => t.startsWith(EMBED_MODEL))) {
+    note(`The "${EMBED_MODEL}" model is missing. Downloading it (one-time, ~275 MB)...`);
+    const r = spawnSync7("ollama", ["pull", EMBED_MODEL], { stdio: "inherit" });
+    if (r.status !== 0) {
+      warn(`Could not download ${EMBED_MODEL}. Check your internet connection and retry.`);
+      return false;
+    }
+    fixed.push(`Downloaded the "${EMBED_MODEL}" model.`);
+  }
+  resetEmbedProbe();
+  return embeddingsAvailable();
+}
+async function doctor(args = []) {
+  const fix = args.includes("--fix");
+  const fixed = [];
   const specs = detect();
   const steps = [];
-  console.log("\n" + c.bold("Holt doctor") + c.dim("  a look at this machine and how best to run Holt on it"));
+  console.log("\n" + c.bold("Holt doctor") + c.dim(" \xB7 a look at this machine and how best to run Holt on it"));
   header("Machine");
   row("platform", `${specs.platform} / ${specs.arch}`);
   row("cpu", `${specs.cpuModel}${specs.cpuCount ? `  (${specs.cpuCount} cores)` : ""}`);
@@ -8049,13 +8501,29 @@ async function doctor() {
   } catch {
     embedOk = false;
   }
+  if (!embedOk && fix) {
+    embedOk = await fixSemanticMemory(fixed);
+  }
   if (embedOk) {
     good(`Ollama reachable and "${EMBED_MODEL}" is present. Memory recall is semantic, private, and local.`);
+    if (fix && existsSync20(wsHoltDir())) {
+      const missing = loadTurns().filter((t) => !Array.isArray(t.emb)).length;
+      if (missing > 0) {
+        note(`${missing} memories in this folder lack embeddings. Upgrading them...`);
+        const r = await backfillEmbeddings((done, total) => {
+          process.stdout.write(`\r  embedding ${done}/${total}...`);
+        });
+        console.log("");
+        if (r.embedded > 0) fixed.push(`Upgraded ${r.embedded} memories to semantic recall.`);
+      }
+    }
   } else {
     note(`Ollama with "${EMBED_MODEL}" not reachable at ${OLLAMA_URL3}.`);
     note("Without it, Holt still remembers, but recall falls back to keyword match.");
-    warn(`Recommendation: enable local embeddings. Install Ollama, then: ollama pull ${EMBED_MODEL}`);
-    steps.push(`Enable semantic memory: ollama pull ${EMBED_MODEL}`);
+    if (!fix) {
+      warn('Recommendation: run "holt doctor --fix" to set this up automatically.');
+      steps.push("Enable semantic memory: holt doctor --fix");
+    }
   }
   header("Knowledge wiki maintainer");
   const rec = recommendLocalModel2(specs.totalRamGB);
@@ -8081,6 +8549,12 @@ async function doctor() {
   }
   note("Hosting tip: a low-power always-on machine (an old laptop, a Pi) is ideal for the bot and scheduled runs.");
   note("Heavy local models want more RAM, so keep those on your bigger machine and let the small box relay.");
+  if (fix) {
+    header("Repairs");
+    if (lastConfigRepair) fixed.push(`Moved a damaged settings file aside (${lastConfigRepair}).`);
+    if (fixed.length === 0) good("Nothing needed repair.");
+    else for (const f of fixed) good(f);
+  }
   header("Recommended next steps");
   if (!cfg) {
     steps.unshift('Set up this folder: run "holt init".');
@@ -8094,8 +8568,167 @@ async function doctor() {
   console.log("");
 }
 
+// src/commands/tour.ts
+function step(n, title) {
+  console.log("\n" + c.accent(`Step ${n} of 3`) + c.bold(`  ${title}`));
+}
+async function tour() {
+  const { ask, close } = createReader();
+  try {
+    if (!await ensureTrusted(ask)) return;
+    const cfg = loadConfig();
+    if (!cfg || !cfg.defaultBrain) {
+      console.log(c.dim('\n  This folder is not set up yet. Run "holt" once, then come back for the tour.\n'));
+      return;
+    }
+    console.log("\n" + c.bold("Welcome. This takes two minutes and shows you the one thing that matters."));
+    step(1, "Ask about your files");
+    console.log(c.dim("  Holt reads the folder it runs in. Asking it what it sees here...\n"));
+    const r = await runTask(
+      "Look at the files in this folder and describe, in two short plain sentences, what this folder seems to be about. If it is empty or nearly empty, say that cheerfully.",
+      { store: false, onChunk: (t) => process.stdout.write(t) }
+    );
+    if (!r.ok) {
+      console.log(c.dim("  (Your brain is not reachable right now, so we will skip this step. The next two work offline.)"));
+      if (r.text) console.log(c.dim(`  ${r.text.trim()}`));
+    }
+    console.log("");
+    step(2, "Teach Holt one thing about you");
+    console.log(c.dim('  Type one fact you want Holt to keep. Examples: "I run a bakery in Pune",'));
+    console.log(c.dim('  "My big project this quarter is the Delhi launch", "I hate long emails".\n'));
+    let fact = (await ask("  Your fact: ") ?? "").trim();
+    if (!fact) fact = "I just finished the Holt tour.";
+    const session = newSessionId();
+    await saveFact(fact, session);
+    console.log(c.green("\n  Kept.") + c.dim("  That went into this folder\u2019s memory, on this laptop, nowhere else."));
+    step(3, "Watch it remember");
+    console.log(c.dim('  Asking Holt\u2019s memory: "what do you know about me?"...\n'));
+    const hits = await recall("what do you know about me? who am I? my work", "__tour__", 4);
+    const shown = hits.filter((h) => h.turn.content.trim().length > 0).slice(0, 3);
+    if (shown.length === 0) {
+      console.log("  " + c.accent("remembered") + `  ${fact}`);
+    } else {
+      for (const h of shown) {
+        console.log("  " + c.accent("remembered") + `  ${h.turn.content.slice(0, 110).replace(/\s+/g, " ")}`);
+      }
+    }
+    const s = memStats();
+    console.log(
+      "\n" + c.bold("  Here is the point: ") + `close this terminal. Come back tomorrow, or next month, and ask again.
+  Still there. This folder now holds ${s.turns} memor${s.turns === 1 ? "y" : "ies"}, and every chat adds more.
+`
+    );
+    console.log(c.dim('  Next: run "holt" to start a real conversation, or "holt help" to see everything it does.\n'));
+  } finally {
+    close();
+  }
+}
+
+// src/commands/reset.ts
+import { existsSync as existsSync21, rmSync as rmSync9 } from "fs";
+async function reset() {
+  const { ask, close } = createReader();
+  try {
+    const dir = wsHoltDir();
+    if (!existsSync21(dir)) {
+      console.log(c.dim("\n  Nothing to reset: Holt has no settings or memory in this folder.\n"));
+      return;
+    }
+    let turns = 0;
+    try {
+      turns = memStats().turns;
+    } catch {
+    }
+    console.log("\n" + c.bold("Reset Holt in this folder"));
+    console.log(c.dim(`  Folder: ${workspace()}`));
+    console.log(c.dim(`  This deletes Holt's settings and all ${turns} remembered moment${turns === 1 ? "" : "s"} here.`));
+    console.log(c.dim("  Your own files are not touched. Other folders are not touched."));
+    const a = (await ask(`
+  Type ${c.bold("reset")} to confirm, or press enter to cancel: `) ?? "").trim().toLowerCase();
+    if (a !== "reset") {
+      console.log(c.dim("  Cancelled. Nothing was changed.\n"));
+      return;
+    }
+    rmSync9(dir, { recursive: true, force: true });
+    console.log(c.green("\n  Done. This folder is a clean slate.") + c.dim('  Run "holt" to set it up again.\n'));
+  } finally {
+    close();
+  }
+}
+
+// src/commands/update.ts
+import { spawnSync as spawnSync8 } from "child_process";
+import { realpathSync as realpathSync4 } from "fs";
+async function latestVersion() {
+  try {
+    const res = await fetch("https://registry.npmjs.org/@holt-os/holt/latest", {
+      signal: AbortSignal.timeout(4e3)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+function isBrewInstall() {
+  try {
+    const p = realpathSync4(process.argv[1] ?? "");
+    return p.includes("/Cellar/") || p.includes("/homebrew/") || p.includes("/linuxbrew/");
+  } catch {
+    return false;
+  }
+}
+async function update() {
+  const { ask, close } = createReader();
+  try {
+    console.log(c.dim(`
+  You have holt ${VERSION}. Checking for a newer one...`));
+    const latest = await latestVersion();
+    if (!latest) {
+      console.log(c.dim("  Could not reach the registry. Check your internet connection and try again.\n"));
+      return;
+    }
+    if (latest === VERSION) {
+      console.log(c.green(`  You are on the latest version (${VERSION}).`) + "\n");
+      return;
+    }
+    console.log(`  Newer version available: ${c.bold(latest)}`);
+    if (isBrewInstall()) {
+      const a2 = (await ask("  Update now via Homebrew? [Y/n] ") ?? "").trim().toLowerCase();
+      if (a2 === "n" || a2 === "no") {
+        console.log(c.dim("  Later, then. The command is: brew upgrade holt\n"));
+        return;
+      }
+      const r2 = spawnSync8("brew", ["upgrade", "holt"], { stdio: "inherit" });
+      if (r2.status === 0) console.log(c.green(`
+  Updated to ${latest}.`) + "\n");
+      else console.log(c.dim("\n  Homebrew reported a problem above. You can retry with: brew upgrade holt\n"));
+      return;
+    }
+    const a = (await ask("  Update now? [Y/n] ") ?? "").trim().toLowerCase();
+    if (a === "n" || a === "no") {
+      console.log(c.dim("  Later, then. The command is: npm install -g @holt-os/holt\n"));
+      return;
+    }
+    const r = spawnSync8("npm", ["install", "-g", "@holt-os/holt"], { stdio: "inherit" });
+    if (r.status === 0) {
+      console.log(c.green(`
+  Updated to ${latest}.`) + "\n");
+    } else {
+      console.log(
+        c.dim(
+          "\n  The install hit a permission problem. Two easy ways out:\n    1. Run it once with sudo: sudo npm install -g @holt-os/holt\n    2. Or install Node with nvm (https://nvm.sh) so no sudo is ever needed.\n"
+        )
+      );
+    }
+  } finally {
+    close();
+  }
+}
+
 // src/commands/write.ts
-import { writeFileSync as writeFileSync19 } from "fs";
+import { writeFileSync as writeFileSync20 } from "fs";
 import { resolve as resolve8 } from "path";
 
 // src/antiai.ts
@@ -8276,7 +8909,7 @@ async function write(args) {
   if (p.out) {
     const target = resolve8(process.cwd(), p.out);
     try {
-      writeFileSync19(target, draft + "\n", "utf8");
+      writeFileSync20(target, draft + "\n", "utf8");
       process.stderr.write(c.dim(`saved to ${target}`) + "\n");
     } catch (e) {
       process.stderr.write(c.red(`Could not write ${target}: ${e.message}`) + "\n");
@@ -8285,6 +8918,37 @@ async function write(args) {
   }
 }
 
+// src/crash.ts
+import { mkdirSync as mkdirSync18, appendFileSync as appendFileSync3 } from "fs";
+import { join as join20 } from "path";
+function handleCrash(err2) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  const detail = err2 instanceof Error ? err2.stack || err2.message : String(err2);
+  let logPath2 = null;
+  const entry = `[${stamp}] holt ${VERSION}  argv: ${process.argv.slice(2).join(" ")}
+${detail}
+
+`;
+  for (const base of [wsHoltDir(), GLOBAL_DIR]) {
+    try {
+      const dir = join20(base, "logs");
+      mkdirSync18(dir, { recursive: true });
+      const p = join20(dir, `crash-${stamp.slice(0, 10)}.log`);
+      appendFileSync3(p, entry, "utf8");
+      logPath2 = p;
+      break;
+    } catch {
+    }
+  }
+  if (!isQuietMode()) {
+    console.error(c.red("\n  Something went wrong, and it is not your fault."));
+    if (logPath2) console.error(c.dim(`  Details saved to: ${logPath2}`));
+    console.error(c.dim("  Try: holt doctor --fix   (it repairs the common causes)"));
+    console.error(c.dim("  Still stuck? https://github.com/holt-os/holt/issues\n"));
+  }
+  process.exit(1);
+}
+
 // src/cli.ts
 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
@@ -8298,40 +8962,53 @@ var BANNER = `
 var HELP = `${BANNER}
 Usage: holt <command>
 
-Commands:
-  (no command)    Start your assistant: sets up if needed, then launches the real
-                  interactive brain (Claude Code, Codex, Gemini), branded as Holt
-  init            Trust this folder, choose and install brains, sign in, set defaults
-  launch          Same as bare "holt": start your assistant
-  chat            Lightweight REPL that remembers past sessions (used for API brains)
-  run <task>      Run one task non-interactively: recall, brain executes, remember
-  schedule        Fire "holt run" on a timer: holt schedule [add | list | remove]
-  routine         Named, reusable, scheduled jobs: holt routine [add | run | list | remove]
-  telegram        Chat with Holt from your phone: holt telegram [setup]
-  notify [msg]    Push a message to your phone over Telegram (stdin-friendly)
-  voice           Teach Holt how you write: holt voice [add <file> | show | edit | clear]
+Start here:
+  (no command)    Start your assistant: sets up if needed, then launches your
+                  brain (Claude Code, Codex, Gemini), branded as Holt
+  tour            A 2-minute guided first run: ask, teach it one fact, watch it remember
+  doctor          Health check for this machine
+                  ("holt doctor --fix" also repairs the common problems for you)
+
+Every day:
+  run <task>      Do one task and remember it: holt run "draft my status update"
   write <what>    Draft content in your voice, with anti-AI checks: holt write "..." [--type]
-  memory          Inspect memory: holt memory [search <query> | embed | clear]
-  wiki            Your derived knowledge wiki: holt wiki [sync | rebuild | lint | list | show]
-  graph           See your memory as an interactive knowledge graph in the browser
-  skill           Manage skills: holt skill [list | show | create | add | remove]
-  doctor          Check this machine and recommend how best to run Holt here
-  mcp             Serve this folder's memory to Claude Code, Cursor, Codex (holt mcp setup)
-  hook            Ambient memory for Claude Code: holt hook [install | remove | status]
-  setting         Configure brains, API brains, and your launch command (per folder)
+  voice           Teach Holt how you write: holt voice [add <file> | show | edit | clear]
+  memory          What Holt knows here: holt memory [search <q> | facts | embed | clear]
+  wiki            A tidy, linked notebook Holt keeps from your memory: holt wiki [sync | show]
+  graph           See everything Holt knows as a visual map in your browser
+  skill           Reusable how-tos you can share: holt skill [list | show | create | add]
+
+From your phone, while you sleep:
+  telegram        Chat with Holt from your phone: holt telegram setup
+  notify [msg]    Send yourself a phone message from any script (stdin-friendly)
+  schedule        Run a task on a timer: holt schedule [add | list | remove]
+  routine         Named, reusable, scheduled jobs: holt routine [add | run | list | remove]
+
+Housekeeping:
+  setting         Change brains, API connections, and your launch word (per folder)
   login <brain>   Sign in to a brain: claude, codex, or gemini
-  version         Print the Holt version
-  help            Show this help (bare "holt" starts your assistant, not this)
+  update          Get the latest Holt, in one word
+  reset           Start this folder over (asks first; your own files are untouched)
+  hook            Ambient memory inside plain Claude Code: holt hook [install | status]
+  mcp             Share Holt's memory with other AI apps (Claude Code, Cursor, Codex)
+  chat            Lightweight built-in chat, used for API brains
+  init            Full setup by hand (bare "holt" runs this for you when needed)
+  launch          Same as bare "holt": start your assistant
+  version | help  Print the version / show this help
 
 Holt runs in the folder you launch it from and asks to trust it first.
-Brains are agent CLIs on your machine (claude, codex, gemini) or direct
-API connections you add in settings.
+A "brain" is the AI doing the thinking: an agent CLI on your machine
+(claude, codex, gemini) or a direct API connection you add in settings.
 
 Docs: https://productsdecoded.com/holt
 Repo: https://github.com/holt-os/holt
 `;
 async function main() {
   const cmd = process.argv[2];
+  const sub = process.argv[3];
+  if (cmd === "statusline" || cmd === "mcp" || cmd === "notify" || cmd === "hook" && (sub === "inject" || sub === "capture")) {
+    setQuietMode(true);
+  }
   switch (cmd) {
     case void 0:
       await launch();
@@ -8400,7 +9077,16 @@ async function main() {
       await notify(process.argv.slice(3));
       break;
     case "doctor":
-      await doctor();
+      await doctor(process.argv.slice(3));
+      break;
+    case "tour":
+      await tour();
+      break;
+    case "reset":
+      await reset();
+      break;
+    case "update":
+      await update();
       break;
     case "voice":
       await voice(process.argv[3], process.argv.slice(4));
@@ -8416,4 +9102,6 @@ async function main() {
       process.exitCode = 1;
   }
 }
-main();
+process.on("uncaughtException", handleCrash);
+process.on("unhandledRejection", handleCrash);
+main().catch(handleCrash);