@holt-os/holt 0.8.4 → 0.9.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((resolve7) => {
     if (q) process.stdout.write(q);
-    if (buffer.length) resolve4(buffer.shift());
-    else if (closed) resolve4(null);
-    else waiters.push(resolve4);
+    if (buffer.length) resolve7(buffer.shift());
+    else if (closed) resolve7(null);
+    else waiters.push(resolve7);
   });
   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((resolve7) => {
     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}` });
+      resolve7({ 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) => resolve7({ 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) resolve7({ ok: true, text });
+      else resolve7({ 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((resolve7) => {
     let child;
     try {
       child = spawn2(cmd, args, { stdio: "inherit" });
     } catch {
-      resolve4(-1);
+      resolve7(-1);
       return;
     }
-    child.on("error", () => resolve4(-1));
-    child.on("close", (code) => resolve4(code ?? -1));
+    child.on("error", () => resolve7(-1));
+    child.on("close", (code) => resolve7(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
@@ -1606,8 +2225,8 @@ async function extractAndSaveFacts(active, cfg, history, session) {
 }
 
 // src/output.ts
-import { writeFileSync as writeFileSync6 } from "fs";
-import { join as join7, isAbsolute } from "path";
+import { writeFileSync as writeFileSync7 } from "fs";
+import { join as join8, isAbsolute } from "path";
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -1747,8 +2366,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 = join8(process.cwd(), base);
+  writeFileSync7(path, renderReply(reply, format), "utf8");
   return path;
 }
 
@@ -2008,7 +2627,8 @@ async function login(which) {
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { basename } from "path";
 async function memoryCmd(sub, rest = []) {
   const { ask, close } = createReader();
   if (!await ensureTrusted(ask)) {
@@ -2055,12 +2675,12 @@ async function memoryCmd(sub, rest = []) {
     return;
   }
   if (action === "facts") {
-    if (!existsSync7(factsMdPath())) {
+    if (!existsSync8(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 = readFileSync9(factsMdPath(), "utf8").trim();
     console.log("\n" + body + "\n");
     close();
     return;
@@ -2077,15 +2697,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,49 +2733,848 @@ 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
+// 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";
+
+// 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 };
+  }
+}
+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 {
+    }
+    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
 import {
-  mkdirSync as mkdirSync6,
-  writeFileSync as writeFileSync7,
-  readFileSync as readFileSync8,
-  existsSync as existsSync8,
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync8,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync7,
+  rmSync as rmSync4,
   readdirSync as readdirSync2,
-  statSync as statSync3,
-  rmSync as rmSync3,
-  cpSync,
-  mkdtempSync
+  statSync as statSync3
 } 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.",
-    ""
-  ].join("\n")));
+import { join as join9 } from "path";
+import { totalmem } from "os";
+function wikiDir() {
+  return join9(wsHoltDir(), "wiki");
 }
-var SKILL_TEMPLATE = (name) => [
-  "---",
-  `name: ${name}`,
-  "description: One sentence on what this skill does and when to use it.",
-  "---",
+function wikiStatePath() {
+  return join9(wikiDir(), ".state.json");
+}
+function wikiIndexPath() {
+  return join9(wikiDir(), "index.md");
+}
+function pagePath(slug) {
+  return join9(wikiDir(), `${slug}.md`);
+}
+function loadState() {
+  try {
+    const s = JSON.parse(readFileSync10(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 });
+  writeFileSync8(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 (!existsSync9(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 (!existsSync9(p)) return null;
+  let raw = "";
+  try {
+    raw = readFileSync10(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 });
+  writeFileSync8(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 } };
+}
+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 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 });
+  writeFileSync8(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(join9(wsHoltDir(), "memory"), { recursive: true });
+    writeFileSync8(
+      join9(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(join9(wsHoltDir(), "memory"), { recursive: true });
+    writeFileSync8(
+      join9(wsHoltDir(), "memory", "turns.jsonl"),
+      kept.map((t) => JSON.stringify(t)).join("\n") + (kept.length ? "\n" : ""),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function wipeWiki() {
+  if (existsSync9(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/commands/wiki.ts
+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;
+}
+function titleToSlug(title) {
+  return proposeSlug(title);
+}
+async function foldFacts(cfg, maintainer, facts) {
+  const summary = { created: 0, updated: 0, factsIntegrated: 0 };
+  if (facts.length === 0) return summary;
+  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);
+    let 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;
+}
+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 syncCmd(cfg) {
+  const state = loadState();
+  const all = factRows();
+  const fresh = all.filter((f) => f.ts > state.lastSyncTs);
+  if (fresh.length === 0) {
+    console.log(c.dim("\n  No new facts since the last sync. Nothing to do.\n"));
+    return;
+  }
+  const { maintainer, report } = await resolveMaintainer(cfg, () => resolveBrainMaintainer(cfg));
+  if (!maintainer) {
+    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;
+  }
+  if (report?.note) console.log(c.dim("\n  " + report.note));
+  console.log("\n" + c.dim(`  Integrating ${fresh.length} new fact${fresh.length === 1 ? "" : "s"} via ${maintainer.label}...`));
+  const summary = await foldFacts(cfg, maintainer, fresh);
+  const newest = Math.max(state.lastSyncTs, ...fresh.map((f) => f.ts));
+  saveSyncMarker(newest);
+  console.log("\n" + c.accent("Wiki synced") + c.dim("  (this folder)"));
+  console.log(`  facts integrated  ${summary.factsIntegrated}`);
+  console.log(`  pages created     ${summary.created}`);
+  console.log(`  pages updated     ${summary.updated}`);
+  console.log(`  maintainer        ${maintainer.label}${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");
+}
+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("\n  Note: --fix can rewrite pages. Put .holt/wiki under git or back it up first."));
+    console.log(c.dim("  For now, lint proposes only; applying edits is left to a future release. Showing the report.\n"));
+  }
+  console.log(c.dim(`
+  Auditing ${pages.length} page${pages.length === 1 ? "" : "s"} via ${maintainer.label}...
+`));
+  const res = await runMaintainer(maintainer, cfg, buildLintPrompt(pages));
+  if (!res.ok || !res.text.trim()) {
+    console.log(c.dim("  Lint could not produce a report (maintainer returned nothing).\n"));
+    return;
+  }
+  console.log(res.text.trim() + "\n");
+}
+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(`  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 rebuild           regenerate the whole wiki from facts"));
+  console.log(c.dim("  holt wiki lint              audit for contradictions, duplicates, gaps"));
+  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 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 "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 | rebuild | lint | list | show <page> | open | status | setup
+`);
+        process.exitCode = 1;
+    }
+  } finally {
+    close();
+  }
+}
+
+// src/commands/skill.ts
+import {
+  mkdirSync as mkdirSync8,
+  writeFileSync as writeFileSync9,
+  readFileSync as readFileSync12,
+  existsSync as existsSync11,
+  readdirSync as readdirSync3,
+  statSync as statSync4,
+  rmSync as rmSync5,
+  cpSync,
+  mkdtempSync
+} from "fs";
+import { join as join11, resolve as resolve2 } from "path";
+import { tmpdir } from "os";
+import { spawnSync as spawnSync2 } from "child_process";
+function usage() {
+  console.log(c.dim([
+    "",
+    "  " + c.accent("holt skill") + c.dim(" - manage SKILL.md skills"),
+    "",
+    "  holt skill list                     list installed skills",
+    "  holt skill show <name>              print a skill",
+    "  holt skill create <name> [--global] scaffold a new skill",
+    "  holt skill add <source> [--global]  install from a git URL or local path",
+    "  holt skill remove <name>            delete a skill",
+    "",
+    "  --global installs into ~/.holt/skills (available in every folder).",
+    "  Without it, skills live in this folder at ./.holt/skills.",
+    ""
+  ].join("\n")));
+}
+var SKILL_TEMPLATE = (name) => [
+  "---",
+  `name: ${name}`,
+  "description: One sentence on what this skill does and when to use it.",
+  "---",
   "",
   `# ${name}`,
   "",
@@ -2170,12 +3597,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 (existsSync11(join11(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 statSync4(join11(root, f)).isDirectory();
       } catch {
         return false;
       }
@@ -2183,8 +3610,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) => existsSync11(join11(root, f, "SKILL.md")));
+  if (withSkill.length === 1) return join11(root, withSkill[0]);
   return null;
 }
 function cmdList() {
@@ -2224,7 +3651,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("  " + join11(skill.dir, "SKILL.md")));
   console.log("");
   console.log(c.dim(body));
   console.log("");
