@holt-os/holt 0.17.0 → 0.18.0

package/README.md

@@ -21,7 +21,7 @@
 - **Any brain, one assistant.** Bare `holt` launches a real interactive brain (Claude Code, Codex, or Gemini) branded as Holt, or you connect a direct API brain with your own key. Switch mid-conversation and keep the full context.
 - **Private memory you can see.** Per-folder semantic recall and distilled facts, an interactive knowledge graph (`holt graph`), and a self-maintaining wiki (`holt wiki`) over everything you tell it. Nothing leaves your machine.
 - **Ambient by default.** `holt hook` wires memory into Claude Code so it recalls and remembers with no manual step, and an MCP server exposes the same memory to Cursor and Codex.
-- **Runs your work.** Run a task once, on a schedule, or as a named routine, and reach it from your phone over Telegram.
+- **Runs your work.** Run a task once, on a schedule, or as a named routine, and reach it from your phone over Telegram. Real OS timers on macOS, Linux, and Windows.
 - **Useful on day one.** `/skill onboard` interviews you and fills memory in about fifteen minutes, `/skill audit` shows what is still missing, and `/skill level-up` turns one manual chore a week into something Holt does.
 - **Extensible, zero-infra.** Thirteen built-in skills plus a git-based community registry (`holt skill search`) in the portable `SKILL.md` format.
 - **Writes in your voice.** `holt write` drafts in a style Holt learns from you, with built-in anti-AI checks.
