@bunshin-cc/bunshin 0.4.8 → 0.5.0

package/dist/bin.js

@@ -1855,6 +1855,18 @@ At most ${max} suggestions. Schema:
                   "signal": "steering"|"environment"|"knowledge"|"capability"|"approach"}]}`;
 }
 function extractJson(text2) {
+  try {
+    const whole = JSON.parse(text2.trim());
+    if (whole && typeof whole === "object") return whole;
+  } catch {
+  }
+  const outer = /^\s*```(?:json)?\s*\n([\s\S]*)\n```\s*$/.exec(text2);
+  if (outer) {
+    try {
+      return JSON.parse(outer[1]);
+    } catch {
+    }
+  }
   const fenced = text2.match(/```(?:json)?\s*([\s\S]*?)```/);
   const candidate = fenced ? fenced[1] : text2;
   const start = candidate.indexOf("{");
@@ -2029,6 +2041,20 @@ var init_reconcile = __esm({
   }
 });
 
+// ../core/src/v2/merge.ts
+var init_merge = __esm({
+  "../core/src/v2/merge.ts"() {
+    "use strict";
+    init_text();
+    init_layers();
+    init_reconcile();
+    init_markdown();
+    init_reflect();
+    init_redact();
+    init_text_index();
+  }
+});
+
 // ../core/src/v2/release.ts
 var init_release = __esm({
   "../core/src/v2/release.ts"() {
@@ -2065,6 +2091,7 @@ var init_v2 = __esm({
     init_engine();
     init_reflect();
     init_reconcile();
+    init_merge();
     init_release();
     init_research();
     init_profile();
@@ -3383,22 +3410,22 @@ async function askSdk(opts) {
     system: opts.system,
     messages: [{ role: "user", content: opts.user }]
   };
-  const format = { type: "json_schema", schema: opts.schema };
+  const format = opts.enforceSchema === false ? void 0 : { type: "json_schema", schema: opts.schema };
   const reqOpts = { timeout: opts.timeoutMs ?? 3e5 };
   let response;
   try {
-    response = isHaiku ? await client.messages.create({ ...base, output_config: { format } }, reqOpts) : await client.beta.messages.create(
+    response = isHaiku ? await client.messages.create({ ...base, ...format ? { output_config: { format } } : {} }, reqOpts) : await client.beta.messages.create(
       {
         ...base,
         betas: ["server-side-fallback-2026-07-01"],
         fallbacks: "default",
-        output_config: { format, effort: opts.effort ?? "medium" }
+        output_config: { ...format ? { format } : {}, effort: opts.effort ?? "medium" }
       },
       reqOpts
     );
   } catch (err) {
     if (!(err instanceof Anthropic.BadRequestError)) throw err;
-    response = await client.messages.create({ ...base, output_config: { format } }, reqOpts);
+    response = await client.messages.create({ ...base, ...format ? { output_config: { format } } : {} }, reqOpts);
   }
   if (response.stop_reason === "refusal") throw new Error("model refused the request");
   return response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
@@ -4284,7 +4311,7 @@ async function syncV2(store, opts = {}) {
     report.errors.push("sync already running in another process; work stays queued");
     return report;
   }
-  const call = (method, route, body) => v2api(config, method, route, body, { deadline, timeoutMs: 15e3 });
+  const call2 = (method, route, body) => v2api(config, method, route, body, { deadline, timeoutMs: 15e3 });
   const ctx = contextFor(v2, config);
   const deploying = (opts.deploy ?? true) && deployEnabled(config, ctx);
   try {
@@ -4298,7 +4325,7 @@ async function syncV2(store, opts = {}) {
     for (const e of v2.listEpisodes().filter((x) => !x.uploaded)) {
       if (Date.now() >= deadline) break;
       try {
-        const res = await call("POST", "/episodes", { episode: episodePayload(e) });
+        const res = await call2("POST", "/episodes", { episode: episodePayload(e) });
         if (res && (typeof res.reflectedTurns === "number" || Array.isArray(res.lessons)) && v2.readSession(e.sessionId)) {
           v2.updateSession(e.sessionId, "", (s) => {
             if (typeof res.reflectedTurns === "number") s.serverReflectedTurns = Math.max(s.serverReflectedTurns ?? 0, res.reflectedTurns);
@@ -4313,8 +4340,8 @@ async function syncV2(store, opts = {}) {
         const served = e.sectionsServed.filter((id) => !isLocalId(id) && !doneServed.has(id));
         const loaded = e.sectionsLoaded.filter((id) => !isLocalId(id) && !doneLoaded.has(id));
         try {
-          if (served.length) await call("POST", "/recall/served", { sectionIds: served });
-          if (loaded.length) await call("POST", "/recall/served", { sectionIds: loaded, loaded: true });
+          if (served.length) await call2("POST", "/recall/served", { sectionIds: served });
+          if (loaded.length) await call2("POST", "/recall/served", { sectionIds: loaded, loaded: true });
           next.reportedServed = [...doneServed, ...served];
           next.reportedLoaded = [...doneLoaded, ...loaded];
           delete next.servedReported;
@@ -4330,7 +4357,7 @@ async function syncV2(store, opts = {}) {
     const pending = v2.listSuggestions().filter((s) => s.status === "submitted" && !s.uploaded && s.op.op !== "param");
     if (pending.length && Date.now() < deadline) {
       try {
-        const res = await call("POST", "/suggestions", { suggestions: pending.map(suggestionPayload) });
+        const res = await call2("POST", "/suggestions", { suggestions: pending.map(suggestionPayload) });
         const ok = new Set(Array.isArray(res.ids) ? res.ids : pending.map((s) => s.id));
         for (const s of pending) {
           if (!ok.has(s.id)) continue;
@@ -4345,7 +4372,7 @@ async function syncV2(store, opts = {}) {
     for (const s of v2.listSuggestions().filter((x) => x.uploaded && x.trialDirty)) {
       if (Date.now() >= deadline) break;
       try {
-        await call("PATCH", `/suggestions/${encodeURIComponent(s.id)}/trial`, s.trial);
+        await call2("PATCH", `/suggestions/${encodeURIComponent(s.id)}/trial`, s.trial);
         v2.writeSuggestion({ ...v2.readSuggestion(s.id) ?? s, trialDirty: false });
         report.trialUpdates++;
       } catch (err) {
@@ -4358,7 +4385,7 @@ async function syncV2(store, opts = {}) {
       const q = new URLSearchParams();
       if (previous?.generatedAt) q.set("since", previous.generatedAt);
       if (previous?.libraryVersion && previous.sections.length) q.set("have", String(previous.libraryVersion));
-      const bundle = await call("GET", `/bundle${q.size ? `?${q}` : ""}`);
+      const bundle = await call2("GET", `/bundle${q.size ? `?${q}` : ""}`);
       if (bundle && Array.isArray(bundle.sections)) {
         const next = bundle.unchanged && previous ? { ...bundle, sections: previous.sections, unchanged: void 0 } : bundle;
         delete next.unchanged;
@@ -5809,7 +5836,10 @@ function mark(v2, sessionId, cwd, field, ids) {
   try {
     v2.updateSession(sessionId, cwd, (s) => {
       addUnique(s.served, ...ids);
-      if (field === "loaded") addUnique(s.loaded, ...ids);
+      if (field === "loaded") {
+        addUnique(s.loaded, ...ids);
+        if (s.inContext) addUnique(s.inContext, ...ids);
+      }
       s.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
     });
   } catch {
@@ -8147,9 +8177,276 @@ Common flags: --api-url URL (default: this project's, else https://api.bunshin.c
   }
 });
 
+// src/v2/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  ROUTINE_PROMPT: () => ROUTINE_PROMPT,
+  cmdRunner: () => cmdRunner,
+  connection: () => connection,
+  renderJob: () => renderJob,
+  runOnce: () => runOnce,
+  setupText: () => setupText
+});
+import fs23 from "node:fs";
+import os5 from "node:os";
+function connection(args, cwd) {
+  const store = 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(/\/$/, "");
+  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"}`;
+  return { apiUrl, key, name: name.replace(/[^\w.:@/-]/g, "-").slice(0, 80) };
+}
+async function call(c, method, route, body, timeoutMs = 6e4) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${c.apiUrl}/v1/runner${route}`, {
+      method,
+      headers: { authorization: `Bearer ${c.key}`, "content-type": "application/json" },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+      signal: ctrl.signal
+    });
+    const text2 = await res.text();
+    const parsed = text2 ? JSON.parse(text2) : null;
+    if (res.status >= 400 && res.status !== 409) throw new Error(`${method} /v1/runner${route}: ${res.status} ${text2.slice(0, 200)}`);
+    return { status: res.status, body: parsed };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function kindsOf(args) {
+  const k = str5(args.flags.kinds);
+  if (!k) return void 0;
+  const list2 = k.split(",").map((x) => x.trim()).filter(Boolean);
+  for (const x of list2) if (!KINDS2.includes(x)) throw new Error(`--kinds: ${x} is not one of ${KINDS2.join(", ")}`);
+  return list2;
+}
+async function lease(c, args, max = 1) {
+  const kinds = kindsOf(args);
+  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";
+  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 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 } : {} };
+}
+async function runOnce(c, args, out, err) {
+  const config = modelConfig(args);
+  const max = Number(str5(args.flags.max) ?? 200);
+  let done = 0;
+  let failed = 0;
+  for (let i = 0; i < max; i++) {
+    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 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 });
+      err(`${job.id} ${job.kind}: ${res.error.slice(0, 160)} (${r2.body.status})
+`);
+      failed++;
+      if (r2.body.status === "retry" && /no LLM backend|not found|ENOENT/.test(res.error)) break;
+      continue;
+    }
+    const r = await call(c, "POST", `/jobs/${job.id}/answer`, { answer: res.value, model, runner: c.name }, 12e4);
+    out(`${job.id} ${job.kind}: ${r.body.status}${r.body.error ? ` (${r.body.error})` : ""} in ${Math.round((Date.now() - started) / 1e3)}s via ${res.backend}
+`);
+    if (r.body.status === "done" || r.body.status === "stale") done++;
+    else failed++;
+  }
+  return { done, failed };
+}
+function renderJob(job) {
+  return `JOB ${job.id} (${job.kind}), attempt ${job.attempts}, answer before ${job.leaseUntil}
+
+===== SYSTEM =====
+${job.system}
+
+===== TASK =====
+${job.prompt}
+
+===== HOW TO ANSWER =====
+You are the model for this job. Read the task above and decide it yourself; do not run other
+tools to answer it. Write ONLY the JSON object it asks for to a file, then run:
+
+  bunshin runner submit ${job.id} <file>
+
+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 setupText(target) {
+  switch (target) {
+    case "claude-routine":
+      return `Claude Code routine (claude.ai/code \u2192 Routines, or /schedule in Claude Code)
+
+1. Console \u2192 Runners \u2192 New runner key. Copy it.
+2. Create an environment for the routine with:
+     BUNSHIN_RUNNER_KEY=<the runner key>
+     BUNSHIN_API_URL=https://api.bunshin.cc
+   and network access to api.bunshin.cc and registry.npmjs.org. No repository is needed.
+3. Create a routine on that environment, daily (e.g. 03:17), with this prompt:
+
+${ROUTINE_PROMPT.replace(/^/gm, "   ")}
+
+The routine's own model (Opus 5.5) answers the jobs; nothing else needs a key.
+`;
+    case "codex-cloud":
+      return `Codex cloud task (chatgpt.com/codex)
+
+1. Console \u2192 Runners \u2192 New runner key. Copy it.
+2. In the Codex environment, add the secret BUNSHIN_RUNNER_KEY and the variable
+   BUNSHIN_API_URL=https://api.bunshin.cc; allow internet access to api.bunshin.cc and
+   registry.npmjs.org.
+3. Run a task (schedule it daily if your plan allows) with this prompt:
+
+${ROUTINE_PROMPT.replace(/^/gm, "   ")}
+`;
+    case "github-action":
+      return `GitHub Actions: a daily workflow on your Claude subscription (no API key)
+
+1. Console \u2192 Runners \u2192 New runner key \u2192 repository secret BUNSHIN_RUNNER_KEY.
+2. \`claude setup-token\` on your machine \u2192 repository secret CLAUDE_CODE_OAUTH_TOKEN.
+   (Codex instead: secret OPENAI_API_KEY, install @openai/codex, --backend codex-cli.)
+3. .github/workflows/bunshin-runner.yml:
+
+name: Bunshin runner
+on:
+  schedule: [{ cron: "17 3 * * *" }]
+  workflow_dispatch: {}
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      - run: npm i -g @anthropic-ai/claude-code @bunshin-cc/bunshin
+      - run: bunshin runner --once --backend claude-cli --model "claude-opus-5-5[1m]" --name github-actions
+        env:
+          BUNSHIN_RUNNER_KEY: \${{ secrets.BUNSHIN_RUNNER_KEY }}
+          BUNSHIN_API_URL: https://api.bunshin.cc
+          CLAUDE_CODE_OAUTH_TOKEN: \${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+`;
+    case "docker":
+      return `A container that keeps the queue drained (Cloudflare Containers, Fly, any box)
+
+FROM node:22-slim
+RUN npm i -g @bunshin-cc/bunshin @anthropic-ai/claude-code @openai/codex
+ENV BUNSHIN_API_URL=https://api.bunshin.cc
+# Provide BUNSHIN_RUNNER_KEY and the model's credentials (CLAUDE_CODE_OAUTH_TOKEN, or
+# ANTHROPIC_API_KEY, or OPENAI_API_KEY for codex) as secrets at run time.
+CMD ["bunshin", "runner", "--watch", "--backend", "claude-cli", "--model", "claude-opus-5-5[1m]", "--name", "container"]
+`;
+    case "cron":
+      return `cron on any machine with claude, codex or pi signed in
+
+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
+
+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)
+  OPENAI_API_KEY + BUNSHIN_OPENAI_MODEL      (BUNSHIN_LLM_PROVIDER=openai)
+  OPENROUTER_API_KEY + BUNSHIN_OPENROUTER_MODEL (BUNSHIN_LLM_PROVIDER=openrouter)
+`;
+  }
+}
+async function cmdRunner(args, cwd, out, err) {
+  const sub = args._[1] ?? "";
+  if (sub === "setup") {
+    out(setupText(args._[2] ?? ""));
+    return 0;
+  }
+  const c = connection(args, cwd);
+  if (sub === "status") {
+    const s = (await call(c, "GET", "/status")).body;
+    if (args.flags.json) {
+      out(`${JSON.stringify(s, null, 2)}
+`);
+      return 0;
+    }
+    out(`server: ${s.executor.provider ? `${s.executor.provider} (${s.executor.model})` : `none (${s.executor.reason})`}
+`);
+    for (const [kind, by] of Object.entries(s.counts)) out(`${kind.padEnd(8)} ${Object.entries(by).map(([k, n]) => `${k} ${n}`).join(" \xB7 ")}
+`);
+    for (const r of s.runners) out(`runner ${r.name}: ${r.done} done, last ${r.lastSeen}${r.model ? `, ${r.model}` : ""}
+`);
+    return 0;
+  }
+  if (sub === "next") {
+    const [job] = await lease(c, args);
+    if (!job) {
+      out("No jobs.\n");
+      return 0;
+    }
+    out(args.flags.json ? `${JSON.stringify(job, null, 2)}
+` : renderJob(job));
+    return 0;
+  }
+  if (sub === "submit") {
+    const id = args._[2];
+    const file = args._[3] ?? "-";
+    if (!id) throw new Error("usage: bunshin runner submit <job id> <file|->");
+    const text2 = file === "-" ? fs23.readFileSync(0, "utf8") : fs23.readFileSync(file, "utf8");
+    const model = str5(args.flags.model) ?? process.env.BUNSHIN_MODEL ?? "agent";
+    const r = await call(c, "POST", `/jobs/${id}/answer`, { answer: text2, model, runner: c.name }, 12e4);
+    out(`${id}: ${r.body.status}${r.body.error ? ` (${r.body.error})` : ""}
+`);
+    return r.body.status === "done" || r.body.status === "stale" ? 0 : 1;
+  }
+  if (sub === "fail") {
+    const id = args._[2];
+    if (!id) throw new Error("usage: bunshin runner fail <job id> --error <why>");
+    const r = await call(c, "POST", `/jobs/${id}/fail`, { error: str5(args.flags.error) ?? "the runner could not answer", runner: c.name });
+    out(`${id}: ${r.body.status}
+`);
+    return 0;
+  }
+  if (sub && sub !== "run") throw new Error(`unknown runner command "${sub}" (run, next, submit, fail, status, setup)`);
+  const watch = args.flags.watch === true;
+  const interval = Number(str5(args.flags.interval) ?? 300) * 1e3;
+  for (; ; ) {
+    const r = await runOnce(c, args, out, err);
+    if (!watch) {
+      out(`runner: ${r.done} answered, ${r.failed} failed
+`);
+      return r.failed && !r.done ? 1 : 0;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+}
+var DEFAULT_API, KINDS2, str5, NPX, ROUTINE_PROMPT;
+var init_runner = __esm({
+  "src/v2/runner.ts"() {
+    "use strict";
+    init_llm();
+    init_store();
+    DEFAULT_API = "https://api.bunshin.cc";
+    KINDS2 = ["reflect", "merge", "create"];
+    str5 = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+    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.
+
+1. Run: ${NPX} runner next
+2. If it prints "No jobs", stop: you are done.
+3. Otherwise it prints one job. Do exactly what its TASK asks: you are the model, so think it
+   through yourself; do not edit any repository. Write only the JSON answer to /tmp/bunshin-answer.json.
+4. Run: ${NPX} runner submit <job id> /tmp/bunshin-answer.json
+5. Go back to step 1. Stop after 40 jobs.`;
+  }
+});
+
 // src/v2/importer.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 import path20 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");
@@ -8287,7 +8584,7 @@ function isGitRepo(root) {
 function workingTreeFiles(root) {
   const out = /* @__PURE__ */ new Map();
   const list2 = isGitRepo(root) ? git3(root, ["ls-files", "-z"]).split("\0").filter(Boolean) : (function walk(dir, base = "") {
-    return fs23.readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+    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] : [];
@@ -8297,12 +8594,12 @@ function workingTreeFiles(root) {
     const abs = path20.join(root, rel);
     let buf;
     try {
-      buf = fs23.readFileSync(abs);
+      buf = fs24.readFileSync(abs);
     } catch {
       continue;
     }
     if (!isText(buf)) continue;
-    const exec = (fs23.statSync(abs).mode & 73) !== 0;
+    const exec = (fs24.statSync(abs).mode & 73) !== 0;
     out.set(rel, { content: buf.toString("utf8"), ...exec ? { mode: "x" } : {} });
   }
   return out;
@@ -8449,7 +8746,7 @@ __export(skills_exports, {
   cmdSkill: () => cmdSkill,
   parsePin: () => parsePin
 });
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import path21 from "node:path";
 function requireOnline(store, what) {
   if (!canCall(store.config())) throw new Error(`${what} needs the hosted library: run \`bunshin setup\` first`);
@@ -8460,10 +8757,10 @@ async function cmdImport2(store, args, cwd, out, err) {
     return 1;
   }
   const root = path21.resolve(cwd, args._[2]);
-  if (!fs24.existsSync(root)) throw new Error(`${root} does not exist`);
-  const pack = str5(args.flags.pack) ?? path21.basename(root);
+  if (!fs25.existsSync(root)) throw new Error(`${root} does not exist`);
+  const pack = str6(args.flags.pack) ?? path21.basename(root);
   const history = args.flags.history !== false && !bool4(args.flags["no-history"]);
-  const read = readSkillSystem(root, { pack, history, ...str5(args.flags.since) ? { since: str5(args.flags.since) } : {} });
+  const read = readSkillSystem(root, { pack, history, ...str6(args.flags.since) ? { since: str6(args.flags.since) } : {} });
   const kinds = /* @__PURE__ */ new Map();
   for (const d of read.docs) {
     const label2 = d.delivery === "always" ? "instructions" : d.delivery === "stop" ? "learning check" : d.kind;
@@ -8479,7 +8776,7 @@ async function cmdImport2(store, args, cwd, out, err) {
   }
   requireOnline(store, "bunshin import");
   const config = store.config();
-  const body = { pack, ...str5(args.flags.layer) ? { layer: str5(args.flags.layer) } : {}, ...str5(args.flags["owner-team"]) ? { ownerTeam: str5(args.flags["owner-team"]) } : {} };
+  const body = { pack, ...str6(args.flags.layer) ? { layer: str6(args.flags.layer) } : {}, ...str6(args.flags["owner-team"]) ? { ownerTeam: str6(args.flags["owner-team"]) } : {} };
   let written = 0;
   let last = null;
   const batches = batchVersions(read.versions);
@@ -8607,7 +8904,7 @@ async function cmdSkill(store, args, cwd, out, err) {
     }
     case "log": {
       requireOnline(store, "bunshin skill log");
-      const since = str5(args.flags.since);
+      const since = str6(args.flags.since);
       const cutoff = since ? sinceCutoff(since) : 0;
       const targets = args._[2] ? [byName(args._[2])].filter((x) => !!x) : skills;
       if (!targets.length) throw new Error(`no skill ${args._[2]}`);
@@ -8634,9 +8931,9 @@ async function cmdSkill(store, args, cwd, out, err) {
 ${report.skills} skills, ${report.references} references, ${report.errors.length} errors, ${report.warnings.length} warnings
 `);
       }
-      const graph = str5(args.flags.graph) ?? (bool4(args.flags.graph) ? "SKILLS-GRAPH.md" : void 0);
+      const graph = str6(args.flags.graph) ?? (bool4(args.flags.graph) ? "SKILLS-GRAPH.md" : void 0);
       if (graph) {
-        fs24.writeFileSync(path21.resolve(cwd, graph), renderSkillGraph(report));
+        fs25.writeFileSync(path21.resolve(cwd, graph), renderSkillGraph(report));
         out(`graph written to ${graph}
 `);
       }
@@ -8645,7 +8942,7 @@ ${report.skills} skills, ${report.references} references, ${report.errors.length
     case "push": {
       const ctx = contextFor(v2, config);
       const name = args._[2];
-      const layer = str5(args.flags.layer);
+      const layer = str6(args.flags.layer);
       const captured = captureEdits(v2, config, ctx, { libraryNames: skills.map((s) => s.skill.name), ...layer ? { newSkillLayer: layer } : {}, ...name && !byName(name) ? { newSkill: name } : {} });
       for (const c of captured) out(`proposed: ${c.name}
 `);
@@ -8696,7 +8993,7 @@ async function cmdLibrary(store, args, cwd, out, err) {
     }
     case "log": {
       requireOnline(store, "bunshin library log");
-      const res = await v2api(config, "GET", `/library?limit=${Number(str5(args.flags.limit) ?? 30) || 30}`);
+      const res = await v2api(config, "GET", `/library?limit=${Number(str6(args.flags.limit) ?? 30) || 30}`);
       for (const v of res.versions) out(`lib@${String(v.version).padEnd(5)} ${v.createdAt.slice(0, 16).replace("T", " ")}  ${v.source.padEnd(8)} ${v.gitCommit ? `${v.gitCommit.slice(0, 10)} ` : ""}${v.summary} (${v.sectionIds.length} documents)
 `);
       return 0;
@@ -8733,27 +9030,27 @@ async function cmdLibrary(store, args, cwd, out, err) {
       const res = await v2api(config, "GET", "/library?limit=1");
       const line = `bunshin: lib@${res.version}
 `;
-      const file = str5(args.flags.write) ?? (bool4(args.flags.write) ? ".claude/skills-version" : void 0);
+      const file = str6(args.flags.write) ?? (bool4(args.flags.write) ? ".claude/skills-version" : void 0);
       if (file) {
         const abs = path21.resolve(cwd, file);
-        fs24.mkdirSync(path21.dirname(abs), { recursive: true });
-        fs24.writeFileSync(abs, line);
+        fs25.mkdirSync(path21.dirname(abs), { recursive: true });
+        fs25.writeFileSync(abs, line);
         out(`${file}: ${line}`);
       } else out(line);
       return 0;
     }
     case "checkout": {
       requireOnline(store, "bunshin library checkout");
-      const to = str5(args.flags.to);
+      const to = str6(args.flags.to);
       if (!to) throw new Error("--to <dir> is required");
-      const pinFile = str5(args.flags.pin);
-      const pin = str5(args.flags.git) ? { git: str5(args.flags.git) } : pinFile ? parsePin(fs24.readFileSync(path21.resolve(cwd, pinFile), "utf8")) : parsePin(args._[2] ?? "");
+      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 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);
-      if (fs24.existsSync(dir) && fs24.readdirSync(dir).length && !bool4(args.flags.force)) throw new Error(`${dir} is not empty (use --force)`);
-      const pack = str5(args.flags.pack);
+      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);
       const res = materialize(docs, dir);
       out(`lib@${snap.version}${pin.git ? ` (commit ${pin.git})` : ""}: ${res.files} files in ${dir}
@@ -8766,7 +9063,7 @@ async function cmdLibrary(store, args, cwd, out, err) {
       return 1;
   }
 }
-var str5, bool4, skillsOf;
+var str6, bool4, skillsOf;
 var init_skills = __esm({
   "src/v2/skills.ts"() {
     "use strict";
@@ -8778,7 +9075,7 @@ var init_skills = __esm({
     init_store2();
     init_sync();
     init_view();
-    str5 = (v) => typeof v === "string" ? v : void 0;
+    str6 = (v) => typeof v === "string" ? v : void 0;
     bool4 = (v) => v === true || v === "true";
     skillsOf = (sections) => sections.filter((s) => s.skill && (s.status === "active" || s.status === "stale"));
   }
@@ -8791,7 +9088,7 @@ __export(reflect_exports, {
   buildLesson: () => buildLesson,
   runReflection: () => runReflection
 });
-import fs25 from "node:fs";
+import fs26 from "node:fs";
 import path22 from "node:path";
 import { createHash as createHash7 } from "node:crypto";
 async function runReflection(store, opts) {
@@ -8800,18 +9097,18 @@ async function runReflection(store, opts) {
   const deadline = Date.now() + 66e4;
   for (; ; ) {
     try {
-      fs25.writeFileSync(lock, String(process.pid), { flag: "wx", mode: 384 });
+      fs26.writeFileSync(lock, String(process.pid), { flag: "wx", mode: 384 });
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       try {
-        const owner = Number(fs25.readFileSync(lock, "utf8"));
+        const owner = Number(fs26.readFileSync(lock, "utf8"));
         if (Number.isInteger(owner) && owner > 0) {
           try {
             process.kill(owner, 0);
           } catch (error2) {
             if (error2.code === "ESRCH") {
-              fs25.unlinkSync(lock);
+              fs26.unlinkSync(lock);
               continue;
             }
           }
@@ -8826,7 +9123,7 @@ async function runReflection(store, opts) {
     return await reflectSession(store, opts);
   } finally {
     try {
-      fs25.unlinkSync(lock);
+      fs26.unlinkSync(lock);
     } catch {
     }
   }
@@ -9168,11 +9465,11 @@ __export(cli_exports, {
   parseArgs: () => parseArgs,
   version: () => version
 });
-import fs26 from "node:fs";
+import fs27 from "node:fs";
 import path23 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"]);
+  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"]);
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--") {
@@ -9215,7 +9512,7 @@ function version() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
       const file = new URL(rel, import.meta.url);
-      const pkg = JSON.parse(fs26.readFileSync(file, "utf8"));
+      const pkg = JSON.parse(fs27.readFileSync(file, "utf8"));
       if (pkg.name === "@bunshin-cc/bunshin" && pkg.version) return pkg.version;
     } catch {
     }
@@ -9238,13 +9535,13 @@ async function main(argv, opts = {}) {
     return 0;
   }
   if (cmd === "hook") {
-    const root = str6(args.flags.root);
+    const root = str7(args.flags.root);
     return hookCommand(args._[1], { cwd, store: root ? new Store(root) : void 0, write: out });
   }
   if (cmd === "setup" && bool5(args.flags.robot)) {
     try {
       const { setupRobot: setupRobot2, robotAttrsFromFlags: robotAttrsFromFlags2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
-      const robotId = str6(args.flags["robot-id"]);
+      const robotId = str7(args.flags["robot-id"]);
       if (!robotId) throw new Error("--robot-id <id> is required with --robot");
       const apiKey = bool5(args.flags["key-stdin"]) ? await new Promise((resolve, reject) => {
         let value = "";
@@ -9255,9 +9552,9 @@ async function main(argv, opts = {}) {
         process.stdin.on("end", () => resolve(value.trim()));
         process.stdin.on("error", reject);
       }) : process.env.BUNSHIN_API_KEY || void 0;
-      const harnessFlag = str6(args.flags.harness);
+      const harnessFlag = str7(args.flags.harness);
       if (harnessFlag && !["claude-code", "codex", "pi", "other"].includes(harnessFlag)) throw new Error("--harness must be claude-code, codex, pi or other");
-      const res = await setupRobot2({ cwd, robotId, robot: robotAttrsFromFlags2(args.flags), apiUrl: str6(args.flags["api-url"]), apiKey, ...harnessFlag ? { harness: harnessFlag } : {} });
+      const res = await setupRobot2({ cwd, robotId, robot: robotAttrsFromFlags2(args.flags), apiUrl: str7(args.flags["api-url"]), apiKey, ...harnessFlag ? { harness: harnessFlag } : {} });
       out(`Robot context ${res.context.id} (${res.context.robot?.armModel} / ${res.context.robot?.mount}, ${res.context.robot?.domain} @ ${res.context.robot?.site}/${res.context.robot?.cell})
 `);
       out(`  store:      ${res.store.root}/v2/context.json
@@ -9276,12 +9573,12 @@ async function main(argv, opts = {}) {
   if (cmd === "setup") {
     try {
       const { setupProject: setupProject2, executable: executable2, readKey: readKey2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
-      const harness = str6(args.flags.harness);
+      const harness = str7(args.flags.harness);
       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 apiUrl = str6(args.flags["api-url"]);
+      const apiUrl = str7(args.flags["api-url"]);
       const key = bool5(args.flags["key-stdin"]) ? await new Promise((resolve, reject) => {
         let value = "";
         process.stdin.setEncoding("utf8");
@@ -9322,7 +9619,7 @@ Key saved privately outside the project.
   if (cmd === "init") return cmdInit(args, cwd, out, err);
   if (cmd === "mcp") {
     const { runMcpServer: runMcpServer2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-    const root = str6(args.flags.root);
+    const root = str7(args.flags.root);
     await runMcpServer2({ cwd, ...root ? { store: new Store(path23.resolve(root)) } : {}, version: version() });
     return 0;
   }
@@ -9332,6 +9629,15 @@ Key saved privately outside the project.
     return 0;
   }
   if (cmd === "repo") return (await Promise.resolve().then(() => (init_gitrepo(), gitrepo_exports))).cmdRepo(args, cwd, out, err);
+  if (cmd === "runner") {
+    try {
+      return await (await Promise.resolve().then(() => (init_runner(), runner_exports))).cmdRunner(args, cwd, out, err);
+    } catch (e) {
+      err(`bunshin runner: ${e instanceof Error ? e.message : String(e)}
+`);
+      return 1;
+    }
+  }
   const store = openStore(args, cwd);
   if (!store) {
     err("bunshin: this project is not connected. Run `bunshin setup --harness codex` (or use --harness claude-code / --harness pi). For offline use, run `bunshin init`.\n");
@@ -9395,7 +9701,7 @@ ${HELP2}`);
   }
 }
 function openStore(args, cwd) {
-  const root = str6(args.flags.root);
+  const root = str7(args.flags.root);
   if (root) {
     const store = new Store(path23.resolve(root));
     store.ensureLayout();
@@ -9405,21 +9711,21 @@ function openStore(args, cwd) {
 }
 async function cmdInit(args, cwd, out, err) {
   const { runInit: runInit2, otherHarnessInstructions: otherHarnessInstructions2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  const harness = str6(args.flags.harness);
+  const harness = str7(args.flags.harness);
   const result = runInit2({
     cwd,
-    role: str6(args.flags.role),
-    orgUnit: str6(args.flags["org-unit"]),
-    orgId: str6(args.flags["org-id"]),
-    userId: str6(args.flags["user-id"]),
-    apiUrl: str6(args.flags["api-url"]),
-    apiKey: str6(args.flags["api-key"]),
-    scope: bool5(args.flags.global) ? "global" : str6(args.flags.scope),
+    role: str7(args.flags.role),
+    orgUnit: str7(args.flags["org-unit"]),
+    orgId: str7(args.flags["org-id"]),
+    userId: str7(args.flags["user-id"]),
+    apiUrl: str7(args.flags["api-url"]),
+    apiKey: str7(args.flags["api-key"]),
+    scope: bool5(args.flags.global) ? "global" : str7(args.flags.scope),
     harness,
     noHooks: args.flags.hooks === false || bool5(args.flags["no-hooks"]),
     removeHooks: bool5(args.flags["remove-hooks"]),
-    settingsFile: str6(args.flags["settings-file"]),
-    bin: str6(args.flags.bin)
+    settingsFile: str7(args.flags["settings-file"]),
+    bin: str7(args.flags.bin)
   });
   if (bool5(args.flags.json)) {
     out(JSON.stringify({ ...result, config: { ...result.config, apiKey: void 0 } }, null, 2) + "\n");
@@ -9459,7 +9765,7 @@ function cmdStatus(store, args, out, v2) {
   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 hooks = config.harness === "pi" ? hookFiles.filter((file) => {
     try {
-      return fs26.readFileSync(file, "utf8").startsWith("// Managed by Bunshin setup.");
+      return fs27.readFileSync(file, "utf8").startsWith("// Managed by Bunshin setup.");
     } catch {
       return false;
     }
@@ -9476,7 +9782,7 @@ function cmdStatus(store, args, out, v2) {
     mothership: config.apiUrl ? { apiUrl: config.apiUrl, key: config.apiKey ? "set" : "missing", lastSyncAt: config.lastSyncAt ?? null } : null,
     llmBackend: resolveBackend(config) ?? "none (set ANTHROPIC_API_KEY or install the claude/codex CLI)",
     hooks: { [config.harness]: hooks },
-    hookFiles: hookFiles.filter((file) => fs26.existsSync(file)),
+    hookFiles: hookFiles.filter((file) => fs27.existsSync(file)),
     recallQuality: last50 ? { precision: last50.precision, recall: last50.recall, f1: last50.f1, traces: last50.traces } : null,
     v2
   };
@@ -9517,7 +9823,7 @@ function cmdStatus(store, args, out, v2) {
 }
 function hookCount(file) {
   try {
-    const raw = JSON.parse(fs26.readFileSync(file, "utf8"));
+    const raw = JSON.parse(fs27.readFileSync(file, "utf8"));
     let n = 0;
     for (const groups of Object.values(raw.hooks ?? {})) {
       for (const g of groups ?? []) {
@@ -9530,22 +9836,22 @@ function hookCount(file) {
   }
 }
 async function cmdRecall2(store, args, cwd, out, err) {
-  const task = args._.slice(1).join(" ").trim() || str6(args.flags.task) || "";
+  const task = args._.slice(1).join(" ").trim() || str7(args.flags.task) || "";
   if (!task) {
     err('bunshin recall: a task is required, e.g. bunshin recall "close an account with a negative balance"\n');
     return 1;
   }
   const { runRecall: runRecall2 } = await Promise.resolve().then(() => (init_recall3(), recall_exports));
-  const sessionId = str6(args.flags.session);
+  const sessionId = str7(args.flags.session);
   const dryRun = bool5(args.flags["dry-run"]) || !sessionId && !bool5(args.flags.apply);
   const result = await runRecall2(store, {
     sessionId: sessionId ?? `cli-${Date.now()}`,
     prompt: task,
     cwd,
-    transcriptPath: str6(args.flags.transcript),
+    transcriptPath: str7(args.flags.transcript),
     dryRun,
     offline: bool5(args.flags.offline),
-    budgetMs: str6(args.flags["budget-ms"]) ? Math.max(1, Number(args.flags["budget-ms"]) || 1) : void 0
+    budgetMs: str7(args.flags["budget-ms"]) ? Math.max(1, Number(args.flags["budget-ms"]) || 1) : void 0
   });
   if (bool5(args.flags.json)) {
     out(JSON.stringify({ served: result.served.map((l) => ({ id: l.id, kind: l.kind, title: l.title, gist: l.gist })), trace: result.trace, reasoning: result.reasoning, degraded: result.degraded, text: result.text }, null, 2) + "\n");
@@ -9596,8 +9902,8 @@ function cmdLessons(store, args, out, err) {
     return 0;
   }
   if (sub === "add") return cmdLessonAdd(store, args, out, err);
-  const kind = str6(args.flags.kind);
-  const q = str6(args.flags.q) ?? (sub === "list" ? args._.slice(2).join(" ") : args._.slice(1).join(" "));
+  const kind = str7(args.flags.kind);
+  const q = str7(args.flags.q) ?? (sub === "list" ? args._.slice(2).join(" ") : args._.slice(1).join(" "));
   const qTerms = q ? terms(q) : [];
   let lessons = store.listLessons().filter((l) => l.status !== "retired" && l.status !== "superseded");
   if (kind) lessons = lessons.filter((l) => l.kind === kind);
@@ -9629,23 +9935,23 @@ ${lessons.length} lesson(s). \`bunshin lessons show <id>\` for the full body.
   return 0;
 }
 function cmdLessonAdd(store, args, out, err) {
-  const title = str6(args.flags.title);
+  const title = str7(args.flags.title);
   if (!title) {
     err('bunshin lessons add: --title is required (e.g. --title "Collections closes negative balances by hand")\n');
     return 1;
   }
-  let content = str6(args.flags.content) ?? "";
+  let content = str7(args.flags.content) ?? "";
   if (!content || content === "-" || args._.includes("-")) {
     try {
-      content = fs26.readFileSync(0, "utf8");
+      content = fs27.readFileSync(0, "utf8");
     } catch {
     }
   }
   const config = store.config();
   const now = nowIso();
-  const kind = str6(args.flags.kind) ?? "fact";
-  const gist = str6(args.flags.gist) ?? content.split("\n").find((l) => l.trim())?.slice(0, 200) ?? title;
-  const tags = (str6(args.flags.tags) ?? "").split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+  const kind = str7(args.flags.kind) ?? "fact";
+  const gist = str7(args.flags.gist) ?? content.split("\n").find((l) => l.trim())?.slice(0, 200) ?? title;
+  const tags = (str7(args.flags.tags) ?? "").split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
   const base = {
     id: newId("l"),
     title,
@@ -9653,7 +9959,7 @@ function cmdLessonAdd(store, args, out, err) {
     tags,
     content: content.trim(),
     status: "active",
-    clearance: str6(args.flags.clearance) ?? "org",
+    clearance: str7(args.flags.clearance) ?? "org",
     provenance: {
       orgId: config.orgId,
       userId: config.userId,
@@ -9666,7 +9972,7 @@ function cmdLessonAdd(store, args, out, err) {
     version: 1,
     updatedAt: now
   };
-  const lesson = kind === "workflow" ? { ...base, kind: "workflow", preconditions: [], steps: [], outcome: str6(args.flags.outcome) ?? "Task completed as described." } : { ...base, kind: "fact" };
+  const lesson = kind === "workflow" ? { ...base, kind: "workflow", preconditions: [], steps: [], outcome: str7(args.flags.outcome) ?? "Task completed as described." } : { ...base, kind: "fact" };
   store.saveLesson(lesson);
   if (bool5(args.flags.json)) out(JSON.stringify(lesson, null, 2) + "\n");
   else out(`Added ${lesson.id} [${lesson.kind}] ${lesson.title}
@@ -9696,14 +10002,14 @@ function renderLessonDetail(l) {
   return lines.join("\n") + "\n";
 }
 async function cmdReflect(store, args, cwd, out, err) {
-  const transcript = args._[1] ?? str6(args.flags.transcript);
+  const transcript = args._[1] ?? str7(args.flags.transcript);
   if (!transcript) {
     err("bunshin reflect: a transcript path is required\n");
     return 1;
   }
   const { runReflection: runReflection2 } = await Promise.resolve().then(() => (init_reflect4(), reflect_exports));
   const result = await runReflection2(store, {
-    sessionId: str6(args.flags.session) ?? path23.basename(transcript).replace(/\.jsonl?$/, ""),
+    sessionId: str7(args.flags.session) ?? path23.basename(transcript).replace(/\.jsonl?$/, ""),
     transcriptPath: transcript,
     cwd,
     force: bool5(args.flags.force)
@@ -9771,13 +10077,13 @@ async function cmdConflict(store, args, out, err) {
   const sub = args._[1] ?? "list";
   if (sub === "resolve") {
     const id = args._[2];
-    const answer = args._.slice(3).join(" ").trim() || str6(args.flags.answer) || "";
+    const answer = args._.slice(3).join(" ").trim() || str7(args.flags.answer) || "";
     if (!id || !answer) {
       err('bunshin conflict resolve: usage: bunshin conflict resolve <id> "<answer>"\n');
       return 1;
     }
     const { resolveConflict: resolveConflict2 } = await Promise.resolve().then(() => (init_sync2(), sync_exports2));
-    const resolved = await resolveConflict2(store, id, answer, str6(args.flags.note));
+    const resolved = await resolveConflict2(store, id, answer, str7(args.flags.note));
     if (bool5(args.flags.json)) out(JSON.stringify(resolved, null, 2) + "\n");
     else out(`Resolved ${resolved.id}: ${answer}
 `);
@@ -9809,7 +10115,7 @@ async function cmdConflict(store, args, out, err) {
 function store0HasKey(store) {
   return !!store.config().apiKey;
 }
-var str6, bool5, HELP2;
+var str7, bool5, HELP2;
 var init_cli = __esm({
   "src/cli.ts"() {
     "use strict";
@@ -9818,7 +10124,7 @@ var init_cli = __esm({
     init_store();
     init_util();
     init_project_hooks();
-    str6 = (v) => typeof v === "string" ? v : void 0;
+    str7 = (v) => typeof v === "string" ? v : void 0;
     bool5 = (v) => v === true || v === "true";
     HELP2 = `bunshin \u2014 shadow-clone memory for coding agents and robots
 
@@ -9870,6 +10176,12 @@ Usage: bunshin <command> [options]
   repo import|attach|clone|verify|list|url|login
                                 host a git repository in Bunshin (full history; git push/pull
                                 keep working through git-remote-bunshin). bunshin repo help
+  runner [--once|--watch] [--backend auto|sdk|claude-cli|codex-cli|pi-cli] [--model <m>] [--kinds reflect,merge,create]
+                                answer the company's queued model work (cloud reflection,
+                                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]
   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.4.8",
+  "version": "0.5.0",
   "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
   "type": "module",
   "bin": {