@holt-os/holt 0.12.0 → 0.12.1

package/README.md

@@ -6,7 +6,14 @@ Holt is an open-source, self-hosted personal agent OS. Clone it, pick your skill
 
 > A *holt* is a small wood: a sheltered place where things are kept and grow. That's the idea. A private home for your knowledge that compounds over time.
 
-> **Status: young but genuinely useful.** Working today: `holt init` and `holt chat`, brains as agent CLIs (Claude Code, Codex, Gemini) or direct API connections with your own key, mid-conversation brain switching that keeps context, persistent per-folder memory with semantic recall, skills in the portable SKILL.md format, and `holt graph`: your memory drawn as an interactive knowledge graph.
+> **Status: shipping and usable today.** Working now:
+>
+> - `holt init` + `holt chat` with any brain (Claude Code, Codex, Gemini, or a direct API key), and mid-conversation brain switching that keeps context.
+> - Per-folder memory with semantic recall and distilled facts, ambient memory for Claude Code (`holt hook`), and opt-in memory shared across folders (`holt memory global`).
+> - A self-maintaining knowledge wiki (`holt wiki`) and an interactive knowledge graph (`holt graph`) that can also ingest your code and docs into communities.
+> - Run a task once, on a schedule, or as a named routine (`holt run` / `schedule` / `routine`), and reach it from your phone over Telegram.
+> - Draft in your own voice with anti-AI checks (`holt write`), and size your setup with `holt doctor`.
+> - Ten built-in skills plus a community registry (`holt skill search`), and an MCP server so Claude Code, Cursor, or Codex can read this folder's memory.
 
 ---
 
@@ -319,6 +326,8 @@ Install **merges** into any existing `hooks` config, never clobbers unrelated se
 
 **Trusted-folder guard (important).** The two runtime hooks (`holt hook inject` and `holt hook capture`, invoked by Claude Code, not you) no-op **silently** unless the folder is a trusted Holt workspace with an existing `.holt/memory`. So Holt never injects your private notes into an unrelated project, and never creates memory in a folder you never set up. To make a folder ambient, run `holt init` (or `holt chat`) there once so it becomes trusted and gets its `.holt/memory`. The inject hook keeps stdout clean (only the context block is printed, since Claude Code injects it verbatim); all diagnostics go to stderr, and both hooks always exit 0 so a memory step never blocks or slows your prompt.
 
+**Seeing what the hooks did (`~/.holt/hooks.log`).** Since the hooks stay silent, every `holt hook capture` run appends **one** line to `~/.holt/hooks.log` with the outcome or the exact skip reason (untrusted folder, no config, `extractFacts` off, no usable brain, missing or empty transcript, too few exchanges, or `saved N facts`), preceded by a line of the raw hook fields it received. Check this file first if capture seems to save nothing. `inject` uses the same log but stays quiet by default; set `HOLT_HOOK_DEBUG=1` to make it log too.
+
 To uninstall, run `holt hook remove` (add `--project` if you installed with `--project`).
 
 ## Output format
@@ -435,6 +444,8 @@ holt voice clear      # remove it
 
 The interview asks you to pick a **depth** up front: `quick` (a few questions) or `detailed` (more). Questions are about **writing and communication style only**: tone, sentence length, first vs third person, emoji habits, words you love or ban, who you write for, and what you want to sound like and not sound like.
 
+Changed your mind at the first prompt? Answer `n`, `skip`, `cancel`, or just press enter to back out cleanly. Nothing is saved and no profile is built; run `holt voice` again whenever you like. Inside the question list, an empty answer skips only that one question.
+
 Privacy is a hard rule. The interview never asks for personal details (no name, job, location, or life story). If you happen to mention something personal in an answer, Holt stores only what you typed and never asks follow ups.
 
 You can also feed it real writing. `holt voice add <file>` reads a file; inside the interview you can paste a sample instead. Samples are stored as a hash and length by default; an excerpt is kept only if you say yes, so Holt can match your rhythm directly.

package/dist/cli.js

@@ -27,6 +27,70 @@ function bar(fraction, width = 12) {
   const filled = Math.round(f * width);
   return c.green("\u2588".repeat(filled)) + c.dim("\u2591".repeat(width - filled));
 }