@@ -63,6 +63,14 @@ That is it. Bare `holt` sets the folder up the first time (trust, brain, memory
 
 Prefer to step through setup on its own first? `holt init` still does that, then `holt` starts the session.
 
+Then, in that first session, run:
+
+```
+/skill onboard
+```
+
+An empty Holt gives generic answers, which is the usual reason people install it and drift away. `onboard` is a fifteen minute interview that fills memory with who you are and what you are working on, and ends by doing one real piece of your work. Everything else gets better once it knows you.
+
 ## What bare `holt` does
 
 `holt` (with no command) is the front door: **your assistant, with memory of you.**
@@ -441,7 +449,7 @@ Options: `--brain <id>` pick a brain, `--out <file>` also write the reply to a f
 
 ### 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.
+Run a task automatically on a timer, using your OS scheduler (launchd on macOS, cron on Linux, Task Scheduler on Windows). 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
@@ -490,7 +498,7 @@ holt routine remove brief       # deletes the routine and its OS timer, if any
 
 Sources: give exactly one of `--skill <name>`, `--task "<prompt>"`, or `--template <t>`. A skill routine splices that skill's `SKILL.md` body into the prompt at run time; a task routine uses the prompt as-is.
 
-Scheduling: `--at HH:MM` (24h, daily) installs an OS timer through the same scheduler `holt schedule` uses (launchd on macOS, cron on Linux) whose command is `holt routine run <name> --quiet`. Omit `--at` for a manual, run-on-demand routine. Removing the routine removes its timer.
+Scheduling: `--at HH:MM` (24h, daily) installs an OS timer through the same scheduler `holt schedule` uses (launchd on macOS, cron on Linux, Task Scheduler on Windows) whose command is `holt routine run <name> --quiet`. Omit `--at` for a manual, run-on-demand routine. Removing the routine removes its timer.
 
 Output routing: by default the result prints to stdout. `--out <file>` also writes it to a file (relative to the routine's workspace); `--notify` pushes it to Telegram (guarded cleanly when Telegram is not set up). Both `--out` and `--notify` can also be passed to `holt routine run` for a single run. In `--quiet` mode (what the scheduler uses) stdout is suppressed but `--out` and `--notify` still fire.
 
@@ -622,7 +630,8 @@ Built in always-shippable phases toward a full-vision v1:
 4. **Knowledge graph**: see and navigate your own memory with `holt graph` *(shipped)*
 5. **Everywhere**: MCP server so other tools read Holt's memory, plus `holt run`, scheduling, and Telegram *(shipped)*
 6. **Knowledge wiki**: LLM-maintained, cross-linked, regenerable pages over your memory with `holt wiki` *(shipped)*
-7. **Next**: docs site, skill registry publishing, more channels
+7. **Onboarding**: a day-one interview that fills memory, plus the weekly audit and level-up ritual *(shipped)*
+8. **Next**: docs site, skill registry publishing, more channels
 
 ## Contributing
 

package/dist/cli.js

@@ -2515,23 +2515,37 @@ function buildCronLine(job, holtPath) {
   const command = buildCommand(job, holtPath);
   return `${minute} ${hour} * * * ${command} # ${CRON_MARKER}${job.id}`;
 }
-function buildWindowsTaskFields(job, holtPath) {
-  let args;
+function taskName(id) {
+  return `Holt ${id}`;
+}
+function cmdScriptPath(id) {
+  return join8(GLOBAL_DIR, "tasks", `${id}.cmd`);
+}
+function cmdQuote(s) {
+  return /[\s&()[\]{}^=;!'+,`~|<>"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+function buildWindowsScript(job, holtPath) {
+  const holt = cmdQuote(holtPath);
+  const lines = ["@echo off", `cd /d ${cmdQuote(job.workspace)}`];
   if (job.runArgs && job.runArgs.length > 0) {
-    args = [...job.runArgs, "--quiet"];
+    lines.push(`${holt} ${job.runArgs.map(cmdQuote).join(" ")} --quiet`);
   } else {
-    args = ["run", job.task];
-    if (job.brain) args.push("--brain", job.brain);
-    args.push("--quiet", "--out", logPath(job.id));
+    const log = cmdQuote(logPath(job.id));
+    let run2 = `${holt} run ${cmdQuote(job.task)}`;
+    if (job.brain) run2 += ` --brain ${cmdQuote(job.brain)}`;
+    run2 += ` --quiet --out ${log}`;
+    lines.push(run2);
+    if (job.notify) {
+      lines.push(`if errorlevel 1 exit /b 1`);
+      lines.push(`type ${log} | ${holt} notify`);
+    }
   }
-  const quoted = args.map((a) => /[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a);
-  return {
-    program: holtPath,
-    args: quoted.join(" "),
-    startIn: job.workspace,
-    when: job.when,
-    name: `Holt ${job.id}`
-  };
+  return lines.join("\r\n") + "\r\n";
+}
+function buildSchtasksArgs(job, scriptPath) {
+  const { hour, minute } = parseWhen(job.when);
+  const hhmm = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+  return ["/Create", "/F", "/SC", "DAILY", "/ST", hhmm, "/TN", taskName(job.id), "/TR", scriptPath];
 }
 function stripCronLines(crontab, id) {
   const marker = `# ${CRON_MARKER}${id}`;
@@ -7533,7 +7547,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.17.0";
+var VERSION = "0.18.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -7846,29 +7860,42 @@ async function addCmd(rest) {
   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 printManualInstall(job, holtPath);
+  installForPlatform(job, holtPath);
   console.log("");
 }
-function printManualInstall(job, holtPath) {
-  if (process.platform !== "win32") {
+function installForPlatform(job, holtPath) {
+  if (process.platform === "darwin") installDarwin(job, holtPath);
+  else if (process.platform === "linux") installLinux(job, holtPath);
+  else if (process.platform === "win32") installWindows(job, holtPath);
+  else {
     console.log(c.dim("\n  Your OS has no built-in installer. Install this entry yourself:"));
     console.log("  " + buildCronLine(job, holtPath));
-    return;
   }
-  const f = buildWindowsTaskFields(job, holtPath);
-  console.log(c.dim("\n  Saved, but not started: Holt cannot install timers on Windows yet."));
-  console.log(c.dim('  Open Task Scheduler, choose "Create Basic Task", and fill in:'));
-  console.log(`    Name        ${f.name}`);
-  console.log(`    Trigger     Daily at ${f.when}`);
-  console.log(`    Program     ${f.program}`);
-  console.log(`    Arguments   ${f.args}`);
-  console.log(`    Start in    ${f.startIn}`);
-  if (job.notify) {
+}
+function installWindows(job, holtPath) {
+  const script = cmdScriptPath(job.id);
+  mkdirSync15(dirname9(script), { recursive: true });
+  writeFileSync17(script, buildWindowsScript(job, holtPath), "utf8");
+  const res = spawnSync5("schtasks", buildSchtasksArgs(job, script), { encoding: "utf8" });
+  if (res.status === 0) {
+    console.log(c.green("  Registered with Task Scheduler."));
+  } else {
+    console.log(c.dim("  Wrote the task script, but schtasks did not confirm."));
+    console.log(c.dim("  Register it yourself with:"));
     console.log(
-      c.dim("\n  Note: --notify does not carry over to Task Scheduler. Read the log file instead.")
+      c.dim(`    schtasks /Create /F /SC DAILY /ST ${job.when} /TN "${taskName(job.id)}" /TR "${script}"`)
     );
+    const why = (res.stderr || "").trim() || (res.error ? res.error.message : "");
+    if (why) console.log(c.dim(`  (${why})`));
+  }
+  console.log(c.dim(`  task: ${taskName(job.id)}`));
+  console.log(c.dim(`  script: ${script}`));
+}
+function removeWindows(id) {
+  spawnSync5("schtasks", ["/Delete", "/F", "/TN", taskName(id)], { encoding: "utf8" });
+  try {
+    rmSync7(cmdScriptPath(id));
+  } catch {
   }
 }
 function listCmd2() {
@@ -7902,6 +7929,11 @@ function removeLinux(id) {
   const next = stripCronLines(body, id);
   spawnSync5("crontab", ["-"], { input: next, encoding: "utf8" });
 }
+function removeForPlatform(id) {
+  if (process.platform === "darwin") removeDarwin(id);
+  else if (process.platform === "linux") removeLinux(id);
+  else if (process.platform === "win32") removeWindows(id);
+}
 function removeCmd(rest) {
   const id = rest[0];
   if (!id) {
@@ -7912,8 +7944,7 @@ function removeCmd(rest) {
   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);
+  removeForPlatform(id);
   if (existed) console.log("\n" + c.green(`  Removed schedule ${id}.`) + "\n");
   else {
     console.error(c.dim(`
@@ -7950,9 +7981,8 @@ async function schedule(sub, rest = []) {
 }
 
 // src/commands/routine.ts
-import { spawnSync as spawnSync6 } from "child_process";
-import { writeFileSync as writeFileSync19, mkdirSync as mkdirSync17, rmSync as rmSync8, existsSync as existsSync19 } from "fs";
-import { dirname as dirname10, resolve as resolve7 } from "path";
+import { writeFileSync as writeFileSync19 } from "fs";
+import { resolve as resolve7 } from "path";
 
 // src/routines.ts
 import { readFileSync as readFileSync19, writeFileSync as writeFileSync18, mkdirSync as mkdirSync16 } from "fs";
@@ -8031,70 +8061,19 @@ function jobForRoutine(r) {
 function routineJobId(name) {
   return `routine-${sanitizeRoutineName(name)}`;
 }
-function installDarwin2(job, holtPath) {
-  const path = plistPath(job.id);
-  mkdirSync17(dirname10(path), { recursive: true });
-  writeFileSync19(path, buildLaunchdPlist(job, holtPath), "utf8");
-  const res = spawnSync6("launchctl", ["load", "-w", path], { encoding: "utf8" });
-  if (res.status === 0) {
-    console.log(c.green("  Loaded into launchd."));
-  } 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 = spawnSync6("crontab", ["-l"], { encoding: "utf8" });
-  return res.status === 0 && typeof res.stdout === "string" ? res.stdout : "";
-}
-function writeCrontab2(body) {
-  const res = spawnSync6("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 printManualInstall(job, holtPath);
-}
-function removeScheduleDarwin(id) {
-  const path = plistPath(id);
-  if (existsSync19(path)) {
-    spawnSync6("launchctl", ["unload", path], { encoding: "utf8" });
-    try {
-      rmSync8(path);
-    } catch {
-    }
-  }
-}
-function removeScheduleLinux(id) {
-  const body = currentCrontab2();
-  const next = stripCronLines(body, id);
-  writeCrontab2(next);
+  installForPlatform(job, holtPath);
 }
 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);
+  removeForPlatform(id);
 }
 function parseAdd2(rest) {
   const opts = { notify: false };
@@ -8449,8 +8428,8 @@ function readStdin3() {
 }
 
 // src/commands/doctor.ts
-import { spawn as spawn5, spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync20 } from "fs";
+import { spawn as spawn5, spawnSync as spawnSync6 } from "child_process";
+import { existsSync as existsSync19 } from "fs";
 
 // src/specs.ts
 import os from "os";
@@ -8612,7 +8591,7 @@ async function fixSemanticMemory(fixed) {
   }
   if (!tags.some((t) => t.startsWith(EMBED_MODEL))) {
     note(`The "${EMBED_MODEL}" model is missing. Downloading it (one-time, ~275 MB)...`);
-    const r = spawnSync7("ollama", ["pull", EMBED_MODEL], { stdio: "inherit" });
+    const r = spawnSync6("ollama", ["pull", EMBED_MODEL], { stdio: "inherit" });
     if (r.status !== 0) {
       warn(`Could not download ${EMBED_MODEL}. Check your internet connection and retry.`);
       return false;
@@ -8675,7 +8654,7 @@ async function doctor(args = []) {
   }
   if (embedOk) {
     good(`Ollama reachable and "${EMBED_MODEL}" is present. Memory recall is semantic, private, and local.`);
-    if (fix && existsSync20(wsHoltDir())) {
+    if (fix && existsSync19(wsHoltDir())) {
       const missing = loadTurns().filter((t) => !Array.isArray(t.emb)).length;
       if (missing > 0) {
         note(`${missing} memories in this folder lack embeddings. Upgrading them...`);
@@ -8794,12 +8773,12 @@ async function tour() {
 }
 
 // src/commands/reset.ts
-import { existsSync as existsSync21, rmSync as rmSync9 } from "fs";
+import { existsSync as existsSync20, rmSync as rmSync8 } from "fs";
 async function reset() {
   const { ask, close } = createReader();
   try {
     const dir = wsHoltDir();
-    if (!existsSync21(dir)) {
+    if (!existsSync20(dir)) {
       console.log(c.dim("\n  Nothing to reset: Holt has no settings or memory in this folder.\n"));
       return;
     }
@@ -8818,7 +8797,7 @@ async function reset() {
       console.log(c.dim("  Cancelled. Nothing was changed.\n"));
       return;
     }
-    rmSync9(dir, { recursive: true, force: true });
+    rmSync8(dir, { recursive: true, force: true });
     console.log(c.green("\n  Done. This folder is a clean slate.") + c.dim('  Run "holt" to set it up again.\n'));
   } finally {
     close();
@@ -8826,7 +8805,7 @@ async function reset() {
 }
 
 // src/commands/update.ts
-import { spawnSync as spawnSync8 } from "child_process";
+import { spawnSync as spawnSync7 } from "child_process";
 import { realpathSync as realpathSync4 } from "fs";
 async function latestVersion() {
   try {
@@ -8868,7 +8847,7 @@ async function update() {
         console.log(c.dim("  Later, then. The command is: brew upgrade holt\n"));
         return;
       }
-      const r2 = spawnSync8("brew", ["upgrade", "holt"], { stdio: "inherit" });
+      const r2 = spawnSync7("brew", ["upgrade", "holt"], { stdio: "inherit" });
       if (r2.status === 0) console.log(c.green(`
   Updated to ${latest}.`) + "\n");
       else console.log(c.dim("\n  Homebrew reported a problem above. You can retry with: brew upgrade holt\n"));
@@ -8878,7 +8857,7 @@ async function update() {
       console.log(c.dim("  Later, then. The command is: npm install -g @holt-os/holt\n"));
       return;
     }
-    const r = spawnSync8("npm", ["install", "-g", "@holt-os/holt"], { stdio: "inherit" });
+    const r = spawnSync7("npm", ["install", "-g", "@holt-os/holt"], { stdio: "inherit" });
     if (r.status === 0) {
       console.log(c.green(`
   Updated to ${latest}.`) + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holt-os/holt",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "An open-source personal agent OS: any LLM, private memory you can see and walk.",
   "type": "module",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "build": "tsup src/cli.ts --format esm --clean",
     "start": "node dist/cli.js",
     "typecheck": "tsc --noEmit",
-    "test": "tsx scripts/specs.test.ts && tsx scripts/skillcompiler.test.ts",
+    "test": "tsx scripts/specs.test.ts && tsx scripts/skillcompiler.test.ts && tsx scripts/scheduler.test.ts",
     "release": "bash scripts/release.sh"
   },
   "devDependencies": {

package/skills/audit/SKILL.md

@@ -86,9 +86,9 @@ an essay.
 - **Hand-edited facts.** Facts added by editing `facts.md` directly are never
   embedded, so they never come back through recall. They must be re-added with
   `holt memory add`.
-- **Windows and timers.** On Windows, `holt schedule` and a routine's `--at`
-  time do not install anything. Anything on rung four there has to run another
-  way, so check the platform before calling rung four solid.
+- **Timers need the machine awake.** A scheduled job fires only if the computer
+  is on at that time; a missed run is skipped, not caught up. If rung four looks
+  solid but the log file is empty, check that first.
 - **Automation above an empty memory.** If Run looks solid while Know is thin,
   say so bluntly. That setup produces confident wrong output on a timer, and it
   is the most expensive failure on this list.