wildcrane-runner 0.6.13 → 0.6.15

package/dist/akb/dist/kanban.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// ai4kanban 0.11.10 — built by runner/scripts/build.mjs. Do not edit.
+// ai4kanban 0.11.12 — built by runner/scripts/build.mjs. Do not edit.
 import { createRequire as __ai4kanbanRequire } from 'node:module'
 const require = __ai4kanbanRequire(import.meta.url)
 var __create = Object.create;
@@ -1167,8 +1167,8 @@ var require_command = __commonJS({
   "../cli/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path85 = __require("node:path");
-    var fs86 = __require("node:fs");
+    var path87 = __require("node:path");
+    var fs87 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2149,7 +2149,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs86.existsSync(executableFile)) return;
+        if (fs87.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2167,11 +2167,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path85.resolve(baseDir, baseName);
-          if (fs86.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path85.extname(baseName))) return void 0;
+          const localBin = path87.resolve(baseDir, baseName);
+          if (fs87.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path87.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs86.existsSync(`${localBin}${ext}`)
+            (ext) => fs87.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2183,21 +2183,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs86.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs87.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path85.resolve(
-            path85.dirname(resolvedScriptPath),
+          executableDir = path87.resolve(
+            path87.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path85.basename(
+            const legacyName = path87.basename(
               this._scriptPath,
-              path85.extname(this._scriptPath)
+              path87.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2208,7 +2208,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path85.extname(executableFile));
+        launchWithNode = sourceExt.includes(path87.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3055,7 +3055,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path85.basename(filename, path85.extname(filename));
+        this._name = path87.basename(filename, path87.extname(filename));
         return this;
       }
       /**
@@ -3069,9 +3069,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path86) {
-        if (path86 === void 0) return this._executableDir;
-        this._executableDir = path86;
+      executableDir(path88) {
+        if (path88 === void 0) return this._executableDir;
+        this._executableDir = path88;
         return this;
       }
       /**
@@ -3754,192 +3754,6 @@ var init_env = __esm({
   }
 });
 
-// ../cli/src/lib/lock.ts
-import { randomUUID } from "node:crypto";
-import fs4 from "node:fs";
-import path5 from "node:path";
-function sleep(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function ageOf(dir) {
-  try {
-    return Date.now() - fs4.statSync(dir).mtimeMs;
-  } catch {
-    return 0;
-  }
-}
-function pidAlive(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return e.code === "EPERM";
-  }
-}
-function ownerOf(dir) {
-  try {
-    const pid = Number(fs4.readFileSync(path5.join(dir, OWNER), "utf8").trim());
-    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function claimBreak(dir) {
-  try {
-    fs4.mkdirSync(path5.join(dir, BREAKING));
-    return true;
-  } catch {
-    return false;
-  }
-}
-function removeClaim(dir, token3) {
-  if (token3) {
-    try {
-      fs4.unlinkSync(path5.join(dir, token3));
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-  try {
-    fs4.rmdirSync(dir);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") return true;
-    if (code === "ENOTEMPTY" || code === "EEXIST") return false;
-    throw err;
-  }
-}
-function tryLock(dir) {
-  fs4.mkdirSync(path5.dirname(dir), { recursive: true });
-  const token3 = `${process.pid}-${randomUUID()}`;
-  const candidate = fs4.mkdtempSync(`${dir}.`);
-  try {
-    fs4.writeFileSync(path5.join(candidate, token3), "");
-    for (; ; ) {
-      try {
-        fs4.renameSync(candidate, dir);
-        return () => {
-          removeClaim(dir, token3);
-        };
-      } catch (err) {
-        const code = err.code;
-        if (code !== "ENOTEMPTY" && code !== "EEXIST") throw err;
-      }
-      let entries;
-      try {
-        entries = fs4.readdirSync(dir);
-      } catch (err) {
-        if (err.code === "ENOENT") continue;
-        throw err;
-      }
-      if (entries.length) {
-        if (entries.length !== 1 || !/^\d+-[a-f0-9-]{36}$/.test(entries[0])) return void 0;
-        const owner = Number(entries[0].split("-")[0]);
-        if (pidAlive(owner)) return void 0;
-      }
-      if (!removeClaim(dir, entries[0])) return void 0;
-    }
-  } finally {
-    fs4.rmSync(candidate, { recursive: true, force: true });
-  }
-}
-function withLock(dir, what, fn) {
-  const until = Date.now() + WAIT_MS;
-  let held4;
-  for (; ; ) {
-    try {
-      fs4.mkdirSync(dir, { recursive: false });
-      try {
-        fs4.writeFileSync(path5.join(dir, OWNER), `${process.pid}
-`);
-      } catch {
-      }
-      break;
-    } catch (err) {
-      const code = err.code;
-      if (code === "ENOENT") {
-        fs4.mkdirSync(path5.dirname(dir), { recursive: true });
-        continue;
-      }
-      if (code !== "EEXIST") throw err;
-      if (ageOf(dir) > STALE_MS) {
-        fs4.rmSync(dir, { recursive: true, force: true });
-        continue;
-      }
-      held4 = ownerOf(dir);
-      if (held4 !== void 0 && !pidAlive(held4) && claimBreak(dir)) {
-        fs4.rmSync(dir, { recursive: true, force: true });
-        continue;
-      }
-      if (Date.now() > until) {
-        die(
-          `another command is ${what}${held4 ? ` (process ${held4})` : ""} and did not finish in ${WAIT_MS / 1e3}s. If nothing else is running, remove ${rel(dir)}/ and try again.`,
-          "board-busy"
-        );
-      }
-      sleep(RETRY_MS);
-    }
-  }
-  try {
-    return fn();
-  } finally {
-    const owner = ownerOf(dir);
-    if (owner === void 0 || owner === process.pid) fs4.rmSync(dir, { recursive: true, force: true });
-  }
-}
-function withBoardLock(fn) {
-  if (!fs4.existsSync(KANBAN)) return fn();
-  if (depth > 0) return fn();
-  try {
-    ensureAkbDir();
-  } catch {
-  }
-  depth++;
-  try {
-    return withLock(LOCK, "writing this board", fn);
-  } finally {
-    depth--;
-  }
-}
-var WAIT_MS, STALE_MS, RETRY_MS, OWNER, BREAKING, depth;
-var init_lock = __esm({
-  "../cli/src/lib/lock.ts"() {
-    "use strict";
-    init_paths();
-    WAIT_MS = 1e4;
-    STALE_MS = 6e4;
-    RETRY_MS = 25;
-    OWNER = "owner";
-    BREAKING = "breaking";
-    depth = 0;
-  }
-});
-
-// ../cli/src/lib/agent/creation-lock.ts
-import path6 from "node:path";
-function withCreationLock(fn) {
-  if (depth2) return fn();
-  return withLock(path6.join(SESSIONS_DIR, "creation.lock"), "changing card creation", () => {
-    depth2++;
-    try {
-      return fn();
-    } finally {
-      depth2--;
-    }
-  });
-}
-var depth2;
-var init_creation_lock = __esm({
-  "../cli/src/lib/agent/creation-lock.ts"() {
-    "use strict";
-    init_lock();
-    init_paths();
-    depth2 = 0;
-  }
-});
-
 // ../cli/src/lib/cloud/config.ts
 function cloudEndpoints() {
   return {
@@ -3965,12 +3779,12 @@ var init_config = __esm({
 });
 
 // ../cli/src/lib/cloud/session.ts
-import fs5 from "node:fs";
-import path7 from "node:path";
+import fs4 from "node:fs";
+import path5 from "node:path";
 function readSession() {
   let raw;
   try {
-    raw = fs5.readFileSync(sessionFile(), "utf8");
+    raw = fs4.readFileSync(sessionFile(), "utf8");
   } catch {
     return null;
   }
@@ -3984,15 +3798,15 @@ function readSession() {
   }
 }
 function writeSession(session) {
-  fs5.mkdirSync(machineHome(), { recursive: true, mode: 448 });
+  fs4.mkdirSync(machineHome(), { recursive: true, mode: 448 });
   const tmp = `${sessionFile()}.${process.pid}.tmp`;
-  fs5.writeFileSync(tmp, `${JSON.stringify(session, null, 2)}
+  fs4.writeFileSync(tmp, `${JSON.stringify(session, null, 2)}
 `, { mode: 384 });
-  fs5.renameSync(tmp, sessionFile());
+  fs4.renameSync(tmp, sessionFile());
 }
 function clearSession() {
   try {
-    fs5.rmSync(sessionFile());
+    fs4.rmSync(sessionFile());
   } catch {
   }
 }
@@ -4057,42 +3871,42 @@ async function takeLock() {
   const until = Date.now() + LOCK_WAIT_MS;
   for (; ; ) {
     try {
-      fs5.mkdirSync(machineHome(), { recursive: true, mode: 448 });
-      fs5.mkdirSync(lockDir());
+      fs4.mkdirSync(machineHome(), { recursive: true, mode: 448 });
+      fs4.mkdirSync(lockDir());
       try {
-        fs5.writeFileSync(lockOwner(), `${process.pid}
+        fs4.writeFileSync(lockOwner(), `${process.pid}
 `);
       } catch {
       }
       return () => {
         try {
-          fs5.rmSync(lockDir(), { recursive: true, force: true });
+          fs4.rmSync(lockDir(), { recursive: true, force: true });
         } catch {
         }
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       if (stale()) {
-        fs5.rmSync(lockDir(), { recursive: true, force: true });
+        fs4.rmSync(lockDir(), { recursive: true, force: true });
         continue;
       }
       if (Date.now() > until) return () => {
       };
-      await sleep2(LOCK_RETRY_MS);
+      await sleep(LOCK_RETRY_MS);
     }
   }
 }
 function stale() {
   let held4;
   try {
-    const pid = Number(fs5.readFileSync(lockOwner(), "utf8").trim());
+    const pid = Number(fs4.readFileSync(lockOwner(), "utf8").trim());
     held4 = Number.isInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
     held4 = void 0;
   }
   if (held4 !== void 0 && !alive(held4)) return true;
   try {
-    return Date.now() - fs5.statSync(lockDir()).mtimeMs > LOCK_STALE_MS;
+    return Date.now() - fs4.statSync(lockDir()).mtimeMs > LOCK_STALE_MS;
   } catch {
     return false;
   }
@@ -4105,7 +3919,7 @@ function alive(pid) {
     return e.code === "EPERM";
   }
 }
-var REFRESH_MARGIN_MS, LOCK_STALE_MS, LOCK_WAIT_MS, LOCK_RETRY_MS, sessionFile, lockDir, lockOwner, expiringSoon, sleep2;
+var REFRESH_MARGIN_MS, LOCK_STALE_MS, LOCK_WAIT_MS, LOCK_RETRY_MS, sessionFile, lockDir, lockOwner, expiringSoon, sleep;
 var init_session = __esm({
   "../cli/src/lib/cloud/session.ts"() {
     "use strict";
@@ -4115,11 +3929,234 @@ var init_session = __esm({
     LOCK_STALE_MS = 3e4;
     LOCK_WAIT_MS = 2e4;
     LOCK_RETRY_MS = 50;
-    sessionFile = () => path7.join(machineHome(), "session.json");
-    lockDir = () => path7.join(machineHome(), "session.lock");
-    lockOwner = () => path7.join(lockDir(), "owner");
+    sessionFile = () => path5.join(machineHome(), "session.json");
+    lockDir = () => path5.join(machineHome(), "session.lock");
+    lockOwner = () => path5.join(lockDir(), "owner");
     expiringSoon = (session) => session.expiresAt - REFRESH_MARGIN_MS <= Date.now();
-    sleep2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+    sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+});
+
+// ../cli/src/lib/cloud/execution.ts
+function executionOf(value = process.env.AI4KANBAN_EXECUTION) {
+  try {
+    const held4 = typeof value === "string" ? JSON.parse(value) : value;
+    if (held4 && UUID.test(held4.job) && UUID.test(held4.machine)) return { job: held4.job, machine: held4.machine };
+  } catch {
+  }
+  return void 0;
+}
+async function executionHeld(execution) {
+  if (!execution) return true;
+  try {
+    const auth = await accessToken();
+    if (!auth.ok) return false;
+    const response = await fetch(`${cloudEndpoints().api}/v1/runner/jobs/${execution.job}/renew`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${auth.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ machineId: execution.machine }),
+      signal: AbortSignal.timeout(2e4)
+    });
+    if (!response.ok) return false;
+    const held4 = await response.json();
+    return held4.renewed === true && held4.stop !== true;
+  } catch {
+    return false;
+  }
+}
+var UUID;
+var init_execution = __esm({
+  "../cli/src/lib/cloud/execution.ts"() {
+    "use strict";
+    init_config();
+    init_session();
+    UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  }
+});
+
+// ../cli/src/lib/lock.ts
+import { randomUUID } from "node:crypto";
+import fs5 from "node:fs";
+import path6 from "node:path";
+function sleep2(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function ageOf(dir) {
+  try {
+    return Date.now() - fs5.statSync(dir).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function ownerOf(dir) {
+  try {
+    const pid = Number(fs5.readFileSync(path6.join(dir, OWNER), "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function claimBreak(dir) {
+  try {
+    fs5.mkdirSync(path6.join(dir, BREAKING));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeClaim(dir, token3) {
+  if (token3) {
+    try {
+      fs5.unlinkSync(path6.join(dir, token3));
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  try {
+    fs5.rmdirSync(dir);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return true;
+    if (code === "ENOTEMPTY" || code === "EEXIST") return false;
+    throw err;
+  }
+}
+function tryLock(dir) {
+  fs5.mkdirSync(path6.dirname(dir), { recursive: true });
+  const token3 = `${process.pid}-${randomUUID()}`;
+  const candidate = fs5.mkdtempSync(`${dir}.`);
+  try {
+    fs5.writeFileSync(path6.join(candidate, token3), "");
+    for (; ; ) {
+      try {
+        fs5.renameSync(candidate, dir);
+        return () => {
+          removeClaim(dir, token3);
+        };
+      } catch (err) {
+        const code = err.code;
+        if (code !== "ENOTEMPTY" && code !== "EEXIST") throw err;
+      }
+      let entries;
+      try {
+        entries = fs5.readdirSync(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") continue;
+        throw err;
+      }
+      if (entries.length) {
+        if (entries.length !== 1 || !/^\d+-[a-f0-9-]{36}$/.test(entries[0])) return void 0;
+        const owner = Number(entries[0].split("-")[0]);
+        if (pidAlive(owner)) return void 0;
+      }
+      if (!removeClaim(dir, entries[0])) return void 0;
+    }
+  } finally {
+    fs5.rmSync(candidate, { recursive: true, force: true });
+  }
+}
+function withLock(dir, what, fn) {
+  const until = Date.now() + WAIT_MS;
+  let held4;
+  for (; ; ) {
+    try {
+      fs5.mkdirSync(dir, { recursive: false });
+      try {
+        fs5.writeFileSync(path6.join(dir, OWNER), `${process.pid}
+`);
+      } catch {
+      }
+      break;
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        fs5.mkdirSync(path6.dirname(dir), { recursive: true });
+        continue;
+      }
+      if (code !== "EEXIST") throw err;
+      if (ageOf(dir) > STALE_MS) {
+        fs5.rmSync(dir, { recursive: true, force: true });
+        continue;
+      }
+      held4 = ownerOf(dir);
+      if (held4 !== void 0 && !pidAlive(held4) && claimBreak(dir)) {
+        fs5.rmSync(dir, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() > until) {
+        die(
+          `another command is ${what}${held4 ? ` (process ${held4})` : ""} and did not finish in ${WAIT_MS / 1e3}s. If nothing else is running, remove ${rel(dir)}/ and try again.`,
+          "board-busy"
+        );
+      }
+      sleep2(RETRY_MS);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    const owner = ownerOf(dir);
+    if (owner === void 0 || owner === process.pid) fs5.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function withBoardLock(fn) {
+  if (!fs5.existsSync(KANBAN)) return fn();
+  if (depth > 0) return fn();
+  try {
+    ensureAkbDir();
+  } catch {
+  }
+  depth++;
+  try {
+    return withLock(LOCK, "writing this board", fn);
+  } finally {
+    depth--;
+  }
+}
+var WAIT_MS, STALE_MS, RETRY_MS, OWNER, BREAKING, depth;
+var init_lock = __esm({
+  "../cli/src/lib/lock.ts"() {
+    "use strict";
+    init_paths();
+    WAIT_MS = 1e4;
+    STALE_MS = 6e4;
+    RETRY_MS = 25;
+    OWNER = "owner";
+    BREAKING = "breaking";
+    depth = 0;
+  }
+});
+
+// ../cli/src/lib/agent/creation-lock.ts
+import path7 from "node:path";
+function withCreationLock(fn) {
+  if (depth2) return fn();
+  return withLock(path7.join(SESSIONS_DIR, "creation.lock"), "changing card creation", () => {
+    depth2++;
+    try {
+      return fn();
+    } finally {
+      depth2--;
+    }
+  });
+}
+var depth2;
+var init_creation_lock = __esm({
+  "../cli/src/lib/agent/creation-lock.ts"() {
+    "use strict";
+    init_lock();
+    init_paths();
+    depth2 = 0;
   }
 });
 
@@ -5477,7 +5514,7 @@ var init_package = __esm({
   "../cli/package.json"() {
     package_default = {
       name: "wildcrane",
-      version: "0.11.10",
+      version: "0.11.12",
       akbContract: 5,
       description: "WildCrane's `akb` command \u2014 scaffold the Markdown board under docs/kanban/, put an agent on a card, and carry the flows the agent works by.",
       keywords: [
@@ -8316,10 +8353,10 @@ function findRollout(threadId) {
     }
     for (const name of names4) {
       if (!name.startsWith("rollout-") || !name.endsWith(tail2)) continue;
-      const path85 = join(dir, name);
+      const path87 = join(dir, name);
       try {
-        const at = statSync(path85).mtimeMs;
-        if (!newest2 || at > newest2.at) newest2 = { path: path85, at };
+        const at = statSync(path87).mtimeMs;
+        if (!newest2 || at > newest2.at) newest2 = { path: path87, at };
       } catch {
       }
     }
@@ -8327,11 +8364,11 @@ function findRollout(threadId) {
   return newest2?.path;
 }
 function readCodexRunFacts(threadId) {
-  const path85 = findRollout(threadId);
-  if (!path85) return void 0;
+  const path87 = findRollout(threadId);
+  if (!path87) return void 0;
   let raw;
   try {
-    raw = readFileSync(path85, "utf8");
+    raw = readFileSync(path87, "utf8");
   } catch {
     return void 0;
   }
@@ -8459,8 +8496,8 @@ function renderCompleted(item) {
       const changes = Array.isArray(item.changes) ? item.changes : [];
       return changes.map((raw) => {
         const change2 = obj(raw);
-        const path85 = str2(change2.path);
-        return path85 ? `\u23FA ${str2(change2.kind) || "change"}(${path85})
+        const path87 = str2(change2.path);
+        return path87 ? `\u23FA ${str2(change2.kind) || "change"}(${path87})
 ` : "";
       }).join("");
     }
@@ -8719,10 +8756,10 @@ function readKimiRunFacts(sessionId) {
   const total = { input: 0, cacheCreation: 0, cacheRead: 0, output: 0 };
   let model;
   let holding = 0;
-  for (const { path: path85, main } of wireFiles(entry.sessionDir)) {
+  for (const { path: path87, main } of wireFiles(entry.sessionDir)) {
     let raw;
     try {
-      raw = readFileSync2(path85, "utf8");
+      raw = readFileSync2(path87, "utf8");
     } catch {
       continue;
     }
@@ -9003,8 +9040,8 @@ var init_tail = __esm({
 import fs24 from "node:fs";
 function whereHint(update2, title) {
   const locations = Array.isArray(update2.locations) ? update2.locations : [];
-  const path85 = str2(obj(locations[0]).path);
-  return path85 && !title.includes(path85) ? hint(path85) : "";
+  const path87 = str2(obj(locations[0]).path);
+  return path87 && !title.includes(path87) ? hint(path87) : "";
 }
 function saidBy(update2) {
   const content = Array.isArray(update2.content) ? update2.content : [];
@@ -9947,27 +9984,40 @@ import crypto3 from "node:crypto";
 import fs25 from "node:fs";
 import os4 from "node:os";
 import path28 from "node:path";
+function spawnGit(args, options) {
+  const out = spawnSync3("git", args, {
+    ...options,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: gitLimits.timeoutMs,
+    killSignal: "SIGKILL"
+  });
+  if (out.error?.code === "ETIMEDOUT") throw new GitTimeoutError(`Git ${args[0]} timed out after ${gitLimits.timeoutMs / 1e3}s; the command was killed.`);
+  return out;
+}
 function git(args, cwd = REPO_ROOT) {
   try {
-    const out = spawnSync3("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true });
+    const out = spawnGit(args, { cwd, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true });
     if (out.error || out.status !== 0) return null;
     return out.stdout;
-  } catch {
+  } catch (error) {
+    if (error instanceof GitTimeoutError) throw error;
     return null;
   }
 }
 function gitDiff(args, cwd = REPO_ROOT) {
   try {
-    const out = spawnSync3("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true });
+    const out = spawnGit(args, { cwd, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true });
     if (out.error || out.status !== 0 && out.status !== 1) return null;
     return out.stdout;
-  } catch {
+  } catch (error) {
+    if (error instanceof GitTimeoutError) throw error;
     return null;
   }
 }
 function tryGit(args, cwd = REPO_ROOT, env2) {
   try {
-    const out = spawnSync3("git", args, {
+    const out = spawnGit(args, {
       cwd,
       encoding: "utf8",
       maxBuffer: MAX_OUTPUT,
@@ -9978,6 +10028,7 @@ function tryGit(args, cwd = REPO_ROOT, env2) {
     if (out.status !== 0) return { ok: false, why: (out.stderr || out.stdout || "").trim() };
     return { ok: true };
   } catch (e) {
+    if (e instanceof GitTimeoutError) throw e;
     return { ok: false, why: e instanceof Error ? e.message : String(e) };
   }
 }
@@ -9986,7 +10037,7 @@ function boardManagedPaths() {
 }
 function outsideBoardForAdd(cwd = REPO_ROOT) {
   const kept2 = boardManagedPaths().filter(
-    (p) => spawnSync3("git", ["check-ignore", "-q", p], { cwd, windowsHide: true }).status !== 0
+    (p) => spawnGit(["check-ignore", "-q", p], { cwd, windowsHide: true }).status !== 0
   );
   return ["--", ".", ...kept2.map((p) => `:(exclude)${p}`)];
 }
@@ -10106,10 +10157,10 @@ function treeMark(base, cwd = REPO_ROOT) {
   const index = path28.join(ensureAkbDir(), `index-${process.pid}-${Date.now()}`);
   try {
     const env2 = { ...process.env, GIT_INDEX_FILE: index };
-    const run2 = (args) => spawnSync3("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true, env: env2 }).status === 0;
+    const run2 = (args) => spawnGit(args, { cwd, encoding: "utf8", maxBuffer: MAX_OUTPUT, windowsHide: true, env: env2 }).status === 0;
     if (!run2(["read-tree", base])) return null;
     if (!run2(["add", "-A", ...outsideBoardForAdd(cwd)])) return null;
-    const tree = spawnSync3("git", ["write-tree"], {
+    const tree = spawnGit(["write-tree"], {
       cwd,
       encoding: "utf8",
       maxBuffer: MAX_OUTPUT,
@@ -10117,7 +10168,8 @@ function treeMark(base, cwd = REPO_ROOT) {
       env: env2
     });
     return tree.status === 0 ? tree.stdout.trim() || null : null;
-  } catch {
+  } catch (error) {
+    if (error instanceof GitTimeoutError) throw error;
     return null;
   } finally {
     try {
@@ -10128,23 +10180,26 @@ function treeMark(base, cwd = REPO_ROOT) {
 }
 function reverseApplies(patch2, ref, cwd = REPO_ROOT) {
   if (!patch2.trim()) return false;
-  const index = path28.join(os4.tmpdir(), `akb-apply-${process.pid}-${Date.now()}.index`);
+  const folder = fs25.mkdtempSync(path28.join(os4.tmpdir(), `akb-apply-${process.pid}-`));
+  const index = path28.join(folder, "index");
+  const patchFile = path28.join(folder, "patch");
   const env2 = { GIT_INDEX_FILE: index };
   try {
+    fs25.writeFileSync(patchFile, patch2);
     if (!tryGit(["read-tree", ref], cwd, env2).ok) return false;
-    const out = spawnSync3("git", ["apply", "--cached", "--reverse", "--check", "-"], {
+    const out = spawnGit(["apply", "--cached", "--reverse", "--check", patchFile], {
       cwd,
-      input: patch2,
       encoding: "utf8",
       maxBuffer: MAX_OUTPUT,
       windowsHide: true,
       env: { ...process.env, ...env2 }
     });
     return !out.error && out.status === 0;
-  } catch {
+  } catch (error) {
+    if (error instanceof GitTimeoutError) throw error;
     return false;
   } finally {
-    fs25.rmSync(index, { force: true });
+    fs25.rmSync(folder, { recursive: true, force: true });
   }
 }
 function squashOnto(dir, base, message) {
@@ -10226,12 +10281,15 @@ function moveBranchRef(branch, commit, expect) {
   if (branchTip(branch) !== expect) return { moved: true };
   return { ok: false, error: `couldn't move ${branch} to ${commit.slice(0, 12)}: ${done2.why ?? "git refused"}` };
 }
-var MAX_OUTPUT, scripted, posix, outsideBoard, deliveryBranch, deliveryWorktree, worktreeDir, inGitRepo, headCommit, worktreeExists, branchExists, pruneWorktreeMetadata, branchTip, isAncestor, changedPaths, branchPatch, lastCommitTouching, continueRebase, abortRebase, conflictedPaths, headingKind;
+var MAX_OUTPUT, gitLimits, GitTimeoutError, scripted, posix, outsideBoard, deliveryBranch, deliveryWorktree, worktreeDir, inGitRepo, headCommit, worktreeExists, branchExists, pruneWorktreeMetadata, branchTip, isAncestor, changedPaths, branchPatch, lastCommitTouching, continueRebase, abortRebase, conflictedPaths, headingKind;
 var init_worktree = __esm({
   "../cli/src/lib/agent/worktree.ts"() {
     "use strict";
     init_paths();
     MAX_OUTPUT = 64 * 1024 * 1024;
+    gitLimits = { timeoutMs: 3e4 };
+    GitTimeoutError = class extends Error {
+    };
     scripted = (args, cwd) => tryGit(["-c", "core.hooksPath=/dev/null", ...args], cwd, { GIT_EDITOR: "true", GIT_SEQUENCE_EDITOR: "true" });
     posix = (p) => p.split(path28.sep).join("/");
     outsideBoard = () => [
@@ -10248,7 +10306,7 @@ var init_worktree = __esm({
     branchExists = (branch) => !!branch && git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]) !== null;
     pruneWorktreeMetadata = () => void git(["worktree", "prune"]);
     branchTip = (branch) => git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`])?.trim() || null;
-    isAncestor = (older, newer, cwd = REPO_ROOT) => spawnSync3("git", ["merge-base", "--is-ancestor", older, newer], { cwd, windowsHide: true }).status === 0;
+    isAncestor = (older, newer, cwd = REPO_ROOT) => spawnGit(["merge-base", "--is-ancestor", older, newer], { cwd, windowsHide: true }).status === 0;
     changedPaths = (base, branch, cwd = REPO_ROOT) => {
       const out = git(["diff", "--name-only", base, branch, ...outsideBoard()], cwd);
       return out === null ? null : out.split("\n").filter(Boolean);
@@ -11556,49 +11614,12 @@ function withSystemLanguage(harness, argv, env2, line) {
 }
 var init_run_settings = __esm({
   "../cli/src/lib/agent/run-settings.ts"() {
-    "use strict";
-    init_argv();
-    init_env();
-    init_language();
-    init_types2();
-    init_providers();
-  }
-});
-
-// ../cli/src/lib/cloud/execution.ts
-function executionOf(value = process.env.AI4KANBAN_EXECUTION) {
-  try {
-    const held4 = typeof value === "string" ? JSON.parse(value) : value;
-    if (held4 && UUID.test(held4.job) && UUID.test(held4.machine)) return { job: held4.job, machine: held4.machine };
-  } catch {
-  }
-  return void 0;
-}
-async function executionHeld(execution) {
-  if (!execution) return true;
-  try {
-    const auth = await accessToken();
-    if (!auth.ok) return false;
-    const response = await fetch(`${cloudEndpoints().api}/v1/runner/jobs/${execution.job}/renew`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${auth.token}`, "content-type": "application/json" },
-      body: JSON.stringify({ machineId: execution.machine }),
-      signal: AbortSignal.timeout(2e4)
-    });
-    if (!response.ok) return false;
-    const held4 = await response.json();
-    return held4.renewed === true && held4.stop !== true;
-  } catch {
-    return false;
-  }
-}
-var UUID;
-var init_execution = __esm({
-  "../cli/src/lib/cloud/execution.ts"() {
-    "use strict";
-    init_config();
-    init_session();
-    UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    "use strict";
+    init_argv();
+    init_env();
+    init_language();
+    init_types2();
+    init_providers();
   }
 });
 
@@ -15546,6 +15567,252 @@ var init_complete = __esm({
   }
 });
 
+// ../cli/src/lib/agent/stop.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import fs39 from "node:fs";
+import os6 from "node:os";
+import path43 from "node:path";
+function markedInProc(entry, strict = false) {
+  const pids = [];
+  for (const name of fs39.readdirSync("/proc")) {
+    if (!/^\d+$/.test(name)) continue;
+    try {
+      if (fs39.readFileSync(`/proc/${name}/environ`, "utf8").split("\0").includes(entry)) pids.push(Number(name));
+    } catch (error) {
+      if (strict && !["ENOENT", "ESRCH"].includes(error.code ?? "")) {
+        const stat = fs39.statSync(`/proc/${name}`, { throwIfNoEntry: false });
+        if (stat?.uid === process.getuid?.()) throw error;
+      }
+    }
+  }
+  return pids;
+}
+function markedInPs(entry, roots) {
+  const ps = spawnSync4("ps", ["-A", "-E", "-ww", "-o", "pid=,ppid=,command="], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: 5e3
+  });
+  if (ps.status !== 0 || !ps.stdout) throw new Error("\u65E0\u6CD5\u67E5\u8BE2\u8FDB\u7A0B\u6811\u3002");
+  const children = /* @__PURE__ */ new Map();
+  const listed2 = /* @__PURE__ */ new Set();
+  const found2 = /* @__PURE__ */ new Set();
+  for (const line of ps.stdout.split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s(.*)$/.exec(line);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    const ppid = Number(m[2]);
+    listed2.add(pid);
+    children.set(ppid, [...children.get(ppid) ?? [], pid]);
+    if (`${m[3]} `.includes(` ${entry} `)) found2.add(pid);
+  }
+  const queue = [...found2, ...roots.filter((pid) => listed2.has(pid))];
+  for (const pid of queue) {
+    found2.add(pid);
+    for (const child of children.get(pid) ?? []) if (!found2.has(child)) queue.push(child);
+  }
+  return [...found2];
+}
+function marked(mark, roots = []) {
+  if (WINDOWS3 || !mark.value) return [];
+  const entry = `${mark.name}=${mark.value}`;
+  try {
+    const pids = process.platform === "linux" ? markedInProc(entry) : markedInPs(entry, roots);
+    return pids.filter((pid) => pid !== process.pid);
+  } catch {
+    return [];
+  }
+}
+function signal(pids, sig) {
+  for (const pid of pids) {
+    try {
+      process.kill(pid, sig);
+    } catch {
+    }
+  }
+}
+function stopWatchers(sessions, onlyPid, stillOwns = () => true, startedBefore) {
+  if (sessions ? !sessions.length : onlyPid === void 0) return [];
+  const command = WINDOWS3 ? "powershell.exe" : "ps";
+  const args = WINDOWS3 ? ["-NoProfile", "-NonInteractive", "-Command", "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine,@{Name='StartedAt';Expression={([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds()}} | ConvertTo-Json -Compress"] : ["-A", "-ww", "-o", "pid=,lstart=,command="];
+  const out = spawnSync4(command, args, { encoding: "utf8", timeout: 5e3, maxBuffer: 16 * 1024 * 1024, windowsHide: true, env: { ...process.env, LC_ALL: "C" } });
+  if (out.status !== 0) return [];
+  let procs;
+  try {
+    procs = WINDOWS3 ? [].concat(JSON.parse(out.stdout)).map((p) => ({ pid: p.ProcessId, command: p.CommandLine ?? "", startedAt: p.StartedAt })) : out.stdout.split("\n").flatMap((line) => {
+      const m = /^\s*(\d+)\s+(\S+\s+\S+\s+\d+\s+\d+:\d+:\d+\s+\d{4})\s+(.*)$/.exec(line);
+      return m ? [{ pid: Number(m[1]), command: m[3], startedAt: Date.parse(m[2]) }] : [];
+    });
+  } catch {
+    return [];
+  }
+  const known2 = sessions && new Set(sessions);
+  const stopped2 = [];
+  for (const proc of procs) {
+    if (proc.pid === process.pid || onlyPid !== void 0 && proc.pid !== onlyPid) continue;
+    if (startedBefore !== void 0 && (!Number.isFinite(proc.startedAt) || proc.startedAt > startedBefore)) continue;
+    const match = /^"?[^\n]*?\bnode(?:\.exe)?"?\s+(?:"[^\n"]+\.mjs"|\S+\.mjs)\s+__watch\s+(\S+)(?:\s|$)/.exec(proc.command);
+    const args2 = `${proc.command} `;
+    const names4 = (flag, value) => args2.includes(` ${flag} ${value} `) || args2.includes(` ${flag} "${value}" `);
+    const board2 = names4("--board", KANBAN) || KANBAN === path43.join(REPO_ROOT, "docs", "kanban") && names4("--dir", REPO_ROOT);
+    if (!match || known2 && !known2.has(match[1]) || !board2 || !stillOwns()) continue;
+    if (WINDOWS3) {
+      if (killTreeOnWindows(proc.pid)) stopped2.push(proc.pid);
+    } else {
+      try {
+        process.kill(-proc.pid, "SIGKILL");
+        stopped2.push(proc.pid);
+      } catch {
+      }
+    }
+  }
+  return stopped2;
+}
+function startedUnder(list, root, since) {
+  const self = list.procs.find((p) => p.pid === root);
+  const from = since ?? self?.startedAt;
+  if (from === void 0 || list.bootedAt > from) return [];
+  if (self && self.startedAt > from) return [];
+  const found2 = self ? [root] : [];
+  const seen = /* @__PURE__ */ new Set([root]);
+  const queue = [{ pid: root, startedAt: from }];
+  for (const parent of queue) {
+    for (const p of list.procs) {
+      if (p.ppid !== parent.pid || seen.has(p.pid) || p.startedAt < parent.startedAt) continue;
+      seen.add(p.pid);
+      found2.push(p.pid);
+      queue.push(p);
+    }
+  }
+  return found2.reverse();
+}
+function readProcList(out) {
+  const procs = [];
+  let bootedAt;
+  for (const line of out.split(/\r?\n/)) {
+    const boot = /^boot (\d+)$/.exec(line.trim());
+    if (boot) bootedAt = Number(boot[1]);
+    const m = /^(\d+) (\d+) (\d+)$/.exec(line.trim());
+    if (m) procs.push({ pid: Number(m[1]), ppid: Number(m[2]), startedAt: Number(m[3]) });
+  }
+  return bootedAt !== void 0 && procs.length ? { procs, bootedAt } : void 0;
+}
+function procsOnWindows() {
+  const ps = spawnSync4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", LIST_PROCS], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: 5e3,
+    windowsHide: true
+  });
+  return ps.status === 0 && ps.stdout ? readProcList(ps.stdout) : void 0;
+}
+function killUnderOnWindows(pid, since) {
+  if (!WINDOWS3 || !pid) return;
+  const list = procsOnWindows();
+  if (!list) return;
+  const pids = startedUnder(list, pid, since).filter((p) => p !== process.pid);
+  if (!pids.length) return;
+  spawnSync4("taskkill", ["/F", ...pids.flatMap((p) => ["/PID", String(p)])], { stdio: "ignore", windowsHide: true, timeout: 1e4 });
+}
+function killMarked(mark, agent) {
+  if (WINDOWS3) {
+    if (agent) killUnderOnWindows(agent.pid, agent.since);
+    return;
+  }
+  signal(marked(mark), "SIGKILL");
+}
+function killTreeOnWindows(pid) {
+  if (!WINDOWS3 || !pid) return false;
+  const out = spawnSync4("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 1e4 });
+  return out.status === 0;
+}
+function later(ms, fn) {
+  const t = setTimeout(fn, ms);
+  if (typeof t.unref === "function") t.unref();
+}
+function endAgent(child, mark, graceMs) {
+  const term = (sig) => {
+    try {
+      child.kill(sig);
+    } catch {
+    }
+  };
+  if (killTreeOnWindows(child.pid)) return;
+  killUnderOnWindows(child.pid);
+  const seen = new Set(marked(mark, child.pid ? [child.pid] : []));
+  term("SIGTERM");
+  signal([...seen].filter((pid) => pid !== child.pid), "SIGTERM");
+  const round = (left) => {
+    const pids = marked(mark, [...seen]);
+    signal(pids, "SIGKILL");
+    for (const pid of pids) seen.add(pid);
+    if (pids.length && left > 1) later(KILL_ROUND_MS, () => round(left - 1));
+  };
+  later(graceMs, () => {
+    term("SIGKILL");
+    round(KILL_ROUNDS);
+  });
+}
+function killRunning() {
+  for (const [child, mark] of running) {
+    if (killTreeOnWindows(child.pid)) continue;
+    killUnderOnWindows(child.pid);
+    signal(marked(mark, child.pid ? [child.pid] : []), "SIGKILL");
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }
+  running.clear();
+}
+function unlisten() {
+  for (const [sig, fn] of listening) process.removeListener(sig, fn);
+  listening.clear();
+}
+function onQuit(sig) {
+  killRunning();
+  unlisten();
+  if (process.listenerCount(sig) === 0) process.exit(128 + os6.constants.signals[sig]);
+}
+function trackAgent(child, mark) {
+  if (!child.pid) return;
+  running.set(child, mark);
+  child.once("close", () => {
+    running.delete(child);
+    if (!running.size) unlisten();
+  });
+  for (const sig of QUIT_SIGNALS) {
+    if (listening.has(sig) || sig === "SIGINT" && interruptIsTheCallers) continue;
+    const fn = () => onQuit(sig);
+    listening.set(sig, fn);
+    process.on(sig, fn);
+  }
+}
+var runMark, stopMark, markEnv, WINDOWS3, KILL_ROUND_MS, KILL_ROUNDS, LIST_PROCS, running, QUIT_SIGNALS, listening, interruptIsTheCallers;
+var init_stop = __esm({
+  "../cli/src/lib/agent/stop.ts"() {
+    "use strict";
+    init_env();
+    init_paths();
+    runMark = (sessionId) => ({ name: RUN_ENV, value: sessionId });
+    stopMark = () => ({ name: STOP_ENV, value: randomUUID5() });
+    markEnv = (env2, mark) => ({ ...env2, [mark.name]: mark.value });
+    WINDOWS3 = process.platform === "win32";
+    KILL_ROUND_MS = 300;
+    KILL_ROUNDS = 3;
+    LIST_PROCS = [
+      "$ErrorActionPreference = 'Stop'",
+      "Get-CimInstance Win32_Process | ForEach-Object { if ($_.CreationDate) { '{0} {1} {2}' -f $_.ProcessId, $_.ParentProcessId, ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() } }",
+      "'boot {0}' -f ([DateTimeOffset](Get-CimInstance Win32_OperatingSystem).LastBootUpTime).ToUnixTimeMilliseconds()"
+    ].join("; ");
+    running = /* @__PURE__ */ new Map();
+    QUIT_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+    listening = /* @__PURE__ */ new Map();
+    interruptIsTheCallers = false;
+  }
+});
+
 // ../cli/src/lib/agent/pause.ts
 function deliveryState(delivery, questions) {
   const landing = delivery.landing;
@@ -15734,12 +16001,12 @@ var init_runner = __esm({
 });
 
 // ../cli/src/lib/agent/rules.ts
-import fs39 from "node:fs";
-import path43 from "node:path";
+import fs40 from "node:fs";
+import path44 from "node:path";
 function ruleFile(agent) {
   if (!agent || hiddenRole(agent)) return "";
   try {
-    return fs39.readFileSync(rulePath(agent), "utf8").trim();
+    return fs40.readFileSync(rulePath(agent), "utf8").trim();
   } catch {
     return "";
   }
@@ -15754,11 +16021,11 @@ function setAgentRule(agent, text5) {
   const rule = String(text5 ?? "").trim();
   try {
     if (!rule) {
-      fs39.rmSync(rulePath(agent), { force: true });
+      fs40.rmSync(rulePath(agent), { force: true });
       return { ok: true };
     }
-    fs39.mkdirSync(RULES, { recursive: true });
-    fs39.writeFileSync(rulePath(agent), `${rule}
+    fs40.mkdirSync(RULES, { recursive: true });
+    fs40.writeFileSync(rulePath(agent), `${rule}
 `);
     return { ok: true };
   } catch (err) {
@@ -15806,7 +16073,7 @@ function migrateFlowRules() {
   adoptRenamedRules();
   let here;
   try {
-    here = new Set(fs39.readdirSync(RULES));
+    here = new Set(fs40.readdirSync(RULES));
   } catch {
     return [];
   }
@@ -15817,9 +16084,9 @@ function migrateFlowRules() {
     if (!from.length) continue;
     const parts = [ruleFile(owner.name), ...from.map(ruleFile)].filter(Boolean);
     try {
-      if (parts.length) fs39.writeFileSync(rulePath(owner.name), `${parts.join("\n\n")}
+      if (parts.length) fs40.writeFileSync(rulePath(owner.name), `${parts.join("\n\n")}
 `);
-      for (const flow of from) fs39.rmSync(rulePath(flow), { force: true });
+      for (const flow of from) fs40.rmSync(rulePath(flow), { force: true });
     } catch (err) {
       notes.push(`could not move the ${from.join(", ")} rule(s) onto \`${owner.name}\`: ${String(err)}`);
       continue;
@@ -15833,7 +16100,7 @@ function migrateFlowRules() {
 function adoptRenamedRules() {
   let here;
   try {
-    here = fs39.readdirSync(RULES);
+    here = fs40.readdirSync(RULES);
   } catch {
     return;
   }
@@ -15843,13 +16110,13 @@ function adoptRenamedRules() {
     const now = RENAMED_ROLES[was] ?? canonicalSpecAgent(was);
     if (now === was) continue;
     try {
-      if (!fs39.existsSync(rulePath(now))) fs39.renameSync(rulePath(was), rulePath(now));
+      if (!fs40.existsSync(rulePath(now))) fs40.renameSync(rulePath(was), rulePath(now));
       else if (FOLDED_SPEC_AGENTS.has(was)) {
         const kept2 = ruleFile(now);
         const carried = ruleFile(was);
-        if (carried && !kept2.includes(carried)) fs39.writeFileSync(rulePath(now), `${[kept2, carried].filter(Boolean).join("\n\n")}
+        if (carried && !kept2.includes(carried)) fs40.writeFileSync(rulePath(now), `${[kept2, carried].filter(Boolean).join("\n\n")}
 `);
-        fs39.rmSync(rulePath(was), { force: true });
+        fs40.rmSync(rulePath(was), { force: true });
       }
     } catch {
     }
@@ -15866,7 +16133,7 @@ var init_rules2 = __esm({
     init_runner();
     init_workflows();
     init_types3();
-    rulePath = (agent) => path43.join(RULES, `${agent}.md`);
+    rulePath = (agent) => path44.join(RULES, `${agent}.md`);
     notOnTheRoster = (name) => `"${name}" is not an agent on this board. It has: ${agentNames().join(", ")}.`;
     flowForRequest = (req) => req.refineRound !== void 0 && REFINE_ACTIONS.has(req.action) ? flowByCommand("refine") : flowByAction(req.action);
     ruleOwnerSays = (owner) => `\`${owner.name}\` agent carries one rule of its own${owner.role ? ", on every flow it runs" : ""}`;
@@ -15951,8 +16218,8 @@ var init_source = __esm({
 });
 
 // ../cli/src/lib/card-sources.ts
-import fs40 from "node:fs";
-import path44 from "node:path";
+import fs41 from "node:fs";
+import path45 from "node:path";
 function planById(id) {
   const found2 = readPlan(`plans/${id}-.md`);
   return found2?.text.trim() ? found2 : null;
@@ -15962,8 +16229,8 @@ function cardLink(id) {
   const found2 = open3 ?? locateArchived(id);
   if (!found2) return null;
   try {
-    const file = found2.kind === "group" ? path44.join(found2.target, "root.md") : found2.target;
-    const title = parseFrontmatter(fs40.readFileSync(file, "utf8")).meta?.title ?? "";
+    const file = found2.kind === "group" ? path45.join(found2.target, "root.md") : found2.target;
+    const title = parseFrontmatter(fs41.readFileSync(file, "utf8")).meta?.title ?? "";
     return { kind: "card", ref: String(id), title, ...open3 ? {} : { archived: true } };
   } catch {
     return null;
@@ -15988,7 +16255,7 @@ function link(ref, items) {
   if (ref.kind === "plan") return planLink(ref.id);
   if (ref.kind === "card") return cardLink(ref.id);
   if (ref.kind === "url") return urlLink(ref.url);
-  const item = items().find((signal2) => path44.basename(signal2.relPath) === ref.file);
+  const item = items().find((signal2) => path45.basename(signal2.relPath) === ref.file);
   return item ? itemLink(item) : null;
 }
 function cardSources(meta, body) {
@@ -16029,12 +16296,12 @@ var init_card_sources = __esm({
 });
 
 // ../cli/src/lib/view/read.ts
-import fs41 from "node:fs";
-import path45 from "node:path";
+import fs42 from "node:fs";
+import path46 from "node:path";
 function readCard(file, relFromTodo) {
-  const id = idPrefix(path45.basename(relFromTodo));
+  const id = idPrefix(path46.basename(relFromTodo));
   if (id === null) {
-    const parts = relFromTodo.split(path45.sep);
+    const parts = relFromTodo.split(path46.sep);
     const folderId = idPrefix(parts[parts.length - 2] || "");
     if (folderId === null) return null;
     return buildCard(folderId, file, relFromTodo);
@@ -16042,10 +16309,10 @@ function readCard(file, relFromTodo) {
   return buildCard(id, file, relFromTodo);
 }
 function buildCard(id, file, relFromTodo) {
-  const text5 = fs41.readFileSync(file, "utf8");
+  const text5 = fs42.readFileSync(file, "utf8");
   const { meta, body } = parseFrontmatter(text5);
   if (!meta) return null;
-  const relPath = relFromTodo.split(path45.sep).join("/");
+  const relPath = relFromTodo.split(path46.sep).join("/");
   const flow = workflowFor(meta.workflow);
   const plan = !!meta.workflow && archivesOnApproval(flow);
   const stages = cardStages(meta, flow).length;
@@ -16054,7 +16321,7 @@ function buildCard(id, file, relFromTodo) {
     // Derived from the file exactly as it is on disk (lib/board/revision.ts), so a card
     // read here and a card read by the contract agree on what version this is.
     revision: revisionOf(text5),
-    updatedAt: fs41.statSync(file).mtime.toISOString(),
+    updatedAt: fs42.statSync(file).mtime.toISOString(),
     relPath,
     title: meta.title,
     priority: meta.priority,
@@ -16075,22 +16342,22 @@ function buildCard(id, file, relFromTodo) {
   };
 }
 function readGroup2(folderName) {
-  const groupDir = path45.join(TODO, folderName);
-  const rootFile = path45.join(groupDir, "root.md");
-  if (!fs41.existsSync(rootFile)) return null;
-  const root = readCard(rootFile, path45.join(folderName, "root.md"));
+  const groupDir = path46.join(TODO, folderName);
+  const rootFile = path46.join(groupDir, "root.md");
+  if (!fs42.existsSync(rootFile)) return null;
+  const root = readCard(rootFile, path46.join(folderName, "root.md"));
   if (!root) return null;
   root.isGroup = true;
   const { total, resolved: resolved2 } = subtaskLines(root.body);
   root.subtaskLines = { total, resolved: resolved2 };
   const subCards = [];
   const recurse = (dir, relDir) => {
-    for (const entry of fs41.readdirSync(dir, { withFileTypes: true })) {
-      const childRel = path45.join(relDir, entry.name);
+    for (const entry of fs42.readdirSync(dir, { withFileTypes: true })) {
+      const childRel = path46.join(relDir, entry.name);
       if (entry.isDirectory()) {
-        recurse(path45.join(dir, entry.name), childRel);
+        recurse(path46.join(dir, entry.name), childRel);
       } else if (entry.name.endsWith(".md") && entry.name !== "README.md" && entry.name !== "root.md") {
-        const c = readCard(path45.join(dir, entry.name), childRel);
+        const c = readCard(path46.join(dir, entry.name), childRel);
         if (c) {
           c.parent = { id: root.id, title: root.title };
           subCards.push(c);
@@ -16111,12 +16378,12 @@ function readGroup2(folderName) {
   return { root, subCards };
 }
 function standaloneCards(dirRel) {
-  const dir = dirRel ? path45.join(TODO, dirRel) : TODO;
-  if (!fs41.existsSync(dir)) return [];
+  const dir = dirRel ? path46.join(TODO, dirRel) : TODO;
+  if (!fs42.existsSync(dir)) return [];
   const cards = [];
-  for (const entry of fs41.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs42.readdirSync(dir, { withFileTypes: true })) {
     if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
-      const c = readCard(path45.join(dir, entry.name), path45.join(dirRel, entry.name));
+      const c = readCard(path46.join(dir, entry.name), path46.join(dirRel, entry.name));
       if (c) cards.push(c);
     }
   }
@@ -16128,7 +16395,7 @@ function collectCards() {
   const top = standaloneCards("");
   board2.push(...top);
   every.push(...top);
-  for (const entry of fs41.readdirSync(TODO, { withFileTypes: true })) {
+  for (const entry of fs42.readdirSync(TODO, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (isGroupFolder(entry.name)) {
       const g = readGroup2(entry.name);
@@ -16160,7 +16427,7 @@ function findCard(id) {
 }
 function attachSources(card) {
   try {
-    const { meta, body } = parseFrontmatter(fs41.readFileSync(path45.join(TODO, card.relPath), "utf8"));
+    const { meta, body } = parseFrontmatter(fs42.readFileSync(path46.join(TODO, card.relPath), "utf8"));
     const sources = meta ? cardSources(meta, body) : [];
     if (sources.length) card.sources = sources;
   } catch {
@@ -16348,8 +16615,8 @@ var init_review = __esm({
 });
 
 // ../cli/src/lib/agent/deliveries.ts
-import fs42 from "node:fs";
-import path46 from "node:path";
+import fs43 from "node:fs";
+import path47 from "node:path";
 function writeAudit(delivery, runs) {
   const known2 = new Map(readAudit(delivery.deliveryId)?.sessions.map((s) => [s.sessionId, s]) ?? []);
   const sessions = delivery.sessions.flatMap((id) => {
@@ -16377,10 +16644,10 @@ function writeAudit(delivery, runs) {
 }
 function writeAuditFile(record) {
   try {
-    fs42.mkdirSync(DELIVERIES, { recursive: true });
+    fs43.mkdirSync(DELIVERIES, { recursive: true });
     const tmp = `${auditPath(record.deliveryId)}.tmp`;
-    fs42.writeFileSync(tmp, JSON.stringify(record, null, 2) + "\n");
-    fs42.renameSync(tmp, auditPath(record.deliveryId));
+    fs43.writeFileSync(tmp, JSON.stringify(record, null, 2) + "\n");
+    fs43.renameSync(tmp, auditPath(record.deliveryId));
     return true;
   } catch {
     return false;
@@ -16388,7 +16655,7 @@ function writeAuditFile(record) {
 }
 function readAudit(deliveryId) {
   try {
-    const data = JSON.parse(fs42.readFileSync(auditPath(deliveryId), "utf8"));
+    const data = JSON.parse(fs43.readFileSync(auditPath(deliveryId), "utf8"));
     return { sessions: Array.isArray(data?.sessions) ? data.sessions : [] };
   } catch {
     return null;
@@ -16403,7 +16670,7 @@ function syncAudit(deliveryId, just) {
 }
 function wholeAudit(file) {
   try {
-    const data = JSON.parse(fs42.readFileSync(file, "utf8"));
+    const data = JSON.parse(fs43.readFileSync(file, "utf8"));
     return typeof data?.deliveryId === "string" && Array.isArray(data.sessions) ? data : null;
   } catch {
     return null;
@@ -16416,14 +16683,14 @@ function activeAudit(file) {
 function allAudits() {
   let names4;
   try {
-    names4 = fs42.readdirSync(DELIVERIES);
+    names4 = fs43.readdirSync(DELIVERIES);
   } catch {
     return [];
   }
   const out = [];
   for (const name of names4) {
     if (!name.endsWith(".json")) continue;
-    const audit = wholeAudit(path46.join(DELIVERIES, name));
+    const audit = wholeAudit(path47.join(DELIVERIES, name));
     if (audit) out.push(audit);
   }
   return out;
@@ -16534,11 +16801,11 @@ function resumeRefusal(delivery, store) {
     );
   }
   if (!worktreeExists(delivery.worktree)) {
-    const path85 = delivery.worktree ?? "";
+    const path87 = delivery.worktree ?? "";
     return refusal(
       "deliveryWorktreeGone",
-      `delivery ${id}'s worktree ${path85} is gone, so there is nothing to carry on. ${rebuild}`,
-      { id, task, path: path85, command: discard }
+      `delivery ${id}'s worktree ${path87} is gone, so there is nothing to carry on. ${rebuild}`,
+      { id, task, path: path87, command: discard }
     );
   }
   if (!branchExists(delivery.branch)) {
@@ -16591,11 +16858,12 @@ function tidyCheckout(deliveryId) {
   const store = readStore();
   const row = store.deliveries.find((d) => d.deliveryId === deliveryId) ?? auditOnly(deliveryId);
   if (!row || row.status === "active") return NOTHING;
-  if (!row.worktree && !row.branch) return NOTHING;
-  if (isResumable(row)) return { removed: false, kept: true };
   if (store.runs.some((r) => r.deliveryId === deliveryId && runIsLive(r))) {
     return { removed: false, kept: false, error: `a run of delivery ${deliveryId} is still going`, reason: "deliveryRunGoing", args: { id: deliveryId } };
   }
+  if (row.status !== "finished" || Date.now() - (row.endedAt ?? 0) > 3e4) stopWatchers(row.sessions);
+  if (!row.worktree && !row.branch) return NOTHING;
+  if (isResumable(row)) return { removed: false, kept: true };
   const removed = removeWorktree(row.worktree, row.branch, true);
   if (!removed.ok) return { removed: false, kept: false, error: removed.error };
   forgetCheckout(deliveryId);
@@ -16618,7 +16886,10 @@ function forgetCheckout(deliveryId) {
 function sweepCheckouts() {
   const seen = /* @__PURE__ */ new Set();
   const complaints = [];
-  const rows = [...readStore().deliveries, ...allAudits().flatMap((a) => auditRow(a) ?? [])];
+  const store = readStore();
+  const rows = [...store.deliveries, ...allAudits().flatMap((a) => auditRow(a) ?? [])];
+  const ended = rows.filter((row) => row.status !== "active" && (row.status !== "finished" || Date.now() - (row.endedAt ?? 0) > 3e4) && !store.runs.some((r) => r.deliveryId === row.deliveryId && runIsLive(r)));
+  stopWatchers([...new Set(ended.flatMap((row) => row.sessions))]);
   for (const row of rows) {
     if (seen.has(row.deliveryId) || row.status === "active" || !row.worktree) continue;
     seen.add(row.deliveryId);
@@ -16628,21 +16899,27 @@ function sweepCheckouts() {
   dropEmptyWorktreeFolders();
   return complaints;
 }
-function resumeRecord(id) {
-  const found2 = endedDelivery(id);
+function resumeRecord(id, execution) {
+  const continueActive = !!execution;
+  const found2 = (continueActive ? namedDelivery(id) : void 0) ?? endedDelivery(id);
   if (!found2) return { ok: false, ...unknownDelivery(id) };
   const refused = resumeRefusal(found2);
-  if (refused) return { ok: false, ...refused };
+  if (refused && !(continueActive && found2.status === "active")) return { ok: false, ...refused };
   const out = withStore((store) => {
     const audit = wholeAudit(auditPath(found2.deliveryId));
-    const row = (audit && auditRow(audit)) ?? store.deliveries.find((d) => d.deliveryId === found2.deliveryId);
+    const live = store.deliveries.find((d) => d.deliveryId === found2.deliveryId);
+    const row = continueActive && live?.status === "active" ? live : (audit && auditRow(audit)) ?? live;
     if (!row) return { ok: false, ...unknownDelivery(id) };
     const again = resumeRefusal(row, store);
-    if (again) return { ok: false, ...again };
+    if (continueActive && row.status === "active") {
+      if (store.runs.some((r) => r.deliveryId === row.deliveryId && runIsLive(r))) {
+        return { ok: false, ...refusal("deliveryRunGoing", "the delivery still has a running agent; stop it before continuing") };
+      }
+    } else if (again) return { ok: false, ...again };
     const at = Date.now();
     const resumed = {
       ...row,
-      cloudExecution: executionOf() ?? row.cloudExecution,
+      cloudExecution: execution ?? executionOf() ?? row.cloudExecution,
       status: "active",
       endedAt: void 0,
       steps: [...row.steps, { step: "resume", at }],
@@ -16671,10 +16948,10 @@ function carryOnFrom(deliveryId) {
 function approvedRequirements(cardId2) {
   const found2 = locate(cardId2);
   if (!found2) return "";
-  const file = found2.kind === "group" ? path46.join(found2.target, "root.md") : found2.target;
+  const file = found2.kind === "group" ? path47.join(found2.target, "root.md") : found2.target;
   let text5;
   try {
-    text5 = fs42.readFileSync(file, "utf8");
+    text5 = fs43.readFileSync(file, "utf8");
   } catch {
     return "";
   }
@@ -16704,8 +16981,8 @@ function cardMeta2(cardId2) {
   try {
     const found2 = locate(cardId2);
     if (!found2) return null;
-    const file = found2.kind === "group" ? path46.join(found2.target, "root.md") : found2.target;
-    return parseFrontmatter(fs42.readFileSync(file, "utf8")).meta;
+    const file = found2.kind === "group" ? path47.join(found2.target, "root.md") : found2.target;
+    return parseFrontmatter(fs43.readFileSync(file, "utf8")).meta;
   } catch {
     return null;
   }
@@ -16954,6 +17231,7 @@ var init_deliveries = __esm({
     init_complete();
     init_outputs();
     init_env();
+    init_stop();
     init_flows();
     init_pause();
     init_rules2();
@@ -16963,7 +17241,7 @@ var init_deliveries = __esm({
     init_store();
     init_types3();
     init_worktree();
-    auditPath = (deliveryId) => path46.join(DELIVERIES, `${deliveryId}.json`);
+    auditPath = (deliveryId) => path47.join(DELIVERIES, `${deliveryId}.json`);
     activeAudits = () => allAudits().filter((a) => a.status === "active");
     auditRow = (audit) => readDeliveryRow({ ...audit, sessions: audit.sessions.map((s) => s.sessionId) });
     lastSessionRunning = (audit) => audit.sessions[audit.sessions.length - 1]?.status === "running";
@@ -16991,6 +17269,41 @@ var init_deliveries = __esm({
   }
 });
 
+// ../cli/src/lib/agent/landing-lock.ts
+import fs44 from "node:fs";
+import path48 from "node:path";
+function lockLanding() {
+  const dir = path48.join(SESSIONS_DIR, ".landing.lock");
+  try {
+    const entries = fs44.readdirSync(dir);
+    const token3 = entries.length === 1 ? entries[0] : "";
+    const match = /^(\d+)-[a-f0-9-]{36}$/.exec(token3);
+    const stat = fs44.statSync(dir);
+    if (match && Date.now() - stat.mtimeMs > landingLimits.staleMs) {
+      stopWatchers(void 0, Number(match[1]), () => {
+        const now = fs44.readdirSync(dir);
+        return now.length === 1 && now[0] === token3 && Date.now() - fs44.statSync(dir).mtimeMs > landingLimits.staleMs;
+      }, stat.birthtimeMs || stat.mtimeMs);
+    }
+  } catch {
+  }
+  return tryLock(dir);
+}
+function renewLandingLock() {
+  const now = /* @__PURE__ */ new Date();
+  fs44.utimesSync(path48.join(SESSIONS_DIR, ".landing.lock"), now, now);
+}
+var landingLimits;
+var init_landing_lock = __esm({
+  "../cli/src/lib/agent/landing-lock.ts"() {
+    "use strict";
+    init_lock();
+    init_paths();
+    init_stop();
+    landingLimits = { staleMs: 5 * 6e4 };
+  }
+});
+
 // ../cli/src/lib/agent/answers.ts
 function answerOutcome(delivery) {
   return pendingAnswers(delivery).some((a) => a.outcome === "changed") ? "changed" : "unchanged";
@@ -17055,8 +17368,8 @@ var init_retry = __esm({
 });
 
 // ../cli/src/lib/agent/landing.ts
-import fs43 from "node:fs";
-import path47 from "node:path";
+import fs45 from "node:fs";
+import path49 from "node:path";
 function waitingOut(delivery, now = Date.now()) {
   const landing = delivery.landing;
   if (!landing) return false;
@@ -17192,8 +17505,9 @@ function noteQueue(held4) {
 }
 async function advanceLanding() {
   let release;
+  let current;
   try {
-    release = tryLock(path47.join(SESSIONS_DIR, ".landing.lock"));
+    release = lockLanding();
     if (!release) return null;
     const owed = await owedRestart();
     if (owed) return owed;
@@ -17208,11 +17522,19 @@ async function advanceLanding() {
         return null;
       }
       tried.add(picked.deliveryId);
+      current = picked;
+      renewLandingLock();
       const step = await landStep(picked);
       if (step.start) return step.start;
       if (!step.done) return null;
     }
-  } catch {
+  } catch (error) {
+    if (current && error instanceof GitTimeoutError) {
+      giveUpSlot(current, error.message);
+      patchLanding(current.deliveryId, (landing) => {
+        landing.retryAt = Date.now() + 3e4;
+      });
+    }
     return null;
   } finally {
     release?.();
@@ -17529,7 +17851,7 @@ async function settleAlreadyLanded(delivery) {
   return true;
 }
 function repairLanding() {
-  const release = tryLock(path47.join(SESSIONS_DIR, ".landing.lock"));
+  const release = lockLanding();
   if (!release) return [];
   try {
     return repairIdleLanding();
@@ -17562,7 +17884,7 @@ var init_landing = __esm({
     init_execution();
     init_board();
     init_io();
-    init_lock();
+    init_landing_lock();
     init_paths();
     init_answers();
     init_commit_mode();
@@ -17603,9 +17925,9 @@ var init_landing = __esm({
     sameDir = (a, b) => {
       const real2 = (dir) => {
         try {
-          return fs43.realpathSync(dir);
+          return fs45.realpathSync(dir);
         } catch {
-          return path47.resolve(dir);
+          return path49.resolve(dir);
         }
       };
       return real2(a) === real2(b);
@@ -17614,35 +17936,35 @@ var init_landing = __esm({
 });
 
 // ../cli/src/lib/agent/pictures.ts
-import fs44 from "node:fs";
-import path48 from "node:path";
+import fs46 from "node:fs";
+import path50 from "node:path";
 function claimRunPictures(box2, sessionId, names4 = []) {
   if (!box2 || !freeBox(box2) || names4.length === 0) return [];
   const from = pictureBox(box2);
   const to = pictureBox(sessionId);
   try {
-    fs44.mkdirSync(SESSIONS_DIR, { recursive: true });
-    fs44.renameSync(from, to);
+    fs46.mkdirSync(SESSIONS_DIR, { recursive: true });
+    fs46.renameSync(from, to);
   } catch {
     return [];
   }
-  return names4.filter(pictureName).map((name) => path48.join(to, name)).filter((file) => fs44.existsSync(file));
+  return names4.filter(pictureName).map((name) => path50.join(to, name)).filter((file) => fs46.existsSync(file));
 }
 function returnRunPictures(sessionId, box2) {
   if (!box2 || !boxId(box2)) return;
   try {
-    fs44.renameSync(pictureBox(sessionId), pictureBox(box2));
+    fs46.renameSync(pictureBox(sessionId), pictureBox(box2));
   } catch {
   }
 }
 function moveRunPictures(from, to, files2 = []) {
   if (files2.length === 0) return [];
   try {
-    fs44.renameSync(pictureBox(from), pictureBox(to));
+    fs46.renameSync(pictureBox(from), pictureBox(to));
   } catch {
     return files2;
   }
-  return files2.map((file) => path48.join(pictureBox(to), path48.basename(file)));
+  return files2.map((file) => path50.join(pictureBox(to), path50.basename(file)));
 }
 var pictureName, boxId, freeBox, pictureBox;
 var init_pictures = __esm({
@@ -17651,14 +17973,14 @@ var init_pictures = __esm({
     init_paths();
     pictureName = (name) => /^[0-9a-f-]{36}\.[a-z0-9]{2,5}$/.test(name);
     boxId = (box2) => /^[0-9a-f-]{36}$/.test(box2);
-    freeBox = (box2) => boxId(box2) && !fs44.existsSync(path48.join(SESSIONS_DIR, `${box2}.log`));
-    pictureBox = (box2) => path48.join(SESSIONS_DIR, `${box2}.images`);
+    freeBox = (box2) => boxId(box2) && !fs46.existsSync(path50.join(SESSIONS_DIR, `${box2}.log`));
+    pictureBox = (box2) => path50.join(SESSIONS_DIR, `${box2}.images`);
   }
 });
 
 // ../cli/src/lib/memories.ts
-import fs45 from "node:fs";
-import path49 from "node:path";
+import fs47 from "node:fs";
+import path51 from "node:path";
 function readMemory(text5, builtIn, folder) {
   const { meta, body } = splitFrontmatter(text5);
   if (meta === null) return null;
@@ -17678,7 +18000,7 @@ function readMemory(text5, builtIn, folder) {
     rules: body.trim(),
     text: text5,
     builtIn,
-    dir: path49.join(MEMORY, folder)
+    dir: path51.join(MEMORY, folder)
   };
 }
 function globalMemories() {
@@ -17689,14 +18011,14 @@ function globalMemories() {
   }
   let folders2 = [];
   try {
-    folders2 = fs45.readdirSync(MEMORY, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    folders2 = fs47.readdirSync(MEMORY, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
   }
   for (const name of folders2) {
     if (name in BUNDLED_MEMORY_FILES || name === RESERVED_MEMORY_DIR) continue;
-    const file = path49.join(MEMORY, name, GLOBAL_MEMORY_FILE);
-    if (!fs45.existsSync(file)) continue;
-    const memory = readMemory(fs45.readFileSync(file, "utf8"), false, name);
+    const file = path51.join(MEMORY, name, GLOBAL_MEMORY_FILE);
+    if (!fs47.existsSync(file)) continue;
+    const memory = readMemory(fs47.readFileSync(file, "utf8"), false, name);
     if (memory) out.push(memory);
   }
   return out;
@@ -17752,16 +18074,16 @@ var init_facts = __esm({
 });
 
 // ../cli/src/lib/view/archive.ts
-import fs46 from "node:fs";
-import path50 from "node:path";
+import fs48 from "node:fs";
+import path52 from "node:path";
 function archivedId(file) {
-  const own = idPrefix(path50.basename(file));
-  return own !== null ? own : idPrefix(path50.basename(path50.dirname(file)));
+  const own = idPrefix(path52.basename(file));
+  return own !== null ? own : idPrefix(path52.basename(path52.dirname(file)));
 }
 function readFile(file) {
   const id = archivedId(file);
   if (id === null) return null;
-  const { meta, body } = parseFrontmatter(fs46.readFileSync(file, "utf8"));
+  const { meta, body } = parseFrontmatter(fs48.readFileSync(file, "utf8"));
   if (!meta) return null;
   return {
     row: {
@@ -17769,15 +18091,15 @@ function readFile(file) {
       title: meta.title,
       archived: meta.archived,
       rejected: meta.rejected,
-      relPath: rel(file).split(path50.sep).join("/")
+      relPath: rel(file).split(path52.sep).join("/")
     },
     body: body.replace(/^\n+/, "").replace(/\s+$/, ""),
     meta
   };
 }
 function readArchive() {
-  const relPath = rel(ARCHIVE).split(path50.sep).join("/");
-  if (!fs46.existsSync(ARCHIVE)) return { relPath, cards: [] };
+  const relPath = rel(ARCHIVE).split(path52.sep).join("/");
+  if (!fs48.existsSync(ARCHIVE)) return { relPath, cards: [] };
   const cards = walkMd(ARCHIVE).map(readFile).filter((found2) => found2 !== null).map((found2) => found2.row);
   cards.sort((a, b) => b.id - a.id);
   return { relPath, cards };
@@ -17792,7 +18114,7 @@ var init_archive = __esm({
 });
 
 // ../cli/src/lib/agent/prompts.ts
-import path51 from "node:path";
+import path53 from "node:path";
 function resumePrompt(deliveryId, cardId2, action) {
   if (!deliveryId) return RESUME_PROMPT;
   if (action === "conflict") {
@@ -17836,7 +18158,7 @@ function buildAsk(rawReq, notes = []) {
 }
 function cardFileOf(id) {
   const found2 = id === void 0 ? null : locate(id);
-  return found2 ? found2.kind === "group" ? path51.join(found2.target, "root.md") : found2.target : "";
+  return found2 ? found2.kind === "group" ? path53.join(found2.target, "root.md") : found2.target : "";
 }
 function realPaths(text5, req) {
   if (req.action !== "scheduled" && req.action !== "sub") return text5;
@@ -17929,7 +18251,7 @@ function frozenRules(req) {
 function archivedCardFile(id) {
   const found2 = locateArchived(id);
   if (!found2) return `${rel(ARCHIVE)}/`;
-  return rel(found2.kind === "group" ? path51.join(found2.target, "root.md") : found2.target);
+  return rel(found2.kind === "group" ? path53.join(found2.target, "root.md") : found2.target);
 }
 function shippedLines(cardId2) {
   const delivery = endedDelivery(`${cardId2}`);
@@ -18100,7 +18422,7 @@ function actionPrompt(req, command, notes) {
     case "spec": {
       const agent = findSpecAgent(req.specAgent ?? "");
       const found2 = req.id === void 0 ? null : locate(req.id);
-      const cardFile3 = found2 ? rel(found2.kind === "group" ? path51.join(found2.target, "root.md") : found2.target) : `task #${req.id}`;
+      const cardFile3 = found2 ? rel(found2.kind === "group" ? path53.join(found2.target, "root.md") : found2.target) : `task #${req.id}`;
       const own = agent ? specAgentInstructions(agent) : null;
       if (own) notes.push(...own.notes);
       const memory = agent ? agentMemoryBlock(agent) : "";
@@ -18212,289 +18534,82 @@ ${shared}` : ""
         `${kb}. Task ${req.id} ${named2} has been approved: write the previews that were waiting on that Approve from the card as it stands.`,
         req.notes ? `Extra notes: ${req.notes}` : "",
         `Don't ask me questions with human-in-the-loop. Leave any questions as open questions.`
-      ].filter(Boolean).join(" ");
-    case "resolve":
-      return [
-        `${kb}. Apply my answers to the open questions on task ${req.id} ${named2} following \`akb guide resolve\`.`,
-        carriedNote(req),
-        answeredNote(req.id, command),
-        req.notes ? `Extra notes: ${req.notes}` : ""
-      ].filter(Boolean).join(" ");
-  }
-}
-function discardedCardsPrompt(cards = []) {
-  if (!cards.length) return "";
-  return "The user discarded the cards listed below. Their absence is intentional. Do not restore or recreate them, including under new IDs or filenames. Continue the remaining work from the current board, preserving the other cards.\n\n" + cards.map((c) => `- #${c.id}: ${c.path}`).join("\n");
-}
-var RESUME_PROMPT, DELIVERY_RESUME, DELIVERY_RESUME_CARD, RESTARTABLE, RESTART_LEAD, restartable, NO_IMPLEMENT, BOARD_FOLDER, CARD_FILE, PROJECT_FOLDER, PLANNING_FOR, SPEC_SELECTOR_FOR, reflectedCards;
-var init_prompts = __esm({
-  "../cli/src/lib/agent/prompts.ts"() {
-    "use strict";
-    init_cards();
-    init_memory();
-    init_memories();
-    init_paths();
-    init_agents();
-    init_command();
-    init_deliveries();
-    init_env();
-    init_facts();
-    init_outputs();
-    init_archive();
-    init_flows();
-    init_resolve();
-    init_runner();
-    init_workflows();
-    init_catalog2();
-    init_roles();
-    init_rules2();
-    init_settings2();
-    init_types3();
-    RESUME_PROMPT = [
-      `Continue. The previous run ended before it finished the task.`,
-      `Pick up where you left off and carry it through.`
-    ].join(" ");
-    DELIVERY_RESUME = [
-      `Continue delivery %s. The previous run ended before the delivery finished.`,
-      `Re-enter the flow from the top and check each step's precondition before you do it \u2014 work that is already done is done, so do not repeat it.`
-    ].join(" ");
-    DELIVERY_RESUME_CARD = `Build the card as the delivery holds it, not as the file reads now: \`%c\` prints the approved copy.`;
-    RESTARTABLE = /* @__PURE__ */ new Set([
-      "implement",
-      "clarify",
-      "resolve",
-      "approve",
-      "archive",
-      "spec",
-      "conflict",
-      "scheduled"
-    ]);
-    RESTART_LEAD = [
-      `The session you were continuing is gone, and this one holds nothing of it.`,
-      `Do the task below from the top, checking each step's precondition before you do it \u2014 work an earlier run already finished is done, so don't repeat it.`
-    ].join(" ");
-    restartable = (run2) => (run2.cardId !== null || !!run2.deliveryId) && RESTARTABLE.has(run2.action);
-    NO_IMPLEMENT = `(Unless the request explicitly asks for implementation, don't implement it; revising the card's drafts is not implementing.)`;
-    BOARD_FOLDER = "<board folder>";
-    CARD_FILE = "<card file>";
-    PROJECT_FOLDER = "<project folder>";
-    PLANNING_FOR = /* @__PURE__ */ new Set(["create", "clarify", "resolve", "approve", "edit"]);
-    SPEC_SELECTOR_FOR = /* @__PURE__ */ new Set(["clarify", "resolve", "approve", "edit"]);
-    reflectedCards = (req) => req.cards ?? (req.id !== void 0 ? [req.id] : []);
-  }
-});
-
-// ../cli/src/lib/agent/stop.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import fs47 from "node:fs";
-import os6 from "node:os";
-function markedInProc(entry, strict = false) {
-  const pids = [];
-  for (const name of fs47.readdirSync("/proc")) {
-    if (!/^\d+$/.test(name)) continue;
-    try {
-      if (fs47.readFileSync(`/proc/${name}/environ`, "utf8").split("\0").includes(entry)) pids.push(Number(name));
-    } catch (error) {
-      if (strict && !["ENOENT", "ESRCH"].includes(error.code ?? "")) {
-        const stat = fs47.statSync(`/proc/${name}`, { throwIfNoEntry: false });
-        if (stat?.uid === process.getuid?.()) throw error;
-      }
-    }
-  }
-  return pids;
-}
-function markedInPs(entry, roots) {
-  const ps = spawnSync4("ps", ["-A", "-E", "-ww", "-o", "pid=,ppid=,command="], {
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    timeout: 5e3
-  });
-  if (ps.status !== 0 || !ps.stdout) throw new Error("\u65E0\u6CD5\u67E5\u8BE2\u8FDB\u7A0B\u6811\u3002");
-  const children = /* @__PURE__ */ new Map();
-  const listed2 = /* @__PURE__ */ new Set();
-  const found2 = /* @__PURE__ */ new Set();
-  for (const line of ps.stdout.split("\n")) {
-    const m = /^\s*(\d+)\s+(\d+)\s(.*)$/.exec(line);
-    if (!m) continue;
-    const pid = Number(m[1]);
-    const ppid = Number(m[2]);
-    listed2.add(pid);
-    children.set(ppid, [...children.get(ppid) ?? [], pid]);
-    if (`${m[3]} `.includes(` ${entry} `)) found2.add(pid);
-  }
-  const queue = [...found2, ...roots.filter((pid) => listed2.has(pid))];
-  for (const pid of queue) {
-    found2.add(pid);
-    for (const child of children.get(pid) ?? []) if (!found2.has(child)) queue.push(child);
-  }
-  return [...found2];
-}
-function marked(mark, roots = []) {
-  if (WINDOWS3 || !mark.value) return [];
-  const entry = `${mark.name}=${mark.value}`;
-  try {
-    const pids = process.platform === "linux" ? markedInProc(entry) : markedInPs(entry, roots);
-    return pids.filter((pid) => pid !== process.pid);
-  } catch {
-    return [];
-  }
-}
-function signal(pids, sig) {
-  for (const pid of pids) {
-    try {
-      process.kill(pid, sig);
-    } catch {
-    }
-  }
-}
-function startedUnder(list, root, since) {
-  const self = list.procs.find((p) => p.pid === root);
-  const from = since ?? self?.startedAt;
-  if (from === void 0 || list.bootedAt > from) return [];
-  if (self && self.startedAt > from) return [];
-  const found2 = self ? [root] : [];
-  const seen = /* @__PURE__ */ new Set([root]);
-  const queue = [{ pid: root, startedAt: from }];
-  for (const parent of queue) {
-    for (const p of list.procs) {
-      if (p.ppid !== parent.pid || seen.has(p.pid) || p.startedAt < parent.startedAt) continue;
-      seen.add(p.pid);
-      found2.push(p.pid);
-      queue.push(p);
-    }
-  }
-  return found2.reverse();
-}
-function readProcList(out) {
-  const procs = [];
-  let bootedAt;
-  for (const line of out.split(/\r?\n/)) {
-    const boot = /^boot (\d+)$/.exec(line.trim());
-    if (boot) bootedAt = Number(boot[1]);
-    const m = /^(\d+) (\d+) (\d+)$/.exec(line.trim());
-    if (m) procs.push({ pid: Number(m[1]), ppid: Number(m[2]), startedAt: Number(m[3]) });
-  }
-  return bootedAt !== void 0 && procs.length ? { procs, bootedAt } : void 0;
-}
-function procsOnWindows() {
-  const ps = spawnSync4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", LIST_PROCS], {
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    timeout: 5e3,
-    windowsHide: true
-  });
-  return ps.status === 0 && ps.stdout ? readProcList(ps.stdout) : void 0;
-}
-function killUnderOnWindows(pid, since) {
-  if (!WINDOWS3 || !pid) return;
-  const list = procsOnWindows();
-  if (!list) return;
-  const pids = startedUnder(list, pid, since).filter((p) => p !== process.pid);
-  if (!pids.length) return;
-  spawnSync4("taskkill", ["/F", ...pids.flatMap((p) => ["/PID", String(p)])], { stdio: "ignore", windowsHide: true, timeout: 1e4 });
-}
-function killMarked(mark, agent) {
-  if (WINDOWS3) {
-    if (agent) killUnderOnWindows(agent.pid, agent.since);
-    return;
-  }
-  signal(marked(mark), "SIGKILL");
-}
-function killTreeOnWindows(pid) {
-  if (!WINDOWS3 || !pid) return false;
-  const out = spawnSync4("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 1e4 });
-  return out.status === 0;
-}
-function later(ms, fn) {
-  const t = setTimeout(fn, ms);
-  if (typeof t.unref === "function") t.unref();
-}
-function endAgent(child, mark, graceMs) {
-  const term = (sig) => {
-    try {
-      child.kill(sig);
-    } catch {
-    }
-  };
-  if (killTreeOnWindows(child.pid)) return;
-  killUnderOnWindows(child.pid);
-  const seen = new Set(marked(mark, child.pid ? [child.pid] : []));
-  term("SIGTERM");
-  signal([...seen].filter((pid) => pid !== child.pid), "SIGTERM");
-  const round = (left) => {
-    const pids = marked(mark, [...seen]);
-    signal(pids, "SIGKILL");
-    for (const pid of pids) seen.add(pid);
-    if (pids.length && left > 1) later(KILL_ROUND_MS, () => round(left - 1));
-  };
-  later(graceMs, () => {
-    term("SIGKILL");
-    round(KILL_ROUNDS);
-  });
-}
-function killRunning() {
-  for (const [child, mark] of running) {
-    if (killTreeOnWindows(child.pid)) continue;
-    killUnderOnWindows(child.pid);
-    signal(marked(mark, child.pid ? [child.pid] : []), "SIGKILL");
-    try {
-      child.kill("SIGKILL");
-    } catch {
-    }
+      ].filter(Boolean).join(" ");
+    case "resolve":
+      return [
+        `${kb}. Apply my answers to the open questions on task ${req.id} ${named2} following \`akb guide resolve\`.`,
+        carriedNote(req),
+        answeredNote(req.id, command),
+        req.notes ? `Extra notes: ${req.notes}` : ""
+      ].filter(Boolean).join(" ");
   }
-  running.clear();
-}
-function unlisten() {
-  for (const [sig, fn] of listening) process.removeListener(sig, fn);
-  listening.clear();
-}
-function onQuit(sig) {
-  killRunning();
-  unlisten();
-  if (process.listenerCount(sig) === 0) process.exit(128 + os6.constants.signals[sig]);
 }
-function trackAgent(child, mark) {
-  if (!child.pid) return;
-  running.set(child, mark);
-  child.once("close", () => {
-    running.delete(child);
-    if (!running.size) unlisten();
-  });
-  for (const sig of QUIT_SIGNALS) {
-    if (listening.has(sig) || sig === "SIGINT" && interruptIsTheCallers) continue;
-    const fn = () => onQuit(sig);
-    listening.set(sig, fn);
-    process.on(sig, fn);
-  }
+function discardedCardsPrompt(cards = []) {
+  if (!cards.length) return "";
+  return "The user discarded the cards listed below. Their absence is intentional. Do not restore or recreate them, including under new IDs or filenames. Continue the remaining work from the current board, preserving the other cards.\n\n" + cards.map((c) => `- #${c.id}: ${c.path}`).join("\n");
 }
-var runMark, stopMark, markEnv, WINDOWS3, KILL_ROUND_MS, KILL_ROUNDS, LIST_PROCS, running, QUIT_SIGNALS, listening, interruptIsTheCallers;
-var init_stop = __esm({
-  "../cli/src/lib/agent/stop.ts"() {
+var RESUME_PROMPT, DELIVERY_RESUME, DELIVERY_RESUME_CARD, RESTARTABLE, RESTART_LEAD, restartable, NO_IMPLEMENT, BOARD_FOLDER, CARD_FILE, PROJECT_FOLDER, PLANNING_FOR, SPEC_SELECTOR_FOR, reflectedCards;
+var init_prompts = __esm({
+  "../cli/src/lib/agent/prompts.ts"() {
     "use strict";
+    init_cards();
+    init_memory();
+    init_memories();
+    init_paths();
+    init_agents();
+    init_command();
+    init_deliveries();
     init_env();
-    runMark = (sessionId) => ({ name: RUN_ENV, value: sessionId });
-    stopMark = () => ({ name: STOP_ENV, value: randomUUID5() });
-    markEnv = (env2, mark) => ({ ...env2, [mark.name]: mark.value });
-    WINDOWS3 = process.platform === "win32";
-    KILL_ROUND_MS = 300;
-    KILL_ROUNDS = 3;
-    LIST_PROCS = [
-      "$ErrorActionPreference = 'Stop'",
-      "Get-CimInstance Win32_Process | ForEach-Object { if ($_.CreationDate) { '{0} {1} {2}' -f $_.ProcessId, $_.ParentProcessId, ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() } }",
-      "'boot {0}' -f ([DateTimeOffset](Get-CimInstance Win32_OperatingSystem).LastBootUpTime).ToUnixTimeMilliseconds()"
-    ].join("; ");
-    running = /* @__PURE__ */ new Map();
-    QUIT_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
-    listening = /* @__PURE__ */ new Map();
-    interruptIsTheCallers = false;
+    init_facts();
+    init_outputs();
+    init_archive();
+    init_flows();
+    init_resolve();
+    init_runner();
+    init_workflows();
+    init_catalog2();
+    init_roles();
+    init_rules2();
+    init_settings2();
+    init_types3();
+    RESUME_PROMPT = [
+      `Continue. The previous run ended before it finished the task.`,
+      `Pick up where you left off and carry it through.`
+    ].join(" ");
+    DELIVERY_RESUME = [
+      `Continue delivery %s. The previous run ended before the delivery finished.`,
+      `Re-enter the flow from the top and check each step's precondition before you do it \u2014 work that is already done is done, so do not repeat it.`
+    ].join(" ");
+    DELIVERY_RESUME_CARD = `Build the card as the delivery holds it, not as the file reads now: \`%c\` prints the approved copy.`;
+    RESTARTABLE = /* @__PURE__ */ new Set([
+      "implement",
+      "clarify",
+      "resolve",
+      "approve",
+      "archive",
+      "spec",
+      "conflict",
+      "scheduled"
+    ]);
+    RESTART_LEAD = [
+      `The session you were continuing is gone, and this one holds nothing of it.`,
+      `Do the task below from the top, checking each step's precondition before you do it \u2014 work an earlier run already finished is done, so don't repeat it.`
+    ].join(" ");
+    restartable = (run2) => (run2.cardId !== null || !!run2.deliveryId) && RESTARTABLE.has(run2.action);
+    NO_IMPLEMENT = `(Unless the request explicitly asks for implementation, don't implement it; revising the card's drafts is not implementing.)`;
+    BOARD_FOLDER = "<board folder>";
+    CARD_FILE = "<card file>";
+    PROJECT_FOLDER = "<project folder>";
+    PLANNING_FOR = /* @__PURE__ */ new Set(["create", "clarify", "resolve", "approve", "edit"]);
+    SPEC_SELECTOR_FOR = /* @__PURE__ */ new Set(["clarify", "resolve", "approve", "edit"]);
+    reflectedCards = (req) => req.cards ?? (req.id !== void 0 ? [req.id] : []);
   }
 });
 
 // ../cli/src/lib/agent/sessions.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import fs48 from "node:fs";
-import path52 from "node:path";
+import fs49 from "node:fs";
+import path54 from "node:path";
 function reap(runs, reaped = [], restore = []) {
   let changed = false;
   const now = Date.now();
@@ -18514,7 +18629,7 @@ function reap(runs, reaped = [], restore = []) {
 }
 function stampDuration(run2, endedAt) {
   try {
-    fs48.appendFileSync(run2.logPath, durationLine(endedAt - run2.startedAt));
+    fs49.appendFileSync(run2.logPath, durationLine(endedAt - run2.startedAt));
   } catch {
   }
 }
@@ -18528,7 +18643,7 @@ function cardNow(cardId2) {
   try {
     const file = cardFile(cardId2);
     if (!file) return null;
-    const { meta } = parseFrontmatter(fs48.readFileSync(file, "utf8"));
+    const { meta } = parseFrontmatter(fs49.readFileSync(file, "utf8"));
     if (!meta) return null;
     return { status: meta.status || "todo", questions: openOf(meta.questions).length, title: meta.title };
   } catch {
@@ -18665,9 +18780,9 @@ function leftBoardOnLanding(id) {
 function archivedRejected(id) {
   const filed = locateArchived(id);
   if (!filed) return null;
-  const file = filed.kind === "group" ? path52.join(filed.target, "root.md") : filed.target;
+  const file = filed.kind === "group" ? path54.join(filed.target, "root.md") : filed.target;
   try {
-    return !!parseFrontmatter(fs48.readFileSync(file, "utf8")).meta?.rejected;
+    return !!parseFrontmatter(fs49.readFileSync(file, "utf8")).meta?.rejected;
   } catch {
     return false;
   }
@@ -18924,7 +19039,7 @@ function openRun(req, prompt, notes = [], sessionId = randomUUID6(), said3) {
   return { run: record, spec };
 }
 function planningSession(cardId2, cwd = REPO_ROOT) {
-  const here = (dir) => !dir || path52.resolve(dir) === cwd;
+  const here = (dir) => !dir || path54.resolve(dir) === cwd;
   const ended = readRuns().filter((r) => r.status === "done").sort((a, b) => b.startedAt - a.startedAt);
   const of = (run3, fork) => {
     if (!here(run3.cwd)) return { none: "elsewhere" };
@@ -19146,8 +19261,8 @@ async function resumeHeld(prev, plan, sessionId, resuming, fresh) {
   clearAsks(prev.sessionId);
   try {
     if (prev.action !== "create") {
-      fs48.unlinkSync(prev.logPath);
-      fs48.rmSync(eventsPathOf(prev.sessionId), { force: true });
+      fs49.unlinkSync(prev.logPath);
+      fs49.rmSync(eventsPathOf(prev.sessionId), { force: true });
     }
   } catch {
   }
@@ -19171,8 +19286,8 @@ function forgetRun(sessionId) {
   if (!gone) return;
   clearAsks(sessionId);
   try {
-    fs48.unlinkSync(gone.logPath);
-    fs48.rmSync(eventsPathOf(gone.sessionId), { force: true });
+    fs49.unlinkSync(gone.logPath);
+    fs49.rmSync(eventsPathOf(gone.sessionId), { force: true });
   } catch {
   }
 }
@@ -19201,14 +19316,14 @@ function noteSpecRefusals(sessionId, refused) {
 }
 function clearAsks(sessionId) {
   try {
-    fs48.unlinkSync(asksPathOf(sessionId));
+    fs49.unlinkSync(asksPathOf(sessionId));
   } catch {
   }
 }
 function readAsks(sessionId) {
   let data;
   try {
-    data = JSON.parse(fs48.readFileSync(asksPathOf(sessionId), "utf8"));
+    data = JSON.parse(fs49.readFileSync(asksPathOf(sessionId), "utf8"));
   } catch {
     return { asks: [], refines: [], refused: [] };
   }
@@ -19235,10 +19350,10 @@ function readAsks(sessionId) {
   return { asks: asks.filter((a) => !discarded.has(a.cardId)), refines: refines.filter((a) => !discarded.has(a.cardId)), refused };
 }
 function writeAsks(sessionId, file) {
-  fs48.mkdirSync(SESSIONS_DIR, { recursive: true });
+  fs49.mkdirSync(SESSIONS_DIR, { recursive: true });
   const tmp = `${asksPathOf(sessionId)}.tmp`;
-  fs48.writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n");
-  fs48.renameSync(tmp, asksPathOf(sessionId));
+  fs49.writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n");
+  fs49.renameSync(tmp, asksPathOf(sessionId));
 }
 function markSpawned(sessionId, pid) {
   patch(sessionId, (r) => {
@@ -19326,7 +19441,10 @@ async function cancelDelivery(id) {
   if (!id.trim()) return { ok: false, ...refusal("deliveryUnnamed", "name the delivery to cancel", { action: "cancel" }) };
   const delivery = namedDelivery(id);
   if (!delivery) return { ok: false, ...unknownDelivery(id) };
-  if (delivery.status !== "active") return { ok: true, deliveryId: delivery.deliveryId };
+  if (delivery.status !== "active") {
+    tidyCheckout(delivery.deliveryId);
+    return { ok: true, deliveryId: delivery.deliveryId };
+  }
   endDelivery(delivery.deliveryId, "cancelled");
   const live = readRuns().find((r) => r.status === "running" && r.deliveryId === delivery.deliveryId && r.action !== "sub");
   if (live) await stopRun(live.sessionId);
@@ -19351,7 +19469,9 @@ async function runIsDown(sessionId) {
 }
 async function resumeDelivery(id) {
   if (!id.trim()) return { ok: false, ...refusal("deliveryUnnamed", "name the delivery to carry on", { action: "resume" }) };
-  const put = resumeRecord(id);
+  const execution = executionOf();
+  if (execution && !await executionHeld(execution)) return { ok: false, error: "\u65E0\u6CD5\u786E\u8BA4\u672C\u6B21\u7EED\u8DD1\u7684\u6267\u884C\u6743\uFF0C\u4EA4\u4ED8\u4FDD\u6301\u539F\u72B6\u3002" };
+  const put = resumeRecord(id, execution);
   if (!put.ok) return put;
   const delivery = put.delivery;
   if (await settleAlreadyLanded(delivery)) {
@@ -19392,12 +19512,12 @@ async function discardDelivery(id) {
   return { ok: true, deliveryId: delivery.deliveryId };
 }
 function writeSpec(spec) {
-  fs48.mkdirSync(SESSIONS_DIR, { recursive: true });
-  fs48.writeFileSync(specPathOf(spec.sessionId), JSON.stringify(spec, null, 2) + "\n");
+  fs49.mkdirSync(SESSIONS_DIR, { recursive: true });
+  fs49.writeFileSync(specPathOf(spec.sessionId), JSON.stringify(spec, null, 2) + "\n");
 }
 function readSpec(sessionId) {
   try {
-    const spec = JSON.parse(fs48.readFileSync(specPathOf(sessionId), "utf8"));
+    const spec = JSON.parse(fs49.readFileSync(specPathOf(sessionId), "utf8"));
     return spec && Array.isArray(spec.plan?.argv) ? spec : null;
   } catch {
     return null;
@@ -19405,28 +19525,28 @@ function readSpec(sessionId) {
 }
 function dropSpec(sessionId) {
   try {
-    fs48.unlinkSync(specPathOf(sessionId));
+    fs49.unlinkSync(specPathOf(sessionId));
   } catch {
   }
 }
 async function acquireIndexLock(giveUp) {
   const until = Date.now() + INDEX_WAIT_MS;
-  const holder = path52.join(INDEX_LOCK2, "holder");
+  const holder = path54.join(INDEX_LOCK2, "holder");
   for (; ; ) {
     if (giveUp()) return null;
     try {
-      fs48.mkdirSync(INDEX_LOCK2, { recursive: false });
-      fs48.writeFileSync(holder, String(process.pid));
-      return () => fs48.rmSync(INDEX_LOCK2, { recursive: true, force: true });
+      fs49.mkdirSync(INDEX_LOCK2, { recursive: false });
+      fs49.writeFileSync(holder, String(process.pid));
+      return () => fs49.rmSync(INDEX_LOCK2, { recursive: true, force: true });
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        fs48.mkdirSync(path52.dirname(INDEX_LOCK2), { recursive: true });
+        fs49.mkdirSync(path54.dirname(INDEX_LOCK2), { recursive: true });
         continue;
       }
       if (code !== "EEXIST") throw err;
       if (!pidAlive(Number(readHolder(holder)))) {
-        fs48.rmSync(INDEX_LOCK2, { recursive: true, force: true });
+        fs49.rmSync(INDEX_LOCK2, { recursive: true, force: true });
         continue;
       }
       if (Date.now() > until) return null;
@@ -19436,7 +19556,7 @@ async function acquireIndexLock(giveUp) {
 }
 function readHolder(file) {
   try {
-    return fs48.readFileSync(file, "utf8").trim();
+    return fs49.readFileSync(file, "utf8").trim();
   } catch {
     return String(process.pid);
   }
@@ -19445,6 +19565,7 @@ var INDEX_ACTIONS, SINGLETON_ACTIONS, VERB, SINGLETON_BUSY, RUN_STATUS, specPath
 var init_sessions = __esm({
   "../cli/src/lib/agent/sessions.ts"() {
     "use strict";
+    init_execution();
     init_creation();
     init_cards();
     init_frontmatter();
@@ -19527,8 +19648,8 @@ var init_sessions = __esm({
       conflict: "implementing",
       hook: "implementing"
     };
-    specPathOf = (sessionId) => path52.join(SESSIONS_DIR, `${sessionId}.plan.json`);
-    asksPathOf = (sessionId) => path52.join(SESSIONS_DIR, `${sessionId}.asks.json`);
+    specPathOf = (sessionId) => path54.join(SESSIONS_DIR, `${sessionId}.plan.json`);
+    asksPathOf = (sessionId) => path54.join(SESSIONS_DIR, `${sessionId}.asks.json`);
     carriesSession = (r) => !!(r.resumedFrom || r.continues && !r.continues.fork);
     canPickUp = (r) => (r.status === "error" || r.status === "interrupted" || r.status === "stopped") && !(r.action === "create" && readRuns().some((next) => next.resumedFrom === r.sessionId));
     neverStarted = (r) => r.unspawned === true || !!r.errorWhy?.some((why) => why.kind === "notInstalled");
@@ -19662,8 +19783,8 @@ var init_questions = __esm({
 });
 
 // ../cli/src/lib/agent/workflow-cards.ts
-import fs49 from "node:fs";
-import path53 from "node:path";
+import fs50 from "node:fs";
+import path55 from "node:path";
 function cardsOnWorkflow(id) {
   const wanted = id || DEFAULT_WORKFLOW;
   const ids = [];
@@ -19674,12 +19795,12 @@ function cardsOnWorkflow(id) {
     return [];
   }
   for (const file of files2) {
-    const base = path53.basename(file);
-    const card = base === "root.md" ? idPrefix(path53.basename(path53.dirname(file))) : idPrefix(base);
+    const base = path55.basename(file);
+    const card = base === "root.md" ? idPrefix(path55.basename(path55.dirname(file))) : idPrefix(base);
     if (card === null) continue;
     let meta;
     try {
-      meta = parseFrontmatter(fs49.readFileSync(file, "utf8")).meta;
+      meta = parseFrontmatter(fs50.readFileSync(file, "utf8")).meta;
     } catch {
       continue;
     }
@@ -19737,12 +19858,12 @@ var init_workflow_cards = __esm({
 });
 
 // ../cli/src/lib/readme.ts
-import fs50 from "node:fs";
-import path54 from "node:path";
+import fs51 from "node:fs";
+import path56 from "node:path";
 function stripReadmeRefs(target) {
-  if (!fs50.existsSync(README)) return [];
+  if (!fs51.existsSync(README)) return [];
   const needle = target.kind === "group" ? `](${target.rel}/` : `](${target.rel})`;
-  const lines = fs50.readFileSync(README, "utf8").split("\n");
+  const lines = fs51.readFileSync(README, "utf8").split("\n");
   const out = [];
   const removed = [];
   let i = 0;
@@ -19764,20 +19885,20 @@ function stripReadmeRefs(target) {
     out.push(line);
     i++;
   }
-  if (removed.length) fs50.writeFileSync(README, out.join("\n"));
+  if (removed.length) fs51.writeFileSync(README, out.join("\n"));
   return removed;
 }
 function addReadmeRef(id, title, relPath) {
-  if (!fs50.existsSync(README)) return false;
-  const link2 = relPath.split(path54.sep).join("/");
+  if (!fs51.existsSync(README)) return false;
+  const link2 = relPath.split(path56.sep).join("/");
   const bullet = `- [#${id} ${title}](${link2})`;
   const heading = `## ${TASKS_HEADING}`;
-  let lines = fs50.readFileSync(README, "utf8").split("\n");
+  let lines = fs51.readFileSync(README, "utf8").split("\n");
   const hi = lines.findIndex((l) => l.trim().toLowerCase() === heading.toLowerCase());
   if (hi === -1) {
     while (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
     lines.push("", heading, "", bullet);
-    fs50.writeFileSync(README, lines.join("\n") + "\n");
+    fs51.writeFileSync(README, lines.join("\n") + "\n");
     return true;
   }
   let end2 = hi + 1;
@@ -19791,15 +19912,15 @@ function addReadmeRef(id, title, relPath) {
     const at = lastBullet !== -1 ? lastBullet + 1 : lines[hi + 1] === "" ? hi + 2 : hi + 1;
     lines.splice(at, 0, bullet);
   }
-  fs50.writeFileSync(README, lines.join("\n"));
+  fs51.writeFileSync(README, lines.join("\n"));
   return true;
 }
 function repointReadmeLink(id, oldRel, newRel, title) {
-  if (!fs50.existsSync(README)) return false;
-  const oldLink = oldRel.split(path54.sep).join("/");
-  const newLink = newRel.split(path54.sep).join("/");
+  if (!fs51.existsSync(README)) return false;
+  const oldLink = oldRel.split(path56.sep).join("/");
+  const newLink = newRel.split(path56.sep).join("/");
   const linkRe = new RegExp(`\\[#${id}\\b[^\\]]*\\]\\(${escapeRegex(oldLink)}\\)`);
-  const lines = fs50.readFileSync(README, "utf8").split("\n");
+  const lines = fs51.readFileSync(README, "utf8").split("\n");
   let changed = false;
   for (let i = 0; i < lines.length; i++) {
     if (!lines[i].includes(`](${oldLink})`)) continue;
@@ -19809,7 +19930,7 @@ function repointReadmeLink(id, oldRel, newRel, title) {
       changed = true;
     }
   }
-  if (changed) fs50.writeFileSync(README, lines.join("\n"));
+  if (changed) fs51.writeFileSync(README, lines.join("\n"));
   return changed;
 }
 var isTableRow, isBulletStart, bulletIndent, TASKS_HEADING, escapeRegex;
@@ -19826,14 +19947,14 @@ var init_readme = __esm({
 });
 
 // ../cli/src/lib/reconcile.ts
-import fs51 from "node:fs";
-import path55 from "node:path";
+import fs52 from "node:fs";
+import path57 from "node:path";
 function liveIds() {
   const ids = /* @__PURE__ */ new Set();
   for (const file of walkMd(TODO)) {
-    const base = path55.basename(file);
+    const base = path57.basename(file);
     if (base === "README.md") continue;
-    const id = base === "root.md" ? idPrefix(path55.basename(path55.dirname(file))) : idPrefix(base);
+    const id = base === "root.md" ? idPrefix(path57.basename(path57.dirname(file))) : idPrefix(base);
     if (id != null) ids.add(id);
   }
   return ids;
@@ -19841,16 +19962,16 @@ function liveIds() {
 function indexableCards() {
   const out = [];
   for (const dir of walkDirs(TODO)) {
-    const id = idPrefix(path55.basename(dir));
-    if (id != null && fs51.existsSync(path55.join(dir, "root.md"))) {
-      out.push({ id, rel: path55.join(path55.relative(TODO, dir), "root.md").split(path55.sep).join("/") });
+    const id = idPrefix(path57.basename(dir));
+    if (id != null && fs52.existsSync(path57.join(dir, "root.md"))) {
+      out.push({ id, rel: path57.join(path57.relative(TODO, dir), "root.md").split(path57.sep).join("/") });
     }
   }
   for (const file of walkMd(TODO)) {
-    const base = path55.basename(file);
+    const base = path57.basename(file);
     if (base === "README.md" || base === "root.md") continue;
-    const relTODO = path55.relative(TODO, file);
-    const segs = relTODO.split(path55.sep);
+    const relTODO = path57.relative(TODO, file);
+    const segs = relTODO.split(path57.sep);
     if (segs.length !== 1) continue;
     const id = idPrefix(base);
     if (id != null) out.push({ id, rel: segs.join("/") });
@@ -19859,7 +19980,7 @@ function indexableCards() {
 }
 function readmeComplaints(fix) {
   const said3 = [];
-  const lines = fs51.readFileSync(README, "utf8").split("\n");
+  const lines = fs52.readFileSync(README, "utf8").split("\n");
   const indexed = /* @__PURE__ */ new Set();
   let fixed = 0;
   for (let i = 0; i < lines.length; i++) {
@@ -19868,13 +19989,13 @@ function readmeComplaints(fix) {
     const id = Number(m[1]);
     const linkPath = m[2];
     indexed.add(id);
-    if (fs51.existsSync(path55.join(TODO, linkPath))) continue;
+    if (fs52.existsSync(path57.join(TODO, linkPath))) continue;
     const found2 = locate(id);
     if (!found2) {
       said3.push(`README links #${id} \u2192 ${linkPath}, but no card with that id exists (removed by hand?). Drop the entry or restore the file.`);
       continue;
     }
-    const want = (found2.kind === "group" ? path55.join(found2.rel, "root.md") : found2.rel).split(path55.sep).join("/");
+    const want = (found2.kind === "group" ? path57.join(found2.rel, "root.md") : found2.rel).split(path57.sep).join("/");
     if (want === linkPath) continue;
     if (!fix) {
       said3.push(`README links #${id} \u2192 ${linkPath}, which isn't there any more; the card is at ${want}.`);
@@ -19884,7 +20005,7 @@ function readmeComplaints(fix) {
     said3.push(`README link #${id} pointed at missing ${linkPath} \u2192 repointed to ${want}.`);
     fixed++;
   }
-  if (fixed) fs51.writeFileSync(README, lines.join("\n"));
+  if (fixed) fs52.writeFileSync(README, lines.join("\n"));
   for (const c of indexableCards()) {
     if (!indexed.has(c.id)) {
       said3.push(`card ${c.rel} (#${c.id}) is not in the README index. Add it under "## ${TASKS_HEADING}".`);
@@ -19896,11 +20017,11 @@ function crossRefComplaints() {
   const said3 = [];
   const live = liveIds();
   for (const file of walkMd(TODO)) {
-    const base = path55.basename(file);
+    const base = path57.basename(file);
     if (base === "README.md") continue;
-    const ownerId = base === "root.md" ? idPrefix(path55.basename(path55.dirname(file))) : idPrefix(base);
+    const ownerId = base === "root.md" ? idPrefix(path57.basename(path57.dirname(file))) : idPrefix(base);
     if (ownerId == null) continue;
-    const { meta } = parseFrontmatter(fs51.readFileSync(file, "utf8"));
+    const { meta } = parseFrontmatter(fs52.readFileSync(file, "utf8"));
     if (!meta) continue;
     for (const field2 of ["blocked_by", "related"]) {
       for (const ref of meta[field2] || []) {
@@ -19913,11 +20034,11 @@ function crossRefComplaints() {
   return said3;
 }
 function reconcileBoard() {
-  if (!fs51.existsSync(README)) return;
+  if (!fs52.existsSync(README)) return;
   for (const line of [...readmeComplaints(true), ...crossRefComplaints()]) warn2(line);
 }
 function boardComplaints() {
-  if (!fs51.existsSync(README)) return [];
+  if (!fs52.existsSync(README)) return [];
   try {
     return [...readmeComplaints(false), ...crossRefComplaints()];
   } catch {
@@ -19937,8 +20058,8 @@ var init_reconcile = __esm({
 });
 
 // ../cli/src/commands/card.ts
-import fs52 from "node:fs";
-import path56 from "node:path";
+import fs53 from "node:fs";
+import path58 from "node:path";
 function defaultBody() {
   return [
     "<\u7528\u4E00\u5C0F\u6BB5\u8BDD\u5148\u8BB2\u53D1\u751F\u4E86\u4EC0\u4E48\u3001\u7528\u6237\u9047\u5230\u4EC0\u4E48\uFF0C\u518D\u8BB2\u8FD9\u5F20\u5361\u8981\u8FBE\u5230\u7684\u7ED3\u679C\u3002>",
@@ -19964,7 +20085,7 @@ function bodyFromFile(opts) {
   if (opts.body === false) die("pass --body-file or --no-body, not both");
   let text5;
   try {
-    text5 = fs52.readFileSync(opts.bodyFile, "utf8");
+    text5 = fs53.readFileSync(opts.bodyFile, "utf8");
   } catch {
     die(`can't read ${opts.bodyFile} \u2014 write the body to a file, then pass its path`, { kind: "needs-input" });
   }
@@ -19996,20 +20117,20 @@ function cmdCreate(opts) {
   const start = opts.id;
   const slug2 = slugify(opts.slug !== void 0 ? opts.slug : title);
   const fileRel = `${start}-${slug2}.md`;
-  const file = path56.join(TODO, fileRel);
+  const file = path58.join(TODO, fileRel);
   const held4 = locate(start) ?? locateArchived(start);
-  if (held4 && path56.basename(held4.target) === `${start}-${slug2}.md`) {
+  if (held4 && path58.basename(held4.target) === `${start}-${slug2}.md`) {
     say(start);
     say(`  ${rel(held4.target)} was already written`);
     return { id: start, ids: [start], title, file: rel(held4.target), indexed: false };
   }
   if (held4) die(`#${start} is already a card here (${rel(held4.target)})`, { kind: "id-taken", id: start });
-  if (fs52.existsSync(file)) die(`${rel(file)} already exists \u2014 pick a different --slug`);
+  if (fs53.existsSync(file)) die(`${rel(file)} already exists \u2014 pick a different --slug`);
   countBoardEvent(triage ? "cards_created_proposed" : "cards_created_asked");
   const meta = { title, priority, status: "todo", blocked_by, related, modules, workflow, triage, source, questions };
   const scaffolded = !written && opts.body !== false;
   const body = written ?? (scaffolded ? defaultBody() : "");
-  fs52.writeFileSync(file, serializeFrontmatter(meta) + "\n\n" + body);
+  fs53.writeFileSync(file, serializeFrontmatter(meta) + "\n\n" + body);
   const indexed = addReadmeRef(start, title, fileRel);
   say(start);
   say(
@@ -20047,8 +20168,8 @@ function cmdUpdate(id, flags) {
   if (creating) die(creating, { kind: "card-being-created", id });
   const found2 = locate(id);
   if (!found2) die(`no task with id ${id} under ${rel(TODO)}`, { kind: "card-not-found", id });
-  const file = found2.kind === "group" ? path56.join(found2.target, "root.md") : found2.target;
-  const { meta, body } = parseFrontmatter(fs52.readFileSync(file, "utf8"));
+  const file = found2.kind === "group" ? path58.join(found2.target, "root.md") : found2.target;
+  const { meta, body } = parseFrontmatter(fs53.readFileSync(file, "utf8"));
   if (!meta) die(`${rel(file)} has no frontmatter \u2014 run \`migrate\` first`);
   if (flags.blockedBy !== void 0 && flags.addBlockedBy !== void 0) die("--blocked-by replaces the list and --add-blocked-by appends to it \u2014 pass one");
   if (flags.related !== void 0 && flags.addRelated !== void 0) die("--related replaces the list and --add-related appends to it \u2014 pass one");
@@ -20128,26 +20249,26 @@ function cmdUpdate(id, flags) {
     meta.status = "todo";
     changes.push("status\u2192todo (open questions)");
   }
-  const curRel = path56.relative(TODO, file);
+  const curRel = path58.relative(TODO, file);
   const isSubtask = found2.kind === "file" && enclosingGroupRoot(file) !== null;
-  let base = path56.basename(file);
+  let base = path58.basename(file);
   if (flags.slug !== void 0) {
     if (found2.kind === "group") die("renaming a group root by script is not supported");
     base = `${id}-${slugify(flags.slug)}.md`;
   }
-  const destRel = path56.join(path56.dirname(curRel), base);
-  const dest = path56.join(TODO, destRel);
+  const destRel = path58.join(path58.dirname(curRel), base);
+  const dest = path58.join(TODO, destRel);
   const moving = dest !== file;
-  if (moving && fs52.existsSync(dest)) die(`${rel(dest)} already exists`);
-  fs52.writeFileSync(file, serializeFrontmatter(meta) + "\n" + body);
-  if (moving) fs52.renameSync(file, dest);
+  if (moving && fs53.existsSync(dest)) die(`${rel(dest)} already exists`);
+  fs53.writeFileSync(file, serializeFrontmatter(meta) + "\n" + body);
+  if (moving) fs53.renameSync(file, dest);
   if (isSubtask) {
     if (moving || changes.includes("title")) repointReadmeLink(id, curRel, destRel, meta.title);
-    if (moving) changes.push(`renamed \u2192 ${destRel.split(path56.sep).join("/")}`);
+    if (moving) changes.push(`renamed \u2192 ${destRel.split(path58.sep).join("/")}`);
   } else if (moving) {
     stripReadmeRefs({ kind: "file", rel: curRel });
     addReadmeRef(id, meta.title, destRel);
-    changes.push(`renamed \u2192 ${destRel.split(path56.sep).join("/")}`);
+    changes.push(`renamed \u2192 ${destRel.split(path58.sep).join("/")}`);
   } else if (changes.includes("title")) {
     stripReadmeRefs({ kind: "file", rel: curRel });
     addReadmeRef(id, meta.title, curRel);
@@ -20159,8 +20280,8 @@ function cmdUpdateQuestions(id, input) {
   const ops = readQuestionOps(input.ops ?? []);
   const found2 = locate(id);
   if (!found2) die(`no task with id ${id} under ${rel(TODO)}`, { kind: "card-not-found", id });
-  const file = found2.kind === "group" ? path56.join(found2.target, "root.md") : found2.target;
-  const { meta, body } = parseFrontmatter(fs52.readFileSync(file, "utf8"));
+  const file = found2.kind === "group" ? path58.join(found2.target, "root.md") : found2.target;
+  const { meta, body } = parseFrontmatter(fs53.readFileSync(file, "utf8"));
   if (!meta) die(`${rel(file)} has no frontmatter \u2014 run \`migrate\` first`);
   if (insideRun() && ops.some((op) => op.kind === "skip" || op.kind === "unskip")) {
     die("only the user skips or reopens a question \u2014 a run leaves questions for them to answer");
@@ -20233,7 +20354,7 @@ function cmdUpdateQuestions(id, input) {
     meta.status = "todo";
     changes.push("status\u2192todo (open questions)");
   }
-  fs52.writeFileSync(file, serializeFrontmatter(meta) + "\n" + body);
+  fs53.writeFileSync(file, serializeFrontmatter(meta) + "\n" + body);
   for (const kind of closed2) countBoardEvent(kind);
   settleDelivery2(id, skipped, unskipped);
   say(
@@ -20307,13 +20428,13 @@ var init_config_template = __esm({
 });
 
 // ../cli/src/lib/agent/local.ts
-import fs53 from "node:fs";
-import path57 from "node:path";
+import fs54 from "node:fs";
+import path59 from "node:path";
 function takeLocalModels(board2) {
-  const file = path57.join(board2, ".local.json");
+  const file = path59.join(board2, ".local.json");
   let held4;
   try {
-    held4 = configBlock(JSON.parse(fs53.readFileSync(file, "utf8")));
+    held4 = configBlock(JSON.parse(fs54.readFileSync(file, "utf8")));
   } catch {
     return {};
   }
@@ -20331,7 +20452,7 @@ function takeLocalModels(board2) {
   }
   if (!Object.keys(agents).length) return out;
   delete held4.agents;
-  fs53.writeFileSync(file, JSON.stringify(held4, null, 2) + "\n");
+  fs54.writeFileSync(file, JSON.stringify(held4, null, 2) + "\n");
   return out;
 }
 var LOCAL_IGNORE_LINE;
@@ -20392,12 +20513,12 @@ var init_identity2 = __esm({
 });
 
 // ../cli/src/lib/signals/migrate.ts
-import fs54 from "node:fs";
-import path58 from "node:path";
+import fs55 from "node:fs";
+import path60 from "node:path";
 function readHandled() {
   let text5;
   try {
-    text5 = fs54.readFileSync(SIGNALS_OLD_HANDLED, "utf8");
+    text5 = fs55.readFileSync(SIGNALS_OLD_HANDLED, "utf8");
   } catch {
     return [];
   }
@@ -20414,57 +20535,57 @@ function readHandled() {
   return held4;
 }
 function lift(from, into) {
-  fs54.mkdirSync(into, { recursive: true });
-  fs54.renameSync(from, path58.join(into, freeName(into, path58.basename(from))));
+  fs55.mkdirSync(into, { recursive: true });
+  fs55.renameSync(from, path60.join(into, freeName(into, path60.basename(from))));
 }
 function repoint(dir, from, into) {
   let entries;
   try {
-    entries = fs54.readdirSync(dir, { withFileTypes: true });
+    entries = fs55.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const file = path58.join(dir, entry.name);
-    const text5 = fs54.readFileSync(file, "utf8");
-    if (text5.includes(from)) fs54.writeFileSync(file, text5.split(from).join(into));
+    const file = path60.join(dir, entry.name);
+    const text5 = fs55.readFileSync(file, "utf8");
+    if (text5.includes(from)) fs55.writeFileSync(file, text5.split(from).join(into));
   }
 }
 function dropIfEmpty2(dir) {
   try {
-    fs54.rmdirSync(dir);
+    fs55.rmdirSync(dir);
   } catch {
   }
 }
 function liftInbox() {
-  if (!fs54.existsSync(SIGNALS_OLD_INBOX)) return;
-  const oldFiles = path58.join(SIGNALS_OLD_INBOX, "files");
-  if (fs54.existsSync(oldFiles)) {
-    for (const entry of fs54.readdirSync(oldFiles, { withFileTypes: true })) {
-      if (entry.isFile()) lift(path58.join(oldFiles, entry.name), SIGNALS_FILES);
+  if (!fs55.existsSync(SIGNALS_OLD_INBOX)) return;
+  const oldFiles = path60.join(SIGNALS_OLD_INBOX, "files");
+  if (fs55.existsSync(oldFiles)) {
+    for (const entry of fs55.readdirSync(oldFiles, { withFileTypes: true })) {
+      if (entry.isFile()) lift(path60.join(oldFiles, entry.name), SIGNALS_FILES);
     }
     dropIfEmpty2(oldFiles);
   }
   const held4 = new Set(readFolder(TRIAGE).map((signal2) => signal2.sourceId));
-  for (const entry of fs54.readdirSync(SIGNALS_OLD_INBOX, { withFileTypes: true })) {
+  for (const entry of fs55.readdirSync(SIGNALS_OLD_INBOX, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const from = path58.join(SIGNALS_OLD_INBOX, entry.name);
+    const from = path60.join(SIGNALS_OLD_INBOX, entry.name);
     const item = parse(from);
     if (item && held4.has(item.sourceId)) {
-      fs54.rmSync(from, { force: true });
+      fs55.rmSync(from, { force: true });
       continue;
     }
     if (item) held4.add(item.sourceId);
     lift(from, TRIAGE);
   }
-  const wasAt = asWritten(path58.join(SIGNALS_OLD_INBOX, "files"));
+  const wasAt = asWritten(path60.join(SIGNALS_OLD_INBOX, "files"));
   const nowAt = asWritten(SIGNALS_FILES);
   for (const dir of [TRIAGE, SIGNALS_ARCHIVED, SIGNALS_DISMISSED]) repoint(dir, wasAt, nowAt);
   dropIfEmpty2(SIGNALS_OLD_INBOX);
 }
 function liftHandled() {
-  if (!fs54.existsSync(SIGNALS_OLD_HANDLED)) return;
+  if (!fs55.existsSync(SIGNALS_OLD_HANDLED)) return;
   const lines = readHandled();
   const held4 = /* @__PURE__ */ new Set([
     ...readFolder(TRIAGE).map((signal2) => signal2.sourceId),
@@ -20474,7 +20595,7 @@ function liftHandled() {
   for (const { sourceId, when } of lines) {
     if (held4.has(sourceId)) continue;
     held4.add(sourceId);
-    fs54.mkdirSync(SIGNALS_DISMISSED, { recursive: true });
+    fs55.mkdirSync(SIGNALS_DISMISSED, { recursive: true });
     const name = freeName(SIGNALS_DISMISSED, fileName("", sourceId));
     const front = [
       "---",
@@ -20484,13 +20605,13 @@ function liftHandled() {
       "---",
       ""
     ];
-    fs54.writeFileSync(path58.join(SIGNALS_DISMISSED, name), `${front.join("\n")}
+    fs55.writeFileSync(path60.join(SIGNALS_DISMISSED, name), `${front.join("\n")}
 `);
   }
-  fs54.rmSync(SIGNALS_OLD_HANDLED, { force: true });
+  fs55.rmSync(SIGNALS_OLD_HANDLED, { force: true });
 }
 function migrateTriage() {
-  if (!fs54.existsSync(SIGNALS_OLD_INBOX) && !fs54.existsSync(SIGNALS_OLD_HANDLED)) return;
+  if (!fs55.existsSync(SIGNALS_OLD_INBOX) && !fs55.existsSync(SIGNALS_OLD_HANDLED)) return;
   try {
     liftInbox();
     liftHandled();
@@ -20505,13 +20626,13 @@ var init_migrate = __esm({
     init_yaml();
     init_inbox();
     HANDLED_LINE = /^-\s+(.+?)\s+—\s+(.+)$/;
-    asWritten = (dir) => `${rel(dir).split(path58.sep).join("/")}/`;
+    asWritten = (dir) => `${rel(dir).split(path60.sep).join("/")}/`;
   }
 });
 
 // ../cli/src/lib/signals/add.ts
-import fs55 from "node:fs";
-import path59 from "node:path";
+import fs56 from "node:fs";
+import path61 from "node:path";
 import { createHash as createHash3 } from "node:crypto";
 function linkTitle(url) {
   let at;
@@ -20524,7 +20645,7 @@ function linkTitle(url) {
   return oneLine(where) || url.slice(0, TITLE_MAX);
 }
 function asText(file) {
-  const ext = path59.extname(file.name).toLowerCase();
+  const ext = path61.extname(file.name).toLowerCase();
   if (!file.type.startsWith("text/") && file.type !== "application/json" && !TEXT_EXTENSIONS.has(ext)) return null;
   try {
     const text5 = new TextDecoder("utf-8", { fatal: true }).decode(file.data);
@@ -20534,9 +20655,9 @@ function asText(file) {
   }
 }
 function fileName2(name, data) {
-  const base = path59.basename(name);
-  const ext = path59.extname(base).toLowerCase().slice(0, 12);
-  const word = path59.basename(base, path59.extname(base)).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "file";
+  const base = path61.basename(name);
+  const ext = path61.extname(base).toLowerCase().slice(0, 12);
+  const word = path61.basename(base, path61.extname(base)).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "file";
   const hash2 = createHash3("sha256").update(data).digest("hex").slice(0, 8);
   return `${word}-${hash2}${ext}`;
 }
@@ -20545,9 +20666,9 @@ function addToInbox(drop) {
   const typed = (drop.text ?? "").trim();
   const file = drop.file;
   if (!typed && !file) return { ok: false, error: "nothing to add \u2014 paste a link or some text, or drop a file." };
-  if (file && file.data.length === 0) return { ok: false, error: `${path59.basename(file.name)} is empty.` };
+  if (file && file.data.length === 0) return { ok: false, error: `${path61.basename(file.name)} is empty.` };
   if (file && file.data.length > MAX_BYTES) {
-    return { ok: false, error: `${path59.basename(file.name)} is over ${MAX_BYTES / 1024 / 1024} MB \u2014 too big for the board.` };
+    return { ok: false, error: `${path61.basename(file.name)} is over ${MAX_BYTES / 1024 / 1024} MB \u2014 too big for the board.` };
   }
   const read4 = describe(typed, file);
   const keep2 = read4.keep;
@@ -20569,8 +20690,8 @@ ${incoming.summary}`);
   if (seen.status === "pending" || seen.status === "archived") return { ok: false, error: `${sayHit(seen)}.` };
   try {
     if (keep2) {
-      fs55.mkdirSync(SIGNALS_FILES, { recursive: true });
-      fs55.writeFileSync(keep2.at, keep2.data);
+      fs56.mkdirSync(SIGNALS_FILES, { recursive: true });
+      fs56.writeFileSync(keep2.at, keep2.data);
     }
     return { ok: true, signal: writeSignal({ ...incoming, sourceId }, formatStamp(/* @__PURE__ */ new Date()), drop.slug) };
   } catch (e) {
@@ -20584,7 +20705,7 @@ function describe(typed, file) {
     return only ? [only] : [];
   };
   if (file) {
-    const name = path59.basename(file.name);
+    const name = path61.basename(file.name);
     const text5 = asText(file);
     const note = typed ? `
 
@@ -20596,7 +20717,7 @@ ${typed}` : "";
     const at = keepAt(file);
     return {
       incoming: {
-        title: path59.basename(name, path59.extname(name)) || name,
+        title: path61.basename(name, path61.extname(name)) || name,
         summary: `${name} \u2014 ${boardRel2(at)}${note}`,
         ...named2
       },
@@ -20634,73 +20755,73 @@ var init_add = __esm({
     MAX_BYTES = 25 * 1024 * 1024;
     TITLE_MAX = 120;
     TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".txt", ".text", ".csv", ".json", ".yml", ".yaml", ".log"]);
-    boardRel2 = (file) => rel(file).split(path59.sep).join("/");
+    boardRel2 = (file) => rel(file).split(path61.sep).join("/");
     oneLine = (text5) => {
       const first = text5.split("\n").find((line) => line.trim()) ?? "";
       const clean = first.replace(/^#+\s*/, "").trim();
       return clean.length > TITLE_MAX ? `${clean.slice(0, TITLE_MAX - 1).trimEnd()}\u2026` : clean;
     };
-    keepAt = (file) => path59.join(SIGNALS_FILES, fileName2(file.name, file.data));
+    keepAt = (file) => path61.join(SIGNALS_FILES, fileName2(file.name, file.data));
   }
 });
 
 // ../cli/src/lib/recurring.ts
-import fs56 from "node:fs";
-import path60 from "node:path";
+import fs57 from "node:fs";
+import path62 from "node:path";
 function migratePruneMemoryCard() {
   const dir = recurringDir();
   let names4;
   try {
-    names4 = fs56.readdirSync(dir);
+    names4 = fs57.readdirSync(dir);
   } catch {
     return null;
   }
   const name = names4.find((entry) => entry.endsWith(`-${PRUNE_SLUG}.md`));
   if (!name) return null;
-  const file = path60.join(dir, name);
+  const file = path62.join(dir, name);
   try {
-    const { meta } = parseFrontmatter(fs56.readFileSync(file, "utf8"));
+    const { meta } = parseFrontmatter(fs57.readFileSync(file, "utf8"));
     const cadence = meta?.cadence;
     if (typeof cadence === "string") adoptMemoryPruneCadence(cadence);
   } catch {
   }
-  fs56.rmSync(file, { force: true });
+  fs57.rmSync(file, { force: true });
   return rel(file);
 }
 function legacyCards() {
   const dir = recurringDir();
-  if (!fs56.existsSync(dir)) return [];
+  if (!fs57.existsSync(dir)) return [];
   const cards = [];
-  for (const entry of fs56.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs57.readdirSync(dir, { withFileTypes: true })) {
     const id = idPrefix(entry.name);
     if (id === null) continue;
-    const full = path60.join(dir, entry.name);
+    const full = path62.join(dir, entry.name);
     const slug2 = entry.name.replace(/\.md$/, "").replace(/^\d+-?/, "");
     if (entry.isFile() && entry.name.endsWith(".md")) cards.push({ id, slug: slug2, file: full });
-    else if (entry.isDirectory() && fs56.existsSync(path60.join(full, "root.md"))) {
-      cards.push({ id, slug: slug2, file: path60.join(full, "root.md"), folder: full });
+    else if (entry.isDirectory() && fs57.existsSync(path62.join(full, "root.md"))) {
+      cards.push({ id, slug: slug2, file: path62.join(full, "root.md"), folder: full });
     }
   }
   return cards.sort((a, b) => a.id - b.id);
 }
 function mergeInto2(from, to, skip = []) {
-  fs56.mkdirSync(to, { recursive: true });
-  for (const entry of fs56.readdirSync(from, { withFileTypes: true })) {
+  fs57.mkdirSync(to, { recursive: true });
+  for (const entry of fs57.readdirSync(from, { withFileTypes: true })) {
     if (skip.includes(entry.name)) continue;
-    const source = path60.join(from, entry.name);
-    const target = path60.join(to, entry.name);
-    if (!fs56.existsSync(target)) fs56.renameSync(source, target);
-    else if (entry.isDirectory() && fs56.statSync(target).isDirectory()) mergeInto2(source, target);
+    const source = path62.join(from, entry.name);
+    const target = path62.join(to, entry.name);
+    if (!fs57.existsSync(target)) fs57.renameSync(source, target);
+    else if (entry.isDirectory() && fs57.statSync(target).isDirectory()) mergeInto2(source, target);
   }
-  if (isEmpty(from)) fs56.rmSync(from, { recursive: true, force: true });
+  if (isEmpty(from)) fs57.rmSync(from, { recursive: true, force: true });
 }
 function moveSideFolders() {
   const dir = recurringDir();
-  for (const entry of fs56.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs57.readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory() || idPrefix(entry.name) !== null) continue;
-    const from = path60.join(dir, entry.name);
-    if (isEmpty(from)) fs56.rmSync(from, { recursive: true, force: true });
-    else mergeInto2(from, path60.join(AGENTS, entry.name));
+    const from = path62.join(dir, entry.name);
+    if (isEmpty(from)) fs57.rmSync(from, { recursive: true, force: true });
+    else mergeInto2(from, path62.join(AGENTS, entry.name));
   }
 }
 function sections(body) {
@@ -20750,8 +20871,8 @@ function agentName(card, text5) {
   const known2 = /* @__PURE__ */ new Set([...specAgentCatalog().agents.map((a) => a.name), ...ROLE_NAMES]);
   for (const name of [slug2, `${slug2}-${card.id}`]) {
     if (!AGENT_NAME.test(name)) continue;
-    const file = path60.join(AGENTS, name, AGENT_FILE3);
-    const written = fs56.existsSync(file) ? fs56.readFileSync(file, "utf8") : null;
+    const file = path62.join(AGENTS, name, AGENT_FILE3);
+    const written = fs57.existsSync(file) ? fs57.readFileSync(file, "utf8") : null;
     if (written === text5(name)) return name;
     if (written === null && !known2.has(name)) return name;
   }
@@ -20768,11 +20889,11 @@ ${q.options.map((o) => `- ${o}`).join("\n")}` : "";
 function removeCard(card) {
   dropCrossRefs(card.id);
   const target = card.folder ?? card.file;
-  stripReadmeRefs({ kind: card.folder ? "group" : "file", rel: path60.relative(TODO, target).split(path60.sep).join("/") });
-  fs56.rmSync(target, { recursive: true, force: true });
+  stripReadmeRefs({ kind: card.folder ? "group" : "file", rel: path62.relative(TODO, target).split(path62.sep).join("/") });
+  fs57.rmSync(target, { recursive: true, force: true });
 }
 function migrateCard(card) {
-  const { meta, body } = parseFrontmatter(fs56.readFileSync(card.file, "utf8"));
+  const { meta, body } = parseFrontmatter(fs57.readFileSync(card.file, "utf8"));
   if (!meta) throw new Error("its frontmatter cannot be read");
   const raw = meta;
   const said3 = (key) => typeof raw[key] === "string" ? raw[key].trim() : "";
@@ -20782,19 +20903,19 @@ function migrateCard(card) {
   if (!flow) throw new Error("this board has no workflow to put it in");
   const text5 = (name2) => agentText(name2, meta.title || card.slug, body);
   const name = agentName(card, text5);
-  const dir = path60.join(AGENTS, name);
-  const file = path60.join(dir, AGENT_FILE3);
-  const madeDir = !fs56.existsSync(dir);
-  const wrote = !fs56.existsSync(file);
+  const dir = path62.join(AGENTS, name);
+  const file = path62.join(dir, AGENT_FILE3);
+  const madeDir = !fs57.existsSync(dir);
+  const wrote = !fs57.existsSync(file);
   try {
-    fs56.mkdirSync(dir, { recursive: true });
-    if (wrote) fs56.writeFileSync(file, text5(name));
+    fs57.mkdirSync(dir, { recursive: true });
+    if (wrote) fs57.writeFileSync(file, text5(name));
     const adopted = adoptWorkflowScheduled(flow.id, name, { cadence, lastRun });
     if (!adopted.ok) throw new Error(adopted.error);
     questionsToTriage(meta, name);
   } catch (e) {
-    if (madeDir) fs56.rmSync(dir, { recursive: true, force: true });
-    else if (wrote) fs56.rmSync(file, { force: true });
+    if (madeDir) fs57.rmSync(dir, { recursive: true, force: true });
+    else if (wrote) fs57.rmSync(file, { force: true });
     throw e;
   }
   if (card.folder) mergeInto2(card.folder, dir, ["root.md"]);
@@ -20804,7 +20925,7 @@ function migrateCard(card) {
 function migrateRecurringCards() {
   const done2 = { agents: [], removed: [], failed: [] };
   const dir = recurringDir();
-  if (!fs56.existsSync(dir)) return done2;
+  if (!fs57.existsSync(dir)) return done2;
   migratePruneMemoryCard();
   moveSideFolders();
   for (const card of legacyCards()) {
@@ -20817,7 +20938,7 @@ function migrateRecurringCards() {
       done2.failed.push({ card: rel(card.file), why: e instanceof Error ? e.message : String(e) });
     }
   }
-  if (isEmpty(dir)) fs56.rmSync(dir, { recursive: true, force: true });
+  if (isEmpty(dir)) fs57.rmSync(dir, { recursive: true, force: true });
   return done2;
 }
 function recurringMigrationLines(done2) {
@@ -20850,14 +20971,14 @@ var init_recurring = __esm({
     PRUNE_SLUG = "prune-the-memory";
     FETCH_SLUG = "fetch-triage-items";
     AGENT_FILE3 = "AGENT.md";
-    recurringDir = () => path60.join(TODO, LEGACY_RECURRING);
-    isEmpty = (dir) => fs56.readdirSync(dir).every((name) => name === ".DS_Store");
+    recurringDir = () => path62.join(TODO, LEGACY_RECURRING);
+    isEmpty = (dir) => fs57.readdirSync(dir).every((name) => name === ".DS_Store");
     SECTION = /^##\s+(.+?)\s*$/;
   }
 });
 
 // ../cli/src/commands/init.ts
-import fs57 from "node:fs";
+import fs58 from "node:fs";
 function boardReadme() {
   return `# Board
 
@@ -20870,20 +20991,20 @@ _(none)_
 `;
 }
 function writeConfigIfMissing() {
-  if (fs57.existsSync(CONFIG)) return false;
-  fs57.mkdirSync(KANBAN, { recursive: true });
-  fs57.writeFileSync(CONFIG, CONFIG_TEMPLATE);
+  if (fs58.existsSync(CONFIG)) return false;
+  fs58.mkdirSync(KANBAN, { recursive: true });
+  fs58.writeFileSync(CONFIG, CONFIG_TEMPLATE);
   return true;
 }
 function writeModulesIfMissing() {
-  if (fs57.existsSync(MODULES_MD)) return false;
-  fs57.mkdirSync(KANBAN, { recursive: true });
-  fs57.writeFileSync(MODULES_MD, MODULES_TEMPLATE);
+  if (fs58.existsSync(MODULES_MD)) return false;
+  fs58.mkdirSync(KANBAN, { recursive: true });
+  fs58.writeFileSync(MODULES_MD, MODULES_TEMPLATE);
   return true;
 }
 function writeGitignoreIfMissing() {
-  fs57.mkdirSync(KANBAN, { recursive: true });
-  const text5 = fs57.existsSync(KANBAN_GITIGNORE) ? fs57.readFileSync(KANBAN_GITIGNORE, "utf8") : "";
+  fs58.mkdirSync(KANBAN, { recursive: true });
+  const text5 = fs58.existsSync(KANBAN_GITIGNORE) ? fs58.readFileSync(KANBAN_GITIGNORE, "utf8") : "";
   const has = (rule) => text5.split("\n").some((line) => line.trim() === rule.line);
   const missing = IGNORE_RULES.filter((rule) => !has(rule));
   if (!missing.length) return false;
@@ -20891,37 +21012,37 @@ function writeGitignoreIfMissing() {
 ${rule.line}
 `).join("");
   const separator = !text5 || text5.endsWith("\n") ? "" : "\n";
-  fs57.writeFileSync(KANBAN_GITIGNORE, `${text5}${separator}${block}`);
+  fs58.writeFileSync(KANBAN_GITIGNORE, `${text5}${separator}${block}`);
   return true;
 }
 function writeSkeletonIfMissing() {
   const added = [];
-  if (!fs57.existsSync(TODO)) {
-    fs57.mkdirSync(TODO, { recursive: true });
+  if (!fs58.existsSync(TODO)) {
+    fs58.mkdirSync(TODO, { recursive: true });
     added.push(`${rel(TODO)}/`);
   }
-  if (!fs57.existsSync(README)) {
-    fs57.writeFileSync(README, boardReadme());
+  if (!fs58.existsSync(README)) {
+    fs58.writeFileSync(README, boardReadme());
     added.push(rel(README));
   }
   return added;
 }
 function retireReleases() {
   const done2 = [];
-  if (fs57.existsSync(RELEASES)) {
-    fs57.rmSync(RELEASES);
+  if (fs58.existsSync(RELEASES)) {
+    fs58.rmSync(RELEASES);
     done2.push(`deleted ${rel(RELEASES)}`);
   }
   let cards = 0;
   for (const dir of [TODO, ARCHIVE]) {
-    if (!fs57.existsSync(dir)) continue;
+    if (!fs58.existsSync(dir)) continue;
     for (const file of walkMd(dir)) {
-      const text5 = fs57.readFileSync(file, "utf8");
+      const text5 = fs58.readFileSync(file, "utf8");
       const end2 = text5.startsWith("---\n") ? text5.indexOf("\n---", 3) : -1;
       if (end2 < 0) continue;
       const head = text5.slice(0, end2).replace(/\nrelease:[^\n]*/, "");
       if (head.length === end2) continue;
-      fs57.writeFileSync(file, head + text5.slice(end2));
+      fs58.writeFileSync(file, head + text5.slice(end2));
       cards++;
     }
   }
@@ -20929,7 +21050,7 @@ function retireReleases() {
   return done2.join(", ");
 }
 function cmdInit() {
-  if (fs57.existsSync(KANBAN)) {
+  if (fs58.existsSync(KANBAN)) {
     const added = [
       ...writeSkeletonIfMissing(),
       writeConfigIfMissing() && rel(CONFIG),
@@ -20964,8 +21085,8 @@ function cmdInit() {
     }
     return { board: rel(KANBAN), created: false, added, memory_paths: scaffolded.map((s) => rel(s.dir)) };
   }
-  fs57.mkdirSync(TODO, { recursive: true });
-  fs57.writeFileSync(README, boardReadme());
+  fs58.mkdirSync(TODO, { recursive: true });
+  fs58.writeFileSync(README, boardReadme());
   writeConfigIfMissing();
   scaffoldProjectMemory();
   writeModulesIfMissing();
@@ -21054,25 +21175,25 @@ var init_scheduled = __esm({
 });
 
 // ../cli/src/lib/card-age.ts
-import fs58 from "node:fs";
-import path61 from "node:path";
+import fs59 from "node:fs";
+import path63 from "node:path";
 function staleAfterIn(config) {
   const days = Number(LINE.exec(config)?.[1]);
   return Number.isInteger(days) && days > 0 ? days : STALE_AFTER_DEFAULT;
 }
 function staleAfter() {
-  if (!fs58.existsSync(CONFIG)) return STALE_AFTER_DEFAULT;
-  return staleAfterIn(fs58.readFileSync(CONFIG, "utf8"));
+  if (!fs59.existsSync(CONFIG)) return STALE_AFTER_DEFAULT;
+  return staleAfterIn(fs59.readFileSync(CONFIG, "utf8"));
 }
 function todoPathspec(top) {
-  const from = path61.relative(real(top), real(TODO));
-  if (!from || from.startsWith("..") || path61.isAbsolute(from)) return null;
-  return from.split(path61.sep).join("/");
+  const from = path63.relative(real(top), real(TODO));
+  if (!from || from.startsWith("..") || path63.isAbsolute(from)) return null;
+  return from.split(path63.sep).join("/");
 }
 function cardFile2(spec, printed) {
   const p = unquotePath(printed);
   if (!p.startsWith(`${spec}/`)) return null;
-  return path61.join(TODO, ...p.slice(spec.length + 1).split("/"));
+  return path63.join(TODO, ...p.slice(spec.length + 1).split("/"));
 }
 function dirtyCards(top, spec) {
   const out = git(["status", "--porcelain", "--untracked-files=all", "--", spec], top);
@@ -21119,9 +21240,9 @@ var init_card_age = __esm({
     gitTop = () => git(["rev-parse", "--show-toplevel"])?.trim() || null;
     real = (p) => {
       try {
-        return fs58.realpathSync(p);
+        return fs59.realpathSync(p);
       } catch {
-        return path61.resolve(p);
+        return path63.resolve(p);
       }
     };
     unquotePath = (line) => {
@@ -21156,8 +21277,8 @@ var init_card_holds = __esm({
 });
 
 // ../cli/src/commands/list.ts
-import fs59 from "node:fs";
-import path62 from "node:path";
+import fs60 from "node:fs";
+import path64 from "node:path";
 function summaryLine(body) {
   const lines = body.split("\n");
   let i = 0;
@@ -21173,13 +21294,13 @@ function summaryLine(body) {
 function openRows() {
   const rows = [];
   for (const file of walkMd(TODO)) {
-    const base = path62.basename(file);
+    const base = path64.basename(file);
     if (base === "README.md") continue;
     const isRoot = base === "root.md";
-    const id = isRoot ? idPrefix(path62.basename(path62.dirname(file))) : idPrefix(base);
+    const id = isRoot ? idPrefix(path64.basename(path64.dirname(file))) : idPrefix(base);
     if (id == null) continue;
-    if (isLegacyRecurring(path62.relative(TODO, file))) continue;
-    const { meta, body } = parseFrontmatter(fs59.readFileSync(file, "utf8"));
+    if (isLegacyRecurring(path64.relative(TODO, file))) continue;
+    const { meta, body } = parseFrontmatter(fs60.readFileSync(file, "utf8"));
     rows.push({
       id,
       file,
@@ -21221,15 +21342,15 @@ function cmdStale(rows, all2, scope, mod) {
 }
 function archivedFiles() {
   const files2 = /* @__PURE__ */ new Map();
-  if (!fs59.existsSync(ARCHIVE)) return files2;
+  if (!fs60.existsSync(ARCHIVE)) return files2;
   for (const file of walkMd(ARCHIVE)) {
-    const id = idPrefix(path62.basename(file));
+    const id = idPrefix(path64.basename(file));
     if (id !== null) files2.set(id, file);
   }
   for (const dir of walkDirs(ARCHIVE)) {
-    const id = idPrefix(path62.basename(dir));
-    const root = path62.join(dir, "root.md");
-    if (id !== null && fs59.existsSync(root)) files2.set(id, root);
+    const id = idPrefix(path64.basename(dir));
+    const root = path64.join(dir, "root.md");
+    if (id !== null && fs60.existsSync(root)) files2.set(id, root);
   }
   return files2;
 }
@@ -21340,14 +21461,14 @@ var init_list = __esm({
 });
 
 // ../cli/src/commands/misc.ts
-import fs60 from "node:fs";
-import path63 from "node:path";
+import fs61 from "node:fs";
+import path65 from "node:path";
 function extractOldMeta(text5, file) {
   const grab = (re) => {
     const m = text5.match(re);
     return m ? m[1].trim() : null;
   };
-  const title = grab(/^#\s+(.+)$/m) || slugify(path63.basename(file, ".md").replace(/^\d+-/, "")).replace(/-/g, " ");
+  const title = grab(/^#\s+(.+)$/m) || slugify(path65.basename(file, ".md").replace(/^\d+-/, "")).replace(/-/g, " ");
   const norm = (raw) => {
     const v = (raw || "").toLowerCase();
     return LEVELS.includes(v) ? v : "med";
@@ -21374,11 +21495,11 @@ function stripOldHeader(text5) {
 }
 function cmdMigrate(opts) {
   const dry = opts.dryRun === true;
-  const files2 = walkMd(TODO).filter((f) => path63.basename(f) !== "README.md");
+  const files2 = walkMd(TODO).filter((f) => path65.basename(f) !== "README.md");
   let changed = 0;
   let skipped = 0;
   for (const file of files2) {
-    const text5 = fs60.readFileSync(file, "utf8");
+    const text5 = fs61.readFileSync(file, "utf8");
     if (text5.trimStart().startsWith("---")) {
       skipped++;
       continue;
@@ -21387,7 +21508,7 @@ function cmdMigrate(opts) {
     const out = serializeFrontmatter(meta) + "\n\n" + stripOldHeader(text5).replace(/^\n+/, "");
     if (dry) say(`would migrate ${rel(file)}  (priority=${meta.priority})`);
     else {
-      fs60.writeFileSync(file, out.endsWith("\n") ? out : out + "\n");
+      fs61.writeFileSync(file, out.endsWith("\n") ? out : out + "\n");
       say(`migrated ${rel(file)}`);
     }
     changed++;
@@ -21408,10 +21529,10 @@ var init_misc = __esm({
 });
 
 // ../cli/src/lib/group-close.ts
-import fs61 from "node:fs";
+import fs62 from "node:fs";
 function groupCloses(rootFile) {
   try {
-    return groupCloseOf(fs61.readFileSync(rootFile, "utf8"));
+    return groupCloseOf(fs62.readFileSync(rootFile, "utf8"));
   } catch {
     return false;
   }
@@ -21424,12 +21545,12 @@ var init_group_close = __esm({
 });
 
 // ../cli/src/commands/remove.ts
-import fs62 from "node:fs";
-import path64 from "node:path";
+import fs63 from "node:fs";
+import path66 from "node:path";
 function leavingIds(id, found2) {
   const ids = /* @__PURE__ */ new Set([id]);
   if (found2.kind === "group") {
-    const names4 = [...walkMd(found2.target), ...walkDirs(found2.target)].map((f) => path64.basename(f));
+    const names4 = [...walkMd(found2.target), ...walkDirs(found2.target)].map((f) => path66.basename(f));
     for (const name of names4) {
       const n = idPrefix(name);
       if (n !== null) ids.add(n);
@@ -21441,10 +21562,10 @@ function findMentions(ids) {
   const hits = [];
   const re = new RegExp(ids.map((id) => `#${id}(?!\\d)`).join("|"));
   for (const dir of [TODO, MEMORY]) {
-    if (!fs62.existsSync(dir)) continue;
+    if (!fs63.existsSync(dir)) continue;
     for (const file of walkMd(dir)) {
-      if (path64.basename(file) === "README.md") continue;
-      const lines = fs62.readFileSync(file, "utf8").split("\n");
+      if (path66.basename(file) === "README.md") continue;
+      const lines = fs63.readFileSync(file, "utf8").split("\n");
       const fmEnd = frontmatterEnd(lines);
       lines.forEach((line, i) => {
         if (!re.test(line)) return;
@@ -21460,12 +21581,12 @@ function findMentions(ids) {
   return hits;
 }
 function leavingCards(id, found2) {
-  const own = found2.kind === "group" ? path64.join(found2.target, "root.md") : found2.target;
+  const own = found2.kind === "group" ? path66.join(found2.target, "root.md") : found2.target;
   const cards = [{ id, file: own }];
   if (found2.kind !== "group") return cards;
   for (const file of walkMd(found2.target)) {
     if (file === own) continue;
-    const n = idPrefix(path64.basename(file));
+    const n = idPrefix(path66.basename(file));
     if (n !== null) cards.push({ id: n, file });
   }
   return cards;
@@ -21474,10 +21595,10 @@ function stampLeaving(cards, rejection) {
   const day = formatDay();
   const stamp4 = rejection && !rejection.discard ? { reason: rejection.reason, at: (/* @__PURE__ */ new Date()).toISOString(), by: insideRun() ? "agent" : "user" } : rejection && { reason: rejection.reason };
   for (const card of cards) {
-    if (!fs62.existsSync(card.file)) continue;
-    const text5 = fs62.readFileSync(card.file, "utf8");
+    if (!fs63.existsSync(card.file)) continue;
+    const text5 = fs63.readFileSync(card.file, "utf8");
     const stamped = stampLeavingIn(text5, day, stamp4);
-    if (stamped !== text5) fs62.writeFileSync(card.file, stamped);
+    if (stamped !== text5) fs63.writeFileSync(card.file, stamped);
   }
 }
 function unfinishedDelivery(id) {
@@ -21493,7 +21614,7 @@ function unfinishedDelivery(id) {
     }[gap];
     return `#${id} is not finished: ${what}.`;
   }
-  const missing = planDeliverables(card.body).filter((src) => src.startsWith(".assets/")).find((src) => !fs62.existsSync(path64.join(ASSETS, src.slice(".assets/".length))));
+  const missing = planDeliverables(card.body).filter((src) => src.startsWith(".assets/")).find((src) => !fs63.existsSync(path66.join(ASSETS, src.slice(".assets/".length))));
   return missing ? `#${id} is not finished: ${missing} is not on this machine.` : null;
 }
 function agentDecisions(text5) {
@@ -21520,8 +21641,8 @@ function removeCard2(id, metric, options) {
   const unfinished = metric === "completed" ? unfinishedDelivery(id) : null;
   if (unfinished) die(unfinished, { kind: "plan-delivery-unfinished" });
   const dest = options.cleanupDiscarded && locateArchived(id) ? null : archiveDest(found2);
-  const cardFile3 = found2.kind === "group" ? path64.join(found2.target, "root.md") : found2.target;
-  const cardText = fs62.existsSync(cardFile3) ? fs62.readFileSync(cardFile3, "utf8") : "";
+  const cardFile3 = found2.kind === "group" ? path66.join(found2.target, "root.md") : found2.target;
+  const cardText = fs63.existsSync(cardFile3) ? fs63.readFileSync(cardFile3, "utf8") : "";
   const { meta: cardMeta3 } = parseFrontmatter(cardText);
   const alsoRemoved = found2.kind === "group" ? walkMd(found2.target).filter((f) => f !== cardFile3).map((f) => rel(f)).sort() : [];
   const leftIds = leavingIds(id, found2);
@@ -21552,10 +21673,10 @@ function removeCard2(id, metric, options) {
   const groupRoot = found2.kind === "file" && !options.closing ? enclosingGroupRoot(found2.target) : null;
   if (dest) {
     stampLeaving(leaving, metric === "rejected" ? { reason: options.reason?.trim() ?? "", discard: options.discard === true } : null);
-    fs62.mkdirSync(ARCHIVE, { recursive: true });
-    fs62.renameSync(found2.target, dest);
+    fs63.mkdirSync(ARCHIVE, { recursive: true });
+    fs63.renameSync(found2.target, dest);
   } else {
-    fs62.rmSync(found2.target, { recursive: true, force: true });
+    fs63.rmSync(found2.target, { recursive: true, force: true });
   }
   const removedRefs = stripReadmeRefs(found2);
   let marked2 = null;
@@ -21604,14 +21725,14 @@ function removeCard2(id, metric, options) {
   };
 }
 function closeGroup(rootFile) {
-  const rootId = idPrefix(path64.basename(path64.dirname(rootFile)));
+  const rootId = idPrefix(path66.basename(path66.dirname(rootFile)));
   if (rootId === null) return null;
   if (runnerProject(KANBAN)) return null;
   if (!groupCloses(rootFile)) return null;
   say(`
 every subtask line on #${rootId} is resolved \u2014 closing the group:`);
   try {
-    const { meta, body } = parseFrontmatter(fs62.readFileSync(rootFile, "utf8"));
+    const { meta, body } = parseFrontmatter(fs63.readFileSync(rootFile, "utf8"));
     const res = cmdRemove(rootId, "completed", { closing: true });
     return {
       id: rootId,
@@ -21668,7 +21789,7 @@ function cleanupDiscardedCards(sessionId) {
       if (card.pending) throw new Error(`Discarding #${card.id} did not finish. Retry the discard.`);
       while (locate(card.id)) cmdRemove(card.id, "rejected", { discard: true, cleanupDiscarded: true });
       dropCrossRefs(card.id);
-      stripReadmeRefs({ kind: "file", rel: path64.relative(TODO, path64.resolve(REPO_ROOT, card.path)).split(path64.sep).join("/") });
+      stripReadmeRefs({ kind: "file", rel: path66.relative(TODO, path66.resolve(REPO_ROOT, card.path)).split(path66.sep).join("/") });
     }
     return discarded.map((c) => c.id);
   });
@@ -21754,8 +21875,8 @@ var init_memory_file = __esm({
 });
 
 // ../cli/src/commands/rule.ts
-import fs63 from "node:fs";
-import path65 from "node:path";
+import fs64 from "node:fs";
+import path67 from "node:path";
 function cmdRule(askedName, flags) {
   const agent = askedName.trim();
   if (!agentRoster().some((a) => a.name === agent)) {
@@ -21764,7 +21885,7 @@ function cmdRule(askedName, flags) {
   const rule = readRuleText(flags.file, flags.text);
   const res = setAgentRule(agent, rule);
   if (!res.ok) die(res.error);
-  const file = rel(path65.join(RULES, `${agent}.md`));
+  const file = rel(path67.join(RULES, `${agent}.md`));
   say(rule ? `wrote the \`${agent}\` rule (${file})` : `cleared the \`${agent}\` rule`);
   return { agent, file, cleared: !rule };
 }
@@ -21772,7 +21893,7 @@ function readRuleText(file, text5) {
   if (file !== void 0 && text5 !== void 0) die("pass --file or --text, not both");
   if (file !== void 0) {
     try {
-      return fs63.readFileSync(file, "utf8").trim();
+      return fs64.readFileSync(file, "utf8").trim();
     } catch {
       die(`can't read ${file} \u2014 write the rule to a file, then pass its path`);
     }
@@ -21899,22 +22020,22 @@ var init_storyboard = __esm({
 });
 
 // ../cli/src/lib/spec-contract.ts
-import fs64 from "node:fs";
-import path66 from "node:path";
+import fs65 from "node:fs";
+import path68 from "node:path";
 function snapshotSpecs() {
   const out = /* @__PURE__ */ new Map();
-  if (!fs64.existsSync(TODO)) return out;
+  if (!fs65.existsSync(TODO)) return out;
   for (const file of walkMd(TODO)) {
-    if (isLegacyRecurring(path66.relative(TODO, file))) continue;
-    const id = idPrefix(path66.basename(file) === "root.md" ? path66.basename(path66.dirname(file)) : path66.basename(file));
-    if (id !== null) out.set(file, { id, text: fs64.readFileSync(file, "utf8") });
+    if (isLegacyRecurring(path68.relative(TODO, file))) continue;
+    const id = idPrefix(path68.basename(file) === "root.md" ? path68.basename(path68.dirname(file)) : path68.basename(file));
+    if (id !== null) out.set(file, { id, text: fs65.readFileSync(file, "utf8") });
   }
   return out;
 }
 function enclosingGroups(file) {
   const ids = [];
   for (let root = enclosingGroupRoot(file); root; root = enclosingGroupRoot(root)) {
-    const id = idPrefix(path66.basename(path66.dirname(root)));
+    const id = idPrefix(path68.basename(path68.dirname(root)));
     if (id !== null) ids.push(id);
   }
   return ids;
@@ -22083,9 +22204,9 @@ function validateSpec(file, text5, id) {
 }
 function inside(dir, name) {
   try {
-    const root = fs64.realpathSync(dir);
-    const real2 = fs64.realpathSync(path66.join(dir, name));
-    return real2.startsWith(root + path66.sep) && fs64.statSync(real2).isFile() ? real2 : null;
+    const root = fs65.realpathSync(dir);
+    const real2 = fs65.realpathSync(path68.join(dir, name));
+    return real2.startsWith(root + path68.sep) && fs65.statSync(real2).isFile() ? real2 : null;
   } catch {
     return null;
   }
@@ -22103,7 +22224,7 @@ function variantsProblem(raw, src, id) {
   if (files2.length < 2 || !files2.every((f) => typeof f === "string" && f)) return `variants needs at least two labels, each naming a file. ${shape}`;
   if (!files2.includes(src)) return `src="${src}" is not one of the variants. Set src to the version shown first.`;
   if (id === void 0) return null;
-  const dir = path66.join(ASSETS, String(id));
+  const dir = path68.join(ASSETS, String(id));
   for (const f of files2) {
     const parts = f.split("/");
     if (parts.length !== 3 || parts[0] !== ".assets" || parts[1] !== String(id) || !inside(dir, parts[2])) {
@@ -22113,7 +22234,7 @@ function variantsProblem(raw, src, id) {
   return null;
 }
 function compareProblem(attrs, id) {
-  const dir = path66.join(ASSETS, String(id));
+  const dir = path68.join(ASSETS, String(id));
   const src = (message) => ({ rule: "compare-src", message });
   const shots = (message) => ({ rule: "compare-shots", message });
   for (const side of ["a", "b"]) {
@@ -22133,7 +22254,7 @@ function compareProblem(attrs, id) {
     const file = inside(dir, named2.name);
     if (!file) return { message: `Compare shots ${at} names no file in this card's asset folder. Write the JSON there or fix the path.` };
     try {
-      return { data: JSON.parse(fs64.readFileSync(file, "utf8")) };
+      return { data: JSON.parse(fs65.readFileSync(file, "utf8")) };
     } catch {
       return { message: `${at} is not valid JSON.` };
     }
@@ -22153,7 +22274,7 @@ function compareProblem(attrs, id) {
 }
 function validateStoryboards(file, id, text5) {
   const errors = [];
-  const dir = path66.join(ASSETS, String(id));
+  const dir = path68.join(ASSETS, String(id));
   for (const marker of storyboardMarkers(text5)) {
     const named2 = assetName(marker.src, id, ["json"]);
     const add = (message) => errors.push({ file: rel(file), line: marker.line, rule: "storyboard-src", message });
@@ -22302,8 +22423,8 @@ var init_mockups = __esm({
 });
 
 // ../cli/src/commands/spec-write.ts
-import fs65 from "node:fs";
-import path67 from "node:path";
+import fs66 from "node:fs";
+import path69 from "node:path";
 function cmdSpecWrite(id, askedName, flags) {
   const agent = findSpecAgent(askedName);
   if (!agent) die(notAnAgent(askedName), { kind: "no-such-spec-agent", specAgent: askedName });
@@ -22311,11 +22432,11 @@ function cmdSpecWrite(id, askedName, flags) {
   const section = readSection(flags.file, flags.text);
   const found2 = locate(id);
   if (!found2) die(`no task with id ${id} under ${rel(TODO)}`, { kind: "card-not-found", id });
-  const file = found2.kind === "group" ? path67.join(found2.target, "root.md") : found2.target;
-  const { meta, body } = parseFrontmatter(fs65.readFileSync(file, "utf8"));
+  const file = found2.kind === "group" ? path69.join(found2.target, "root.md") : found2.target;
+  const { meta, body } = parseFrontmatter(fs66.readFileSync(file, "utf8"));
   if (!meta) die(`${rel(file)} has no frontmatter \u2014 run \`migrate\` first`);
   const { body: next, replaced } = splice(body, name, section);
-  fs65.writeFileSync(file, serializeFrontmatter(meta) + "\n" + next);
+  fs66.writeFileSync(file, serializeFrontmatter(meta) + "\n" + next);
   say(`${replaced ? "rewrote" : "wrote"} the \`${name}\` section on #${id} (${rel(file)})`);
   return { id, specAgent: name, replaced, file: rel(file) };
 }
@@ -22324,7 +22445,7 @@ function readSection(file, text5) {
   let raw;
   if (file !== void 0) {
     try {
-      raw = fs65.readFileSync(file, "utf8");
+      raw = fs66.readFileSync(file, "utf8");
     } catch {
       die(`can't read ${file} \u2014 write your section to a file, then pass its path`);
     }
@@ -22790,11 +22911,11 @@ var init_shared = __esm({
 });
 
 // ../cli/src/commands/goal.ts
-import fs66 from "node:fs";
+import fs67 from "node:fs";
 function load() {
   const file = goalsFile();
   if (!file) die("Goals exist only inside a WildCrane goal discussion.");
-  const held4 = JSON.parse(fs66.readFileSync(file, "utf8"));
+  const held4 = JSON.parse(fs67.readFileSync(file, "utf8"));
   if (held4.goals !== void 0 && held4.ideas !== void 0 && JSON.stringify(held4.goals) !== JSON.stringify(held4.ideas)) die("goals and ideas do not match.");
   const goals = held4.goals ?? held4.ideas;
   if (!Array.isArray(goals)) die("The goals array is missing or invalid.");
@@ -22819,7 +22940,7 @@ function splitBody2(text5) {
 }
 function readBody(bodyFile) {
   if (!bodyFile) die("--body-file is required; write the goal in a writable temporary file first.");
-  const text5 = fs66.readFileSync(bodyFile, "utf8");
+  const text5 = fs67.readFileSync(bodyFile, "utf8");
   if (!text5.trim()) die("The goal must not be empty.");
   return splitBody2(text5);
 }
@@ -22831,7 +22952,7 @@ function named(held4, id) {
 function cmdGoal(args, opts) {
   const sub = args[0] ?? "";
   const { file, held: held4 } = load();
-  const write2 = () => fs66.writeFileSync(file, `${JSON.stringify({ workflows: held4.workflows, ideas: held4.goals }, null, 2)}
+  const write2 = () => fs67.writeFileSync(file, `${JSON.stringify({ workflows: held4.workflows, ideas: held4.goals }, null, 2)}
 `);
   if (sub === "new") {
     const title = opts.title?.trim();
@@ -22901,8 +23022,8 @@ __export(board_exports, {
   buildBoardProgram: () => buildBoardProgram
 });
 import crypto4 from "node:crypto";
-import fs67 from "node:fs";
-import path68 from "node:path";
+import fs68 from "node:fs";
+import path70 from "node:path";
 async function dispatch(move2, cmd, args, opts, cli) {
   const ctx = ctxOf(cmd, cli.program);
   const data = await runAction(ctx, {}, async () => {
@@ -22941,7 +23062,7 @@ async function cloudCard(task, opts) {
   let request;
   if (typeof opts.bodyFile === "string") {
     try {
-      request = fs67.readFileSync(opts.bodyFile, "utf8");
+      request = fs68.readFileSync(opts.bodyFile, "utf8");
     } catch {
     }
   }
@@ -22971,7 +23092,7 @@ async function cloudCard(task, opts) {
   const file = creationReceipt(`${checked.value}:${requestId}`, slot);
   const journal = readCreation(file, said3);
   if (!journal.made) {
-    const key = `akb-${path68.basename(file, ".json").slice(0, 40)}`;
+    const key = `akb-${path70.basename(file, ".json").slice(0, 40)}`;
     const made = await createProjectTask(checked.value, journal.said, key);
     if (!made.ok) throw new BoardError(creationError(`Cloud did not make the task: ${made.error}`, triage), { kind: "refused" });
     journal.made = made.value;
@@ -23116,16 +23237,16 @@ var init_board2 = __esm({
 });
 
 // ../cli/src/lib/board-cli.ts
-import fs68 from "node:fs";
-import path69 from "node:path";
+import fs69 from "node:fs";
+import path71 from "node:path";
 function useBoard(found2, dirNamed) {
-  if (!found2.named && found2.board === path69.join(found2.root, "docs", "kanban")) setBoardRoot(found2.root, dirNamed);
+  if (!found2.named && found2.board === path71.join(found2.root, "docs", "kanban")) setBoardRoot(found2.root, dirNamed);
   else setBoardDir(found2.board, found2.root);
   useProjectState();
 }
 function whole(found2, move2) {
   if (move2 === MAKES_A_BOARD) return found2;
-  if (!fs68.existsSync(path69.join(found2.board, "todo"))) {
+  if (!fs69.existsSync(path71.join(found2.board, "todo"))) {
     die(`the board in ${found2.board} has no todo/ \u2014 run \`init\` to add what is missing.`, {
       kind: "board-incomplete",
       dir: found2.root
@@ -23134,13 +23255,13 @@ function whole(found2, move2) {
   return found2;
 }
 function findBoardUpward(from, move2) {
-  let dir = path69.resolve(from);
+  let dir = path71.resolve(from);
   for (; ; ) {
-    if (hasBoard(dir)) return { root: dir, board: path69.join(dir, "docs", "kanban") };
+    if (hasBoard(dir)) return { root: dir, board: path71.join(dir, "docs", "kanban") };
     if (isBoardDir(dir)) return { root: projectRootOf(dir), board: dir };
-    const kept2 = path69.join(dir, ".akb", "kanban");
-    if (move2 !== MAKES_A_BOARD && fs68.existsSync(path69.join(kept2, "todo"))) return { root: dir, board: kept2 };
-    const up = path69.dirname(dir);
+    const kept2 = path71.join(dir, ".akb", "kanban");
+    if (move2 !== MAKES_A_BOARD && fs69.existsSync(path71.join(kept2, "todo"))) return { root: dir, board: kept2 };
+    const up = path71.dirname(dir);
     if (up === dir) return null;
     dir = up;
   }
@@ -23148,11 +23269,11 @@ function findBoardUpward(from, move2) {
 function resolveBoard(move2, { board: board2, dir, cwd, installHint }) {
   const named2 = board2 ?? boardFromEnv();
   if (named2) {
-    const folder = path69.resolve(cwd, named2);
-    if (!fs68.existsSync(folder) && move2 !== MAKES_A_BOARD) {
+    const folder = path71.resolve(cwd, named2);
+    if (!fs69.existsSync(folder) && move2 !== MAKES_A_BOARD) {
       die(`no such folder: ${folder}`, { kind: "no-such-folder", dir: folder });
     }
-    if (fs68.existsSync(folder) && !isBoardDir(folder) && move2 !== MAKES_A_BOARD) {
+    if (fs69.existsSync(folder) && !isBoardDir(folder) && move2 !== MAKES_A_BOARD) {
       die(`${folder} is not a board \u2014 it has no todo/ and config.md. ${installHint}\u3002`, {
         kind: "no-board",
         dir: folder
@@ -23161,24 +23282,24 @@ function resolveBoard(move2, { board: board2, dir, cwd, installHint }) {
     return { root: projectRootOf(folder), board: folder, named: true };
   }
   if (dir !== null) {
-    const root = path69.resolve(dir);
-    if (!fs68.existsSync(root)) die(`no such folder: ${root}`, { kind: "no-such-folder", dir: root });
-    const kept2 = path69.join(root, ".akb", "kanban");
-    if (!hasBoard(root) && move2 !== MAKES_A_BOARD && fs68.existsSync(path69.join(kept2, "todo"))) return whole({ root, board: kept2 }, move2);
+    const root = path71.resolve(dir);
+    if (!fs69.existsSync(root)) die(`no such folder: ${root}`, { kind: "no-such-folder", dir: root });
+    const kept2 = path71.join(root, ".akb", "kanban");
+    if (!hasBoard(root) && move2 !== MAKES_A_BOARD && fs69.existsSync(path71.join(kept2, "todo"))) return whole({ root, board: kept2 }, move2);
     if (!hasBoard(root) && move2 !== MAKES_A_BOARD) {
       die(`no board in ${root} \u2014 it has no docs/kanban/. ${installHint}\u3002`, {
         kind: "no-board",
         dir: root
       });
     }
-    return whole({ root, board: path69.join(root, "docs", "kanban") }, move2);
+    return whole({ root, board: path71.join(root, "docs", "kanban") }, move2);
   }
   const found2 = findBoardUpward(cwd, move2);
   if (found2) return whole(found2, move2);
-  if (move2 === MAKES_A_BOARD) return { root: path69.resolve(cwd), board: path69.join(path69.resolve(cwd), "docs", "kanban") };
+  if (move2 === MAKES_A_BOARD) return { root: path71.resolve(cwd), board: path71.join(path71.resolve(cwd), "docs", "kanban") };
   die(
-    `no board here. Looked in ${path69.resolve(cwd)} and every folder above it for docs/kanban/. ${installHint}\uFF0C\u6216\u7528 --board \u6307\u5B9A\u5DF2\u6709\u770B\u677F\u3002`,
-    { kind: "no-board", dir: path69.resolve(cwd) }
+    `no board here. Looked in ${path71.resolve(cwd)} and every folder above it for docs/kanban/. ${installHint}\uFF0C\u6216\u7528 --board \u6307\u5B9A\u5DF2\u6709\u770B\u677F\u3002`,
+    { kind: "no-board", dir: path71.resolve(cwd) }
   );
 }
 function editDistance(a, b) {
@@ -23260,8 +23381,8 @@ var init_board_cli = __esm({
     init_io();
     init_pointer();
     MAKES_A_BOARD = "init";
-    hasBoard = (dir) => fs68.existsSync(path69.join(dir, "docs", "kanban"));
-    isBoardDir = (dir) => fs68.existsSync(path69.join(dir, "todo")) && fs68.existsSync(path69.join(dir, "config.md"));
+    hasBoard = (dir) => fs69.existsSync(path71.join(dir, "docs", "kanban"));
+    isBoardDir = (dir) => fs69.existsSync(path71.join(dir, "todo")) && fs69.existsSync(path71.join(dir, "config.md"));
     boardFromEnv = () => {
       const named2 = process.env.AI4KANBAN_BOARD?.trim();
       return named2 ? named2 : null;
@@ -23528,8 +23649,8 @@ var init_guide = __esm({
 });
 
 // ../cli/src/lib/agent/approve.ts
-import fs74 from "node:fs";
-import path75 from "node:path";
+import fs75 from "node:fs";
+import path77 from "node:path";
 function approvalRequest(req) {
   const id = req.id;
   const card = id === void 0 ? null : findCard(id);
@@ -23547,12 +23668,12 @@ function advancePhase(id) {
   const card = findCard(id);
   const found2 = locate(id);
   if (!card || !found2 || !awaitingApproval(card)) return { error: `#${id} is no longer waiting on approval.` };
-  const file = found2.kind === "group" ? path75.join(found2.target, "root.md") : found2.target;
-  const { meta, body } = parseFrontmatter(fs74.readFileSync(file, "utf8"));
+  const file = found2.kind === "group" ? path77.join(found2.target, "root.md") : found2.target;
+  const { meta, body } = parseFrontmatter(fs75.readFileSync(file, "utf8"));
   if (!meta) return { error: `#${id} has no frontmatter` };
   meta.phase = card.stage + 1;
   meta.status = "todo";
-  fs74.writeFileSync(file, serializeFrontmatter(meta) + "\n" + body);
+  fs75.writeFileSync(file, serializeFrontmatter(meta) + "\n" + body);
   return null;
 }
 var init_approve = __esm({
@@ -23676,16 +23797,16 @@ var init_start = __esm({
 });
 
 // ../cli/src/lib/agent/task-chats.ts
-import fs75 from "node:fs";
-import path76 from "node:path";
+import fs76 from "node:fs";
+import path78 from "node:path";
 function taskChatFile(task, home3) {
   if (!TASK.test(task)) throw new Error(`${task} is not a task id.`);
-  return path76.join(taskChatsDir(home3), `${task}.jsonl`);
+  return path78.join(taskChatsDir(home3), `${task}.jsonl`);
 }
 function readTaskChat(task, home3) {
   let text5;
   try {
-    text5 = fs75.readFileSync(taskChatFile(task, home3), "utf8");
+    text5 = fs76.readFileSync(taskChatFile(task, home3), "utf8");
   } catch {
     return [];
   }
@@ -23706,13 +23827,13 @@ var init_task_chats = __esm({
     "use strict";
     init_home();
     TASK = /^[\w-]{1,100}$/;
-    taskChatsDir = (home3 = machineHome()) => path76.join(home3, "chats");
+    taskChatsDir = (home3 = machineHome()) => path78.join(home3, "chats");
   }
 });
 
 // ../cli/src/lib/agent/memory-review.ts
-import fs76 from "node:fs";
-import path77 from "node:path";
+import fs77 from "node:fs";
+import path79 from "node:path";
 function taskChatsToReview(tasks) {
   const out = [];
   for (const ref of [...new Set(tasks)]) {
@@ -23734,8 +23855,8 @@ function readArchived2(id) {
   const found2 = Number.isInteger(id) && id > 0 ? locateArchived(id) : null;
   if (!found2) return null;
   try {
-    const file = found2.kind === "group" ? path77.join(found2.target, "root.md") : found2.target;
-    const { meta, body } = parseFrontmatter(fs76.readFileSync(file, "utf8"));
+    const file = found2.kind === "group" ? path79.join(found2.target, "root.md") : found2.target;
+    const { meta, body } = parseFrontmatter(fs77.readFileSync(file, "utf8"));
     if (!meta) return null;
     return { id, title: meta.title, modules: meta.modules ?? [], rejected: meta.rejected, body };
   } catch {
@@ -23804,17 +23925,17 @@ var init_memory_review = __esm({
 });
 
 // ../cli/src/lib/agent/dismissal-review.ts
-import fs77 from "node:fs";
-import path78 from "node:path";
+import fs78 from "node:fs";
+import path80 from "node:path";
 function rejectionsToReview() {
-  const dir = path78.join(ARCHIVE, REJECTIONS_TO_REVIEW);
-  if (!fs77.existsSync(dir)) return [];
+  const dir = path80.join(ARCHIVE, REJECTIONS_TO_REVIEW);
+  if (!fs78.existsSync(dir)) return [];
   const found2 = [];
   for (const file of walkMd(dir)) {
     const id = archivedId(file);
     if (id === null) continue;
     try {
-      const { meta } = parseFrontmatter(fs77.readFileSync(file, "utf8"));
+      const { meta } = parseFrontmatter(fs78.readFileSync(file, "utf8"));
       if (!meta?.rejected || meta.rejected_by !== "user" || !meta.rejected_reason.trim()) continue;
       found2.push({ id, title: meta.title, file: rel(file), reason: meta.rejected_reason.trim(), rejectedAt: meta.rejected_at });
     } catch {
@@ -23844,7 +23965,7 @@ function citedSources(text5) {
 function withdrawnSources() {
   const cited = [...new Set(plannerCopies("rejected.md").flatMap((file) => {
     try {
-      return citedSources(fs77.readFileSync(file, "utf8"));
+      return citedSources(fs78.readFileSync(file, "utf8"));
     } catch {
       return [];
     }
@@ -23869,8 +23990,8 @@ var init_dismissal_review = __esm({
 });
 
 // ../cli/src/lib/agent/flow.ts
-import fs78 from "node:fs";
-import path79 from "node:path";
+import fs79 from "node:fs";
+import path81 from "node:path";
 function readCard2(id, home3 = "board") {
   const found2 = home3 === "archive" ? locateArchived(id) : locate(id);
   if (!found2) {
@@ -23879,10 +24000,10 @@ function readCard2(id, home3 = "board") {
       { kind: "card-not-found", id }
     );
   }
-  const file = found2.kind === "group" ? path79.join(found2.target, "root.md") : found2.target;
+  const file = found2.kind === "group" ? path81.join(found2.target, "root.md") : found2.target;
   let text5;
   try {
-    text5 = fs78.readFileSync(file, "utf8");
+    text5 = fs79.readFileSync(file, "utf8");
   } catch {
     die(`#${id} is on the board but ${rel(file)} can't be read.`, { kind: "card-unreadable", id });
   }
@@ -24006,7 +24127,7 @@ function workspaceField(delivery) {
   if (!delivery?.worktree) return [];
   return field("workspace", [
     `write code in ${delivery.worktree} \u2014 this delivery's own worktree, on branch ${delivery.branch}.`,
-    path79.resolve(process.cwd()).startsWith(worktreeDir(delivery.worktree)) ? `it is your working folder already; the board's own files are NOT in it and never go on that branch.` : `cd into it first \u2014 you are in the project checkout, and code written here is not part of this build. The board's own files are NOT in it and never go on that branch.`,
+    path81.resolve(process.cwd()).startsWith(worktreeDir(delivery.worktree)) ? `it is your working folder already; the board's own files are NOT in it and never go on that branch.` : `cd into it first \u2014 you are in the project checkout, and code written here is not part of this build. The board's own files are NOT in it and never go on that branch.`,
     `every board command names the project's own copy: \`${boardCommandFor()} <command>\`.`,
     `${rel(REPO_ROOT)} is the project \u2014 the card, the memory files and the docs are changed there, not here.`
   ]);
@@ -24750,7 +24871,7 @@ __export(watch_exports, {
   watchRun: () => watchRun
 });
 import { spawn as spawn4 } from "node:child_process";
-import fs79 from "node:fs";
+import fs80 from "node:fs";
 async function watchRun(sessionId, resume = startResume) {
   const spec = readSpec(sessionId);
   const run2 = peekRun(sessionId);
@@ -24786,11 +24907,11 @@ async function watchRun(sessionId, resume = startResume) {
   const record = claimed ?? run2;
   const sub = record.action === "sub";
   if (claim) await setCardStatus(claim.cardId, claim.status);
-  fs79.mkdirSync(SESSIONS_DIR, { recursive: true });
-  const logFile = fs79.createWriteStream(record.logPath, { flags: "a" });
+  fs80.mkdirSync(SESSIONS_DIR, { recursive: true });
+  const logFile = fs80.createWriteStream(record.logPath, { flags: "a" });
   logFile.on("error", () => {
   });
-  const eventsFile = fs79.createWriteStream(eventsPathOf(sessionId), { flags: "a" });
+  const eventsFile = fs80.createWriteStream(eventsPathOf(sessionId), { flags: "a" });
   eventsFile.on("error", () => {
   });
   const event2 = (e) => eventsFile.write(`${JSON.stringify(e)}
@@ -25379,7 +25500,7 @@ var init_watch = __esm({
 });
 
 // ../cli/src/kanban.ts
-import fs85 from "node:fs";
+import fs86 from "node:fs";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../cli/src/lib/cli/agent.ts
@@ -25868,8 +25989,8 @@ async function testAgent(args) {
 }
 
 // ../cli/src/commands/cloud.ts
-import fs70 from "node:fs";
-import path71 from "node:path";
+import fs71 from "node:fs";
+import path73 from "node:path";
 
 // ../cli/src/lib/cloud/avatar.ts
 init_session();
@@ -25917,13 +26038,13 @@ init_config();
 init_home();
 init_config();
 init_session();
-import fs69 from "node:fs";
-import path70 from "node:path";
+import fs70 from "node:fs";
+import path72 from "node:path";
 var FRESH_MS = 10 * 6e4;
 var GRACE_MS = 7 * 24 * 60 * 6e4;
-var heldFile = () => path70.join(machineHome(), "pro.json");
+var heldFile = () => path72.join(machineHome(), "pro.json");
 function forgetPro() {
-  fs69.rmSync(heldFile(), { force: true });
+  fs70.rmSync(heldFile(), { force: true });
 }
 
 // ../cli/src/lib/cloud/account.ts
@@ -26100,10 +26221,10 @@ async function cloudImage(opts, program2) {
   const prompt = opts.prompt.trim();
   if (!prompt) usage("Missing the prompt.", line);
   const references = opts.refs.map((file) => {
-    const type = REF_TYPES[path71.extname(file).toLowerCase()];
+    const type = REF_TYPES[path73.extname(file).toLowerCase()];
     if (!type) usage(`--ref ${file}: use a PNG, JPEG or WebP file.`, line);
     try {
-      return `data:${type};base64,${fs70.readFileSync(file).toString("base64")}`;
+      return `data:${type};base64,${fs71.readFileSync(file).toString("base64")}`;
     } catch (e) {
       usage(`--ref ${file}: ${e instanceof Error ? e.message : String(e)}`, line);
     }
@@ -26209,31 +26330,31 @@ async function generate(g) {
     refuse(g.failed, g.fallback);
   }
   const out = g.outFor?.(res, g.out) ?? g.out;
-  fs70.mkdirSync(path71.dirname(path71.resolve(out)), { recursive: true });
-  fs70.writeFileSync(out, Buffer.from(await res.arrayBuffer()));
+  fs71.mkdirSync(path73.dirname(path73.resolve(out)), { recursive: true });
+  fs71.writeFileSync(out, Buffer.from(await res.arrayBuffer()));
   say(`${out} (${g.label(res)})`);
   return { out };
 }
 
 // ../cli/src/commands/cloud-import.ts
 import crypto5 from "node:crypto";
-import fs72 from "node:fs";
-import path73 from "node:path";
+import fs73 from "node:fs";
+import path75 from "node:path";
 
 // ../cloud/src/board-files.ts
 var ROOTS = ["todo/", ".archive/", "memory/", "workflows/", "triage/", "assets/", "rules/"];
 var SETTINGS = ["modules.md", "config.md"];
-var isSettingsPath = (path85) => SETTINGS.includes(path85) || /^rules\/(?:workflows\/)?[^/]+\.md$/.test(path85);
+var isSettingsPath = (path87) => SETTINGS.includes(path87) || /^rules\/(?:workflows\/)?[^/]+\.md$/.test(path87);
 var BOARD_FILE_LIMIT = 256 * 1024;
-function isBoardPath(path85) {
-  if (!path85 || path85.length > 500 || path85.startsWith("/") || path85.includes("\\") || path85.includes("\0")) return false;
-  if (path85.split("/").some((part) => !part || part === "." || part === "..")) return false;
-  if (path85 === "todo/README.md" || path85.split("/").includes(".sync")) return false;
-  if (path85.startsWith("workflows/")) return true;
-  if (SETTINGS.includes(path85)) return true;
-  if (path85.startsWith("rules/")) return isSettingsPath(path85);
-  if (path85.startsWith("assets/")) return path85.endsWith(".json");
-  return ROOTS.some((root) => path85.startsWith(root)) && path85.endsWith(".md");
+function isBoardPath(path87) {
+  if (!path87 || path87.length > 500 || path87.startsWith("/") || path87.includes("\\") || path87.includes("\0")) return false;
+  if (path87.split("/").some((part) => !part || part === "." || part === "..")) return false;
+  if (path87 === "todo/README.md" || path87.split("/").includes(".sync")) return false;
+  if (path87.startsWith("workflows/")) return true;
+  if (SETTINGS.includes(path87)) return true;
+  if (path87.startsWith("rules/")) return isSettingsPath(path87);
+  if (path87.startsWith("assets/")) return path87.endsWith(".json");
+  return ROOTS.some((root) => path87.startsWith(root)) && path87.endsWith(".md");
 }
 var workflowFolder = (id) => id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 
@@ -26337,8 +26458,8 @@ init_bundled();
 // ../cli/src/lib/agents/shared-memory.ts
 init_bundled();
 init_parse();
-import fs71 from "node:fs";
-import path72 from "node:path";
+import fs72 from "node:fs";
+import path74 from "node:path";
 function sharedMemory(board2) {
   const declared = /* @__PURE__ */ new Map();
   const take = (folder, text5, builtIn) => {
@@ -26350,16 +26471,16 @@ function sharedMemory(board2) {
     const at = /^([^/]+)\/AGENT\.md$/.exec(key);
     if (at) take(at[1], text5, true);
   }
-  const root = path72.join(board2, "agents");
+  const root = path74.join(board2, "agents");
   let folders2 = [];
   try {
-    folders2 = fs71.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+    folders2 = fs72.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
   } catch {
   }
   for (const folder of folders2.sort()) {
     let text5 = null;
     try {
-      text5 = fs71.readFileSync(path72.join(root, folder, "AGENT.md"), "utf8");
+      text5 = fs72.readFileSync(path74.join(root, folder, "AGENT.md"), "utf8");
     } catch {
     }
     take(folder, text5, false);
@@ -26448,24 +26569,24 @@ async function findProject(asked) {
   }
   throw new Refused(`No project of yours has the id or prefix "${asked}".`, "not_found");
 }
-var read = (file) => fs72.readFileSync(file, "utf8");
+var read = (file) => fs73.readFileSync(file, "utf8");
 var bytes2 = (text5) => Buffer.byteLength(text5, "utf8");
 function files(dir) {
-  if (!fs72.existsSync(dir)) return [];
+  if (!fs73.existsSync(dir)) return [];
   const out = [];
-  for (const entry of fs72.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs73.readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".")) continue;
-    const full = path73.join(dir, entry.name);
+    const full = path75.join(dir, entry.name);
     if (entry.isDirectory()) out.push(...files(full));
     else if (entry.isFile()) out.push(full);
   }
   return out;
 }
-var posix2 = (p) => p.split(path73.sep).join("/");
+var posix2 = (p) => p.split(path75.sep).join("/");
 function openCards() {
   const out = [];
   for (const file of walkMd(TODO)) {
-    const rel2 = posix2(path73.relative(TODO, file));
+    const rel2 = posix2(path75.relative(TODO, file));
     if (rel2 === "README.md") continue;
     const parts = rel2.split("/");
     const text5 = read(file);
@@ -26499,14 +26620,14 @@ function bodyProblems(text5) {
   return out;
 }
 function packWorkflow(flow) {
-  const own = path73.join(WORKFLOWS, flow.id);
+  const own = path75.join(WORKFLOWS, flow.id);
   const out = {};
-  for (const file of files(own)) out[posix2(path73.relative(own, file))] = read(file);
+  for (const file of files(own)) out[posix2(path75.relative(own, file))] = read(file);
   const named2 = [...flow.previews, ...flow.land, ...flow.scheduled].map((h) => h.agent).filter((a) => !LAND_ROLES.includes(a));
   for (const agent of new Set(named2)) {
-    const dir = path73.join(AGENTS, agent);
-    if (fs72.existsSync(path73.join(dir, "AGENT.md"))) {
-      for (const file of files(dir)) out[`agents/${agent}/${posix2(path73.relative(dir, file))}`] = read(file);
+    const dir = path75.join(AGENTS, agent);
+    if (fs73.existsSync(path75.join(dir, "AGENT.md"))) {
+      for (const file of files(dir)) out[`agents/${agent}/${posix2(path75.relative(dir, file))}`] = read(file);
       continue;
     }
     for (const [key, text5] of Object.entries(BUNDLED_AGENT_FILES)) {
@@ -26558,8 +26679,8 @@ function draftsOf(text5) {
     const at = /^\.(assets|mockups)\/(.+)$/.exec(name);
     if (!at) continue;
     const base = at[1] === "assets" ? ASSETS : MOCKUPS;
-    const file = path73.resolve(base, at[2]);
-    if (file.startsWith(base + path73.sep) && fs72.statSync(file, { throwIfNoEntry: false })?.isFile()) out.set(name, file);
+    const file = path75.resolve(base, at[2]);
+    if (file.startsWith(base + path75.sep) && fs73.statSync(file, { throwIfNoEntry: false })?.isFile()) out.set(name, file);
   }
   return [...out].map(([name, file]) => ({ name, file }));
 }
@@ -26593,9 +26714,9 @@ async function uploadDrafts(task, drafts) {
   const assets = {};
   for (const { name, file } of drafts) {
     if (!card.body.includes(name)) continue;
-    const ext = path73.extname(file).toLowerCase();
+    const ext = path75.extname(file).toLowerCase();
     const type = TYPES[ext] ?? "application/octet-stream";
-    const data = fs72.readFileSync(file);
+    const data = fs73.readFileSync(file);
     const artifact = await api("POST", `/v1/tasks/${task}/artifacts`, { type: kindOf(ext), name: name.slice(0, 200) });
     const upload = await api("POST", `/v1/artifacts/${artifact.id}/uploads`, { content_type: type, size: Math.max(data.length, 1) });
     await api("PUT", `/v1/uploads/${upload.id}`, void 0, { bytes: data, type });
@@ -26638,10 +26759,10 @@ usage: ${program2} cloud import --project <id or prefix> [--dry-run]`, { kind: "
 async function run(asked, dryRun) {
   const project = await findProject(asked);
   const cloudFlows = await all(`/v1/workflows?workspace=${encodeURIComponent(project.workspace)}`);
-  const board2 = crypto5.createHash("sha256").update(fs72.realpathSync(KANBAN)).digest("hex").slice(0, 16);
+  const board2 = crypto5.createHash("sha256").update(fs73.realpathSync(KANBAN)).digest("hex").slice(0, 16);
   const cards = openCards();
   const problems = [];
-  const where = (file) => posix2(path73.relative(KANBAN, file));
+  const where = (file) => posix2(path75.relative(KANBAN, file));
   const own = workflows().filter((w) => !w.builtIn);
   const packed = /* @__PURE__ */ new Map();
   for (const flow of own) {
@@ -26668,7 +26789,7 @@ async function run(asked, dryRun) {
   const root = `projects/${project.id}/`;
   const boardFiles = [];
   for (const file of [...files(MEMORY), ...files(RULES), CONFIG, MODULES_MD]) {
-    if (!fs72.existsSync(file)) continue;
+    if (!fs73.existsSync(file)) continue;
     const rel2 = where(file);
     if (!isBoardPath(rel2)) continue;
     const content = read(file);
@@ -26779,16 +26900,16 @@ async function run(asked, dryRun) {
 }
 function leftLocal(own) {
   const out = [];
-  const count4 = (dir) => fs72.existsSync(dir) ? walkMd(dir).length : 0;
+  const count4 = (dir) => fs73.existsSync(dir) ? walkMd(dir).length : 0;
   const archived = count4(ARCHIVE);
   if (archived) out.push(`.archive/ (${archived})`);
   const triage = count4(TRIAGE);
   if (triage) out.push(`triage/ (${triage})`);
-  if (fs72.existsSync(DELIVERIES)) out.push("deliveries/");
-  if (fs72.existsSync(path73.join(KANBAN, "metrics.csv"))) out.push("metrics.csv");
+  if (fs73.existsSync(DELIVERIES)) out.push("deliveries/");
+  if (fs73.existsSync(path75.join(KANBAN, "metrics.csv"))) out.push("metrics.csv");
   const named2 = new Set(own.flatMap((w) => [...w.previews, ...w.land, ...w.scheduled].map((h) => h.agent)));
-  if (fs72.existsSync(AGENTS)) {
-    for (const e of fs72.readdirSync(AGENTS, { withFileTypes: true })) {
+  if (fs73.existsSync(AGENTS)) {
+    for (const e of fs73.readdirSync(AGENTS, { withFileTypes: true })) {
       if (e.isDirectory() && !e.name.startsWith(".") && !named2.has(e.name)) out.push(`agents/${e.name}/`);
     }
   }
@@ -26806,8 +26927,8 @@ init_session();
 init_io();
 init_paths();
 import { createHash as createHash4 } from "node:crypto";
-import fs73 from "node:fs";
-import path74 from "node:path";
+import fs74 from "node:fs";
+import path76 from "node:path";
 var SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var CAPTURED = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
 var MAX_BYTES3 = 50 * 1024 * 1024;
@@ -26906,10 +27027,10 @@ This template has no preview.`);
   const written = [];
   for (const p of previews) {
     const bytes3 = Buffer.from(await (await ask(`/${at}/previews/${route(p.path)}`, {}, WITHOUT)).arrayBuffer());
-    const file = path74.basename(p.path);
-    const out = path74.join(opts.to, file.startsWith(`${name}-`) ? file : `${name}-${file}`);
-    fs73.mkdirSync(opts.to, { recursive: true });
-    fs73.writeFileSync(out, bytes3);
+    const file = path76.basename(p.path);
+    const out = path76.join(opts.to, file.startsWith(`${name}-`) ? file : `${name}-${file}`);
+    fs74.mkdirSync(opts.to, { recursive: true });
+    fs74.writeFileSync(out, bytes3);
     written.push(out);
     say(out);
   }
@@ -26922,15 +27043,15 @@ async function templateGet(name, opts, program2) {
   const { template } = await asJson(await ask(`/${at}`, {}, WITHOUT));
   const fetched = [];
   for (const f of template.files) {
-    const out = path74.resolve(to, f.path);
-    if (!out.startsWith(path74.resolve(to) + path74.sep)) refuse2(T.corrupt, WITHOUT);
+    const out = path76.resolve(to, f.path);
+    if (!out.startsWith(path76.resolve(to) + path76.sep)) refuse2(T.corrupt, WITHOUT);
     const bytes3 = Buffer.from(await (await ask(`/${at}/files/${route(f.path)}`, {}, WITHOUT)).arrayBuffer());
     if (bytes3.byteLength !== f.size || createHash4("sha256").update(bytes3).digest("hex") !== f.sha256) {
       refuse2(T.corrupt, WITHOUT);
     }
     fetched.push({ out, bytes: bytes3 });
   }
-  const taken = fetched.filter((f) => fs73.existsSync(f.out)).map((f) => path74.relative(to, f.out));
+  const taken = fetched.filter((f) => fs74.existsSync(f.out)).map((f) => path76.relative(to, f.out));
   if (taken.length > 0) {
     refuse2({
       zh: `\u76EE\u6807\u6587\u4EF6\u5939\u5DF2\u6709\u540C\u540D\u6587\u4EF6\uFF1A${taken.join("\u3001")}\u3002\u8BF7\u6362\u4E00\u4E2A\u6587\u4EF6\u5939\uFF0C\u6216\u5148\u79FB\u8D70\u8FD9\u4E9B\u6587\u4EF6\u3002`,
@@ -26938,8 +27059,8 @@ async function templateGet(name, opts, program2) {
     });
   }
   for (const f of fetched) {
-    fs73.mkdirSync(path74.dirname(f.out), { recursive: true });
-    fs73.writeFileSync(f.out, f.bytes);
+    fs74.mkdirSync(path76.dirname(f.out), { recursive: true });
+    fs74.writeFileSync(f.out, f.bytes);
   }
   say(`\u5DF2\u53D6\u56DE ${name}\uFF1A${fetched.length} \u4E2A\u6587\u4EF6\uFF0C\u4F4D\u4E8E ${to}
 Fetched ${name}: ${fetched.length} files into ${to}`);
@@ -26957,25 +27078,25 @@ async function templateSource(name, opts) {
       say(`evidence: ${e.path}`);
       continue;
     }
-    const out = path74.join(opts.to, `${name}-${path74.basename(e.path)}`);
-    fs73.mkdirSync(opts.to, { recursive: true });
-    fs73.writeFileSync(out, Buffer.from(await (await ask(`/${at}/evidence/${route(e.path)}`)).arrayBuffer()));
+    const out = path76.join(opts.to, `${name}-${path76.basename(e.path)}`);
+    fs74.mkdirSync(opts.to, { recursive: true });
+    fs74.writeFileSync(out, Buffer.from(await (await ask(`/${at}/evidence/${route(e.path)}`)).arrayBuffer()));
     written.push(out);
     say(out);
   }
   return { name, source, evidence: written.length > 0 ? written : evidence.map((e) => e.path) };
 }
 async function templatePublish(dir, opts) {
-  const root = path74.resolve(dir);
-  const manifest = path74.join(root, "template.md");
-  if (!fs73.existsSync(manifest)) invalid("\u6587\u4EF6\u5939\u9876\u5C42\u7F3A\u5C11 template.md\u3002", "template.md is missing from the folder\u2019s top level.");
-  const meta = readTemplateMeta(fs73.readFileSync(manifest, "utf8"));
+  const root = path76.resolve(dir);
+  const manifest = path76.join(root, "template.md");
+  if (!fs74.existsSync(manifest)) invalid("\u6587\u4EF6\u5939\u9876\u5C42\u7F3A\u5C11 template.md\u3002", "template.md is missing from the folder\u2019s top level.");
+  const meta = readTemplateMeta(fs74.readFileSync(manifest, "utf8"));
   const files2 = walk2(root);
-  const total = files2.reduce((sum, f) => sum + fs73.statSync(path74.join(root, f)).size, 0);
+  const total = files2.reduce((sum, f) => sum + fs74.statSync(path76.join(root, f)).size, 0);
   if (total > MAX_BYTES3) invalid("\u6A21\u677F\u6587\u4EF6\u5408\u8BA1\u8D85\u8FC7 50 MB\u3002", "the template\u2019s files exceed 50 MB.");
   for (const extra of [...opts.preview, ...opts.evidence]) {
-    if (!fs73.existsSync(extra)) invalid(`\u627E\u4E0D\u5230\u6587\u4EF6 ${extra}\u3002`, `${extra} does not exist.`);
-    if (path74.resolve(extra).startsWith(root + path74.sep)) {
+    if (!fs74.existsSync(extra)) invalid(`\u627E\u4E0D\u5230\u6587\u4EF6 ${extra}\u3002`, `${extra} does not exist.`);
+    if (path76.resolve(extra).startsWith(root + path76.sep)) {
       invalid(
         `${extra} \u5728\u6A21\u677F\u6587\u4EF6\u5939\u5185\uFF1B\u9884\u89C8\u56FE\u4E0E\u6765\u6E90\u51ED\u8BC1\u9700\u653E\u5728\u6A21\u677F\u6587\u4EF6\u5939\u4E4B\u5916\u3002`,
         `${extra} is inside the template folder; keep previews and evidence outside it.`
@@ -26987,10 +27108,10 @@ async function templatePublish(dir, opts) {
   }
   const form = new FormData();
   form.set("meta", JSON.stringify({ ...meta, replace: !!opts.replace }));
-  const add = (kind, name, file) => form.append(`${kind}:${name}`, new Blob([fs73.readFileSync(file)]), path74.basename(name));
-  for (const f of files2) add("files", f, path74.join(root, f));
-  for (const f of opts.preview) add("previews", path74.basename(f), f);
-  for (const f of opts.evidence) add("evidence", path74.basename(f), f);
+  const add = (kind, name, file) => form.append(`${kind}:${name}`, new Blob([fs74.readFileSync(file)]), path76.basename(name));
+  for (const f of files2) add("files", f, path76.join(root, f));
+  for (const f of opts.preview) add("previews", path76.basename(f), f);
+  for (const f of opts.evidence) add("evidence", path76.basename(f), f);
   const done2 = await asJson(await ask("", { method: "POST", body: form }));
   say(
     done2.replaced ? `\u5DF2\u66FF\u6362 ${done2.name}\uFF1A${files2.length} \u4E2A\u6587\u4EF6\u3002
@@ -27006,11 +27127,11 @@ Deleted ${name} from the catalog.`);
   return { name, deleted: true };
 }
 async function templateShowcase(name, dir) {
-  const file = path74.join(dir, "showcase.json");
-  if (!fs73.existsSync(file)) invalid(`${dir} \u4E2D\u7F3A\u5C11 showcase.json\u3002`, `showcase.json is missing from ${dir}.`);
+  const file = path76.join(dir, "showcase.json");
+  if (!fs74.existsSync(file)) invalid(`${dir} \u4E2D\u7F3A\u5C11 showcase.json\u3002`, `showcase.json is missing from ${dir}.`);
   let meta;
   try {
-    meta = JSON.parse(fs73.readFileSync(file, "utf8"));
+    meta = JSON.parse(fs74.readFileSync(file, "utf8"));
   } catch {
     return invalid("showcase.json \u4E0D\u662F\u6709\u6548\u7684 JSON\u3002", "showcase.json is not valid JSON.");
   }
@@ -27022,9 +27143,9 @@ async function templateShowcase(name, dir) {
   const form = new FormData();
   form.set("meta", JSON.stringify(meta));
   for (const p of new Set(named2)) {
-    const at = path74.join(dir, p);
-    if (!fs73.existsSync(at)) invalid(`\u627E\u4E0D\u5230\u6587\u4EF6 ${at}\u3002`, `${at} does not exist.`);
-    form.append(`media:${p}`, new Blob([fs73.readFileSync(at)]), p);
+    const at = path76.join(dir, p);
+    if (!fs74.existsSync(at)) invalid(`\u627E\u4E0D\u5230\u6587\u4EF6 ${at}\u3002`, `${at} does not exist.`);
+    form.append(`media:${p}`, new Blob([fs74.readFileSync(at)]), p);
   }
   const done2 = await asJson(await ask(`/${encodeURIComponent(name)}/showcase`, { method: "PUT", body: form }));
   say(`\u5DF2\u66F4\u65B0 ${name} \u7684\u5C55\u793A\u8D44\u6599\uFF1A${done2.files} \u4E2A\u6587\u4EF6\u3002
@@ -27033,7 +27154,7 @@ Updated ${name}'s showcase: ${done2.files} files.`);
 }
 function walk2(root, sub = "") {
   const out = [];
-  for (const entry of fs73.readdirSync(path74.join(root, sub), { withFileTypes: true })) {
+  for (const entry of fs74.readdirSync(path76.join(root, sub), { withFileTypes: true })) {
     if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
     const rel2 = sub ? `${sub}/${entry.name}` : entry.name;
     if (entry.isDirectory()) out.push(...walk2(root, rel2));
@@ -27318,7 +27439,7 @@ init_opencode();
 init_locate();
 init_store();
 import { spawnSync as spawnSync5 } from "node:child_process";
-import path80 from "node:path";
+import path82 from "node:path";
 var AGENTS2 = {
   claude: "claude-code",
   codex: "codex",
@@ -27333,10 +27454,10 @@ var AGENTS2 = {
 var RUNTIMES = /* @__PURE__ */ new Set(["node", "bun", "deno"]);
 function agentOf2(args) {
   const words = args.trim().split(/\s+/);
-  const first = path80.basename(words[0] ?? "");
+  const first = path82.basename(words[0] ?? "");
   const script = RUNTIMES.has(first) ? words[1] ?? "" : words[0] ?? "";
   if (script.includes("/@anthropic-ai/claude-code/")) return "claude-code";
-  return AGENTS2[path80.basename(script).replace(/\.(m?js|cjs|exe)$/, "")];
+  return AGENTS2[path82.basename(script).replace(/\.(m?js|cjs|exe)$/, "")];
 }
 function processChain() {
   if (process.platform === "win32") return [];
@@ -27400,8 +27521,8 @@ init_tasks();
 init_read();
 init_rules();
 init_board();
-import fs80 from "node:fs";
-import path81 from "node:path";
+import fs81 from "node:fs";
+import path83 from "node:path";
 var FOLLOW_MS = 400;
 async function cmdStartRun(action, args, opts, program2 = "akb") {
   const { req, follow: follow2, print } = readRequest(action, args, opts);
@@ -27691,7 +27812,7 @@ async function cmdSubStart(words, opts) {
   let prompt = words.join(" ");
   if (opts.file) {
     try {
-      prompt = fs80.readFileSync(path81.resolve(opts.file), "utf8");
+      prompt = fs81.readFileSync(path83.resolve(opts.file), "utf8");
     } catch {
       die(`--file: cannot read ${opts.file}`, { kind: "run-refused" });
     }
@@ -27982,7 +28103,7 @@ async function cmdWatch(sessionId) {
 // ../cli/src/commands/triage.ts
 init_scheduled();
 init_workflows();
-import fs82 from "node:fs";
+import fs83 from "node:fs";
 
 // ../cli/src/lib/signals/index.ts
 init_cards();
@@ -27992,16 +28113,16 @@ init_yaml();
 // ../cli/src/lib/signals/config.ts
 init_settings2();
 init_paths();
-import fs81 from "node:fs";
-import path82 from "node:path";
+import fs82 from "node:fs";
+import path84 from "node:path";
 var TOKEN_KEY = "TRIAGE_ENDPOINT_TOKEN";
 var ENDPOINT_SETTING = "Triage endpoint";
 var LINE2 = /^- \*\*Triage endpoint\*\*\s*[—-]\s*(.+)$/m;
-var boardRel3 = (file) => rel(file).split(path82.sep).join("/");
+var boardRel3 = (file) => rel(file).split(path84.sep).join("/");
 function signalEndpoint() {
   let text5;
   try {
-    text5 = fs81.readFileSync(CONFIG, "utf8");
+    text5 = fs82.readFileSync(CONFIG, "utf8");
   } catch {
     return "";
   }
@@ -28177,7 +28298,7 @@ async function cmdTriageAdd(opts) {
   let body = opts.text;
   if (opts.file !== void 0) {
     try {
-      body = fs82.readFileSync(opts.file, "utf8");
+      body = fs83.readFileSync(opts.file, "utf8");
     } catch {
       die(`can't read ${opts.file} \u2014 write the item to a file, then pass its path`, { kind: "needs-input" });
     }
@@ -28741,8 +28862,8 @@ function declareAgent(program2, cli) {
 }
 
 // ../cli/src/lib/cli/setup.ts
-import fs84 from "node:fs";
-import path84 from "node:path";
+import fs85 from "node:fs";
+import path86 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../cli/src/commands/update.ts
@@ -28756,8 +28877,8 @@ init_paths();
 init_memory();
 init_yaml2();
 init_version();
-import fs83 from "node:fs";
-import path83 from "node:path";
+import fs84 from "node:fs";
+import path85 from "node:path";
 import { spawnSync as spawnSync6 } from "node:child_process";
 var NAME = "wildcrane";
 var REPO = "https://github.com/ai4kanban/ai4kanban";
@@ -28779,10 +28900,10 @@ var Report = class {
     for (const line of this.notes) say(`  ! ${line}`);
   }
 };
-var read3 = (file) => fs83.existsSync(file) ? fs83.readFileSync(file, "utf8") : null;
+var read3 = (file) => fs84.existsSync(file) ? fs84.readFileSync(file, "utf8") : null;
 function statOf(p) {
   try {
-    return fs83.lstatSync(p);
+    return fs84.lstatSync(p);
   } catch {
     return null;
   }
@@ -28807,10 +28928,10 @@ async function cmdUpdate2(ctx) {
   return { updated: ctx.dir, from, to: SKILL_VERSION };
 }
 async function repairBoard(root, report3, named2) {
-  const legacy = path83.join(root, "docs", "kanban");
-  const kept2 = path83.join(root, ".akb", "kanban");
-  const board2 = named2 ?? (fs83.existsSync(legacy) ? legacy : kept2);
-  if (!fs83.existsSync(board2)) {
+  const legacy = path85.join(root, "docs", "kanban");
+  const kept2 = path85.join(root, ".akb", "kanban");
+  const board2 = named2 ?? (fs84.existsSync(legacy) ? legacy : kept2);
+  if (!fs84.existsSync(board2)) {
     report3.notes.push("\u672A\u627E\u5230\u770B\u677F\uFF0C\u8BF7\u901A\u8FC7\u63D2\u4EF6\u8FDE\u63A5\u4E91\u7AEF\u9879\u76EE\u3002");
     return false;
   }
@@ -28841,20 +28962,20 @@ function moveRuntimes(root, board2, report3) {
   }
 }
 function moveLegacyMemory(board2, report3) {
-  const memory = path83.join(board2, "memory");
+  const memory = path85.join(board2, "memory");
   const moved = [];
   for (const name of MEMORY_FILES) {
-    const from = path83.join(board2, name);
+    const from = path85.join(board2, name);
     const st = statOf(from);
     if (!st || !st.isFile()) continue;
-    fs83.mkdirSync(memory, { recursive: true });
-    const to = path83.join(memory, name);
+    fs84.mkdirSync(memory, { recursive: true });
+    const to = path85.join(memory, name);
     const there = read3(to);
     if (there === null) {
-      fs83.renameSync(from, to);
+      fs84.renameSync(from, to);
       moved.push(name);
     } else if (there === read3(from)) {
-      fs83.rmSync(from);
+      fs84.rmSync(from);
       moved.push(name);
     } else {
       report3.notes.push(`both docs/kanban/${name} and docs/kanban/memory/${name} exist and differ \u2014 merge them by hand`);
@@ -28863,23 +28984,23 @@ function moveLegacyMemory(board2, report3) {
   if (moved.length) report3.did.push(`moved the memory set into docs/kanban/memory/: ${moved.join(", ")}`);
 }
 function dropRecordFile(board2) {
-  const file = path83.join(board2, "record.csv");
-  if (!fs83.existsSync(file)) return null;
-  fs83.rmSync(file);
+  const file = path85.join(board2, "record.csv");
+  if (!fs84.existsSync(file)) return null;
+  fs84.rmSync(file);
   return "removed docs/kanban/record.csv (the planning scores it fed are gone)";
 }
 function dropModuleGoals(board2, report3) {
-  const memory = path83.join(board2, "memory");
-  if (!fs83.existsSync(memory)) return;
-  const root = read3(path83.join(memory, "goal.md"));
+  const memory = path85.join(board2, "memory");
+  if (!fs84.existsSync(memory)) return;
+  const root = read3(path85.join(memory, "goal.md"));
   let dropped = 0;
-  for (const entry of fs83.readdirSync(memory, { withFileTypes: true })) {
+  for (const entry of fs84.readdirSync(memory, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const file = path83.join(memory, entry.name, "goal.md");
+    const file = path85.join(memory, entry.name, "goal.md");
     const text5 = read3(file);
     if (text5 === null) continue;
     if (text5 === root || text5.includes(UNFILLED) || !goalWords(text5)) {
-      fs83.rmSync(file);
+      fs84.rmSync(file);
       dropped++;
     } else {
       report3.notes.push(
@@ -28901,10 +29022,10 @@ var PLAN_LEADS = {
 var GONE_LEADS = ["software-planner", "planner"];
 function planLeads(board2) {
   const leads = { ...PLAN_LEADS };
-  const root = path83.join(board2, "workflows");
-  for (const entry of fs83.existsSync(root) ? fs83.readdirSync(root, { withFileTypes: true }) : []) {
+  const root = path85.join(board2, "workflows");
+  for (const entry of fs84.existsSync(root) ? fs84.readdirSync(root, { withFileTypes: true }) : []) {
     if (!entry.isDirectory()) continue;
-    const meta = splitFrontmatter(read3(path83.join(root, entry.name, "WORKFLOW.md")) ?? "").meta;
+    const meta = splitFrontmatter(read3(path85.join(root, entry.name, "WORKFLOW.md")) ?? "").meta;
     const stages = meta === null ? void 0 : parseYamlBlock(meta).stages;
     const plan = stages && typeof stages === "object" && !Array.isArray(stages) ? stages.plan : void 0;
     const lead = plan && typeof plan === "object" && !Array.isArray(plan) && typeof plan.lead === "string" ? plan.lead.trim() : "";
@@ -28913,30 +29034,30 @@ function planLeads(board2) {
   return leads;
 }
 function movePlanRules(board2, report3) {
-  const rules = path83.join(board2, "rules");
+  const rules = path85.join(board2, "rules");
   const moved = [];
   for (const [id, leads] of Object.entries(planLeads(board2))) {
     for (const lead of leads) {
-      const from = path83.join(rules, `${lead}.md`);
+      const from = path85.join(rules, `${lead}.md`);
       const rule = read3(from)?.trim();
       if (!rule) continue;
-      const to = path83.join(rules, "workflows", `${id}.md`);
+      const to = path85.join(rules, "workflows", `${id}.md`);
       const there = read3(to)?.trim() ?? "";
       if (!there.includes(rule)) {
-        fs83.mkdirSync(path83.dirname(to), { recursive: true });
-        fs83.writeFileSync(to, `${[there, rule].filter(Boolean).join("\n\n")}
+        fs84.mkdirSync(path85.dirname(to), { recursive: true });
+        fs84.writeFileSync(to, `${[there, rule].filter(Boolean).join("\n\n")}
 `);
         moved.push(`${lead} \u2192 ${id}`);
       }
     }
   }
-  for (const lead of GONE_LEADS) fs83.rmSync(path83.join(rules, `${lead}.md`), { force: true });
+  for (const lead of GONE_LEADS) fs84.rmSync(path85.join(rules, `${lead}.md`), { force: true });
   if (moved.length) report3.did.push(`made each plan agent's rule its workflow's card rule (docs/kanban/rules/workflows/): ${moved.join(", ")}`);
 }
 function noteOldWorkflows(board2, report3) {
   const old = (dir, file, keys) => {
-    const root = path83.join(board2, dir);
-    return (fs83.existsSync(root) ? fs83.readdirSync(root, { withFileTypes: true }) : []).filter((e) => e.isDirectory() && keys.test(splitFrontmatter(read3(path83.join(root, e.name, file)) ?? "").meta ?? "")).map((e) => `docs/kanban/${dir}/${e.name}/${file}`);
+    const root = path85.join(board2, dir);
+    return (fs84.existsSync(root) ? fs84.readdirSync(root, { withFileTypes: true }) : []).filter((e) => e.isDirectory() && keys.test(splitFrontmatter(read3(path85.join(root, e.name, file)) ?? "").meta ?? "")).map((e) => `docs/kanban/${dir}/${e.name}/${file}`);
   };
   const files2 = [...old("workflows", "WORKFLOW.md", /^(stages|delivers):/m), ...old("agents", "AGENT.md", /^\s+(hook|lead):/m)];
   if (files2.length) {
@@ -28946,7 +29067,7 @@ function noteOldWorkflows(board2, report3) {
   }
 }
 function checkConfig(board2, report3) {
-  const current = read3(path83.join(board2, "config.md"));
+  const current = read3(path85.join(board2, "config.md"));
   if (!current) return;
   const added = missingConfigKeys(current);
   if (added.length) {
@@ -28956,7 +29077,7 @@ function checkConfig(board2, report3) {
   }
 }
 function checkModules(board2, report3) {
-  const map2 = read3(path83.join(board2, "modules.md"));
+  const map2 = read3(path85.join(board2, "modules.md"));
   if (map2 && map2.includes(UNFILLED)) {
     report3.notes.push(
       "docs/kanban/modules.md is still blank \u2014 write it from the repo (`akb guide module-map`)"
@@ -29010,14 +29131,14 @@ function declareSetup(program2, cli) {
   program2.version(SKILL_VERSION, "-v, --version", "print this version").addHelpText("beforeAll", spelled(cli.program));
   const dirOption = (cmd) => cmd.option("--dir <path>", "the project to work on (default: the current folder)").option("--json", "answer as one JSON object instead of prose");
   const where = (cmd) => {
-    const dir = path84.resolve(String(cmd.optsWithGlobals().dir ?? cli.cwd));
-    if (!fs84.existsSync(dir)) throw new BoardError(`no such folder: ${dir}`, { kind: "no-such-folder", dir });
+    const dir = path86.resolve(String(cmd.optsWithGlobals().dir ?? cli.cwd));
+    if (!fs85.existsSync(dir)) throw new BoardError(`no such folder: ${dir}`, { kind: "no-such-folder", dir });
     return dir;
   };
   dirOption(program2.command("update")).summary("\u4FEE\u590D\u5DF2\u6709\u770B\u677F\u5E76\u68C0\u67E5 CLI \u65B0\u7248\u672C").description("\u4FEE\u590D\u5DF2\u6709\u770B\u677F\u5E76\u63D0\u793A CLI \u5347\u7EA7\u547D\u4EE4\u3002\u6CA1\u6709\u770B\u677F\u65F6\uFF0C\u8BF7\u901A\u8FC7\u63D2\u4EF6\u8FDE\u63A5\u4E91\u7AEF\u9879\u76EE\u3002").action(async function() {
     const dir = where(this);
     const named2 = this.optsWithGlobals().board ?? process.env.AI4KANBAN_BOARD?.trim();
-    const board2 = named2 ? path84.resolve(cli.cwd, named2) : null;
+    const board2 = named2 ? path86.resolve(cli.cwd, named2) : null;
     await runAction(ctxOf(this, cli.program), {}, () => cmdUpdate2({ dir, program: cli.program, board: board2 }));
   });
   program2.command("__rules", { hidden: true }).action(function() {
@@ -29061,7 +29182,7 @@ function invokedDirectly() {
   const entry = process.argv[1];
   if (!entry) return false;
   try {
-    return fs85.realpathSync(entry) === fs85.realpathSync(SELF2);
+    return fs86.realpathSync(entry) === fs86.realpathSync(SELF2);
   } catch {
     return false;
   }