@bunshin-cc/bunshin 0.5.0 → 0.5.2

package/dist/bin.js

@@ -953,17 +953,17 @@ var init_document = __esm({
 });
 
 // ../core/src/v2/sections/markdown.ts
-function repoSectionId(repo, path24, anchor = "") {
-  return anchor ? `repo:${repo}/${path24}#${anchor}` : `repo:${repo}/${path24}`;
+function repoSectionId(repo, path25, anchor = "") {
+  return anchor ? `repo:${repo}/${path25}#${anchor}` : `repo:${repo}/${path25}`;
 }
-function docKind(path24) {
-  const base = path24.split("/").pop()?.toLowerCase() ?? "";
+function docKind(path25) {
+  const base = path25.split("/").pop()?.toLowerCase() ?? "";
   if (base === "testing.md") return "verification";
   if (base === "skill.md") return "skill";
   return "spec";
 }
-function defaultPaths(path24) {
-  const dir = path24.split("/").slice(0, -1).join("/");
+function defaultPaths(path25) {
+  const dir = path25.split("/").slice(0, -1).join("/");
   if (!dir || dir.startsWith(".claude/") || dir.startsWith(".codex/")) return [];
   return [`${dir}/**`];
 }
@@ -1108,11 +1108,11 @@ function lintSkills(sections) {
     }
   const state = /* @__PURE__ */ new Map();
   const cycles = /* @__PURE__ */ new Set();
-  const dfs = (n, path24) => {
+  const dfs = (n, path25) => {
     state.set(n, 1);
     for (const d of edges[n] ?? []) {
-      if (state.get(d) === 1) cycles.add([...path24.slice(path24.indexOf(d)), d].join(" -> "));
-      else if (!state.get(d)) dfs(d, [...path24, d]);
+      if (state.get(d) === 1) cycles.add([...path25.slice(path25.indexOf(d)), d].join(" -> "));
+      else if (!state.get(d)) dfs(d, [...path25, d]);
     }
     state.set(n, 2);
   };
@@ -1199,8 +1199,8 @@ function parsePythonSkills(text2) {
   }
   return { skills, constants };
 }
-function harnessSectionId(path24, symbol) {
-  return `harness:${path24}#${symbol}`;
+function harnessSectionId(path25, symbol) {
+  return `harness:${path25}#${symbol}`;
 }
 var DEF_RE;
 var init_python = __esm({
@@ -1326,8 +1326,8 @@ function globToRegExp(glob) {
   globCache.set(glob, out);
   return out;
 }
-function matchesGlob(path24, glob) {
-  const p = path24.replace(/^\.\//, "").replace(/\\/g, "/");
+function matchesGlob(path25, glob) {
+  const p = path25.replace(/^\.\//, "").replace(/\\/g, "/");
   return globToRegExp(glob.replace(/^\.\//, "")).test(p);
 }
 var DEFAULT_EMBEDDERS, globCache;
@@ -1418,10 +1418,10 @@ function push(sections, reader, query) {
   for (const s of recallable(sections, reader)) {
     const triggers = [...(s.triggers ?? []).filter((t) => t.anchor), { anchor: "", paths: s.paths, entities: s.entities, skills: s.skills }];
     for (const t of triggers) {
-      const path24 = paths.find((p) => t.paths.some((g) => matchesGlob(p, g)));
-      const entity = path24 ? void 0 : t.entities.find((e) => entities.has(e) || text2 && text2.includes(e));
-      const skill = path24 || entity ? void 0 : skills.find((k) => t.skills.includes(k));
-      const trigger = path24 ? `path:${path24}` : entity ? `entity:${entity}` : skill ? `skill:${skill}` : "";
+      const path25 = paths.find((p) => t.paths.some((g) => matchesGlob(p, g)));
+      const entity = path25 ? void 0 : t.entities.find((e) => entities.has(e) || text2 && text2.includes(e));
+      const skill = path25 || entity ? void 0 : skills.find((k) => t.skills.includes(k));
+      const trigger = path25 ? `path:${path25}` : entity ? `entity:${entity}` : skill ? `skill:${skill}` : "";
       if (trigger) {
         hits.set(s.id, { section: s, trigger, anchor: t.anchor });
         break;
@@ -1666,6 +1666,7 @@ var init_redact = __esm({
       { kind: "aws-key", re: /\b(?:AKIA|ASIA|AGPA|AIDA|AROA|ANPA)[0-9A-Z]{16}\b/g },
       { kind: "github-pat", re: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g },
       { kind: "github-fine-pat", re: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g },
+      { kind: "bunshin-key", re: /\bbsk_[A-Za-z0-9]{8}_[A-Za-z0-9]{16,}\b/g },
       { kind: "anthropic-key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
       { kind: "openai-key", re: /\bsk-(?:proj-|live-)?[A-Za-z0-9_-]{20,}\b/g },
       { kind: "slack-token", re: /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/g },
@@ -5258,9 +5259,9 @@ function buildEpisode(store, session, transcriptPath, now = /* @__PURE__ */ new
   const from = reflectCursor(session, turns);
   const fresh = sinceTurn(scan, from);
   const signals = { ...sessionSignals({ scan: fresh, startedAt: session.startedAt, lastActivityAt: session.lastActivityAt, partial: from > 0 }), ...outcome ? { outcome: outcome.status } : {} };
-  const gate = sessionGate(signals, { now: now.toISOString(), cacheTtlMs: config.reflect.cacheTtlMs });
   const id = episodeIdFor(view.ctx.id, session.sessionId);
   const previous = v2.readEpisode(id);
+  const gate = sessionGate(signals, { now: now.toISOString(), cacheTtlMs: config.reflect.cacheTtlMs });
   const upload = config.upload ?? "redacted";
   const calls = v2.readCalls(session.sessionId);
   const snippets = [.../* @__PURE__ */ new Set([...v2.readSnippets(session.sessionId), ...scan.snippets])];
@@ -5279,7 +5280,8 @@ function buildEpisode(store, session, transcriptPath, now = /* @__PURE__ */ new
     suggestionIds: [.../* @__PURE__ */ new Set([...previous?.suggestionIds ?? [], ...session.suggestionIds])],
     // "edge" only while this machine's reflections cover every turn; new work is open again.
     reflected: previous?.reflected === "edge" && from >= turns ? "edge" : "none",
-    gate,
+    // Nothing new since the last reflection: the header keeps the gate that judged that work.
+    gate: turns <= from && previous?.gate ? previous.gate : gate,
     upload,
     turns,
     reflectedTurns: from,
@@ -8180,22 +8182,44 @@ Common flags: --api-url URL (default: this project's, else https://api.bunshin.c
 // src/v2/runner.ts
 var runner_exports = {};
 __export(runner_exports, {
+  LAUNCHD_LABEL: () => LAUNCHD_LABEL,
   ROUTINE_PROMPT: () => ROUTINE_PROMPT,
   cmdRunner: () => cmdRunner,
   connection: () => connection,
+  cronLine: () => cronLine,
+  installPrompt: () => installPrompt,
+  installSchedule: () => installSchedule,
+  launchdPlist: () => launchdPlist,
+  readInstalled: () => readInstalled,
+  removeSchedule: () => removeSchedule,
   renderJob: () => renderJob,
   runOnce: () => runOnce,
+  runnerHome: () => runnerHome,
+  scheduledCommand: () => scheduledCommand,
   setupText: () => setupText
 });
+import { spawnSync as spawnSync3 } from "node:child_process";
 import fs23 from "node:fs";
 import os5 from "node:os";
+import path20 from "node:path";
+function runnerHome(home = process.env.BUNSHIN_RUNNER_HOME || os5.homedir()) {
+  return path20.join(home, ".bunshin", "runner");
+}
+function readInstalled(home) {
+  try {
+    return JSON.parse(fs23.readFileSync(path20.join(runnerHome(home), "config.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
 function connection(args, cwd) {
-  const store = Store.discover(cwd);
+  const saved = readInstalled();
+  const store = saved && path20.resolve(cwd).startsWith(runnerHome()) ? null : Store.discover(cwd);
   const config = store?.config();
-  const key = process.env.BUNSHIN_RUNNER_KEY || process.env.BUNSHIN_API_KEY || config?.apiKey || "";
-  const apiUrl = (str5(args.flags["api-url"]) ?? process.env.BUNSHIN_API_URL ?? config?.apiUrl ?? DEFAULT_API).replace(/\/$/, "");
+  const key = str5(args.flags.key) || process.env.BUNSHIN_RUNNER_KEY || process.env.BUNSHIN_API_KEY || config?.apiKey || saved?.key || "";
+  const apiUrl = (str5(args.flags["api-url"]) || process.env.BUNSHIN_API_URL || config?.apiUrl || saved?.apiUrl || DEFAULT_API).replace(/\/$/, "");
   if (!key) throw new Error("no key: set BUNSHIN_RUNNER_KEY (create a runner key in the console: Runners \u2192 New runner key) or run inside a connected project");
-  const name = str5(args.flags.name) ?? process.env.BUNSHIN_RUNNER_NAME ?? `${os5.hostname().split(".")[0] || "runner"}`;
+  const name = str5(args.flags.name) ?? process.env.BUNSHIN_RUNNER_NAME ?? saved?.name ?? `${os5.hostname().split(".")[0] || "runner"}`;
   return { apiUrl, key, name: name.replace(/[^\w.:@/-]/g, "-").slice(0, 80) };
 }
 async function call(c, method, route, body, timeoutMs = 6e4) {
@@ -8228,9 +8252,10 @@ async function lease(c, args, max = 1) {
   return (await call(c, "POST", "/lease", { max, runner: c.name, ...kinds ? { kinds } : {} }, 12e4)).body.jobs;
 }
 function modelConfig(args) {
-  const backend = str5(args.flags.backend) ?? "auto";
+  const saved = readInstalled();
+  const backend = str5(args.flags.backend) ?? saved?.backend ?? "auto";
   if (!["auto", "sdk", "claude-cli", "codex-cli", "pi-cli"].includes(backend)) throw new Error("--backend must be auto, sdk, claude-cli, codex-cli or pi-cli");
-  const model = str5(args.flags.model) ?? process.env.BUNSHIN_MODEL;
+  const model = str5(args.flags.model) ?? process.env.BUNSHIN_MODEL ?? saved?.model;
   const harness = backend === "codex-cli" ? "codex" : backend === "pi-cli" ? "pi" : "claude-code";
   return { ...DEFAULT_CONFIG, backend, harness, ...model ? { model } : {}, ...model && backend === "codex-cli" ? { codexModel: model } : {}, ...model && backend === "pi-cli" ? { piModel: model } : {} };
 }
@@ -8243,7 +8268,7 @@ async function runOnce(c, args, out, err) {
     const [job] = await lease(c, args);
     if (!job) break;
     const started = Date.now();
-    const res = await askJson(config, { system: job.system, user: job.prompt, schema: job.schema, enforceSchema: false, timeoutMs: 15 * 6e4, maxTokens: 16e3 });
+    const res = await askJson(config, { system: job.system, user: job.prompt, schema: job.schema, enforceSchema: false, timeoutMs: 15 * 6e4, maxTokens: 16e3, cwd: workDir() });
     const model = config.backend === "codex-cli" ? config.codexModel ?? "codex default" : config.backend === "pi-cli" ? config.piModel ?? "pi default" : config.model;
     if (!res.ok) {
       const r2 = await call(c, "POST", `/jobs/${job.id}/fail`, { error: res.error.slice(0, 1900), model, runner: c.name });
@@ -8280,8 +8305,183 @@ If you cannot answer it, run: bunshin runner fail ${job.id} --error "<why>"
 Then run \`bunshin runner next\` again until it says there are no jobs.
 `;
 }
+function workDir() {
+  const dir = path20.join(runnerHome(), "work");
+  fs23.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function which(name) {
+  for (const d of [...(process.env.PATH || "").split(path20.delimiter), path20.join(os5.homedir(), ".local", "bin")]) {
+    if (d && fs23.existsSync(path20.join(d, name))) return path20.join(d, name);
+  }
+  return null;
+}
+function scheduledCommand(backend) {
+  const node = path20.dirname(process.execPath);
+  const npx = fs23.existsSync(path20.join(node, "npx")) ? path20.join(node, "npx") : which("npx") ?? "npx";
+  const bin = BIN_OF[backend] ? which(BIN_OF[backend]) : null;
+  const dirs = [.../* @__PURE__ */ new Set([node, ...bin ? [path20.dirname(bin)] : [], path20.join(os5.homedir(), ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"])];
+  return { argv: [npx, "-y", PKG, "runner", "--once"], path: dirs.join(path20.delimiter) };
+}
+function launchdPlist(backend, everyMinutes, home = runnerHome()) {
+  const cmd = scheduledCommand(backend);
+  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>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>${cmd.argv.map((a) => `<string>${xml(a)}</string>`).join("")}</array>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${xml(cmd.path)}</string></dict>
+  <key>WorkingDirectory</key><string>${xml(home)}</string>
+  <key>StartInterval</key><integer>${everyMinutes * 60}</integer>
+  <key>StandardOutPath</key><string>${xml(path20.join(home, "runner.log"))}</string>
+  <key>StandardErrorPath</key><string>${xml(path20.join(home, "runner.log"))}</string>
+  <key>ProcessType</key><string>Background</string>
+  <key>LowPriorityIO</key><true/>
+</dict>
+</plist>
+`;
+}
+function cronLine(backend, everyMinutes, home = runnerHome()) {
+  const cmd = scheduledCommand(backend);
+  const when = everyMinutes >= 60 ? `17 */${Math.max(1, Math.round(everyMinutes / 60))} * * *` : `*/${everyMinutes} * * * *`;
+  const q = (v) => `'${v.replace(/'/g, `'\\''`)}'`;
+  return `${when} cd ${q(home)} && PATH=${q(cmd.path)} ${cmd.argv.map(q).join(" ")} >> ${q(path20.join(home, "runner.log"))} 2>&1 ${CRON_MARK}`;
+}
+function launchAgentsDir(opts) {
+  return opts.launchAgents ?? path20.join(process.env.BUNSHIN_RUNNER_HOME || os5.homedir(), "Library", "LaunchAgents");
+}
+function installSchedule(backend, everyMinutes, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const run2 = opts.run ?? realRun;
+  if (platform === "darwin") {
+    const dir = launchAgentsDir(opts);
+    const plist = path20.join(dir, `${LAUNCHD_LABEL}.plist`);
+    fs23.mkdirSync(dir, { recursive: true });
+    fs23.writeFileSync(plist, launchdPlist(backend, everyMinutes));
+    const domain = `gui/${process.getuid?.() ?? 501}`;
+    run2("launchctl", ["bootout", `${domain}/${LAUNCHD_LABEL}`]);
+    const r = run2("launchctl", ["bootstrap", domain, plist]);
+    if (r.status !== 0) throw new Error(`launchctl bootstrap: ${(r.stderr || r.stdout).trim() || `exit ${r.status}`}`);
+    return { kind: "launchd", where: plist, argv: scheduledCommand(backend).argv };
+  }
+  if (platform === "linux" || platform === "freebsd" || platform === "openbsd") {
+    const current = run2("crontab", ["-l"]);
+    const kept = (current.status === 0 ? current.stdout : "").split("\n").filter((l) => l.trim() && !l.includes(CRON_MARK));
+    const r = run2("crontab", ["-"], [...kept, cronLine(backend, everyMinutes), ""].join("\n"));
+    if (r.status !== 0) throw new Error(`crontab: ${(r.stderr || r.stdout).trim() || `exit ${r.status}`}`);
+    return { kind: "cron", where: "crontab", argv: scheduledCommand(backend).argv };
+  }
+  return { kind: "none", where: "", argv: scheduledCommand(backend).argv };
+}
+function removeSchedule(opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const run2 = opts.run ?? realRun;
+  if (platform === "darwin") {
+    const plist = path20.join(launchAgentsDir(opts), `${LAUNCHD_LABEL}.plist`);
+    run2("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LAUNCHD_LABEL}`]);
+    if (!fs23.existsSync(plist)) return "no schedule";
+    fs23.rmSync(plist, { force: true });
+    return `removed ${plist}`;
+  }
+  const current = run2("crontab", ["-l"]);
+  if (current.status !== 0 || !current.stdout.includes(CRON_MARK)) return "no schedule";
+  run2("crontab", ["-"], current.stdout.split("\n").filter((l) => !l.includes(CRON_MARK)).join("\n"));
+  return "removed the crontab line";
+}
+async function install(args, cwd, out, err, opts = {}) {
+  const c = connection(args, cwd);
+  try {
+    await call(c, "GET", "/status");
+  } catch (e) {
+    const m = e instanceof Error ? e.message : String(e);
+    err(/40[13]/.test(m) ? `This key cannot answer model jobs. Create one in the console: Runners \u2192 New runner key (admins only).
+` : `Could not reach ${c.apiUrl}: ${m}
+`);
+    return 1;
+  }
+  const config = modelConfig(args);
+  const backend = resolveBackend(config);
+  if (!backend) {
+    err("No model on this computer: install Claude Code (or Codex, or pi), sign in, and paste the command again.\n");
+    return 1;
+  }
+  const every = Math.max(15, Number(str5(args.flags.every) ?? 60) || 60);
+  const home = runnerHome();
+  fs23.mkdirSync(home, { recursive: true, mode: 448 });
+  const saved = { apiUrl: c.apiUrl, key: c.key, backend, ...config.model && str5(args.flags.model) ? { model: config.model } : {}, name: c.name, every };
+  fs23.writeFileSync(path20.join(home, "config.json"), JSON.stringify(saved, null, 2) + "\n", { mode: 384 });
+  fs23.chmodSync(path20.join(home, "config.json"), 384);
+  let schedule;
+  try {
+    schedule = installSchedule(backend, every, opts);
+  } catch (e) {
+    err(`Saved the runner, but could not schedule it: ${e instanceof Error ? e.message : String(e)}
+Run it yourself: npx -y ${PKG} runner --once
+`);
+    return 1;
+  }
+  out(`\u2713 Runner "${c.name}" answers ${c.apiUrl}'s model jobs with ${BACKEND_NAME[backend] ?? backend} on this computer.
+`);
+  out(schedule.kind === "none" ? `  No scheduler here: run \`npx -y ${PKG} runner --once\` on a schedule yourself.
+` : `  Every ${every} minutes while this computer is on (${schedule.kind}). Log: ${path20.join(home, "runner.log")}
+`);
+  out(`  Stop: npx -y ${PKG} runner uninstall
+`);
+  if (args.flags.run === false) return 0;
+  out(`
+Answering what waits now\u2026
+`);
+  const r = await runOnce(c, args, out, err);
+  out(r.done || r.failed ? `${r.done} answered, ${r.failed} failed.
+` : `Nothing waiting. The next nightly's work is answered on schedule.
+`);
+  return r.failed && !r.done ? 1 : 0;
+}
+function uninstall(out, opts = {}) {
+  out(`${removeSchedule(opts)}
+`);
+  const file = path20.join(runnerHome(), "config.json");
+  if (fs23.existsSync(file)) {
+    fs23.rmSync(file, { force: true });
+    out(`removed ${file} (revoke the key in the console: Agent keys)
+`);
+  }
+  return 0;
+}
+function installPrompt(key) {
+  return `Set up this computer as my team's Bunshin runner: it answers Bunshin's queued model work (lessons
+from work sessions, merging the shared documents) with this computer's own Claude Code / Codex / pi
+sign-in, about once an hour while the computer is on.
+
+1. Run: npx -y ${PKG} runner install --key ${key}
+2. If it says there is no model on this computer, check \`claude --version\` (or codex / pi). If none
+   is installed or signed in, tell me the one command to install or sign in, wait for me, then run
+   step 1 again.
+3. If it says the key cannot answer jobs or the API cannot be reached, stop and show me its message.
+4. Finish with what it printed last: how many jobs it answered and how to stop it.
+
+Do not change any repository or other files.`;
+}
 function setupText(target) {
   switch (target) {
+    case "this-computer":
+      return `This computer (Claude Code, Codex or pi signed in): one paste
+
+1. Console \u2192 Runners \u2192 New runner key. The page shows this command with the key in it:
+
+   npx -y ${PKG} runner install --key <runner key>
+
+It checks the key, picks the model this computer is signed in to, answers every hour while the
+computer is on (launchd on macOS, cron on Linux) and answers what waits now.
+Stop: npx -y ${PKG} runner uninstall
+
+Or paste this into Claude Code (or Codex, or pi) on that computer, and it does the rest:
+
+${installPrompt("<runner key>").replace(/^/gm, "   ")}
+`;
     case "claude-routine":
       return `Claude Code routine (claude.ai/code \u2192 Routines, or /schedule in Claude Code)
 
@@ -8349,7 +8549,7 @@ CMD ["bunshin", "runner", "--watch", "--backend", "claude-cli", "--model", "clau
 17 3 * * *  BUNSHIN_RUNNER_KEY=<key> bunshin runner --once --backend claude-cli --model "claude-opus-5-5[1m]" >> ~/.bunshin/runner.log 2>&1
 `;
     default:
-      return `bunshin runner setup <target>: claude-routine | codex-cloud | github-action | docker | cron
+      return `bunshin runner setup <target>: this-computer | claude-routine | codex-cloud | github-action | docker | cron
 
 Or give the server a key and it runs model work itself (wrangler secret put \u2026):
   ANTHROPIC_API_KEY (+ BUNSHIN_MODEL, default claude-opus-5-5)
@@ -8358,12 +8558,14 @@ Or give the server a key and it runs model work itself (wrangler secret put \u20
 `;
   }
 }
-async function cmdRunner(args, cwd, out, err) {
+async function cmdRunner(args, cwd, out, err, opts = {}) {
   const sub = args._[1] ?? "";
   if (sub === "setup") {
     out(setupText(args._[2] ?? ""));
     return 0;
   }
+  if (sub === "install") return install(args, cwd, out, err, opts);
+  if (sub === "uninstall") return uninstall(out, opts);
   const c = connection(args, cwd);
   if (sub === "status") {
     const s = (await call(c, "GET", "/status")).body;
@@ -8409,7 +8611,7 @@ async function cmdRunner(args, cwd, out, err) {
 `);
     return 0;
   }
-  if (sub && sub !== "run") throw new Error(`unknown runner command "${sub}" (run, next, submit, fail, status, setup)`);
+  if (sub && sub !== "run") throw new Error(`unknown runner command "${sub}" (run, next, submit, fail, status, install, uninstall, setup)`);
   const watch = args.flags.watch === true;
   const interval = Number(str5(args.flags.interval) ?? 300) * 1e3;
   for (; ; ) {
@@ -8422,7 +8624,7 @@ async function cmdRunner(args, cwd, out, err) {
     await new Promise((resolve) => setTimeout(resolve, interval));
   }
 }
-var DEFAULT_API, KINDS2, str5, NPX, ROUTINE_PROMPT;
+var DEFAULT_API, KINDS2, str5, LAUNCHD_LABEL, CRON_MARK, PKG, BIN_OF, xml, realRun, BACKEND_NAME, NPX, ROUTINE_PROMPT;
 var init_runner = __esm({
   "src/v2/runner.ts"() {
     "use strict";
@@ -8431,6 +8633,16 @@ var init_runner = __esm({
     DEFAULT_API = "https://api.bunshin.cc";
     KINDS2 = ["reflect", "merge", "create"];
     str5 = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+    LAUNCHD_LABEL = "cc.bunshin.runner";
+    CRON_MARK = "# bunshin-runner";
+    PKG = "@bunshin-cc/bunshin@latest";
+    BIN_OF = { "claude-cli": "claude", "codex-cli": "codex", "pi-cli": "pi" };
+    xml = (v) => v.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    realRun = (cmd, args, input) => {
+      const r = spawnSync3(cmd, args, { encoding: "utf8", ...input !== void 0 ? { input } : {} });
+      return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? r.error?.message ?? "" };
+    };
+    BACKEND_NAME = { sdk: "the Anthropic API key in this environment", "claude-cli": "Claude Code", "codex-cli": "Codex", "pi-cli": "pi" };
     NPX = "npx -y @bunshin-cc/bunshin@latest";
     ROUTINE_PROMPT = `You are this company's Bunshin runner. Bunshin queues model work (reflecting on work sessions,
 reconciling the shared documents); you answer it, then stop.
@@ -8447,7 +8659,7 @@ reconciling the shared documents); you answer it, then stop.
 // src/v2/importer.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import fs24 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 function rewriteRepoPaths(text2, repoName2, pack) {
   const re = new RegExp(`(?<=^|[\\s\`'"(=:])(?:~|\\$\\{?[A-Za-z_][A-Za-z0-9_]*\\}?)?(?:/[\\w.@+-]+)*/${escapeRe(repoName2)}(?=[/\\s\`'")\\]]|[.,;:](?:\\s|$)|$)`, "gm");
   return text2.replace(re, `~/.bunshin/library/${pack}`);
@@ -8486,7 +8698,7 @@ function buildDocs(files, opts) {
     const main2 = `${dir}/SKILL.md`;
     const text2 = rw(files.get(main2).content);
     const fm = frontmatterDescription(text2);
-    const name = path20.posix.basename(dir);
+    const name = path21.posix.basename(dir);
     const bundle = {};
     for (const p of all.filter((x) => x.startsWith(`${dir}/`))) {
       claimed.add(p);
@@ -8587,11 +8799,11 @@ function workingTreeFiles(root) {
     return fs24.readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
       if (e.name === ".git" || e.name === "node_modules") return [];
       const rel = base ? `${base}/${e.name}` : e.name;
-      return e.isDirectory() ? walk(path20.join(dir, e.name), rel) : e.isFile() ? [rel] : [];
+      return e.isDirectory() ? walk(path21.join(dir, e.name), rel) : e.isFile() ? [rel] : [];
     });
   })(root);
   for (const rel of list2) {
-    const abs = path20.join(root, rel);
+    const abs = path21.join(root, rel);
     let buf;
     try {
       buf = fs24.readFileSync(abs);
@@ -8633,7 +8845,7 @@ function diffDocs(prev, next) {
   return { docs: next.filter((d) => before.get(d.path) !== fingerprint(d)), removed: [...before.keys()].filter((p) => !after.has(p)) };
 }
 function readSkillSystem(root, opts) {
-  const repoName2 = path20.basename(path20.resolve(root));
+  const repoName2 = path21.basename(path21.resolve(root));
   const build = (files2) => buildDocs(files2, { pack: opts.pack, repoName: repoName2, ...opts.rewrite === false ? { rewrite: false } : {} });
   const tree = build(workingTreeFiles(root));
   if (!opts.history || !isGitRepo(root)) return { versions: [{ summary: `import ${opts.pack}`, docs: tree, removed: [], complete: true }], docs: tree };
@@ -8710,7 +8922,7 @@ var init_importer = __esm({
     escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     looksGenerated = (text2) => /generated by|do not edit( by hand)?/i.test(text2.slice(0, 600));
     isStopHook = (text2) => /"decision"\s*:\s*"block"|decision.{0,4}block/.test(text2) && /REASON=/.test(text2);
-    isUpdateHook = (p, text2) => /auto-?update/i.test(path20.basename(p)) || /git (pull|fetch)/.test(text2) && /SessionStart|session start/i.test(text2);
+    isUpdateHook = (p, text2) => /auto-?update/i.test(path21.basename(p)) || /git (pull|fetch)/.test(text2) && /SessionStart|session start/i.test(text2);
     fingerprint = (d) => JSON.stringify(d);
     REWRITE_SYSTEM = `You adapt a company's skill documents after its skill system moved into Bunshin.
 
@@ -8747,7 +8959,7 @@ __export(skills_exports, {
   parsePin: () => parsePin
 });
 import fs25 from "node:fs";
-import path21 from "node:path";
+import path22 from "node:path";
 function requireOnline(store, what) {
   if (!canCall(store.config())) throw new Error(`${what} needs the hosted library: run \`bunshin setup\` first`);
 }
@@ -8756,9 +8968,9 @@ async function cmdImport2(store, args, cwd, out, err) {
     err("usage: bunshin import skills <dir> [--pack <name>] [--layer org|team:<unit>] [--owner-team <unit>] [--no-history] [--dry-run] [--propose-rewrites]\n");
     return 1;
   }
-  const root = path21.resolve(cwd, args._[2]);
+  const root = path22.resolve(cwd, args._[2]);
   if (!fs25.existsSync(root)) throw new Error(`${root} does not exist`);
-  const pack = str6(args.flags.pack) ?? path21.basename(root);
+  const pack = str6(args.flags.pack) ?? path22.basename(root);
   const history = args.flags.history !== false && !bool4(args.flags["no-history"]);
   const read = readSkillSystem(root, { pack, history, ...str6(args.flags.since) ? { since: str6(args.flags.since) } : {} });
   const kinds = /* @__PURE__ */ new Map();
@@ -8793,7 +9005,7 @@ async function cmdImport2(store, args, cwd, out, err) {
   const propose = args.flags["propose-rewrites"];
   if (propose) {
     const only = typeof propose === "string" && propose !== "true" ? propose.split(",").map((x) => x.trim()).filter(Boolean) : [];
-    await proposeRewrites(store, read.docs.filter((d) => !only.length || only.some((o) => d.path.includes(o))), pack, path21.basename(root), out, err);
+    await proposeRewrites(store, read.docs.filter((d) => !only.length || only.some((o) => d.path.includes(o))), pack, path22.basename(root), out, err);
   }
   out("Run `bunshin sync` on each machine (it runs at session start) to install the skills, instructions and files.\n");
   return 0;
@@ -8933,7 +9145,7 @@ ${report.skills} skills, ${report.references} references, ${report.errors.length
       }
       const graph = str6(args.flags.graph) ?? (bool4(args.flags.graph) ? "SKILLS-GRAPH.md" : void 0);
       if (graph) {
-        fs25.writeFileSync(path21.resolve(cwd, graph), renderSkillGraph(report));
+        fs25.writeFileSync(path22.resolve(cwd, graph), renderSkillGraph(report));
         out(`graph written to ${graph}
 `);
       }
@@ -9032,8 +9244,8 @@ async function cmdLibrary(store, args, cwd, out, err) {
 `;
       const file = str6(args.flags.write) ?? (bool4(args.flags.write) ? ".claude/skills-version" : void 0);
       if (file) {
-        const abs = path21.resolve(cwd, file);
-        fs25.mkdirSync(path21.dirname(abs), { recursive: true });
+        const abs = path22.resolve(cwd, file);
+        fs25.mkdirSync(path22.dirname(abs), { recursive: true });
         fs25.writeFileSync(abs, line);
         out(`${file}: ${line}`);
       } else out(line);
@@ -9044,11 +9256,11 @@ async function cmdLibrary(store, args, cwd, out, err) {
       const to = str6(args.flags.to);
       if (!to) throw new Error("--to <dir> is required");
       const pinFile = str6(args.flags.pin);
-      const pin = str6(args.flags.git) ? { git: str6(args.flags.git) } : pinFile ? parsePin(fs25.readFileSync(path21.resolve(cwd, pinFile), "utf8")) : parsePin(args._[2] ?? "");
+      const pin = str6(args.flags.git) ? { git: str6(args.flags.git) } : pinFile ? parsePin(fs25.readFileSync(path22.resolve(cwd, pinFile), "utf8")) : parsePin(args._[2] ?? "");
       const q = pin.git ? `git=${pin.git}` : pin.version ? `version=${pin.version}` : "";
       if (!q) throw new Error("name a version: lib@N, --git <sha>, or --pin <file>");
       const snap = await v2api(config, "GET", `/library/snapshot?${q}`, void 0, { timeoutMs: 12e4 });
-      const dir = path21.resolve(cwd, to);
+      const dir = path22.resolve(cwd, to);
       if (fs25.existsSync(dir) && fs25.readdirSync(dir).length && !bool4(args.flags.force)) throw new Error(`${dir} is not empty (use --force)`);
       const pack = str6(args.flags.pack);
       const docs = snap.sections.filter((s) => !pack || s.pack === pack);
@@ -9089,11 +9301,11 @@ __export(reflect_exports, {
   runReflection: () => runReflection
 });
 import fs26 from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 async function runReflection(store, opts) {
   const empty = { lessonIds: [], used: [], missed: [], attribution: [] };
-  const lock = path22.join(store.root, `reflect-${createHash7("sha256").update(opts.sessionId).digest("hex")}.lock`);
+  const lock = path23.join(store.root, `reflect-${createHash7("sha256").update(opts.sessionId).digest("hex")}.lock`);
   const deadline = Date.now() + 66e4;
   for (; ; ) {
     try {
@@ -9466,7 +9678,7 @@ __export(cli_exports, {
   version: () => version
 });
 import fs27 from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 function parseArgs(argv) {
   const out = { _: [], flags: {} };
   const valueless = /* @__PURE__ */ new Set(["json", "quiet", "force", "sync", "global", "help", "version", "dry-run", "offline", "apply", "no-hooks", "remove-hooks", "key-stdin", "debug", "verbose", "robot", "fork", "upload", "index", "all", "legacy", "depth", "local", "skip-github", "propose-rewrites", "clear", "watch", "once"]);
@@ -9577,7 +9789,7 @@ async function main(argv, opts = {}) {
       if (harness !== "codex" && harness !== "claude-code" && harness !== "pi") throw new Error("Choose your agent: bunshin setup --harness codex, claude-code, or pi.");
       const agent = harness === "claude-code" ? "claude" : harness;
       if (!executable2(agent)) throw new Error(`${agent} was not found. Install and sign in to your agent, then run setup again.`);
-      const existing = new Store(path23.join(cwd, ".bunshin")).config();
+      const existing = new Store(path24.join(cwd, ".bunshin")).config();
       const apiUrl = str7(args.flags["api-url"]);
       const key = bool5(args.flags["key-stdin"]) ? await new Promise((resolve, reject) => {
         let value = "";
@@ -9620,7 +9832,7 @@ Key saved privately outside the project.
   if (cmd === "mcp") {
     const { runMcpServer: runMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
     const root = str7(args.flags.root);
-    await runMcpServer2({ cwd, ...root ? { store: new Store(path23.resolve(root)) } : {}, version: version() });
+    await runMcpServer2({ cwd, ...root ? { store: new Store(path24.resolve(root)) } : {}, version: version() });
     return 0;
   }
   if (cmd === "demo") {
@@ -9703,7 +9915,7 @@ ${HELP2}`);
 function openStore(args, cwd) {
   const root = str7(args.flags.root);
   if (root) {
-    const store = new Store(path23.resolve(root));
+    const store = new Store(path24.resolve(root));
     store.ensureLayout();
     return store;
   }
@@ -9762,7 +9974,7 @@ function cmdStatus(store, args, out, v2) {
   const conflicts = store.listConflicts().filter((c) => c.status === "open");
   const metrics = store.readMetrics(void 0);
   const last50 = metrics?.windows?.find((w) => w.name === "last50");
-  const hookFiles = config.harness === "codex" ? [.../* @__PURE__ */ new Set([path23.join(process.env.CODEX_HOME ?? path23.join(homeDir(), ".codex"), "hooks.json"), codexProjectHooks(path23.dirname(store.root)).file])] : config.harness === "claude-code" ? [path23.join(homeDir(), ".claude", "settings.json"), path23.join(path23.dirname(store.root), ".claude", "settings.local.json")] : config.harness === "pi" ? [path23.join(homeDir(), ".pi/agent/extensions/bunshin.js"), path23.join(path23.dirname(store.root), ".pi/extensions/bunshin.js")] : [];
+  const hookFiles = config.harness === "codex" ? [.../* @__PURE__ */ new Set([path24.join(process.env.CODEX_HOME ?? path24.join(homeDir(), ".codex"), "hooks.json"), codexProjectHooks(path24.dirname(store.root)).file])] : config.harness === "claude-code" ? [path24.join(homeDir(), ".claude", "settings.json"), path24.join(path24.dirname(store.root), ".claude", "settings.local.json")] : config.harness === "pi" ? [path24.join(homeDir(), ".pi/agent/extensions/bunshin.js"), path24.join(path24.dirname(store.root), ".pi/extensions/bunshin.js")] : [];
   const hooks = config.harness === "pi" ? hookFiles.filter((file) => {
     try {
       return fs27.readFileSync(file, "utf8").startsWith("// Managed by Bunshin setup.");
@@ -10009,7 +10221,7 @@ async function cmdReflect(store, args, cwd, out, err) {
   }
   const { runReflection: runReflection2 } = await Promise.resolve().then(() => (init_reflect4(), reflect_exports));
   const result = await runReflection2(store, {
-    sessionId: str7(args.flags.session) ?? path23.basename(transcript).replace(/\.jsonl?$/, ""),
+    sessionId: str7(args.flags.session) ?? path24.basename(transcript).replace(/\.jsonl?$/, ""),
     transcriptPath: transcript,
     cwd,
     force: bool5(args.flags.force)
@@ -10181,7 +10393,9 @@ Usage: bunshin <command> [options]
                                 reconciliation) with this machine's model. BUNSHIN_RUNNER_KEY
   runner next | submit <job> <file|-> | fail <job> --error <why>
                                 agent mode, for a Claude Code routine or Codex cloud task
-  runner status | setup [claude-routine|codex-cloud|github-action|docker|cron]
+  runner install --key <runner key> [--every <minutes>] [--no-run] | uninstall
+                                this computer answers it every hour (launchd / cron)
+  runner status | setup [this-computer|claude-routine|codex-cloud|github-action|docker|cron]
   reflect --fork --session <id> [--focus "<text>"]   (what the session-end hook detaches)
 
   lessons [list] [--kind fact|workflow] [--q <query>] [--json]   (legacy lesson store)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunshin-cc/bunshin",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
   "type": "module",
   "bin": {