@@ -2236,19 +3663,19 @@ function cmdCreate(name, global) {
     return;
   }
   const scope = global ? "global" : "workspace";
-  const dir = join8(skillsRoot(scope), clean);
-  if (existsSync8(dir)) {
+  const dir = join11(skillsRoot(scope), clean);
+  if (existsSync11(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");
+  mkdirSync8(dir, { recursive: true });
+  writeFileSync9(join11(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("  " + join11(dir, "SKILL.md")));
   console.log(c.dim('  Edit it, then run it in chat with "/skill ' + clean + '".\n'));
 }
 function cmdAdd(source, global) {
@@ -2261,7 +3688,7 @@ function cmdAdd(source, global) {
   let tempDir = "";
   try {
     if (isGitUrl(source)) {
-      tempDir = mkdtempSync(join8(tmpdir(), "holt-skill-"));
+      tempDir = mkdtempSync(join11(tmpdir(), "holt-skill-"));
       console.log(c.dim(`
   Cloning ${source} ...`));
       const res = spawnSync2("git", ["clone", "--depth", "1", source, tempDir], { stdio: "ignore" });
@@ -2272,8 +3699,8 @@ function cmdAdd(source, global) {
       }
       fetched = tempDir;
     } else {
-      fetched = resolve(source);
-      if (!existsSync8(fetched)) {
+      fetched = resolve2(source);
+      if (!existsSync11(fetched)) {
         console.error(c.red(`
   No such path: ${fetched}
 `));
@@ -2289,7 +3716,7 @@ function cmdAdd(source, global) {
     }
     let skillName = "";
     try {
-      const { data } = parseFrontmatter(readFileSync8(join8(skillDir, "SKILL.md"), "utf8"));
+      const { data } = parseFrontmatter(readFileSync12(join11(skillDir, "SKILL.md"), "utf8"));
       skillName = sanitizeName(data.name || "");
     } catch {
       skillName = "";
@@ -2300,25 +3727,25 @@ function cmdAdd(source, global) {
       process.exitCode = 1;
       return;
     }
-    const dest = join8(skillsRoot(scope), skillName);
-    if (existsSync8(dest)) {
+    const dest = join11(skillsRoot(scope), skillName);
+    if (existsSync11(dest)) {
       console.error(c.red(`
   A ${scope} skill named "${skillName}" already exists.`));
       console.error(c.dim("  " + dest + "\n"));
       process.exitCode = 1;
       return;
     }
-    mkdirSync6(skillsRoot(scope), { recursive: true });
+    mkdirSync8(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 = join11(dest, ".git");
+    if (existsSync11(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("  " + join11(dest, "SKILL.md") + "\n"));
   } finally {
-    if (tempDir && existsSync8(tempDir)) {
+    if (tempDir && existsSync11(tempDir)) {
       try {
-        rmSync3(tempDir, { recursive: true, force: true });
+        rmSync5(tempDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -2330,9 +3757,9 @@ async function cmdRemove(name, ask) {
     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 = join11(skillsRoot("workspace"), clean);
+  const globalDir = join11(skillsRoot("global"), clean);
+  const target = existsSync11(wsDir) ? wsDir : existsSync11(globalDir) ? globalDir : "";
   if (!target) {
     console.error(c.dim(`
   No skill named "${clean}" found.
@@ -2344,7 +3771,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"));
@@ -2392,9 +3819,9 @@ 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 writeFileSync10, mkdirSync as mkdirSync9, existsSync as existsSync12 } from "fs";
+import { join as join12, dirname as dirname2, resolve as resolve3 } from "path";
+import { spawn as spawn4 } from "child_process";
 
 // src/graphview.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -2469,7 +3896,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 +3956,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 +3984,39 @@ 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 escapeForScript(json) {
   return json.replace(/<\/(script)/gi, "<\\/$1").replace(/<!--/g, "<\\u0021--");
 }
@@ -2662,6 +4122,7 @@ 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:#5bd66f"></span>wiki page</div>
   <div class="row"><span class="swatch" style="background:var(--line);border:1px solid var(--muted)"></span>ring = session</div>
 </div>
 <div id="hint">drag to pan &middot; wheel to zoom &middot; click a node &middot; Esc to clear</div>
@@ -2712,7 +4173,7 @@ function renderGraphHtml(graph2, meta) {
   });
 
   function radiusOf(n) {
-    var base = n.kind === "concept" ? 3 : 5;
+    var base = n.kind === "concept" ? 3 : n.kind === "wiki" ? 6 : 5;
     return base + Math.min(9, Math.sqrt(n._deg) * 1.6);
   }
 
@@ -2791,6 +4252,7 @@ function renderGraphHtml(graph2, meta) {
   var query = "";
 
   function roleColor(n) {
+    if (n.kind === "wiki") return "#5bd66f";
     if (n.kind === "concept") return "#9a8cff";
     return n.role === "user" ? "#f0b91e" : "#35d0d6";
   }
@@ -2817,7 +4279,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" : "#4a5262";
       ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y); ctx.stroke();
     }
     ctx.globalAlpha = 1;
@@ -2848,11 +4310,11 @@ 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; turn labels when zoomed in
+      if (n.kind === "concept" || n.kind === "wiki" || view.scale > 1.4) {
         ctx.globalAlpha = faded ? 0.25 : 0.9;
-        ctx.fillStyle = "#e7e9ee";
-        ctx.font = (n.kind === "concept" ? 11 : 10) + "px ui-monospace, monospace";
+        ctx.fillStyle = n.kind === "wiki" ? "#5bd66f" : "#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 +4378,8 @@ 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"
           : (esc(hov.session || "") + (when ? " &middot; " + when : ""));
         tooltip.innerHTML = "<div>" + esc(hov.label) + "</div><div class='t-meta'>" + meta + "</div>";
         tooltip.style.display = "block";
@@ -2959,8 +4423,8 @@ 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 {
       highlightSet = null;
@@ -3015,11 +4479,16 @@ function parseArgs(args) {
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     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 === "--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 +4503,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();
@@ -3050,12 +4519,16 @@ async function graph(args = []) {
   close();
   const opts = parseArgs(args);
   const turns = loadTurns();
-  if (turns.length === 0) {
+  const includeWiki = opts.wiki !== void 0 ? opts.wiki : existsSync12(wikiDir());
+  const wikiPages = includeWiki ? wikiGraphPages() : [];
+  if (turns.length === 0 && wikiPages.length === 0) {
     console.log(c.dim('\n  No memory in this folder yet. Have a chat first with "holt chat", then come back.\n'));
     return;
   }
-  const g = buildGraph(turns);
+  let g = buildGraph(turns);
+  if (wikiPages.length) g = mergeGraphs(g, buildWikiGraph(wikiPages));
   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 +4537,13 @@ 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 ? resolve3(opts.out) : join12(wsHoltDir(), "graph.html");
+  mkdirSync9(dirname2(outPath), { recursive: true });
+  writeFileSync10(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`);
+  console.log(`  nodes    ${g.nodes.length}  (${parts.join(", ")})`);
   console.log(`  edges    ${g.edges.length}`);
   console.log(`  file     ${outPath}`);
   if (opts.open) {
@@ -3174,7 +4649,7 @@ function recoverId(line) {
   return null;
 }
 function runMcpServer(opts) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve7) => {
     const stdin = process.stdin;
     let buffer = "";
     let chain = Promise.resolve();
@@ -3226,11 +4701,11 @@ function runMcpServer(opts) {
         processLine(buffer);
         buffer = "";
       }
-      chain.then(() => resolve4()).catch(() => resolve4());
+      chain.then(() => resolve7()).catch(() => resolve7());
     });
     stdin.on("error", (e) => {
       console.error(`[mcp] stdin error: ${e.message}`);
-      chain.then(() => resolve4()).catch(() => resolve4());
+      chain.then(() => resolve7()).catch(() => resolve7());
     });
     stdin.resume();
   });
@@ -3350,7 +4825,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.8.4";
+var VERSION = "0.9.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -3395,10 +4870,370 @@ async function mcp(sub, rest = []) {
   }
 }
 
+// src/commands/hook.ts
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync11, existsSync as existsSync13, mkdirSync as mkdirSync10, copyFileSync, realpathSync as realpathSync2 } from "fs";
+import { join as join13, dirname as dirname3 } 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 join13(homedir3(), ".claude", "settings.json");
+}
+function projectSettingsPath() {
+  return join13(process.cwd(), ".claude", "settings.json");
+}
+function readSettings(path) {
+  if (!existsSync13(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync13(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) {
+  mkdirSync10(dirname3(path), { recursive: true });
+  writeFileSync11(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+function backup(path) {
+  if (!existsSync13(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 (!existsSync13(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 (!existsSync13(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((resolve7) => {
+    let input = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve7(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 || !existsSync13(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 (!existsSync13(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 = readFileSync13(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()}
+`);
+  } 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 writeFileSync12 } from "fs";
+import { resolve as resolve4 } from "path";
+var USAGE3 = [
   "  holt run <task> [options]",
   "",
   "  Run a single task against your default brain and stream the reply.",
@@ -3448,7 +5283,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 +5321,9 @@ async function run(args) {
     process.stdout.write("\n");
   }
   if (p.out) {
-    const target = resolve3(process.cwd(), p.out);
+    const target = resolve4(process.cwd(), p.out);
     try {
-      writeFileSync9(target, result.text, "utf8");
+      writeFileSync12(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 +5334,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 writeFileSync14, mkdirSync as mkdirSync12, rmSync as rmSync6, existsSync as existsSync14 } from "fs";
+import { dirname as dirname4 } 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 join14 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync13, mkdirSync as mkdirSync11 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
 import { spawnSync as spawnSync3 } from "child_process";
 function schedulesPath() {
-  return join10(GLOBAL_DIR, "schedules.json");
+  return join14(GLOBAL_DIR, "schedules.json");
 }
 function logsDir() {
-  return join10(GLOBAL_DIR, "logs");
+  return join14(GLOBAL_DIR, "logs");
 }
 function logPath(id) {
-  return join10(logsDir(), `${id}.log`);
+  return join14(logsDir(), `${id}.log`);
 }
 function plistPath(id) {
-  return join10(homedir3(), "Library", "LaunchAgents", `com.holt.${id}.plist`);
+  return join14(homedir4(), "Library", "LaunchAgents", `com.holt.${id}.plist`);
 }
 function loadJobs() {
   try {
-    const raw = JSON.parse(readFileSync9(schedulesPath(), "utf8"));
+    const raw = JSON.parse(readFileSync14(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");
+  mkdirSync11(GLOBAL_DIR, { recursive: true });
+  writeFileSync13(schedulesPath(), JSON.stringify(jobs, null, 2) + "\n", "utf8");
 }
 function addJob(job) {
   const jobs = loadJobs();
@@ -3575,6 +5410,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 +5473,7 @@ function appendCronLine(crontab, line) {
   return (base ? base + "\n" : "") + line + "\n";
 }
 function ensureLogsDir() {
-  mkdirSync8(logsDir(), { recursive: true });
+  mkdirSync11(logsDir(), { recursive: true });
 }
 
 // src/commands/schedule.ts
@@ -3660,8 +5499,8 @@ function parseAdd(rest) {
 }
 function installDarwin(job, holtPath) {
   const path = plistPath(job.id);
-  mkdirSync9(dirname3(path), { recursive: true });
-  writeFileSync11(path, buildLaunchdPlist(job, holtPath), "utf8");
+  mkdirSync12(dirname4(path), { recursive: true });
+  writeFileSync14(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 +5529,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 (existsSync14(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 writeFileSync16, mkdirSync as mkdirSync14, rmSync as rmSync7, existsSync as existsSync15 } from "fs";
+import { dirname as dirname5, resolve as resolve5 } from "path";
+
+// src/routines.ts
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync15, mkdirSync as mkdirSync13 } from "fs";
+import { join as join15 } from "path";
+function sanitizeRoutineName(name) {
+  return (name || "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function routinesPath() {
+  return join15(GLOBAL_DIR, "routines.json");
+}
+function loadRoutines() {
+  try {
+    const raw = JSON.parse(readFileSync15(routinesPath(), "utf8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+function saveRoutines(routines) {
+  mkdirSync13(GLOBAL_DIR, { recursive: true });
+  writeFileSync15(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);
+  mkdirSync14(dirname5(path), { recursive: true });
+  writeFileSync16(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 (existsSync15(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 = resolve5(routine2.workspace, outTarget);
+    try {
+      writeFileSync16(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 +6107,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 readFileSync16 } from "fs";
 async function notify(args) {
   const nonFlag = args.filter((a) => a !== "-" && !a.startsWith("--"));
   const wantsStdin = args.includes("-") || !process.stdin.isTTY;
@@ -3819,7 +6120,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 +6143,409 @@ async function notify(args) {
     process.exitCode = 1;
   }
 }
-function readStdin() {
+function readStdin2() {
   try {
-    return readFileSync10(0, "utf8");
+    return readFileSync16(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 writeFileSync17 } from "fs";
+import { resolve as resolve6 } 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 = resolve6(process.cwd(), p.out);
+    try {
+      writeFileSync17(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 +6564,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 +6618,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 +6631,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}"`);