@factiii/runner 0.11.3 → 0.12.1

package/dist/cli.js

@@ -963,7 +963,7 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path21 = require("node:path");
+    var path23 = require("node:path");
     var fs15 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1896,9 +1896,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path21.resolve(baseDir, baseName);
+          const localBin = path23.resolve(baseDir, baseName);
           if (fs15.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path21.extname(baseName))) return void 0;
+          if (sourceExt.includes(path23.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs15.existsSync(`${localBin}${ext}`)
           );
@@ -1916,17 +1916,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path21.resolve(
-            path21.dirname(resolvedScriptPath),
+          executableDir = path23.resolve(
+            path23.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path21.basename(
+            const legacyName = path23.basename(
               this._scriptPath,
-              path21.extname(this._scriptPath)
+              path23.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1937,7 +1937,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path21.extname(executableFile));
+        launchWithNode = sourceExt.includes(path23.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2777,7 +2777,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path21.basename(filename, path21.extname(filename));
+        this._name = path23.basename(filename, path23.extname(filename));
         return this;
       }
       /**
@@ -2791,9 +2791,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path22) {
-        if (path22 === void 0) return this._executableDir;
-        this._executableDir = path22;
+      executableDir(path24) {
+        if (path24 === void 0) return this._executableDir;
+        this._executableDir = path24;
         return this;
       }
       /**
@@ -6499,7 +6499,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net3 = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash: createHash2 } = require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash2 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -7037,7 +7037,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes(16).toString("base64");
+      const key = randomBytes2(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -8428,8 +8428,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path21, errorMaps, issueData } = params;
-  const fullPath = [...path21, ...issueData.path || []];
+  const { data, path: path23, errorMaps, issueData } = params;
+  const fullPath = [...path23, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -8545,11 +8545,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value2, path21, key) {
+  constructor(parent, value2, path23, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value2;
-    this._path = path21;
+    this._path = path23;
     this._key = key;
   }
   get path() {
@@ -12910,7 +12910,7 @@ ${diff.slice(0, 8e3)}`,
 }
 
 // ../../shared/all/helpers/board-agent-core/engine.ts
-var import_path13 = require("path");
+var import_path15 = require("path");
 
 // ../../shared/all/domains/electron.ts
 var SETUP_LOG_PREFIX = "
log ";
@@ -13019,7 +13019,7 @@ async function ensurePrimaryClone(target, cloneUrl, branch) {
   await target.sh(`mkdir -p ${target.paths.worktrees}`);
 }
 async function addWorktree(target, workName, baseBranch, kind) {
-  const path21 = worktreeFor(target.paths, workName);
+  const path23 = worktreeFor(target.paths, workName);
   const branch = workBranch(workName, kind);
   await gitInDir(
     target,
@@ -13029,7 +13029,7 @@ async function addWorktree(target, workName, baseBranch, kind) {
     baseBranch
   ).catch(() => {
   });
-  await removeWorktree(target, path21).catch(() => {
+  await removeWorktree(target, path23).catch(() => {
   });
   await gitInDir(
     target,
@@ -13038,30 +13038,30 @@ async function addWorktree(target, workName, baseBranch, kind) {
     "add",
     "-B",
     branch,
-    path21,
+    path23,
     `origin/${baseBranch}`
   );
-  return { path: path21, branch };
+  return { path: path23, branch };
 }
-async function removeWorktree(target, path21) {
+async function removeWorktree(target, path23) {
   await gitInDir(
     target,
     target.paths.repo,
     "worktree",
     "remove",
     "--force",
-    path21
+    path23
   );
 }
-async function removeWorktreeAndBranch(target, path21) {
+async function removeWorktreeAndBranch(target, path23) {
   const branch = await gitInDir(
     target,
-    path21,
+    path23,
     "rev-parse",
     "--abbrev-ref",
     "HEAD"
   ).then((out) => out.trim()).catch(() => "");
-  await removeWorktree(target, path21);
+  await removeWorktree(target, path23);
   if (branch && branch !== "HEAD") {
     await gitInDir(target, target.paths.repo, "branch", "-D", branch).catch(
       () => {
@@ -13075,8 +13075,8 @@ async function pruneWorktrees(target) {
     }
   );
 }
-function isWorktreePath(target, path21) {
-  return path21.startsWith(`${target.paths.worktrees}/`);
+function isWorktreePath(target, path23) {
+  return path23.startsWith(`${target.paths.worktrees}/`);
 }
 async function setGitIdentity(target, name, email, workdir = target.paths.workspace) {
   if (name) await gitInDir(target, workdir, "config", "user.name", name);
@@ -13102,13 +13102,13 @@ function parseStatus(raw) {
     const y = line[1];
     const rest = line.slice(3);
     const arrow = rest.indexOf(" -> ");
-    const path21 = arrow === -1 ? rest : rest.slice(arrow + 4);
+    const path23 = arrow === -1 ? rest : rest.slice(arrow + 4);
     if (x === "?" || y === "?") {
-      unstaged.push({ path: path21, code: "A" });
+      unstaged.push({ path: path23, code: "A" });
       continue;
     }
-    if (x !== " ") staged.push({ path: path21, code: x });
-    if (y !== " ") unstaged.push({ path: path21, code: y });
+    if (x !== " ") staged.push({ path: path23, code: x });
+    if (y !== " ") unstaged.push({ path: path23, code: y });
   }
   return { staged, unstaged };
 }
@@ -13337,6 +13337,13 @@ async function ensureRedis(target) {
   }
   throw new Error("redis-server did not come up.");
 }
+var TERMINAL_ACK_KEY = "terminal:ack";
+async function getTerminalAck(target) {
+  return await redisCli(target, `GET ${TERMINAL_ACK_KEY}`).catch(() => "");
+}
+async function setTerminalAck(target, digest) {
+  await redisCliStdin(target, ["SET", TERMINAL_ACK_KEY], digest);
+}
 async function putCard(target, record) {
   const id = safeId(record.postId);
   await redisCliStdin(target, ["SET", cardKey(id)], JSON.stringify(record));
@@ -13372,49 +13379,10 @@ async function deleteCard(target, postId) {
   await redisCli(target, `SREM ${INDEX_KEY} ${id}`);
 }
 
-// ../../shared/all/helpers/card-ai/card-session.ts
-function isWorktreeSession(s, target) {
-  return isWorktreePath(target, s.workspacePath);
-}
-function sessionToRecord(s, prompt2 = "") {
-  return {
-    postId: s.postId,
-    taskId: s.taskId,
-    mode: s.mode,
-    phase: s.phase,
-    provider: s.provider,
-    worktreePath: s.workspacePath,
-    agentSessionId: s.agentSessionId,
-    taskTitle: s.taskTitle,
-    targetBranch: s.targetBranch,
-    startedAt: s.startedAt,
-    prompt: prompt2,
-    pendingQuestion: s.pendingQuestion
-  };
-}
-async function putSessionCard(s, target, prompt2 = "") {
-  try {
-    await putCard(target, sessionToRecord(s, prompt2));
-  } catch {
-  }
-}
-async function teardownSession(s, target) {
-  if (isWorktreeSession(s, target)) {
-    const drop = s.mode === "bare" ? removeWorktreeAndBranch : removeWorktree;
-    await drop(target, s.workspacePath).catch(() => {
-    });
-  }
-  await deleteCard(target, s.postId).catch(() => {
-  });
-}
-
-// ../../shared/all/helpers/board-agent-core/exec.ts
-var import_child_process2 = require("child_process");
+// ../../shared/all/helpers/board-agent-core/tmux.ts
 var import_fs = require("fs");
-var import_promises = __toESM(require("fs/promises"));
-var import_net = __toESM(require("net"));
+var import_promises = require("fs/promises");
 var import_path3 = __toESM(require("path"));
-var import_util4 = require("util");
 
 // ../../shared/all/helpers/board-agent-core/host-env.ts
 var import_child_process = require("child_process");
@@ -13541,13 +13509,314 @@ async function hostEnv() {
   return { ...process.env, PATH: await freshPath() };
 }
 
+// ../../shared/all/helpers/board-agent-core/tmux.ts
+var TMUX_CONF = [
+  // Wheel scrolls, drag selects in copy mode.
+  "set -g mouse on",
+  "set -g history-limit 50000",
+  // These three are copy-on-select: tmux emits OSC 52, the client clips it.
+  "set -g set-clipboard on",
+  "set -ga terminal-features ,*:clipboard",
+  "bind -T copy-mode MouseDragEnd1Pane send -X copy-selection-and-cancel",
+  "bind -T copy-mode-vi MouseDragEnd1Pane send -X copy-selection-and-cancel",
+  // A pane whose process exits stays as a dead pane instead of taking the
+  // session — and the tab — with it. `respawnTmuxPane` brings it back. Without
+  // this a stray `exit` or Ctrl-D destroys the tab the user was working in.
+  "set -g remain-on-exit on",
+  ""
+].join("\n");
+var DEFAULT_SIZE = { cols: 80, rows: 24 };
+var SOCKET = "factiii";
+function safeTmuxName(raw) {
+  return raw.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
+}
+function tmuxConfPath(target) {
+  return `${target.paths.root}/tmux.conf`;
+}
+function tmuxCli(target) {
+  return `tmux -L ${SOCKET} -f ${tmuxConfPath(target)}`;
+}
+function shellQuote(argv) {
+  return argv.map((arg) => `'${arg.replace(/'/g, `'\\''`)}'`).join(" ");
+}
+function ptyArgv(argv, size) {
+  const sized = [
+    "sh",
+    "-c",
+    `stty rows ${size.rows} cols ${size.cols} 2>/dev/null; exec ${shellQuote(argv)}`
+  ];
+  const script = process.platform === "darwin" ? ["script", "-q", "/dev/null", ...sized] : ["script", "-qec", shellQuote(sized), "/dev/null"];
+  return ["bash", "-c", 'exec "$@" < <(cat)', "bash", ...script];
+}
+async function respawnTmuxPane(opts) {
+  const { target, session, argv } = opts;
+  const cmd = ["respawn-pane", "-k"];
+  if (opts.cwd) cmd.push("-c", opts.cwd);
+  for (const [k, v] of Object.entries(opts.env ?? {})) {
+    cmd.push("-e", `${k}=${v}`);
+  }
+  cmd.push("-t", session, "--", ...argv);
+  await target.sh(`${tmuxCli(target)} ${shellQuote(cmd)}`);
+}
+async function tmuxSessionExists(target, session) {
+  return await target.sh(
+    `${tmuxCli(target)} has-session -t ${shellQuote([session])} 2>/dev/null`
+  ).then(() => true).catch(() => false);
+}
+async function setTmuxSessionOption(target, session, name, value2) {
+  await target.sh(
+    `${tmuxCli(target)} set-option -t ${shellQuote([session])} ${shellQuote([name, value2])}`
+  ).catch(() => {
+  });
+}
+async function sourceTmuxConf(target) {
+  const conf = tmuxConfPath(target);
+  await target.writeFile(conf, TMUX_CONF);
+  await target.sh(`${tmuxCli(target)} source-file ${shellQuote([conf])}`).catch(() => {
+  });
+}
+function resurrectSource() {
+  const rel = ["vendor", "tmux-resurrect"];
+  const candidates2 = [
+    import_path3.default.join(__dirname, "..", ...rel),
+    import_path3.default.join(__dirname, "..", "..", "..", "..", "apps", "runner", ...rel),
+    import_path3.default.join(process.cwd(), "apps", "runner", ...rel)
+  ];
+  return candidates2.find(
+    (dir) => (0, import_fs.existsSync)(import_path3.default.join(dir, "scripts", "save.sh"))
+  ) ?? null;
+}
+function hostRoot(target) {
+  return import_path3.default.dirname(target.paths.root);
+}
+function resurrectRoot(target) {
+  return `${hostRoot(target)}/tmux-plugins/tmux-resurrect`;
+}
+function resurrectStateDir(target) {
+  return `${hostRoot(target)}/tmux-resurrect-state`;
+}
+async function ensureTmuxResurrect(target) {
+  const source = resurrectSource();
+  if (!source) return;
+  const root = resurrectRoot(target);
+  try {
+    const want = await (0, import_promises.readFile)(import_path3.default.join(source, "VERSION"), "utf-8").then((v) => v.trim()).catch(() => "");
+    const have = await target.sh(`cat ${shellQuote([`${root}/VERSION`])} 2>/dev/null || true`).catch(() => "");
+    if (want && have.trim() === want) return;
+    const files = (await resurrectFiles(source)).filter((f) => f !== "VERSION");
+    for (const rel of files) {
+      await target.writeFile(
+        `${root}/${rel}`,
+        await (0, import_promises.readFile)(import_path3.default.join(source, rel), "utf-8")
+      );
+    }
+    await target.sh(
+      `chmod +x ${shellQuote([`${root}/scripts`])}/*.sh ${shellQuote([`${root}/save_command_strategies`])}/*.sh`
+    );
+    await target.writeFile(`${root}/VERSION`, want);
+  } catch {
+  }
+}
+async function resurrectFiles(source) {
+  const out = [];
+  const walk = async (rel) => {
+    const entries = await (0, import_promises.readdir)(import_path3.default.join(source, rel), {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const next = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) await walk(next);
+      else out.push(next);
+    }
+  };
+  await walk("");
+  return out;
+}
+async function setResurrectOptions(target) {
+  const opts = [
+    ["@resurrect-processes", "false"],
+    ["@resurrect-capture-pane-contents", "on"],
+    ["@resurrect-dir", resurrectStateDir(target)]
+  ];
+  for (const [name, value2] of opts) {
+    await target.sh(`${tmuxCli(target)} set-option -g ${shellQuote([name, value2])}`).catch(() => {
+    });
+  }
+}
+async function tmuxServerRunning(target) {
+  return await target.sh(`${tmuxCli(target)} list-sessions -F '#{session_name}' 2>/dev/null`).then(() => true).catch(() => false);
+}
+async function resurrectSave(target) {
+  if (!await tmuxServerRunning(target)) return;
+  await setResurrectOptions(target);
+  await target.sh(
+    `${tmuxCli(target)} run-shell ${shellQuote([`${resurrectRoot(target)}/scripts/save.sh`])}`
+  ).catch(() => {
+  });
+}
+async function resurrectRestore(target) {
+  const scripts = resurrectRoot(target);
+  const hasSave = await target.sh(`test -f ${shellQuote([`${resurrectStateDir(target)}/last`])}`).then(() => true).catch(() => false);
+  if (!hasSave) return [];
+  const placeholder = "factiii-restore";
+  try {
+    await target.sh(
+      `${tmuxCli(target)} new-session -d -s ${placeholder} 'sleep 60' 2>/dev/null || true`
+    );
+    await setResurrectOptions(target);
+    await target.sh(
+      `${tmuxCli(target)} run-shell ${shellQuote([`${scripts}/scripts/restore.sh`])}`
+    );
+    const stdout = await target.sh(
+      `${tmuxCli(target)} list-sessions -F '#{session_name}' 2>/dev/null || true`
+    );
+    return stdout.split("\n").map((line) => line.trim()).filter((name) => name.startsWith("terminal-"));
+  } catch {
+    return [];
+  } finally {
+    await target.sh(
+      `${tmuxCli(target)} kill-session -t ${placeholder} 2>/dev/null || true`
+    ).catch(() => {
+    });
+  }
+}
+async function tmuxPanePaths(target) {
+  const stdout = await target.sh(
+    `${tmuxCli(target)} list-panes -a -F '#{session_name}|#{pane_current_path}' 2>/dev/null || true`
+  ).catch(() => "");
+  const byName = /* @__PURE__ */ new Map();
+  for (const raw of stdout.split("\n")) {
+    const [name, dir] = raw.trim().split("|");
+    if (name && dir && !byName.has(name)) byName.set(name, dir);
+  }
+  return byName;
+}
+async function terminalSessionNames(target, postId) {
+  const prefix = `terminal-${safeTmuxName(postId)}-`;
+  const stdout = await target.sh(
+    `${tmuxCli(target)} list-sessions -F '#{session_name}' 2>/dev/null || true`
+  ).catch(() => "");
+  return stdout.split("\n").map((line) => line.trim()).filter((name) => name.startsWith(prefix));
+}
+async function killTerminalSessions(target, postId) {
+  const names = await terminalSessionNames(target, postId);
+  if (names.length === 0) return;
+  const cli = tmuxCli(target);
+  const script = names.map(
+    (name) => (
+      // -P walks children; the pane pid itself dies with the session below.
+      `for p in $(${cli} list-panes -t ${name} -F '#{pane_pid}' 2>/dev/null); do pkill -TERM -P "$p" 2>/dev/null || true; done; ${cli} kill-session -t ${name} 2>/dev/null || true`
+    )
+  ).join("; ");
+  await target.sh(script).catch(() => {
+  });
+}
+async function startTmuxSession(opts) {
+  const { target, session } = opts;
+  const conf = tmuxConfPath(target);
+  await target.writeFile(conf, TMUX_CONF);
+  let size = opts.size ?? DEFAULT_SIZE;
+  const dataCbs = [];
+  const closeCbs = [];
+  const errorCbs = [];
+  let proc;
+  const attach = async () => {
+    const argv = ["tmux", "-L", SOCKET, "-u", "-f", conf, "new-session"];
+    if (opts.attachExisting) argv.push("-A");
+    argv.push("-s", session, "-x", String(size.cols), "-y", String(size.rows));
+    for (const [k, v] of Object.entries(opts.env ?? {})) {
+      argv.push("-e", `${k}=${v}`);
+    }
+    argv.push("--", ...opts.argv);
+    const mine = await target.spawn(ptyArgv(argv, size), {
+      env: { TERM: "xterm-256color" }
+    });
+    proc = mine;
+    mine.stdin?.on("error", () => {
+    });
+    const live = () => proc === mine;
+    const emit = (chunk) => {
+      if (live()) for (const cb of dataCbs) cb(chunk);
+    };
+    mine.stdout?.on("data", emit);
+    mine.stderr?.on("data", emit);
+    mine.on("error", (err) => {
+      if (live()) for (const cb of errorCbs) cb(err);
+    });
+    mine.on("close", (code) => {
+      if (live()) for (const cb of closeCbs) cb(code ?? null);
+    });
+  };
+  await attach();
+  return {
+    session,
+    onData: (cb) => dataCbs.push(cb),
+    onClose: (cb) => closeCbs.push(cb),
+    onError: (cb) => errorCbs.push(cb),
+    write: (data) => proc.stdin?.write(data),
+    resize: async (cols, rows) => {
+      if (cols === size.cols && rows === size.rows) return;
+      size = { cols, rows };
+      const old = proc;
+      await attach();
+      killTree(old);
+    },
+    detach: () => killTree(proc)
+  };
+}
+
+// ../../shared/all/helpers/card-ai/card-session.ts
+function isWorktreeSession(s, target) {
+  return isWorktreePath(target, s.workspacePath);
+}
+function sessionToRecord(s, prompt2 = "") {
+  return {
+    postId: s.postId,
+    taskId: s.taskId,
+    mode: s.mode,
+    phase: s.phase,
+    provider: s.provider,
+    worktreePath: s.workspacePath,
+    agentSessionId: s.agentSessionId,
+    taskTitle: s.taskTitle,
+    targetBranch: s.targetBranch,
+    startedAt: s.startedAt,
+    prompt: prompt2,
+    pendingQuestion: s.pendingQuestion
+  };
+}
+async function putSessionCard(s, target, prompt2 = "") {
+  try {
+    await putCard(target, sessionToRecord(s, prompt2));
+  } catch {
+  }
+}
+async function teardownSession(s, target) {
+  await killTerminalSessions(target, s.postId).catch(() => {
+  });
+  if (isWorktreeSession(s, target)) {
+    const drop = s.mode === "bare" ? removeWorktreeAndBranch : removeWorktree;
+    await drop(target, s.workspacePath).catch(() => {
+    });
+  }
+  await deleteCard(target, s.postId).catch(() => {
+  });
+}
+
 // ../../shared/all/helpers/board-agent-core/exec.ts
+var import_child_process2 = require("child_process");
+var import_crypto = require("crypto");
+var import_fs2 = require("fs");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_net = __toESM(require("net"));
+var import_path4 = __toESM(require("path"));
+var import_util4 = require("util");
 var execFileAsync = (0, import_util4.promisify)(import_child_process2.execFile);
 var MAX_BUFFER = 10 * 1024 * 1024;
 var PORTS_FILE = ".ports";
 var NUM_PORTS = 6;
 function portsFilePath(spaceDir) {
-  return import_path3.default.join(spaceDir, PORTS_FILE);
+  return import_path4.default.join(spaceDir, PORTS_FILE);
 }
 async function allocateSpacePorts(spaceDir) {
   const existing = readSpacePorts(spaceDir);
@@ -13573,19 +13842,35 @@ async function allocateSpacePorts(spaceDir) {
     seen.add(port);
     ports.push(port);
   }
-  await import_promises.default.mkdir(spaceDir, { recursive: true });
-  await import_promises.default.writeFile(portsFilePath(spaceDir), ports.join(","), "utf-8");
+  await import_promises2.default.mkdir(spaceDir, { recursive: true });
+  await import_promises2.default.writeFile(portsFilePath(spaceDir), ports.join(","), "utf-8");
   return ports;
 }
+var SECRET_FILE = ".secret";
+function spaceSecret(spaceDir) {
+  const file = import_path4.default.join(spaceDir, SECRET_FILE);
+  try {
+    const existing = (0, import_fs2.readFileSync)(file, "utf-8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const secret = (0, import_crypto.randomBytes)(24).toString("hex");
+  try {
+    (0, import_fs2.mkdirSync)(spaceDir, { recursive: true });
+    (0, import_fs2.writeFileSync)(file, secret, { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+  return secret;
+}
 function readSpacePorts(spaceDir) {
   try {
-    return (0, import_fs.readFileSync)(portsFilePath(spaceDir), "utf-8").split(",").map((p) => Number(p.trim())).filter((p) => Number.isInteger(p) && p > 0);
+    return (0, import_fs2.readFileSync)(portsFilePath(spaceDir), "utf-8").split(",").map((p) => Number(p.trim())).filter((p) => Number.isInteger(p) && p > 0);
   } catch {
     return [];
   }
 }
 function usableCwd(dir) {
-  return dir && (0, import_fs.existsSync)(dir) ? dir : void 0;
+  return dir && (0, import_fs2.existsSync)(dir) ? dir : void 0;
 }
 function hostTarget(spaceDir, extraEnv) {
   const paths = hostSpacePaths(spaceDir);
@@ -13651,8 +13936,8 @@ function hostTarget(spaceDir, extraEnv) {
       });
     },
     async writeFile(filePath, content) {
-      await import_promises.default.mkdir(import_path3.default.dirname(filePath), { recursive: true });
-      await import_promises.default.writeFile(filePath, content, "utf-8");
+      await import_promises2.default.mkdir(import_path4.default.dirname(filePath), { recursive: true });
+      await import_promises2.default.writeFile(filePath, content, "utf-8");
     },
     async step(cmd, opts) {
       const res = await execLogin(cmd, {
@@ -13867,14 +14152,14 @@ function createEventSink(send, spaceSlug, notify) {
 }
 
 // ../../shared/all/helpers/card-ai/frpc.ts
-var import_fs2 = require("fs");
-var import_promises5 = __toESM(require("fs/promises"));
-var import_path7 = __toESM(require("path"));
+var import_fs3 = require("fs");
+var import_promises6 = __toESM(require("fs/promises"));
+var import_path8 = __toESM(require("path"));
 
 // ../../shared/all/helpers/board-agent-core/host-skills.ts
-var import_promises4 = __toESM(require("fs/promises"));
+var import_promises5 = __toESM(require("fs/promises"));
 var import_os2 = __toESM(require("os"));
-var import_path6 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 
 // ../../shared/all/domains/posts.ts
 var postDataSort = /* @__PURE__ */ ((postDataSort2) => {
@@ -14384,17 +14669,17 @@ var skillScopeSchema = external_exports.enum(["global", "repo"]);
 
 // ../../shared/all/helpers/board-agent-core/host-deploy.ts
 var import_child_process3 = require("child_process");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_path5 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_path6 = __toESM(require("path"));
 var import_util5 = require("util");
 
 // ../../shared/all/helpers/board-agent-core/secrets-bridge.ts
-var import_promises2 = __toESM(require("fs/promises"));
+var import_promises3 = __toESM(require("fs/promises"));
 var import_net2 = __toESM(require("net"));
-var import_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 var SECRET_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function secretsSocketPath(spaceDir) {
-  return import_path4.default.join(hostSpacePaths(spaceDir).state, "secrets.sock");
+  return import_path5.default.join(hostSpacePaths(spaceDir).state, "secrets.sock");
 }
 function redactor(values) {
   const significant = values.filter((v) => v.length >= 4);
@@ -14448,8 +14733,8 @@ async function handleRun(request, handlers, reply) {
 }
 async function startSecretsBridge(opts) {
   const socketPath = secretsSocketPath(opts.spaceDir);
-  await import_promises2.default.mkdir(import_path4.default.dirname(socketPath), { recursive: true });
-  await import_promises2.default.rm(socketPath, { force: true });
+  await import_promises3.default.mkdir(import_path5.default.dirname(socketPath), { recursive: true });
+  await import_promises3.default.rm(socketPath, { force: true });
   const { handlers } = opts;
   let queue = Promise.resolve();
   let queueDepth = 0;
@@ -14514,13 +14799,13 @@ async function startSecretsBridge(opts) {
       resolve2();
     });
   });
-  await import_promises2.default.chmod(socketPath, 384).catch(() => void 0);
+  await import_promises3.default.chmod(socketPath, 384).catch(() => void 0);
   return {
     close: async () => {
       for (const conn of live) conn.destroy();
       live.clear();
       await new Promise((resolve2) => server.close(() => resolve2()));
-      await import_promises2.default.rm(socketPath, { force: true });
+      await import_promises3.default.rm(socketPath, { force: true });
     }
   };
 }
@@ -14537,14 +14822,14 @@ var CHECKER_PATH = `${SKILL_DIR}/check-environment.sh`;
 var CLAUDE_SKILLS_DIR = ".claude/skills";
 var CLAUDE_LINK = `${CLAUDE_SKILLS_DIR}/deploy`;
 async function ensureClaudeSkillLink(workspace) {
-  const linkPath = import_path5.default.join(workspace, CLAUDE_LINK);
+  const linkPath = import_path6.default.join(workspace, CLAUDE_LINK);
   try {
-    await import_promises3.default.lstat(linkPath);
+    await import_promises4.default.lstat(linkPath);
     return;
   } catch {
   }
-  await import_promises3.default.mkdir(import_path5.default.join(workspace, CLAUDE_SKILLS_DIR), { recursive: true });
-  await import_promises3.default.symlink("../../.agents/skills/deploy", linkPath, "dir");
+  await import_promises4.default.mkdir(import_path6.default.join(workspace, CLAUDE_SKILLS_DIR), { recursive: true });
+  await import_promises4.default.symlink("../../.agents/skills/deploy", linkPath, "dir");
 }
 var GIT_NO_HELPER = ["-c", "credential.helper="];
 var GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
@@ -14589,7 +14874,7 @@ async function gitCatFileBatch(cwd, shas) {
   return out;
 }
 async function ensureWorkspaceClone(opts) {
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   const branch = (opts.mainBranch || "main").replace(/[^\w./-]/g, "");
   const url2 = buildCloneUrl(opts.repoUrl, opts.githubToken);
   let cloned = false;
@@ -14597,14 +14882,14 @@ async function ensureWorkspaceClone(opts) {
     await hostGit(workspace, "rev-parse", "--git-dir");
     await hostGit(workspace, "remote", "set-url", "origin", url2);
   } catch {
-    const leftovers = await import_promises3.default.readdir(workspace).catch(() => []);
+    const leftovers = await import_promises4.default.readdir(workspace).catch(() => []);
     if (leftovers.includes(".git")) {
       throw new Error(
         `${workspace} holds a git repository that cannot be read. Remove it and retry.`
       );
     }
     for (const name of leftovers) {
-      await import_promises3.default.rm(import_path5.default.join(workspace, name), { recursive: true, force: true });
+      await import_promises4.default.rm(import_path6.default.join(workspace, name), { recursive: true, force: true });
     }
     await execFileAsync2(
       "git",
@@ -14756,15 +15041,15 @@ function spaceEnv(spaceDir) {
   };
 }
 async function readContract(workspace) {
-  const skill = await import_promises3.default.readFile(import_path5.default.join(workspace, SKILL_PATH), "utf-8").catch(() => {
+  const skill = await import_promises4.default.readFile(import_path6.default.join(workspace, SKILL_PATH), "utf-8").catch(() => {
     throw new Error("The creator wrote no SKILL.md.");
   });
-  const checker = await import_promises3.default.readFile(import_path5.default.join(workspace, CHECKER_PATH), "utf-8").catch(() => {
+  const checker = await import_promises4.default.readFile(import_path6.default.join(workspace, CHECKER_PATH), "utf-8").catch(() => {
     throw new Error("The creator wrote no check-environment.sh.");
   });
   try {
     const raw = JSON.parse(
-      await import_promises3.default.readFile(import_path5.default.join(workspace, VARIABLES_PATH), "utf-8")
+      await import_promises4.default.readFile(import_path6.default.join(workspace, VARIABLES_PATH), "utf-8")
     );
     return {
       skill,
@@ -14781,7 +15066,7 @@ async function generateDeploySkill(opts) {
     throw new Error("Describe your deployment process first.");
   }
   const status = await checkDeployStatus(opts);
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   sendLog({
     type: "system",
     content: `Resetting workspace to origin/${status.branch}...`
@@ -14824,7 +15109,7 @@ async function generateDeploySkill(opts) {
 async function reviseDeploySkill(opts) {
   const { feedback, sendLog } = opts;
   if (!feedback.trim()) throw new Error("Corrections are empty.");
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   sendLog({ type: "system", content: "Applying your corrections..." });
   const { result } = await spawnAgent(
     opts.provider,
@@ -14852,7 +15137,7 @@ async function loadSkillDraft(opts) {
     throw new Error("Not a deploy-skill branch.");
   }
   await checkDeployStatus(opts);
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   await hostGit(
     workspace,
     "fetch",
@@ -14864,7 +15149,7 @@ async function loadSkillDraft(opts) {
   return readContract(workspace);
 }
 async function approveDeploySkill(opts) {
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   await readContract(workspace);
   await ensureClaudeSkillLink(workspace);
   if (opts.gitName)
@@ -14907,19 +15192,19 @@ async function runEnvironmentCheck(opts) {
       "No environment checker on the default branch. Generate the deploy skill first."
     );
   }
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   const script = await hostGit(
     workspace,
     "cat-file",
     "-p",
     `origin/${status.branch}:${CHECKER_PATH}`
   );
-  const tmp = import_path5.default.join(opts.spaceDir, `.env-check.${process.pid}.sh`);
-  await import_promises3.default.writeFile(tmp, script, { mode: 448 });
+  const tmp = import_path6.default.join(opts.spaceDir, `.env-check.${process.pid}.sh`);
+  await import_promises4.default.writeFile(tmp, script, { mode: 448 });
   let ok = true;
   let output = "";
   try {
-    const scriptArg = tmp.split(import_path5.default.sep).join("/");
+    const scriptArg = tmp.split(import_path6.default.sep).join("/");
     const res = await execLogin(`bash ${JSON.stringify(scriptArg)}`, {
       cwd: workspace,
       env: { ...process.env, ...spaceEnv(opts.spaceDir) },
@@ -14928,7 +15213,7 @@ async function runEnvironmentCheck(opts) {
     output = res.output;
     if (res.code !== 0) ok = false;
   } finally {
-    await import_promises3.default.rm(tmp, { force: true });
+    await import_promises4.default.rm(tmp, { force: true });
   }
   const checks = [];
   for (const line of output.split("\n")) {
@@ -14950,7 +15235,7 @@ async function fixEnvironment(opts) {
   const before = await runEnvironmentCheck(opts);
   if (before.ok) return before;
   const status = await checkDeployStatus(opts);
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   const script = await hostGit(
     workspace,
     "cat-file",
@@ -14985,7 +15270,7 @@ async function fixEnvironment(opts) {
   return runEnvironmentCheck(opts);
 }
 async function discardDeploySkill(opts) {
-  const workspace = import_path5.default.join(opts.spaceDir, "workspace");
+  const workspace = import_path6.default.join(opts.spaceDir, "workspace");
   await hostGit(workspace, "checkout", "--", ".").catch(() => null);
   await hostGit(workspace, "clean", "-fd");
   return { success: true };
@@ -15104,21 +15389,22 @@ var AGENTS_ROOT = ".agents/skills";
 var CLAUDE_ROOT = ".claude/skills";
 var CLI_ROOTS = [CLAUDE_ROOT, ".codex/skills"];
 function globalAgentsRoot() {
-  return import_path6.default.join(import_os2.default.homedir(), ".agents", "skills");
+  return import_path7.default.join(import_os2.default.homedir(), ".agents", "skills");
 }
 var AGENTS_LINK_TARGET = "../.agents/skills";
 var BRANCH_PREFIX = "skill/";
+var MIGRATE_BRANCH = `${BRANCH_PREFIX}migrate`;
 var SYMLINK_MODE = "120000";
 function summarize(raw, base) {
   const { frontmatter, errors } = parseSkill(raw);
   return { ...base, description: frontmatter.description, errors };
 }
 async function rootLinkState(root) {
-  const linkPath = import_path6.default.join(import_os2.default.homedir(), ...root.split("/"));
-  const stat = await import_promises4.default.lstat(linkPath).catch(() => null);
+  const linkPath = import_path7.default.join(import_os2.default.homedir(), ...root.split("/"));
+  const stat = await import_promises5.default.lstat(linkPath).catch(() => null);
   if (!stat) return "missing";
   if (!stat.isSymbolicLink()) return "blocked";
-  const target = await import_promises4.default.readlink(linkPath).catch(() => "");
+  const target = await import_promises5.default.readlink(linkPath).catch(() => "");
   return target.replace(/\/+$/, "") === AGENTS_LINK_TARGET ? "linked" : "missing";
 }
 async function globalLinkState() {
@@ -15128,12 +15414,12 @@ async function globalLinkState() {
 }
 async function listGlobal() {
   const root = globalAgentsRoot();
-  const entries = await import_promises4.default.readdir(root, { withFileTypes: true }).catch(() => []);
+  const entries = await import_promises5.default.readdir(root, { withFileTypes: true }).catch(() => []);
   const out = [];
   for (const entry of entries) {
     if (entry.isFile()) continue;
-    const dir = import_path6.default.join(root, entry.name);
-    const raw = await import_promises4.default.readFile(import_path6.default.join(dir, "SKILL.md"), "utf-8").catch(() => "");
+    const dir = import_path7.default.join(root, entry.name);
+    const raw = await import_promises5.default.readFile(import_path7.default.join(dir, "SKILL.md"), "utf-8").catch(() => "");
     if (!raw) continue;
     out.push(
       summarize(raw, {
@@ -15302,7 +15588,7 @@ async function ensureSkillsWorktree(spaceDir, branch) {
   } catch {
     await hostGit(repo, "worktree", "prune").catch(() => {
     });
-    await import_promises4.default.rm(worktree, { recursive: true, force: true });
+    await import_promises5.default.rm(worktree, { recursive: true, force: true });
     await hostGit(
       repo,
       "worktree",
@@ -15367,29 +15653,34 @@ async function listSkillsImpl(opts) {
       globalLink,
       repoLink: "linked",
       repoBranch: "",
-      repoAvailable: false
+      repoAvailable: false,
+      repoMigrationBranch: "",
+      repoMigrationMissing: []
     };
   }
   const ctx = await repoContext(opts);
   const repo = await repoSkills(ctx);
+  const migration = openMigration(ctx.liveBlobs, ctx.pending);
   return {
     global: global2,
     repo,
     globalLink,
     repoLink: repoLinkState(ctx),
     repoBranch: ctx.branch,
-    repoAvailable: true
+    repoAvailable: true,
+    repoMigrationBranch: migration.branch,
+    repoMigrationMissing: migration.missing
   };
 }
 async function bundleFilesOnDisk(dir) {
   const out = [];
   const walk = async (current, prefix, depth) => {
     if (depth > 3 || out.length >= 200) return;
-    const entries = await import_promises4.default.readdir(current, { withFileTypes: true }).catch(() => []);
+    const entries = await import_promises5.default.readdir(current, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
-        await walk(import_path6.default.join(current, entry.name), rel, depth + 1);
+        await walk(import_path7.default.join(current, entry.name), rel, depth + 1);
       } else if (rel !== "SKILL.md") {
         out.push(rel);
       }
@@ -15401,7 +15692,7 @@ async function bundleFilesOnDisk(dir) {
 async function readSkillImpl(opts) {
   if (opts.scope === "global") {
     const dir = resolveSkillDir(globalAgentsRoot(), opts.name);
-    const content2 = await import_promises4.default.readFile(import_path6.default.join(dir, "SKILL.md"), "utf-8");
+    const content2 = await import_promises5.default.readFile(import_path7.default.join(dir, "SKILL.md"), "utf-8");
     const { frontmatter: frontmatter2, errors: errors2 } = parseSkill(content2);
     return {
       name: opts.name,
@@ -15436,71 +15727,102 @@ async function readSkillImpl(opts) {
   };
 }
 async function moveIntoAgents(from, to) {
-  if (await import_promises4.default.access(to).then(
+  if (await import_promises5.default.access(to).then(
     () => true,
     () => false
   )) {
     throw new Error(
-      `${import_path6.default.basename(to)} exists in both roots. Remove one copy, then migrate.`
+      `${import_path7.default.basename(to)} exists in both roots. Remove one copy, then migrate.`
     );
   }
-  await import_promises4.default.mkdir(import_path6.default.dirname(to), { recursive: true });
+  await import_promises5.default.mkdir(import_path7.default.dirname(to), { recursive: true });
   try {
-    await import_promises4.default.rename(from, to);
+    await import_promises5.default.rename(from, to);
   } catch {
-    await import_promises4.default.cp(from, to, { recursive: true });
-    await import_promises4.default.rm(from, { recursive: true, force: true });
+    await import_promises5.default.cp(from, to, { recursive: true });
+    await import_promises5.default.rm(from, { recursive: true, force: true });
   }
 }
 async function migrateGlobal() {
   const moved = [];
   for (const root of CLI_ROOTS) {
-    const dir = import_path6.default.join(import_os2.default.homedir(), ...root.split("/"));
-    const stat = await import_promises4.default.lstat(dir).catch(() => null);
+    const dir = import_path7.default.join(import_os2.default.homedir(), ...root.split("/"));
+    const stat = await import_promises5.default.lstat(dir).catch(() => null);
     if (!stat || stat.isSymbolicLink()) continue;
-    const entries = await import_promises4.default.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await import_promises5.default.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isFile() || entry.isSymbolicLink()) continue;
-      const src = import_path6.default.join(dir, entry.name);
-      if (!await import_promises4.default.access(import_path6.default.join(src, "SKILL.md")).then(
+      const src = import_path7.default.join(dir, entry.name);
+      if (!await import_promises5.default.access(import_path7.default.join(src, "SKILL.md")).then(
         () => true,
         () => false
       )) {
         continue;
       }
-      await moveIntoAgents(src, import_path6.default.join(globalAgentsRoot(), entry.name));
+      await moveIntoAgents(src, import_path7.default.join(globalAgentsRoot(), entry.name));
       moved.push(entry.name);
     }
-    await import_promises4.default.rmdir(dir).catch(() => {
+    await import_promises5.default.rmdir(dir).catch(() => {
     });
   }
   for (const root of CLI_ROOTS) {
-    const linkPath = import_path6.default.join(import_os2.default.homedir(), ...root.split("/"));
-    const after = await import_promises4.default.lstat(linkPath).catch(() => null);
-    if (after?.isSymbolicLink()) await import_promises4.default.rm(linkPath, { force: true });
+    const linkPath = import_path7.default.join(import_os2.default.homedir(), ...root.split("/"));
+    const after = await import_promises5.default.lstat(linkPath).catch(() => null);
+    if (after?.isSymbolicLink()) await import_promises5.default.rm(linkPath, { force: true });
     else if (after) {
       throw new Error(
         `~/${root} still has files that are not skills. Empty it, then migrate.`
       );
     }
-    await import_promises4.default.mkdir(import_path6.default.dirname(linkPath), { recursive: true });
-    await import_promises4.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir");
+    await import_promises5.default.mkdir(import_path7.default.dirname(linkPath), { recursive: true });
+    await import_promises5.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir");
   }
   return moved;
 }
+var MIGRATE_SUBJECT = /^Migrate \d+ skill\(s\) to /;
+function migrationCommitsOnly(log) {
+  return log.split("\n").map((line) => line.trim()).filter(Boolean).every((subject) => MIGRATE_SUBJECT.test(subject));
+}
+function openMigration(liveBlobs, pending) {
+  const onBranch = pending.find(
+    (entry) => entry.branch === MIGRATE_BRANCH
+  )?.blobs;
+  if (!onBranch) return { branch: "", missing: [] };
+  const missing = /* @__PURE__ */ new Set();
+  for (const stray of strayRepoSkills(liveBlobs)) {
+    const name = stray.slice(stray.lastIndexOf("/") + 1);
+    if (!onBranch.has(`${AGENTS_ROOT}/${name}`)) missing.add(name);
+  }
+  return { branch: MIGRATE_BRANCH, missing: [...missing].sort() };
+}
 async function migrateSkillsImpl(opts) {
   if (opts.scope === "global") {
-    return { branch: "", moved: await migrateGlobal() };
+    return { branch: "", moved: await migrateGlobal(), pushed: false };
   }
   const ctx = await repoContext(opts);
   const strays = strayRepoSkills(ctx.liveBlobs);
   const linked = ctx.links.get(CLAUDE_ROOT);
   if (!strays.length && linked === AGENTS_LINK_TARGET) {
-    return { branch: "", moved: [] };
+    return { branch: "", moved: [], pushed: false };
   }
   const { branch } = ctx;
   const workspace = await ensureSkillsWorktree(opts.spaceDir, branch);
-  const target = `${BRANCH_PREFIX}migrate`;
+  const target = MIGRATE_BRANCH;
+  const existing = await hostGit(
+    workspace,
+    "ls-remote",
+    "--heads",
+    "origin",
+    target
+  ).catch(() => "");
+  if (existing.trim()) {
+    await hostGit(
+      workspace,
+      "fetch",
+      "origin",
+      `+refs/heads/${target}:refs/remotes/origin/${target}`
+    );
+  }
   await hostGit(workspace, "checkout", "-B", target, `origin/${branch}`);
   await hostGit(workspace, "clean", "-fd");
   if (opts.gitName) {
@@ -15518,24 +15840,46 @@ async function migrateSkillsImpl(opts) {
         `${name} exists in both ${AGENTS_ROOT} and ${stray}. Remove one copy, then migrate.`
       );
     }
-    await import_promises4.default.mkdir(import_path6.default.join(workspace, AGENTS_ROOT), { recursive: true });
+    await import_promises5.default.mkdir(import_path7.default.join(workspace, AGENTS_ROOT), { recursive: true });
     await hostGit(workspace, "mv", stray, dest);
     moved.push(name);
   }
-  const linkPath = import_path6.default.join(workspace, CLAUDE_ROOT);
-  await import_promises4.default.rm(linkPath, { recursive: true, force: true });
-  await import_promises4.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir");
+  const linkPath = import_path7.default.join(workspace, CLAUDE_ROOT);
+  await import_promises5.default.rm(linkPath, { recursive: true, force: true });
+  await import_promises5.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir");
   await hostGit(workspace, "add", "-A");
   const dirty = await hostGit(workspace, "status", "--porcelain");
-  if (!dirty.trim()) return { branch: "", moved: [] };
+  if (!dirty.trim()) return { branch: "", moved: [], pushed: false };
   await hostGit(
     workspace,
     "commit",
     "-m",
     `Migrate ${moved.length} skill(s) to ${AGENTS_ROOT} and link ${CLAUDE_ROOT}`
   );
-  await hostGit(workspace, "push", "origin", target);
-  return { branch: target, moved };
+  if (!existing.trim()) {
+    await hostGit(workspace, "push", "origin", target);
+    return { branch: target, moved, pushed: true };
+  }
+  const [rebuilt, onBranch] = await Promise.all([
+    hostGit(workspace, "rev-parse", "HEAD^{tree}"),
+    hostGit(workspace, "rev-parse", `origin/${target}^{tree}`)
+  ]);
+  if (rebuilt.trim() === onBranch.trim()) {
+    return { branch: target, moved, pushed: false };
+  }
+  const log = await hostGit(
+    workspace,
+    "log",
+    "--format=%s",
+    `origin/${branch}..origin/${target}`
+  );
+  if (!migrationCommitsOnly(log)) {
+    throw new Error(
+      `${target} carries commits that are not this migration. Merge or delete that branch, then migrate.`
+    );
+  }
+  await hostGit(workspace, "push", "--force-with-lease", "origin", target);
+  return { branch: target, moved, pushed: true };
 }
 function assertWritable(name, content) {
   const parsed = parseSkill(content);
@@ -15550,16 +15894,16 @@ function assertWritable(name, content) {
 }
 async function writeSkillFile(opts) {
   const dir = resolveSkillDir(opts.root, opts.name);
-  const file = import_path6.default.join(dir, "SKILL.md");
+  const file = import_path7.default.join(dir, "SKILL.md");
   if (opts.keepExisting) {
-    const exists = await import_promises4.default.access(file).then(
+    const exists = await import_promises5.default.access(file).then(
       () => true,
       () => false
     );
     if (exists) return;
   }
-  await import_promises4.default.mkdir(dir, { recursive: true });
-  await import_promises4.default.writeFile(file, opts.content, "utf-8");
+  await import_promises5.default.mkdir(dir, { recursive: true });
+  await import_promises5.default.writeFile(file, opts.content, "utf-8");
 }
 async function writeGlobalSkill(opts) {
   assertWritable(opts.name, opts.content);
@@ -15574,14 +15918,14 @@ async function installBundledSkill(opts) {
     content: opts.content,
     keepExisting: true
   });
-  await write(import_path6.default.join(home, ...AGENTS_ROOT.split("/")));
+  await write(import_path7.default.join(home, ...AGENTS_ROOT.split("/")));
   for (const root of CLI_ROOTS) {
-    const linkPath = import_path6.default.join(home, ...root.split("/"));
-    const stat = await import_promises4.default.lstat(linkPath).catch(() => null);
+    const linkPath = import_path7.default.join(home, ...root.split("/"));
+    const stat = await import_promises5.default.lstat(linkPath).catch(() => null);
     if (stat?.isSymbolicLink()) continue;
     if (!stat) {
-      await import_promises4.default.mkdir(import_path6.default.dirname(linkPath), { recursive: true });
-      await import_promises4.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir").catch(() => void 0);
+      await import_promises5.default.mkdir(import_path7.default.dirname(linkPath), { recursive: true });
+      await import_promises5.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir").catch(() => void 0);
       continue;
     }
     await write(linkPath);
@@ -15589,7 +15933,7 @@ async function installBundledSkill(opts) {
 }
 async function deleteGlobalSkill(opts) {
   const dir = resolveSkillDir(globalAgentsRoot(), opts.name);
-  await import_promises4.default.rm(dir, { recursive: true, force: true });
+  await import_promises5.default.rm(dir, { recursive: true, force: true });
 }
 async function proposeRepoSkillImpl(opts) {
   assertWritable(opts.name, opts.content);
@@ -15627,9 +15971,9 @@ async function proposeRepoSkillImpl(opts) {
   if (opts.gitEmail) {
     await hostGit(workspace, "config", "user.email", opts.gitEmail);
   }
-  await import_promises4.default.mkdir(import_path6.default.join(workspace, dir), { recursive: true });
-  await import_promises4.default.writeFile(
-    import_path6.default.join(workspace, dir, "SKILL.md"),
+  await import_promises5.default.mkdir(import_path7.default.join(workspace, dir), { recursive: true });
+  await import_promises5.default.writeFile(
+    import_path7.default.join(workspace, dir, "SKILL.md"),
     opts.content,
     "utf-8"
   );
@@ -15736,18 +16080,18 @@ function vendoredBinaryName() {
 async function installFrpcBinary(target) {
   const p = frpcPaths(target);
   const binaryName = vendoredBinaryName();
-  const src = import_path7.default.join(__dirname, "..", "vendor", binaryName);
-  if (!(0, import_fs2.existsSync)(src)) {
+  const src = import_path8.default.join(__dirname, "..", "vendor", binaryName);
+  if (!(0, import_fs3.existsSync)(src)) {
     throw new Error(
       `Vendored frpc missing (${src}). Run apps/runner/scripts/fetch-frpc.sh.`
     );
   }
-  const staged = await import_promises5.default.stat(p.binary).catch(() => null);
-  const source = await import_promises5.default.stat(src);
+  const staged = await import_promises6.default.stat(p.binary).catch(() => null);
+  const source = await import_promises6.default.stat(src);
   if (staged?.size === source.size) return;
-  await import_promises5.default.mkdir(p.binDir, { recursive: true });
-  await import_promises5.default.copyFile(src, p.binary);
-  await import_promises5.default.chmod(p.binary, 493);
+  await import_promises6.default.mkdir(p.binDir, { recursive: true });
+  await import_promises6.default.copyFile(src, p.binary);
+  await import_promises6.default.chmod(p.binary, 493);
 }
 var EXPOSE_SKILL_NAME = "share-a-port";
 var FENCE = "```";
@@ -16137,18 +16481,18 @@ var ClaudeModeEngine = class _ClaudeModeEngine {
     await this.core.ensureSpaceWorkspace();
     await assertAgentSignedIn(session.provider, this.core.target());
     if (hasGit) {
-      const { path: path21 } = await addWorktree(
+      const { path: path23 } = await addWorktree(
         this.core.target(),
         session.taskId,
         baseBranch || config.mainBranch || "main",
         "card"
       );
-      session.workspacePath = path21;
+      session.workspacePath = path23;
       await setGitIdentity(
         this.core.target(),
         config.gitName,
         config.gitEmail,
-        path21
+        path23
       );
       this.emitter.addLog(session, "system", "Worktree ready.");
     } else {
@@ -16370,18 +16714,18 @@ var ClaudeModeEngine = class _ClaudeModeEngine {
     this.emitter.addLog(session, "system", "Preparing environment...");
     await this.core.ensureSpaceWorkspace();
     await assertAgentSignedIn(session.provider, this.core.target());
-    const { path: path21 } = await addWorktree(
+    const { path: path23 } = await addWorktree(
       this.core.target(),
       session.taskId,
       config.mainBranch || "main",
       "card"
     );
-    session.workspacePath = path21;
+    session.workspacePath = path23;
     await setGitIdentity(
       this.core.target(),
       config.gitName,
       config.gitEmail,
-      path21
+      path23
     );
     await this.putCard(session);
     const patchDir = `${this.core.target().paths.root}/patches/${session.taskId}`;
@@ -16576,7 +16920,7 @@ ${buildPrompt(prompts_default.implement)}`;
 };
 
 // ../../shared/all/helpers/terminal-ai/terminal-mode.ts
-var import_crypto = require("crypto");
+var import_crypto4 = require("crypto");
 
 // ../../shared/all/helpers/board-agent-core/boardTerminal.ts
 function boardTerminalKey(spaceSlug) {
@@ -16587,95 +16931,6 @@ function isCardPostId(id) {
   return UUID_RE.test(id);
 }
 
-// ../../shared/all/helpers/board-agent-core/tmux.ts
-var TMUX_CONF = [
-  // Wheel scrolls, drag selects in copy mode.
-  "set -g mouse on",
-  "set -g history-limit 50000",
-  // These three are copy-on-select: tmux emits OSC 52, the client clips it.
-  "set -g set-clipboard on",
-  "set -ga terminal-features ,*:clipboard",
-  "bind -T copy-mode MouseDragEnd1Pane send -X copy-selection-and-cancel",
-  "bind -T copy-mode-vi MouseDragEnd1Pane send -X copy-selection-and-cancel",
-  ""
-].join("\n");
-var DEFAULT_SIZE = { cols: 80, rows: 24 };
-var SOCKET = "factiii";
-function safeTmuxName(raw) {
-  return raw.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
-}
-function tmuxConfPath(target) {
-  return `${target.paths.root}/tmux.conf`;
-}
-function tmuxCli(target) {
-  return `tmux -L ${SOCKET} -f ${tmuxConfPath(target)}`;
-}
-function shellQuote(argv) {
-  return argv.map((arg) => `'${arg.replace(/'/g, `'\\''`)}'`).join(" ");
-}
-function ptyArgv(argv, size) {
-  const sized = [
-    "sh",
-    "-c",
-    `stty rows ${size.rows} cols ${size.cols} 2>/dev/null; exec ${shellQuote(argv)}`
-  ];
-  const script = process.platform === "darwin" ? ["script", "-q", "/dev/null", ...sized] : ["script", "-qec", shellQuote(sized), "/dev/null"];
-  return ["bash", "-c", 'exec "$@" < <(cat)', "bash", ...script];
-}
-async function startTmuxSession(opts) {
-  const { target, session } = opts;
-  const conf = tmuxConfPath(target);
-  await target.writeFile(conf, TMUX_CONF);
-  let size = opts.size ?? DEFAULT_SIZE;
-  const dataCbs = [];
-  const closeCbs = [];
-  const errorCbs = [];
-  let proc;
-  const attach = async () => {
-    const argv = ["tmux", "-L", SOCKET, "-u", "-f", conf, "new-session"];
-    if (opts.attachExisting) argv.push("-A");
-    argv.push("-s", session, "-x", String(size.cols), "-y", String(size.rows));
-    for (const [k, v] of Object.entries(opts.env ?? {})) {
-      argv.push("-e", `${k}=${v}`);
-    }
-    argv.push("--", ...opts.argv);
-    const mine = await target.spawn(ptyArgv(argv, size), {
-      env: { TERM: "xterm-256color" }
-    });
-    proc = mine;
-    mine.stdin?.on("error", () => {
-    });
-    const live = () => proc === mine;
-    const emit = (chunk) => {
-      if (live()) for (const cb of dataCbs) cb(chunk);
-    };
-    mine.stdout?.on("data", emit);
-    mine.stderr?.on("data", emit);
-    mine.on("error", (err) => {
-      if (live()) for (const cb of errorCbs) cb(err);
-    });
-    mine.on("close", (code) => {
-      if (live()) for (const cb of closeCbs) cb(code ?? null);
-    });
-  };
-  await attach();
-  return {
-    session,
-    onData: (cb) => dataCbs.push(cb),
-    onClose: (cb) => closeCbs.push(cb),
-    onError: (cb) => errorCbs.push(cb),
-    write: (data) => proc.stdin?.write(data),
-    resize: async (cols, rows) => {
-      if (cols === size.cols && rows === size.rows) return;
-      size = { cols, rows };
-      const old = proc;
-      await attach();
-      killTree(old);
-    },
-    detach: () => killTree(proc)
-  };
-}
-
 // ../../shared/all/helpers/terminal-ai/agentState.ts
 var STATES = /* @__PURE__ */ new Set(["working", "idle", "blocked"]);
 var AGENT_STATE_CHANNEL = "agent-state";
@@ -16720,6 +16975,189 @@ function drainStateMessages(buffer) {
   return { states, rest: [...lines.slice(consumed), partial].join("\n") };
 }
 
+// ../../shared/all/helpers/terminal-ai/digest.ts
+var import_crypto3 = __toESM(require("crypto"));
+var import_promises8 = require("fs/promises");
+var import_path10 = __toESM(require("path"));
+
+// ../../shared/all/helpers/board-agent-core/plugin.ts
+var import_crypto2 = __toESM(require("crypto"));
+var import_fs4 = require("fs");
+var import_promises7 = require("fs/promises");
+var import_os3 = __toESM(require("os"));
+var import_path9 = __toESM(require("path"));
+var MARKETPLACE_NAME = "factiii-runner";
+var PLUGIN_ID = `factiii@${MARKETPLACE_NAME}`;
+var SECRETS_BIN = "factiii-secrets";
+function candidates() {
+  return [
+    import_path9.default.join(__dirname, "..", "plugin"),
+    import_path9.default.join(__dirname, "..", "..", "..", "..", "apps", "runner", "plugin"),
+    import_path9.default.join(process.cwd(), "apps", "runner", "plugin")
+  ];
+}
+function pluginRoot() {
+  for (const dir of candidates()) {
+    if ((0, import_fs4.existsSync)(import_path9.default.join(dir, ".claude-plugin", "marketplace.json"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+function renderedPluginRoot() {
+  return import_path9.default.join(import_os3.default.homedir(), ".factiii-runner", "plugin");
+}
+async function runnerVersion(source) {
+  const pkg = import_path9.default.join(source, "..", "package.json");
+  const raw = await (0, import_promises7.readFile)(pkg, "utf8").catch(() => null);
+  if (!raw) return FALLBACK_VERSION;
+  try {
+    const { version } = JSON.parse(raw);
+    return version || FALLBACK_VERSION;
+  } catch {
+    return FALLBACK_VERSION;
+  }
+}
+var FALLBACK_VERSION = "0.0.0-unknown";
+async function treeFiles(dir) {
+  const entries = await (0, import_promises7.readdir)(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const full = import_path9.default.join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...await treeFiles(full));
+    else if (entry.isFile()) files.push(full);
+  }
+  return files.sort();
+}
+async function fingerprint(source, url2, version = "") {
+  const hash = import_crypto2.default.createHash("sha256").update(url2).update(version);
+  for (const file of await treeFiles(source)) {
+    hash.update(import_path9.default.relative(source, file));
+    hash.update(await (0, import_promises7.readFile)(file));
+  }
+  return hash.digest("hex");
+}
+function stampPath(dest) {
+  return `${dest}.stamp`;
+}
+var inFlight = /* @__PURE__ */ new Map();
+function renderPlugin(boardMcpUrl) {
+  const running = inFlight.get(boardMcpUrl);
+  if (running) return running;
+  const started = renderPluginImpl(boardMcpUrl).finally(
+    () => inFlight.delete(boardMcpUrl)
+  );
+  inFlight.set(boardMcpUrl, started);
+  return started;
+}
+async function renderPluginImpl(boardMcpUrl) {
+  const source = pluginRoot();
+  if (!source) return null;
+  const dest = renderedPluginRoot();
+  const version = await runnerVersion(source);
+  const want = await fingerprint(source, boardMcpUrl, version);
+  const have = await (0, import_promises7.readFile)(stampPath(dest), "utf8").catch(() => null);
+  if (have === want) return dest;
+  await (0, import_promises7.mkdir)(import_path9.default.dirname(dest), { recursive: true });
+  await (0, import_promises7.cp)(source, dest, { recursive: true, force: true });
+  await (0, import_promises7.writeFile)(
+    import_path9.default.join(dest, "factiii", ".mcp.json"),
+    `${JSON.stringify(boardMcpConfig(boardMcpUrl), null, 2)}
+`
+  );
+  await stampVersion(dest, version);
+  await (0, import_promises7.writeFile)(stampPath(dest), want);
+  return dest;
+}
+async function stampVersion(dest, version) {
+  const manifest = import_path9.default.join(dest, "factiii", ".claude-plugin", "plugin.json");
+  const raw = await (0, import_promises7.readFile)(manifest, "utf8").catch(() => null);
+  if (!raw) return;
+  const parsed = JSON.parse(raw);
+  await (0, import_promises7.writeFile)(
+    manifest,
+    `${JSON.stringify({ ...parsed, version }, null, 2)}
+`
+  );
+}
+function boardMcpConfig(url2) {
+  return {
+    mcpServers: {
+      "factiii-board": {
+        type: "http",
+        url: url2,
+        bearer_token_env_var: BOARD_MCP_TOKEN_ENV,
+        // Written literally, for claude to expand at connect time. Not a
+        // template string: the `${…}` has to survive into the file.
+        headers: { Authorization: "Bearer ${" + BOARD_MCP_TOKEN_ENV + "}" }
+      }
+    }
+  };
+}
+
+// ../../shared/all/helpers/terminal-ai/initScript.ts
+function terminalPrelude(cwd, binDir) {
+  return [
+    // cd in-script, falling back to $HOME. Must match the agent's worktree:
+    // the CLIs key transcripts by cwd, so --resume needs it.
+    `cd ${cwd} 2>/dev/null || cd "$HOME" 2>/dev/null || cd /`,
+    // Prepended here rather than via the session env, so the login shell's
+    // own PATH survives.
+    `export PATH="${binDir}:$PATH"`,
+    `export PS1='\\[\\e[1;32m\\]user@bare\\[\\e[0m\\]:\\w\\$ '`
+  ].join("; ");
+}
+var SAFE_SESSION_ID = /^[a-zA-Z0-9_-]{1,128}$/;
+function cardBriefPrompt(postId) {
+  return `You are working on a Factiii board card. Its postId is ${postId}. Pass that postId to the factiii-board MCP: get_card to read the card, then card_comments for its discussion. Then start working on it.`;
+}
+var CLAUDE_PERMISSION_MODE = `--permission-mode auto`;
+var RESUME_SEED = "You are now in an interactive terminal, not the board UI. Respond in plain text and use your normal tools; do not use openui-lang or component schemas anymore.";
+function terminalInitScript(cwd, binDir, resumeAgentSessionId, provider, cardPostId) {
+  const prelude = terminalPrelude(cwd, binDir);
+  const shell = `exec bash --norc -i`;
+  if (!resumeAgentSessionId || !SAFE_SESSION_ID.test(resumeAgentSessionId)) {
+    if (!cardPostId) return `${prelude}; ${shell}`;
+    const prompt2 = cardBriefPrompt(cardPostId);
+    const start = provider === "codex" ? `codex '${prompt2}'` : `claude ${CLAUDE_PERMISSION_MODE} '${prompt2}'`;
+    return `${prelude}; ${start}; ${shell}`;
+  }
+  const resume = provider === "codex" ? `codex resume ${resumeAgentSessionId} '${RESUME_SEED}'` : `claude ${CLAUDE_PERMISSION_MODE} --resume ${resumeAgentSessionId} '${RESUME_SEED}'`;
+  return `${prelude}; ${resume}; ${shell}`;
+}
+
+// ../../shared/all/helpers/terminal-ai/digest.ts
+var TERMINAL_FP_OPTION = "@factiii-fp";
+var CWD_PLACEHOLDER = "/__cwd__";
+var VOLATILE_ENV_KEYS = /* @__PURE__ */ new Set(["FACTIII_PORTS"]);
+var PLUGIN_CACHE_MS = 3e4;
+var pluginCache = null;
+async function pluginContribution() {
+  const now = Date.now();
+  if (pluginCache && now - pluginCache.at < PLUGIN_CACHE_MS) {
+    return pluginCache.value;
+  }
+  const source = pluginRoot();
+  const shipped = source ? await fingerprint(source, "", "").catch(() => "") : "";
+  const mcp = await (0, import_promises8.readFile)(
+    import_path10.default.join(renderedPluginRoot(), "factiii", ".mcp.json"),
+    "utf-8"
+  ).catch(() => "");
+  const value2 = `${shipped}|${mcp}`;
+  pluginCache = { at: now, value: value2 };
+  return value2;
+}
+async function terminalDigest(target) {
+  const hash = import_crypto3.default.createHash("sha256").update(TMUX_CONF).update(terminalPrelude(CWD_PLACEHOLDER, target.paths.bin));
+  const env = target.stateEnv();
+  for (const key of Object.keys(env).sort()) {
+    if (VOLATILE_ENV_KEYS.has(key)) continue;
+    hash.update(`${key}=${env[key]}`);
+  }
+  hash.update(await pluginContribution());
+  return hash.digest("hex");
+}
+
 // ../../shared/all/helpers/terminal-ai/processes.ts
 var PS_FORMAT = "pid=,ppid=,pcpu=,rss=,etime=,args=";
 var PS_FIELDS = 5;
@@ -16889,19 +17327,306 @@ function parseSsListen(raw) {
       use.set(pid, found);
     }
   }
-  return use;
-}
-async function socketsFor(target, pids) {
-  if (pids.length === 0) return /* @__PURE__ */ new Map();
-  const lsof = await target.run(["lsof", "-a", "-p", pids.join(","), "-nP", "-iTCP", "-F", "pnT"]).catch((err) => String(err.stdout ?? ""));
-  if (lsof.trim()) return parseLsofSockets(lsof);
-  const ss = await target.run(["ss", "-ltnpH"]).catch(() => "");
-  if (!ss.trim()) return /* @__PURE__ */ new Map();
-  const all = parseSsListen(ss);
-  const wanted = new Set(pids);
-  for (const pid of all.keys()) if (!wanted.has(pid)) all.delete(pid);
-  return all;
-}
+  return use;
+}
+async function socketsFor(target, pids) {
+  if (pids.length === 0) return /* @__PURE__ */ new Map();
+  const lsof = await target.run(["lsof", "-a", "-p", pids.join(","), "-nP", "-iTCP", "-F", "pnT"]).catch((err) => String(err.stdout ?? ""));
+  if (lsof.trim()) return parseLsofSockets(lsof);
+  const ss = await target.run(["ss", "-ltnpH"]).catch(() => "");
+  if (!ss.trim()) return /* @__PURE__ */ new Map();
+  const all = parseSsListen(ss);
+  const wanted = new Set(pids);
+  for (const pid of all.keys()) if (!wanted.has(pid)) all.delete(pid);
+  return all;
+}
+
+// ../../shared/all/helpers/terminal-ai/tabNames.ts
+var TAB_LIST_FORMAT = "#{session_name}|#{pane_current_command}|#{host}|#{@factiii-fp}|#{pane_dead}|#{pane_title}";
+var SHELL_COMMANDS = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "fish"]);
+var tabName = (cmd, host, title) => {
+  const command = cmd.replace(/\.exe$/, "") || "bash";
+  if (!title || title === host || SHELL_COMMANDS.has(command)) return command;
+  return title;
+};
+var parseTerminalTabs = (stdout, prefix) => {
+  const byId = /* @__PURE__ */ new Map();
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line.startsWith(prefix)) continue;
+    const parts2 = line.slice(prefix.length).split("|");
+    if (parts2.length < 6) continue;
+    const id = parts2[0].trim();
+    if (!id || byId.has(id)) continue;
+    byId.set(id, {
+      id,
+      name: tabName(
+        parts2[1].trim(),
+        parts2[2].trim(),
+        parts2.slice(5).join("|").trim()
+      ),
+      fp: parts2[3].trim(),
+      dead: parts2[4].trim() === "1"
+    });
+  }
+  return Array.from(byId.values()).sort(
+    (a, b) => (parseInt(a.id, 10) || 0) - (parseInt(b.id, 10) || 0)
+  );
+};
+
+// ../../shared/all/helpers/wireChunk.ts
+var MAX_INLINE_BYTES = 14e3;
+var chunkCounter = 0;
+function nextChunkId() {
+  return `c-${++chunkCounter}-${Date.now()}`;
+}
+function chunkWire(wire) {
+  if (wire.length <= MAX_INLINE_BYTES) return [wire];
+  const id = nextChunkId();
+  const total = Math.ceil(wire.length / MAX_INLINE_BYTES);
+  const frames = [];
+  for (let i = 0; i < total; i++) {
+    const start = i * MAX_INLINE_BYTES;
+    const slice = wire.slice(start, start + MAX_INLINE_BYTES);
+    const frame = { __c: id, __i: i, __n: total, d: slice };
+    frames.push(JSON.stringify(frame));
+  }
+  return frames;
+}
+function makeChunkReassembler() {
+  const buffers = /* @__PURE__ */ new Map();
+  return {
+    feed(raw) {
+      if (!raw.startsWith('{"__c"')) return raw;
+      let frame;
+      try {
+        frame = JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+      if (typeof frame.__c !== "string" || typeof frame.__i !== "number" || typeof frame.__n !== "number" || typeof frame.d !== "string") {
+        return raw;
+      }
+      let buf = buffers.get(frame.__c);
+      if (!buf) {
+        buf = { received: new Array(frame.__n), total: frame.__n };
+        buffers.set(frame.__c, buf);
+      }
+      buf.received[frame.__i] = frame.d;
+      for (let i = 0; i < buf.total; i++) {
+        if (buf.received[i] === void 0) return null;
+      }
+      buffers.delete(frame.__c);
+      return buf.received.join("");
+    }
+  };
+}
+
+// ../../shared/all/helpers/terminal-ai/terminal.ts
+function tmuxName(terminalKey) {
+  return `terminal-${safeTmuxName(terminalKey)}`;
+}
+async function restartTerminalSession(opts) {
+  const { target, terminalKey, cwd } = opts;
+  await respawnTmuxPane({
+    target,
+    session: tmuxName(terminalKey),
+    argv: ["bash", "-c", terminalInitScript(cwd, target.paths.bin)],
+    cwd,
+    // Rebuilt rather than inherited: picking up an env the session was created
+    // too early to see is half the reason to restart at all.
+    env: target.stateEnv()
+  }).catch(() => {
+  });
+  await terminalDigest(target).then(
+    (digest) => setTmuxSessionOption(
+      target,
+      tmuxName(terminalKey),
+      TERMINAL_FP_OPTION,
+      digest
+    )
+  ).catch(() => {
+  });
+}
+var TerminalManager = class {
+  constructor(send, getCardTarget, getCardWorkdir) {
+    this.send = send;
+    this.getCardTarget = getCardTarget;
+    this.getCardWorkdir = getCardWorkdir;
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  handle(msg) {
+    switch (msg.op) {
+      case "open":
+        void this.open(msg);
+        return;
+      case "stdin":
+        this.stdin(msg.sessionId, msg.data);
+        return;
+      case "resize":
+        void this.resize(msg.sessionId, msg.cols, msg.rows);
+        return;
+      case "close":
+        this.close(msg.sessionId);
+        return;
+      case "kill":
+        void this.killTmuxSession(msg.postId, msg.terminalKey);
+        return;
+      case "restart":
+        void this.restart(msg.postId, msg.terminalKey);
+        return;
+    }
+  }
+  async open(msg) {
+    if (this.sessions.has(msg.sessionId)) {
+      this.emitError(msg.sessionId, "Session already open.");
+      return;
+    }
+    const target = this.getCardTarget(msg.postId);
+    if (!target) {
+      this.emitError(
+        msg.sessionId,
+        `No active card session for postId=${msg.postId}.`
+      );
+      return;
+    }
+    const tmuxSession = tmuxName(msg.terminalKey);
+    const cardPostId = msg.briefCard && !msg.resumeAgentSessionId && isCardPostId(msg.postId) ? msg.postId : void 0;
+    const init = this.buildInit(target, msg.postId, {
+      resumeAgentSessionId: msg.resumeAgentSessionId,
+      provider: msg.resumeProvider,
+      cardPostId
+    });
+    const creating = !await tmuxSessionExists(target, tmuxSession);
+    try {
+      const session = await startTmuxSession({
+        target,
+        session: tmuxSession,
+        // Attach if it exists, else create. This is what makes the shell
+        // survive modal close/reopen: the server holds it, we just view.
+        attachExisting: true,
+        size: { cols: msg.cols, rows: msg.rows },
+        // Without these, `claude` in the shell reads the default ~/.claude and
+        // asks to sign in, while the agent spawns (which pass agentEnv) don't.
+        env: target.stateEnv(),
+        argv: init.argv
+      });
+      this.sessions.set(msg.sessionId, session);
+      if (creating) {
+        void resurrectSave(target);
+        void terminalDigest(target).then(
+          (digest) => setTmuxSessionOption(
+            target,
+            tmuxSession,
+            TERMINAL_FP_OPTION,
+            digest
+          )
+        ).catch(() => {
+        });
+      }
+      session.onData(
+        (data) => this.emit({
+          type: "terminal",
+          op: "stdout",
+          sessionId: msg.sessionId,
+          data: data.toString("base64")
+        })
+      );
+      session.onError((err) => {
+        this.cleanup(msg.sessionId);
+        this.emitError(msg.sessionId, err.message);
+      });
+      session.onClose((code) => {
+        if (!this.sessions.has(msg.sessionId)) return;
+        this.cleanup(msg.sessionId);
+        this.emit({
+          type: "terminal",
+          op: "exit",
+          sessionId: msg.sessionId,
+          code
+        });
+      });
+      this.emit({ type: "terminal", op: "opened", sessionId: msg.sessionId });
+    } catch (err) {
+      this.emitError(
+        msg.sessionId,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  /** What tmux runs for a tab, and where. One builder so `open` and `restart`
+   *  cannot drift. */
+  buildInit(target, postId, agent) {
+    const cwd = this.getCardWorkdir(postId) || target.paths.workspace;
+    return {
+      cwd,
+      argv: [
+        "bash",
+        "-c",
+        terminalInitScript(
+          cwd,
+          target.paths.bin,
+          agent?.resumeAgentSessionId,
+          agent?.provider,
+          agent?.cardPostId
+        )
+      ]
+    };
+  }
+  /** Restart the tab's process while keeping the tab. */
+  async restart(postId, terminalKey) {
+    const target = this.getCardTarget(postId);
+    if (!target) return;
+    await restartTerminalSession({
+      target,
+      terminalKey,
+      cwd: this.getCardWorkdir(postId) || target.paths.workspace
+    });
+  }
+  stdin(sessionId, b64) {
+    this.sessions.get(sessionId)?.write(Buffer.from(b64, "base64"));
+  }
+  async resize(sessionId, cols, rows) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    if (!Number.isInteger(cols) || !Number.isInteger(rows)) return;
+    if (cols < 1 || rows < 1) return;
+    await session.resize(cols, rows).catch(() => {
+    });
+  }
+  close(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    this.sessions.delete(sessionId);
+    session.detach();
+  }
+  /** Tear down the tmux session for a tab. Used when the user explicitly
+   *  removes a tab (the X button), not on transient detach. */
+  async killTmuxSession(postId, terminalKey) {
+    const target = this.getCardTarget(postId);
+    if (!target) return;
+    await target.sh(
+      `${tmuxCli(target)} kill-session -t ${tmuxName(terminalKey)} 2>/dev/null || true`
+    ).catch(() => {
+    });
+    await resurrectSave(target);
+  }
+  destroyAll() {
+    for (const sessionId of [...this.sessions.keys()]) {
+      this.close(sessionId);
+    }
+  }
+  cleanup(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  emitError(sessionId, message) {
+    this.emit({ type: "terminal", op: "error", sessionId, message });
+  }
+  emit(msg) {
+    const wire = JSON.stringify(msg);
+    for (const frame of chunkWire(wire)) this.send(frame);
+  }
+};
 
 // ../../shared/all/helpers/terminal-ai/watcher.ts
 var PRUNED_DIRS = [
@@ -16928,12 +17653,12 @@ var FLUSH_MS = 120;
 var SELF_WRITE_MS = 2e3;
 var dynamicImport = new Function("s", "return import(s)");
 var importFs = new Function("s", "return import(s)");
-async function resolveReal(path21) {
+async function resolveReal(path23) {
   try {
     const { realpath } = await importFs("fs/promises");
-    return await realpath(path21);
+    return await realpath(path23);
   } catch {
-    return path21;
+    return path23;
   }
 }
 var loadSubscribe = null;
@@ -17047,19 +17772,19 @@ var WorkspaceWatcher = class {
   }
   record(kind, relPath) {
     if (this.closed) return;
-    const path21 = "/" + relPath;
-    const expiry = this.selfWrites.get(path21);
+    const path23 = "/" + relPath;
+    const expiry = this.selfWrites.get(path23);
     if (expiry !== void 0) {
       if (expiry > Date.now()) return;
-      this.selfWrites.delete(path21);
+      this.selfWrites.delete(path23);
     }
     const { added, changed, removed } = this.pending;
-    added.delete(path21);
-    changed.delete(path21);
-    removed.delete(path21);
-    if (kind === "added") added.add(path21);
-    else if (kind === "changed") changed.add(path21);
-    else removed.add(path21);
+    added.delete(path23);
+    changed.delete(path23);
+    removed.delete(path23);
+    if (kind === "added") added.add(path23);
+    else if (kind === "changed") changed.add(path23);
+    else removed.add(path23);
     if (added.size + changed.size + removed.size > MAX_BATCH) {
       this.pending = { ...emptyPending(), resync: true };
     }
@@ -17078,8 +17803,8 @@ var WorkspaceWatcher = class {
     this.pending = emptyPending();
     if (!resync && !added.size && !changed.size && !removed.size) return;
     const now = Date.now();
-    for (const [path21, expiry] of this.selfWrites) {
-      if (expiry <= now) this.selfWrites.delete(path21);
+    for (const [path23, expiry] of this.selfWrites) {
+      if (expiry <= now) this.selfWrites.delete(path23);
     }
     this.emit({
       added: resync ? [] : [...added],
@@ -17283,8 +18008,8 @@ var TerminalModeEngine = class {
   /** Suppress the change event our own write is about to produce, so a save
    *  never comes back to the editor as an outside edit. Normalized to the form
    *  the watcher emits, since callers spell the path either way. */
-  expectWrite(postId, path21) {
-    this.watchers.get(postId)?.expectWrite(posixNormalize(path21));
+  expectWrite(postId, path23) {
+    this.watchers.get(postId)?.expectWrite(posixNormalize(path23));
   }
   // ── Lifecycle / ModeEngine ──
   start(base, args) {
@@ -17344,7 +18069,7 @@ var TerminalModeEngine = class {
     }
     if (!session) return;
     this.stopWatching(session.postId);
-    await this.teardown(session);
+    await teardownSession(session, this.core.target());
     const removedPostId = session.postId;
     this.reservedNames.delete(removedPostId);
     this.sessions.delete(removedPostId);
@@ -17357,33 +18082,6 @@ var TerminalModeEngine = class {
     this.reservedNames.clear();
     this.sessions.clear();
   }
-  /** Every tmux session this post owns, by the `terminal-<postId>-<tab>` name
-   *  tmuxName() builds. */
-  async terminalSessionNames(target, postId) {
-    const prefix = `terminal-${postId.replace(/[^a-zA-Z0-9._-]/g, "_")}-`;
-    const stdout = await target.sh(
-      `${tmuxCli(target)} list-sessions -F '#{session_name}' 2>/dev/null || true`
-    ).catch(() => "");
-    return stdout.split("\n").map((line) => line.trim()).filter((name) => name.startsWith(prefix));
-  }
-  /** Kill the post's terminals and everything running inside them. Killing the
-   *  tmux session alone leaves a process that reparented away from the shell,
-   *  so each pane's process tree is killed first. */
-  async killTerminals(postId) {
-    const target = this.core.target();
-    const names = await this.terminalSessionNames(target, postId);
-    for (const name of names) {
-      await target.sh(
-        `for p in $(${tmuxCli(target)} list-panes -t ${name} -F '#{pane_pid}' 2>/dev/null); do pkill -TERM -P "$p" 2>/dev/null || true; done; ${tmuxCli(target)} kill-session -t ${name} 2>/dev/null || true`
-      ).catch(() => {
-      });
-    }
-  }
-  async teardown(session) {
-    await this.killTerminals(session.postId).catch(() => {
-    });
-    await teardownSession(session, this.core.target());
-  }
   putCard(s) {
     return putSessionCard(s, this.core.target());
   }
@@ -17481,18 +18179,18 @@ var TerminalModeEngine = class {
         this.reservedNames.values()
       );
       this.reservedNames.set(session.postId, workName);
-      const { path: path21 } = await addWorktree(
+      const { path: path23 } = await addWorktree(
         this.core.target(),
         workName,
         branch,
         "terminal"
       );
-      session.workspacePath = path21;
+      session.workspacePath = path23;
       await setGitIdentity(
         this.core.target(),
         config.gitName,
         config.gitEmail,
-        path21
+        path23
       );
       this.emitter.addLog(session, "system", "Worktree ready.");
     } else {
@@ -17554,11 +18252,11 @@ var TerminalModeEngine = class {
   }
   async bareFsList({
     postId,
-    path: path21
+    path: path23
   }) {
     const target = this.getBareTarget(postId);
     const root = this.getBareRoot(postId);
-    const abs = this.resolveBarePath(path21, root);
+    const abs = this.resolveBarePath(path23, root);
     const relRoot = abs.slice(root.length) || "/";
     const out = await target.run([
       "sh",
@@ -17608,30 +18306,30 @@ var TerminalModeEngine = class {
   }
   async bareFsRead({
     postId,
-    path: path21
+    path: path23
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path21, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path23, this.getBareRoot(postId));
     const b64 = (await target.sh(`base64 < ${shEscape(abs)} | tr -d '
 '`)).trim();
     return { content: b64, encoding: "base64" };
   }
   async bareFsWrite({
     postId,
-    path: path21,
+    path: path23,
     content,
     encoding
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path21, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path23, this.getBareRoot(postId));
     const b64 = encoding === "base64" ? content : Buffer.from(content, "utf-8").toString("base64");
     if (!/^[A-Za-z0-9+/=\n\r]*$/.test(b64)) {
       throw new Error("Invalid base64 payload.");
     }
-    this.expectWrite(String(postId), path21);
+    this.expectWrite(String(postId), path23);
     await writeBase64File(target, abs, b64);
     const session = this.sessions.get(String(postId));
-    if (session) delete session.buffers[path21];
+    if (session) delete session.buffers[path23];
   }
   /** Append one chunk of a dropped image to the per-space drops dir
    *  (`paths.root`, OUTSIDE the card worktree so it never touches the repo).
@@ -17649,7 +18347,7 @@ var TerminalModeEngine = class {
     }
     const safeExt = (ext || "png").toLowerCase().replace(/[^a-z0-9]/g, "") || "png";
     const oneShot = !dropId;
-    const safeId2 = oneShot ? (0, import_crypto.randomUUID)() : dropId.toLowerCase().replace(/[^a-z0-9-]/g, "");
+    const safeId2 = oneShot ? (0, import_crypto4.randomUUID)() : dropId.toLowerCase().replace(/[^a-z0-9-]/g, "");
     if (!safeId2) throw new Error("Invalid drop id.");
     const dropsDir = `${target.paths.root}/drops`;
     const abs = `${dropsDir}/${safeId2}.${safeExt}`;
@@ -17681,39 +18379,39 @@ var TerminalModeEngine = class {
   }
   bareOpenFile({
     postId: rawPostId,
-    path: path21
+    path: path23
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    if (!session.openedFiles.includes(path21)) {
-      session.openedFiles.push(path21);
+    if (!session.openedFiles.includes(path23)) {
+      session.openedFiles.push(path23);
     }
   }
   bareCloseFile({
     postId: rawPostId,
-    path: path21
+    path: path23
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    session.openedFiles = session.openedFiles.filter((p) => p !== path21);
-    delete session.buffers[path21];
+    session.openedFiles = session.openedFiles.filter((p) => p !== path23);
+    delete session.buffers[path23];
   }
   bareBufferSet({
     postId: rawPostId,
-    path: path21,
+    path: path23,
     content
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    session.buffers[path21] = content;
+    session.buffers[path23] = content;
   }
   async bareFsDelete({
     postId,
-    path: path21
+    path: path23
   }) {
     const target = this.getBareTarget(postId);
     const root = this.getBareRoot(postId);
-    const abs = this.resolveBarePath(path21, root);
+    const abs = this.resolveBarePath(path23, root);
     if (abs === root) {
       throw new Error("Refusing to delete the repo root.");
     }
@@ -17721,10 +18419,10 @@ var TerminalModeEngine = class {
   }
   async bareFsMkdir({
     postId,
-    path: path21
+    path: path23
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path21, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path23, this.getBareRoot(postId));
     await target.sh(`mkdir -p ${shEscape(abs)}`);
   }
   async bareReview({
@@ -17847,26 +18545,68 @@ var TerminalModeEngine = class {
     const prefix = `terminal-${sanitizedPostId}-`;
     try {
       const stdout = await target.sh(
-        `${tmuxCli(target)} list-panes -a -F '#{session_name}|#{pane_current_command}' 2>/dev/null || true`
-      );
-      const byId = /* @__PURE__ */ new Map();
-      for (const raw of stdout.split("\n")) {
-        const line = raw.trim();
-        if (!line.startsWith(prefix)) continue;
-        const rest = line.slice(prefix.length);
-        const sep = rest.indexOf("|");
-        if (sep === -1) continue;
-        const id = rest.slice(0, sep);
-        const cmd = rest.slice(sep + 1).trim() || "bash";
-        if (!byId.has(id)) byId.set(id, cmd);
-      }
-      return Array.from(byId, ([id, name]) => ({ id, name })).sort(
-        (a, b) => (parseInt(a.id, 10) || 0) - (parseInt(b.id, 10) || 0)
+        `${tmuxCli(target)} list-panes -a -F '${TAB_LIST_FORMAT}' 2>/dev/null || true`
       );
+      const rows = parseTerminalTabs(stdout, prefix);
+      return rows.map(({ id, name, dead }) => ({ id, name, dead }));
     } catch {
       return [];
     }
   }
+  /** Terminal tabs across several posts in one sweep, so the sessions view can
+   *  ask about a whole board without a round trip per card. */
+  async staleTabsFor(target, postIds, current) {
+    if (!current) return [];
+    const stdout = await target.sh(
+      `${tmuxCli(target)} list-panes -a -F '${TAB_LIST_FORMAT}' 2>/dev/null || true`
+    ).catch(() => "");
+    const stale = [];
+    for (const postId of postIds) {
+      const prefix = `terminal-${postId.replace(/[^a-zA-Z0-9._-]/g, "_")}-`;
+      for (const row of parseTerminalTabs(stdout, prefix)) {
+        if (row.fp !== current) stale.push({ postId, tabId: row.id });
+      }
+    }
+    return stale;
+  }
+  async bareTerminalHealth({
+    postIds
+  }) {
+    const target = this.core.target();
+    const digest = await terminalDigest(target).catch(() => "");
+    const acked = await getTerminalAck(target);
+    return {
+      digest,
+      acked: !!digest && acked === digest,
+      staleTabs: await this.staleTabsFor(target, postIds, digest)
+    };
+  }
+  async bareAckTerminalDigest() {
+    const target = this.core.target();
+    const digest = await terminalDigest(target).catch(() => "");
+    if (!digest) return;
+    await setTerminalAck(target, digest);
+  }
+  async bareRestartStaleTerminals({
+    postIds
+  }) {
+    const target = this.core.target();
+    const digest = await terminalDigest(target).catch(() => "");
+    const stale = await this.staleTabsFor(target, postIds, digest);
+    for (const { postId, tabId } of stale) {
+      let cwd = target.paths.workspace;
+      try {
+        cwd = this.gitWorkdir(postId) || cwd;
+      } catch {
+      }
+      await restartTerminalSession({
+        target,
+        terminalKey: `${postId}-${tabId}`,
+        cwd
+      });
+    }
+    return { restarted: stale.length };
+  }
   /** This card's panes: the pid its tree hangs off, and the pane id its
    *  processes carry in their environment. */
   async panePids(target, postId) {
@@ -18406,8 +19146,8 @@ async function pollGithubDeviceCode(clientId, deviceCode) {
       };
   }
 }
-async function githubApi(token, path21) {
-  const res = await fetch(`${API_BASE}${path21}`, {
+async function githubApi(token, path23) {
+  const res = await fetch(`${API_BASE}${path23}`, {
     headers: {
       Authorization: `Bearer ${token}`,
       Accept: "application/vnd.github+json",
@@ -18416,7 +19156,7 @@ async function githubApi(token, path21) {
   });
   if (!res.ok) {
     throw new Error(
-      `GitHub ${path21} failed (${res.status}): ${await res.text()}`
+      `GitHub ${path23} failed (${res.status}): ${await res.text()}`
     );
   }
   return await res.json();
@@ -18461,10 +19201,10 @@ async function listGithubBranches(token, fullName) {
 }
 
 // ../../shared/all/helpers/board-agent-core/host-run.ts
-var import_path10 = __toESM(require("path"));
+var import_path13 = __toESM(require("path"));
 
 // ../../shared/all/helpers/board-agent-core/secrets-gate.ts
-var import_crypto2 = __toESM(require("crypto"));
+var import_crypto5 = __toESM(require("crypto"));
 var DEPLOY_ORIGIN = "Deploy run";
 var UNATTRIBUTED = "This runner did not start the session that asked, so the request was refused. `factiii-secrets` only works inside a session the runner spawned.";
 var SecretsGate = class {
@@ -18489,7 +19229,14 @@ var SecretsGate = class {
   /** Mint a token for one session, labelled with what the owner should see on
    *  the prompt - the label is most of the decision, so name the session. */
   issueToken(origin) {
-    const token = import_crypto2.default.randomBytes(24).toString("hex");
+    const token = import_crypto5.default.randomBytes(24).toString("hex");
+    this.tokens.set(token, origin);
+    return token;
+  }
+  /** Register a durable token the caller already holds, instead of minting a
+   *  fresh one. For the space token: terminals outlive this process, so a
+   *  minted one leaves them unattributed after a restart. Idempotent. */
+  adoptToken(token, origin) {
     this.tokens.set(token, origin);
     return token;
   }
@@ -18513,7 +19260,7 @@ var SecretsGate = class {
     return new Promise((resolve2) => {
       this.waiting = {
         request: {
-          id: import_crypto2.default.randomUUID(),
+          id: import_crypto5.default.randomUUID(),
           command: opts.command,
           keys: opts.keys,
           origin: opts.origin,
@@ -18553,13 +19300,13 @@ var SecretsGate = class {
 };
 
 // ../../shared/all/helpers/board-agent-core/secrets-run.ts
-var import_path9 = __toESM(require("path"));
+var import_path12 = __toESM(require("path"));
 
 // ../../shared/all/helpers/board-agent-core/host-secrets.ts
 var import_child_process4 = require("child_process");
-var import_crypto3 = __toESM(require("crypto"));
-var import_promises6 = __toESM(require("fs/promises"));
-var import_path8 = __toESM(require("path"));
+var import_crypto6 = __toESM(require("crypto"));
+var import_promises9 = __toESM(require("fs/promises"));
+var import_path11 = __toESM(require("path"));
 var import_util6 = require("util");
 var execFileAsync3 = (0, import_util6.promisify)(import_child_process4.execFile);
 var IDENTITY_FILE = "age-identity.enc";
@@ -18585,14 +19332,14 @@ async function assertBinaries() {
   }
 }
 function deriveKey(password, salt) {
-  return import_crypto3.default.scryptSync(password, salt, 32, {
+  return import_crypto6.default.scryptSync(password, salt, 32, {
     N: SCRYPT_N,
     maxmem: 64 * 1024 * 1024
   });
 }
 async function secretsInitialized(configDir) {
   try {
-    await import_promises6.default.access(import_path8.default.join(configDir, IDENTITY_FILE));
+    await import_promises9.default.access(import_path11.default.join(configDir, IDENTITY_FILE));
     return true;
   } catch {
     return false;
@@ -18614,9 +19361,9 @@ async function initSecrets(configDir, password) {
   if (!identity || !recipient) {
     throw new Error("age-keygen returned no usable keypair.");
   }
-  const salt = import_crypto3.default.randomBytes(16);
-  const iv = import_crypto3.default.randomBytes(12);
-  const cipher = import_crypto3.default.createCipheriv(
+  const salt = import_crypto6.default.randomBytes(16);
+  const iv = import_crypto6.default.randomBytes(12);
+  const cipher = import_crypto6.default.createCipheriv(
     "aes-256-gcm",
     deriveKey(password, salt),
     iv
@@ -18631,17 +19378,17 @@ async function initSecrets(configDir, password) {
     tag: cipher.getAuthTag().toString("base64"),
     data: data.toString("base64")
   };
-  await import_promises6.default.writeFile(import_path8.default.join(configDir, IDENTITY_FILE), JSON.stringify(box), {
+  await import_promises9.default.writeFile(import_path11.default.join(configDir, IDENTITY_FILE), JSON.stringify(box), {
     mode: 384
   });
-  await import_promises6.default.writeFile(import_path8.default.join(configDir, RECIPIENT_FILE), `${recipient}
+  await import_promises9.default.writeFile(import_path11.default.join(configDir, RECIPIENT_FILE), `${recipient}
 `, {
     mode: 384
   });
   return { success: true };
 }
 function decryptIdentity(box, password) {
-  const decipher = import_crypto3.default.createDecipheriv(
+  const decipher = import_crypto6.default.createDecipheriv(
     "aes-256-gcm",
     deriveKey(password, Buffer.from(box.salt, "base64")),
     Buffer.from(box.iv, "base64")
@@ -18657,17 +19404,17 @@ function decryptIdentity(box, password) {
   }
 }
 function envPath(spaceDir) {
-  return import_path8.default.join(spaceDir, "secrets", ENV_FILE);
+  return import_path11.default.join(spaceDir, "secrets", ENV_FILE);
 }
 async function identityFor(configDir, password) {
   const box = JSON.parse(
-    await import_promises6.default.readFile(import_path8.default.join(configDir, IDENTITY_FILE), "utf-8")
+    await import_promises9.default.readFile(import_path11.default.join(configDir, IDENTITY_FILE), "utf-8")
   );
   return decryptIdentity(box, password);
 }
 async function readEnv(spaceDir, identity) {
   try {
-    await import_promises6.default.access(envPath(spaceDir));
+    await import_promises9.default.access(envPath(spaceDir));
   } catch {
     return {};
   }
@@ -18696,14 +19443,14 @@ async function readEnv(spaceDir, identity) {
   return values;
 }
 async function writeEnv(configDir, spaceDir, identity, values) {
-  const recipient = (await import_promises6.default.readFile(import_path8.default.join(configDir, RECIPIENT_FILE), "utf-8")).trim();
+  const recipient = (await import_promises9.default.readFile(import_path11.default.join(configDir, RECIPIENT_FILE), "utf-8")).trim();
   const plain = `${Object.entries(values).map(([k, v]) => `${k}=${v}`).join("\n")}
 `;
   const tmp = envPath(spaceDir).replace(
     /\.enc\.env$/,
     `.${process.pid}.tmp.env`
   );
-  await import_promises6.default.writeFile(tmp, plain, { mode: 384 });
+  await import_promises9.default.writeFile(tmp, plain, { mode: 384 });
   try {
     const { stdout } = await execFileAsync3(
       "sops",
@@ -18722,13 +19469,13 @@ async function writeEnv(configDir, spaceDir, identity, values) {
         maxBuffer: 4 * 1024 * 1024
       }
     );
-    await import_promises6.default.writeFile(envPath(spaceDir), stdout, { mode: 384 });
+    await import_promises9.default.writeFile(envPath(spaceDir), stdout, { mode: 384 });
   } finally {
-    await import_promises6.default.rm(tmp, { force: true });
+    await import_promises9.default.rm(tmp, { force: true });
   }
 }
 async function storedSecretKeys(spaceDir) {
-  const raw = await import_promises6.default.readFile(envPath(spaceDir), "utf-8").catch(() => "");
+  const raw = await import_promises9.default.readFile(envPath(spaceDir), "utf-8").catch(() => "");
   const keys = [];
   for (const line of raw.split("\n")) {
     const eq = line.indexOf("=");
@@ -18772,9 +19519,9 @@ var COMMAND_TIMEOUT_MS = 6 * 60 * 6e4;
 var tail = (s, max = 8e3) => s.length > max ? s.slice(-max) : s;
 function containedCwd(cwd, spaceDir) {
   if (!cwd) return null;
-  const resolved = import_path9.default.resolve(cwd);
-  const root = import_path9.default.resolve(spaceDir);
-  return resolved === root || resolved.startsWith(root + import_path9.default.sep) ? resolved : null;
+  const resolved = import_path12.default.resolve(cwd);
+  const root = import_path12.default.resolve(spaceDir);
+  return resolved === root || resolved.startsWith(root + import_path12.default.sep) ? resolved : null;
 }
 async function authorizeAndRun(opts) {
   const { command, gate } = opts;
@@ -18859,8 +19606,8 @@ function tailMarker(text) {
 }
 async function startDeployRun(opts) {
   const { hooks } = opts;
-  const workspace = import_path10.default.join(opts.spaceDir, "workspace");
-  const configDir = import_path10.default.dirname(opts.spaceDir);
+  const workspace = import_path13.default.join(opts.spaceDir, "workspace");
+  const configDir = import_path13.default.dirname(opts.spaceDir);
   const status = await checkDeployStatus(opts);
   if (!status.hasSkill || !status.hasVariables || !status.hasChecker) {
     throw new Error(
@@ -19079,123 +19826,8 @@ async function getDriveRoot(accessToken) {
 }
 
 // ../../shared/all/helpers/board-agent-core/space-core.ts
-var import_promises8 = require("fs/promises");
-var import_path12 = __toESM(require("path"));
-
-// ../../shared/all/helpers/board-agent-core/plugin.ts
-var import_crypto4 = __toESM(require("crypto"));
-var import_fs3 = require("fs");
-var import_promises7 = require("fs/promises");
-var import_os3 = __toESM(require("os"));
-var import_path11 = __toESM(require("path"));
-var MARKETPLACE_NAME = "factiii-runner";
-var PLUGIN_ID = `factiii@${MARKETPLACE_NAME}`;
-var SECRETS_BIN = "factiii-secrets";
-function candidates() {
-  return [
-    import_path11.default.join(__dirname, "..", "plugin"),
-    import_path11.default.join(__dirname, "..", "..", "..", "..", "apps", "runner", "plugin"),
-    import_path11.default.join(process.cwd(), "apps", "runner", "plugin")
-  ];
-}
-function pluginRoot() {
-  for (const dir of candidates()) {
-    if ((0, import_fs3.existsSync)(import_path11.default.join(dir, ".claude-plugin", "marketplace.json"))) {
-      return dir;
-    }
-  }
-  return null;
-}
-function renderedPluginRoot() {
-  return import_path11.default.join(import_os3.default.homedir(), ".factiii-runner", "plugin");
-}
-async function runnerVersion(source) {
-  const pkg = import_path11.default.join(source, "..", "package.json");
-  const raw = await (0, import_promises7.readFile)(pkg, "utf8").catch(() => null);
-  if (!raw) return FALLBACK_VERSION;
-  try {
-    const { version } = JSON.parse(raw);
-    return version || FALLBACK_VERSION;
-  } catch {
-    return FALLBACK_VERSION;
-  }
-}
-var FALLBACK_VERSION = "0.0.0-unknown";
-async function treeFiles(dir) {
-  const entries = await (0, import_promises7.readdir)(dir, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const full = import_path11.default.join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...await treeFiles(full));
-    else if (entry.isFile()) files.push(full);
-  }
-  return files.sort();
-}
-async function fingerprint(source, url2, version = "") {
-  const hash = import_crypto4.default.createHash("sha256").update(url2).update(version);
-  for (const file of await treeFiles(source)) {
-    hash.update(import_path11.default.relative(source, file));
-    hash.update(await (0, import_promises7.readFile)(file));
-  }
-  return hash.digest("hex");
-}
-function stampPath(dest) {
-  return `${dest}.stamp`;
-}
-var inFlight = /* @__PURE__ */ new Map();
-function renderPlugin(boardMcpUrl) {
-  const running = inFlight.get(boardMcpUrl);
-  if (running) return running;
-  const started = renderPluginImpl(boardMcpUrl).finally(
-    () => inFlight.delete(boardMcpUrl)
-  );
-  inFlight.set(boardMcpUrl, started);
-  return started;
-}
-async function renderPluginImpl(boardMcpUrl) {
-  const source = pluginRoot();
-  if (!source) return null;
-  const dest = renderedPluginRoot();
-  const version = await runnerVersion(source);
-  const want = await fingerprint(source, boardMcpUrl, version);
-  const have = await (0, import_promises7.readFile)(stampPath(dest), "utf8").catch(() => null);
-  if (have === want) return dest;
-  await (0, import_promises7.mkdir)(import_path11.default.dirname(dest), { recursive: true });
-  await (0, import_promises7.cp)(source, dest, { recursive: true, force: true });
-  await (0, import_promises7.writeFile)(
-    import_path11.default.join(dest, "factiii", ".mcp.json"),
-    `${JSON.stringify(boardMcpConfig(boardMcpUrl), null, 2)}
-`
-  );
-  await stampVersion(dest, version);
-  await (0, import_promises7.writeFile)(stampPath(dest), want);
-  return dest;
-}
-async function stampVersion(dest, version) {
-  const manifest = import_path11.default.join(dest, "factiii", ".claude-plugin", "plugin.json");
-  const raw = await (0, import_promises7.readFile)(manifest, "utf8").catch(() => null);
-  if (!raw) return;
-  const parsed = JSON.parse(raw);
-  await (0, import_promises7.writeFile)(
-    manifest,
-    `${JSON.stringify({ ...parsed, version }, null, 2)}
-`
-  );
-}
-function boardMcpConfig(url2) {
-  return {
-    mcpServers: {
-      "factiii-board": {
-        type: "http",
-        url: url2,
-        bearer_token_env_var: BOARD_MCP_TOKEN_ENV,
-        // Written literally, for claude to expand at connect time. Not a
-        // template string: the `${…}` has to survive into the file.
-        headers: { Authorization: "Bearer ${" + BOARD_MCP_TOKEN_ENV + "}" }
-      }
-    }
-  };
-}
+var import_promises10 = require("fs/promises");
+var import_path14 = __toESM(require("path"));
 
 // ../../shared/all/helpers/board-agent-core/toolchain.ts
 var TOOLS = [
@@ -19421,6 +20053,7 @@ var SpaceCore = class {
     this.runnerToken = options.runnerToken;
     this.serverUrl = options.serverUrl;
     this.mcp = options.mcp;
+    this.mcpToken = options.mcpToken;
     this.requestSudo = options.requestSudo;
     this.activity = new ActivityTracker(this.emitter);
     this.gate.subscribe(() => {
@@ -19464,7 +20097,7 @@ var SpaceCore = class {
             return { code: 3, output: "" };
           }
           return authorizeAndRun({
-            configDir: import_path12.default.dirname(spaceDir),
+            configDir: import_path14.default.dirname(spaceDir),
             spaceDir,
             // A step legitimately cds into subdirectories, so the caller's own
             // cwd is right - but only inside the space. Anywhere else is a
@@ -19515,7 +20148,11 @@ var SpaceCore = class {
    * that DOES know itself - the deploy run - mints its own and overrides this.
    */
   secretsToken() {
-    this.spaceSecretsToken ||= this.gate.issueToken("A session on this board");
+    if (this.spaceSecretsToken) return this.spaceSecretsToken;
+    this.spaceSecretsToken = this.gate.adoptToken(
+      spaceSecret(this.spaceDir()),
+      "A session on this board"
+    );
     return this.spaceSecretsToken;
   }
   readConfig() {
@@ -19526,7 +20163,8 @@ var SpaceCore = class {
   target() {
     this.execTarget ??= hostTarget(this.spaceDir(), () => {
       const env = {};
-      for (const lane of this.mcpLanes()) env[lane.tokenEnv] = lane.mcp.token;
+      const onedrive = this.mcpToken?.();
+      if (onedrive) env[MCP_TOKEN_ENV] = onedrive;
       const board = this.boardMcp();
       if (board) env[BOARD_MCP_TOKEN_ENV] = board.token;
       env.FACTIII_SECRETS_TOKEN = this.secretsToken();
@@ -19717,6 +20355,8 @@ var SpaceCore = class {
           markOnboardingComplete(target).catch(() => {
           })
         ]);
+        await this.restoreTerminals();
+        await this.applyTerminalConfig();
         status("");
         this.ready = true;
       } catch (err) {
@@ -19802,17 +20442,17 @@ var SpaceCore = class {
     const source = pluginRoot();
     if (!source) return;
     const { bin } = this.target().paths;
-    const from = import_path12.default.join(source, "factiii", "bin", SECRETS_BIN);
-    const to = import_path12.default.join(bin, SECRETS_BIN);
+    const from = import_path14.default.join(source, "factiii", "bin", SECRETS_BIN);
+    const to = import_path14.default.join(bin, SECRETS_BIN);
     try {
       const [src, staged] = await Promise.all([
-        (0, import_promises8.readFile)(from),
-        (0, import_promises8.readFile)(to).catch(() => null)
+        (0, import_promises10.readFile)(from),
+        (0, import_promises10.readFile)(to).catch(() => null)
       ]);
       if (staged?.equals(src)) return;
-      await (0, import_promises8.mkdir)(bin, { recursive: true });
-      await (0, import_promises8.copyFile)(from, to);
-      await (0, import_promises8.chmod)(to, 493);
+      await (0, import_promises10.mkdir)(bin, { recursive: true });
+      await (0, import_promises10.copyFile)(from, to);
+      await (0, import_promises10.chmod)(to, 493);
     } catch {
     }
   }
@@ -19875,9 +20515,79 @@ var SpaceCore = class {
     });
     await Promise.all([this.provisionPluginLane(), this.provisionBinLane()]);
     await this.provisionMcpLane();
+    await this.restoreTerminals();
+    await this.applyTerminalConfig();
     this.ready = true;
     return true;
   }
+  /** Push a changed tmux config into the server that is already running.
+   *
+   *  tmux reads `-f` only when it STARTS, so a config a runner update changed
+   *  would otherwise sit unread until every session on the host died. Sourcing
+   *  it reaches the live sessions and costs no process its life, which is why
+   *  this half never has to bother the user - unlike the env half, where a
+   *  restart is the only way in.
+   *
+   *  Runs AFTER the plugin and helper lanes above, deliberately: those are two
+   *  of the inputs the digest covers, and recording one before they finish
+   *  would stamp a state the runner is about to invalidate. */
+  /** Bring this space's tabs back after the tmux server died (a reboot, or a
+   *  kill). A runner restart needs none of this — tmux outlives us.
+   *
+   *  Structure only: every tab returns as a fresh shell.
+   *
+   *  Each restored pane is respawned, because resurrect rebuilds panes on the
+   *  DEFAULT shell with no bin dir on PATH, and stamped, because it saves no
+   *  user options and an unstamped session would read as stale on every boot. */
+  async restoreTerminals() {
+    try {
+      const target = this.target();
+      await ensureTmuxResurrect(target);
+      const root = target.paths.root;
+      const before = await tmuxPanePaths(target);
+      const mineUp = [...before].some(
+        ([name, dir]) => name.startsWith("terminal-") && dir.startsWith(root)
+      );
+      if (mineUp) return;
+      const restored = await resurrectRestore(target);
+      const paths = await tmuxPanePaths(target);
+      const revived = restored.filter(
+        (name) => !before.has(name) && (paths.get(name) ?? "").startsWith(root)
+      );
+      if (revived.length === 0) return;
+      const digest = await terminalDigest(target).catch(() => "");
+      for (const session of revived) {
+        await respawnTmuxPane({
+          target,
+          session,
+          argv: [
+            "bash",
+            "-c",
+            terminalInitScript(
+              paths.get(session) || target.paths.workspace,
+              target.paths.bin
+            )
+          ],
+          cwd: paths.get(session) || target.paths.workspace,
+          env: target.stateEnv()
+        }).catch(() => {
+        });
+        if (digest) {
+          await setTmuxSessionOption(
+            target,
+            session,
+            TERMINAL_FP_OPTION,
+            digest
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  async applyTerminalConfig() {
+    await sourceTmuxConf(this.target()).catch(() => {
+    });
+  }
   async ensureSetup() {
     await this.ensureSpaceWorkspace();
     return { ready: true };
@@ -20528,7 +21238,7 @@ var BoardAgentEngine = class _BoardAgentEngine {
   // ── Runner secrets store (secrets.sh contract; see host-secrets.ts) ──
   secretsDirs() {
     const spaceDir = this.core.spaceDir();
-    return { configDir: (0, import_path13.dirname)(spaceDir), spaceDir };
+    return { configDir: (0, import_path15.dirname)(spaceDir), spaceDir };
   }
   async deploySecretsStatus() {
     return {
@@ -20919,6 +21629,15 @@ var BoardAgentEngine = class _BoardAgentEngine {
       this.getCardTarget(String(p.postId)) ?? void 0
     );
   }
+  bareTerminalHealth(p) {
+    return this.terminal.bareTerminalHealth(p);
+  }
+  bareAckTerminalDigest() {
+    return this.terminal.bareAckTerminalDigest();
+  }
+  bareRestartStaleTerminals(p) {
+    return this.terminal.bareRestartStaleTerminals(p);
+  }
   bareEditorState(p) {
     return this.terminal.bareEditorState(p);
   }
@@ -21556,6 +22275,17 @@ ${c.content.trim() || "(no description)"}`
         return await this.bareListTerminals(
           payload
         );
+      case "bareTerminalHealth":
+        return await this.bareTerminalHealth(
+          payload
+        );
+      case "bareAckTerminalDigest":
+        await this.bareAckTerminalDigest();
+        return void 0;
+      case "bareRestartStaleTerminals":
+        return await this.bareRestartStaleTerminals(
+          payload
+        );
       case "bareEditorState":
         return this.bareEditorState(
           payload
@@ -21598,11 +22328,11 @@ ${c.content.trim() || "(no description)"}`
 
 // ../../shared/all/helpers/board-agent-core/index-service.ts
 var import_child_process5 = require("child_process");
-var import_crypto5 = require("crypto");
-var import_fs4 = require("fs");
-var import_promises9 = __toESM(require("fs/promises"));
+var import_crypto7 = require("crypto");
+var import_fs5 = require("fs");
+var import_promises11 = __toESM(require("fs/promises"));
 var import_net3 = require("net");
-var import_path14 = require("path");
+var import_path16 = require("path");
 var import_util7 = require("util");
 var execFileAsync4 = (0, import_util7.promisify)(import_child_process5.execFile);
 var IndexService = class {
@@ -21616,7 +22346,7 @@ var IndexService = class {
   /** Per-space bearer for MCP + file, derived from the control token (the
    *  service computes the same). */
   bearerToken(spaceSlug) {
-    return (0, import_crypto5.createHmac)("sha256", this.opts.controlToken).update(`mcp:${spaceSlug}`).digest("hex");
+    return (0, import_crypto7.createHmac)("sha256", this.opts.controlToken).update(`mcp:${spaceSlug}`).digest("hex");
   }
   /** MCP bridge for a space. Null until the service is up (which it kicks
    *  off), so a bad :0 URL is never baked in; provisionMcpLane re-runs. */
@@ -21661,7 +22391,7 @@ var IndexService = class {
     const log = await this.openLog();
     this.proc = (0, import_child_process5.spawn)(
       process.execPath,
-      [(0, import_path14.join)(this.opts.indexDir, "index.js")],
+      [(0, import_path16.join)(this.opts.indexDir, "index.js")],
       {
         cwd: this.opts.indexDir,
         env: {
@@ -21689,8 +22419,8 @@ var IndexService = class {
    *  opened (a missing log must never stop the service from starting). */
   async openLog() {
     try {
-      await import_promises9.default.mkdir(this.opts.dataDir, { recursive: true });
-      return (0, import_fs4.openSync)((0, import_path14.join)(this.opts.dataDir, "index.log"), "a");
+      await import_promises11.default.mkdir(this.opts.dataDir, { recursive: true });
+      return (0, import_fs5.openSync)((0, import_path16.join)(this.opts.dataDir, "index.log"), "a");
     } catch {
       return null;
     }
@@ -21699,10 +22429,10 @@ var IndexService = class {
    *  platform needing node-gyp fails here rather than at query time. */
   async installDeps() {
     const dir = this.opts.indexDir;
-    if ((0, import_fs4.existsSync)((0, import_path14.join)(dir, "node_modules"))) return;
-    await import_promises9.default.copyFile(
-      (0, import_path14.join)(dir, "image-package.json"),
-      (0, import_path14.join)(dir, "package.json")
+    if ((0, import_fs5.existsSync)((0, import_path16.join)(dir, "node_modules"))) return;
+    await import_promises11.default.copyFile(
+      (0, import_path16.join)(dir, "image-package.json"),
+      (0, import_path16.join)(dir, "package.json")
     );
     await execFileAsync4(
       "npm",
@@ -21714,15 +22444,15 @@ var IndexService = class {
    *  CLIs' persistent MCP config, so a fresh port each start would leave every
    *  registration pointing at a dead one. */
   async stablePort() {
-    const file = (0, import_path14.join)(this.opts.dataDir, ".port");
-    const saved = Number(await import_promises9.default.readFile(file, "utf-8").catch(() => ""));
+    const file = (0, import_path16.join)(this.opts.dataDir, ".port");
+    const saved = Number(await import_promises11.default.readFile(file, "utf-8").catch(() => ""));
     if (Number.isInteger(saved) && saved > 0 && await isFree(saved)) {
       return saved;
     }
     const port = await freePort();
-    await import_promises9.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
+    await import_promises11.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
     });
-    await import_promises9.default.writeFile(file, String(port), "utf-8").catch(() => {
+    await import_promises11.default.writeFile(file, String(port), "utf-8").catch(() => {
     });
     return port;
   }
@@ -21889,24 +22619,24 @@ async function pairWithBrowser(serverUrl) {
 }
 
 // src/config.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 var import_os6 = __toESM(require("os"));
-var import_path19 = __toESM(require("path"));
+var import_path21 = __toESM(require("path"));
 
 // src/secureFile.ts
-var import_crypto8 = __toESM(require("crypto"));
-var import_fs7 = __toESM(require("fs"));
-var import_path18 = __toESM(require("path"));
+var import_crypto10 = __toESM(require("crypto"));
+var import_fs8 = __toESM(require("fs"));
+var import_path20 = __toESM(require("path"));
 
 // src/keychain.ts
 var import_child_process7 = require("child_process");
-var import_crypto6 = __toESM(require("crypto"));
-var import_fs5 = __toESM(require("fs"));
+var import_crypto8 = __toESM(require("crypto"));
+var import_fs6 = __toESM(require("fs"));
 var import_os4 = __toESM(require("os"));
-var import_path15 = __toESM(require("path"));
+var import_path17 = __toESM(require("path"));
 var SERVICE = "factiii-runner";
 var ACCOUNT = "config-encryption-key";
-var DPAPI_KEY_FILE = import_path15.default.join(
+var DPAPI_KEY_FILE = import_path17.default.join(
   import_os4.default.homedir(),
   ".factiii-runner",
   "config-key.dpapi"
@@ -21987,7 +22717,7 @@ function linuxWrite(key) {
 function winRead() {
   let wrapped;
   try {
-    wrapped = import_fs5.default.readFileSync(DPAPI_KEY_FILE, "utf-8").trim();
+    wrapped = import_fs6.default.readFileSync(DPAPI_KEY_FILE, "utf-8").trim();
   } catch {
     return { state: "missing" };
   }
@@ -22012,8 +22742,8 @@ function winWrite(key) {
     "-Command",
     `ConvertTo-SecureString -String '${key.toString("base64")}' -AsPlainText -Force | ConvertFrom-SecureString`
   ]);
-  import_fs5.default.mkdirSync(import_path15.default.dirname(DPAPI_KEY_FILE), { recursive: true });
-  import_fs5.default.writeFileSync(DPAPI_KEY_FILE, `${out.trim()}
+  import_fs6.default.mkdirSync(import_path17.default.dirname(DPAPI_KEY_FILE), { recursive: true });
+  import_fs6.default.writeFileSync(DPAPI_KEY_FILE, `${out.trim()}
 `, { mode: 384 });
 }
 function keychainBackend() {
@@ -22152,7 +22882,7 @@ function resolve() {
       cached = { key: null, status: diagnose() };
       return cached;
     }
-    const fresh = import_crypto6.default.randomBytes(32);
+    const fresh = import_crypto8.default.randomBytes(32);
     writeKey(fresh);
     const verify = readKey();
     if (verify.state !== "found" || !verify.key.equals(fresh)) {
@@ -22174,23 +22904,23 @@ function keychainStatus() {
 }
 
 // src/secureStore.ts
-var import_crypto7 = __toESM(require("crypto"));
-var import_fs6 = __toESM(require("fs"));
-var import_path17 = __toESM(require("path"));
+var import_crypto9 = __toESM(require("crypto"));
+var import_fs7 = __toESM(require("fs"));
+var import_path19 = __toESM(require("path"));
 
 // src/paths.ts
 var import_os5 = __toESM(require("os"));
-var import_path16 = __toESM(require("path"));
-var CONFIG_DIR = import_path16.default.join(import_os5.default.homedir(), ".factiii-runner");
+var import_path18 = __toESM(require("path"));
+var CONFIG_DIR = import_path18.default.join(import_os5.default.homedir(), ".factiii-runner");
 function safeSlug(spaceSlug) {
   return spaceSlug.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
 function spaceDirPath(spaceSlug) {
-  return import_path16.default.join(CONFIG_DIR, safeSlug(spaceSlug));
+  return import_path18.default.join(CONFIG_DIR, safeSlug(spaceSlug));
 }
 
 // src/secureStore.ts
-var VAULT_KEY_FILE = import_path17.default.join(CONFIG_DIR, "vault-key.json");
+var VAULT_KEY_FILE = import_path19.default.join(CONFIG_DIR, "vault-key.json");
 var SCRYPT_N2 = 1 << 15;
 var MIN_PASSWORD_LENGTH = 8;
 var SecureStoreError = class extends Error {
@@ -22217,7 +22947,7 @@ function requireKeychainKey() {
   );
 }
 function passwordKey(password, salt) {
-  return import_crypto7.default.scryptSync(password, salt, 32, {
+  return import_crypto9.default.scryptSync(password, salt, 32, {
     N: SCRYPT_N2,
     maxmem: 64 * 1024 * 1024
   });
@@ -22225,7 +22955,7 @@ function passwordKey(password, salt) {
 function wrapKey(machineKey, pwKey) {
   const ikm = pwKey ? Buffer.concat([machineKey, pwKey]) : machineKey;
   return Buffer.from(
-    import_crypto7.default.hkdfSync(
+    import_crypto9.default.hkdfSync(
       "sha256",
       ikm,
       Buffer.alloc(0),
@@ -22235,8 +22965,8 @@ function wrapKey(machineKey, pwKey) {
   );
 }
 function seal(plaintext, key) {
-  const iv = import_crypto7.default.randomBytes(12);
-  const cipher = import_crypto7.default.createCipheriv("aes-256-gcm", key, iv);
+  const iv = import_crypto9.default.randomBytes(12);
+  const cipher = import_crypto9.default.createCipheriv("aes-256-gcm", key, iv);
   const data = Buffer.concat([cipher.update(plaintext), cipher.final()]);
   return {
     iv: iv.toString("base64"),
@@ -22246,7 +22976,7 @@ function seal(plaintext, key) {
 }
 function unseal(box, key) {
   try {
-    const decipher = import_crypto7.default.createDecipheriv(
+    const decipher = import_crypto9.default.createDecipheriv(
       "aes-256-gcm",
       key,
       Buffer.from(box.iv, "base64")
@@ -22263,7 +22993,7 @@ function unseal(box, key) {
 function readVaultFile() {
   try {
     const parsed = JSON.parse(
-      import_fs6.default.readFileSync(VAULT_KEY_FILE, "utf-8")
+      import_fs7.default.readFileSync(VAULT_KEY_FILE, "utf-8")
     );
     return parsed.v === 1 ? parsed : null;
   } catch {
@@ -22271,15 +23001,15 @@ function readVaultFile() {
   }
 }
 function writeVaultFile(file) {
-  import_fs6.default.mkdirSync(CONFIG_DIR, { recursive: true });
+  import_fs7.default.mkdirSync(CONFIG_DIR, { recursive: true });
   const tmp = `${VAULT_KEY_FILE}.${process.pid}.tmp`;
-  import_fs6.default.writeFileSync(tmp, `${JSON.stringify(file, null, 2)}
+  import_fs7.default.writeFileSync(tmp, `${JSON.stringify(file, null, 2)}
 `, { mode: 384 });
-  import_fs6.default.renameSync(tmp, VAULT_KEY_FILE);
+  import_fs7.default.renameSync(tmp, VAULT_KEY_FILE);
 }
 var unlockedDek = null;
 function createVault(machineKey) {
-  const dek = import_crypto7.default.randomBytes(32);
+  const dek = import_crypto9.default.randomBytes(32);
   writeVaultFile({
     v: 1,
     passwordEnabled: false,
@@ -22374,7 +23104,7 @@ function enablePassword(password) {
     );
   }
   const dek = dataKey();
-  const salt = import_crypto7.default.randomBytes(16);
+  const salt = import_crypto9.default.randomBytes(16);
   writeVaultFile({
     v: 1,
     passwordEnabled: true,
@@ -22402,7 +23132,7 @@ function changePassword(current, next) {
       "The current password is not correct."
     );
   }
-  const salt = import_crypto7.default.randomBytes(16);
+  const salt = import_crypto9.default.randomBytes(16);
   writeVaultFile({
     v: 1,
     passwordEnabled: true,
@@ -22479,8 +23209,8 @@ function storeStatus() {
 // src/secureFile.ts
 var MAGIC = "FACTIII1";
 function encrypt(plain, key, version) {
-  const iv = import_crypto8.default.randomBytes(12);
-  const cipher = import_crypto8.default.createCipheriv("aes-256-gcm", key, iv);
+  const iv = import_crypto10.default.randomBytes(12);
+  const cipher = import_crypto10.default.createCipheriv("aes-256-gcm", key, iv);
   const data = Buffer.concat([cipher.update(plain), cipher.final()]);
   const envelope = {
     v: version,
@@ -22491,7 +23221,7 @@ function encrypt(plain, key, version) {
   return `${MAGIC}${JSON.stringify(envelope)}`;
 }
 function decrypt(envelope, key) {
-  const decipher = import_crypto8.default.createDecipheriv(
+  const decipher = import_crypto10.default.createDecipheriv(
     "aes-256-gcm",
     key,
     Buffer.from(envelope.iv, "base64")
@@ -22512,15 +23242,15 @@ function parseEnvelope(raw) {
   }
 }
 function atomicWrite(filePath, body) {
-  import_fs7.default.mkdirSync(import_path18.default.dirname(filePath), { recursive: true });
+  import_fs8.default.mkdirSync(import_path20.default.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.tmp`;
-  import_fs7.default.writeFileSync(tmp, body, { mode: 384 });
-  import_fs7.default.renameSync(tmp, filePath);
+  import_fs8.default.writeFileSync(tmp, body, { mode: 384 });
+  import_fs8.default.renameSync(tmp, filePath);
 }
 function readSecureBuffer(filePath) {
   let raw;
   try {
-    raw = import_fs7.default.readFileSync(filePath, "utf-8");
+    raw = import_fs8.default.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -22577,7 +23307,7 @@ function writeSecureJson(filePath, value2) {
 function readBootJson(filePath) {
   let raw;
   try {
-    raw = import_fs7.default.readFileSync(filePath, "utf-8");
+    raw = import_fs8.default.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -22627,8 +23357,8 @@ function writeBootJson(filePath, value2) {
 }
 
 // src/config.ts
-var CONFIG_DIR2 = import_path19.default.join(import_os6.default.homedir(), ".factiii-runner");
-var CONFIG_FILE = import_path19.default.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = import_path21.default.join(import_os6.default.homedir(), ".factiii-runner");
+var CONFIG_FILE = import_path21.default.join(CONFIG_DIR2, "config.json");
 function readRunnerConfig() {
   return readBootJson(CONFIG_FILE);
 }
@@ -22636,7 +23366,7 @@ function writeRunnerConfig(config) {
   writeBootJson(CONFIG_FILE, config);
 }
 function configExists() {
-  return import_fs8.default.existsSync(CONFIG_FILE);
+  return import_fs9.default.existsSync(CONFIG_FILE);
 }
 
 // src/promptPassword.ts
@@ -22735,72 +23465,24 @@ function installLatest() {
     stdio: "inherit",
     // On Windows npm is npm.cmd, which spawnSync can't exec without a shell.
     shell: process.platform === "win32"
-  });
-  if (res.status !== 0) {
-    console.error(
-      `[update] npm install failed (exit ${res.status ?? "signal"}). Staying on ${currentVersion()}.`
-    );
-    return false;
-  }
-  return true;
-}
-
-// src/supervisor.ts
-var import_node_child_process2 = require("node:child_process");
-
-// ../../shared/all/helpers/wireChunk.ts
-var MAX_INLINE_BYTES = 14e3;
-var chunkCounter = 0;
-function nextChunkId() {
-  return `c-${++chunkCounter}-${Date.now()}`;
-}
-function chunkWire(wire) {
-  if (wire.length <= MAX_INLINE_BYTES) return [wire];
-  const id = nextChunkId();
-  const total = Math.ceil(wire.length / MAX_INLINE_BYTES);
-  const frames = [];
-  for (let i = 0; i < total; i++) {
-    const start = i * MAX_INLINE_BYTES;
-    const slice = wire.slice(start, start + MAX_INLINE_BYTES);
-    const frame = { __c: id, __i: i, __n: total, d: slice };
-    frames.push(JSON.stringify(frame));
+  });
+  if (res.status !== 0) {
+    console.error(
+      `[update] npm install failed (exit ${res.status ?? "signal"}). Staying on ${currentVersion()}.`
+    );
+    return false;
   }
-  return frames;
-}
-function makeChunkReassembler() {
-  const buffers = /* @__PURE__ */ new Map();
-  return {
-    feed(raw) {
-      if (!raw.startsWith('{"__c"')) return raw;
-      let frame;
-      try {
-        frame = JSON.parse(raw);
-      } catch {
-        return raw;
-      }
-      if (typeof frame.__c !== "string" || typeof frame.__i !== "number" || typeof frame.__n !== "number" || typeof frame.d !== "string") {
-        return raw;
-      }
-      let buf = buffers.get(frame.__c);
-      if (!buf) {
-        buf = { received: new Array(frame.__n), total: frame.__n };
-        buffers.set(frame.__c, buf);
-      }
-      buf.received[frame.__i] = frame.d;
-      for (let i = 0; i < buf.total; i++) {
-        if (buf.received[i] === void 0) return null;
-      }
-      buffers.delete(frame.__c);
-      return buf.received.join("");
-    }
-  };
+  return true;
 }
 
+// src/supervisor.ts
+var import_node_child_process2 = require("node:child_process");
+
 // src/daemon.ts
-var import_crypto9 = require("crypto");
-var import_fs10 = __toESM(require("fs"));
+var import_crypto11 = require("crypto");
+var import_fs11 = __toESM(require("fs"));
 var import_node_datachannel = require("node-datachannel");
-var import_path21 = __toESM(require("path"));
+var import_path23 = __toESM(require("path"));
 
 // ../../node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
 var XMLHttpRequestModule = __toESM(require_XMLHttpRequest(), 1);
@@ -23980,12 +24662,12 @@ function parse2(str) {
   uri.queryKey = queryKey(uri, uri["query"]);
   return uri;
 }
-function pathNames(obj, path21) {
-  const regx = /\/{2,9}/g, names = path21.replace(regx, "/").split("/");
-  if (path21.slice(0, 1) == "/" || path21.length === 0) {
+function pathNames(obj, path23) {
+  const regx = /\/{2,9}/g, names = path23.replace(regx, "/").split("/");
+  if (path23.slice(0, 1) == "/" || path23.length === 0) {
     names.splice(0, 1);
   }
-  if (path21.slice(-1) == "/") {
+  if (path23.slice(-1) == "/") {
     names.splice(names.length - 1, 1);
   }
   return names;
@@ -24604,7 +25286,7 @@ var protocol2 = Socket.protocol;
 // ../../node_modules/socket.io-client/build/esm-debug/url.js
 var import_debug7 = __toESM(require_src(), 1);
 var debug7 = (0, import_debug7.default)("socket.io-client:url");
-function url(uri, path21 = "", loc) {
+function url(uri, path23 = "", loc) {
   let obj = uri;
   loc = loc || typeof location !== "undefined" && location;
   if (null == uri)
@@ -24638,7 +25320,7 @@ function url(uri, path21 = "", loc) {
   obj.path = obj.path || "/";
   const ipv6 = obj.host.indexOf(":") !== -1;
   const host = ipv6 ? "[" + obj.host + "]" : obj.host;
-  obj.id = obj.protocol + "://" + host + ":" + obj.port + path21;
+  obj.id = obj.protocol + "://" + host + ":" + obj.port + path23;
   obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
   return obj;
 }
@@ -26272,8 +26954,8 @@ function lookup(uri, opts) {
   const parsed = url(uri, opts.path || "/socket.io");
   const source = parsed.source;
   const id = parsed.id;
-  const path21 = parsed.path;
-  const sameNamespace = cache[id] && path21 in cache[id]["nsps"];
+  const path23 = parsed.path;
+  const sameNamespace = cache[id] && path23 in cache[id]["nsps"];
   const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
   let io;
   if (newConnection) {
@@ -26298,205 +26980,22 @@ Object.assign(lookup, {
   connect: lookup
 });
 
-// ../../shared/all/helpers/terminal-ai/terminal.ts
-function terminalPrelude(cwd, binDir) {
-  return [
-    // cd in-script, falling back to $HOME. Must match the agent's worktree:
-    // the CLIs key transcripts by cwd, so --resume needs it.
-    `cd ${cwd} 2>/dev/null || cd "$HOME" 2>/dev/null || cd /`,
-    // Prepended here rather than via the session env, so the login shell's
-    // own PATH survives.
-    `export PATH="${binDir}:$PATH"`,
-    `export PS1='\\[\\e[1;32m\\]user@bare\\[\\e[0m\\]:\\w\\$ '`
-  ].join("; ");
-}
-var SAFE_SESSION_ID = /^[a-zA-Z0-9_-]{1,128}$/;
-function cardContextPath(target, postId) {
-  const safe = postId.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80) || "card";
-  return `${target.paths.root}/.cards/${safe}.md`;
-}
-function cardContextPrompt(path21) {
-  return `Read ${path21} - it is the Factiii card this session was opened from. Use it as the context and start working on it.`;
-}
-var CLAUDE_PERMISSION_MODE = `--permission-mode auto`;
-var RESUME_SEED = "You are now in an interactive terminal, not the board UI. Respond in plain text and use your normal tools; do not use openui-lang or component schemas anymore.";
-function terminalInitScript(cwd, binDir, resumeAgentSessionId, provider, cardFile) {
-  const prelude = terminalPrelude(cwd, binDir);
-  const shell = `exec bash --norc -i`;
-  if (!resumeAgentSessionId || !SAFE_SESSION_ID.test(resumeAgentSessionId)) {
-    if (!cardFile) return `${prelude}; ${shell}`;
-    const prompt2 = cardContextPrompt(cardFile);
-    const start = provider === "codex" ? `codex '${prompt2}'` : `claude ${CLAUDE_PERMISSION_MODE} '${prompt2}'`;
-    return `${prelude}; ${start}; ${shell}`;
-  }
-  const resume = provider === "codex" ? `codex resume ${resumeAgentSessionId} '${RESUME_SEED}'` : `claude ${CLAUDE_PERMISSION_MODE} --resume ${resumeAgentSessionId} '${RESUME_SEED}'`;
-  return `${prelude}; ${resume}; ${shell}`;
+// src/agent-adapter.ts
+var import_fs10 = __toESM(require("fs"));
+var import_path22 = __toESM(require("path"));
+function credsDir(spaceSlug) {
+  return import_path22.default.join(spaceDirPath(spaceSlug), ".creds");
 }
-function tmuxName(terminalKey) {
-  return `terminal-${safeTmuxName(terminalKey)}`;
+function githubPath(spaceSlug) {
+  return import_path22.default.join(credsDir(spaceSlug), "github.json");
 }
-var TerminalManager = class {
-  constructor(send, getCardTarget, getCardWorkdir) {
-    this.send = send;
-    this.getCardTarget = getCardTarget;
-    this.getCardWorkdir = getCardWorkdir;
-    this.sessions = /* @__PURE__ */ new Map();
-  }
-  handle(msg) {
-    switch (msg.op) {
-      case "open":
-        void this.open(msg);
-        return;
-      case "stdin":
-        this.stdin(msg.sessionId, msg.data);
-        return;
-      case "resize":
-        void this.resize(msg.sessionId, msg.cols, msg.rows);
-        return;
-      case "close":
-        this.close(msg.sessionId);
-        return;
-      case "kill":
-        void this.killTmuxSession(msg.postId, msg.terminalKey);
-        return;
-    }
-  }
-  async open(msg) {
-    if (this.sessions.has(msg.sessionId)) {
-      this.emitError(msg.sessionId, "Session already open.");
-      return;
-    }
-    const target = this.getCardTarget(msg.postId);
-    if (!target) {
-      this.emitError(
-        msg.sessionId,
-        `No active card session for postId=${msg.postId}.`
-      );
-      return;
-    }
-    const tmuxSession = tmuxName(msg.terminalKey);
-    const wantsCardContext = !msg.resumeAgentSessionId && !!msg.cardContext;
-    const cardFile = wantsCardContext ? cardContextPath(target, msg.postId) : void 0;
-    let wroteCardFile = false;
-    if (cardFile) {
-      wroteCardFile = await target.writeFile(cardFile, msg.cardContext).then(() => true).catch(() => false);
-    }
-    try {
-      const session = await startTmuxSession({
-        target,
-        session: tmuxSession,
-        // Attach if it exists, else create. This is what makes the shell
-        // survive modal close/reopen: the server holds it, we just view.
-        attachExisting: true,
-        size: { cols: msg.cols, rows: msg.rows },
-        // Without these, `claude` in the shell reads the default ~/.claude and
-        // asks to sign in, while the agent spawns (which pass agentEnv) don't.
-        env: target.stateEnv(),
-        argv: [
-          "bash",
-          "-c",
-          terminalInitScript(
-            this.getCardWorkdir(msg.postId) || target.paths.workspace,
-            target.paths.bin,
-            msg.resumeAgentSessionId,
-            msg.resumeProvider,
-            wroteCardFile ? cardFile : void 0
-          )
-        ]
-      });
-      this.sessions.set(msg.sessionId, session);
-      session.onData(
-        (data) => this.emit({
-          type: "terminal",
-          op: "stdout",
-          sessionId: msg.sessionId,
-          data: data.toString("base64")
-        })
-      );
-      session.onError((err) => {
-        this.cleanup(msg.sessionId);
-        this.emitError(msg.sessionId, err.message);
-      });
-      session.onClose((code) => {
-        if (!this.sessions.has(msg.sessionId)) return;
-        this.cleanup(msg.sessionId);
-        this.emit({
-          type: "terminal",
-          op: "exit",
-          sessionId: msg.sessionId,
-          code
-        });
-      });
-      this.emit({ type: "terminal", op: "opened", sessionId: msg.sessionId });
-    } catch (err) {
-      this.emitError(
-        msg.sessionId,
-        err instanceof Error ? err.message : String(err)
-      );
-    }
-  }
-  stdin(sessionId, b64) {
-    this.sessions.get(sessionId)?.write(Buffer.from(b64, "base64"));
-  }
-  async resize(sessionId, cols, rows) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    if (!Number.isInteger(cols) || !Number.isInteger(rows)) return;
-    if (cols < 1 || rows < 1) return;
-    await session.resize(cols, rows).catch(() => {
-    });
-  }
-  close(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    this.sessions.delete(sessionId);
-    session.detach();
-  }
-  /** Tear down the tmux session for a tab. Used when the user explicitly
-   *  removes a tab (the X button), not on transient detach. */
-  async killTmuxSession(postId, terminalKey) {
-    const target = this.getCardTarget(postId);
-    if (!target) return;
-    await target.sh(
-      `${tmuxCli(target)} kill-session -t ${tmuxName(terminalKey)} 2>/dev/null || true`
-    ).catch(() => {
-    });
-  }
-  destroyAll() {
-    for (const sessionId of [...this.sessions.keys()]) {
-      this.close(sessionId);
-    }
-  }
-  cleanup(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  emitError(sessionId, message) {
-    this.emit({ type: "terminal", op: "error", sessionId, message });
-  }
-  emit(msg) {
-    const wire = JSON.stringify(msg);
-    for (const frame of chunkWire(wire)) this.send(frame);
-  }
-};
-
-// src/agent-adapter.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path20 = __toESM(require("path"));
-var RUNNER_CONFIG_PATH = import_path20.default.join(CONFIG_DIR, "runner-config.json");
 function connectionPath(spaceSlug) {
-  return import_path20.default.join(CONFIG_DIR, `space-${safeSlug(spaceSlug)}.onedrive.json`);
+  return import_path22.default.join(credsDir(spaceSlug), "onedrive.json");
 }
+var RUNNER_CONFIG_PATH = import_path22.default.join(CONFIG_DIR, "runner-config.json");
 function writeJson(filePath, value2) {
   writeSecureJson(filePath, value2);
 }
-var CONFIG_FIELDS = [
-  "repoUrl",
-  "mainBranch",
-  "gitName",
-  "gitEmail",
-  "githubToken",
-  "provider"
-];
 function fillDefaults(config) {
   return {
     repoUrl: config.repoUrl || "",
@@ -26507,29 +27006,107 @@ function fillDefaults(config) {
     provider: config.provider || "claude"
   };
 }
-function migrateLegacyConfigs() {
-  const file = { boards: {} };
-  let legacy = [];
+function configDirNames() {
+  try {
+    return import_fs10.default.readdirSync(CONFIG_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function provisionedSpaceSlugs() {
+  return configDirNames().filter(
+    (name) => import_fs10.default.existsSync(import_path22.default.join(CONFIG_DIR, name, "bin"))
+  );
+}
+var migrated = false;
+function migrateToSpaceFolders() {
+  if (migrated) return;
+  migrated = true;
+  try {
+    migrateOnce();
+  } catch {
+    migrated = false;
+  }
+}
+function readLegacy(filePath) {
+  if (!import_fs10.default.existsSync(filePath)) return { readable: true, value: null };
+  const value2 = readSecureJson(filePath);
+  return { readable: value2 !== null, value: value2 };
+}
+function migrateOnce() {
+  const legacy = readLegacy(RUNNER_CONFIG_PATH);
+  if (!legacy.readable) {
+    throw new Error(
+      `Cannot read ${RUNNER_CONFIG_PATH} \u2014 leaving the legacy stores in place.`
+    );
+  }
+  const store = legacy.value ?? {};
+  const base = store.default ?? {};
+  const boards = store.boards ?? {};
+  const strays = {};
+  const consumed = [];
+  let strayFiles = [];
   try {
-    legacy = import_fs9.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".json")).filter((f) => !f.endsWith(".onedrive.json"));
+    strayFiles = import_fs10.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".json")).filter((f) => !f.endsWith(".onedrive.json"));
   } catch {
-    return file;
+    strayFiles = [];
   }
-  for (const name of legacy) {
+  for (const name of strayFiles) {
     const slug = name.slice("space-".length, -".json".length);
-    const parsed = readSecureJson(
-      import_path20.default.join(CONFIG_DIR, name)
+    const parsed = readLegacy(
+      import_path22.default.join(CONFIG_DIR, name)
     );
-    if (!parsed) continue;
-    if (!file.defaultSlug) {
-      file.defaultSlug = slug;
-      file.default = parsed;
-    } else {
-      file.boards[slug] = parsed;
+    if (!parsed.readable) continue;
+    if (parsed.value) strays[slug] = parsed.value;
+    consumed.push(name);
+  }
+  const slugs = /* @__PURE__ */ new Set([
+    ...Object.keys(boards),
+    ...Object.keys(strays),
+    ...store.defaultSlug ? [store.defaultSlug] : [],
+    ...provisionedSpaceSlugs()
+  ]);
+  for (const slug of slugs) {
+    if (import_fs10.default.existsSync(githubPath(slug))) continue;
+    const over = boards[slug] ?? strays[slug] ?? {};
+    if (!Object.keys(over).length && !Object.keys(base).length) continue;
+    const merged = fillDefaults({
+      repoUrl: over.repoUrl || base.repoUrl,
+      mainBranch: over.mainBranch || base.mainBranch,
+      gitName: over.gitName || base.gitName,
+      gitEmail: over.gitEmail || base.gitEmail,
+      githubToken: over.githubToken || base.githubToken,
+      provider: over.provider || base.provider
+    });
+    import_fs10.default.mkdirSync(credsDir(slug), { recursive: true });
+    writeJson(githubPath(slug), merged);
+  }
+  let odFiles = [];
+  try {
+    odFiles = import_fs10.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".onedrive.json"));
+  } catch {
+    odFiles = [];
+  }
+  for (const name of odFiles) {
+    const slug = name.slice("space-".length, -".onedrive.json".length);
+    if (import_fs10.default.existsSync(connectionPath(slug))) {
+      consumed.push(name);
+      continue;
+    }
+    const conn = readLegacy(import_path22.default.join(CONFIG_DIR, name));
+    if (!conn.readable) continue;
+    if (conn.value) {
+      import_fs10.default.mkdirSync(credsDir(slug), { recursive: true });
+      writeJson(connectionPath(slug), conn.value);
+    }
+    consumed.push(name);
+  }
+  for (const name of [...consumed, "runner-config.json"]) {
+    try {
+      import_fs10.default.rmSync(import_path22.default.join(CONFIG_DIR, name), { force: true });
+    } catch {
     }
   }
-  if (file.defaultSlug) writeJson(RUNNER_CONFIG_PATH, file);
-  return file;
 }
 var sweptStrays = false;
 function encryptStrayPlaintextConfigs() {
@@ -26538,14 +27115,14 @@ function encryptStrayPlaintextConfigs() {
   const OURS = /^(config|runner-config|space-.*)\.json(\.bak-\d+)?$/;
   let names = [];
   try {
-    names = import_fs9.default.readdirSync(CONFIG_DIR).filter((f) => OURS.test(f));
+    names = import_fs10.default.readdirSync(CONFIG_DIR).filter((f) => OURS.test(f));
   } catch {
     return;
   }
   for (const name of names) {
-    const filePath = import_path20.default.join(CONFIG_DIR, name);
+    const filePath = import_path22.default.join(CONFIG_DIR, name);
     try {
-      const raw = import_fs9.default.readFileSync(filePath, "utf-8");
+      const raw = import_fs10.default.readFileSync(filePath, "utf-8");
       if (!raw.startsWith("{")) continue;
       writeSecureJson(filePath, JSON.parse(raw));
     } catch {
@@ -26557,84 +27134,50 @@ function encryptStrayPlaintextConfigs() {
 function resetStraySweep() {
   sweptStrays = false;
 }
-function readRunnerConfig2() {
+function readBoard(spaceSlug) {
   encryptStrayPlaintextConfigs();
-  const file = readSecureJson(RUNNER_CONFIG_PATH);
-  return file ?? migrateLegacyConfigs();
+  migrateToSpaceFolders();
+  return readSecureJson(githubPath(spaceSlug)) ?? {};
 }
 async function getConfiguredConnections() {
   const kinds = /* @__PURE__ */ new Set();
-  let file;
   try {
-    file = readRunnerConfig2();
+    for (const slug of listConfiguredSlugs()) {
+      if (kinds.has("git") && kinds.has("onedrive")) break;
+      if (readBoard(slug).githubToken) kinds.add("git");
+      if (import_fs10.default.existsSync(connectionPath(slug))) kinds.add("onedrive");
+    }
   } catch {
     return [];
   }
-  const configs = [file.default ?? {}, ...Object.values(file.boards ?? {})];
-  for (const c of configs) {
-    if (c.githubToken) kinds.add("git");
-  }
   if (await isSignedIn(hostTarget(CONFIG_DIR), "claude")) kinds.add("claude");
-  try {
-    const hasOneDrive = import_fs9.default.readdirSync(CONFIG_DIR).some((f) => f.endsWith(".onedrive.json"));
-    if (hasOneDrive) kinds.add("onedrive");
-  } catch {
-  }
   return [...kinds];
 }
 function listConfiguredSlugs() {
   try {
-    const file = readRunnerConfig2();
-    return [
-      .../* @__PURE__ */ new Set([
-        ...Object.keys(file.boards ?? {}),
-        ...file.defaultSlug ? [file.defaultSlug] : []
-      ])
-    ];
+    migrateToSpaceFolders();
+    return configDirNames().filter(
+      (slug) => import_fs10.default.existsSync(githubPath(slug)) || import_fs10.default.existsSync(connectionPath(slug))
+    );
   } catch {
     return [];
   }
 }
 var localConfigProvider = {
   readConfig(spaceSlug) {
-    let file;
     try {
-      file = readRunnerConfig2();
+      return fillDefaults(readBoard(spaceSlug));
     } catch (err) {
       if (!isSecureStoreError(err)) throw err;
       return fillDefaults({});
     }
-    const base = file.default ?? {};
-    const over = file.boards?.[spaceSlug] ?? {};
-    return fillDefaults({
-      repoUrl: over.repoUrl || base.repoUrl,
-      mainBranch: over.mainBranch || base.mainBranch,
-      gitName: over.gitName || base.gitName,
-      gitEmail: over.gitEmail || base.gitEmail,
-      githubToken: over.githubToken || base.githubToken,
-      provider: over.provider || base.provider
-    });
   },
+  // The whole config, every time: a cleared field has to persist as cleared,
+  // which is what makes disconnect stick.
   writeConfig(spaceSlug, config) {
-    const file = readRunnerConfig2();
-    file.boards ??= {};
-    if (!file.defaultSlug) {
-      file.defaultSlug = spaceSlug;
-      file.default = config;
-    } else if (spaceSlug === file.defaultSlug) {
-      file.default = config;
-    } else {
-      const base = file.default ?? {};
-      const diff = {};
-      for (const f of CONFIG_FIELDS) {
-        if (config[f] && config[f] !== base[f]) {
-          diff[f] = config[f];
-        }
-      }
-      if (Object.keys(diff).length) file.boards[spaceSlug] = diff;
-      else delete file.boards[spaceSlug];
-    }
-    writeJson(RUNNER_CONFIG_PATH, file);
+    migrateToSpaceFolders();
+    import_fs10.default.mkdirSync(credsDir(spaceSlug), { recursive: true });
+    writeJson(githubPath(spaceSlug), config);
   },
   readOneDriveConnection(spaceSlug) {
     try {
@@ -26647,7 +27190,7 @@ var localConfigProvider = {
   writeOneDriveConnection(spaceSlug, connection) {
     const filePath = connectionPath(spaceSlug);
     if (!connection) {
-      import_fs9.default.rmSync(filePath, { force: true });
+      import_fs10.default.rmSync(filePath, { force: true });
       return;
     }
     writeJson(filePath, connection);
@@ -26672,7 +27215,7 @@ var localConfigProvider = {
       "claude",
       "codex"
     ]) {
-      import_fs9.default.mkdirSync(import_path20.default.join(dir, sub), { recursive: true });
+      import_fs10.default.mkdirSync(import_path22.default.join(dir, sub), { recursive: true });
     }
     return dir;
   }
@@ -26846,15 +27389,15 @@ async function startDaemon(config) {
     }
   );
   const indexCandidates = [
-    import_path21.default.join(__dirname, "..", "index"),
-    import_path21.default.join(__dirname, "..", "..", "index", "image")
+    import_path23.default.join(__dirname, "..", "index"),
+    import_path23.default.join(__dirname, "..", "..", "index", "image")
   ];
-  const indexDir = indexCandidates.find((p) => import_fs10.default.existsSync(p)) ?? indexCandidates[0];
+  const indexDir = indexCandidates.find((p) => import_fs11.default.existsSync(p)) ?? indexCandidates[0];
   const odIndex = new IndexService({
-    controlToken: (0, import_crypto9.createHash)("sha256").update(config.authToken).digest("hex"),
+    controlToken: (0, import_crypto11.createHash)("sha256").update(config.authToken).digest("hex"),
     embedUrl: () => config.serverUrl,
     indexDir,
-    dataDir: import_path21.default.join(CONFIG_DIR, "index-data")
+    dataDir: import_path23.default.join(CONFIG_DIR, "index-data")
   });
   void odIndex.ensureRunning().catch((err) => {
     console.error(
@@ -26951,7 +27494,9 @@ async function startDaemon(config) {
         // Board MCP is server-hosted, so the base URL is all it needs.
         serverUrl: config.serverUrl,
         // Point the agent at the index MCP endpoint (lazy for the port).
-        mcp: () => odIndex.mcpBridge(spaceSlug)
+        mcp: () => odIndex.mcpBridge(spaceSlug),
+        // The bearer alone, available before the service has a port for a URL.
+        mcpToken: () => odIndex.bearerToken(spaceSlug)
       });
       engines.set(spaceSlug, engine);
       void engine.reattachAndHydrate();