@holt-os/holt 0.6.0 → 0.8.0

package/README.md

@@ -127,18 +127,95 @@ holt skill remove <name>              delete a skill
 
 In chat, run one with `/skill <name> [your input]`. Available skills are also listed to the brain each turn, so it knows what it can be asked to follow.
 
+## Use Holt from your other tools (MCP)
+
+Holt can run as an [MCP](https://modelcontextprotocol.io) server, so Claude Code, Cursor, and Codex can recall and remember from Holt's memory for the folder without leaving those tools.
+
+```bash
+holt mcp        # run the MCP server for the current folder (talks JSON-RPC over stdio)
+holt mcp setup  # print the config snippets for each client
+```
+
+The server serves the memory of whatever folder it is launched in. Because MCP is non-interactive (stdin carries the protocol), it cannot prompt for trust, so it **auto-trusts the launch folder** and adds it to `~/.holt/trust.json`. Startup logging goes to stderr; stdout is reserved for the protocol.
+
+Tools it exposes:
+
+- `recall` (`query`, optional `k`): search this folder's memory for relevant moments and facts.
+- `remember` (`content`): save a durable fact to this folder's memory.
+- `list_skills`: list the skills installed for this folder.
+- `get_skill` (`name`): get a skill's full instructions.
+- `memory_stats`: memory statistics for this folder.
+
+**Claude Code**
+
+```bash
+claude mcp add holt -- holt mcp
+```
+
+**Cursor / Codex** (JSON config):
+
+```json
+{ "mcpServers": { "holt": { "command": "holt", "args": ["mcp"] } } }
+```
+
+Point the client at the folder whose memory you want it to use; Holt serves whatever folder the server process starts in.
+
 ## Output format
 
 Replies print as markdown. `/output html` (or `markdown`) switches the save format and persists it. `/save [name]` writes the last reply to the current folder: `.md`, or a small self-contained dark-theme `.html` page.
 
+## Run tasks, schedule them, reach them from your phone
+
+Beyond interactive chat, Holt can run a task once, on a timer, or from Telegram. The selected brain does the task; your memory is recalled into it automatically.
+
+### holt run
+
+Run a single task non-interactively. It recalls relevant memory, injects your skills, runs the brain once, streams the reply, and saves the exchange to this folder's memory.
+
+```bash
+holt run "summarize the open items in this folder"
+```
+
+Options: `--brain <id>` pick a brain, `--out <file>` also write the reply to a file, `--no-store` skip saving, `--no-recall` skip memory, `--quiet` suppress streaming. The folder must be trusted first (`holt init` or `holt chat` once); in a non-interactive context an untrusted folder exits non-zero instead of prompting.
+
+### holt schedule
+
+Run a task automatically on a timer, using your OS scheduler (launchd on macOS, cron on Linux). A scheduled run behaves exactly like typing `holt run` in that folder.
+
+```bash
+holt schedule add "summarize my inbox and flag what is urgent" 07:00 --notify
+holt schedule list
+holt schedule remove <id>
+```
+
+`<HH:MM>` is a 24h daily time. `--notify` pushes the output to your Telegram. Jobs live in `~/.holt/schedules.json`; each run logs to `~/.holt/logs/<id>.log`.
+
+### Telegram: chat with Holt from your phone
+
+Holt can run as a Telegram bot. Messages you send are run through your brain (with memory) and the reply comes back to your phone. Single user: only your chat id is served.
+
+```bash
+holt telegram setup   # message @BotFather for a token, paste it, auto-detect your chat id
+holt telegram         # run the bot (keep it running under a service manager)
+holt notify "backup done"          # push a one-off message
+holt run "daily brief" | holt notify   # pipe any output to your phone
+```
+
+The token is stored in `~/.holt/telegram.json` (mode 600) and never printed in full.
+
 ## Commands
 
 ```
 holt init            set up (trust, brains, sign-in, defaults) for this folder
 holt chat            start a session that remembers past ones
+holt run <task>      run one task non-interactively (recall, brain, remember)
+holt schedule        run a task on a timer: add | list | remove
+holt telegram        chat with Holt from your phone: telegram [setup]
+holt notify [msg]    push a message to your phone over Telegram (stdin-friendly)
 holt graph           see your memory as an interactive knowledge graph
+holt mcp             run an MCP server so other tools use this folder's memory (holt mcp setup)
 holt skill           manage skills: list | show | create | add | remove
-holt memory          inspect memory: holt memory [search <query> | embed | clear]
+holt memory          inspect memory: holt memory [search <query> | facts | embed | clear]
 holt setting         configure brains, API brains, and launch command
 holt login <brain>   sign in to claude, codex, or gemini
 holt version         print version
@@ -147,7 +224,7 @@ holt help            show help
 
 ## Configuration
 
-`holt init` writes `<folder>/.holt/config.json` (default brain and enabled brains for that folder). Trusted folders live in `~/.holt/trust.json`. Edit settings with `holt setting`.
+`holt init` writes `<folder>/.holt/config.json` (default brain and enabled brains for that folder). Trusted folders live in `~/.holt/trust.json`. Edit settings with `holt setting`. Scheduled jobs live in `~/.holt/schedules.json`, and the Telegram token in `~/.holt/telegram.json` (mode 600).
 
 ## Architecture
 
@@ -162,8 +239,8 @@ Built in always-shippable phases toward a full-vision v1:
 2. **Any LLM directly**: API brains with your own key, HTML or Markdown output *(shipped)*
 3. **Skills**: portable SKILL.md skills, create/add/run *(shipped)*
 4. **Knowledge graph**: see and navigate your own memory with `holt graph` *(shipped)*
-5. **Orchestration**: a local model works, a cloud model reviews the risky steps
-6. **Channels and polish**: Telegram, docs site, skill registry publishing
+5. **Everywhere**: MCP server so other tools read Holt's memory, plus `holt run`, scheduling, and Telegram *(shipped)*
+6. **Next**: docs site, skill registry publishing, more channels
 
 ## Contributing
 

package/dist/cli.js

@@ -36,11 +36,11 @@ function createReader() {
     closed = true;
     while (waiters.length) waiters.shift()(null);
   });
-  const ask = (q) => new Promise((resolve3) => {
+  const ask = (q) => new Promise((resolve4) => {
     if (q) process.stdout.write(q);
-    if (buffer.length) resolve3(buffer.shift());
-    else if (closed) resolve3(null);
-    else waiters.push(resolve3);
+    if (buffer.length) resolve4(buffer.shift());
+    else if (closed) resolve4(null);
+    else waiters.push(resolve4);
   });
   return { ask, close: () => rl.close() };
 }
@@ -222,29 +222,29 @@ function renderPrompt(history, message, memory = []) {
   return parts.join("\n");
 }
 function runBrain(brain, prompt, onChunk) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let child;
     try {
       child = spawn(brain.command, [...brain.args, prompt], { stdio: ["ignore", "pipe", "pipe"] });
     } catch (e) {
-      resolve3({ ok: false, text: `Could not launch "${brain.command}": ${e.message}` });
+      resolve4({ ok: false, text: `Could not launch "${brain.command}": ${e.message}` });
       return;
     }
     let out = "";
-    let err = "";
+    let err2 = "";
     child.stdout.on("data", (d) => {
       const s = d.toString();
       out += s;
       if (onChunk) onChunk(s);
     });
     child.stderr.on("data", (d) => {
-      err += d.toString();
+      err2 += d.toString();
     });
-    child.on("error", (e) => resolve3({ ok: false, text: `Could not run "${brain.command}": ${e.message}` }));
+    child.on("error", (e) => resolve4({ ok: false, text: `Could not run "${brain.command}": ${e.message}` }));
     child.on("close", (code) => {
       const text = out.trim();
-      if (code === 0 && text) resolve3({ ok: true, text });
-      else resolve3({ ok: false, text: err.trim() || text || `"${brain.command}" exited with code ${code}` });
+      if (code === 0 && text) resolve4({ ok: true, text });
+      else resolve4({ ok: false, text: err2.trim() || text || `"${brain.command}" exited with code ${code}` });
     });
   });
 }
@@ -393,16 +393,16 @@ function currentAlias() {
 // src/install.ts
 import { spawn as spawn2 } from "child_process";
 function runInteractive(cmd, args) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let child;
     try {
       child = spawn2(cmd, args, { stdio: "inherit" });
     } catch {
-      resolve3(-1);
+      resolve4(-1);
       return;
     }
-    child.on("error", () => resolve3(-1));
-    child.on("close", (code) => resolve3(code ?? -1));
+    child.on("error", () => resolve4(-1));
+    child.on("close", (code) => resolve4(code ?? -1));
   });
 }
 
@@ -765,9 +765,9 @@ async function init() {
   console.log("Looking for agent CLIs on your machine...\n");
   const found = [];
   for (const id of BRAIN_IDS) {
-    const ok = isInstalled(BRAIN_DEFS[id].command);
-    console.log(`  ${ok ? c.green("found  ") : c.dim("missing")}  ${BRAIN_DEFS[id].label} (${BRAIN_DEFS[id].command})`);
-    if (ok) found.push(id);
+    const ok2 = isInstalled(BRAIN_DEFS[id].command);
+    console.log(`  ${ok2 ? c.green("found  ") : c.dim("missing")}  ${BRAIN_DEFS[id].label} (${BRAIN_DEFS[id].command})`);
+    if (ok2) found.push(id);
   }
   console.log("");
   const chosen = parseBrains(
@@ -988,8 +988,8 @@ async function runApiBrain(brain, prompt, onChunk) {
   let carry = "";
   let text = "";
   try {
-    for await (const chunk of res.body) {
-      carry += decoder.decode(chunk, { stream: true });
+    for await (const chunk2 of res.body) {
+      carry += decoder.decode(chunk2, { stream: true });
       const { events, rest } = parseSSELines(carry);
       carry = rest;
       for (const ev of events) {
@@ -1597,9 +1597,9 @@ async function chat() {
     const base = renderPrompt(history, line, remembered);
     const prompt = promptOverride ?? (skillsBlock ? skillsBlock + "\n\n" + base : base);
     let streamed = false;
-    const onChunk = (chunk) => {
+    const onChunk = (chunk2) => {
       streamed = true;
-      process.stdout.write(chunk);
+      process.stdout.write(chunk2);
     };
     const res = active.kind === "cli" ? await runBrain(cfg.brains[active.id], prompt, onChunk) : await runApiBrain(active.brain, prompt, onChunk);
     if (res.ok) {
@@ -2692,8 +2692,1055 @@ async function graph(args = []) {
   }
 }
 
+// src/mcp/server.ts
+var DEFAULT_PROTOCOL_VERSION = "2025-06-18";
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function ok(id, result) {
+  return { jsonrpc: "2.0", id: id ?? null, result };
+}
+function err(id, code, message) {
+  return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
+}
+async function handleMcpMessage(msg, opts) {
+  if (!isObject(msg)) {
+    console.error("[mcp] ignoring non-object message");
+    return null;
+  }
+  const message = msg;
+  const method = typeof message.method === "string" ? message.method : void 0;
+  const hasId = "id" in message && message.id !== void 0 && message.id !== null;
+  const id = message.id;
+  if (method === void 0) {
+    if (hasId) return err(id, -32600, "Invalid Request: missing method");
+    console.error("[mcp] ignoring message with no method");
+    return null;
+  }
+  if (!hasId) {
+    if (!method.startsWith("notifications/")) {
+      console.error(`[mcp] ignoring notification-shaped message: ${method}`);
+    }
+    return null;
+  }
+  const params = isObject(message.params) ? message.params : {};
+  try {
+    switch (method) {
+      case "initialize": {
+        const requested = params["protocolVersion"];
+        const protocolVersion = typeof requested === "string" ? requested : DEFAULT_PROTOCOL_VERSION;
+        return ok(id, {
+          protocolVersion,
+          capabilities: { tools: {} },
+          serverInfo: { name: opts.name, version: opts.version }
+        });
+      }
+      case "ping":
+        return ok(id, {});
+      case "tools/list":
+        return ok(id, {
+          tools: opts.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema
+          }))
+        });
+      case "tools/call": {
+        const name = typeof params["name"] === "string" ? params["name"] : "";
+        const rawArgs = params["arguments"];
+        const args = isObject(rawArgs) ? rawArgs : {};
+        const tool = opts.tools.find((t) => t.name === name);
+        if (!tool) {
+          return ok(id, {
+            content: [{ type: "text", text: "Unknown tool: " + name }],
+            isError: true
+          });
+        }
+        try {
+          const text = await tool.handler(args);
+          return ok(id, { content: [{ type: "text", text }] });
+        } catch (e) {
+          const emsg = e instanceof Error ? e.message : String(e);
+          return ok(id, {
+            content: [{ type: "text", text: "Tool error: " + emsg }],
+            isError: true
+          });
+        }
+      }
+      default:
+        return err(id, -32601, "Method not found: " + method);
+    }
+  } catch (e) {
+    const emsg = e instanceof Error ? e.message : String(e);
+    console.error(`[mcp] internal error handling ${method}: ${emsg}`);
+    return err(id, -32603, "Internal error: " + emsg);
+  }
+}
+function recoverId(line) {
+  const num = line.match(/"id"\s*:\s*(-?\d+(?:\.\d+)?)/);
+  if (num && num[1] !== void 0) {
+    const n = Number(num[1]);
+    if (Number.isFinite(n)) return n;
+  }
+  const str = line.match(/"id"\s*:\s*"((?:[^"\\]|\\.)*)"/);
+  if (str && str[1] !== void 0) return str[1];
+  return null;
+}
+function runMcpServer(opts) {
+  return new Promise((resolve4) => {
+    const stdin = process.stdin;
+    let buffer = "";
+    let chain = Promise.resolve();
+    const send = (response) => {
+      process.stdout.write(JSON.stringify(response) + "\n");
+    };
+    const processLine = (rawLine) => {
+      const line = rawLine.trim();
+      if (line === "") return;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        const id = recoverId(line);
+        if (id !== null) {
+          send(err(id, -32700, "Parse error"));
+        } else {
+          console.error("[mcp] parse error on line, no id to recover, skipping");
+        }
+        return;
+      }
+      if (Array.isArray(parsed)) {
+        chain = chain.then(async () => {
+          for (const entry of parsed) {
+            const response = await handleMcpMessage(entry, opts);
+            if (response !== null) send(response);
+          }
+        });
+        return;
+      }
+      chain = chain.then(async () => {
+        const response = await handleMcpMessage(parsed, opts);
+        if (response !== null) send(response);
+      });
+    };
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk2) => {
+      buffer += chunk2;
+      let nl = buffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        processLine(line);
+        nl = buffer.indexOf("\n");
+      }
+    });
+    stdin.on("end", () => {
+      if (buffer.length > 0) {
+        processLine(buffer);
+        buffer = "";
+      }
+      chain.then(() => resolve4()).catch(() => resolve4());
+    });
+    stdin.on("error", (e) => {
+      console.error(`[mcp] stdin error: ${e.message}`);
+      chain.then(() => resolve4()).catch(() => resolve4());
+    });
+    stdin.resume();
+  });
+}
+
+// src/mcp/tools.ts
+var MCP_SESSION = "__mcp__";
+function holtTools() {
+  return [
+    {
+      name: "recall",
+      description: "Search Holt's memory for this folder and return the most relevant remembered moments and distilled facts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "What to recall." },
+          k: { type: "number", description: "Max results to return (default 5)." }
+        },
+        required: ["query"]
+      },
+      handler: async (args) => {
+        try {
+          const query = String(args.query || "").trim();
+          if (!query) return "Provide a query to recall.";
+          const k = Number(args.k) || 5;
+          const hits = await recall(query, MCP_SESSION, k);
+          if (hits.length === 0) return "No relevant memory found.";
+          const lines = hits.map(
+            (h) => `${h.score.toFixed(2)}  (${h.turn.role})  ${h.turn.content.replace(/\s+/g, " ").trim()}`
+          );
+          return [`Recalled ${hits.length} relevant memory item(s):`, ...lines].join("\n");
+        } catch (err2) {
+          return `Could not recall right now: ${err2 instanceof Error ? err2.message : String(err2)}`;
+        }
+      }
+    },
+    {
+      name: "remember",
+      description: "Save a durable fact to Holt's memory for this folder.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "The fact to remember." }
+        },
+        required: ["content"]
+      },
+      handler: async (args) => {
+        try {
+          const content = String(args.content || "").trim();
+          if (!content) return "Nothing to remember: content was empty.";
+          const ok2 = await saveFact(content, MCP_SESSION);
+          return ok2 ? "Remembered." : "Already known (duplicate).";
+        } catch (err2) {
+          return `Could not remember right now: ${err2 instanceof Error ? err2.message : String(err2)}`;
+        }
+      }
+    },
+    {
+      name: "list_skills",
+      description: "List the skills installed for this folder (workspace and global).",
+      inputSchema: { type: "object", properties: {} },
+      handler: async () => {
+        try {
+          const skills = listSkills();
+          if (skills.length === 0) return "No skills installed.";
+          const lines = skills.map((s) => `${s.name}: ${s.description || "(no description)"}`);
+          return ["Installed skills:", ...lines].join("\n");
+        } catch (err2) {
+          return `Could not list skills right now: ${err2 instanceof Error ? err2.message : String(err2)}`;
+        }
+      }
+    },
+    {
+      name: "get_skill",
+      description: "Get the full instructions (body) of a skill by name.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "The skill name." }
+        },
+        required: ["name"]
+      },
+      handler: async (args) => {
+        try {
+          const name = String(args.name || "").trim();
+          if (!name) return "Provide a skill name.";
+          const loaded = loadSkill(name);
+          if (!loaded) return `No skill named "${name}".`;
+          return [`Skill: ${loaded.skill.name}`, "", loaded.body].join("\n");
+        } catch (err2) {
+          return `Could not load that skill right now: ${err2 instanceof Error ? err2.message : String(err2)}`;
+        }
+      }
+    },
+    {
+      name: "memory_stats",
+      description: "Show statistics for Holt's memory in this folder.",
+      inputSchema: { type: "object", properties: {} },
+      handler: async () => {
+        try {
+          const s = memStats();
+          return [
+            "Holt memory (this folder):",
+            `moments    ${s.turns}`,
+            `facts      ${s.facts}`,
+            `sessions   ${s.sessions}`,
+            `embedded   ${s.withEmbeddings} of ${s.turns}`,
+            `size       ${(s.bytes / 1024).toFixed(1)} KB`
+          ].join("\n");
+        } catch (err2) {
+          return `Could not read memory stats right now: ${err2 instanceof Error ? err2.message : String(err2)}`;
+        }
+      }
+    }
+  ];
+}
+
+// src/commands/mcp.ts
+function printSetup() {
+  const config = JSON.stringify(
+    { mcpServers: { holt: { command: "holt", args: ["mcp"] } } },
+    null,
+    2
+  );
+  const out = [
+    "Add Holt as an MCP server to your other tools.",
+    "",
+    "The server serves the memory of whatever folder it is launched in, and",
+    "auto-trusts that folder on first run.",
+    "",
+    "Claude Code:",
+    "  claude mcp add holt -- holt mcp",
+    "",
+    "Cursor / Codex (JSON config):",
+    config,
+    ""
+  ].join("\n");
+  console.log(out);
+}
+async function mcp(sub, rest = []) {
+  void rest;
+  if (sub === "setup") {
+    printSetup();
+    return;
+  }
+  try {
+    if (!isTrusted()) trustDir();
+    console.error("Holt MCP: serving memory for " + workspace());
+    await runMcpServer({ name: "holt", version: "0.7.0", tools: holtTools() });
+  } catch (err2) {
+    console.error("Holt MCP failed: " + (err2 instanceof Error ? err2.message : String(err2)));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/run.ts
+import { writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/runner.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function resolveActive2(cfg, id) {
+  if (BRAIN_IDS.includes(id)) {
+    const b = cfg.brains[id];
+    return { kind: "cli", id, label: b.label };
+  }
+  const api = findApiBrain(cfg, id);
+  if (api) return { kind: "api", id, label: `${id} (api: ${api.provider}/${api.model})`, brain: api };
+  return null;
+}
+async function runTask(task, opts = {}) {
+  try {
+    const cfg = loadConfig();
+    if (!cfg || !cfg.defaultBrain) {
+      return { ok: false, text: "No Holt setup in this folder. Run holt init.", brainLabel: "" };
+    }
+    const wantId = opts.brainId ?? cfg.defaultBrain;
+    const active = resolveActive2(cfg, wantId);
+    if (!active) {
+      return { ok: false, text: `Brain "${wantId}" is not configured. Run holt setting.`, brainLabel: "" };
+    }
+    if (active.kind === "cli" && !isInstalled(cfg.brains[active.id].command)) {
+      return {
+        ok: false,
+        text: `${active.label} (${cfg.brains[active.id].command}) is not on your PATH. Install it or run holt setting.`,
+        brainLabel: active.label
+      };
+    }
+    if (active.kind === "api" && !resolveApiKey(active.brain)) {
+      return {
+        ok: false,
+        text: `${active.label} has no API key. Run holt setting to add one.`,
+        brainLabel: active.label
+      };
+    }
+    const runSession = "run-" + newSessionId();
+    const recalled = opts.recall !== false ? await recall(task, runSession, 4) : [];
+    const block = skillsPromptBlock();
+    const base = renderPrompt([], task, recalled);
+    const prompt = block ? block + "\n\n" + base : base;
+    const res = active.kind === "cli" ? await runBrain(cfg.brains[active.id], prompt, opts.onChunk) : await runApiBrain(active.brain, prompt, opts.onChunk);
+    if (res.ok && opts.store !== false) {
+      const now = Date.now();
+      appendTurn({ id: randomUUID3().slice(0, 8), ts: now, session: runSession, role: "user", content: task, emb: await embed(task) ?? void 0 });
+      appendTurn({ id: randomUUID3().slice(0, 8), ts: now, session: runSession, role: "assistant", content: res.text, emb: await embed(res.text) ?? void 0 });
+    }
+    return { ok: res.ok, text: res.text, brainLabel: active.label };
+  } catch (e) {
+    return { ok: false, text: e.message, brainLabel: "" };
+  }
+}
+
+// src/commands/run.ts
+var USAGE = [
+  "  holt run <task> [options]",
+  "",
+  "  Run a single task against your default brain and stream the reply.",
+  "",
+  "  options:",
+  "    --brain <id>   use a specific brain (CLI or API brain id)",
+  "    --out <file>   also write the reply to a file (relative to this folder)",
+  "    --no-store     do not save this exchange to memory",
+  "    --no-recall    do not pull memory into the prompt",
+  "    --quiet        suppress streaming; still writes --out and sets exit code",
+  "",
+  '  example: holt run "summarize the open items in this folder"'
+].join("\n");
+function parseArgs2(args) {
+  const words2 = [];
+  let brainId;
+  let out;
+  let noStore = false;
+  let noRecall = false;
+  let quiet = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--brain") {
+      brainId = args[++i];
+      continue;
+    }
+    if (a === "--out") {
+      out = args[++i];
+      continue;
+    }
+    if (a === "--no-store") {
+      noStore = true;
+      continue;
+    }
+    if (a === "--no-recall") {
+      noRecall = true;
+      continue;
+    }
+    if (a === "--quiet") {
+      quiet = true;
+      continue;
+    }
+    words2.push(a);
+  }
+  return { task: words2.join(" ").trim(), brainId, out, noStore, noRecall, quiet };
+}
+async function run(args) {
+  const p = parseArgs2(args);
+  if (!p.task) {
+    console.log(USAGE);
+    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 schedule/run.\n");
+      process.exitCode = 1;
+      return;
+    }
+  }
+  let streamed = false;
+  const result = await runTask(p.task, {
+    brainId: p.brainId,
+    recall: !p.noRecall,
+    store: !p.noStore,
+    onChunk: p.quiet ? void 0 : (ch) => {
+      streamed = true;
+      process.stdout.write(ch);
+    }
+  });
+  if (!p.quiet && !streamed) {
+    process.stdout.write(result.text);
+  }
+  if (!p.quiet && (streamed || result.text) && !result.text.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+  if (!result.ok) {
+    process.stderr.write(c.red(result.text) + "\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (p.out) {
+    const target = resolve3(process.cwd(), p.out);
+    writeFileSync8(target, result.text, "utf8");
+    process.stderr.write(c.dim(`saved to ${target}`) + "\n");
+  }
+}
+
+// src/commands/schedule.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync8, rmSync as rmSync4, existsSync as existsSync8 } from "fs";
+import { dirname as dirname3 } from "path";
+
+// src/scheduler.ts
+import { homedir as homedir3 } from "os";
+import { join as join9 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7 } from "fs";
+import { randomUUID as randomUUID4 } from "crypto";
+import { spawnSync as spawnSync3 } from "child_process";
+function schedulesPath() {
+  return join9(GLOBAL_DIR, "schedules.json");
+}
+function logsDir() {
+  return join9(GLOBAL_DIR, "logs");
+}
+function logPath(id) {
+  return join9(logsDir(), `${id}.log`);
+}
+function plistPath(id) {
+  return join9(homedir3(), "Library", "LaunchAgents", `com.holt.${id}.plist`);
+}
+function loadJobs() {
+  try {
+    const raw = JSON.parse(readFileSync8(schedulesPath(), "utf8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+function saveJobs(jobs) {
+  mkdirSync7(GLOBAL_DIR, { recursive: true });
+  writeFileSync9(schedulesPath(), JSON.stringify(jobs, null, 2) + "\n", "utf8");
+}
+function addJob(job) {
+  const jobs = loadJobs();
+  jobs.push(job);
+  saveJobs(jobs);
+  return jobs;
+}
+function removeJob(id) {
+  const jobs = loadJobs().filter((j) => j.id !== id);
+  saveJobs(jobs);
+  return jobs;
+}
+function newJobId() {
+  return randomUUID4().slice(0, 8);
+}
+function parseWhen(when) {
+  const m = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(when.trim());
+  if (!m) {
+    throw new Error(
+      `Could not read time "${when}". Use 24h HH:MM for a daily run, e.g. 07:00 or 23:30.`
+    );
+  }
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  return { hour, minute };
+}
+function shQuote(s) {
+  return `'` + s.replace(/'/g, `'\\''`) + `'`;
+}
+function resolveHoltPath() {
+  try {
+    const finder = process.platform === "win32" ? "where" : "which";
+    const res = spawnSync3(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;
+    }
+  } catch {
+  }
+  return "holt";
+}
+function buildCommand(job, holtPath) {
+  const holt = shQuote(holtPath);
+  const ws = shQuote(job.workspace);
+  const log = shQuote(logPath(job.id));
+  let cmd = `cd ${ws} && ${holt} run ${shQuote(job.task)}`;
+  if (job.brain) cmd += ` --brain ${shQuote(job.brain)}`;
+  cmd += ` --quiet --out ${log}`;
+  if (job.notify) cmd += ` && ${holt} notify "$(cat ${log})"`;
+  return cmd;
+}
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildLaunchdPlist(job, holtPath) {
+  const { hour, minute } = parseWhen(job.when);
+  const command = buildCommand(job, holtPath);
+  const log = logPath(job.id);
+  const args = ["/bin/sh", "-lc", command];
+  const argXml = args.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.holt.${xmlEscape(job.id)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argXml}
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${hour}</integer>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+  </dict>
+  <key>RunAtLoad</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(log)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(log)}</string>
+</dict>
+</plist>
+`;
+}
+var CRON_MARKER = "holt:";
+function buildCronLine(job, holtPath) {
+  const { hour, minute } = parseWhen(job.when);
+  const command = buildCommand(job, holtPath);
+  return `${minute} ${hour} * * * ${command} # ${CRON_MARKER}${job.id}`;
+}
+function stripCronLines(crontab, id) {
+  const marker = `# ${CRON_MARKER}${id}`;
+  const kept = crontab.split("\n").filter((line) => !line.includes(marker));
+  return kept.join("\n").replace(/\n+$/, "\n");
+}
+function appendCronLine(crontab, line) {
+  const base = crontab.replace(/\s*$/, "");
+  return (base ? base + "\n" : "") + line + "\n";
+}
+function ensureLogsDir() {
+  mkdirSync7(logsDir(), { recursive: true });
+}
+
+// src/commands/schedule.ts
+function parseAdd(rest) {
+  const positional = [];
+  const opts = { notify: false };
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--notify") opts.notify = true;
+    else if (a === "--name") opts.name = rest[++i];
+    else if (a === "--brain") opts.brain = rest[++i];
+    else if (a && a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq > 2) {
+        const k = a.slice(2, eq);
+        const v = a.slice(eq + 1);
+        if (k === "name") opts.name = v;
+        else if (k === "brain") opts.brain = v;
+      }
+    } else if (a !== void 0) positional.push(a);
+  }
+  return { task: positional[0], when: positional[1], opts };
+}
+function installDarwin(job, holtPath) {
+  const path = plistPath(job.id);
+  mkdirSync8(dirname3(path), { recursive: true });
+  writeFileSync10(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."));
+  } 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 currentCrontab() {
+  const res = spawnSync4("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" });
+  return res.status === 0;
+}
+function installLinux(job, holtPath) {
+  const line = buildCronLine(job, holtPath);
+  const next = appendCronLine(currentCrontab(), line);
+  if (writeCrontab(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);
+  }
+}
+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'));
+    return;
+  }
+  try {
+    parseWhen(when);
+  } catch (e) {
+    console.log("\n  " + c.red(e.message) + "\n");
+    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 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'));
+    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 (existsSync8(path)) {
+    spawnSync4("launchctl", ["unload", path], { encoding: "utf8" });
+    try {
+      rmSync4(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"));
+    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.log(c.dim(`
+  No schedule with id ${id}. Nothing to remove.
+`));
+}
+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") {
+    listCmd();
+    return;
+  }
+  if (action !== "add" && action !== "remove" && action !== "rm") {
+    usage2();
+    return;
+  }
+  const { ask, close } = createReader();
+  if (!await ensureTrusted(ask)) {
+    close();
+    return;
+  }
+  close();
+  if (action === "add") await addCmd(rest);
+  else removeCmd(rest);
+}
+
+// src/telegram.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync11, existsSync as existsSync9, mkdirSync as mkdirSync9 } from "fs";
+import { join as join10 } from "path";
+var API_BASE = "https://api.telegram.org";
+var CHUNK_SIZE = 4e3;
+function telegramConfigPath() {
+  return join10(GLOBAL_DIR, "telegram.json");
+}
+function loadTelegramConfig() {
+  const path = telegramConfigPath();
+  if (!existsSync9(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync9(path, "utf8"));
+    if (typeof raw.token !== "string" || typeof raw.allowedChatId !== "number") return null;
+    return { token: raw.token, allowedChatId: raw.allowedChatId };
+  } catch {
+    return null;
+  }
+}
+function saveTelegramConfig(cfg) {
+  mkdirSync9(GLOBAL_DIR, { recursive: true });
+  writeFileSync11(telegramConfigPath(), JSON.stringify(cfg, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function buildSendRequest(token, chatId, text) {
+  return {
+    url: `${API_BASE}/bot${token}/sendMessage`,
+    body: JSON.stringify({ chat_id: chatId, text })
+  };
+}
+function buildGetUpdatesUrl(token, offset, timeoutSec) {
+  const params = new URLSearchParams({
+    offset: String(offset),
+    timeout: String(timeoutSec)
+  });
+  return `${API_BASE}/bot${token}/getUpdates?${params.toString()}`;
+}
+function chunk(text, size = CHUNK_SIZE) {
+  if (text.length === 0) return [""];
+  const out = [];
+  for (let i = 0; i < text.length; i += size) out.push(text.slice(i, i + size));
+  return out;
+}
+async function sendMessage(text, chatId) {
+  const cfg = loadTelegramConfig();
+  if (!cfg) {
+    process.stderr.write('[telegram] not configured; run "holt telegram setup"\n');
+    return false;
+  }
+  const target = chatId ?? cfg.allowedChatId;
+  const pieces = chunk(text || "No output.");
+  let allOk = true;
+  for (const piece of pieces) {
+    const { url, body } = buildSendRequest(cfg.token, target, piece);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body
+      });
+      if (!res.ok) {
+        allOk = false;
+        process.stderr.write(`[telegram] sendMessage HTTP ${res.status}
+`);
+      }
+    } catch (err2) {
+      allOk = false;
+      process.stderr.write(`[telegram] sendMessage failed: ${err2.message}
+`);
+    }
+  }
+  return allOk;
+}
+async function getUpdates(offset) {
+  const cfg = loadTelegramConfig();
+  if (!cfg) return [];
+  const timeoutSec = 30;
+  const url = buildGetUpdatesUrl(cfg.token, offset, timeoutSec);
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), (timeoutSec + 10) * 1e3);
+  try {
+    const res = await fetch(url, { signal: ac.signal });
+    if (!res.ok) {
+      process.stderr.write(`[telegram] getUpdates HTTP ${res.status}
+`);
+      return [];
+    }
+    const data = await res.json();
+    if (!data || data.ok !== true || !Array.isArray(data.result)) return [];
+    return data.result;
+  } catch (err2) {
+    process.stderr.write(`[telegram] getUpdates failed: ${err2.message}
+`);
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/commands/telegram.ts
+var HELP_TEXT = "Holt bot. Send me anything and I will run it through your selected brain and reply.\nCommands: /help this message.";
+async function telegram(sub, _rest = []) {
+  const action = (sub || "").toLowerCase();
+  if (action === "setup") {
+    await setup();
+    return;
+  }
+  await runBot();
+}
+async function setup() {
+  const { ask, close } = createReader();
+  try {
+    console.log("\n" + c.accent("Connect Holt to Telegram"));
+    console.log(c.dim("  1. Open Telegram and message @BotFather."));
+    console.log(c.dim("  2. Send /newbot, follow the prompts, and copy the bot token it gives you."));
+    console.log(c.dim("     A token looks like 123456789:AAF...  (keep it secret)."));
+    const token = (await ask("\n  Paste your bot token: ") ?? "").trim();
+    if (!token) {
+      console.log(c.red("  No token entered. Cancelled.\n"));
+      return;
+    }
+    console.log("\n" + c.dim("  Now I need your chat id (so I only answer you)."));
+    console.log(c.dim("  Option A: open your new bot in Telegram and send it any message,"));
+    console.log(c.dim("            then I will auto-detect the chat id."));
+    console.log(c.dim("  Option B: paste a numeric chat id yourself."));
+    const mode = (await ask("\n  Auto-detect from a message you just sent? [Y/n] ") ?? "").trim().toLowerCase();
+    let allowedChatId = null;
+    if (mode === "" || mode === "y" || mode === "yes") {
+      saveTelegramConfig({ token, allowedChatId: 0 });
+      console.log(c.dim("\n  Checking for a recent message..."));
+      const updates = await getUpdates(0);
+      allowedChatId = latestChatId(updates);
+      if (allowedChatId === null) {
+        console.log(c.red("  Did not find a recent message."));
+        const manual = (await ask("  Paste your numeric chat id instead: ") ?? "").trim();
+        allowedChatId = parseChatId(manual);
+      }
+    } else {
+      const manual = (await ask("  Paste your numeric chat id: ") ?? "").trim();
+      allowedChatId = parseChatId(manual);
+    }
+    if (allowedChatId === null) {
+      console.log(c.red('\n  No valid chat id. Nothing saved. Run "holt telegram setup" again.\n'));
+      return;
+    }
+    const cfg = { token, allowedChatId };
+    saveTelegramConfig(cfg);
+    console.log(
+      "\n" + c.green("  Saved.") + c.dim(` token ...${token.slice(-4)}  chat id ${allowedChatId}  (~/.holt/telegram.json, mode 600)`)
+    );
+    console.log(c.dim("  Start the bot with: holt telegram\n"));
+  } finally {
+    close();
+  }
+}
+function parseChatId(s) {
+  if (!/^-?\d+$/.test(s)) return null;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+function latestChatId(updates) {
+  for (let i = updates.length - 1; i >= 0; i--) {
+    const u = updates[i];
+    if (u && u.message) return u.message.chat.id;
+  }
+  return null;
+}
+async function runBot() {
+  const cfg = loadTelegramConfig();
+  if (!cfg) {
+    console.log(c.dim('\n  Telegram is not set up. Run "holt telegram setup" first.\n'));
+    return;
+  }
+  if (!isTrusted()) {
+    trustDir();
+    process.stderr.write(`[telegram] auto-trusted ${workspace()}
+`);
+  }
+  process.stderr.write("[telegram] bot started; long-polling for messages. Ctrl-C to stop.\n");
+  let offset = 0;
+  let busy = false;
+  while (true) {
+    let updates = [];
+    try {
+      updates = await getUpdates(offset);
+    } catch (err2) {
+      process.stderr.write(`[telegram] poll error: ${err2.message}
+`);
+      await sleep(1e3);
+      continue;
+    }
+    for (const u of updates) {
+      if (u && typeof u.update_id === "number") offset = Math.max(offset, u.update_id + 1);
+      try {
+        await handleUpdate(u, cfg, () => busy, (v) => {
+          busy = v;
+        });
+      } catch (err2) {
+        process.stderr.write(`[telegram] update ${u?.update_id} failed: ${err2.message}
+`);
+      }
+    }
+  }
+}
+async function handleUpdate(u, cfg, getBusy, setBusy) {
+  const msg = u?.message;
+  if (!msg || typeof msg.text !== "string") return;
+  if (msg.chat.id !== cfg.allowedChatId) {
+    process.stderr.write(`[telegram] ignoring message from chat ${msg.chat.id}
+`);
+    return;
+  }
+  const text = msg.text.trim();
+  if (text === "/start" || text === "/help") {
+    await sendMessage(HELP_TEXT, cfg.allowedChatId);
+    return;
+  }
+  if (getBusy()) {
+    await sendMessage("Still working on the previous message. Try again in a moment.", cfg.allowedChatId);
+    return;
+  }
+  setBusy(true);
+  try {
+    process.stderr.write(`[telegram] running task (${text.length} chars)
+`);
+    const result = await runTask(text);
+    await sendMessage(result.text || "No output.", cfg.allowedChatId);
+    process.stderr.write(`[telegram] replied (brain: ${result.brainLabel})
+`);
+  } catch (err2) {
+    process.stderr.write(`[telegram] runTask failed: ${err2.message}
+`);
+    await sendMessage("Sorry, that run failed. Check the Holt logs.", cfg.allowedChatId);
+  } finally {
+    setBusy(false);
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/commands/notify.ts
+import { readFileSync as readFileSync10 } from "fs";
+async function notify(args) {
+  const nonFlag = args.filter((a) => a !== "-" && !a.startsWith("--"));
+  const wantsStdin = args.includes("-") || !process.stdin.isTTY;
+  let message = "";
+  if (nonFlag.length > 0 && !args.includes("-")) {
+    message = nonFlag.join(" ").trim();
+  } else if (wantsStdin) {
+    message = readStdin().trim();
+  } else if (nonFlag.length > 0) {
+    message = nonFlag.join(" ").trim();
+  }
+  if (!message) {
+    process.stderr.write('Nothing to send. Pass a message or pipe text into "holt notify".\n');
+    process.exitCode = 1;
+    return;
+  }
+  const cfg = loadTelegramConfig();
+  if (!cfg) {
+    process.stderr.write('Telegram is not set up. Run "holt telegram setup".\n');
+    process.exitCode = 1;
+    return;
+  }
+  const ok2 = await sendMessage(message, cfg.allowedChatId);
+  if (ok2) {
+    process.stderr.write("Sent to Telegram.\n");
+  } else {
+    process.stderr.write("Failed to send to Telegram. Check the network and your bot token.\n");
+    process.exitCode = 1;
+  }
+}
+function readStdin() {
+  try {
+    return readFileSync10(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
 // src/cli.ts
-var VERSION = "0.6.0";
+var VERSION = "0.8.0";
 var BANNER = `
   \u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551  \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
@@ -2709,9 +3756,14 @@ Usage: holt <command>
 Commands:
   init            Trust this folder, choose and install brains, sign in, set defaults
   chat            Start a session. It remembers past sessions in this folder
+  run <task>      Run one task non-interactively: recall, brain executes, remember
+  schedule        Fire "holt run" on a timer: holt schedule [add | list | remove]
+  telegram        Chat with Holt from your phone: holt telegram [setup]
+  notify [msg]    Push a message to your phone over Telegram (stdin-friendly)
   memory          Inspect memory: holt memory [search <query> | embed | clear]
   graph           See your memory as an interactive knowledge graph in the browser
   skill           Manage skills: holt skill [list | show | create | add | remove]
+  mcp             Serve this folder's memory to Claude Code, Cursor, Codex (holt mcp setup)
   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
@@ -2761,6 +3813,21 @@ async function main() {
     case "graph":
       await graph(process.argv.slice(3));
       break;
+    case "mcp":
+      await mcp(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 "telegram":
+      await telegram(process.argv[3], process.argv.slice(4));
+      break;
+    case "notify":
+      await notify(process.argv.slice(3));
+      break;
     default:
       console.log(`
   Unknown command: "${cmd}"`);

package/package.json

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