@onebrain-ai/cli 2.2.5 → 2.3.1

package/README.md

@@ -23,7 +23,7 @@
 </p>
 
 <p align="center">
-  <strong>Your personal AI OS</strong> — persistent memory, 25+ skills, and a full local stack<br>
+  <strong>Your personal AI OS</strong> — persistent memory, 29+ skills, and a full local stack<br>
   (Claude Code + Obsidian + tmux + Telegram), entirely on your own machine.
 </p>
 
@@ -35,7 +35,7 @@
 
 ## What is OneBrain?
 
-OneBrain is an AI operating system layer built on top of Obsidian. It gives your AI agent persistent memory, a structured knowledge vault, and 25+ pre-built skills — so every session picks up exactly where the last one left off.
+OneBrain is an AI operating system layer built on top of Obsidian. It gives your AI agent persistent memory, a structured knowledge vault, and 29+ pre-built skills — so every session picks up exactly where the last one left off.
 
 Unlike chat-based AI tools, OneBrain lives in plain Markdown files you own forever. No cloud sync required. No proprietary format. Just your agent, your vault, your data.
 
@@ -70,7 +70,7 @@ OneBrain doesn't compete with Claude Code, Gemini CLI, or any other AI harness
 
 | # | Layer | Role | What lives here |
 |---|---|---|---|
-| 01 | **OneBrain** | OS layer (plugin + CLI) | 25+ skills · lifecycle hooks · vault sync · indexing · checkpoints · harness routing |
+| 01 | **OneBrain** | OS layer (plugin + CLI) | 29+ skills · lifecycle hooks · vault sync · indexing · checkpoints · harness routing |
 | 02 | **Harness** | Agentic runtime | Bring your own — Claude Code · Gemini CLI · Codex · Qwen · ... |
 | 03 | **LLM** | Intelligence source | Local (mlx, ollama) · cloud (claude, gemini, gpt) · raw API |
 | 04 | **Obsidian Vault** | Source of truth | Plain Markdown — notes, memory, decisions, knowledge graph |
@@ -84,7 +84,7 @@ A great harness already knows how to talk to an LLM, edit files, and run shell c
 | | What OneBrain adds | Why it matters |
 |---|---|---|
 | 🧠 | **Memory** — Identity, preferences, decisions, project state — promoted across four tiers as it earns trust | The harness alone starts every session from zero. OneBrain doesn't. |
-| ⚡ | **Skills** — 25+ vault-aware verbs (`/braindump`, `/research`, `/distill`, `/learn`, `/wrapup`, …) | Pre-built workflows the harness would otherwise need you to script every time. |
+| ⚡ | **Skills** — 29+ vault-aware verbs (`/braindump`, `/research`, `/distill`, `/learn`, `/wrapup`, …) | Pre-built workflows the harness would otherwise need you to script every time. |
 | 🎯 | **Calibration** — Every correction, every preference, every learned habit tunes the agent to *you* | The longer you use it, the sharper it gets — your vault is the training data. |
 | 🔀 | **Continuity** — Context lives in the vault, not the harness | Switch from Claude Code to Gemini CLI to Codex. Same memory. Same skills. Same agent. |
 
@@ -210,7 +210,7 @@ OneBrain doesn't just store markdown. Every feature exists to make you and the a
 |---|---|---|
 | 🧠 | **Persistent Memory** | Remembers your name, goals, preferences, and decisions across every session |
 | 🖥️ | **Personal AI OS** | Full local stack: Claude Code + Obsidian + tmux + Telegram — no cloud infra needed |
