@holt-os/holt 0.8.4 → 0.10.0

package/dist/cli.js

@@ -41,11 +41,11 @@ function createReader() {
     closed = true;
     while (waiters.length) waiters.shift()(null);
   });
-  const ask = (q) => new Promise((resolve4) => {
+  const ask = (q) => new Promise((resolve8) => {
     if (q) process.stdout.write(q);
-    if (buffer.length) resolve4(buffer.shift());
-    else if (closed) resolve4(null);
-    else waiters.push(resolve4);
+    if (buffer.length) resolve8(buffer.shift());
+    else if (closed) resolve8(null);
+    else waiters.push(resolve8);
   });
   return { ask, close: () => rl.close() };
 }
@@ -98,6 +98,7 @@ function ensureWsDir() {
 }
 
 // src/config.ts
+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"] },
@@ -126,7 +127,15 @@ function defaultConfig() {
     const d = BRAIN_DEFS[id];
     brains[id] = { id, label: d.label, command: d.command, args: [...d.args], enabled: false };
   }
-  return { version: 4, defaultBrain: null, brains, apiBrains: [], outputFormat: "markdown", memory: { extractFacts: true } };
+  return {
+    version: 5,
+    defaultBrain: null,
+    brains,
+    apiBrains: [],
+    outputFormat: "markdown",
+    memory: { extractFacts: true },
+    wiki: { maintainer: "brain", localModel: WIKI_DEFAULT_LOCAL_MODEL }
+  };
 }
 function loadConfig() {
   const path = wsConfigPath();
@@ -136,15 +145,22 @@ function loadConfig() {
     const base = defaultConfig();
     const brains = cfg.brains ?? {};
     for (const id of BRAIN_IDS) if (!brains[id]) brains[id] = base.brains[id];
+    const wikiIn = cfg.wiki ?? {};
+    const wiki = {
+      maintainer: wikiIn.maintainer === "local" ? "local" : "brain",
+      localModel: typeof wikiIn.localModel === "string" && wikiIn.localModel.trim() ? wikiIn.localModel.trim() : WIKI_DEFAULT_LOCAL_MODEL,
+      ...typeof wikiIn.autoSync === "boolean" ? { autoSync: wikiIn.autoSync } : {}
+    };
     return {
-      version: 4,
+      version: 5,
       defaultBrain: cfg.defaultBrain ?? null,
       brains,
       apiBrains: Array.isArray(cfg.apiBrains) ? cfg.apiBrains : [],
       outputFormat: cfg.outputFormat === "html" ? "html" : "markdown",
       memory: {
         extractFacts: cfg.memory && typeof cfg.memory.extractFacts === "boolean" ? cfg.memory.extractFacts : true
-      }
+      },
+      wiki
     };
   } catch {
     return null;
@@ -227,12 +243,12 @@ function renderPrompt(history, message, memory = []) {
   return parts.join("\n");
 }
 function runBrain(brain, prompt, onChunk) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve8) => {
     let child;
     try {
       child = spawn(brain.command, [...brain.args, prompt], { stdio: ["ignore", "pipe", "pipe"] });
     } catch (e) {
-      resolve4({ ok: false, text: `Could not launch "${brain.command}": ${e.message}` });
+      resolve8({ ok: false, text: `Could not launch "${brain.command}": ${e.message}` });
       return;
     }
     let out = "";
@@ -245,11 +261,11 @@ function runBrain(brain, prompt, onChunk) {
     child.stderr.on("data", (d) => {
       err2 += d.toString();
     });
-    child.on("error", (e) => resolve4({ ok: false, text: `Could not run "${brain.command}": ${e.message}` }));
+    child.on("error", (e) => resolve8({ ok: false, text: `Could not run "${brain.command}": ${e.message}` }));
     child.on("close", (code) => {
       const text = out.trim();
-      if (code === 0 && text) resolve4({ ok: true, text });
-      else resolve4({ ok: false, text: err2.trim() || text || `"${brain.command}" exited with code ${code}` });
+      if (code === 0 && text) resolve8({ ok: true, text });
+      else resolve8({ ok: false, text: err2.trim() || text || `"${brain.command}" exited with code ${code}` });
     });
   });
 }
@@ -419,16 +435,16 @@ function currentAlias() {
 // src/install.ts
 import { spawn as spawn2 } from "child_process";
 function runInteractive(cmd, args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve8) => {
     let child;
     try {
       child = spawn2(cmd, args, { stdio: "inherit" });
     } catch {
-      resolve4(-1);
+      resolve8(-1);
       return;
     }
-    child.on("error", () => resolve4(-1));
-    child.on("close", (code) => resolve4(code ?? -1));
+    child.on("error", () => resolve8(-1));
+    child.on("close", (code) => resolve8(code ?? -1));
   });
 }
 