+var CSI = "\x1B[";
+function createStatusBar() {
+  const out = process.stdout;
+  if (!out.isTTY) {
+    return { active: false, set: () => {
+    }, detach: () => {
+    } };
+  }
+  let text = "";
+  let detached = false;
+  const realWrite = out.write.bind(out);
+  const rows = () => out.rows || 24;
+  const paint = () => {
+    if (detached) return;
+    const r = rows();
+    realWrite(
+      `\x1B7${CSI}${r};1H${CSI}2K` + // clear the line
+      text + `\x1B8`
+      // restore cursor
+    );
+  };
+  const reserve = () => {
+    const r = rows();
+    realWrite(
+      `${CSI}1;${Math.max(1, r - 1)}r${CSI}${Math.max(1, r - 1)};1H`
+      // move cursor into the region
+    );
+    paint();
+  };
+  const onResize = () => {
+    if (!detached) reserve();
+  };
+  const detach = () => {
+    if (detached) return;
+    detached = true;
+    out.removeListener("resize", onResize);
+    process.removeListener("exit", detach);
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    const r = rows();
+    realWrite(
+      `${CSI}r\x1B7${CSI}${r};1H${CSI}2K\x1B8${CSI}?25h`
+      // ensure cursor visible
+    );
+  };
+  const onSignal = (sig) => {
+    detach();
+    process.removeListener(sig, onSignal);
+    process.kill(process.pid, sig);
+  };
+  reserve();
+  out.on("resize", onResize);
+  process.once("exit", detach);
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  return {
+    active: true,
+    set(next) {
+      text = next;
+      paint();
+    },
+    detach
+  };
+}
 function createReader() {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   const buffer = [];
@@ -225,6 +289,7 @@ function renderPrompt(history, message, memory = []) {
   const parts = [];
   if (recent.length || memory.length) {
     parts.push(
+      "You are the user's assistant, running through Holt, a tool that gives you durable memory of this user across sessions. Notes recalled from their past sessions may appear below; use them naturally and answer as their assistant.",
       "You are continuing an ongoing conversation. Use the context below and reply only as the assistant to the final User message."
     );
   }
@@ -1756,10 +1821,19 @@ var QUESTIONS = [
   { 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" }
 ];
+function isSkip(a) {
+  if (a === null) return true;
+  const s = a.trim().toLowerCase();
+  return s === "" || s === "n" || s === "no" || s === "skip" || s === "cancel" || s === "q" || s === "quit";
+}
+function skipNotice() {
+  console.log(c.dim("\n  Skipped. Run ") + c.accent("holt voice") + c.dim(" anytime.\n"));
+}
 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();
+  if (s === "n" || s === "no" || s === "skip" || s === "cancel" || s === "q" || s === "quit") return null;
   return s === "detailed" || s === "d" ? "detailed" : "quick";
 }
 async function runQuestions(ask, depth) {
@@ -1887,13 +1961,21 @@ async function voiceInterview() {
   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 modeRaw = await ask("Do the [i]nterview, add [s]amples, or [b]oth? [i] ");
+  if (isSkip(modeRaw)) {
+    close();
+    skipNotice();
+    return;
+  }
+  const mode = (modeRaw ?? "").trim().toLowerCase();
+  const wantInterview = mode === "i" || mode === "b" || mode === "interview" || mode === "both";
   const wantSamples = mode === "s" || mode === "b" || mode === "samples" || mode === "both";
-  if (wantInterview) {
+  const wantInterviewOrDefault = wantInterview || !wantSamples;
+  if (wantInterviewOrDefault) {
     const depth = await askDepth(ask);
     if (depth === null) {
       close();
+      skipNotice();
       return;
     }
     v.depth = depth;
@@ -1917,6 +1999,11 @@ async function voiceInterview() {
     }
   }
   close();
+  const gotAnswers = v.answers.some((a) => a.answer.trim());
+  if (!gotAnswers && v.samples.length === 0) {
+    skipNotice();
+    return;
+  }
   saveVoice(v);
   console.log(c.dim("\n  Building your style profile from a brain..."));
   const synthed = await synthesizeVoice(v);
@@ -2218,7 +2305,10 @@ async function extractAndSaveFacts(active, cfg, history, session) {
   try {
     if (Math.floor(history.length / 2) < MIN_EXCHANGES_FOR_EXTRACTION) return 0;
     const prompt = buildExtractionPrompt(history);
-    const res = active.kind === "cli" ? await runBrain(cfg.brains[active.id], prompt) : await runApiBrain(active.brain, prompt);
+    const res = active.kind === "cli" ? await runBrain(
+      active.commandOverride ? { ...cfg.brains[active.id], command: active.commandOverride } : cfg.brains[active.id],
+      prompt
+    ) : await runApiBrain(active.brain, prompt);
     if (!res.ok) return 0;
     const facts = parseFacts(res.text);
     let saved = 0;
@@ -2896,9 +2986,8 @@ function saveReply(reply, format, name) {
 function statusLine(brainLabel, history) {
   const live = Math.min(history.length, MAX_REPLAY_TURNS);
   const frac = MAX_REPLAY_TURNS ? live / MAX_REPLAY_TURNS : 0;
-  const pct = Math.round(frac * 100);
   const mem = memStats().turns;
-  return c.dim("  " + brainLabel + "  ") + c.dim("[") + bar(frac) + c.dim("]") + c.dim(`  ${pct}% context  \xB7  ${mem} in memory`);
+  return c.dim("  " + brainLabel + "  ") + c.dim("[") + bar(frac) + c.dim("]") + c.dim(`  recent ${live}/${MAX_REPLAY_TURNS}  \xB7  ${mem} in memory`);
 }
 function help() {
   console.log(c.dim([
@@ -2954,6 +3043,12 @@ async function chat() {
   const session = newSessionId();
   const history = [];
   let lastReply = "";
+  const sb = createStatusBar();
+  const showStatus = () => {
+    const line = statusLine(active.label, history);
+    if (sb.active) sb.set(line);
+    else console.log(line + "\n");
+  };
   const embedOk = await embeddingsAvailable();
   const stats = memStats();
   console.log("\n" + c.accent("Holt") + c.dim(`  brain: ${active.label}`));
@@ -2964,7 +3059,7 @@ async function chat() {
     console.log(c.dim(`  ${stats.turns - stats.withEmbeddings} older moments lack embeddings. Run "holt memory embed" to upgrade them.`));
   }
   console.log(c.dim("Type a message. Commands: /brain  /memory  /output  /save  /setting  /clear  /help  /exit"));
-  console.log(statusLine(active.label, history) + "\n");
+  showStatus();
   while (true) {
     const raw = await ask(c.accent("\u203A "));
     if (raw === null) break;
@@ -3107,11 +3202,12 @@ async function chat() {
       const now = Date.now();
       appendTurn({ id: randomUUID3().slice(0, 8), ts: now, session, role: "user", content: line, emb: await embed(line) ?? void 0 });
       appendTurn({ id: randomUUID3().slice(0, 8), ts: now, session, role: "assistant", content: res.text, emb: await embed(res.text) ?? void 0 });
-      console.log(statusLine(active.label, history) + "\n");
+      showStatus();
     } else {
       console.log(c.red("\n  " + res.text + "\n"));
     }
   }
+  sb.detach();
   if (cfg.memory?.extractFacts !== false) {
     try {
       const arg = active.kind === "cli" ? { kind: "cli", id: active.id } : { kind: "api", brain: active.brain };
@@ -5853,7 +5949,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.12.0";
+var VERSION = "0.12.1";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -5899,7 +5995,8 @@ async function mcp(sub, rest = []) {
 }
 
 // src/commands/hook.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync11, copyFileSync, realpathSync as realpathSync2 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, existsSync as existsSync14, mkdirSync as mkdirSync11, copyFileSync, realpathSync as realpathSync2, appendFileSync as appendFileSync2, statSync as statSync7 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
 import { join as join15, dirname as dirname5 } from "path";
 import { homedir as homedir3 } from "os";
 var EVENT = {
@@ -6114,25 +6211,87 @@ function guardTrusted(real) {
   if (!existsSync14(memDir())) return false;
   return true;
 }
+function hookLog(msg) {
+  try {
+    mkdirSync11(GLOBAL_DIR, { recursive: true });
+    appendFileSync2(join15(GLOBAL_DIR, "hooks.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`, "utf8");
+  } catch {
+  }
+}
+function fileBytes(path) {
+  if (!path) return 0;
+  try {
+    return statSync7(path).size;
+  } catch {
+    return 0;
+  }
+}
 async function inject() {
+  const debug = !!process.env.HOLT_HOOK_DEBUG;
+  const dlog = (m) => {
+    if (debug) hookLog(m);
+  };
   try {
     const raw = await readStdin(2e3);
     const data = parseHookInput(raw);
+    dlog(
+      `inject cwd=${data.cwd ?? "(none)"} event=${data.hook_event_name ?? "UserPromptSubmit"} hasCwd=${!!data.cwd} promptLen=${(data.prompt || "").trim().length}`
+    );
     const prompt = (data.prompt || "").trim();
-    if (prompt.length < 3) return;
+    if (prompt.length < 3) {
+      dlog("inject -> prompt too short");
+      return;
+    }
     const real = enterFolder(data.cwd);
-    if (!real) return;
-    if (!guardTrusted(real)) return;
+    if (!real) {
+      dlog("inject -> no cwd");
+      return;
+    }
+    if (!guardTrusted(real)) {
+      dlog(`inject -> untrusted or no .holt/memory (real=${real})`);
+      return;
+    }
     const session = data.session_id || newSessionId();
     const hits = await recall(prompt, session, 4);
-    if (!hits.length) return;
+    if (!hits.length) {
+      dlog("inject -> recalled 0 notes");
+      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")
+      [
+        "Background on this user, recalled from earlier sessions (use it directly, do not mention looking it up):",
+        ...lines,
+        ""
+      ].join("\n")
     );
+    dlog(`inject -> injected ${hits.length} note(s)`);
   } catch (e) {
     process.stderr.write("holt hook inject: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    dlog("inject -> error: " + (e instanceof Error ? e.message : String(e)));
+  }
+}
+function countLines(raw) {
+  let n = 0;
+  for (const line of raw.split("\n")) if (line.trim()) n++;
+  return n;
+}
+function textFromContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const b of content) {
+    if (typeof b === "string") {
+      parts.push(b);
+      continue;
+    }
+    if (!b || typeof b !== "object") continue;
+    const blk = b;
+    if (blk.type === "tool_use" || blk.type === "tool_result" || blk.type === "thinking") continue;
+    if (typeof blk.text === "string") parts.push(blk.text);
   }
+  return parts.join(" ").trim();
 }
 function readTranscript(path) {
   const out = [];
@@ -6150,56 +6309,133 @@ function readTranscript(path) {
     } catch {
       continue;
     }
+    if (!rec || typeof rec !== "object") 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();
-    }
+    const topType = d.type === "user" || d.type === "assistant" ? d.type : void 0;
+    const m = d.message && typeof d.message === "object" ? d.message : void 0;
+    const msgRole = m && (m.role === "user" || m.role === "assistant") ? m.role : void 0;
+    const role = msgRole ?? topType;
+    if (role !== "user" && role !== "assistant") continue;
+    let text = m ? textFromContent(m.content) : "";
+    if (!text) text = textFromContent(d.content);
     text = text.trim();
     if (text.length < 3) continue;
-    out.push({ role: m.role, content: text });
+    out.push({ role, content: text });
   }
   return out;
 }
+function resolveCommandPath(command) {
+  if (command.startsWith("/") && existsSync14(command)) return command;
+  try {
+    const shell = process.env.SHELL || "/bin/sh";
+    const res = spawnSync3(shell, ["-lc", "command -v " + command], { encoding: "utf8" });
+    if (res.status === 0) {
+      const p = (res.stdout || "").trim().split("\n")[0]?.trim();
+      if (p && p.startsWith("/") && existsSync14(p)) return p;
+    }
+  } catch {
+  }
+  const home = homedir3();
+  const dirs = [
+    join15(home, ".local", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    join15(home, ".npm-global", "bin"),
+    "/usr/bin",
+    "/bin"
+  ];
+  for (const dir of dirs) {
+    const candidate = join15(dir, command);
+    if (existsSync14(candidate)) return candidate;
+  }
+  return null;
+}
 function resolveExtractionBrain(cfg) {
   const id = cfg.defaultBrain;
-  if (!id) return null;
+  const diag = { defaultBrain: id ?? "(none)", command: "(none)", whichFound: false, resolvedPath: null };
+  if (!id) return { brain: null, diag };
   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 command = cfg.brains[bid].command;
+    diag.command = command;
+    if (!cfg.brains[bid].enabled) return { brain: null, diag };
+    const whichFound = isInstalled(command);
+    diag.whichFound = whichFound;
+    if (whichFound) {
+      return { brain: { kind: "cli", id: bid }, diag };
+    }
+    const resolved = resolveCommandPath(command);
+    diag.resolvedPath = resolved;
+    if (resolved) {
+      return { brain: { kind: "cli", id: bid, commandOverride: resolved }, diag };
+    }
+    return { brain: null, diag };
   }
   const api = findApiBrain(cfg, id);
-  if (api && resolveApiKey(api)) return { kind: "api", brain: api };
-  return null;
+  if (api && resolveApiKey(api)) return { brain: { kind: "api", brain: api }, diag };
+  return { brain: null, diag };
 }
 async function capture() {
+  const cwdForLog = process.cwd();
   try {
     const raw = await readStdin(3e3);
     const data = parseHookInput(raw);
+    hookLog(
+      `capture-fields event=${data.hook_event_name ?? "Stop"} hasCwd=${!!data.cwd} hasTranscriptPath=${!!data.transcript_path} transcriptBytes=${fileBytes(data.transcript_path)} stdinBytes=${raw.length}`
+    );
     const real = enterFolder(data.cwd);
-    if (!real) return;
-    if (!guardTrusted(real)) return;
+    if (!real) {
+      hookLog(`capture cwd=${data.cwd ?? cwdForLog} event=Stop -> no cwd`);
+      return;
+    }
+    if (!guardTrusted(real)) {
+      hookLog(`capture cwd=${real} event=Stop -> untrusted or no .holt/memory (real=${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;
+    if (!cfg) {
+      hookLog(`capture cwd=${real} event=Stop -> no config`);
+      return;
+    }
+    if (cfg.memory?.extractFacts === false) {
+      hookLog(`capture cwd=${real} event=Stop -> extractFacts off`);
+      return;
+    }
+    const { brain, diag } = resolveExtractionBrain(cfg);
+    if (!brain) {
+      hookLog(
+        `capture cwd=${real} event=Stop -> no usable brain (defaultBrain=${diag.defaultBrain} command=${diag.command} whichFound=${diag.whichFound} resolvedPath=${diag.resolvedPath ?? "none"})`
+      );
+      return;
+    }
+    if (brain.kind === "cli" && brain.commandOverride) {
+      hookLog(`capture cwd=${real} event=Stop -> brain resolved via absolute path (resolvedPath=${brain.commandOverride})`);
+    }
+    if (!data.transcript_path) {
+      hookLog(`capture cwd=${real} event=Stop -> no transcript_path`);
+      return;
+    }
     const history = readTranscript(data.transcript_path);
-    if (!history.length) return;
+    if (!history.length) {
+      let bytes = 0;
+      let lines = 0;
+      try {
+        const rawT = readFileSync15(data.transcript_path, "utf8");
+        bytes = Buffer.byteLength(rawT, "utf8");
+        lines = countLines(rawT);
+      } catch {
+      }
+      hookLog(`capture cwd=${real} event=Stop -> transcript parsed 0 turns (path=${data.transcript_path} bytes=${bytes} lines=${lines})`);
+      return;
+    }
+    const exchanges = Math.floor(history.length / 2);
+    if (exchanges < MIN_EXCHANGES_FOR_EXTRACTION) {
+      hookLog(`capture cwd=${real} event=Stop -> only ${exchanges} exchange(s) (<${MIN_EXCHANGES_FOR_EXTRACTION}, skipped)`);
+      return;
+    }
     const session = "hook-" + (data.session_id || newSessionId());
     const n = await extractAndSaveFacts(brain, cfg, history, session);
+    hookLog(`capture cwd=${real} event=Stop -> saved ${n} fact${n === 1 ? "" : "s"}`);
     if (n > 0) process.stderr.write(`holt hook capture: saved ${n} fact${n === 1 ? "" : "s"} to ${memDir()}
 `);
     if (cfg.wiki?.autoSync) {
@@ -6212,7 +6448,9 @@ async function capture() {
       }
     }
   } catch (e) {
-    process.stderr.write("holt hook capture: " + (e instanceof Error ? e.message : String(e)) + "\n");
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write("holt hook capture: " + msg + "\n");
+    hookLog(`capture cwd=${cwdForLog} event=Stop -> error: ${msg}`);
   }
 }
 var USAGE2 = [
@@ -6370,7 +6608,7 @@ async function run(args) {
 }
 
 // src/commands/schedule.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync5 } from "child_process";
 import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync13, rmSync as rmSync6, existsSync as existsSync15 } from "fs";
 import { dirname as dirname6 } from "path";
 
@@ -6379,7 +6617,7 @@ import { homedir as homedir4 } from "os";
 import { join as join16 } from "path";
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync14, mkdirSync as mkdirSync12 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 function schedulesPath() {
   return join16(GLOBAL_DIR, "schedules.json");
 }
@@ -6435,7 +6673,7 @@ function shQuote(s) {
 function resolveHoltPath() {
   try {
     const finder = process.platform === "win32" ? "where" : "which";
-    const res = spawnSync3(finder, ["holt"], { encoding: "utf8" });
+    const res = spawnSync4(finder, ["holt"], { encoding: "utf8" });
     if (res.status === 0 && typeof res.stdout === "string") {
       const first = res.stdout.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
       if (first) return first;
@@ -6538,7 +6776,7 @@ function installDarwin(job, holtPath) {
   const path = plistPath(job.id);
   mkdirSync13(dirname6(path), { recursive: true });
   writeFileSync15(path, buildLaunchdPlist(job, holtPath), "utf8");
-  const res = spawnSync4("launchctl", ["load", "-w", path], { encoding: "utf8" });
+  const res = spawnSync5("launchctl", ["load", "-w", path], { encoding: "utf8" });
   if (res.status === 0) {
     console.log(c.green("  Loaded into launchd."));
   } else {
@@ -6549,11 +6787,11 @@ function installDarwin(job, holtPath) {
   console.log(c.dim(`  plist: ${path}`));
 }
 function currentCrontab() {
-  const res = spawnSync4("crontab", ["-l"], { encoding: "utf8" });
+  const res = spawnSync5("crontab", ["-l"], { encoding: "utf8" });
   return res.status === 0 && typeof res.stdout === "string" ? res.stdout : "";
 }
 function writeCrontab(body) {
-  const res = spawnSync4("crontab", ["-"], { input: body, encoding: "utf8" });
+  const res = spawnSync5("crontab", ["-"], { input: body, encoding: "utf8" });
   return res.status === 0;
 }
 function installLinux(job, holtPath) {
@@ -6626,7 +6864,7 @@ function listCmd2() {
 function removeDarwin(id) {
   const path = plistPath(id);
   if (existsSync15(path)) {
-    spawnSync4("launchctl", ["unload", path], { encoding: "utf8" });
+    spawnSync5("launchctl", ["unload", path], { encoding: "utf8" });
     try {
       rmSync6(path);
     } catch {
@@ -6634,10 +6872,10 @@ function removeDarwin(id) {
   }
 }
 function removeLinux(id) {
-  const res = spawnSync4("crontab", ["-l"], { encoding: "utf8" });
+  const res = spawnSync5("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" });
+  spawnSync5("crontab", ["-"], { input: next, encoding: "utf8" });
 }
 function removeCmd(rest) {
   const id = rest[0];
@@ -6687,7 +6925,7 @@ async function schedule(sub, rest = []) {
 }
 
 // src/commands/routine.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 import { writeFileSync as writeFileSync17, mkdirSync as mkdirSync15, rmSync as rmSync7, existsSync as existsSync16 } from "fs";
 import { dirname as dirname7, resolve as resolve6 } from "path";
 
@@ -6772,7 +7010,7 @@ function installDarwin2(job, holtPath) {
   const path = plistPath(job.id);
   mkdirSync15(dirname7(path), { recursive: true });
   writeFileSync17(path, buildLaunchdPlist(job, holtPath), "utf8");
-  const res = spawnSync5("launchctl", ["load", "-w", path], { encoding: "utf8" });
+  const res = spawnSync6("launchctl", ["load", "-w", path], { encoding: "utf8" });
   if (res.status === 0) {
     console.log(c.green("  Loaded into launchd."));
   } else {
@@ -6783,11 +7021,11 @@ function installDarwin2(job, holtPath) {
   console.log(c.dim(`  plist: ${path}`));
 }
 function currentCrontab2() {
-  const res = spawnSync5("crontab", ["-l"], { encoding: "utf8" });
+  const res = spawnSync6("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" });
+  const res = spawnSync6("crontab", ["-"], { input: body, encoding: "utf8" });
   return res.status === 0;
 }
 function installLinux2(job, holtPath) {
@@ -6816,7 +7054,7 @@ function installSchedule(r) {
 function removeScheduleDarwin(id) {
   const path = plistPath(id);
   if (existsSync16(path)) {
-    spawnSync5("launchctl", ["unload", path], { encoding: "utf8" });
+    spawnSync6("launchctl", ["unload", path], { encoding: "utf8" });
     try {
       rmSync7(path);
     } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holt-os/holt",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "An open-source personal agent OS: any LLM, private memory you can see and walk.",
   "type": "module",
   "license": "MIT",