-| ⚡ | **25+ Skills** | Braindump, research, consolidate, bookmark, import files, daily briefing, and more |
+| ⚡ | **29+ Skills** | Braindump, research, consolidate, bookmark, import files, daily briefing, and more |
 | 📂 | **Vault-native Markdown** | Plain Markdown, no lock-in. Your data stays yours forever |
 | 🔀 | **Multi-Harness OS** | Switch between Claude Code, Gemini CLI, Codex, Qwen, or BYO LLM — context never breaks. [See architecture ↑](#the-harness-os-architecture) |
 | 🔌 | **Zero Config** | Clone, open in Obsidian, run `/onboarding`. Ready in under 2 minutes |
@@ -340,7 +340,7 @@ Same vault. Same skills. Same memory. The LLM swaps; OneBrain doesn't notice.
 
 <a id="commands"></a>
 
-## 📋 25+ Commands
+## 📋 29+ Commands
 
 Skills are organized by workflow phase. **Gemini CLI users:** prepend the `onebrain:` namespace, e.g. `/onebrain:braindump` instead of `/braindump` (avoids collisions with Gemini built-in commands like `/help` and `/tasks`).
 
@@ -389,6 +389,10 @@ Skills are organized by workflow phase. **Gemini CLI users:** prepend the `onebr
 | `/qmd` | Set up fast vault search index — enables semantic search across all notes |
 | `/help` | List all available commands with descriptions |
 | `/wrapup` | Wrap up session — merges any auto-checkpoints and saves full summary to session log |
+| `/schedule-add` | Interactive wizard for adding a recurring scheduled skill |
+| `/schedule-once` | One-shot wizard: schedule a skill to run once at a specific datetime |
+| `/schedule-list` | Show all scheduled entries |
+| `/schedule-remove` | Remove a scheduled entry |
 
 <details>
 <summary><strong>📁 Vault Structure</strong></summary>
@@ -483,6 +487,78 @@ Multi-device sync and hosted agent runtimes. Your unified intelligence travels w
 
 ---
 
+## Scheduling
+
+OneBrain skills can run automatically on a schedule via your OS scheduler (macOS launchd; Linux + Windows coming soon). Configure in `vault.yml`:
+
+```yaml
+schedule:
+  - cron: "0 9 * * *"      # daily 9am
+    skill: /daily
+  - cron: "0 18 * * 5"     # Friday 6pm
+    skill: /weekly
+  - cron: "0 12 * * 0"     # Sunday noon
+    skill: /recap
+```
+
+For a one-shot reminder, use `at:` instead of `cron:`:
+
+```yaml
+schedule:
+  - at: "2026-05-13 14:30"
+    skill: /reminder
+```
+
+After firing, the launchd plist auto-uninstalls itself.
+
+Register schedules:
+
+```bash
+onebrain register-schedule
+```
+
+Or use the interactive wizards from inside your vault:
+
+```
+/schedule-add      # recurring schedule wizard
+/schedule-once     # one-shot wizard
+/schedule-list     # show all scheduled entries
+/schedule-remove   # remove an entry
+```
+
+Output goes to `[logs_folder]/scheduler/YYYY/MM/YYYY-MM-DD-{skill}.md` as readable markdown.
+
+### Command mode (CLI binaries, hook-style)
+
+For CLI maintenance tasks that aren't OneBrain skills, use the `command + args[]` shape:
+
+```yaml
+schedule:
+  - cron: "0 3 * * 0"
+    command: onebrain
+    args: [qmd-reindex]
+  - cron: "0 5 * * *"
+    command: rsync
+    args: [-av, /vault, /backup]
+```
+
+This matches the same shape Claude Code uses for `hooks` in `settings.json` — direct binary invocation with positional argv. No wrapper skill needed.
+
+CLI flags:
+
+| Flag | Purpose |
+|---|---|
+| `--dry-run` | Print plist without writing |
+| `--remove` | Remove all OneBrain schedules |
+| `--refresh` | Re-emit plists after vault move |
+| `--resume <skill>` | Resume an auto-paused skill |
+| `--status` | Show registered schedules + run history |
+| `--test <skill>` | Manually invoke a scheduled skill once |
+
+**Note:** OneBrain's scheduler is distinct from Claude Code's `/loop` (in-session) and `/schedule` (cloud-hosted). OneBrain runs locally and writes to your vault.
+
+---
+
 <details>
 <summary><strong>⚙️ Prerequisites & Detailed Setup</strong></summary>
 <br>

package/dist/onebrain

@@ -9560,7 +9560,7 @@ var init_lib = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@onebrain-ai/cli",
-    version: "2.2.5",
+    version: "2.3.1",
     description: "CLI for OneBrain \u2014 personal AI OS for Obsidian with persistent memory, 24+ skills, and Claude Code integration",
     keywords: [
       "onebrain",
@@ -11021,8 +11021,8 @@ var init_vault_sync = __esm(() => {
 });
 
 // src/index.ts
-import { existsSync } from "fs";
-import { dirname as dirname4, join as join11 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname4, join as join12 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -11048,7 +11048,7 @@ var import_picocolors5 = __toESM(require_picocolors(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
 function resolveBinaryVersion() {
   if (true)
-    return "2.2.5";
+    return "2.3.1";
   try {
     const pkg = require_package();
     return pkg.version ?? "dev";
@@ -13121,8 +13121,390 @@ async function sessionInitCommand(vaultRoot) {
 // src/index.ts
 init_vault_sync();
 
-// src/commands/update.ts
+// src/commands/register-schedule.ts
 var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_yaml7 = __toESM(require_dist(), 1);
+import { existsSync } from "fs";
+import { readFile as readFile6, unlink as unlink4, writeFile as writeFile6 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join11 } from "path";
+
+// src/lib/scheduler/cron-parse.ts
+var CRON_FIELD_RE = /^(\*|\d+)$/;
+function validateCron(cron) {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5) {
+    return { valid: false, reason: `expected 5 fields, got ${fields.length}` };
+  }
+  for (const f2 of fields) {
+    if (!CRON_FIELD_RE.test(f2)) {
+      return { valid: false, reason: `invalid field syntax: "${f2}"` };
+    }
+  }
+  return { valid: true };
+}
+function cronFieldsToLaunchd(cron) {
+  const [m3, h, dom, mon, dow] = cron.trim().split(/\s+/);
+  const out2 = {};
+  if (m3 !== "*")
+    out2.Minute = Number.parseInt(m3, 10);
+  if (h !== "*")
+    out2.Hour = Number.parseInt(h, 10);
+  if (dom !== "*")
+    out2.Day = Number.parseInt(dom, 10);
+  if (mon !== "*")
+    out2.Month = Number.parseInt(mon, 10);
+  if (dow !== "*")
+    out2.Weekday = Number.parseInt(dow, 10);
+  return out2;
+}
+var AT_RE = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})$/;
+function validateAt(at) {
+  const m3 = at.match(AT_RE);
+  if (!m3) {
+    return { valid: false, reason: `expected 'YYYY-MM-DD HH:MM', got "${at}"` };
+  }
+  const [, , mo, d, h, mi] = m3;
+  const month = Number.parseInt(mo, 10);
+  const day = Number.parseInt(d, 10);
+  const hour = Number.parseInt(h, 10);
+  const minute = Number.parseInt(mi, 10);
+  if (month < 1 || month > 12)
+    return { valid: false, reason: `month out of range: ${month}` };
+  if (day < 1 || day > 31)
+    return { valid: false, reason: `day out of range: ${day}` };
+  if (hour > 23)
+    return { valid: false, reason: `hour out of range: ${hour}` };
+  if (minute > 59)
+    return { valid: false, reason: `minute out of range: ${minute}` };
+  return { valid: true };
+}
+function atToLaunchd(at) {
+  const m3 = at.match(AT_RE);
+  if (!m3)
+    throw new Error(`atToLaunchd called with unvalidated input: ${at}`);
+  const [, y2, mo, d, h, mi] = m3;
+  return {
+    Year: Number.parseInt(y2, 10),
+    Month: Number.parseInt(mo, 10),
+    Day: Number.parseInt(d, 10),
+    Hour: Number.parseInt(h, 10),
+    Minute: Number.parseInt(mi, 10)
+  };
+}
+
+// src/lib/scheduler/entry.ts
+function isOneShot(entry) {
+  return entry.at !== undefined;
+}
+function isSkillMode(entry) {
+  return entry.skill !== undefined;
+}
+function isCommandMode(entry) {
+  return entry.command !== undefined;
+}
+function validateEntry(entry) {
+  const hasCron = entry.cron !== undefined;
+  const hasAt = entry.at !== undefined;
+  if (hasCron === hasAt) {
+    return { valid: false, reason: "entry must have exactly one of `cron` or `at`" };
+  }
+  const hasSkill = entry.skill !== undefined;
+  const hasCommand = entry.command !== undefined;
+  if (hasSkill === hasCommand) {
+    return { valid: false, reason: "entry must have exactly one of `skill` or `command`" };
+  }
+  if (hasSkill && !entry.skill) {
+    return { valid: false, reason: "entry.skill must not be empty" };
+  }
+  if (hasCommand && !entry.command) {
+    return { valid: false, reason: "entry.command must not be empty" };
+  }
+  if (entry.args !== undefined) {
+    const isArray = Array.isArray(entry.args);
+    if (hasSkill && isArray) {
+      return {
+        valid: false,
+        reason: "skill-mode entries require `args` as a map (Record<string, string>), not an array"
+      };
+    }
+    if (hasCommand && !isArray) {
+      return {
+        valid: false,
+        reason: "command-mode entries require `args` as a string array, not a map"
+      };
+    }
+    if (isArray) {
+      for (const v2 of entry.args) {
+        if (typeof v2 !== "string") {
+          return { valid: false, reason: "command-mode `args` must contain only strings" };
+        }
+      }
+    }
+  }
+  return { valid: true };
+}
+
+// src/lib/scheduler/launchd.ts
+var xmlEscape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function labelForEntry(entry) {
+  const raw = isCommandMode(entry) ? entry.command : (entry.skill ?? "").replace(/^\//, "");
+  return raw.replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function generatePlist(entry, ctx) {
+  const labelSafe = labelForEntry(entry);
+  const label = `com.onebrain.${labelSafe}`;
+  const calendar = isOneShot(entry) ? atToLaunchd(entry.at) : cronFieldsToLaunchd(entry.cron);
+  const calendarXml = Object.entries(calendar).map(([k2, v2]) => `        <key>${k2}</key>
+        <integer>${v2}</integer>`).join(`
+`);
+  let programArgumentsBlock;
+  if (isOneShot(entry)) {
+    if (isCommandMode(entry)) {
+      const argv = entry.args ?? [];
+      const quotedArgs = argv.map((a2) => `"${a2}"`).join(" ");
+      const innerCommand = `"${entry.command}"${quotedArgs ? ` ${quotedArgs}` : ""}`;
+      const plistFilePath = `${ctx.homedir}/Library/LaunchAgents/${label}.plist`;
+      const shellLine = xmlEscape(`${innerCommand}; launchctl bootout gui/${ctx.uid}/${label}; rm -f "${plistFilePath}"`);
+      programArgumentsBlock = `        <string>/bin/sh</string>
+        <string>-c</string>
+        <string>${shellLine}</string>`;
+    } else {
+      const plistFilePath = plistPath(entry.skill ?? "", ctx.homedir);
+      const argsFlags = entry.args ? ` ${Object.entries(entry.args).map(([k2, v2]) => `--${k2}="${v2}"`).join(" ")}` : "";
+      const shellLine = xmlEscape(`"${ctx.skillCliPath}" --vault="${ctx.vaultPath}" --skill="${entry.skill}" --headless${argsFlags}; launchctl bootout gui/${ctx.uid}/${label}; rm -f "${plistFilePath}"`);
+      programArgumentsBlock = `        <string>/bin/sh</string>
+        <string>-c</string>
+        <string>${shellLine}</string>`;
+    }
+  } else if (isCommandMode(entry)) {
+    const argv = entry.args ?? [];
+    programArgumentsBlock = [
+      `        <string>${xmlEscape(entry.command)}</string>`,
+      ...argv.map((a2) => `        <string>${xmlEscape(a2)}</string>`)
+    ].join(`
+`);
+  } else {
+    const argsBlock = entry.args ? `
+${Object.entries(entry.args).map(([k2, v2]) => `        <string>--${xmlEscape(k2)}=${xmlEscape(v2)}</string>`).join(`
+`)}` : "";
+    programArgumentsBlock = `        <string>${xmlEscape(ctx.skillCliPath)}</string>
+        <string>--vault</string>
+        <string>${xmlEscape(ctx.vaultPath)}</string>
+        <string>--skill</string>
+        <string>${xmlEscape(entry.skill ?? "")}</string>
+        <string>--headless</string>${argsBlock}`;
+  }
+  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>${xmlEscape(label)}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgumentsBlock}
+    </array>
+    <key>StartCalendarInterval</key>
+    <dict>
+${calendarXml}
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${xmlEscape(ctx.logBasePath)}/onebrain-${labelSafe}.stdout</string>
+    <key>StandardErrorPath</key>
+    <string>${xmlEscape(ctx.logBasePath)}/onebrain-${labelSafe}.stderr</string>
+    <key>RunAtLoad</key>
+    <false/>
+</dict>
+</plist>`;
+}
+function plistPath(skillOrLabel, homedir4) {
+  const labelSafe = skillOrLabel.startsWith("/") ? skillOrLabel.replace(/^\//, "").replace(/[^a-zA-Z0-9-]/g, "-") : skillOrLabel.replace(/[^a-zA-Z0-9-]/g, "-");
+  return `${homedir4}/Library/LaunchAgents/com.onebrain.${labelSafe}.plist`;
+}
+
+// src/commands/register-schedule.ts
+async function registerSchedule(opts) {
+  if (opts.remove)
+    return await removeAll(opts.vault);
+  if (opts.status)
+    return await printStatus(opts.vault);
+  if (opts.test)
+    return await testRun(opts.vault, opts.test);
+  if (opts.resume)
+    return await resumeSkill(opts.vault, opts.resume);
+  if (opts.refresh) {
+    console.log(import_picocolors8.default.dim("(--refresh: re-emitting plists with current vault path)"));
+  }
+  const config = await readVaultConfig(opts.vault);
+  const entries = config.schedule ?? [];
+  if (entries.length === 0) {
+    console.log(import_picocolors8.default.yellow("No schedule entries in vault.yml. Nothing to register."));
+    return;
+  }
+  for (const entry of entries) {
+    const ve = validateEntry(entry);
+    if (!ve.valid)
+      throw new Error(`Invalid schedule entry: ${ve.reason}`);
+    if (isOneShot(entry)) {
+      const va = validateAt(entry.at);
+      if (!va.valid)
+        throw new Error(`Invalid at "${entry.at}": ${va.reason}`);
+      sanitizeArgsForOneShot(entry);
+    } else if (entry.cron !== undefined) {
+      const vc = validateCron(entry.cron);
+      if (!vc.valid)
+        throw new Error(`Invalid cron "${entry.cron}": ${vc.reason}`);
+    }
+    if (isSkillMode(entry)) {
+      await validateSchedulable(opts.vault, entry);
+    }
+  }
+  const skillCliPath = process.argv[1] ?? "onebrain";
+  const ctx = {
+    vaultPath: opts.vault,
+    skillCliPath,
+    logBasePath: join11(opts.vault, "07-logs/scheduler"),
+    uid: process.getuid?.() ?? 501,
+    homedir: homedir4()
+  };
+  const seen = new Map;
+  for (const entry of entries) {
+    const target = plistPath(labelForEntry(entry), ctx.homedir);
+    if (seen.has(target)) {
+      const existing = seen.get(target);
+      if (existing) {
+        const existingLabel = isCommandMode(existing) ? `command:${existing.command}` : `skill:${existing.skill}`;
+        const newLabel = isCommandMode(entry) ? `command:${entry.command}` : `skill:${entry.skill}`;
+        throw new Error(`Conflict: ${newLabel} and ${existingLabel} normalize to the same plist path ${target}`);
+      }
+    }
+    seen.set(target, entry);
+  }
+  for (const entry of entries) {
+    const plistContent = generatePlist(entry, ctx);
+    const targetPath = plistPath(labelForEntry(entry), ctx.homedir);
+    if (opts.dryRun) {
+      console.log(import_picocolors8.default.cyan(`---  ${targetPath}  ---`));
+      console.log(plistContent);
+      continue;
+    }
+    await writeFile6(targetPath, plistContent, "utf8");
+    console.log(import_picocolors8.default.green(`\u2713 Wrote ${targetPath}`));
+  }
+  console.log(import_picocolors8.default.green(`
+Registered ${entries.length} schedule entries.`));
+  console.log(import_picocolors8.default.dim("Use launchctl to load (or restart launchd):"));
+  for (const entry of entries) {
+    const target = plistPath(labelForEntry(entry), ctx.homedir);
+    console.log(import_picocolors8.default.dim(`  launchctl load ${target}`));
+  }
+}
+async function readVaultConfig(vault) {
+  const yamlPath = join11(vault, "vault.yml");
+  if (!existsSync(yamlPath))
+    return {};
+  const raw = await readFile6(yamlPath, "utf8");
+  return import_yaml7.parse(raw) ?? {};
+}
+function sanitizeArgsForOneShot(entry) {
+  const values = isCommandMode(entry) ? entry.args ?? [] : Object.values(entry.args ?? {});
+  for (const v2 of values) {
+    if (/["$`\\]/.test(v2)) {
+      throw new Error(`Arg value must not contain shell-special chars (", $, \`, \\): ${v2}`);
+    }
+  }
+}
+async function validateSchedulable(vault, entry) {
+  if (!entry.skill) {
+    throw new Error("validateSchedulable invoked on non-skill entry \u2014 caller bug");
+  }
+  const skillName = entry.skill.replace(/^\//, "");
+  const skillPath = join11(vault, ".claude/plugins/onebrain/skills", skillName, "SKILL.md");
+  if (!existsSync(skillPath)) {
+    throw new Error(`Skill ${entry.skill} not found at ${skillPath}`);
+  }
+  const raw = await readFile6(skillPath, "utf8");
+  const match = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    throw new Error(`Skill ${entry.skill} has no YAML frontmatter`);
+  }
+  const fm = import_yaml7.parse(match[1]);
+  if (fm.schedulable === false) {
+    throw new Error(`Skill ${entry.skill} requires user input \u2014 cannot schedule`);
+  }
+  if (fm.schedulable_with_args) {
+    const required = fm.required_args ?? [];
+    const provided = Object.keys(entry.args ?? {});
+    const missing = required.filter((r2) => !provided.includes(r2));
+    if (missing.length > 0) {
+      throw new Error(`Skill ${entry.skill} requires args: [${missing.join(", ")}]`);
+    }
+  } else if (!fm.schedulable) {
+    throw new Error(`Skill ${entry.skill} does not declare schedulable: true in frontmatter`);
+  }
+  if (entry.args) {
+    for (const [k2, v2] of Object.entries(entry.args)) {
+      if (/["$`\\]/.test(v2)) {
+        throw new Error(`Arg "${k2}" value must not contain shell-special chars (", $, \`, \\): ${v2}`);
+      }
+    }
+  }
+}
+async function removeAll(vault) {
+  const config = await readVaultConfig(vault);
+  const entries = config.schedule ?? [];
+  for (const entry of entries) {
+    const target = plistPath(labelForEntry(entry), homedir4());
+    if (existsSync(target)) {
+      await unlink4(target);
+      console.log(import_picocolors8.default.green(`\u2713 Removed ${target}`));
+    }
+  }
+}
+async function printStatus(vault) {
+  const config = await readVaultConfig(vault);
+  const entries = config.schedule ?? [];
+  console.log(import_picocolors8.default.cyan(`Registered schedules: ${entries.length}`));
+  for (const entry of entries) {
+    const target = plistPath(labelForEntry(entry), homedir4());
+    const installed = existsSync(target) ? "\u2713" : "\u2717";
+    const when = entry.at ?? entry.cron ?? "?";
+    const tag = entry.at ? import_picocolors8.default.magenta("[once]") : import_picocolors8.default.dim("[cron]");
+    let targetLabel;
+    if (isCommandMode(entry)) {
+      const argv = entry.args ?? [];
+      const argStr = argv.length ? ` ${argv.join(" ")}` : "";
+      targetLabel = `${import_picocolors8.default.yellow("cmd:")} ${entry.command}${argStr}`;
+    } else {
+      const argsMap = entry.args ?? {};
+      const argStr = Object.keys(argsMap).length ? ` (${Object.entries(argsMap).map(([k2, v2]) => `${k2}=${v2}`).join(", ")})` : "";
+      targetLabel = `${import_picocolors8.default.green("skill:")} ${entry.skill}${argStr}`;
+    }
+    console.log(`  ${installed} ${tag} ${when}  ${targetLabel}`);
+  }
+}
+async function testRun(vault, skill) {
+  console.log(import_picocolors8.default.cyan(`Testing scheduled invocation of ${skill}...`));
+  console.log(import_picocolors8.default.dim("(Spawns headless Claude Code. Output streams here.)"));
+  const { spawn } = await import("child_process");
+  const child = spawn("claude", ["--vault", vault, "--skill", skill, "--headless"], {
+    stdio: "inherit"
+  });
+  await new Promise((resolve) => child.on("exit", resolve));
+}
+async function resumeSkill(vault, skill) {
+  const marker = join11(vault, "07-logs/scheduler/.paused", `${skill.replace(/^\//, "")}.txt`);
+  if (existsSync(marker)) {
+    await unlink4(marker);
+    console.log(import_picocolors8.default.green(`\u2713 Resumed ${skill}`));
+  } else {
+    console.log(import_picocolors8.default.yellow(`${skill} is not paused.`));
+  }
+}
+
+// src/commands/update.ts
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 init_cli_ui();
 var GITHUB_REPO = "https://api.github.com/repos/onebrain-ai/onebrain";
 var GITHUB_RELEASES_URL = `${GITHUB_REPO}/releases/latest`;
@@ -13217,7 +13599,7 @@ async function runUpdate(opts = {}) {
   const sp1 = createStep("\uD83D\uDD0D", "Local version");
   const { version: currentVersion, publishedAt: localPublishedAt } = await currentVersionFn();
   result.currentVersion = currentVersion;
-  const localVersionLabel = localPublishedAt ? `${import_picocolors8.default.dim(currentVersion)}  ${import_picocolors8.default.dim("\xB7")}  ${import_picocolors8.default.dim(formatReleaseDate(localPublishedAt))}` : import_picocolors8.default.dim(currentVersion);
+  const localVersionLabel = localPublishedAt ? `${import_picocolors9.default.dim(currentVersion)}  ${import_picocolors9.default.dim("\xB7")}  ${import_picocolors9.default.dim(formatReleaseDate(localPublishedAt))}` : import_picocolors9.default.dim(currentVersion);
   if (sp1)
     sp1.stop(localVersionLabel);
   else
@@ -13229,9 +13611,9 @@ async function runUpdate(opts = {}) {
     const release = await fetchLatestRelease(fetchFn);
     latestVersion = release.version;
     publishedAt = release.publishedAt;
-    const dateSuffix = publishedAt ? `  ${import_picocolors8.default.dim("\xB7")}  ${import_picocolors8.default.dim(formatReleaseDate(publishedAt))}` : "";
+    const dateSuffix = publishedAt ? `  ${import_picocolors9.default.dim("\xB7")}  ${import_picocolors9.default.dim(formatReleaseDate(publishedAt))}` : "";
     if (sp2)
-      sp2.stop(`${import_picocolors8.default.green(latestVersion)}${dateSuffix}`);
+      sp2.stop(`${import_picocolors9.default.green(latestVersion)}${dateSuffix}`);
     else
       writeLine(`latest: ${latestVersion}`);
   } catch (err) {
@@ -13252,7 +13634,7 @@ async function runUpdate(opts = {}) {
   if (check) {
     if (isTTY) {
       if (currentVersion !== latestVersion) {
-        barLine(`\u2B06\uFE0F   ${import_picocolors8.default.dim(currentVersion)}  \u2192  ${import_picocolors8.default.green(latestVersion)}  \xB7 binary would upgrade`);
+        barLine(`\u2B06\uFE0F   ${import_picocolors9.default.dim(currentVersion)}  \u2192  ${import_picocolors9.default.green(latestVersion)}  \xB7 binary would upgrade`);
         barBlank();
       }
       close("Dry run complete \u2014 no changes made");
@@ -13265,7 +13647,7 @@ async function runUpdate(opts = {}) {
   }
   if (latestVersion === currentVersion) {
     if (isTTY) {
-      close(`Already up to date \u2014 @onebrain-ai/cli ${import_picocolors8.default.dim(latestVersion)}`);
+      close(`Already up to date \u2014 @onebrain-ai/cli ${import_picocolors9.default.dim(latestVersion)}`);
     } else {
       writeLine(`already up to date: @onebrain-ai/cli ${latestVersion}`);
       writeLine("done: nothing to do");
@@ -13275,14 +13657,14 @@ async function runUpdate(opts = {}) {
     return result;
   }
   if (isTTY) {
-    barLine(`\u2B06\uFE0F   ${import_picocolors8.default.dim(currentVersion)}  \u2192  ${import_picocolors8.default.green(latestVersion)}`);
+    barLine(`\u2B06\uFE0F   ${import_picocolors9.default.dim(currentVersion)}  \u2192  ${import_picocolors9.default.green(latestVersion)}`);
     barBlank();
   }
   const sp3 = createStep("\uD83D\uDCE6", "Installing @onebrain-ai/cli");
   try {
     await installBinaryFn(latestVersion);
     if (sp3)
-      sp3.stop(import_picocolors8.default.green(latestVersion));
+      sp3.stop(import_picocolors9.default.green(latestVersion));
     else
       writeLine(`upgrading: @onebrain-ai/cli ${latestVersion} installed`);
   } catch (err) {
@@ -13319,7 +13701,7 @@ async function runUpdate(opts = {}) {
   result.ok = true;
   result.exitCode = 0;
   if (isTTY) {
-    close(`Done \u2014 run ${import_picocolors8.default.cyan("/update")} in Claude to sync vault files`);
+    close(`Done \u2014 run ${import_picocolors9.default.cyan("/update")} in Claude to sync vault files`);
   } else {
     writeLine("done: run /update in Claude to sync vault files");
   }
@@ -13346,7 +13728,7 @@ function patchUtf8(stream) {
 }
 
 // src/index.ts
-var VERSION = "2.2.5";
+var VERSION = "2.3.1";
 var RELEASE_DATE = "2026-05-12";
 patchUtf8(process.stdout);
 patchUtf8(process.stderr);
@@ -13361,7 +13743,7 @@ function findVaultRoot(startDir) {
     return process.cwd();
   let dir = startDir;
   while (true) {
-    if (existsSync(join11(dir, "vault.yml")))
+    if (existsSync2(join12(dir, "vault.yml")))
       return dir;
     const parent = dirname4(dir);
     if (parent === dir)
@@ -13389,6 +13771,9 @@ program2.command("doctor").description("Run vault health checks and report issue
     ...opts.fix !== undefined ? { fix: opts.fix } : {}
   });
 });
+program2.command("register-schedule").description("Register OneBrain scheduled skills with the OS scheduler (macOS launchd)").option("--vault <path>", "Vault path", process.cwd()).option("--dry-run", "Print plist without writing").option("--remove", "Remove all OneBrain schedule entries").option("--refresh", "Re-emit plists with current vault path").option("--resume <skill>", "Resume an auto-paused skill").option("--status", "Show registered schedules + recent run status").option("--test <skill>", "Manually invoke a scheduled skill once").action(async (opts) => {
+  await registerSchedule(opts);
+});
 program2.command("help").description("Show this help message").action(() => {
   program2.help();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebrain-ai/cli",
-  "version": "2.2.5",
+  "version": "2.3.1",
   "description": "CLI for OneBrain — personal AI OS for Obsidian with persistent memory, 24+ skills, and Claude Code integration",
   "keywords": [
     "onebrain",