@@ -498,6 +514,13 @@ function loadTurns() {
 function appendTurn(t) {
   mkdirSync4(memDir(), { recursive: true });
   appendFileSync(memPath(), JSON.stringify(t) + "\n", "utf8");
+  if (t.role === "fact") {
+    try {
+      const ws = workspace();
+      if (isGlobalEnabled(ws)) appendGlobalFact(t, ws);
+    } catch {
+    }
+  }
 }
 function clearMemory() {
   if (existsSync4(memPath())) rmSync2(memPath());
@@ -556,6 +579,117 @@ function memStats() {
   const bytes = existsSync4(memPath()) ? statSync(memPath()).size : 0;
   return { turns: turns.length, facts, sessions, withEmbeddings, bytes };
 }
+function globalMemDir() {
+  return join4(GLOBAL_DIR, "global");
+}
+function globalMemPath() {
+  return join4(globalMemDir(), "turns.jsonl");
+}
+function memoryScopesPath() {
+  return join4(GLOBAL_DIR, "memory-scopes.json");
+}
+function readScopes() {
+  try {
+    const raw = JSON.parse(readFileSync4(memoryScopesPath(), "utf8"));
+    return { enabled: Array.isArray(raw.enabled) ? raw.enabled.filter((s) => typeof s === "string") : [] };
+  } catch {
+    return { enabled: [] };
+  }
+}
+function writeScopes(s) {
+  mkdirSync4(GLOBAL_DIR, { recursive: true });
+  writeFileSync4(memoryScopesPath(), JSON.stringify({ enabled: s.enabled }, null, 2) + "\n", "utf8");
+}
+function isGlobalEnabled(ws = workspace()) {
+  try {
+    return readScopes().enabled.includes(ws);
+  } catch {
+    return false;
+  }
+}
+function globalWorkspaces() {
+  return readScopes().enabled.slice();
+}
+function loadGlobalFacts() {
+  try {
+    if (!existsSync4(globalMemPath())) return [];
+    const out = [];
+    for (const line of readFileSync4(globalMemPath(), "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const row2 = JSON.parse(line);
+        if (row2 && typeof row2.content === "string" && typeof row2.workspace === "string") out.push(row2);
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function appendGlobalFact(t, ws) {
+  try {
+    const norm2 = normalizeFact(t.content);
+    for (const g of loadGlobalFacts()) {
+      if (g.workspace === ws && normalizeFact(g.content) === norm2) return false;
+    }
+    mkdirSync4(globalMemDir(), { recursive: true });
+    const row2 = {
+      id: t.id,
+      ts: t.ts,
+      session: t.session,
+      role: "fact",
+      content: t.content,
+      workspace: ws,
+      ...Array.isArray(t.emb) ? { emb: t.emb } : {}
+    };
+    appendFileSync(globalMemPath(), JSON.stringify(row2) + "\n", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function enableGlobal(ws = workspace()) {
+  const s = readScopes();
+  if (!s.enabled.includes(ws)) {
+    s.enabled.push(ws);
+    writeScopes(s);
+  }
+  let added = 0;
+  for (const t of loadTurns()) {
+    if (t.role === "fact" && appendGlobalFact(t, ws)) added++;
+  }
+  return added;
+}
+function disableGlobal(ws = workspace(), purge = false) {
+  const s = readScopes();
+  const next = s.enabled.filter((w) => w !== ws);
+  if (next.length !== s.enabled.length) writeScopes({ enabled: next });
+  if (!purge) return { purged: 0 };
+  try {
+    const all = loadGlobalFacts();
+    const kept = all.filter((g) => g.workspace !== ws);
+    const purged = all.length - kept.length;
+    if (purged > 0) {
+      mkdirSync4(globalMemDir(), { recursive: true });
+      writeFileSync4(globalMemPath(), kept.map((g) => JSON.stringify(g)).join("\n") + (kept.length ? "\n" : ""), "utf8");
+    }
+    return { purged };
+  } catch {
+    return { purged: 0 };
+  }
+}
+function globalStats() {
+  const rows = loadGlobalFacts();
+  const workspaces = new Set(rows.map((r) => r.workspace)).size;
+  let bytes = 0;
+  try {
+    bytes = existsSync4(globalMemPath()) ? statSync(globalMemPath()).size : 0;
+  } catch {
+    bytes = 0;
+  }
+  return { facts: rows.length, workspaces, bytes };
+}
 function cosine(a, b) {
   let dot = 0;
   let na = 0;
@@ -583,21 +717,39 @@ function keywordScore(q, text) {
   return hit / q.size;
 }
 var FACT_BOOST = 1.15;
+function scoreRow(content, emb, role, qEmb, qTok) {
+  const useEmb = qEmb && Array.isArray(emb);
+  let score = useEmb ? cosine(qEmb, emb) : keywordScore(qTok, content);
+  if (score > (useEmb ? 0.35 : 0.15)) {
+    if (role === "fact") score *= FACT_BOOST;
+    return score;
+  }
+  return null;
+}
 async function recall(query, currentSession, k = 4) {
+  const ws = workspace();
   const past = loadTurns().filter((t) => t.session !== currentSession);
-  if (past.length === 0) return [];
   const qEmb = await embed(query);
   const qTok = tokens(query);
   const scored = [];
   for (const turn of past) {
-    let score = 0;
-    if (qEmb && Array.isArray(turn.emb)) score = cosine(qEmb, turn.emb);
-    else score = keywordScore(qTok, turn.content);
-    if (score > (qEmb && Array.isArray(turn.emb) ? 0.35 : 0.15)) {
-      if (turn.role === "fact") score *= FACT_BOOST;
-      scored.push({ turn, score });
+    const score = scoreRow(turn.content, turn.emb, turn.role, qEmb, qTok);
+    if (score !== null) scored.push({ turn, score });
+  }
+  if (isGlobalEnabled(ws)) {
+    for (const g of loadGlobalFacts()) {
+      if (g.workspace === ws) continue;
+      const score = scoreRow(g.content, g.emb, g.role, qEmb, qTok);
+      if (score !== null) {
+        scored.push({
+          turn: { id: g.id, ts: g.ts, session: g.session, role: g.role, content: g.content, emb: g.emb },
+          score,
+          workspace: g.workspace
+        });
+      }
     }
   }
+  if (scored.length === 0) return [];
   scored.sort((a, b) => b.score - a.score);
   return scored.slice(0, k);
 }
@@ -1360,6 +1512,465 @@ async function setting() {
   console.log("");
 }
 
+// src/commands/voice.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { resolve } from "path";
+
+// src/voice.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync7, rmSync as rmSync3 } from "fs";
+import { join as join7 } from "path";
+var VOICE_VERSION = 1;
+function voicePath() {
+  return join7(GLOBAL_DIR, "voice.json");
+}
+function loadVoice() {
+  try {
+    const raw = readFileSync7(voicePath(), "utf8");
+    const p = JSON.parse(raw);
+    return {
+      version: VOICE_VERSION,
+      depth: p.depth === "detailed" ? "detailed" : p.depth === "quick" ? "quick" : void 0,
+      answers: Array.isArray(p.answers) ? p.answers : [],
+      samples: Array.isArray(p.samples) ? p.samples : [],
+      style: p.style ?? void 0,
+      synthesizedAt: typeof p.synthesizedAt === "number" ? p.synthesizedAt : void 0,
+      synthesisNote: typeof p.synthesisNote === "string" ? p.synthesisNote : void 0,
+      updatedAt: typeof p.updatedAt === "number" ? p.updatedAt : Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+function emptyVoice() {
+  return { version: VOICE_VERSION, answers: [], samples: [], updatedAt: Date.now() };
+}
+function saveVoice(v) {
+  try {
+    mkdirSync6(GLOBAL_DIR, { recursive: true });
+    v.version = VOICE_VERSION;
+    v.updatedAt = Date.now();
+    writeFileSync6(voicePath(), JSON.stringify(v, null, 2) + "\n", { encoding: "utf8", mode: 384 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearVoice() {
+  try {
+    if (!existsSync7(voicePath())) return false;
+    writeFileSync6(voicePath(), "{}\n", "utf8");
+    rmSync3(voicePath(), { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var MAX_EXCERPT = 1200;
+function hashText(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 16);
+}
+function makeSample(source, text, keepExcerpt) {
+  const clean = text.replace(/\s+$/g, "");
+  return {
+    source,
+    hash: hashText(clean),
+    length: clean.length,
+    excerpt: keepExcerpt ? clean.slice(0, MAX_EXCERPT) : void 0,
+    storedFull: keepExcerpt,
+    addedAt: Date.now()
+  };
+}
+function resolveDefaultBrain(cfg) {
+  if (!cfg || !cfg.defaultBrain) return null;
+  const id = cfg.defaultBrain;
+  if (BRAIN_IDS.includes(id)) {
+    const b = cfg.brains[id];
+    if (b && b.enabled && isInstalled(b.command)) return { kind: "cli", id };
+    return null;
+  }
+  const api = findApiBrain(cfg, id);
+  if (api && resolveApiKey(api)) return { kind: "api", brain: api };
+  return null;
+}
+async function callBrain(active, cfg, prompt) {
+  try {
+    const res = active.kind === "cli" ? await runBrain(cfg.brains[active.id], prompt) : await runApiBrain(active.brain, prompt);
+    return { ok: res.ok, text: res.text };
+  } catch (e) {
+    return { ok: false, text: e.message };
+  }
+}
+function buildSynthesisPrompt(v) {
+  const answers = v.answers.filter((a) => a.answer.trim()).map((a) => `- ${a.question}
+  ANSWER: ${a.answer.trim()}`).join("\n");
+  const samples = v.samples.map((s, i) => {
+    if (s.excerpt) return `Sample ${i + 1} (${s.source}):
+${s.excerpt}`;
+    return `Sample ${i + 1} (${s.source}): [not stored, ${s.length} chars]`;
+  }).join("\n\n");
+  return [
+    "You are analyzing how a specific person writes so their assistant can draft in their voice.",
+    "From the interview answers and any writing samples below, produce a STYLE PROFILE.",
+    "Focus ONLY on writing and communication style. Do not infer or invent personal facts",
+    "(no name, job, location, or life details), and never add fields beyond the schema.",
+    "",
+    "Output ONLY a JSON object, no prose and no code fences, with these keys:",
+    "{",
+    '  "tone": string,               // e.g. "casual, dry"',
+    '  "formality": number,          // 1 very casual .. 5 very formal',
+    '  "avgSentenceLength": string,  // e.g. "short" or "8-14 words"',
+    '  "person": string,             // "first" | "third" | "mixed"',
+    '  "emoji": string,              // "none" | "rare" | "one per post" ...',
+    '  "formatting": string,         // paragraph, header, and list habits',
+    '  "signatureMoves": string[],   // recurring devices they like',
+    '  "bannedWords": string[],      // words or phrases to avoid',
+    '  "targetAudiences": string[],  // who they write for',
+    '  "soundsLike": string,         // one line: what to sound like',
+    '  "doesNotSoundLike": string    // one line: what to avoid sounding like',
+    "}",
+    "If a value is unknown, use an empty string or empty array. Never guess personal info.",
+    "",
+    answers ? "INTERVIEW ANSWERS:\n" + answers : "INTERVIEW ANSWERS: (none)",
+    "",
+    samples ? "WRITING SAMPLES:\n" + samples : "WRITING SAMPLES: (none)",
+    "",
+    "JSON object:"
+  ].join("\n");
+}
+function parseStyleProfile(raw) {
+  let s = (raw || "").trim();
+  s = s.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/i, "").trim();
+  const start = s.indexOf("{");
+  const end = s.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  let obj;
+  try {
+    obj = JSON.parse(s.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  const str = (x) => typeof x === "string" && x.trim() ? x.trim() : void 0;
+  const arr = (x) => {
+    if (!Array.isArray(x)) return void 0;
+    const out = x.filter((i) => typeof i === "string" && i.trim().length > 0).map((i) => i.trim());
+    return out.length ? out : void 0;
+  };
+  const num = (x) => {
+    const n = typeof x === "number" ? x : typeof x === "string" ? Number(x) : NaN;
+    return Number.isFinite(n) ? Math.max(1, Math.min(5, Math.round(n))) : void 0;
+  };
+  const profile = {
+    tone: str(o["tone"]),
+    formality: num(o["formality"]),
+    avgSentenceLength: str(o["avgSentenceLength"]),
+    person: str(o["person"]),
+    emoji: str(o["emoji"]),
+    formatting: str(o["formatting"]),
+    signatureMoves: arr(o["signatureMoves"]),
+    bannedWords: arr(o["bannedWords"]),
+    targetAudiences: arr(o["targetAudiences"]),
+    soundsLike: str(o["soundsLike"]),
+    doesNotSoundLike: str(o["doesNotSoundLike"])
+  };
+  const any = Object.values(profile).some((v) => v !== void 0);
+  return any ? profile : null;
+}
+async function synthesizeVoice(v) {
+  const cfg = loadConfig();
+  const active = resolveDefaultBrain(cfg);
+  if (!active || !cfg) {
+    v.synthesisNote = 'No brain configured yet. Raw answers and samples are saved; run "holt voice" again once a brain is set to build the style profile.';
+    return v;
+  }
+  const prompt = buildSynthesisPrompt(v);
+  const res = await callBrain(active, cfg, prompt);
+  if (!res.ok) {
+    v.synthesisNote = "Could not reach the brain to synthesize a profile. Raw answers and samples are saved.";
+    return v;
+  }
+  const style = parseStyleProfile(res.text);
+  if (!style) {
+    v.synthesisNote = "The brain reply could not be parsed into a style profile. Raw answers and samples are saved.";
+    return v;
+  }
+  v.style = style;
+  v.synthesizedAt = Date.now();
+  v.synthesisNote = void 0;
+  return v;
+}
+function voicePromptBlock(v) {
+  if (!v) return "";
+  const s = v.style;
+  const lines = [];
+  if (s) {
+    lines.push("VOICE PROFILE (write in this voice):");
+    if (s.tone) lines.push(`- Tone: ${s.tone}`);
+    if (typeof s.formality === "number") lines.push(`- Formality: ${s.formality}/5 (1 casual, 5 formal)`);
+    if (s.avgSentenceLength) lines.push(`- Sentence length: ${s.avgSentenceLength}`);
+    if (s.person) lines.push(`- Person: ${s.person}`);
+    if (s.emoji) lines.push(`- Emoji: ${s.emoji}`);
+    if (s.formatting) lines.push(`- Formatting habits: ${s.formatting}`);
+    if (s.signatureMoves?.length) lines.push(`- Signature moves: ${s.signatureMoves.join("; ")}`);
+    if (s.bannedWords?.length) lines.push(`- Never use: ${s.bannedWords.join(", ")}`);
+    if (s.targetAudiences?.length) lines.push(`- Audience: ${s.targetAudiences.join(", ")}`);
+    if (s.soundsLike) lines.push(`- Should sound like: ${s.soundsLike}`);
+    if (s.doesNotSoundLike) lines.push(`- Should NOT sound like: ${s.doesNotSoundLike}`);
+  }
+  const withExcerpt = v.samples.filter((x) => x.excerpt);
+  if (withExcerpt.length) {
+    lines.push("", "WRITING SAMPLES from this person (match this rhythm, do not copy content):");
+    for (const smp of withExcerpt.slice(0, 2)) {
+      lines.push('"""', (smp.excerpt ?? "").slice(0, 600), '"""');
+    }
+  }
+  if (!s) {
+    const ans = v.answers.filter((a) => a.answer.trim());
+    if (ans.length) {
+      lines.push("", "The person described their writing style as:");
+      for (const a of ans.slice(0, 8)) lines.push(`- ${a.question} ${a.answer.trim()}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/voice.ts
+var QUESTIONS = [
+  { key: "tone", q: "What tone do you want to sound like? (casual / professional / playful / dry, or describe it)", depth: "quick" },
+  { key: "sentences", q: "Short punchy sentences, longer flowing ones, or a mix?", depth: "quick" },
+  { key: "person", q: 'Do you write in first person ("I"), third person, or a mix?', depth: "quick" },
+  { key: "emoji", q: "Emoji: never, rarely, or freely? Any you like or ban?", depth: "quick" },
+  { key: "banned", q: "Any words or phrases you love, and any you never want used?", depth: "quick" },
+  { key: "audience", q: "Who do you usually write for? (e.g. peers, customers, a general audience)", depth: "detailed" },
+  { key: "formatting", q: "Formatting habits: short paragraphs, headers, bullet lists, plain prose?", depth: "detailed" },
+  { key: "soundsLike", q: "Name a writer, publication, or vibe you want to sound like.", depth: "detailed" },
+  { key: "avoid", q: "What do you NOT want to sound like? (e.g. corporate, salesy, robotic)", depth: "detailed" },
+  { key: "signature", q: "Any signature moves? (openings you like, how you end, humor, analogies)", depth: "detailed" }
+];
+async function askDepth(ask) {
+  const a = await ask('Depth? "quick" (a few questions) or "detailed" (more): [quick] ');
+  if (a === null) return null;
+  const s = a.trim().toLowerCase();
+  return s === "detailed" || s === "d" ? "detailed" : "quick";
+}
+async function runQuestions(ask, depth) {
+  const set = QUESTIONS.filter((q) => depth === "detailed" || q.depth === "quick");
+  const out = [];
+  console.log(c.dim("\n  Answer in your own words. Press enter to skip any question.\n"));
+  for (const q of set) {
+    const a = await ask("  " + q.q + "\n  > ");
+    if (a === null) break;
+    out.push({ key: q.key, question: q.q, answer: a.trim() });
+  }
+  return out;
+}
+async function askKeepExcerpt(ask) {
+  const a = (await ask("  Store a short excerpt so Holt can match your tone directly? [y/N] ") ?? "").trim().toLowerCase();
+  return a === "y" || a === "yes";
+}
+async function addFileSample(ask, file, v) {
+  const path = resolve(process.cwd(), file);
+  let text;
+  try {
+    text = readFileSync8(path, "utf8");
+  } catch (e) {
+    console.error(c.red(`  Could not read ${path}: ${e.message}`));
+    return null;
+  }
+  if (!text.trim()) {
+    console.error(c.red(`  ${path} is empty.`));
+    return null;
+  }
+  const keep = ask ? await askKeepExcerpt(ask) : true;
+  v.samples.push(makeSample("file:" + path, text, keep));
+  console.log(c.green(`  Added sample from ${path}`) + c.dim(` (${text.length} chars${keep ? ", excerpt stored" : ", hash only"})`));
+  return v;
+}
+async function pasteSample(ask, v) {
+  console.log(c.dim('  Paste your writing sample. End with a single "." on its own line.'));
+  const lines = [];
+  for (; ; ) {
+    const line = await ask("");
+    if (line === null) break;
+    if (line.trim() === ".") break;
+    lines.push(line);
+  }
+  const text = lines.join("\n").trim();
+  if (!text) {
+    console.log(c.dim("  Nothing pasted, skipping."));
+    return null;
+  }
+  const keep = await askKeepExcerpt(ask);
+  v.samples.push(makeSample("paste", text, keep));
+  console.log(c.green("  Sample added.") + c.dim(` (${text.length} chars${keep ? ", excerpt stored" : ", hash only"})`));
+  return v;
+}
+function printStyle(s) {
+  const row2 = (label, val) => {
+    if (val === void 0 || Array.isArray(val) && val.length === 0) return;
+    const shown = Array.isArray(val) ? val.join(", ") : String(val);
+    console.log(`  ${c.dim(label.padEnd(16))} ${shown}`);
+  };
+  row2("tone", s.tone);
+  row2("formality", typeof s.formality === "number" ? `${s.formality}/5` : void 0);
+  row2("sentence len", s.avgSentenceLength);
+  row2("person", s.person);
+  row2("emoji", s.emoji);
+  row2("formatting", s.formatting);
+  row2("signature", s.signatureMoves);
+  row2("banned", s.bannedWords);
+  row2("audience", s.targetAudiences);
+  row2("sounds like", s.soundsLike);
+  row2("not like", s.doesNotSoundLike);
+}
+function showProfile(v) {
+  console.log("\n" + c.accent("Your writing voice") + c.dim("  (" + voicePath() + ")"));
+  if (v.depth) console.log(c.dim(`  interview depth: ${v.depth}`));
+  console.log(c.dim(`  answers: ${v.answers.filter((a) => a.answer.trim()).length}   samples: ${v.samples.length}`));
+  if (v.style) {
+    console.log("");
+    printStyle(v.style);
+  } else if (v.synthesisNote) {
+    console.log("\n  " + c.dim(v.synthesisNote));
+  } else {
+    console.log("\n  " + c.dim("No synthesized profile yet."));
+  }
+  console.log("");
+}
+var USAGE = [
+  "  holt voice [subcommand]",
+  "",
+  "  (no subcommand)   run the writing-style interview and build your profile",
+  "  add <file>        add a writing sample from a file",
+  "  show              print your voice profile",
+  "  edit              show where voice.json lives (it is human-editable)",
+  "  clear             remove your voice profile",
+  "",
+  "  The interview only asks about writing and communication style.",
+  "  It never asks for personal details. Your profile lives at ~/.holt/voice.json."
+].join("\n");
+async function voice(sub, args = []) {
+  switch (sub) {
+    case "show":
+      return voiceShow();
+    case "add":
+      return voiceAdd(args[0]);
+    case "edit":
+      return voiceEdit();
+    case "clear":
+      return voiceClear();
+    case "help":
+    case "-h":
+    case "--help":
+      console.log(USAGE);
+      return;
+    case void 0:
+      return voiceInterview();
+    default:
+      console.error(c.red(`  Unknown voice subcommand: "${sub}"`));
+      console.log(USAGE);
+      process.exitCode = 1;
+  }
+}
+async function voiceInterview() {
+  const { ask, close } = createReader();
+  const existing = loadVoice();
+  const v = existing ?? emptyVoice();
+  console.log("\n" + c.accent("Teach Holt your writing voice"));
+  console.log(c.dim("  Style only. No personal questions. You can do the interview, share samples, or both.\n"));
+  const mode = (await ask("Do the [i]nterview, add [s]amples, or [b]oth? [i] ") ?? "").trim().toLowerCase();
+  const wantInterview = mode === "" || mode === "i" || mode === "b" || mode === "interview" || mode === "both";
+  const wantSamples = mode === "s" || mode === "b" || mode === "samples" || mode === "both";
+  if (wantInterview) {
+    const depth = await askDepth(ask);
+    if (depth === null) {
+      close();
+      return;
+    }
+    v.depth = depth;
+    const answers = await runQuestions(ask, depth);
+    const askedKeys = new Set(answers.map((a) => a.key));
+    v.answers = [...v.answers.filter((a) => !askedKeys.has(a.key)), ...answers];
+  }
+  if (wantSamples) {
+    for (; ; ) {
+      const how = (await ask("\n  Add a sample from a [f]ile or [p]aste it? (enter to finish): ") ?? "").trim().toLowerCase();
+      if (how === "" || how === "q" || how === "n" || how === "done") break;
+      if (how === "f" || how === "file") {
+        const fp = await ask("  File path: ");
+        if (fp === null) break;
+        if (fp.trim()) await addFileSample(ask, fp.trim(), v);
+      } else if (how === "p" || how === "paste") {
+        await pasteSample(ask, v);
+      } else {
+        console.log(c.dim("  Type f, p, or press enter to finish."));
+      }
+    }
+  }
+  close();
+  saveVoice(v);
+  console.log(c.dim("\n  Building your style profile from a brain..."));
+  const synthed = await synthesizeVoice(v);
+  saveVoice(synthed);
+  if (synthed.style) {
+    console.log(c.green("  Style profile ready."));
+    printStyle(synthed.style);
+  } else if (synthed.synthesisNote) {
+    console.log("  " + c.dim(synthed.synthesisNote));
+  }
+  console.log(c.dim(`
+  Saved to ${voicePath()}`));
+  console.log(c.dim("  Draft in this voice with:  ") + c.accent('holt write "..."') + "\n");
+}
+async function voiceShow() {
+  const v = loadVoice();
+  if (!v) {
+    console.log(c.dim("\n  No voice profile yet. Run ") + c.accent("holt voice") + c.dim(" to create one.\n"));
+    return;
+  }
+  showProfile(v);
+}
+async function voiceAdd(file) {
+  if (!file) {
+    console.log(c.dim("  Usage: holt voice add <file>"));
+    process.exitCode = 1;
+    return;
+  }
+  const v = loadVoice() ?? emptyVoice();
+  const updated = await addFileSample(null, file, v);
+  if (!updated) {
+    process.exitCode = 1;
+    return;
+  }
+  saveVoice(updated);
+  console.log(c.dim("  Refreshing style profile..."));
+  const synthed = await synthesizeVoice(updated);
+  saveVoice(synthed);
+  if (synthed.synthesisNote) console.log("  " + c.dim(synthed.synthesisNote));
+  else console.log(c.green("  Profile updated."));
+}
+async function voiceEdit() {
+  const path = voicePath();
+  const v = loadVoice();
+  if (!v) {
+    console.log(c.dim(`
+  No profile yet. Run "holt voice" first. It will be written to:
+    ${path}
+`));
+    return;
+  }
+  console.log("\n" + c.accent("Your voice profile is a plain JSON file you can edit by hand:"));
+  console.log("  " + path);
+  console.log(c.dim("  Open it in any editor. Keys: answers, samples, style (tone, formality, bannedWords, ...)."));
+  console.log(c.dim('  After hand-editing "answers" or "samples", run "holt voice" to re-synthesize the style.\n'));
+}
+async function voiceClear() {
+  const had = clearVoice();
+  console.log(had ? c.green("\n  Voice profile removed.\n") : c.dim("\n  No voice profile to remove.\n"));
+}
+
 // src/commands/init.ts
 function parseBrains(raw, found) {
   const s = raw.trim().toLowerCase();
@@ -1491,6 +2102,14 @@ Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
   } else {
     console.log(c.dim('No brain is ready yet. Install one, then run "holt init" again.\n'));
   }
+  const voiceReader = createReader();
+  const voiceAns = (await voiceReader.ask("Want Holt to learn how you write, so it can draft in your voice? [y/N] ") ?? "").trim().toLowerCase();
+  voiceReader.close();
+  if (voiceAns === "y" || voiceAns === "yes") {
+    await voiceInterview();
+  } else {
+    console.log(c.dim('  Skipped. Run "holt voice" anytime to set up your writing voice.\n'));
+  }
 }
 
 // src/commands/chat.ts
@@ -1605,60 +2224,574 @@ async function extractAndSaveFacts(active, cfg, history, session) {
   }
 }
 
-// src/output.ts
-import { writeFileSync as writeFileSync6 } from "fs";
-import { join as join7, isAbsolute } 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*?(?:\([^)\s]*\)[^)\s]*)*)\)/g, (_m, label, url) => {
-    const trimmed = url.trim();
-    const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(trimmed);
-    const safeScheme = !scheme || /^(https?|mailto)$/i.test(scheme[1]);
-    if (!safeScheme) return label;
-    const safe = trimmed.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;
+// src/wiki.ts
+import {
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync7,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync7,
+  rmSync as rmSync4,
+  readdirSync as readdirSync2,
+  statSync as statSync3
+} from "fs";
+import { join as join8 } from "path";
+import { totalmem } from "os";
+
+// src/localmodel.ts
+var OLLAMA_URL2 = process.env.HOLT_OLLAMA_URL || "http://127.0.0.1:11434";
+async function localModelStatus(model) {
+  try {
+    const res = await fetch(`${OLLAMA_URL2}/api/tags`, { signal: AbortSignal.timeout(1500) });
+    if (!res.ok) return { reachable: false, hasModel: false };
+    const data = await res.json();
+    const want = model.includes(":") ? model : `${model}:latest`;
+    const hasModel = !!data.models?.some((m) => {
+      const n = m.name || "";
+      return n === model || n === want || n.startsWith(`${model}:`);
+    });
+    return { reachable: true, hasModel };
+  } catch {
+    return { reachable: false, hasModel: false };
+  }
 }
-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;
+async function localGenerate(model, prompt, timeoutMs = 12e4) {
+  let res;
+  try {
+    res = await fetch(`${OLLAMA_URL2}/api/generate`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model, prompt, stream: false }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (e) {
+    return { ok: false, text: `Could not reach local Ollama at ${OLLAMA_URL2}: ${e.message}` };
+  }
+  if (!res.ok) {
+    let body = "";
+    try {
+      body = await res.text();
+    } catch {
     }
-  };
-  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] ?? "");
+    return { ok: false, text: `Ollama error ${res.status}: ${body.slice(0, 200)}` };
+  }
+  try {
+    const data = await res.json();
+    const text = (data.response || "").trim();
+    if (text) return { ok: true, text };
+    return { ok: false, text: "Local model returned an empty reply." };
+  } catch (e) {
+    return { ok: false, text: `Could not parse Ollama reply: ${e.message}` };
+  }
+}
+function pullHint(model) {
+  return `ollama pull ${model}`;
+}
+
+// src/wiki.ts
+function wikiDir() {
+  return join8(wsHoltDir(), "wiki");
+}
+function wikiStatePath() {
+  return join8(wikiDir(), ".state.json");
+}
+function wikiIndexPath() {
+  return join8(wikiDir(), "index.md");
+}
+function pagePath(slug) {
+  return join8(wikiDir(), `${slug}.md`);
+}
+function loadState() {
+  try {
+    const s = JSON.parse(readFileSync9(wikiStatePath(), "utf8"));
+    return { lastSyncTs: typeof s.lastSyncTs === "number" ? s.lastSyncTs : 0, updatedAt: s.updatedAt ?? 0 };
+  } catch {
+    return { lastSyncTs: 0, updatedAt: 0 };
+  }
+}
+function saveState(s) {
+  mkdirSync7(wikiDir(), { recursive: true });
+  writeFileSync7(wikiStatePath(), JSON.stringify(s, null, 2) + "\n", "utf8");
+}
+function saveSyncMarker(ts) {
+  saveState({ lastSyncTs: ts, updatedAt: Date.now() });
+}
+function isPageFile(name) {
+  return name.endsWith(".md") && name !== "index.md";
+}
+function listPageSlugs() {
+  const dir = wikiDir();
+  if (!existsSync8(dir)) return [];
+  try {
+    return readdirSync2(dir).filter(isPageFile).map((f) => f.slice(0, -3)).sort();
+  } catch {
+    return [];
+  }
+}
+function readPage(slug) {
+  const p = pagePath(slug);
+  if (!existsSync8(p)) return null;
+  let raw = "";
+  try {
+    raw = readFileSync9(p, "utf8");
+  } catch {
+    return null;
+  }
+  const { data, body } = parseFrontmatter(raw);
+  return {
+    slug,
+    title: data.title || slug,
+    updated: data.updated || "",
+    sources: parseSources(data.sources),
+    body
+  };
+}
+function loadPages() {
+  const out = [];
+  for (const slug of listPageSlugs()) {
+    const pg = readPage(slug);
+    if (pg) out.push(pg);
+  }
+  return out;
+}
+function parseSources(raw) {
+  if (!raw) return [];
+  return raw.replace(/^\[|\]$/g, "").split(/[\s,]+/).map((s) => s.replace(/^["']|["']$/g, "").trim()).filter(Boolean);
+}
+var PAGE_HEADER_NOTE = "Derived page, maintained by Holt. Safe to edit; a rebuild will regenerate it from facts.";
+function renderPage(pg) {
+  const fm = [
+    "---",
+    `title: ${pg.title}`,
+    `updated: ${pg.updated}`,
+    `sources: ${pg.sources.join(", ")}`,
+    "---",
+    "",
+    `> ${PAGE_HEADER_NOTE}`,
+    "",
+    pg.body.trim(),
+    ""
+  ].join("\n");
+  return fm;
+}
+function writePage(pg) {
+  mkdirSync7(wikiDir(), { recursive: true });
+  writeFileSync7(pagePath(pg.slug), renderPage(pg), "utf8");
+}
+var WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+function extractLinks(body) {
+  const out = [];
+  let m;
+  WIKILINK_RE.lastIndex = 0;
+  while ((m = WIKILINK_RE.exec(body)) !== null) {
+    const target = (m[1] || "").split("|")[0].trim();
+    if (target) out.push(target);
+  }
+  return out;
+}
+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;
+}
+var ROUTE_SIMILARITY_THRESHOLD = 0.55;
+async function pageEmbeddings(pages) {
+  const out = [];
+  for (const page of pages) {
+    const emb = await embed(`${page.title}
+${page.body.slice(0, 1500)}`);
+    if (emb) out.push({ page, emb });
+  }
+  return out;
+}
+async function routeFact(content, targets) {
+  const e = await embed(content);
+  if (!e) {
+    return { kind: targets.length ? "existing" : "new", slug: targets[0]?.page.slug ?? "notes", score: 0 };
+  }
+  let best = null;
+  let bestScore = -1;
+  for (const t of targets) {
+    const s = cosine2(e, t.emb);
+    if (s > bestScore) {
+      bestScore = s;
+      best = t;
+    }
+  }
+  if (best && bestScore >= ROUTE_SIMILARITY_THRESHOLD) {
+    return { kind: "existing", slug: best.page.slug, score: bestScore };
+  }
+  return { kind: "new", slug: proposeSlug(content), score: bestScore < 0 ? 0 : bestScore };
+}
+function proposeSlug(content) {
+  const words2 = content.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !ROUTE_STOPWORDS.has(w)).slice(0, 4);
+  const slug = sanitizeName(words2.join("-"));
+  return slug || "notes";
+}
+var ROUTE_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "that",
+  "this",
+  "with",
+  "from",
+  "for",
+  "was",
+  "are",
+  "has",
+  "have",
+  "will",
+  "user",
+  "their",
+  "they",
+  "about",
+  "into",
+  "per",
+  "via"
+]);
+async function resolveMaintainer(cfg, resolveBrain) {
+  if (cfg.wiki.maintainer === "local") {
+    const model = cfg.wiki.localModel;
+    const status2 = await localModelStatus(model);
+    if (status2.reachable && status2.hasModel) {
+      const m = { kind: "local", model, label: `local (${model})` };
+      return { maintainer: m, report: { maintainer: m, fellBack: false } };
+    }
+    const why = status2.reachable ? `local model "${model}" is not pulled. Run: ${pullHint(model)}` : "local Ollama is not reachable.";
+    const brain2 = resolveBrain();
+    if (brain2) {
+      return {
+        maintainer: brain2,
+        report: { maintainer: brain2, fellBack: true, note: `${why} Falling back to ${brain2.label}.` }
+      };
+    }
+    return { maintainer: null, report: null };
+  }
+  const brain = resolveBrain();
+  if (!brain) return { maintainer: null, report: null };
+  return { maintainer: brain, report: { maintainer: brain, fellBack: false } };
+}
+function resolveBrainMaintainer(cfg) {
+  const id = cfg.defaultBrain;
+  if (!id) return null;
+  if (BRAIN_IDS.includes(id)) {
+    const b = cfg.brains[id];
+    if (!isInstalled(b.command)) return null;
+    return { kind: "cli", id, label: b.label };
+  }
+  const api = findApiBrain(cfg, id);
+  if (api && resolveApiKey(api)) return { kind: "api", brain: api, label: `${id} (api: ${api.provider}/${api.model})` };
+  return null;
+}
+async function runMaintainer(m, cfg, prompt) {
+  if (m.kind === "cli") return runBrain(cfg.brains[m.id], prompt);
+  if (m.kind === "api") return runApiBrain(m.brain, prompt);
+  const r = await localGenerate(m.model, prompt);
+  return { ok: r.ok, text: r.text };
+}
+function buildPagePrompt(title, existingBody, facts, otherTitles) {
+  const lines = [
+    `You maintain a personal knowledge wiki. Write or update ONE page titled "${title}".`,
+    "Output ONLY the page body in Markdown. No frontmatter, no code fences, no preamble.",
+    "",
+    "Rules:",
+    "- Synthesize the facts into concise, self-contained prose (a few short paragraphs or tight bullets).",
+    "- Merge new facts into the existing text; do not just append. Resolve overlaps. Keep it current.",
+    "- Do not invent anything beyond the facts given.",
+    '- End with a line "## Related" followed by [[Wiki Page]] links to other pages that connect.',
+    "- Use [[double-bracket]] links for any other page you reference."
+  ];
+  if (otherTitles.length) {
+    lines.push("", "Other existing pages you may link to:", ...otherTitles.map((t) => `- ${t}`));
+  }
+  if (existingBody.trim()) {
+    lines.push("", "Current page body:", existingBody.trim());
+  }
+  lines.push("", "New facts to integrate:", ...facts.map((f) => `- ${f}`), "", "Updated page body:");
+  return lines.join("\n");
+}
+function emptySummary() {
+  return { created: 0, updated: 0, factsIntegrated: 0 };
+}
+function dedupe(a) {
+  return [...new Set(a)];
+}
+function deriveTitle(content, slug) {
+  const fromSlug = slug.split("-").filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+  return fromSlug || content.slice(0, 40);
+}
+function stripFrontmatterEcho(text) {
+  let s = text.trim();
+  s = s.replace(/^```(?:markdown|md)?\s*/i, "").replace(/```\s*$/i, "").trim();
+  if (s.startsWith("---")) {
+    const end = s.indexOf("\n---", 3);
+    if (end >= 0) s = s.slice(end + 4).trim();
+  }
+  return s;
+}
+async function foldFacts(cfg, maintainer, facts) {
+  const summary = emptySummary();
+  if (facts.length === 0) return { summary, changed: [] };
+  let pages = loadPages();
+  const targets = await pageEmbeddings(pages);
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of facts) {
+    const decision = await routeFact(f.content, targets);
+    const slug = decision.slug;
+    let isNew = decision.kind === "new";
+    const existingGroup = groups.get(slug);
+    if (existingGroup) {
+      existingGroup.facts.push(f);
+    } else {
+      if (isNew && listPageSlugs().includes(slug)) isNew = false;
+      groups.set(slug, { slug, isNew, facts: [f] });
+    }
+  }
+  const knownTitles = new Set(pages.map((p) => p.title));
+  for (const group of groups.values()) {
+    knownTitles.add(readPage(group.slug)?.title ?? deriveTitle(group.facts[0].content, group.slug));
+  }
+  const changed = [];
+  for (const group of groups.values()) {
+    const existing = readPage(group.slug);
+    const title = existing?.title ?? deriveTitle(group.facts[0].content, group.slug);
+    const prompt = buildPagePrompt(
+      title,
+      existing?.body ?? "",
+      group.facts.map((f) => f.content),
+      [...knownTitles].filter((t) => t !== title)
+    );
+    const res = await runMaintainer(maintainer, cfg, prompt);
+    if (!res.ok || !res.text.trim()) continue;
+    const body = stripFrontmatterEcho(res.text);
+    const prevSources = existing?.sources ?? [];
+    const page = {
+      slug: group.slug,
+      title,
+      updated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+      sources: dedupe([...prevSources, ...group.facts.map((f) => f.id)]),
+      body
+    };
+    writePage(page);
+    changed.push(page);
+    if (existing) summary.updated++;
+    else summary.created++;
+    summary.factsIntegrated += group.facts.length;
+  }
+  pages = loadPages();
+  writeIndex(pages);
+  await indexPagesForRecall(changed);
+  return { summary, changed };
+}
+async function syncWiki(cfg, resolveBrain) {
+  const base = {
+    ...emptySummary(),
+    status: "nothing",
+    freshFacts: 0,
+    maintainer: null,
+    report: null,
+    changed: false
+  };
+  try {
+    const state = loadState();
+    const fresh = factRows().filter((f) => f.ts > state.lastSyncTs);
+    if (fresh.length === 0) return base;
+    base.freshFacts = fresh.length;
+    const { maintainer, report } = await resolveMaintainer(cfg, resolveBrain);
+    base.maintainer = maintainer;
+    base.report = report;
+    if (!maintainer) return { ...base, status: "no-maintainer" };
+    const { summary, changed } = await foldFacts(cfg, maintainer, fresh);
+    const newest = Math.max(state.lastSyncTs, ...fresh.map((f) => f.ts));
+    saveSyncMarker(newest);
+    return {
+      ...summary,
+      status: "ok",
+      freshFacts: fresh.length,
+      maintainer,
+      report,
+      changed: changed.length > 0
+    };
+  } catch {
+    return base;
+  }
+}
+function renderIndex(pages) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const lines = [
+    "---",
+    "title: Wiki Index",
+    `updated: ${today}`,
+    "---",
+    "",
+    "# Wiki",
+    "",
+    "Derived knowledge for this folder. Pages are synthesized from `facts.md` and",
+    "`turns.jsonl` and are regenerable with `holt wiki rebuild`. Open in Obsidian to",
+    "browse the [[links]].",
+    ""
+  ];
+  if (pages.length === 0) {
+    lines.push("_No pages yet. Run `holt wiki sync` after chatting._", "");
+    return lines.join("\n");
+  }
+  lines.push("## Pages", "");
+  for (const pg of [...pages].sort((a, b) => a.title.localeCompare(b.title))) {
+    const when = pg.updated ? ` _(updated ${pg.updated})_` : "";
+    lines.push(`- [[${pg.title}]]${when}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function writeIndex(pages) {
+  mkdirSync7(wikiDir(), { recursive: true });
+  writeFileSync7(wikiIndexPath(), renderIndex(pages), "utf8");
+}
+var WIKI_SESSION = "wiki";
+function wikiRowId(slug) {
+  return "wiki-" + sanitizeName(slug).slice(0, 24);
+}
+function dropWikiRows(slugs) {
+  const keep = loadTurns().filter((t) => !(t.session === WIKI_SESSION && slugs.has(t.id.replace(/^wiki-/, ""))));
+  return keep;
+}
+async function indexPagesForRecall(pages) {
+  try {
+    if (pages.length === 0) return;
+    const slugs = new Set(pages.map((p) => sanitizeName(p.slug).slice(0, 24)));
+    const kept = dropWikiRows(slugs);
+    mkdirSync7(join8(wsHoltDir(), "memory"), { recursive: true });
+    writeFileSync7(
+      join8(wsHoltDir(), "memory", "turns.jsonl"),
+      kept.map((t) => JSON.stringify(t)).join("\n") + (kept.length ? "\n" : ""),
+      "utf8"
+    );
+    for (const pg of pages) {
+      const content = `${pg.title}
+${pg.body}`.slice(0, 4e3);
+      appendTurn({
+        id: wikiRowId(pg.slug),
+        ts: Date.now(),
+        session: WIKI_SESSION,
+        role: "fact",
+        content,
+        emb: await embed(content) ?? void 0
+      });
+    }
+  } catch {
+  }
+}
+function clearWikiRecallRows() {
+  try {
+    const kept = loadTurns().filter((t) => t.session !== WIKI_SESSION);
+    mkdirSync7(join8(wsHoltDir(), "memory"), { recursive: true });
+    writeFileSync7(
+      join8(wsHoltDir(), "memory", "turns.jsonl"),
+      kept.map((t) => JSON.stringify(t)).join("\n") + (kept.length ? "\n" : ""),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function wipeWiki() {
+  if (existsSync8(wikiDir())) rmSync4(wikiDir(), { recursive: true, force: true });
+}
+function wikiStats() {
+  const slugs = listPageSlugs();
+  let bytes = 0;
+  for (const slug of slugs) {
+    try {
+      bytes += statSync3(pagePath(slug)).size;
+    } catch {
+    }
+  }
+  return { pages: slugs.length, bytes, lastSyncTs: loadState().lastSyncTs };
+}
+function factRows() {
+  return loadTurns().filter((t) => t.role === "fact" && t.session !== WIKI_SESSION).map((t) => ({ id: t.id, content: t.content, ts: t.ts }));
+}
+var RAM_RECOMMENDATIONS = [
+  { minGiB: 48, model: "qwen2.5:32b", note: "plenty of headroom for a large local model (~20GB)." },
+  { minGiB: 24, model: "qwen2.5:14b", note: "a 14B model (~9GB) fits comfortably." },
+  { minGiB: 16, model: "qwen2.5:7b", note: "default. ~4.7GB; tight alongside the embed model + editor. An always-on machine is a better host. Alternative: llama3.1:8b." },
+  { minGiB: 0, model: "llama3.2:3b", note: "under 16GB, local is discouraged; if you insist, this ~2GB model is modest quality. The brain maintainer is the better default." }
+];
+function totalGiB() {
+  return Math.round(totalmem() / 1024 ** 3 * 10) / 10;
+}
+function recommendLocalModel(gib = totalGiB()) {
+  const tier = RAM_RECOMMENDATIONS.find((r) => gib >= r.minGiB) ?? RAM_RECOMMENDATIONS[RAM_RECOMMENDATIONS.length - 1];
+  return {
+    gib,
+    model: tier.model,
+    note: tier.note,
+    pull: pullHint(tier.model),
+    discourageLocal: gib < 16
+  };
+}
+
+// src/output.ts
+import { writeFileSync as writeFileSync8 } from "fs";
+import { join as join9, isAbsolute } 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*?(?:\([^)\s]*\)[^)\s]*)*)\)/g, (_m, label, url) => {
+    const trimmed = url.trim();
+    const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(trimmed);
+    const safeScheme = !scheme || /^(https?|mailto)$/i.test(scheme[1]);
+    if (!safeScheme) return label;
+    const safe = trimmed.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++;
@@ -1747,8 +2880,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 = join7(process.cwd(), base);
-  writeFileSync6(path, renderReply(reply, format), "utf8");
+  const path = join9(process.cwd(), base);
+  writeFileSync8(path, renderReply(reply, format), "utf8");
   return path;
 }
 
@@ -1980,6 +3113,13 @@ async function chat() {
     } catch {
     }
   }
+  if (cfg.wiki?.autoSync) {
+    try {
+      const res = await syncWiki(cfg, () => resolveBrainMaintainer(cfg));
+      if (res.status === "ok" && res.changed) console.log(c.dim("  updated the wiki."));
+    } catch {
+    }
+  }
   close();
   console.log(c.dim("\nBye.\n"));
 }
@@ -2008,7 +3148,8 @@ async function login(which) {
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
+import { basename } from "path";
 async function memoryCmd(sub, rest = []) {
   const { ask, close } = createReader();
   if (!await ensureTrusted(ask)) {
@@ -2055,12 +3196,12 @@ async function memoryCmd(sub, rest = []) {
     return;
   }
   if (action === "facts") {
-    if (!existsSync7(factsMdPath())) {
+    if (!existsSync9(factsMdPath())) {
       console.log(c.dim("\n  No facts distilled yet. They form when you end a chat session.\n"));
       close();
       return;
     }
-    const body = readFileSync7(factsMdPath(), "utf8").trim();
+    const body = readFileSync10(factsMdPath(), "utf8").trim();
     console.log("\n" + body + "\n");
     close();
     return;
@@ -2077,15 +3218,23 @@ async function memoryCmd(sub, rest = []) {
     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);
-      console.log(`  ${c.accent(h.score.toFixed(2))}  ${c.dim(when)}  (${h.turn.role}) ${h.turn.content.slice(0, 100).replace(/\s+/g, " ")}`);
+      const src = h.workspace ? c.dim(` [${basename(h.workspace)}]`) : "";
+      console.log(
+        `  ${c.accent(h.score.toFixed(2))}  ${c.dim(when)}  (${h.turn.role})${src} ${h.turn.content.slice(0, 100).replace(/\s+/g, " ")}`
+      );
     }
     console.log("");
     close();
     return;
   }
-  if (action && !["clear", "embed", "facts", "search"].includes(action)) {
+  if (action === "global") {
+    globalCmd((rest[0] || "").toLowerCase(), rest.slice(1));
+    close();
+    return;
+  }
+  if (action && !["clear", "embed", "facts", "search", "global"].includes(action)) {
     console.error(`
-  Unknown memory subcommand: "${sub}". Use: search <query> | facts | embed | clear
+  Unknown memory subcommand: "${sub}". Use: search <query> | facts | embed | global | clear
 `);
     process.exitCode = 1;
     close();
@@ -2105,41 +3254,618 @@ async function memoryCmd(sub, rest = []) {
     console.log(c.dim(`
   ${s.turns - s.withEmbeddings} moments lack embeddings. Run "holt memory embed" to upgrade them to semantic recall.`));
   }
+  const gEnabled = isGlobalEnabled(workspace());
+  console.log(`  global      ${gEnabled ? c.green("on") + c.dim("  (contributes + reads shared facts)") : c.dim("off  (this folder is isolated, the default)")}`);
   console.log(c.dim("\n  holt memory search <query>   find remembered moments"));
   console.log(c.dim("  holt memory facts            show distilled facts (facts.md)"));
   console.log(c.dim("  holt memory embed            embed older memories for semantic recall"));
+  console.log(c.dim("  holt memory global           share high-value facts across your folders"));
   console.log(c.dim("  holt memory clear            wipe this folder's memory\n"));
   close();
 }
+function globalCmd(act, rest) {
+  const ws = workspace();
+  if (act === "on") {
+    const already = isGlobalEnabled(ws);
+    const added = enableGlobal(ws);
+    const g = globalStats();
+    if (already) console.log("\n" + c.green("  Global memory already on for this folder."));
+    else console.log("\n" + c.green("  Global memory ON for this folder."));
+    console.log(c.dim(`  Backfilled ${added} fact${added === 1 ? "" : "s"} into the shared store.`));
+    console.log(c.dim(`  New facts here mirror automatically; recall now spans ${g.workspaces} contributing folder${g.workspaces === 1 ? "" : "s"}.
+`));
+    return;
+  }
+  if (act === "off") {
+    const purge = rest.includes("--purge");
+    if (!isGlobalEnabled(ws) && !purge) {
+      console.log("\n" + c.dim("  Global memory is already off for this folder.\n"));
+      return;
+    }
+    const { purged } = disableGlobal(ws, purge);
+    console.log("\n" + c.green("  Global memory OFF for this folder.") + c.dim("  (recall is local-only again)"));
+    if (purge) console.log(c.dim(`  Purged ${purged} of this folder's row${purged === 1 ? "" : "s"} from the shared store.`));
+    else console.log(c.dim("  This folder's rows stay in the shared store. Re-run with --purge to remove them."));
+    console.log("");
+    return;
+  }
+  if (act === "" || act === "status") {
+    const enabled = isGlobalEnabled(ws);
+    const g = globalStats();
+    const contributors = globalWorkspaces();
+    console.log("\n" + c.accent("Holt global memory") + c.dim("  (opt-in, shared facts across your folders)"));
+    console.log(`  this folder    ${enabled ? c.green("on") : c.dim("off (isolated, the default)")}`);
+    console.log(`  contributing   ${g.workspaces} folder${g.workspaces === 1 ? "" : "s"}`);
+    console.log(`  shared facts   ${g.facts}`);
+    console.log(`  size           ${(g.bytes / 1024).toFixed(1)} KB  (${globalMemPath()})`);
+    console.log(`  registry       ${memoryScopesPath()}`);
+    if (contributors.length) {
+      console.log(c.dim("\n  Folders sharing facts:"));
+      for (const w of contributors) console.log(c.dim(`    ${basename(w)}  ${w === ws ? "(this folder)" : w}`));
+    }
+    console.log(c.dim("\n  holt memory global on          share this folder's facts + read others"));
+    console.log(c.dim("  holt memory global off         stop sharing + reading (add --purge to delete rows)"));
+    console.log(c.dim("  holt memory global status      this view\n"));
+    return;
+  }
+  console.error(`
+  Unknown "memory global" action: "${act}". Use: on | off [--purge] | status
+`);
+  process.exitCode = 1;
+}
 
-// src/commands/skill.ts
-import {
-  mkdirSync as mkdirSync6,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync8,
-  existsSync as existsSync8,
-  readdirSync as readdirSync2,
-  statSync as statSync3,
-  rmSync as rmSync3,
-  cpSync,
-  mkdtempSync
-} from "fs";
-import { join as join8, 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.",
+// src/commands/wiki.ts
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
+import { join as join10 } from "path";
+import { spawn as spawn3 } from "child_process";
+function titleToSlug(title) {
+  return proposeSlug(title);
+}
+async function syncCmd(cfg) {
+  const res = await syncWiki(cfg, () => resolveBrainMaintainer(cfg));
+  if (res.status === "nothing") {
+    console.log(c.dim("\n  No new facts since the last sync. Nothing to do.\n"));
+    return;
+  }
+  if (res.status === "no-maintainer") {
+    if (res.report?.note) console.log(c.dim("\n  " + res.report.note));
+    console.log(c.red("\n  No maintainer available."));
+    console.log(c.dim("  Configure a brain (holt init) or set wiki.maintainer to local with a pulled model.\n"));
+    return;
+  }
+  const maintainer = res.maintainer;
+  if (res.report?.note) console.log(c.dim("\n  " + res.report.note));
+  console.log("\n" + c.dim(`  Integrated ${res.freshFacts} new fact${res.freshFacts === 1 ? "" : "s"} via ${maintainer.label}...`));
+  console.log("\n" + c.accent("Wiki synced") + c.dim("  (this folder)"));
+  console.log(`  facts integrated  ${res.factsIntegrated}`);
+  console.log(`  pages created     ${res.created}`);
+  console.log(`  pages updated     ${res.updated}`);
+  console.log(`  maintainer        ${maintainer.label}${res.report?.fellBack ? c.dim(" (fell back)") : ""}`);
+  console.log(c.dim(`
+  Wiki: ${wikiDir()}  (open in Obsidian to browse [[links]])
+`));
+}
+async function rebuildCmd(cfg, ask) {
+  const facts = factRows();
+  if (facts.length === 0) {
+    console.log(c.dim("\n  No facts to build from yet. Chat first so facts distill, then sync.\n"));
+    return;
+  }
+  const a = (await ask(`
+  Wipe and regenerate the wiki from ${facts.length} facts? This discards hand-edits. [y/N] `) ?? "").trim().toLowerCase();
+  if (a !== "y" && a !== "yes") {
+    console.log(c.dim("  Kept.\n"));
+    return;
+  }
+  const { maintainer, report } = await resolveMaintainer(cfg, () => resolveBrainMaintainer(cfg));
+  if (!maintainer) {
+    console.log(c.red("\n  No maintainer available. Configure a brain or a local model first.\n"));
+    return;
+  }
+  if (report?.note) console.log(c.dim("  " + report.note));
+  wipeWiki();
+  clearWikiRecallRows();
+  console.log(c.dim(`
+  Rebuilding from ${facts.length} facts via ${maintainer.label}...`));
+  const { summary } = await foldFacts(cfg, maintainer, facts);
+  saveSyncMarker(Math.max(0, ...facts.map((f) => f.ts)));
+  console.log("\n" + c.accent("Wiki rebuilt"));
+  console.log(`  pages         ${summary.created}`);
+  console.log(`  facts folded  ${summary.factsIntegrated}`);
+  console.log(c.dim(`
+  Wiki: ${wikiDir()}
+`));
+}
+function buildLintPrompt(pages) {
+  const lines = [
+    "You are auditing a personal knowledge wiki for quality. Review the pages below.",
+    "Report, concisely and as plain text (no code fences):",
+    "- CONTRADICTIONS: statements across pages that conflict.",
+    "- DUPLICATES: pages or passages that overlap and should merge.",
+    "- GAPS: obvious missing links ([[...]]) or topics implied but not written.",
+    "If a category is clean, say so in one line. Do not rewrite the pages.",
+    "",
+    "Pages:"
+  ];
+  for (const pg of pages) {
+    lines.push("", `### ${pg.title} (${pg.slug})`, pg.body.slice(0, 1200));
+  }
+  return lines.join("\n");
+}
+var FIX_BEGIN = "<<<HOLT-PAGE ";
+var FIX_END = "<<<HOLT-END>>>";
+function buildFixPrompt(pages) {
+  const lines = [
+    "You maintain a personal knowledge wiki. Fix quality issues across the pages",
+    "below: resolve CONTRADICTIONS (keep the most recent/consistent statement),",
+    "merge DUPLICATE passages, and add obvious missing [[wikilinks]]. Do not invent",
+    "new facts; only reconcile and de-duplicate what is already written.",
+    "",
+    "Return EVERY page, even unchanged ones, using EXACTLY this format and nothing",
+    "else (no prose, no code fences, no frontmatter):",
+    "",
+    `${FIX_BEGIN}<slug>>>>`,
+    '<corrected page body in Markdown, ending with a "## Related" section of [[links]]>',
+    FIX_END,
+    "",
+    "Pages:"
+  ];
+  for (const pg of pages) {
+    lines.push("", `${FIX_BEGIN}${pg.slug}>>>`, `### ${pg.title}`, pg.body.trim(), FIX_END);
+  }
+  return lines.join("\n");
+}
+function parseFixReply(raw) {
+  const out = /* @__PURE__ */ new Map();
+  const text = raw || "";
+  let i = 0;
+  while (true) {
+    const begin = text.indexOf(FIX_BEGIN, i);
+    if (begin < 0) break;
+    const slugStart = begin + FIX_BEGIN.length;
+    const slugEnd = text.indexOf(">>>", slugStart);
+    if (slugEnd < 0) break;
+    const slug = text.slice(slugStart, slugEnd).trim();
+    const bodyStart = slugEnd + 3;
+    const end = text.indexOf(FIX_END, bodyStart);
+    if (end < 0) break;
+    let body = text.slice(bodyStart, end).trim();
+    body = body.replace(/^###[^\n]*\n+/, "").trim();
+    if (slug && body) out.set(slug, body);
+    i = end + FIX_END.length;
+  }
+  return out;
+}
+async function lintCmd(cfg, fix) {
+  const pages = loadPages();
+  if (pages.length === 0) {
+    console.log(c.dim('\n  No pages to lint. Run "holt wiki sync" first.\n'));
+    return;
+  }
+  const { maintainer, report } = await resolveMaintainer(cfg, () => resolveBrainMaintainer(cfg));
+  if (!maintainer) {
+    console.log(c.red("\n  No maintainer available. Configure a brain or a local model first.\n"));
+    return;
+  }
+  if (report?.note) console.log(c.dim("\n  " + report.note));
+  if (!fix) {
+    console.log(c.dim(`
+  Auditing ${pages.length} page${pages.length === 1 ? "" : "s"} via ${maintainer.label}...
+`));
+    const res2 = await runMaintainer(maintainer, cfg, buildLintPrompt(pages));
+    if (!res2.ok || !res2.text.trim()) {
+      console.log(c.dim("  Lint could not produce a report (maintainer returned nothing).\n"));
+      return;
+    }
+    console.log(res2.text.trim() + "\n");
+    return;
+  }
+  console.log(c.dim("\n  --fix will rewrite affected pages. Put .holt/wiki under git or back it up first;"));
+  console.log(c.dim('  a bad fix is fully recoverable with "holt wiki rebuild".'));
+  console.log(c.dim(`
+  Auditing + fixing ${pages.length} page${pages.length === 1 ? "" : "s"} via ${maintainer.label}...
+`));
+  const res = await runMaintainer(maintainer, cfg, buildFixPrompt(pages));
+  if (!res.ok || !res.text.trim()) {
+    console.log(c.dim("  Lint --fix could not produce corrections (maintainer returned nothing). Files untouched.\n"));
+    return;
+  }
+  const corrected = parseFixReply(res.text);
+  if (corrected.size === 0) {
+    console.log(c.dim("  No parseable corrections returned. Files untouched.\n"));
+    return;
+  }
+  const byPage = new Map(pages.map((p) => [p.slug, p]));
+  const applied = [];
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  for (const [slug, body] of corrected) {
+    const page = byPage.get(slug);
+    if (!page) continue;
+    if (body.trim() === page.body.trim()) continue;
+    try {
+      writePage({ ...page, body: body.trim(), updated: today });
+      applied.push(page.title);
+    } catch {
+    }
+  }
+  if (applied.length === 0) {
+    console.log(c.dim("  Lint found nothing to change. Pages already clean.\n"));
+    return;
+  }
+  console.log("\n" + c.accent("Wiki lint applied") + c.dim("  (this folder)"));
+  console.log(`  pages rewritten   ${applied.length}`);
+  for (const t of applied) console.log(c.dim(`    - ${t}`));
+  console.log(c.dim(`
+  Recover any page with "holt wiki rebuild". Wiki: ${wikiDir()}
+`));
+}
+function listCmd() {
+  const slugs = listPageSlugs();
+  if (slugs.length === 0) {
+    console.log(c.dim('\n  No wiki pages yet. Run "holt wiki sync" after chatting.\n'));
+    return;
+  }
+  console.log("\n" + c.accent("Wiki pages") + c.dim("  (this folder)"));
+  for (const slug of slugs) {
+    const pg = readPage(slug);
+    if (!pg) continue;
+    const size = existsSync10(join10(wikiDir(), slug + ".md")) ? (readFileSync11(join10(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("");
+}
+function showCmd(name) {
+  if (!name) {
+    console.log(c.dim("\n  Usage: holt wiki show <page>\n"));
+    return;
+  }
+  const want = name.toLowerCase();
+  const slug = listPageSlugs().find((s) => s.toLowerCase() === want || s.toLowerCase() === titleToSlug(name)) ?? loadPages().find((p) => p.title.toLowerCase() === want)?.slug;
+  if (!slug) {
+    console.log(c.dim(`
+  No page "${name}". Try "holt wiki list".
+`));
+    return;
+  }
+  const raw = readFileSync11(join10(wikiDir(), slug + ".md"), "utf8");
+  console.log("\n" + raw.trim() + "\n");
+}
+async function statusCmd(cfg) {
+  const stats = wikiStats();
+  const rec = recommendLocalModel();
+  const state = loadState();
+  const lastSync = state.lastSyncTs ? new Date(state.lastSyncTs).toISOString().slice(0, 10) : "never";
+  console.log("\n" + c.accent("Holt wiki") + c.dim("  (this folder)"));
+  console.log(`  maintainer    ${cfg.wiki.maintainer}`);
+  console.log(`  localModel    ${cfg.wiki.localModel}`);
+  console.log(`  auto-sync     ${cfg.wiki.autoSync ? c.green("on") : c.dim("off")}${cfg.wiki.autoSync ? "" : c.dim("  (holt wiki auto on)")}`);
+  console.log(`  pages         ${stats.pages}`);
+  console.log(`  size          ${(stats.bytes / 1024).toFixed(1)} KB  (./.holt/wiki/)`);
+  console.log(`  last sync     ${lastSync}`);
+  if (cfg.wiki.maintainer === "local") {
+    const st = await localModelStatus(cfg.wiki.localModel);
+    const line = st.reachable ? st.hasModel ? c.green("ready") : c.red("model not pulled") + c.dim(`  (${pullHint(cfg.wiki.localModel)})`) : c.red("Ollama not reachable");
+    console.log(`  local status  ${line}`);
+  }
+  console.log(c.dim(`
+  RAM ${rec.gib} GiB -> recommended local model: ${rec.model}`));
+  console.log(c.dim(`  ${rec.note}`));
+  if (rec.discourageLocal) console.log(c.dim("  Local maintenance is discouraged at this RAM; the brain maintainer is recommended."));
+  console.log(c.dim(`  Pull it with: ${rec.pull}`));
+  console.log(c.dim("\n  holt wiki sync              fold new facts into pages"));
+  console.log(c.dim("  holt wiki auto [on|off]     auto-sync the wiki when a session ends"));
+  console.log(c.dim("  holt wiki rebuild           regenerate the whole wiki from facts"));
+  console.log(c.dim("  holt wiki lint [--fix]      audit (and with --fix, apply) contradiction/duplicate fixes"));
+  console.log(c.dim("  holt wiki list / show <p>   browse pages"));
+  console.log(c.dim("  holt wiki open              open in your default app (Obsidian reads it natively)\n"));
+}
+function autoCmd(cfg, arg) {
+  const want = (arg || "").toLowerCase();
+  if (want === "") {
+    const on2 = cfg.wiki.autoSync === true;
+    console.log("\n" + c.accent("Wiki auto-sync") + c.dim("  (this folder)"));
+    console.log(`  ${on2 ? c.green("on") : c.dim("off")}`);
+    console.log(c.dim("  usage: holt wiki auto on | off"));
+    console.log(c.dim("  When on, the wiki folds new facts in automatically after a chat session"));
+    console.log(c.dim('  or when the Claude Code Stop hook captures facts. No manual "holt wiki sync".\n'));
+    return;
+  }
+  if (want !== "on" && want !== "off") {
+    console.log(c.dim("\n  usage: holt wiki auto on | off\n"));
+    return;
+  }
+  cfg.wiki.autoSync = want === "on";
+  saveConfig(cfg);
+  console.log(
+    want === "on" ? c.green("\n  wiki auto-sync: on") + c.dim("  (syncs at session end)\n") : c.dim("\n  wiki auto-sync: off\n")
+  );
+}
+function setupCmd(cfg) {
+  const rec = recommendLocalModel();
+  console.log("\n" + c.accent("Local wiki maintainer: model recommendation"));
+  console.log(`  detected RAM   ${rec.gib} GiB`);
+  console.log(`  recommended    ${c.cyan(rec.model)}`);
+  console.log(`  why            ${rec.note}`);
+  if (rec.discourageLocal) {
+    console.log(c.dim("\n  At under 16 GiB, keep wiki.maintainer = brain (rides your Claude plan, no marginal RAM)."));
+  }
+  console.log(c.dim(`
+  To use it locally:`));
+  console.log(c.dim(`    1. ${rec.pull}`));
+  console.log(c.dim(`    2. set wiki.maintainer = "local" and wiki.localModel = "${rec.model}" in .holt/config.json`));
+  console.log(c.dim(`  Current: maintainer=${cfg.wiki.maintainer}, localModel=${cfg.wiki.localModel}
+`));
+}
+function openCmd() {
+  const target = existsSync10(wikiIndexPath()) ? wikiIndexPath() : wikiDir();
+  if (!existsSync10(target)) {
+    console.log(c.dim('\n  No wiki yet. Run "holt wiki sync" first.\n'));
+    return;
+  }
+  try {
+    let cmd;
+    let args;
+    if (process.platform === "darwin") {
+      cmd = "open";
+      args = [target];
+    } else if (process.platform === "win32") {
+      cmd = "cmd";
+      args = ["/c", "start", "", target];
+    } else {
+      cmd = "xdg-open";
+      args = [target];
+    }
+    const child = spawn3(cmd, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+    console.log(c.dim(`
+  Opening ${target}`));
+    console.log(c.dim("  Tip: Obsidian can open .holt/wiki as a vault and read the [[links]] natively.\n"));
+  } catch {
+    console.log(c.dim(`
+  Could not open it. Path: ${target}
+`));
+  }
+}
+async function wikiCmd(sub, rest = []) {
+  const action = (sub || "").toLowerCase();
+  const { ask, close } = createReader();
+  if (!await ensureTrusted(ask)) {
+    close();
+    return;
+  }
+  const cfg = loadConfig();
+  if (!cfg) {
+    console.log(c.dim('\n  No Holt setup in this folder. Run "holt init" first.\n'));
+    close();
+    return;
+  }
+  try {
+    switch (action) {
+      case "sync":
+        await syncCmd(cfg);
+        break;
+      case "auto":
+        autoCmd(cfg, rest[0] ?? "");
+        break;
+      case "rebuild":
+        await rebuildCmd(cfg, ask);
+        break;
+      case "lint":
+        await lintCmd(cfg, rest.includes("--fix"));
+        break;
+      case "list":
+        listCmd();
+        break;
+      case "show":
+        showCmd(rest.join(" ").trim());
+        break;
+      case "open":
+        openCmd();
+        break;
+      case "setup":
+      case "recommend":
+        setupCmd(cfg);
+        break;
+      case "":
+      case "status":
+        await statusCmd(cfg);
+        break;
+      default:
+        console.error(`
+  Unknown wiki subcommand: "${sub}". Use: sync | auto | rebuild | lint | list | show <page> | open | status | setup
+`);
+        process.exitCode = 1;
+    }
+  } finally {
+    close();
+  }
+}
+
+// src/commands/skill.ts
+import {
+  mkdirSync as mkdirSync9,
+  writeFileSync as writeFileSync10,
+  readFileSync as readFileSync13,
+  existsSync as existsSync12,
+  readdirSync as readdirSync3,
+  statSync as statSync5,
+  rmSync as rmSync5,
+  cpSync,
+  mkdtempSync
+} from "fs";
+import { join as join12, resolve as resolve3 } from "path";
+import { tmpdir } from "os";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/registry.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync8, statSync as statSync4 } from "fs";
+import { join as join11, isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import { pathToFileURL, fileURLToPath } 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 join11(GLOBAL_DIR, "registry-cache.json");
+}
+function registryUrl() {
+  const env = (process.env.HOLT_REGISTRY_URL || "").trim();
+  return env || DEFAULT_REGISTRY_URL;
+}
+function coerceRegistry(value) {
+  if (!value || typeof value !== "object") return null;
+  const obj = value;
+  const skillsRaw = Array.isArray(obj.skills) ? obj.skills : [];
+  const skills = [];
+  for (const row2 of skillsRaw) {
+    if (!row2 || typeof row2 !== "object") continue;
+    const r = row2;
+    const name = typeof r.name === "string" ? r.name.trim() : "";
+    const source = typeof r.source === "string" ? r.source.trim() : "";
+    if (!name || !source) continue;
+    const description = typeof r.description === "string" ? r.description.trim() : "";
+    const author = typeof r.author === "string" ? r.author.trim() : "";
+    const tags = Array.isArray(r.tags) ? r.tags.filter((t) => typeof t === "string").map((t) => t.trim()).filter(Boolean) : void 0;
+    const entry = { name, description, source, author };
+    if (tags && tags.length) entry.tags = tags;
+    skills.push(entry);
+  }
+  const version = typeof obj.version === "number" ? obj.version : 1;
+  return { version, skills };
+}
+function parseRegistry(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return coerceRegistry(parsed);
+}
+function readCache() {
+  try {
+    const path = registryCachePath();
+    if (!existsSync11(path)) return null;
+    const raw = JSON.parse(readFileSync12(path, "utf8"));
+    if (!raw || typeof raw.fetchedAt !== "number" || typeof raw.url !== "string") return null;
+    const registry = coerceRegistry(raw.registry);
+    if (!registry) return null;
+    return { fetchedAt: raw.fetchedAt, url: raw.url, registry };
+  } catch {
+    return null;
+  }
+}
+function writeCache(url, registry) {
+  try {
+    mkdirSync8(GLOBAL_DIR, { recursive: true });
+    const body = { fetchedAt: Date.now(), url, registry };
+    writeFileSync9(registryCachePath(), JSON.stringify(body, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+function localPathFor(loc) {
+  if (loc.startsWith("file://")) {
+    try {
+      return fileURLToPath(loc);
+    } catch {
+      return null;
+    }
+  }
+  if (/^https?:\/\//i.test(loc)) return null;
+  return isAbsolute2(loc) ? loc : resolve2(loc);
+}
+var UNREACHABLE_MSG = "no registry reachable; set HOLT_REGISTRY_URL or the community registry is not live yet";
+function loadLocal(path) {
+  try {
+    if (!existsSync11(path)) {
+      return { registry: null, fromCache: false, error: UNREACHABLE_MSG };
+    }
+    const registry = parseRegistry(readFileSync12(path, "utf8"));
+    if (!registry) {
+      return { registry: null, fromCache: false, error: "registry file is not valid JSON" };
+    }
+    return { registry, fromCache: false };
+  } catch {
+    return { registry: null, fromCache: false, error: UNREACHABLE_MSG };
+  }
+}
+async function loadRemote(url) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+    if (!res.ok) {
+      return { registry: null, fromCache: false, error: UNREACHABLE_MSG };
+    }
+    const registry = parseRegistry(await res.text());
+    if (!registry) {
+      return { registry: null, fromCache: false, error: "registry response is not valid JSON" };
+    }
+    return { registry, fromCache: false };
+  } catch {
+    return { registry: null, fromCache: false, error: UNREACHABLE_MSG };
+  }
+}
+async function loadRegistry(opts = {}) {
+  const url = registryUrl();
+  const cached = readCache();
+  const fresh = cached && cached.url === url && Date.now() - cached.fetchedAt < CACHE_TTL_MS;
+  if (!opts.refresh && fresh && cached) {
+    return { registry: cached.registry, fromCache: true };
+  }
+  const local = localPathFor(url);
+  const result = local ? loadLocal(local) : await loadRemote(url);
+  if (result.registry) {
+    writeCache(url, result.registry);
+    return result;
+  }
+  if (cached && cached.url === url) {
+    return { registry: cached.registry, fromCache: true, error: result.error };
+  }
+  return result;
+}
+function searchSkills(skills, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [...skills].sort((a, b) => a.name.localeCompare(b.name));
+  const rank = (s) => {
+    if (s.name.toLowerCase().includes(q)) return 0;
+    if (s.description.toLowerCase().includes(q)) return 1;
+    if ((s.tags || []).some((t) => t.toLowerCase().includes(q))) return 2;
+    return 3;
+  };
+  return skills.map((s) => ({ s, r: rank(s) })).filter((x) => x.r < 3).sort((a, b) => a.r !== b.r ? a.r - b.r : a.s.name.localeCompare(b.s.name)).map((x) => x.s);
+}
+function resolveByName(skills, name) {
+  const want = name.trim().toLowerCase();
+  return skills.find((s) => s.name.toLowerCase() === want) || null;
+}
+function buildPublishEntry(input) {
+  const entry = {
+    name: input.name,
+    description: input.description,
+    source: input.source,
+    author: input.author
+  };
+  if (input.tags && input.tags.length) entry.tags = input.tags;
+  return JSON.stringify(entry, null, 2).split("\n").map((l) => "  " + l).join("\n");
+}
+
+// src/commands/skill.ts
+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 search <query>           find skills in the registry",
+    "  holt skill add <src|name> [--global] install from a git URL, path, or registry name",
+    "  holt skill publish [<name>]         prepare a skill for the registry (prints a PR entry)",
+    "  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.",
+    "  search/add-by-name use the registry (HOLT_REGISTRY_URL or the community index).",
     ""
   ].join("\n")));
 }
@@ -2170,12 +3896,12 @@ function isGitUrl(s) {
   return s.includes("://") || s.endsWith(".git") || s.startsWith("git@");
 }
 function findSkillDir(root) {
-  if (existsSync8(join8(root, "SKILL.md"))) return root;
+  if (existsSync12(join12(root, "SKILL.md"))) return root;
   let subs = [];
   try {
-    subs = readdirSync2(root).filter((f) => {
+    subs = readdirSync3(root).filter((f) => {
       try {
-        return statSync3(join8(root, f)).isDirectory();
+        return statSync5(join12(root, f)).isDirectory();
       } catch {
         return false;
       }
@@ -2183,8 +3909,8 @@ function findSkillDir(root) {
   } catch {
     return null;
   }
-  const withSkill = subs.filter((f) => existsSync8(join8(root, f, "SKILL.md")));
-  if (withSkill.length === 1) return join8(root, withSkill[0]);
+  const withSkill = subs.filter((f) => existsSync12(join12(root, f, "SKILL.md")));
+  if (withSkill.length === 1) return join12(root, withSkill[0]);
   return null;
 }
 function cmdList() {
@@ -2224,7 +3950,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("  " + join8(skill.dir, "SKILL.md")));
+  console.log(c.dim("  " + join12(skill.dir, "SKILL.md")));
   console.log("");
   console.log(c.dim(body));
   console.log("");
@@ -2236,60 +3962,55 @@ function cmdCreate(name, global) {
     return;
   }
   const scope = global ? "global" : "workspace";
-  const dir = join8(skillsRoot(scope), clean);
-  if (existsSync8(dir)) {
+  const dir = join12(skillsRoot(scope), clean);
+  if (existsSync12(dir)) {
     console.error(c.red(`
   A ${scope} skill named "${clean}" already exists.`));
     console.error(c.dim("  " + dir + "\n"));
     process.exitCode = 1;
     return;
   }
-  mkdirSync6(dir, { recursive: true });
-  writeFileSync7(join8(dir, "SKILL.md"), SKILL_TEMPLATE(clean), "utf8");
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync10(join12(dir, "SKILL.md"), SKILL_TEMPLATE(clean), "utf8");
   console.log(c.green(`
   Created ${scope} skill "${clean}".`));
-  console.log(c.dim("  " + join8(dir, "SKILL.md")));
+  console.log(c.dim("  " + join12(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";
+function installFromSource(source, scope) {
   let fetched = "";
   let tempDir = "";
   try {
     if (isGitUrl(source)) {
-      tempDir = mkdtempSync(join8(tmpdir(), "holt-skill-"));
+      tempDir = mkdtempSync(join12(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.error(c.red("  Clone failed. Check the URL and that git is installed.\n"));
         process.exitCode = 1;
-        return;
+        return false;
       }
       fetched = tempDir;
     } else {
-      fetched = resolve(source);
-      if (!existsSync8(fetched)) {
+      fetched = resolve3(source);
+      if (!existsSync12(fetched)) {
         console.error(c.red(`
   No such path: ${fetched}
 `));
         process.exitCode = 1;
-        return;
+        return false;
       }
     }
     const skillDir = findSkillDir(fetched);
     if (!skillDir) {
       console.error(c.red("\n  Could not find a SKILL.md at the source root or in a single subfolder.\n"));
       process.exitCode = 1;
-      return;
+      return false;
     }
     let skillName = "";
     try {
-      const { data } = parseFrontmatter(readFileSync8(join8(skillDir, "SKILL.md"), "utf8"));
+      const { data } = parseFrontmatter(readFileSync13(join12(skillDir, "SKILL.md"), "utf8"));
       skillName = sanitizeName(data.name || "");
     } catch {
       skillName = "";
@@ -2298,41 +4019,167 @@ function cmdAdd(source, global) {
     if (!skillName) {
       console.error(c.red("\n  Could not determine a valid skill name.\n"));
       process.exitCode = 1;
-      return;
+      return false;
     }
-    const dest = join8(skillsRoot(scope), skillName);
-    if (existsSync8(dest)) {
+    const dest = join12(skillsRoot(scope), skillName);
+    if (existsSync12(dest)) {
       console.error(c.red(`
   A ${scope} skill named "${skillName}" already exists.`));
       console.error(c.dim("  " + dest + "\n"));
       process.exitCode = 1;
-      return;
+      return false;
     }
-    mkdirSync6(skillsRoot(scope), { recursive: true });
+    mkdirSync9(skillsRoot(scope), { recursive: true });
     cpSync(skillDir, dest, { recursive: true });
-    const nestedGit = join8(dest, ".git");
-    if (existsSync8(nestedGit)) rmSync3(nestedGit, { recursive: true, force: true });
+    const nestedGit = join12(dest, ".git");
+    if (existsSync12(nestedGit)) rmSync5(nestedGit, { recursive: true, force: true });
     console.log(c.green(`
   Installed ${scope} skill "${skillName}".`));
-    console.log(c.dim("  " + join8(dest, "SKILL.md") + "\n"));
+    console.log(c.dim("  " + join12(dest, "SKILL.md") + "\n"));
+    return true;
   } finally {
-    if (tempDir && existsSync8(tempDir)) {
+    if (tempDir && existsSync12(tempDir)) {
       try {
-        rmSync3(tempDir, { recursive: true, force: true });
+        rmSync5(tempDir, { recursive: true, force: true });
       } catch {
       }
     }
   }
 }
+async function cmdAdd(source, global, refresh) {
+  if (!source) {
+    console.log(c.dim("\n  Usage: holt skill add <git-url|path|name> [--global]\n"));
+    return;
+  }
+  const scope = global ? "global" : "workspace";
+  if (isGitUrl(source) || existsSync12(resolve3(source))) {
+    installFromSource(source, scope);
+    return;
+  }
+  const { registry, error } = await loadRegistry({ refresh });
+  if (!registry) {
+    console.error(c.red(`
+  "${source}" is not a git URL or a local path, and the registry is unavailable.`));
+    console.error(c.dim("  " + (error || "no registry reachable") + "\n"));
+    process.exitCode = 1;
+    return;
+  }
+  const hit = resolveByName(registry.skills, source);
+  if (!hit) {
+    console.error(c.red(`
+  No skill named "${source}" in the registry.`));
+    console.error(c.dim('  Try "holt skill search ' + source + '" to find one.\n'));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(c.dim(`
+  Resolved "${hit.name}" -> ${hit.source}`));
+  installFromSource(hit.source, scope);
+}
+async function cmdSearch(query, refresh) {
+  const { registry, error, fromCache } = await loadRegistry({ refresh });
+  if (!registry) {
+    console.error(c.red("\n  Registry unavailable."));
+    console.error(c.dim("  " + (error || "no registry reachable") + "\n"));
+    process.exitCode = 1;
+    return;
+  }
+  const hits = searchSkills(registry.skills, query);
+  if (hits.length === 0) {
+    const what = query.trim() ? `matching "${query.trim()}"` : "in the registry";
+    console.log(c.dim(`
+  No skills ${what}.
+`));
+    return;
+  }
+  const nameW = Math.max(4, ...hits.map((s) => s.name.length));
+  const authorW = Math.max(6, ...hits.map((s) => (s.author || "").length));
+  console.log(
+    "\n" + c.accent("Registry") + c.dim("  " + registryUrl() + (fromCache ? "  (cached)" : ""))
+  );
+  console.log(
+    "  " + c.dim("name".padEnd(nameW)) + "  " + c.dim("author".padEnd(authorW)) + "  " + c.dim("description")
+  );
+  for (const s of hits) {
+    const desc = s.description.length > 56 ? s.description.slice(0, 55) + "\u2026" : s.description;
+    console.log(
+      "  " + c.bold(s.name.padEnd(nameW)) + "  " + c.dim((s.author || "").padEnd(authorW)) + "  " + (desc || c.dim("(no description)"))
+    );
+    console.log("  " + " ".repeat(nameW) + "  " + " ".repeat(authorW) + "  " + c.dim(s.source));
+  }
+  console.log(c.dim('\n  Install one with "holt skill add <name>".\n'));
+}
+function cmdPublish(name) {
+  let skillName = "";
+  let description = "";
+  let sourceHint = "";
+  if (name) {
+    const loaded = loadSkill(name);
+    if (!loaded) {
+      console.error(c.red(`
+  No skill named "${sanitizeName(name)}". Try "holt skill list".
+`));
+      process.exitCode = 1;
+      return;
+    }
+    let raw = "";
+    try {
+      raw = readFileSync13(join12(loaded.skill.dir, "SKILL.md"), "utf8");
+    } catch {
+      console.error(c.red("\n  Could not read the skill's SKILL.md.\n"));
+      process.exitCode = 1;
+      return;
+    }
+    const { data } = parseFrontmatter(raw);
+    skillName = sanitizeName(data.name || loaded.skill.name);
+    description = (data.description || loaded.skill.description || "").trim();
+  } else {
+    const file = join12(process.cwd(), "SKILL.md");
+    if (!existsSync12(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(readFileSync13(file, "utf8"));
+    skillName = sanitizeName(data.name || process.cwd().split(/[\\/]/).pop() || "");
+    description = (data.description || "").trim();
+    sourceHint = process.cwd();
+  }
+  if (!skillName || !description) {
+    console.error(c.red("\n  This skill is missing a name or description in its SKILL.md frontmatter."));
+    console.error(c.dim("  Both are required to publish. Add:  name: <name>  and  description: <one line>\n"));
+    process.exitCode = 1;
+    return;
+  }
+  const entry = buildPublishEntry({
+    name: skillName,
+    description,
+    source: sourceHint || `https://github.com/<you>/${skillName}`,
+    author: "<your name or handle>",
+    tags: []
+  });
+  console.log("\n" + c.accent(`Publish "${skillName}" to the Holt skill registry`));
+  console.log(c.dim("  The registry is a git-based JSON index. Publishing = opening a PR that adds your entry.\n"));
+  console.log(c.dim("  1. Push this skill to a public git repo (or note a subpath spec Holt can clone)."));
+  console.log(c.dim('  2. Add this entry to the "skills" array in registry.json:'));
+  console.log("");
+  console.log(entry);
+  console.log("");
+  console.log(c.dim('     Replace the "source" (your public git URL or path) and "author" fields.'));
+  console.log(c.dim("  3. Open a pull request against the registry repo:"));
+  console.log(c.dim("     " + REGISTRY_REPO_URL));
+  console.log(c.dim('\n  No push happens here. Once merged, anyone can "holt skill add ' + skillName + '".\n'));
+}
 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 = join8(skillsRoot("workspace"), clean);
-  const globalDir = join8(skillsRoot("global"), clean);
-  const target = existsSync8(wsDir) ? wsDir : existsSync8(globalDir) ? globalDir : "";
+  const wsDir = join12(skillsRoot("workspace"), clean);
+  const globalDir = join12(skillsRoot("global"), clean);
+  const target = existsSync12(wsDir) ? wsDir : existsSync12(globalDir) ? globalDir : "";
   if (!target) {
     console.error(c.dim(`
   No skill named "${clean}" found.
@@ -2344,7 +4191,7 @@ async function cmdRemove(name, ask) {
   const a = (await ask(`
   Delete ${scope} skill "${clean}"? [y/N] `) ?? "").trim().toLowerCase();
   if (a === "y" || a === "yes") {
-    rmSync3(target, { recursive: true, force: true });
+    rmSync5(target, { recursive: true, force: true });
     console.log(c.green("  Removed.\n"));
   } else {
     console.log(c.dim("  Kept.\n"));
@@ -2357,7 +4204,8 @@ async function skillCmd(sub, rest = []) {
     return;
   }
   const global = rest.includes("--global");
-  const args = rest.filter((a) => a !== "--global");
+  const refresh = rest.includes("--refresh");
+  const args = rest.filter((a) => a !== "--global" && a !== "--refresh");
   const action = (sub || "").toLowerCase();
   try {
     switch (action) {
@@ -2373,9 +4221,16 @@ async function skillCmd(sub, rest = []) {
       case "new":
         cmdCreate(args[0], global);
         break;
+      case "search":
+      case "find":
+        await cmdSearch(args.join(" "), refresh);
+        break;
       case "add":
       case "install":
-        cmdAdd(args[0], global);
+        await cmdAdd(args[0], global, refresh);
+        break;
+      case "publish":
+        cmdPublish(args[0]);
         break;
       case "remove":
       case "rm":
@@ -2392,9 +4247,73 @@ async function skillCmd(sub, rest = []) {
 }
 
 // src/commands/graph.ts
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
-import { join as join9, dirname as dirname2, resolve as resolve2 } from "path";
-import { spawn as spawn3 } from "child_process";
+import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync13 } from "fs";
+import { join as join14, dirname as dirname3, resolve as resolve4 } from "path";
+import { spawn as spawn4 } from "child_process";
+
+// src/communities.ts
+var MAX_ITERS = 30;
+function detectCommunities(input) {
+  const { nodeIds, edges } = input;
+  const order = nodeIds.slice();
+  const idx = /* @__PURE__ */ new Map();
+  order.forEach((id, i) => idx.set(id, i));
+  const adj = order.map(() => /* @__PURE__ */ new Map());
+  for (const e of edges) {
+    const a = idx.get(e.source);
+    const b = idx.get(e.target);
+    if (a === void 0 || b === void 0 || a === b) continue;
+    const am = adj[a];
+    const bm = adj[b];
+    am.set(b, (am.get(b) || 0) + 1);
+    bm.set(a, (bm.get(a) || 0) + 1);
+  }
+  const label = order.map((_, i) => i);
+  for (let iter = 0; iter < MAX_ITERS; iter++) {
+    let changed = false;
+    for (let i = 0; i < order.length; i++) {
+      const neigh = adj[i];
+      if (neigh.size === 0) continue;
+      const tally = /* @__PURE__ */ new Map();
+      for (const [j, w] of neigh) {
+        const lj = label[j];
+        tally.set(lj, (tally.get(lj) || 0) + w);
+      }
+      let best = label[i];
+      let bestW = -1;
+      for (const [lab, w] of tally) {
+        if (w > bestW || w === bestW && lab < best) {
+          best = lab;
+          bestW = w;
+        }
+      }
+      if (best !== label[i]) {
+        label[i] = best;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  const remap = /* @__PURE__ */ new Map();
+  const community = /* @__PURE__ */ new Map();
+  const members = /* @__PURE__ */ new Map();
+  for (let i = 0; i < order.length; i++) {
+    const raw = label[i];
+    let cid = remap.get(raw);
+    if (cid === void 0) {
+      cid = String(remap.size);
+      remap.set(raw, cid);
+    }
+    const id = order[i];
+    community.set(id, cid);
+    const arr = members.get(cid);
+    if (arr) arr.push(id);
+    else members.set(cid, [id]);
+  }
+  const sizes = /* @__PURE__ */ new Map();
+  for (const [cid, arr] of members) sizes.set(cid, arr.length);
+  return { community, members, sizes, count: members.size };
+}
 
 // src/graphview.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -2469,7 +4388,7 @@ var STOPWORDS = /* @__PURE__ */ new Set([
   "thanks",
   "lets"
 ]);
-function cosine2(a, b) {
+function cosine3(a, b) {
   let dot = 0;
   let na = 0;
   let nb = 0;
@@ -2529,7 +4448,7 @@ function buildGraph(turns) {
       const a = withEmb[i];
       for (let j = i + 1; j < withEmb.length; j++) {
         const b = withEmb[j];
-        const sim = cosine2(a.emb, b.emb);
+        const sim = cosine3(a.emb, b.emb);
         if (sim >= SEMANTIC_MIN) pairs.push({ source: a.id, target: b.id, sim });
       }
     }
@@ -2557,6 +4476,82 @@ function buildGraph(turns) {
   }
   return { nodes, edges };
 }
+function buildWikiGraph(pages) {
+  const nodes = [];
+  const edges = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    byKey.set(p.slug.toLowerCase(), p);
+    byKey.set(p.title.toLowerCase(), p);
+  }
+  for (const p of pages) {
+    nodes.push({ id: "wiki:" + p.slug, kind: "wiki", label: p.title });
+  }
+  for (const p of pages) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const raw of p.links) {
+      const target = byKey.get(raw.toLowerCase());
+      if (!target || target.slug === p.slug) continue;
+      const key = target.slug;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ source: "wiki:" + p.slug, target: "wiki:" + target.slug, kind: "wikilink", width: 2 });
+    }
+  }
+  return { nodes, edges };
+}
+function mergeGraphs(a, b) {
+  const seen = new Set(a.nodes.map((n) => n.id));
+  const nodes = [...a.nodes];
+  for (const n of b.nodes) if (!seen.has(n.id)) {
+    nodes.push(n);
+    seen.add(n.id);
+  }
+  return { nodes, edges: [...a.edges, ...b.edges] };
+}
+function buildCodeGraph(files, edges) {
+  const nodes = [];
+  const ids = new Set(files.map((f) => f.id));
+  for (const f of files) {
+    const snippet = f.content.replace(/\s+/g, " ").trim().slice(0, 180);
+    nodes.push({
+      id: f.id,
+      kind: f.kind === "code" ? "file" : "doc",
+      label: shortPath(f.id),
+      path: f.id,
+      ext: f.ext,
+      topDir: f.topDir,
+      snippet
+    });
+  }
+  const out = [];
+  for (const e of edges) {
+    if (!ids.has(e.source) || !ids.has(e.target)) continue;
+    out.push({ source: e.source, target: e.target, kind: e.kind, width: e.kind === "dep" ? 1.5 : 1.5 });
+  }
+  return { nodes, edges: out };
+}
+function shortPath(p) {
+  const parts = p.split("/");
+  return parts.length <= 2 ? p : parts.slice(-2).join("/");
+}
+function assignCommunities(graph2) {
+  const nodeIds = graph2.nodes.map((n) => n.id);
+  const idSet = new Set(nodeIds);
+  const edges = graph2.edges.filter((e) => idSet.has(e.source) && idSet.has(e.target)).map((e) => ({ source: e.source, target: e.target }));
+  const { community } = detectCommunities({ nodeIds, edges });
+  const degree = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) degree.set(id, 0);
+  for (const e of edges) {
+    degree.set(e.source, (degree.get(e.source) || 0) + 1);
+    degree.set(e.target, (degree.get(e.target) || 0) + 1);
+  }
+  for (const n of graph2.nodes) {
+    n.community = community.get(n.id);
+    n.degree = degree.get(n.id) || 0;
+  }
+  return graph2;
+}
 function escapeForScript(json) {
   return json.replace(/<\/(script)/gi, "<\\/$1").replace(/<!--/g, "<\\u0021--");
 }
@@ -2662,7 +4657,10 @@ function renderGraphHtml(graph2, meta) {
   <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 class="row"><span class="swatch" style="background:#5bd66f"></span>wiki page</div>
+  <div class="row"><span class="swatch" style="background:#e2704a"></span>code file</div>
+  <div class="row"><span class="swatch" style="background:#4a90d9"></span>doc file</div>
+  <div class="row"><span class="swatch" style="background:var(--line);border:1px solid var(--muted)"></span>ring = session / community</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>
@@ -2712,10 +4710,17 @@ function renderGraphHtml(graph2, meta) {
   });
 
   function radiusOf(n) {
-    var base = n.kind === "concept" ? 3 : 5;
+    var base = n.kind === "concept" ? 3 : n.kind === "wiki" ? 6 : (n.kind === "file" || n.kind === "doc") ? 5 : 5;
     return base + Math.min(9, Math.sqrt(n._deg) * 1.6);
   }
 
+  // ---- community tint: a stable hue per community id ----
+  function communityHue(cid) {
+    var k = parseInt(cid, 10);
+    if (isNaN(k)) k = 0;
+    return (k * 137.508) % 360; // golden-angle spread, same trick as sessions
+  }
+
   // ---- initial layout: spread on a spiral so physics has somewhere to start ----
   nodes.forEach(function (n, i) {
     var ang = i * 2.399963;
@@ -2727,7 +4732,7 @@ function renderGraphHtml(graph2, meta) {
 
   // ---- physics ----
   var REPULSION = 5200, SPRING = 0.02, GRAVITY = 0.015, DAMP = 0.86;
-  var restLen = { sequential: 60, semantic: 45, concept: 70 };
+  var restLen = { sequential: 60, semantic: 45, concept: 70, dep: 55, link: 55, wikilink: 55 };
 
   function step() {
     var i, j, n, m, dx, dy, d2, d, f;
@@ -2791,13 +4796,16 @@ function renderGraphHtml(graph2, meta) {
   var query = "";
 
   function roleColor(n) {
+    if (n.kind === "wiki") return "#5bd66f";
     if (n.kind === "concept") return "#9a8cff";
+    if (n.kind === "file") return "#e2704a";
+    if (n.kind === "doc") return "#4a90d9";
     return n.role === "user" ? "#f0b91e" : "#35d0d6";
   }
 
   function matchesQuery(n) {
     if (!query) return false;
-    var hay = (n.label || "") + " " + (n.content || "");
+    var hay = (n.label || "") + " " + (n.content || "") + " " + (n.path || "") + " " + (n.snippet || "");
     return hay.toLowerCase().indexOf(query) >= 0;
   }
 
@@ -2817,7 +4825,7 @@ function renderGraphHtml(graph2, meta) {
       }
       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.strokeStyle = lk.kind === "semantic" ? "#35d0d6" : lk.kind === "concept" ? "#9a8cff" : lk.kind === "wikilink" ? "#5bd66f" : lk.kind === "dep" ? "#e2704a" : lk.kind === "link" ? "#4a90d9" : "#4a5262";
       ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y); ctx.stroke();
     }
     ctx.globalAlpha = 1;
@@ -2831,12 +4839,17 @@ function renderGraphHtml(graph2, meta) {
       var faded = (highlightSet && !highlightSet.has(n.id)) || (query && !matchesQuery(n));
       ctx.globalAlpha = faded ? 0.18 : 1;
 
-      // session ring
+      // session ring (turns) or community ring (files/docs)
       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();
+      } else if ((n.kind === "file" || n.kind === "doc") && n.community != null) {
+        ctx.beginPath();
+        ctx.arc(p.x, p.y, r + 2.4, 0, Math.PI * 2);
+        ctx.strokeStyle = "hsl(" + communityHue(n.community) + ",70%,58%)";
+        ctx.lineWidth = 2; ctx.stroke();
       }
 
       ctx.beginPath();
@@ -2848,11 +4861,14 @@ function renderGraphHtml(graph2, meta) {
         ctx.lineWidth = 2; ctx.strokeStyle = "#ffffff"; ctx.stroke();
       }
 
-      // concept labels always; turn labels when zoomed in
-      if (n.kind === "concept" || view.scale > 1.4) {
+      // concept + wiki labels always; file/doc when zoomed a little; turn labels when zoomed in
+      var showLabel = n.kind === "concept" || n.kind === "wiki"
+        || ((n.kind === "file" || n.kind === "doc") && view.scale > 0.9)
+        || view.scale > 1.4;
+      if (showLabel) {
         ctx.globalAlpha = faded ? 0.25 : 0.9;
-        ctx.fillStyle = "#e7e9ee";
-        ctx.font = (n.kind === "concept" ? 11 : 10) + "px ui-monospace, monospace";
+        ctx.fillStyle = n.kind === "wiki" ? "#5bd66f" : n.kind === "file" ? "#e2704a" : n.kind === "doc" ? "#4a90d9" : "#e7e9ee";
+        ctx.font = (n.kind === "wiki" ? 12 : n.kind === "concept" ? 11 : 10) + "px ui-monospace, monospace";
         ctx.fillText(n.label, p.x + r + 4, p.y + 3);
       }
     }
@@ -2916,6 +4932,10 @@ function renderGraphHtml(graph2, meta) {
         var when = hov.ts ? new Date(hov.ts).toISOString().slice(0, 10) : "";
         var meta = hov.kind === "concept"
           ? ("concept &middot; in " + (hov.freq || 0) + " turns")
+          : hov.kind === "wiki"
+          ? "wiki page"
+          : (hov.kind === "file" || hov.kind === "doc")
+          ? (esc(hov.path || "") + " &middot; " + hov._deg + " links" + (hov.community != null ? " &middot; community " + esc(String(hov.community)) : ""))
           : (esc(hov.session || "") + (when ? " &middot; " + when : ""));
         tooltip.innerHTML = "<div>" + esc(hov.label) + "</div><div class='t-meta'>" + meta + "</div>";
         tooltip.style.display = "block";
@@ -2959,9 +4979,12 @@ function renderGraphHtml(graph2, meta) {
   }
   function onNodeClick(n) {
     selected = n.id;
-    if (n.kind === "concept") {
-      highlightSet = neighbors(n.id); // light up its connected turns
+    if (n.kind === "concept" || n.kind === "wiki") {
+      highlightSet = neighbors(n.id); // light up its connected nodes
       closePanel();
+    } else if (n.kind === "file" || n.kind === "doc") {
+      highlightSet = neighbors(n.id); // light up dependencies/links
+      openPanel(n);
     } else {
       highlightSet = null;
       openPanel(n);
@@ -2975,6 +4998,18 @@ function renderGraphHtml(graph2, meta) {
 
   // ---- side panel ----
   function openPanel(n) {
+    if (n.kind === "file" || n.kind === "doc") {
+      document.getElementById("p-session").textContent = (n.kind === "file" ? "code" : "doc") + (n.ext ? " (." + n.ext + ")" : "");
+      document.getElementById("p-dot").style.background = roleColor(n);
+      document.getElementById("p-role").textContent = n.path || n.label || "";
+      document.getElementById("p-role").style.color = roleColor(n);
+      // textContent keeps any <script>/<img onerror> in the path or snippet inert.
+      document.getElementById("p-content").textContent = n.snippet || "";
+      document.getElementById("p-time").textContent =
+        (n.community != null ? "community " + n.community + "  |  " : "") + (n._deg || 0) + " links";
+      panel.classList.add("open");
+      return;
+    }
     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 || "";
@@ -3009,17 +5044,384 @@ function renderGraphHtml(graph2, meta) {
 `;
 }
 
+// src/ingest.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
+import { join as join13, relative, sep, extname, dirname as dirname2, basename as basename2 } from "path";
+var CODE_EXT = /* @__PURE__ */ new Set([
+  "js",
+  "jsx",
+  "ts",
+  "tsx",
+  "mjs",
+  "cjs",
+  "py",
+  "go",
+  "rb",
+  "rs",
+  "java",
+  "kt",
+  "kts",
+  "swift",
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "hpp",
+  "cs",
+  "php",
+  "scala",
+  "sh",
+  "bash"
+]);
+var DOC_EXT = /* @__PURE__ */ new Set(["md", "mdx", "txt", "rst"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".holt",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "out",
+  "target",
+  "vendor",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".cache",
+  "tmp",
+  ".idea",
+  ".vscode"
+]);
+var MAX_FILES = 2e3;
+var MAX_FILE_BYTES = 400 * 1024;
+var MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+function toPosix(p) {
+  return sep === "/" ? p : p.split(sep).join("/");
+}
+function ingestFolder(root, want = { code: true, docs: true }) {
+  const files = [];
+  const skipped = { dirs: 0, tooBig: 0, unreadable: 0, hitFileCap: false, hitByteCap: false };
+  let totalBytes = 0;
+  const stack = [root];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync4(dir).sort((a, b) => a.localeCompare(b));
+    } catch {
+      skipped.unreadable++;
+      continue;
+    }
+    const subdirs = [];
+    for (const name of entries) {
+      if (files.length >= MAX_FILES) {
+        skipped.hitFileCap = true;
+        break;
+      }
+      const full = join13(dir, name);
+      let st;
+      try {
+        st = statSync6(full);
+      } catch {
+        skipped.unreadable++;
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (name.startsWith(".") || SKIP_DIRS.has(name)) {
+          skipped.dirs++;
+          continue;
+        }
+        subdirs.push(full);
+        continue;
+      }
+      if (!st.isFile()) continue;
+      const ext = extname(name).slice(1).toLowerCase();
+      const isCode = CODE_EXT.has(ext);
+      const isDoc = DOC_EXT.has(ext);
+      if (!isCode && !isDoc) continue;
+      if (isCode && !want.code) continue;
+      if (isDoc && !want.docs) continue;
+      if (st.size > MAX_FILE_BYTES) {
+        skipped.tooBig++;
+        continue;
+      }
+      if (totalBytes + st.size > MAX_TOTAL_BYTES) {
+        skipped.hitByteCap = true;
+        continue;
+      }
+      let content;
+      try {
+        content = readFileSync14(full, "utf8");
+      } catch {
+        skipped.unreadable++;
+        continue;
+      }
+      totalBytes += st.size;
+      const rel = toPosix(relative(root, full)) || name;
+      const firstSlash = rel.indexOf("/");
+      const topDir = firstSlash < 0 ? "." : rel.slice(0, firstSlash);
+      files.push({
+        id: rel,
+        path: rel,
+        kind: isCode ? "code" : "doc",
+        ext,
+        topDir,
+        content
+      });
+    }
+    if (files.length >= MAX_FILES) {
+      skipped.hitFileCap = true;
+    }
+    for (let i = subdirs.length - 1; i >= 0; i--) stack.push(subdirs[i]);
+  }
+  const byId = new Set(files.map((f) => f.id));
+  const edges = extractEdges(files, byId);
+  return { files, edges, skipped };
+}
+function extractEdges(files, byId) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (source, target, kind) => {
+    if (source === target) return;
+    const key = source + "\0" + target + "\0" + kind;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push({ source, target, kind });
+  };
+  for (const f of files) {
+    if (f.kind === "code") {
+      for (const spec of codeSpecifiers(f)) {
+        const resolved = resolveCodeSpec(f, spec, byId);
+        if (resolved) push(f.id, resolved, "dep");
+      }
+    } else {
+      for (const spec of docLinks(f.content)) {
+        const resolved = resolveDocLink(f, spec, byId, files);
+        if (resolved) push(f.id, resolved, "link");
+      }
+    }
+  }
+  return edges;
+}
+var JS_FROM_RE = /(?:import|export)\b[^;'"]*?\bfrom\s*['"]([^'"]+)['"]/g;
+var JS_BARE_IMPORT_RE = /\bimport\s*['"]([^'"]+)['"]/g;
+var JS_REQUIRE_RE = /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var JS_DYN_IMPORT_RE = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var PY_IMPORT_RE = /^[ \t]*import\s+([A-Za-z0-9_.]+)/gm;
+var PY_FROM_RE = /^[ \t]*from\s+(\.*[A-Za-z0-9_.]*)\s+import\b/gm;
+function matchAll(re, text) {
+  const out = [];
+  re.lastIndex = 0;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    if (m[1]) out.push(m[1]);
+  }
+  return out;
+}
+function codeSpecifiers(f) {
+  if (f.ext === "py") {
+    return [...matchAll(PY_IMPORT_RE, f.content), ...matchAll(PY_FROM_RE, f.content)];
+  }
+  if (["js", "jsx", "ts", "tsx", "mjs", "cjs"].includes(f.ext)) {
+    return [
+      ...matchAll(JS_FROM_RE, f.content),
+      ...matchAll(JS_BARE_IMPORT_RE, f.content),
+      ...matchAll(JS_REQUIRE_RE, f.content),
+      ...matchAll(JS_DYN_IMPORT_RE, f.content)
+    ];
+  }
+  return [];
+}
+var JS_TRY_EXT = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".d.ts"];
+var JS_INDEX = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx", "/index.mjs"];
+function joinPosix(fromDir, spec) {
+  const parts = (fromDir === "." ? [] : fromDir.split("/")).concat(spec.split("/"));
+  const out = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      out.pop();
+      continue;
+    }
+    out.push(part);
+  }
+  return out.join("/");
+}
+function resolveCodeSpec(f, spec, byId) {
+  if (f.ext === "py") return resolvePySpec(f, spec, byId);
+  if (!(spec.startsWith("./") || spec.startsWith("../"))) return null;
+  const fromDir = toPosixDir(f.id);
+  const base = joinPosix(fromDir, spec);
+  for (const ext of JS_TRY_EXT) {
+    const cand = base + ext;
+    if (cand && byId.has(cand)) return cand;
+  }
+  for (const idx of JS_INDEX) {
+    const cand = base + idx;
+    if (byId.has(cand)) return cand;
+  }
+  return null;
+}
+function resolvePySpec(f, spec, byId) {
+  let mod = spec;
+  let up = 0;
+  while (mod.startsWith(".")) {
+    up++;
+    mod = mod.slice(1);
+  }
+  const segs = mod ? mod.split(".") : [];
+  let baseDir = toPosixDir(f.id);
+  if (up > 0) {
+    for (let i = 1; i < up; i++) baseDir = toPosixDir(baseDir + "/x");
+  }
+  const relBase = up > 0 ? joinPosix(baseDir, segs.join("/")) : segs.join("/");
+  const candidates = up > 0 ? [relBase + ".py", relBase + "/__init__.py"] : [
+    relBase + ".py",
+    relBase + "/__init__.py",
+    // absolute import may still be relative to the file's own dir
+    joinPosix(toPosixDir(f.id), segs.join("/")) + ".py"
+  ];
+  for (const cand of candidates) if (cand && byId.has(cand)) return cand;
+  return null;
+}
+function toPosixDir(id) {
+  const d = toPosix(dirname2(id));
+  return d === "" || d === "." ? "." : d;
+}
+var MD_LINK_RE = /\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g;
+var WIKILINK_RE2 = /\[\[([^\]]+)\]\]/g;
+function docLinks(content) {
+  const out = [];
+  for (const raw of matchAll(MD_LINK_RE, content)) out.push(raw);
+  WIKILINK_RE2.lastIndex = 0;
+  let m;
+  while ((m = WIKILINK_RE2.exec(content)) !== null) {
+    const target = (m[1] || "").split("|")[0];
+    if (target && target.trim()) out.push(target.trim());
+  }
+  return out;
+}
+function resolveDocLink(f, spec, byId, files) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(spec) || spec.startsWith("#") || spec.startsWith("mailto:")) return null;
+  const clean = spec.split("#")[0].split("?")[0].trim();
+  if (!clean) return null;
+  if (clean.includes("/") || clean.includes(".")) {
+    const fromDir = toPosixDir(f.id);
+    const base = joinPosix(fromDir, clean);
+    for (const ext of ["", ".md", ".mdx", ".txt", ".rst"]) {
+      const cand = base + ext;
+      if (cand && byId.has(cand)) return cand;
+    }
+  }
+  const wantName = clean.toLowerCase();
+  for (const cand of files) {
+    if (cand.kind !== "doc") continue;
+    const stem = basename2(cand.id).replace(/\.[^.]+$/, "").toLowerCase();
+    if (stem === wantName) return cand.id;
+  }
+  return null;
+}
+
+// src/graphreport.ts
+var TOP_GOD_NODES = 12;
+var REP_PER_COMMUNITY = 6;
+function degrees(graph2) {
+  const idSet = new Set(graph2.nodes.map((n) => n.id));
+  const deg = /* @__PURE__ */ new Map();
+  for (const n of graph2.nodes) deg.set(n.id, 0);
+  for (const e of graph2.edges) {
+    if (!idSet.has(e.source) || !idSet.has(e.target)) continue;
+    deg.set(e.source, (deg.get(e.source) || 0) + 1);
+    deg.set(e.target, (deg.get(e.target) || 0) + 1);
+  }
+  return deg;
+}
+function reportLabel(n) {
+  return n.path || n.label || n.id;
+}
+function renderReport(graph2, meta) {
+  const date = new Date(meta.generatedAt ?? Date.now()).toISOString().slice(0, 10);
+  const lines = [];
+  lines.push(`# Graph Report - ${meta.workspace}  (${date})`);
+  lines.push("");
+  if (graph2.nodes.length === 0) {
+    lines.push("## Summary");
+    lines.push("- 0 nodes, 0 edges, 0 communities.");
+    lines.push("- Nothing to ingest here yet. Run `holt graph --code` or `holt graph --docs`");
+    lines.push("  in a folder with source or docs, then `holt graph report`.");
+    lines.push("");
+    return lines.join("\n") + "\n";
+  }
+  const deg = degrees(graph2);
+  const idSet = new Set(graph2.nodes.map((n) => n.id));
+  const validEdges = graph2.edges.filter((e) => idSet.has(e.source) && idSet.has(e.target));
+  const commMembers = /* @__PURE__ */ new Map();
+  for (const n of graph2.nodes) {
+    const cid = n.community ?? "0";
+    const arr = commMembers.get(cid);
+    if (arr) arr.push(n);
+    else commMembers.set(cid, [n]);
+  }
+  const communityCount = commMembers.size;
+  const fileCount = graph2.nodes.filter((n) => n.kind === "file").length;
+  const docCount = graph2.nodes.filter((n) => n.kind === "doc").length;
+  lines.push("## Summary");
+  lines.push(`- ${graph2.nodes.length} nodes, ${validEdges.length} edges, ${communityCount} communities detected`);
+  lines.push(`- Ingested: ${fileCount} code files, ${docCount} docs`);
+  lines.push("- Community algorithm: label propagation (deterministic, zero dependency)");
+  lines.push("");
+  lines.push("## God Nodes (most connected - your core files)");
+  const ranked = graph2.nodes.slice().sort((a, b) => (deg.get(b.id) || 0) - (deg.get(a.id) || 0) || reportLabel(a).localeCompare(reportLabel(b))).filter((n) => (deg.get(n.id) || 0) > 0).slice(0, TOP_GOD_NODES);
+  if (ranked.length === 0) {
+    lines.push("- None: no nodes have any edges yet (nothing links to anything).");
+  } else {
+    ranked.forEach((n, i) => {
+      const d = deg.get(n.id) || 0;
+      const cid = n.community ?? "0";
+      lines.push(`${i + 1}. \`${reportLabel(n)}\` - ${d} edges (community ${cid})`);
+    });
+  }
+  lines.push("");
+  lines.push("## Communities");
+  const sortedComms = [...commMembers.entries()].sort(
+    (a, b) => b[1].length - a[1].length || a[0].localeCompare(b[0])
+  );
+  for (const [cid, members] of sortedComms) {
+    lines.push("");
+    lines.push(`### Community ${cid} (${members.length} nodes)`);
+    const reps = members.slice().sort((a, b) => (deg.get(b.id) || 0) - (deg.get(a.id) || 0) || reportLabel(a).localeCompare(reportLabel(b))).slice(0, REP_PER_COMMUNITY).map((n) => reportLabel(n));
+    const extra = members.length - reps.length;
+    const shown = reps.join(", ");
+    lines.push(`Representative: ${shown}${extra > 0 ? ` (+${extra} more)` : ""}`);
+  }
+  lines.push("");
+  return lines.join("\n") + "\n";
+}
+
 // src/commands/graph.ts
 function parseArgs(args) {
-  const opts = { open: true };
+  const opts = { open: true, code: false, docs: false, report: false };
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
-    if (a === "--no-open") opts.open = false;
+    if (a === "report") opts.report = true;
+    else if (a === "--no-open") opts.open = false;
+    else if (a === "--wiki") opts.wiki = true;
+    else if (a === "--no-wiki") opts.wiki = false;
+    else if (a === "--code") opts.code = true;
+    else if (a === "--docs") opts.docs = true;
+    else if (a === "--all") {
+      opts.code = true;
+      opts.docs = true;
+    } else if (a === "--report") opts.report = true;
     else if (a === "--out") opts.out = args[++i];
     else if (a && a.startsWith("--out=")) opts.out = a.slice("--out=".length);
   }
   return opts;
 }
+function wikiGraphPages() {
+  return loadPages().map((p) => ({ slug: p.slug, title: p.title, links: extractLinks(p.body) }));
+}
 function openInBrowser(path) {
   try {
     let cmd;
@@ -3034,7 +5436,7 @@ function openInBrowser(path) {
       cmd = "xdg-open";
       cmdArgs = [path];
     }
-    const child = spawn3(cmd, cmdArgs, { detached: true, stdio: "ignore" });
+    const child = spawn4(cmd, cmdArgs, { detached: true, stdio: "ignore" });
     child.on("error", () => {
     });
     child.unref();
@@ -3049,13 +5451,57 @@ async function graph(args = []) {
   }
   close();
   const opts = parseArgs(args);
+  if (opts.report && !opts.code && !opts.docs) {
+    opts.code = true;
+    opts.docs = true;
+  }
+  const ingestCode = opts.code;
+  const ingestDocs = opts.docs;
   const turns = loadTurns();
-  if (turns.length === 0) {
+  const includeWiki = opts.wiki !== void 0 ? opts.wiki : existsSync13(wikiDir());
+  const wikiPages = includeWiki ? wikiGraphPages() : [];
+  let fileNodeCount = 0;
+  let docNodeCount = 0;
+  let codeGraph = null;
+  if (ingestCode || ingestDocs) {
+    const res = ingestFolder(workspace(), { code: ingestCode, docs: ingestDocs });
+    codeGraph = buildCodeGraph(res.files, res.edges);
+    fileNodeCount = codeGraph.nodes.filter((n) => n.kind === "file").length;
+    docNodeCount = codeGraph.nodes.filter((n) => n.kind === "doc").length;
+    const skipNotes = [];
+    if (res.skipped.dirs) skipNotes.push(`${res.skipped.dirs} dirs`);
+    if (res.skipped.tooBig) skipNotes.push(`${res.skipped.tooBig} too-big`);
+    if (res.skipped.unreadable) skipNotes.push(`${res.skipped.unreadable} unreadable`);
+    if (res.skipped.hitFileCap) skipNotes.push("file cap hit");
+    if (res.skipped.hitByteCap) skipNotes.push("byte cap hit");
+    if (skipNotes.length) console.log(c.dim(`  ingest skipped: ${skipNotes.join(", ")}`));
+  }
+  if (turns.length === 0 && wikiPages.length === 0 && !codeGraph) {
     console.log(c.dim('\n  No memory in this folder yet. Have a chat first with "holt chat", then come back.\n'));
+    console.log(c.dim(`  Or ingest this folder's code/docs: "holt graph --code" / "holt graph --docs".
+`));
+    return;
+  }
+  let g = buildGraph(turns);
+  if (wikiPages.length) g = mergeGraphs(g, buildWikiGraph(wikiPages));
+  if (codeGraph) g = mergeGraphs(g, codeGraph);
+  if (codeGraph) assignCommunities(g);
+  if (opts.report) {
+    const md = renderReport(g, { workspace: workspace() });
+    const reportPath = opts.out ? resolve4(opts.out) : join14(workspace(), "GRAPH_REPORT.md");
+    mkdirSync10(dirname3(reportPath), { recursive: true });
+    writeFileSync11(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)`);
+    console.log(`  edges        ${g.edges.length}`);
+    console.log(`  communities  ${g.nodes.length ? communities : 0}`);
+    console.log(`  file         ${reportPath}
+`);
     return;
   }
-  const g = buildGraph(turns);
   const conceptCount = g.nodes.filter((n) => n.kind === "concept").length;
+  const wikiCount = g.nodes.filter((n) => n.kind === "wiki").length;
   const sessions = new Set(turns.map((t) => t.session)).size;
   const html = renderGraphHtml(g, {
     workspace: workspace(),
@@ -3064,11 +5510,15 @@ async function graph(args = []) {
     concepts: conceptCount,
     edges: g.edges.length
   });
-  const outPath = opts.out ? resolve2(opts.out) : join9(wsHoltDir(), "graph.html");
-  mkdirSync7(dirname2(outPath), { recursive: true });
-  writeFileSync8(outPath, html, "utf8");
+  const outPath = opts.out ? resolve4(opts.out) : join14(wsHoltDir(), "graph.html");
+  mkdirSync10(dirname3(outPath), { recursive: true });
+  writeFileSync11(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)`);
+  const parts = [`${turns.length} turns`, `${conceptCount} concepts`];
+  if (wikiCount) parts.push(`${wikiCount} wiki pages`);
+  if (fileNodeCount) parts.push(`${fileNodeCount} code files`);
+  if (docNodeCount) parts.push(`${docNodeCount} docs`);
+  console.log(`  nodes    ${g.nodes.length}  (${parts.join(", ")})`);
   console.log(`  edges    ${g.edges.length}`);
   console.log(`  file     ${outPath}`);
   if (opts.open) {
@@ -3174,7 +5624,7 @@ function recoverId(line) {
   return null;
 }
 function runMcpServer(opts) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve8) => {
     const stdin = process.stdin;
     let buffer = "";
     let chain = Promise.resolve();
@@ -3226,11 +5676,11 @@ function runMcpServer(opts) {
         processLine(buffer);
         buffer = "";
       }
-      chain.then(() => resolve4()).catch(() => resolve4());
+      chain.then(() => resolve8()).catch(() => resolve8());
     });
     stdin.on("error", (e) => {
       console.error(`[mcp] stdin error: ${e.message}`);
-      chain.then(() => resolve4()).catch(() => resolve4());
+      chain.then(() => resolve8()).catch(() => resolve8());
     });
     stdin.resume();
   });
@@ -3350,7 +5800,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.8.4";
+var VERSION = "0.10.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -3395,10 +5845,379 @@ async function mcp(sub, rest = []) {
   }
 }
 
+// src/commands/hook.ts
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync11, copyFileSync, realpathSync as realpathSync2 } from "fs";
+import { join as join15, dirname as dirname4 } from "path";
+import { homedir as homedir3 } from "os";
+var EVENT = {
+  inject: "UserPromptSubmit",
+  capture: "Stop"
+};
+var HOOK_CMD = {
+  inject: "holt hook inject",
+  capture: "holt hook capture"
+};
+function globalSettingsPath() {
+  return join15(homedir3(), ".claude", "settings.json");
+}
+function projectSettingsPath() {
+  return join15(process.cwd(), ".claude", "settings.json");
+}
+function readSettings(path) {
+  if (!existsSync14(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync15(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) {
+  mkdirSync11(dirname4(path), { recursive: true });
+  writeFileSync12(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+function backup(path) {
+  if (!existsSync14(path)) return null;
+  const dest = `${path}.holt-bak`;
+  try {
+    copyFileSync(path, dest);
+    return dest;
+  } catch {
+    return null;
+  }
+}
+function isHoltEntry(m, dir) {
+  return Array.isArray(m.hooks) && m.hooks.some((h) => typeof h?.command === "string" && h.command.includes(HOOK_CMD[dir]));
+}
+function addHook(settings, dir) {
+  settings.hooks = settings.hooks ?? {};
+  const event = EVENT[dir];
+  const list = settings.hooks[event] = settings.hooks[event] ?? [];
+  if (list.some((m) => isHoltEntry(m, dir))) return false;
+  list.push({ hooks: [{ type: "command", command: HOOK_CMD[dir] }] });
+  return true;
+}
+function removeHook(settings, dir) {
+  const event = EVENT[dir];
+  const list = settings.hooks?.[event];
+  if (!Array.isArray(list)) return false;
+  let changed = false;
+  const kept = [];
+  for (const m of list) {
+    if (!isHoltEntry(m, dir)) {
+      kept.push(m);
+      continue;
+    }
+    const others = (m.hooks || []).filter((h) => !(typeof h?.command === "string" && h.command.includes(HOOK_CMD[dir])));
+    if (others.length) kept.push({ ...m, hooks: others });
+    changed = true;
+  }
+  if (!changed) return false;
+  if (kept.length) settings.hooks[event] = kept;
+  else delete settings.hooks[event];
+  return true;
+}
+function isHoltInstalled(settings, dir) {
+  const list = settings.hooks?.[EVENT[dir]];
+  return Array.isArray(list) && list.some((m) => isHoltEntry(m, dir));
+}
+function parseFlags(rest) {
+  let injectOnly = false;
+  let captureOnly = false;
+  let project = false;
+  for (const a of rest) {
+    if (a === "--inject-only") injectOnly = true;
+    else if (a === "--capture-only") captureOnly = true;
+    else if (a === "--project") project = true;
+  }
+  const inject2 = injectOnly || !captureOnly;
+  const capture2 = captureOnly || !injectOnly;
+  return { inject: inject2, capture: capture2, project };
+}
+function install(rest) {
+  const flags = parseFlags(rest);
+  const path = flags.project ? projectSettingsPath() : globalSettingsPath();
+  const target = flags.project ? "project (./.claude/settings.json)" : "global (~/.claude/settings.json)";
+  let settings;
+  try {
+    settings = readSettings(path);
+  } catch (e) {
+    console.error(c.red("  " + e.message));
+    process.exitCode = 1;
+    return;
+  }
+  const bak = backup(path);
+  const changed = [];
+  if (flags.inject && addHook(settings, "inject")) changed.push("inject");
+  if (flags.capture && addHook(settings, "capture")) changed.push("capture");
+  writeSettings(path, settings);
+  const wanted = [flags.inject ? "inject" : "", flags.capture ? "capture" : ""].filter(Boolean).join(" + ");
+  if (changed.length) {
+    console.log(c.green(`  installed ${changed.join(" + ")} into ${target}`));
+  } else {
+    console.log(c.dim(`  ${wanted} already installed in ${target} (no change)`));
+  }
+  if (bak) console.log(c.dim(`  backup: ${bak}`));
+  console.log(c.dim("  Holt now injects folder memory before each prompt and captures facts when a session ends,"));
+  console.log(c.dim("  but only in folders you have trusted with an existing .holt/memory."));
+  console.log(c.dim("  Undo any time with: holt hook remove" + (flags.project ? " --project" : "")));
+}
+function remove(rest) {
+  const project = rest.includes("--project");
+  const paths = project ? [projectSettingsPath()] : [globalSettingsPath(), projectSettingsPath()];
+  let touchedAny = false;
+  for (const path of paths) {
+    if (!existsSync14(path)) continue;
+    let settings;
+    try {
+      settings = readSettings(path);
+    } catch (e) {
+      console.error(c.red("  " + e.message));
+      continue;
+    }
+    const bak = backup(path);
+    let changed = false;
+    if (removeHook(settings, "inject")) changed = true;
+    if (removeHook(settings, "capture")) changed = true;
+    if (changed) {
+      if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
+      writeSettings(path, settings);
+      console.log(c.green(`  removed Holt hooks from ${path}`));
+      if (bak) console.log(c.dim(`  backup: ${bak}`));
+      touchedAny = true;
+    }
+  }
+  if (!touchedAny) console.log(c.dim("  no Holt hooks found to remove."));
+}
+function status(rest) {
+  const project = rest.includes("--project");
+  const entries = project ? [{ label: "project", path: projectSettingsPath() }] : [
+    { label: "global", path: globalSettingsPath() },
+    { label: "project", path: projectSettingsPath() }
+  ];
+  console.log(c.accent("  Holt ambient hooks"));
+  for (const e of entries) {
+    if (!existsSync14(e.path)) {
+      console.log(c.dim(`  ${e.label.padEnd(8)} ${e.path}  (no settings file)`));
+      continue;
+    }
+    let settings;
+    try {
+      settings = readSettings(e.path);
+    } catch {
+      console.log(c.red(`  ${e.label.padEnd(8)} ${e.path}  (unreadable JSON)`));
+      continue;
+    }
+    const inj = isHoltInstalled(settings, "inject");
+    const cap = isHoltInstalled(settings, "capture");
+    const active = [inj ? "inject" : "", cap ? "capture" : ""].filter(Boolean).join(" + ") || "none";
+    const mark = inj || cap ? c.green("on ") : c.dim("off");
+    console.log(`  ${e.label.padEnd(8)} ${mark}  ${c.dim(e.path)}  ${c.dim("[" + active + "]")}`);
+  }
+  console.log(c.dim("  Runtime hooks only act in trusted Holt folders that already have .holt/memory."));
+}
+function readStdin(timeoutMs) {
+  return new Promise((resolve8) => {
+    let input = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve8(input);
+    };
+    try {
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk2) => {
+        input += chunk2;
+      });
+      process.stdin.on("end", finish);
+      process.stdin.on("error", finish);
+    } catch {
+      finish();
+    }
+    setTimeout(finish, timeoutMs);
+  });
+}
+function parseHookInput(raw) {
+  try {
+    const j = JSON.parse(raw || "{}");
+    return j && typeof j === "object" ? j : {};
+  } catch {
+    return {};
+  }
+}
+function enterFolder(cwd) {
+  if (!cwd || !existsSync14(cwd)) return null;
+  try {
+    const real = realpathSync2(cwd);
+    process.chdir(real);
+    return real;
+  } catch {
+    return null;
+  }
+}
+function guardTrusted(real) {
+  if (!isTrusted(real)) return false;
+  if (!existsSync14(memDir())) return false;
+  return true;
+}
+async function inject() {
+  try {
+    const raw = await readStdin(2e3);
+    const data = parseHookInput(raw);
+    const prompt = (data.prompt || "").trim();
+    if (prompt.length < 3) return;
+    const real = enterFolder(data.cwd);
+    if (!real) return;
+    if (!guardTrusted(real)) return;
+    const session = data.session_id || newSessionId();
+    const hits = await recall(prompt, session, 4);
+    if (!hits.length) return;
+    const lines = hits.map((h) => `- ${h.turn.content.replace(/\s+/g, " ").trim().slice(0, 500)}`);
+    process.stdout.write(
+      ["[Holt memory - relevant notes from earlier sessions in this folder]", ...lines, ""].join("\n")
+    );
+  } catch (e) {
+    process.stderr.write("holt hook inject: " + (e instanceof Error ? e.message : String(e)) + "\n");
+  }
+}
+function readTranscript(path) {
+  const out = [];
+  let raw;
+  try {
+    raw = readFileSync15(path, "utf8");
+  } catch {
+    return out;
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const d = rec;
+    if (d.type !== "user" && d.type !== "assistant") continue;
+    const m = d.message;
+    if (!m || m.role !== "user" && m.role !== "assistant") continue;
+    let text = "";
+    if (typeof m.content === "string") {
+      text = m.content;
+    } else if (Array.isArray(m.content)) {
+      text = m.content.map((b) => {
+        if (typeof b === "string") return b;
+        if (b && typeof b.text === "string") return b.text;
+        return "";
+      }).join(" ").trim();
+    }
+    text = text.trim();
+    if (text.length < 3) continue;
+    out.push({ role: m.role, content: text });
+  }
+  return out;
+}
+function resolveExtractionBrain(cfg) {
+  const id = cfg.defaultBrain;
+  if (!id) return null;
+  if (BRAIN_IDS.includes(id)) {
+    const bid = id;
+    if (!cfg.brains[bid].enabled) return null;
+    if (!isInstalled(cfg.brains[bid].command)) return null;
+    return { kind: "cli", id: bid };
+  }
+  const api = findApiBrain(cfg, id);
+  if (api && resolveApiKey(api)) return { kind: "api", brain: api };
+  return null;
+}
+async function capture() {
+  try {
+    const raw = await readStdin(3e3);
+    const data = parseHookInput(raw);
+    const real = enterFolder(data.cwd);
+    if (!real) return;
+    if (!guardTrusted(real)) return;
+    const cfg = loadConfig();
+    if (!cfg) return;
+    if (cfg.memory?.extractFacts === false) return;
+    const brain = resolveExtractionBrain(cfg);
+    if (!brain) return;
+    if (!data.transcript_path) return;
+    const history = readTranscript(data.transcript_path);
+    if (!history.length) return;
+    const session = "hook-" + (data.session_id || newSessionId());
+    const n = await extractAndSaveFacts(brain, cfg, history, session);
+    if (n > 0) process.stderr.write(`holt hook capture: saved ${n} fact${n === 1 ? "" : "s"} to ${memDir()}
+`);
+    if (cfg.wiki?.autoSync) {
+      const res = await syncWiki(cfg, () => resolveBrainMaintainer(cfg));
+      if (res.status === "ok" && res.changed) {
+        process.stderr.write(
+          `holt hook capture: updated the wiki (${res.created} created, ${res.updated} updated) in ${wikiDir()}
+`
+        );
+      }
+    }
+  } catch (e) {
+    process.stderr.write("holt hook capture: " + (e instanceof Error ? e.message : String(e)) + "\n");
+  }
+}
+var USAGE2 = [
+  "  holt hook <command>",
+  "",
+  "  Wire Holt into Claude Code so folder memory works ambiently: it injects",
+  "  relevant remembered notes before each prompt and captures durable facts",
+  "  when a session ends. Both run only in trusted Holt folders that already",
+  "  have .holt/memory.",
+  "",
+  "  management:",
+  "    install [flags]   write the hooks into Claude Code settings",
+  "        --inject-only   install only the before-prompt recall hook",
+  "        --capture-only  install only the end-of-session fact hook",
+  "        --project       write ./.claude/settings.json (default: ~/.claude)",
+  "    remove [--project]  remove ONLY Holt hooks, leaving other settings intact",
+  "    status [--project]  show what is installed and which directions are active",
+  "",
+  "  runtime (invoked by Claude Code, not you):",
+  "    inject    UserPromptSubmit body: recall + print a context block",
+  "    capture   Stop body: distill facts from the transcript and save them",
+  "",
+  "  example: holt hook install        # both hooks, global settings"
+].join("\n");
+async function hook(sub, rest = []) {
+  switch (sub) {
+    case "install":
+      install(rest);
+      return;
+    case "remove":
+    case "uninstall":
+      remove(rest);
+      return;
+    case "status":
+      status(rest);
+      return;
+    case "inject":
+      await inject();
+      return;
+    case "capture":
+      await capture();
+      return;
+    case void 0:
+    case "help":
+    case "-h":
+    case "--help":
+      console.log(USAGE2);
+      return;
+    default:
+      console.error(`  Unknown hook command: "${sub}". Run "holt hook help".`);
+      process.exitCode = 1;
+  }
+}
+
 // src/commands/run.ts
-import { writeFileSync as writeFileSync9 } from "fs";
-import { resolve as resolve3 } from "path";
-var USAGE = [
+import { writeFileSync as writeFileSync13 } from "fs";
+import { resolve as resolve5 } from "path";
+var USAGE3 = [
   "  holt run <task> [options]",
   "",
   "  Run a single task against your default brain and stream the reply.",
@@ -3448,7 +6267,7 @@ function parseArgs2(args) {
 async function run(args) {
   const p = parseArgs2(args);
   if (!p.task) {
-    console.log(USAGE);
+    console.log(USAGE3);
     return;
   }
   if (!isTrusted()) {
@@ -3486,9 +6305,9 @@ async function run(args) {
     process.stdout.write("\n");
   }
   if (p.out) {
-    const target = resolve3(process.cwd(), p.out);
+    const target = resolve5(process.cwd(), p.out);
     try {
-      writeFileSync9(target, result.text, "utf8");
+      writeFileSync13(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");
@@ -3499,38 +6318,38 @@ async function run(args) {
 
 // src/commands/schedule.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync9, rmSync as rmSync4, existsSync as existsSync9 } from "fs";
-import { dirname as dirname3 } from "path";
+import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync13, rmSync as rmSync6, existsSync as existsSync15 } from "fs";
+import { dirname as dirname5 } from "path";
 
 // src/scheduler.ts
-import { homedir as homedir3 } from "os";
-import { join as join10 } from "path";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync10, mkdirSync as mkdirSync8 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join16 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync14, mkdirSync as mkdirSync12 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
 import { spawnSync as spawnSync3 } from "child_process";
 function schedulesPath() {
-  return join10(GLOBAL_DIR, "schedules.json");
+  return join16(GLOBAL_DIR, "schedules.json");
 }
 function logsDir() {
-  return join10(GLOBAL_DIR, "logs");
+  return join16(GLOBAL_DIR, "logs");
 }
 function logPath(id) {
-  return join10(logsDir(), `${id}.log`);
+  return join16(logsDir(), `${id}.log`);
 }
 function plistPath(id) {
-  return join10(homedir3(), "Library", "LaunchAgents", `com.holt.${id}.plist`);
+  return join16(homedir4(), "Library", "LaunchAgents", `com.holt.${id}.plist`);
 }
 function loadJobs() {
   try {
-    const raw = JSON.parse(readFileSync9(schedulesPath(), "utf8"));
+    const raw = JSON.parse(readFileSync16(schedulesPath(), "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
 function saveJobs(jobs) {
-  mkdirSync8(GLOBAL_DIR, { recursive: true });
-  writeFileSync10(schedulesPath(), JSON.stringify(jobs, null, 2) + "\n", "utf8");
+  mkdirSync12(GLOBAL_DIR, { recursive: true });
+  writeFileSync14(schedulesPath(), JSON.stringify(jobs, null, 2) + "\n", "utf8");
 }
 function addJob(job) {
   const jobs = loadJobs();
@@ -3575,6 +6394,10 @@ function resolveHoltPath() {
 function buildCommand(job, holtPath) {
   const holt = shQuote(holtPath);
   const ws = shQuote(job.workspace);
+  if (job.runArgs && job.runArgs.length > 0) {
+    const parts = job.runArgs.map(shQuote).join(" ");
+    return `cd ${ws} && ${holt} ${parts} --quiet`;
+  }
   const log = shQuote(logPath(job.id));
   let cmd = `cd ${ws} && ${holt} run ${shQuote(job.task)}`;
   if (job.brain) cmd += ` --brain ${shQuote(job.brain)}`;
@@ -3634,7 +6457,7 @@ function appendCronLine(crontab, line) {
   return (base ? base + "\n" : "") + line + "\n";
 }
 function ensureLogsDir() {
-  mkdirSync8(logsDir(), { recursive: true });
+  mkdirSync12(logsDir(), { recursive: true });
 }
 
 // src/commands/schedule.ts
@@ -3660,8 +6483,8 @@ function parseAdd(rest) {
 }
 function installDarwin(job, holtPath) {
   const path = plistPath(job.id);
-  mkdirSync9(dirname3(path), { recursive: true });
-  writeFileSync11(path, buildLaunchdPlist(job, holtPath), "utf8");
+  mkdirSync13(dirname5(path), { recursive: true });
+  writeFileSync15(path, buildLaunchdPlist(job, holtPath), "utf8");
   const res = spawnSync4("launchctl", ["load", "-w", path], { encoding: "utf8" });
   if (res.status === 0) {
     console.log(c.green("  Loaded into launchd."));
@@ -3690,114 +6513,576 @@ function installLinux(job, holtPath) {
     console.log(c.dim("  Could not update the crontab automatically. Add this line yourself:"));
     console.log("  " + line);
   }
-}
-async function addCmd(rest) {
-  const { task, when, opts } = parseAdd(rest);
-  if (!task || !when) {
-    console.log(c.dim('\n  Usage: holt schedule add "<task>" <HH:MM> [--name <n>] [--notify] [--brain <id>]\n'));
+}
+async function addCmd(rest) {
+  const { task, when, opts } = parseAdd(rest);
+  if (!task || !when) {
+    console.log(c.dim('\n  Usage: holt schedule add "<task>" <HH:MM> [--name <n>] [--notify] [--brain <id>]\n'));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    parseWhen(when);
+  } catch (e) {
+    console.error("\n  " + c.red(e.message) + "\n");
+    process.exitCode = 1;
+    return;
+  }
+  const ws = workspace();
+  const holtPath = resolveHoltPath();
+  const job = {
+    id: newJobId(),
+    name: opts.name || task.slice(0, 40),
+    task,
+    when,
+    workspace: ws,
+    notify: opts.notify,
+    ...opts.brain ? { brain: opts.brain } : {}
+  };
+  ensureLogsDir();
+  addJob(job);
+  console.log("\n" + c.accent("Scheduled."));
+  console.log(`  id         ${job.id}`);
+  console.log(`  when       daily at ${job.when}`);
+  console.log(`  workspace  ${job.workspace}`);
+  if (job.notify) console.log(`  notify     on (pushes output to Telegram)`);
+  console.log(`  log        ${logPath(job.id)}`);
+  if (process.platform === "darwin") installDarwin(job, holtPath);
+  else if (process.platform === "linux") installLinux(job, holtPath);
+  else {
+    console.log(c.dim("\n  Your OS has no built-in installer. Install this entry yourself:"));
+    console.log("  " + buildCronLine(job, holtPath));
+  }
+  console.log("");
+}
+function listCmd2() {
+  const jobs = loadJobs();
+  if (jobs.length === 0) {
+    console.log(c.dim("\n  No scheduled tasks yet. Add one with:"));
+    console.log(c.dim('  holt schedule add "<task>" <HH:MM> [--notify]\n'));
+    return;
+  }
+  console.log("\n" + c.accent("Scheduled tasks"));
+  for (const j of jobs) {
+    console.log(`  ${c.bold(j.id)}  daily ${j.when}  ${c.dim(j.notify ? "(notify)" : "")}`);
+    console.log(`      ${j.name}`);
+    console.log(c.dim(`      ${j.workspace}`));
+  }
+  console.log("");
+}
+function removeDarwin(id) {
+  const path = plistPath(id);
+  if (existsSync15(path)) {
+    spawnSync4("launchctl", ["unload", path], { encoding: "utf8" });
+    try {
+      rmSync6(path);
+    } catch {
+    }
+  }
+}
+function removeLinux(id) {
+  const res = spawnSync4("crontab", ["-l"], { encoding: "utf8" });
+  const body = res.status === 0 && typeof res.stdout === "string" ? res.stdout : "";
+  const next = stripCronLines(body, id);
+  spawnSync4("crontab", ["-"], { input: next, encoding: "utf8" });
+}
+function removeCmd(rest) {
+  const id = rest[0];
+  if (!id) {
+    console.log(c.dim("\n  Usage: holt schedule remove <id>   (see ids with: holt schedule list)\n"));
+    process.exitCode = 1;
+    return;
+  }
+  const before = loadJobs();
+  const existed = before.some((j) => j.id === id);
+  removeJob(id);
+  if (process.platform === "darwin") removeDarwin(id);
+  else if (process.platform === "linux") removeLinux(id);
+  if (existed) console.log("\n" + c.green(`  Removed schedule ${id}.`) + "\n");
+  else {
+    console.error(c.dim(`
+  No schedule with id ${id}. Nothing to remove.
+`));
+    process.exitCode = 1;
+  }
+}
+function usage2() {
+  console.log("\n" + c.accent("holt schedule") + c.dim("  run a task automatically on a timer"));
+  console.log(c.dim('\n  holt schedule add "<task>" <HH:MM> [--name <n>] [--notify] [--brain <id>]'));
+  console.log(c.dim("  holt schedule list"));
+  console.log(c.dim("  holt schedule remove <id>\n"));
+}
+async function schedule(sub, rest = []) {
+  const action = (sub || "").toLowerCase();
+  if (action === "list") {
+    listCmd2();
+    return;
+  }
+  if (action !== "add" && action !== "remove" && action !== "rm") {
+    if (action) process.exitCode = 1;
+    usage2();
+    return;
+  }
+  const { ask, close } = createReader();
+  if (!await ensureTrusted(ask)) {
+    close();
+    return;
+  }
+  close();
+  if (action === "add") await addCmd(rest);
+  else removeCmd(rest);
+}
+
+// src/commands/routine.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync15, rmSync as rmSync7, existsSync as existsSync16 } from "fs";
+import { dirname as dirname6, resolve as resolve6 } from "path";
+
+// src/routines.ts
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync16, mkdirSync as mkdirSync14 } from "fs";
+import { join as join17 } from "path";
+function sanitizeRoutineName(name) {
+  return (name || "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function routinesPath() {
+  return join17(GLOBAL_DIR, "routines.json");
+}
+function loadRoutines() {
+  try {
+    const raw = JSON.parse(readFileSync17(routinesPath(), "utf8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+function saveRoutines(routines) {
+  mkdirSync14(GLOBAL_DIR, { recursive: true });
+  writeFileSync16(routinesPath(), JSON.stringify(routines, null, 2) + "\n", "utf8");
+}
+function findRoutine(name) {
+  const want = sanitizeRoutineName(name);
+  return loadRoutines().find((r) => r.name === want);
+}
+function upsertRoutine(routine2) {
+  const routines = loadRoutines().filter((r) => r.name !== routine2.name);
+  routines.push(routine2);
+  saveRoutines(routines);
+  return routines;
+}
+function removeRoutine(name) {
+  const want = sanitizeRoutineName(name);
+  const routines = loadRoutines().filter((r) => r.name !== want);
+  saveRoutines(routines);
+  return routines;
+}
+var ROUTINE_TEMPLATES = {
+  "daily-brief": {
+    describe: "A short daily brief of what changed and what is open in this folder, pushed to Telegram.",
+    source: {
+      kind: "task",
+      value: "Summarize what changed and what is open in this folder recently, as a short brief. Lead with the most important item. Keep it to a few tight bullets."
+    },
+    when: "08:00",
+    notify: true
+  },
+  standup: {
+    describe: "A daily standup: what got done, what is next, and any blockers in this folder.",
+    source: {
+      kind: "task",
+      value: "Write a short standup for this folder: what got done recently, what is next, and any blockers. Three short sections, plain text."
+    },
+    when: "09:00",
+    notify: true
+  }
+};
+function templateNames() {
+  return Object.keys(ROUTINE_TEMPLATES).sort();
+}
+
+// src/commands/routine.ts
+function jobForRoutine(r) {
+  return {
+    id: routineJobId(r.name),
+    name: `routine:${r.name}`,
+    task: r.source.kind === "task" ? r.source.value : `skill:${r.source.value}`,
+    when: r.when,
+    workspace: r.workspace,
+    notify: r.notify,
+    ...r.brain ? { brain: r.brain } : {},
+    runArgs: ["routine", "run", r.name]
+  };
+}
+function routineJobId(name) {
+  return `routine-${sanitizeRoutineName(name)}`;
+}
+function installDarwin2(job, holtPath) {
+  const path = plistPath(job.id);
+  mkdirSync15(dirname6(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."));
+  } else {
+    console.log(c.dim("  Wrote the plist, but launchctl load did not confirm."));
+    console.log(c.dim(`  Load it yourself with:  launchctl load -w ${path}`));
+    if (res.stderr && res.stderr.trim()) console.log(c.dim(`  (${res.stderr.trim()})`));
+  }
+  console.log(c.dim(`  plist: ${path}`));
+}
+function currentCrontab2() {
+  const res = spawnSync5("crontab", ["-l"], { encoding: "utf8" });
+  return res.status === 0 && typeof res.stdout === "string" ? res.stdout : "";
+}
+function writeCrontab2(body) {
+  const res = spawnSync5("crontab", ["-"], { input: body, encoding: "utf8" });
+  return res.status === 0;
+}
+function installLinux2(job, holtPath) {
+  const line = buildCronLine(job, holtPath);
+  const next = appendCronLine(currentCrontab2(), line);
+  if (writeCrontab2(next)) {
+    console.log(c.green("  Added to your crontab."));
+    console.log(c.dim(`  line: ${line}`));
+  } else {
+    console.log(c.dim("  Could not update the crontab automatically. Add this line yourself:"));
+    console.log("  " + line);
+  }
+}
+function installSchedule(r) {
+  const holtPath = resolveHoltPath();
+  const job = jobForRoutine(r);
+  removeSchedule(r.name);
+  addJob(job);
+  if (process.platform === "darwin") installDarwin2(job, holtPath);
+  else if (process.platform === "linux") installLinux2(job, holtPath);
+  else {
+    console.log(c.dim("\n  Your OS has no built-in installer. Install this entry yourself:"));
+    console.log("  " + buildCronLine(job, holtPath));
+  }
+}
+function removeScheduleDarwin(id) {
+  const path = plistPath(id);
+  if (existsSync16(path)) {
+    spawnSync5("launchctl", ["unload", path], { encoding: "utf8" });
+    try {
+      rmSync7(path);
+    } catch {
+    }
+  }
+}
+function removeScheduleLinux(id) {
+  const body = currentCrontab2();
+  const next = stripCronLines(body, id);
+  writeCrontab2(next);
+}
+function removeSchedule(name) {
+  const id = routineJobId(name);
+  const existed = loadJobs().some((j) => j.id === id);
+  removeJob(id);
+  if (!existed) return;
+  if (process.platform === "darwin") removeScheduleDarwin(id);
+  else if (process.platform === "linux") removeScheduleLinux(id);
+}
+function parseAdd2(rest) {
+  const opts = { notify: false };
+  let name;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === void 0) continue;
+    if (a === "--notify") opts.notify = true;
+    else if (a === "--skill") opts.skill = rest[++i];
+    else if (a === "--task") opts.task = rest[++i];
+    else if (a === "--template") opts.template = rest[++i];
+    else if (a === "--at") opts.when = rest[++i];
+    else if (a === "--out") opts.out = rest[++i];
+    else if (a === "--brain") opts.brain = rest[++i];
+    else if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq > 2) {
+        const k = a.slice(2, eq);
+        const v = a.slice(eq + 1);
+        if (k === "skill") opts.skill = v;
+        else if (k === "task") opts.task = v;
+        else if (k === "template") opts.template = v;
+        else if (k === "at") opts.when = v;
+        else if (k === "out") opts.out = v;
+        else if (k === "brain") opts.brain = v;
+      }
+    } else if (name === void 0) name = a;
+  }
+  return { name, opts };
+}
+async function addCmd2(rest) {
+  const { name: rawName, opts } = parseAdd2(rest);
+  const name = sanitizeRoutineName(rawName || "");
+  if (!name) {
+    usage3();
+    process.exitCode = 1;
+    return;
+  }
+  let source;
+  let when = opts.when;
+  let notify2 = opts.notify;
+  if (opts.template) {
+    const tpl = ROUTINE_TEMPLATES[opts.template];
+    if (!tpl) {
+      console.error(
+        "\n  " + c.red(`Unknown template "${opts.template}".`) + c.dim(` Available: ${templateNames().join(", ")}`) + "\n"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    source = { ...tpl.source };
+    if (when === void 0) when = tpl.when;
+    if (!opts.notify) notify2 = tpl.notify;
+  } else if (opts.skill !== void 0 && opts.task !== void 0) {
+    console.error("\n  " + c.red("Give either --skill or --task, not both.") + "\n");
+    process.exitCode = 1;
+    return;
+  } else if (opts.skill !== void 0) {
+    const loaded = loadSkill(opts.skill);
+    if (!loaded) {
+      console.error("\n  " + c.red(`No skill named "${opts.skill}".`) + c.dim(' Try "holt skill list".') + "\n");
+      process.exitCode = 1;
+      return;
+    }
+    source = { kind: "skill", value: loaded.skill.name };
+  } else if (opts.task !== void 0 && opts.task.trim()) {
+    source = { kind: "task", value: opts.task.trim() };
+  } else {
+    console.error("\n  " + c.red('A routine needs a source: give --skill <s>, --task "<p>", or --template <t>.') + "\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (when !== void 0) {
+    try {
+      parseWhen(when);
+    } catch (e) {
+      console.error("\n  " + c.red(e.message) + "\n");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const routine2 = {
+    name,
+    source,
+    notify: notify2,
+    workspace: workspace(),
+    ...when !== void 0 ? { when } : {},
+    ...opts.out ? { out: opts.out } : {},
+    ...opts.brain ? { brain: opts.brain } : {}
+  };
+  upsertRoutine(routine2);
+  if (routine2.when) installSchedule(routine2);
+  console.log("\n" + c.accent("Routine saved."));
+  printRoutine(routine2, "  ");
+  if (!routine2.when) console.log(c.dim(`
+  Run it with:  holt routine run ${routine2.name}`));
+  console.log("");
+}
+function buildRoutinePrompt(r) {
+  if (r.source.kind === "task") return { prompt: r.source.value };
+  const loaded = loadSkill(r.source.value);
+  if (!loaded) return { error: `Skill "${r.source.value}" is no longer installed. Try "holt skill list".` };
+  const prompt = [
+    loaded.body,
+    "",
+    "Apply the skill above to this request:",
+    "Run this skill now for the current folder."
+  ].join("\n");
+  return { prompt };
+}
+async function runCmd(rest) {
+  let quiet = false;
+  let outOverride;
+  let notifyOverride = false;
+  let brainOverride;
+  let name = "";
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === void 0) continue;
+    if (a === "--quiet") quiet = true;
+    else if (a === "--notify") notifyOverride = true;
+    else if (a === "--out") outOverride = rest[++i];
+    else if (a === "--brain") brainOverride = rest[++i];
+    else if (!a.startsWith("--") && !name) name = sanitizeRoutineName(a);
+  }
+  if (!name) {
+    console.log(c.dim("\n  Usage: holt routine run <name> [--quiet] [--out <file>] [--notify] [--brain <id>]\n"));
+    process.exitCode = 1;
+    return;
+  }
+  const routine2 = findRoutine(name);
+  if (!routine2) {
+    process.stderr.write(c.red(`No routine named "${name}". See "holt routine list".`) + "\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (!isTrusted()) {
+    if (process.stdin.isTTY) {
+      const { ask, close } = createReader();
+      const ok2 = await ensureTrusted(ask);
+      close();
+      if (!ok2) return;
+    } else {
+      process.stderr.write("This folder is not trusted. Run holt init or holt chat here once, then run the routine.\n");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const built = buildRoutinePrompt(routine2);
+  if ("error" in built) {
+    process.stderr.write(c.red(built.error) + "\n");
     process.exitCode = 1;
     return;
   }
-  try {
-    parseWhen(when);
-  } catch (e) {
-    console.error("\n  " + c.red(e.message) + "\n");
+  const brainId = brainOverride ?? routine2.brain;
+  const outTarget = outOverride ?? routine2.out;
+  const wantNotify = notifyOverride || routine2.notify;
+  let streamed = false;
+  const result = await runTask(built.prompt, {
+    ...brainId ? { brainId } : {},
+    onChunk: quiet ? void 0 : (ch) => {
+      streamed = true;
+      process.stdout.write(ch);
+    }
+  });
+  if (!result.ok) {
+    if (streamed) process.stdout.write("\n");
+    process.stderr.write(c.red(result.text) + "\n");
     process.exitCode = 1;
     return;
   }
-  const ws = workspace();
-  const holtPath = resolveHoltPath();
-  const job = {
-    id: newJobId(),
-    name: opts.name || task.slice(0, 40),
-    task,
-    when,
-    workspace: ws,
-    notify: opts.notify,
-    ...opts.brain ? { brain: opts.brain } : {}
-  };
-  ensureLogsDir();
-  addJob(job);
-  console.log("\n" + c.accent("Scheduled."));
-  console.log(`  id         ${job.id}`);
-  console.log(`  when       daily at ${job.when}`);
-  console.log(`  workspace  ${job.workspace}`);
-  if (job.notify) console.log(`  notify     on (pushes output to Telegram)`);
-  console.log(`  log        ${logPath(job.id)}`);
-  if (process.platform === "darwin") installDarwin(job, holtPath);
-  else if (process.platform === "linux") installLinux(job, holtPath);
-  else {
-    console.log(c.dim("\n  Your OS has no built-in installer. Install this entry yourself:"));
-    console.log("  " + buildCronLine(job, holtPath));
+  if (!quiet && !streamed) process.stdout.write(result.text);
+  if (!quiet && (streamed || result.text) && !result.text.endsWith("\n")) process.stdout.write("\n");
+  if (outTarget) {
+    const target = resolve6(routine2.workspace, outTarget);
+    try {
+      writeFileSync17(target, result.text, "utf8");
+      if (!quiet) 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;
+    }
+  }
+  if (wantNotify) {
+    if (!loadTelegramConfig()) {
+      process.stderr.write(c.dim('Telegram is not set up; skipping notify. Run "holt telegram setup".') + "\n");
+    } else {
+      const sent = await sendMessage(result.text);
+      if (!sent) process.stderr.write(c.dim("Could not push the result to Telegram.") + "\n");
+    }
   }
-  console.log("");
 }
-function listCmd() {
-  const jobs = loadJobs();
-  if (jobs.length === 0) {
-    console.log(c.dim("\n  No scheduled tasks yet. Add one with:"));
-    console.log(c.dim('  holt schedule add "<task>" <HH:MM> [--notify]\n'));
+function sourceLabel(s) {
+  return s.kind === "skill" ? `skill:${s.value}` : `task: ${s.value.length > 46 ? s.value.slice(0, 45) + "\u2026" : s.value}`;
+}
+function outputsLabel(r) {
+  const outs = [];
+  if (r.notify) outs.push("notify");
+  if (r.out) outs.push(`out:${r.out}`);
+  if (outs.length === 0) outs.push("stdout");
+  return outs.join(" ");
+}
+function listCmd3() {
+  const routines = loadRoutines();
+  if (routines.length === 0) {
+    console.log(c.dim("\n  No routines yet. Add one with:"));
+    console.log(c.dim('  holt routine add <name> (--skill <s> | --task "<p>") [--at HH:MM] [--notify] [--out <file>]\n'));
     return;
   }
-  console.log("\n" + c.accent("Scheduled tasks"));
-  for (const j of jobs) {
-    console.log(`  ${c.bold(j.id)}  daily ${j.when}  ${c.dim(j.notify ? "(notify)" : "")}`);
-    console.log(`      ${j.name}`);
-    console.log(c.dim(`      ${j.workspace}`));
+  console.log("\n" + c.accent("Routines"));
+  for (const r of routines) {
+    const sched = r.when ? `daily ${r.when}` : "manual";
+    console.log(`  ${c.bold(r.name)}  ${c.dim(sched)}  ${c.dim(outputsLabel(r))}`);
+    console.log(c.dim(`      ${sourceLabel(r.source)}`));
+    console.log(c.dim(`      ${r.workspace}`));
+  }
+  console.log(c.dim("\n  holt routine show <name>   full detail"));
+  console.log(c.dim("  holt routine run <name>    run it now\n"));
+}
+function printRoutine(r, pad) {
+  console.log(`${pad}name       ${r.name}`);
+  console.log(`${pad}source     ${sourceLabel(r.source)}`);
+  console.log(`${pad}schedule   ${r.when ? `daily at ${r.when}` : "manual (run on demand)"}`);
+  console.log(`${pad}outputs    ${outputsLabel(r)}`);
+  if (r.brain) console.log(`${pad}brain      ${r.brain}`);
+  console.log(`${pad}workspace  ${r.workspace}`);
+}
+function showCmd2(rest) {
+  const name = sanitizeRoutineName(rest.find((a) => !a.startsWith("--")) || "");
+  if (!name) {
+    console.log(c.dim("\n  Usage: holt routine show <name>\n"));
+    process.exitCode = 1;
+    return;
   }
-  console.log("");
-}
-function removeDarwin(id) {
-  const path = plistPath(id);
-  if (existsSync9(path)) {
-    spawnSync4("launchctl", ["unload", path], { encoding: "utf8" });
-    try {
-      rmSync4(path);
-    } catch {
-    }
+  const r = findRoutine(name);
+  if (!r) {
+    console.error(c.dim(`
+  No routine named "${name}". See "holt routine list".
+`));
+    process.exitCode = 1;
+    return;
   }
+  console.log("\n" + c.accent(r.name));
+  printRoutine(r, "  ");
+  if (r.source.kind === "task") {
+    console.log(c.dim("\n  task:"));
+    console.log("  " + r.source.value);
+  }
+  console.log("");
 }
-function removeLinux(id) {
-  const res = spawnSync4("crontab", ["-l"], { encoding: "utf8" });
-  const body = res.status === 0 && typeof res.stdout === "string" ? res.stdout : "";
-  const next = stripCronLines(body, id);
-  spawnSync4("crontab", ["-"], { input: next, encoding: "utf8" });
-}
-function removeCmd(rest) {
-  const id = rest[0];
-  if (!id) {
-    console.log(c.dim("\n  Usage: holt schedule remove <id>   (see ids with: holt schedule list)\n"));
+function removeCmd2(rest) {
+  const name = sanitizeRoutineName(rest.find((a) => !a.startsWith("--")) || "");
+  if (!name) {
+    console.log(c.dim("\n  Usage: holt routine remove <name>\n"));
     process.exitCode = 1;
     return;
   }
-  const before = loadJobs();
-  const existed = before.some((j) => j.id === id);
-  removeJob(id);
-  if (process.platform === "darwin") removeDarwin(id);
-  else if (process.platform === "linux") removeLinux(id);
-  if (existed) console.log("\n" + c.green(`  Removed schedule ${id}.`) + "\n");
+  const existed = loadRoutines().some((r) => r.name === name);
+  removeSchedule(name);
+  removeRoutine(name);
+  if (existed) console.log("\n" + c.green(`  Removed routine ${name}.`) + "\n");
   else {
     console.error(c.dim(`
-  No schedule with id ${id}. Nothing to remove.
+  No routine named "${name}". Nothing to remove.
 `));
     process.exitCode = 1;
   }
 }
-function usage2() {
-  console.log("\n" + c.accent("holt schedule") + c.dim("  run a task automatically on a timer"));
-  console.log(c.dim('\n  holt schedule add "<task>" <HH:MM> [--name <n>] [--notify] [--brain <id>]'));
-  console.log(c.dim("  holt schedule list"));
-  console.log(c.dim("  holt schedule remove <id>\n"));
+function usage3() {
+  console.log("\n" + c.accent("holt routine") + c.dim("  named, reusable, scheduled jobs"));
+  console.log(c.dim('\n  holt routine add <name> (--skill <s> | --task "<p>") [--at HH:MM] [--notify] [--out <file>] [--brain <id>]'));
+  console.log(c.dim(`  holt routine add <name> --template <t>   (templates: ${templateNames().join(", ")})`));
+  console.log(c.dim("  holt routine run <name> [--quiet]"));
+  console.log(c.dim("  holt routine list"));
+  console.log(c.dim("  holt routine show <name>"));
+  console.log(c.dim("  holt routine remove <name>"));
+  console.log(c.dim("\n  A routine = a task source (skill or inline prompt) + an optional daily"));
+  console.log(c.dim("  schedule + output routing (stdout, --out file, or --notify to Telegram).\n"));
 }
-async function schedule(sub, rest = []) {
+async function routine(sub, rest = []) {
   const action = (sub || "").toLowerCase();
-  if (action === "list") {
-    listCmd();
+  if (action === "list" || action === "ls") {
+    listCmd3();
+    return;
+  }
+  if (action === "show" || action === "view") {
+    showCmd2(rest);
+    return;
+  }
+  if (!action) {
+    usage3();
+    listCmd3();
+    return;
+  }
+  if (action === "run") {
+    await runCmd(rest);
     return;
   }
   if (action !== "add" && action !== "remove" && action !== "rm") {
-    if (action) process.exitCode = 1;
-    usage2();
+    process.exitCode = 1;
+    usage3();
     return;
   }
   const { ask, close } = createReader();
@@ -3806,12 +7091,12 @@ async function schedule(sub, rest = []) {
     return;
   }
   close();
-  if (action === "add") await addCmd(rest);
-  else removeCmd(rest);
+  if (action === "add") await addCmd2(rest);
+  else removeCmd2(rest);
 }
 
 // src/commands/notify.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 async function notify(args) {
   const nonFlag = args.filter((a) => a !== "-" && !a.startsWith("--"));
   const wantsStdin = args.includes("-") || !process.stdin.isTTY;
@@ -3819,7 +7104,7 @@ async function notify(args) {
   if (nonFlag.length > 0 && !args.includes("-")) {
     message = nonFlag.join(" ").trim();
   } else if (wantsStdin) {
-    message = readStdin().trim();
+    message = readStdin2().trim();
   } else if (nonFlag.length > 0) {
     message = nonFlag.join(" ").trim();
   }
@@ -3842,14 +7127,409 @@ async function notify(args) {
     process.exitCode = 1;
   }
 }
-function readStdin() {
+function readStdin2() {
   try {
-    return readFileSync10(0, "utf8");
+    return readFileSync18(0, "utf8");
   } catch {
     return "";
   }
 }
 
+// src/specs.ts
+import os from "os";
+var BYTES_PER_GB = 1024 ** 3;
+function toGB(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return 0;
+  return Math.round(bytes / BYTES_PER_GB);
+}
+function detect() {
+  let platform = "unknown";
+  let arch = "unknown";
+  let cpuModel = "unknown";
+  let cpuCount = 0;
+  let totalRamGB = 0;
+  let freeRamGB = 0;
+  let nodeVersion = "unknown";
+  try {
+    platform = os.platform();
+  } catch {
+  }
+  try {
+    arch = os.arch();
+  } catch {
+  }
+  try {
+    const cpus = os.cpus();
+    if (Array.isArray(cpus) && cpus.length) {
+      cpuCount = cpus.length;
+      const first = cpus[0];
+      if (first && typeof first.model === "string" && first.model.trim()) {
+        cpuModel = first.model.trim();
+      }
+    }
+  } catch {
+  }
+  try {
+    totalRamGB = toGB(os.totalmem());
+  } catch {
+  }
+  try {
+    freeRamGB = toGB(os.freemem());
+  } catch {
+  }
+  try {
+    if (typeof process.version === "string" && process.version) nodeVersion = process.version;
+  } catch {
+  }
+  return { platform, arch, cpuModel, cpuCount, totalRamGB, freeRamGB, nodeVersion };
+}
+var LOCAL_MODEL_RECS = [
+  {
+    minRamGB: 48,
+    rec: {
+      local: true,
+      model: "qwen2.5:32b",
+      size: "~20GB",
+      note: "Plenty of headroom. A 32B model runs comfortably and gives the best local quality."
+    }
+  },
+  {
+    minRamGB: 24,
+    rec: {
+      local: true,
+      model: "qwen2.5:14b",
+      size: "~9GB",
+      note: "A 14B model fits well here and is a solid local maintainer."
+    }
+  },
+  {
+    minRamGB: 16,
+    rec: {
+      local: true,
+      model: "qwen2.5:7b",
+      alt: "llama3.1:8b",
+      size: "~4.7GB",
+      note: "A 7B model works but is tight alongside the embed model and your editor. Prefer running it on your always-on machine."
+    }
+  },
+  {
+    minRamGB: 0,
+    rec: {
+      // Discouraged below 16GB: local generation is too modest to be worth it
+      // for the wiki maintainer. The small model stays named as the only viable
+      // option if you insist, but local is off by default here.
+      local: false,
+      model: "llama3.2:3b",
+      size: "~2GB",
+      note: 'Under 16GB, local generation is modest. A small 3B model is the safe ceiling; the hosted "brain" maintainer will be noticeably better, so it is the recommendation here.'
+    }
+  }
+];
+function recommendLocalModel2(totalRamGB) {
+  const ram = Number.isFinite(totalRamGB) && totalRamGB > 0 ? totalRamGB : 0;
+  for (const tier of LOCAL_MODEL_RECS) {
+    if (ram >= tier.minRamGB) return tier.rec;
+  }
+  return {
+    local: false,
+    model: null,
+    note: 'Could not read RAM. Use the hosted "brain" maintainer to be safe.'
+  };
+}
+
+// src/commands/doctor.ts
+var OLLAMA_URL3 = process.env.HOLT_OLLAMA_URL || "http://127.0.0.1:11434";
+function header(title) {
+  console.log("\n" + c.accent(title));
+}
+function row(label, value) {
+  console.log(`  ${label.padEnd(12)}${value}`);
+}
+function note(text) {
+  console.log("  " + c.dim(text));
+}
+function good(text) {
+  console.log("  " + c.green(text));
+}
+function warn(text) {
+  console.log("  " + c.red(text));
+}
+async function doctor() {
+  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"));
+  header("Machine");
+  row("platform", `${specs.platform} / ${specs.arch}`);
+  row("cpu", `${specs.cpuModel}${specs.cpuCount ? `  (${specs.cpuCount} cores)` : ""}`);
+  row(
+    "ram",
+    specs.totalRamGB ? `${specs.totalRamGB} GB total, ${specs.freeRamGB} GB free` : "unknown"
+  );
+  row("node", specs.nodeVersion);
+  header("Brains");
+  const installed = [];
+  for (const id of BRAIN_IDS) {
+    const def = BRAIN_DEFS[id];
+    const here = isInstalled(def.command);
+    if (here) installed.push(def.label);
+    console.log(`  ${here ? c.green("installed") : c.dim("missing  ")}  ${def.label} ${c.dim(`(${def.command})`)}`);
+  }
+  const cfg = loadConfig();
+  const apiBrains = cfg?.apiBrains ?? [];
+  if (apiBrains.length) {
+    note(`API brains configured here: ${apiBrains.map((b) => b.id).join(", ")}`);
+  }
+  if (installed.length) {
+    good(`Recommendation: use an installed CLI brain (${installed[0]}). No API keys needed.`);
+  } else if (apiBrains.length) {
+    good("Recommendation: no CLI brain installed, but you have an API brain configured. That works.");
+  } else {
+    warn("Recommendation: no brain available. Install one CLI brain (claude, codex, or gemini) or add an API brain.");
+    steps.push('Install a brain: run "holt init" (or add an API brain in "holt setting").');
+  }
+  header("Semantic memory");
+  let embedOk = false;
+  try {
+    embedOk = await embeddingsAvailable();
+  } catch {
+    embedOk = false;
+  }
+  if (embedOk) {
+    good(`Ollama reachable and "${EMBED_MODEL}" is present. Memory recall is semantic, private, and local.`);
+  } 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}`);
+  }
+  header("Knowledge wiki maintainer");
+  const rec = recommendLocalModel2(specs.totalRamGB);
+  note('Holt can keep your knowledge wiki with a hosted "brain" (rides your Claude plan) or a local model.');
+  good('Default recommendation: "brain" (best quality, no extra RAM, uses the brain you already have).');
+  if (rec.local && rec.model) {
+    const alt = rec.alt ? ` (or ${rec.alt})` : "";
+    console.log(
+      "  " + c.cyan("local option: ") + `${rec.model}${alt}${rec.size ? c.dim(`  ${rec.size}`) : ""} for this ${specs.totalRamGB || "?"} GB machine.`
+    );
+    note(rec.note);
+    note(`To use it locally: ollama pull ${rec.model}`);
+  } else {
+    note(rec.note);
+    if (rec.model) note(`If you still want local: ollama pull ${rec.model} (${rec.size ?? "small"}).`);
+  }
+  header("Always-on / Telegram");
+  const tg = loadTelegramConfig();
+  if (tg) {
+    good("Telegram bot is configured. You can chat with Holt from your phone.");
+  } else {
+    note("No Telegram bot configured. Set one up to reach Holt from your phone: holt telegram setup");
+  }
+  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.");
+  header("Recommended next steps");
+  if (!cfg) {
+    steps.unshift('Set up this folder: run "holt init".');
+  }
+  if (steps.length === 0) {
+    good('You are in good shape. Run "holt chat" to start.');
+  } else {
+    let n = 1;
+    for (const s of steps) console.log(`  ${c.accent(String(n++) + ".")} ${s}`);
+  }
+  console.log("");
+}
+
+// src/commands/write.ts
+import { writeFileSync as writeFileSync18 } from "fs";
+import { resolve as resolve7 } from "path";
+
+// src/antiai.ts
+var EM_DASH = String.fromCharCode(8212);
+var ANTI_AI_RULES = [
+  "No em-dashes anywhere. Use a comma, colon, period, or parentheses instead.",
+  'No "rule of three" tricolons or parallel three-beat lists for drama.',
+  `No "in today's fast-paced world" or "in an era of" style openers.`,
+  'No "it is not X, it is Y" or "not just X but Y" reframes.',
+  "No tidy bow-tie conclusion that restates the thesis in one neat takeaway.",
+  "No callback closer where the last line echoes or inverts the opening.",
+  "Vary sentence length. Mix short and long. Avoid uniform rhythm.",
+  "Prefer concrete specifics, names, and numbers over abstractions.",
+  'Cut hedging filler ("it is worth noting", "needless to say", "the truth is").',
+  "Avoid corporate buzzwords (leverage, unlock, seamless, robust, holistic, synergy, elevate, streamline, empower, game-changer).",
+  "Avoid performed emotion (thrilled, humbled, honored, excited to share).",
+  "No emoji unless the voice profile explicitly allows it.",
+  "No ALL CAPS for emphasis and no bold on adjectives or adverbs.",
+  "Leave at least one thought slightly open. Do not resolve everything neatly.",
+  "Write like a person talking to one smart reader, not a press release."
+];
+function antiAiPromptBlock() {
+  return [
+    "ANTI-AI WRITING RULES (follow all, they matter):",
+    ...ANTI_AI_RULES.map((r) => `- ${r}`),
+    "",
+    "The single hardest rule: the output must contain zero em-dash characters.",
+    "Write plainly. If a sentence sounds like a LinkedIn influencer or a brochure, rewrite it."
+  ].join("\n");
+}
+function antiAiCheckInstruction() {
+  return [
+    "Review the draft below against these anti-AI rules and the voice profile.",
+    "Rewrite any sentence that violates them. Keep the meaning and length similar.",
+    "Remove every em-dash. Output ONLY the corrected draft, no commentary.",
+    "",
+    antiAiPromptBlock()
+  ].join("\n");
+}
+function scanAntiAi(text) {
+  const flags = [];
+  const t = text || "";
+  if (t.includes(EM_DASH)) {
+    flags.push({ rule: "no-em-dash", detail: "contains an em-dash character" });
+  }
+  const openers = [
+    /in today'?s (fast[- ]paced|ever[- ]changing) world/i,
+    /in an era of/i,
+    /without further ado/i,
+    /let'?s (dive|get started)/i
+  ];
+  for (const re of openers) {
+    if (re.test(t)) flags.push({ rule: "stock-opener", detail: `matches ${re.source}` });
+  }
+  const buzz = ["leverage", "seamless", "seamlessly", "unlock", "game-changer", "synergy", "holistic", "elevate", "empower", "streamline"];
+  for (const w of buzz) {
+    const re = new RegExp(`\\b${w.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}\\b`, "i");
+    if (re.test(t)) flags.push({ rule: "buzzword", detail: `uses "${w}"` });
+  }
+  return flags;
+}
+function stripEmDash(text) {
+  return (text || "").split(EM_DASH).join(", ");
+}
+
+// src/commands/write.ts
+var TYPES = ["linkedin", "email", "tweet", "blog", "generic"];
+var TYPE_SHAPE = {
+  linkedin: "Format: a LinkedIn post. Keep it tight, a few short paragraphs. No hashtag wall.",
+  email: "Format: an email. Include a subject line, then a short body. Plain and direct.",
+  tweet: "Format: a single short post under 280 characters. One clear idea.",
+  blog: 'Format: a short blog post with a title and a few paragraphs. No "conclusion" header.',
+  generic: "Format: whatever best fits the request. Keep it concise unless asked otherwise."
+};
+var USAGE4 = [
+  '  holt write "<what to write>" [options]',
+  "",
+  "  Draft content in your saved writing voice, with anti-AI checks.",
+  "",
+  "  options:",
+  "    --type <t>   linkedin | email | tweet | blog | generic (default generic)",
+  "    --out <file> also write the draft to a file (relative to this folder)",
+  "    --brain <id> use a specific brain (CLI or API brain id)",
+  "    --fast       skip the anti-AI self-check second pass",
+  "",
+  '  example: holt write "a linkedin post about shipping Holt" --type linkedin',
+  "",
+  '  Tip: build your voice first with "holt voice". Without it, a plain voice is used.'
+].join("\n");
+function parseArgs3(args) {
+  const words2 = [];
+  let type = "generic";
+  let out;
+  let brainId;
+  let fast = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--type") {
+      const t = (args[++i] ?? "").toLowerCase();
+      if (TYPES.includes(t)) type = t;
+      continue;
+    }
+    if (a === "--out") {
+      out = args[++i];
+      continue;
+    }
+    if (a === "--brain") {
+      brainId = args[++i];
+      continue;
+    }
+    if (a === "--fast") {
+      fast = true;
+      continue;
+    }
+    words2.push(a);
+  }
+  return { task: words2.join(" ").trim(), type, out, brainId, fast };
+}
+function buildWritePrompt(p, voiceBlock) {
+  const parts = [antiAiPromptBlock(), ""];
+  if (voiceBlock) {
+    parts.push(voiceBlock, "");
+  } else {
+    parts.push("No saved voice profile. Write in a plain, natural, first-person voice.", "");
+  }
+  parts.push(TYPE_SHAPE[p.type], "");
+  parts.push("Write the following. Output ONLY the finished piece, no preamble and no notes:");
+  parts.push(p.task);
+  return parts.join("\n");
+}
+async function write(args) {
+  const p = parseArgs3(args);
+  if (!p.task) {
+    console.log(USAGE4);
+    return;
+  }
+  if (!isTrusted()) {
+    if (process.stdin.isTTY) {
+      const { ask, close } = createReader();
+      const ok2 = await ensureTrusted(ask);
+      close();
+      if (!ok2) return;
+    } else {
+      process.stderr.write("This folder is not trusted. Run holt init or holt chat here once first.\n");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const v = loadVoice();
+  const voiceBlock = voicePromptBlock(v);
+  if (!v || !v.style && v.samples.length === 0 && v.answers.every((a) => !a.answer.trim())) {
+    process.stderr.write(c.dim('No voice profile found, using a plain voice. Build one with "holt voice".') + "\n");
+  }
+  const prompt = buildWritePrompt(p, voiceBlock);
+  const gen = await runTask(prompt, { brainId: p.brainId, recall: false, store: false });
+  if (!gen.ok) {
+    process.stderr.write(c.red(gen.text) + "\n");
+    process.exitCode = 1;
+    return;
+  }
+  let draft = gen.text;
+  if (!p.fast) {
+    const flagsBefore = scanAntiAi(draft);
+    const checkPrompt = [
+      antiAiCheckInstruction(),
+      voiceBlock ? "\n" + voiceBlock : "",
+      "\nDRAFT:",
+      draft
+    ].join("\n");
+    const checked = await runTask(checkPrompt, { brainId: p.brainId, recall: false, store: false });
+    if (checked.ok && checked.text.trim()) {
+      const flagsAfter = scanAntiAi(checked.text);
+      if (flagsAfter.length <= flagsBefore.length) draft = checked.text;
+    }
+  }
+  draft = stripEmDash(draft).trimEnd();
+  process.stdout.write(draft + "\n");
+  if (p.out) {
+    const target = resolve7(process.cwd(), p.out);
+    try {
+      writeFileSync18(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");
+      process.exitCode = 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
@@ -3868,12 +7548,18 @@ Commands:
   chat            Start a session. It remembers past sessions in this folder
   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]
+  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)
   login <brain>   Sign in to a brain: claude, codex, or gemini
   version         Print the Holt version
@@ -3916,6 +7602,9 @@ async function main() {
     case "memory":
       await memoryCmd(process.argv[3], process.argv.slice(4));
       break;
+    case "wiki":
+      await wikiCmd(process.argv[3], process.argv.slice(4));
+      break;
     case "skill":
     case "skills":
       await skillCmd(process.argv[3], process.argv.slice(4));
@@ -3926,18 +7615,33 @@ async function main() {
     case "mcp":
       await mcp(process.argv[3], process.argv.slice(4));
       break;
+    case "hook":
+      await hook(process.argv[3], process.argv.slice(4));
+      break;
     case "run":
       await run(process.argv.slice(3));
       break;
     case "schedule":
       await schedule(process.argv[3], process.argv.slice(4));
       break;
+    case "routine":
+      await routine(process.argv[3], process.argv.slice(4));
+      break;
     case "telegram":
       await telegram(process.argv[3], process.argv.slice(4));
       break;
     case "notify":
       await notify(process.argv.slice(3));
       break;
+    case "doctor":
+      await doctor();
+      break;
+    case "voice":
+      await voice(process.argv[3], process.argv.slice(4));
+      break;
+    case "write":
+      await write(process.argv.slice(3));
+      break;
     default:
       console.error(`
   Unknown command: "${cmd}"`);