@factiii/runner 0.10.1 → 0.10.2

package/dist/cli.js

@@ -915,18 +915,18 @@ var require_suggestSimilar = __commonJS({
       }
       return d[a.length][b.length];
     }
-    function suggestSimilar(word, candidates) {
-      if (!candidates || candidates.length === 0) return "";
-      candidates = Array.from(new Set(candidates));
+    function suggestSimilar(word, candidates2) {
+      if (!candidates2 || candidates2.length === 0) return "";
+      candidates2 = Array.from(new Set(candidates2));
       const searchingOptions = word.startsWith("--");
       if (searchingOptions) {
         word = word.slice(2);
-        candidates = candidates.map((candidate) => candidate.slice(2));
+        candidates2 = candidates2.map((candidate) => candidate.slice(2));
       }
       let similar = [];
       let bestDistance = maxDistance;
       const minSimilarity = 0.4;
-      candidates.forEach((candidate) => {
+      candidates2.forEach((candidate) => {
         if (candidate.length <= 1) return;
         const distance = editDistance(word, candidate);
         const length = Math.max(word.length, candidate.length);
@@ -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 path17 = require("node:path");
+    var path18 = require("node:path");
     var fs14 = 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 = path17.resolve(baseDir, baseName);
+          const localBin = path18.resolve(baseDir, baseName);
           if (fs14.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path17.extname(baseName))) return void 0;
+          if (sourceExt.includes(path18.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs14.existsSync(`${localBin}${ext}`)
           );
@@ -1916,17 +1916,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path17.resolve(
-            path17.dirname(resolvedScriptPath),
+          executableDir = path18.resolve(
+            path18.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path17.basename(
+            const legacyName = path18.basename(
               this._scriptPath,
-              path17.extname(this._scriptPath)
+              path18.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1937,7 +1937,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path17.extname(executableFile));
+        launchWithNode = sourceExt.includes(path18.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 = path17.basename(filename, path17.extname(filename));
+        this._name = path18.basename(filename, path18.extname(filename));
         return this;
       }
       /**
@@ -2791,9 +2791,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path18) {
-        if (path18 === void 0) return this._executableDir;
-        this._executableDir = path18;
+      executableDir(path19) {
+        if (path19 === void 0) return this._executableDir;
+        this._executableDir = path19;
         return this;
       }
       /**
@@ -3984,7 +3984,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/debug/node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os6 = require("os");
+    var os7 = require("os");
     var hasFlag = require_has_flag();
     var env = process.env;
     var forceColor;
@@ -4022,7 +4022,7 @@ var require_supports_color = __commonJS({
       }
       const min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        const osRelease = os6.release().split(".");
+        const osRelease = os7.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -8428,8 +8428,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path17, errorMaps, issueData } = params;
-  const fullPath = [...path17, ...issueData.path || []];
+  const { data, path: path18, errorMaps, issueData } = params;
+  const fullPath = [...path18, ...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, path17, key) {
+  constructor(parent, value2, path18, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value2;
-    this._path = path17;
+    this._path = path18;
     this._key = key;
   }
   get path() {
@@ -12908,7 +12908,7 @@ ${diff.slice(0, 8e3)}`,
 }
 
 // ../../shared/all/helpers/board-agent-core/engine.ts
-var import_path9 = require("path");
+var import_path10 = require("path");
 
 // ../../shared/all/domains/electron.ts
 var SETUP_LOG_PREFIX = "
log ";
@@ -13017,7 +13017,7 @@ async function ensurePrimaryClone(target, cloneUrl, branch) {
   await target.sh(`mkdir -p ${target.paths.worktrees}`);
 }
 async function addWorktree(target, workName, baseBranch, kind) {
-  const path17 = worktreeFor(target.paths, workName);
+  const path18 = worktreeFor(target.paths, workName);
   const branch = workBranch(workName, kind);
   await gitInDir(
     target,
@@ -13027,7 +13027,7 @@ async function addWorktree(target, workName, baseBranch, kind) {
     baseBranch
   ).catch(() => {
   });
-  await removeWorktree(target, path17).catch(() => {
+  await removeWorktree(target, path18).catch(() => {
   });
   await gitInDir(
     target,
@@ -13036,30 +13036,30 @@ async function addWorktree(target, workName, baseBranch, kind) {
     "add",
     "-B",
     branch,
-    path17,
+    path18,
     `origin/${baseBranch}`
   );
-  return { path: path17, branch };
+  return { path: path18, branch };
 }
-async function removeWorktree(target, path17) {
+async function removeWorktree(target, path18) {
   await gitInDir(
     target,
     target.paths.repo,
     "worktree",
     "remove",
     "--force",
-    path17
+    path18
   );
 }
-async function removeWorktreeAndBranch(target, path17) {
+async function removeWorktreeAndBranch(target, path18) {
   const branch = await gitInDir(
     target,
-    path17,
+    path18,
     "rev-parse",
     "--abbrev-ref",
     "HEAD"
   ).then((out) => out.trim()).catch(() => "");
-  await removeWorktree(target, path17);
+  await removeWorktree(target, path18);
   if (branch && branch !== "HEAD") {
     await gitInDir(target, target.paths.repo, "branch", "-D", branch).catch(
       () => {
@@ -13073,8 +13073,8 @@ async function pruneWorktrees(target) {
     }
   );
 }
-function isWorktreePath(target, path17) {
-  return path17.startsWith(`${target.paths.worktrees}/`);
+function isWorktreePath(target, path18) {
+  return path18.startsWith(`${target.paths.worktrees}/`);
 }
 async function setGitIdentity(target, name, email, workdir = target.paths.workspace) {
   if (name) await gitInDir(target, workdir, "config", "user.name", name);
@@ -13100,13 +13100,13 @@ function parseStatus(raw) {
     const y = line[1];
     const rest = line.slice(3);
     const arrow = rest.indexOf(" -> ");
-    const path17 = arrow === -1 ? rest : rest.slice(arrow + 4);
+    const path18 = arrow === -1 ? rest : rest.slice(arrow + 4);
     if (x === "?" || y === "?") {
-      unstaged.push({ path: path17, code: "A" });
+      unstaged.push({ path: path18, code: "A" });
       continue;
     }
-    if (x !== " ") staged.push({ path: path17, code: x });
-    if (y !== " ") unstaged.push({ path: path17, code: y });
+    if (x !== " ") staged.push({ path: path18, code: x });
+    if (y !== " ") unstaged.push({ path: path18, code: y });
   }
   return { staged, unstaged };
 }
@@ -13300,16 +13300,18 @@ function cardKey(postId) {
   return `card:${safeId(postId)}`;
 }
 var INDEX_KEY = "cards";
-function socketPath(target) {
+function redisSocketPath(target) {
   return `${target.paths.state}/redis.sock`;
 }
 async function redisCli(target, args) {
-  const out = await target.sh(`redis-cli -s ${socketPath(target)} ${args}`);
+  const out = await target.sh(
+    `redis-cli -s ${redisSocketPath(target)} ${args}`
+  );
   return out.replace(/\n$/, "");
 }
 function redisCliStdin(target, args, stdin) {
   return target.runWithStdin(
-    ["redis-cli", "-s", socketPath(target), "-x", ...args],
+    ["redis-cli", "-s", redisSocketPath(target), "-x", ...args],
     stdin,
     `redis-cli ${args.join(" ")}`
   );
@@ -13322,7 +13324,7 @@ async function ensureRedis(target) {
   }
   const stateDir = target.paths.state;
   await target.sh(
-    `mkdir -p ${stateDir} && redis-server --daemonize yes --appendonly yes --save '' --dir ${stateDir} --port 0 --unixsocket ${socketPath(target)} --unixsocketperm 700`
+    `mkdir -p ${stateDir} && redis-server --daemonize yes --appendonly yes --save '' --dir ${stateDir} --port 0 --unixsocket ${redisSocketPath(target)} --unixsocketperm 700`
   );
   for (let i = 0; i < 20; i += 1) {
     try {
@@ -13688,6 +13690,7 @@ function toSummary(session) {
     pendingQuestion: session.pendingQuestion,
     error: session.error,
     startedAt: session.startedAt,
+    agentState: session.agentState,
     targetBranch: session.targetBranch,
     taskTitle: session.taskTitle,
     todos: session.todos,
@@ -15917,18 +15920,18 @@ var ClaudeModeEngine = class _ClaudeModeEngine {
     await this.core.ensureSpaceWorkspace();
     await assertAgentSignedIn(session.provider, this.core.target());
     if (hasGit) {
-      const { path: path17 } = await addWorktree(
+      const { path: path18 } = await addWorktree(
         this.core.target(),
         session.taskId,
         baseBranch || config.mainBranch || "main",
         "card"
       );
-      session.workspacePath = path17;
+      session.workspacePath = path18;
       await setGitIdentity(
         this.core.target(),
         config.gitName,
         config.gitEmail,
-        path17
+        path18
       );
       this.emitter.addLog(session, "system", "Worktree ready.");
     } else {
@@ -16150,18 +16153,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: path17 } = await addWorktree(
+    const { path: path18 } = await addWorktree(
       this.core.target(),
       session.taskId,
       config.mainBranch || "main",
       "card"
     );
-    session.workspacePath = path17;
+    session.workspacePath = path18;
     await setGitIdentity(
       this.core.target(),
       config.gitName,
       config.gitEmail,
-      path17
+      path18
     );
     await this.putCard(session);
     const patchDir = `${this.core.target().paths.root}/patches/${session.taskId}`;
@@ -16456,6 +16459,50 @@ async function startTmuxSession(opts) {
   };
 }
 
+// ../../shared/all/helpers/terminal-ai/agentState.ts
+var STATES = /* @__PURE__ */ new Set(["working", "idle", "blocked"]);
+var AGENT_STATE_CHANNEL = "agent-state";
+function agentStateKey(paneId) {
+  return `agent-state:${paneId}`;
+}
+function parseAgentMessage(payload) {
+  const at = payload.indexOf(" ");
+  if (at <= 0) return null;
+  const state = parseAgentState(payload.slice(at + 1));
+  return state ? { paneId: payload.slice(0, at), state } : null;
+}
+function postIdForSessionName(sessionName, postIds) {
+  for (const postId of postIds) {
+    const prefix = `terminal-${postId.replace(/[^a-zA-Z0-9._-]/g, "_")}-`;
+    if (sessionName.startsWith(prefix)) return postId;
+  }
+  return null;
+}
+function parseAgentState(text) {
+  const word = text.trim();
+  return STATES.has(word) ? word : null;
+}
+function drainStateMessages(buffer) {
+  const lines = buffer.split("\n");
+  const partial = lines.pop() ?? "";
+  const states = [];
+  let i = 0;
+  let consumed = 0;
+  while (i < lines.length) {
+    if (lines[i] !== "message") {
+      i += 1;
+      consumed = i;
+      continue;
+    }
+    if (i + 2 >= lines.length) break;
+    const parsed = parseAgentMessage(lines[i + 2]);
+    if (parsed) states.push(parsed);
+    i += 3;
+    consumed = i;
+  }
+  return { states, rest: [...lines.slice(consumed), partial].join("\n") };
+}
+
 // ../../shared/all/helpers/terminal-ai/processes.ts
 var PS_FORMAT = "pid=,ppid=,pcpu=,rss=,etime=,args=";
 var PS_FIELDS = 5;
@@ -16501,6 +16548,45 @@ function descendantsOf(rows, roots) {
   }
   return found.sort((a, b) => a.pid - b.pid);
 }
+function panesByPid(raw) {
+  const found = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    const pid = Number(trimmed.split(/\s+/)[0]);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    const match = /(?:^|\s)TMUX_PANE=(%\d+)(?:\s|$)/.exec(trimmed);
+    if (match) found.set(pid, match[1]);
+  }
+  return found;
+}
+async function processesForCard(panes, table, lookupPanes) {
+  const mine = /* @__PURE__ */ new Map();
+  for (const pane of panes) {
+    for (const row of processesForPane(table, pane.pid)) {
+      mine.set(row.pid, { tabId: pane.tabId, row });
+    }
+  }
+  const shells = new Set(panes.map((pane) => pane.pid));
+  const rest = table.filter((row) => row.pid > 1 && !mine.has(row.pid) && !shells.has(row.pid)).map((row) => row.pid);
+  if (rest.length === 0) return mine;
+  const paneOf = await lookupPanes(rest);
+  const tabByPane = new Map(panes.map((pane) => [pane.paneId, pane.tabId]));
+  const adopted = /* @__PURE__ */ new Map();
+  for (const row of table) {
+    const tabId = tabByPane.get(paneOf.get(row.pid) ?? "");
+    if (!tabId || mine.has(row.pid)) continue;
+    mine.set(row.pid, { tabId, row });
+    const roots = adopted.get(tabId);
+    if (roots) roots.push(row.pid);
+    else adopted.set(tabId, [row.pid]);
+  }
+  for (const [tabId, roots] of adopted) {
+    for (const row of descendantsOf(table, roots)) {
+      if (!mine.has(row.pid)) mine.set(row.pid, { tabId, row });
+    }
+  }
+  return mine;
+}
 function commandOf(args) {
   const first = args.trim().split(/\s+/)[0] ?? "";
   const base = first.split("/").pop() ?? first;
@@ -16625,12 +16711,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(path17) {
+async function resolveReal(path18) {
   try {
     const { realpath } = await importFs("fs/promises");
-    return await realpath(path17);
+    return await realpath(path18);
   } catch {
-    return path17;
+    return path18;
   }
 }
 var loadSubscribe = null;
@@ -16744,19 +16830,19 @@ var WorkspaceWatcher = class {
   }
   record(kind, relPath) {
     if (this.closed) return;
-    const path17 = "/" + relPath;
-    const expiry = this.selfWrites.get(path17);
+    const path18 = "/" + relPath;
+    const expiry = this.selfWrites.get(path18);
     if (expiry !== void 0) {
       if (expiry > Date.now()) return;
-      this.selfWrites.delete(path17);
+      this.selfWrites.delete(path18);
     }
     const { added, changed, removed } = this.pending;
-    added.delete(path17);
-    changed.delete(path17);
-    removed.delete(path17);
-    if (kind === "added") added.add(path17);
-    else if (kind === "changed") changed.add(path17);
-    else removed.add(path17);
+    added.delete(path18);
+    changed.delete(path18);
+    removed.delete(path18);
+    if (kind === "added") added.add(path18);
+    else if (kind === "changed") changed.add(path18);
+    else removed.add(path18);
     if (added.size + changed.size + removed.size > MAX_BATCH) {
       this.pending = { ...emptyPending(), resync: true };
     }
@@ -16775,8 +16861,8 @@ var WorkspaceWatcher = class {
     this.pending = emptyPending();
     if (!resync && !added.size && !changed.size && !removed.size) return;
     const now = Date.now();
-    for (const [path17, expiry] of this.selfWrites) {
-      if (expiry <= now) this.selfWrites.delete(path17);
+    for (const [path18, expiry] of this.selfWrites) {
+      if (expiry <= now) this.selfWrites.delete(path18);
     }
     this.emit({
       added: resync ? [] : [...added],
@@ -16822,6 +16908,7 @@ async function writeBase64File(target, abs, b64, opts = {}) {
     `Write ${abs}`
   );
 }
+var PANE_REREAD_MS = 1e3;
 var TerminalModeEngine = class {
   constructor(core, emitter) {
     this.core = core;
@@ -16832,12 +16919,117 @@ var TerminalModeEngine = class {
     /** Worktree name each session claimed, keyed by postId. Covers the window
      *  `claimWorkName`'s disk scan cannot: a name taken but not yet created. */
     this.reservedNames = /* @__PURE__ */ new Map();
+    // ── agent activity ──
+    /** Long-lived `redis-cli subscribe` on the space's own socket. One for every
+     *  session: the channel is space-wide and the pane rides in the payload, so
+     *  a session starting does not mean re-subscribing. */
+    this.stateSub = null;
+    /** Applies states one at a time; see the comment at the push site. */
+    this.stateQueue = Promise.resolve();
+    /** pane id -> tmux session name, refreshed only when a pane we have not seen
+     *  turns up. Panes outlive individual messages, so re-reading the whole map
+     *  per message would be a tmux call per hook. */
+    this.paneSessions = /* @__PURE__ */ new Map();
+    this.paneReadAt = 0;
+  }
+  /** Idempotent, like startWatching: re-entering a session must not stack
+   *  subscribers. */
+  async startStateSub() {
+    if (this.stateSub) return;
+    const target = this.core.target();
+    const child = await target.spawn([
+      "redis-cli",
+      "-s",
+      redisSocketPath(target),
+      "subscribe",
+      AGENT_STATE_CHANNEL
+    ]).catch(() => null);
+    if (!child) return;
+    this.stateSub = child;
+    let buffer = "";
+    child.stdout?.on("data", (chunk) => {
+      buffer += String(chunk);
+      const { states, rest } = drainStateMessages(buffer);
+      buffer = rest;
+      for (const { paneId, state } of states) {
+        this.stateQueue = this.stateQueue.then(() => this.applyPaneState(paneId, state)).catch(() => {
+        });
+      }
+    });
+    child.once("exit", () => {
+      if (this.stateSub === child) this.stateSub = null;
+    });
+    void this.hydrateAgentStates();
+  }
+  /** Read the last reported state for every live session's pane.
+   *
+   *  Subscribing only catches what happens next. After a runner restart the
+   *  sessions come back but no hook has fired yet, so an idle session would
+   *  show as working until someone typed in it — which for an idle session may
+   *  be never. This is what the hook's SET alongside its PUBLISH is for. */
+  async hydrateAgentStates() {
+    if (this.sessions.size === 0) return;
+    await this.refreshPanes();
+    const target = this.core.target();
+    for (const [paneId, name] of this.paneSessions) {
+      const postId = postIdForSessionName(name, this.sessions.keys());
+      const session = postId ? this.sessions.get(postId) : null;
+      if (!session || session.agentState) continue;
+      const raw = await target.sh(
+        `redis-cli -s ${redisSocketPath(target)} get '${agentStateKey(paneId)}'`
+      ).catch(() => "");
+      const state = parseAgentState(raw);
+      if (!state) continue;
+      session.agentState = state;
+      this.emitter.emitSessionUpdate(session);
+    }
+  }
+  /** Called after a session is removed, never before: every stopWatching call
+   *  site runs while the session is still in the map, so keying this off
+   *  stopWatching would leave the subscriber running for the life of the
+   *  process. */
+  releaseStateSub() {
+    if (this.sessions.size > 0) return;
+    this.stateSub?.kill();
+    this.stateSub = null;
+  }
+  async applyPaneState(paneId, state) {
+    let name = this.paneSessions.get(paneId);
+    if (!name) {
+      await this.refreshPanes();
+      name = this.paneSessions.get(paneId);
+    }
+    if (!name) return;
+    const postId = postIdForSessionName(name, this.sessions.keys());
+    if (!postId) return;
+    const session = this.sessions.get(postId);
+    if (!session || session.agentState === state) return;
+    session.agentState = state;
+    this.emitter.emitSessionUpdate(session);
+  }
+  /** Rate-limited: a pane that will never resolve — one whose session has
+   *  since closed — would otherwise re-list on every message it sent, which is
+   *  a tmux subprocess per hook. */
+  async refreshPanes() {
+    const now = Date.now();
+    if (now - this.paneReadAt < PANE_REREAD_MS) return;
+    this.paneReadAt = now;
+    const target = this.core.target();
+    const out = await target.sh(
+      `${tmuxCli(target)} list-panes -a -F '#{pane_id}|#{session_name}' 2>/dev/null || true`
+    ).catch(() => "");
+    this.paneSessions.clear();
+    for (const raw of out.split("\n")) {
+      const [pane, name] = raw.trim().split("|");
+      if (pane && name) this.paneSessions.set(pane, name);
+    }
   }
   // ── working-tree watching ──
   /** Start watching a session's tree. Idempotent: re-entering a session (the
    *  modal reopening, a hydrate after restart) must not stack watchers. */
   startWatching(session) {
     const postId = session.postId;
+    void this.startStateSub();
     if (this.watchers.has(postId)) return;
     const paths = this.core.target().paths;
     const root = session.workspacePath || paths.root;
@@ -16874,8 +17066,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, path17) {
-    this.watchers.get(postId)?.expectWrite(posixNormalize(path17));
+  expectWrite(postId, path18) {
+    this.watchers.get(postId)?.expectWrite(posixNormalize(path18));
   }
   // ── Lifecycle / ModeEngine ──
   start(base, args) {
@@ -16921,6 +17113,7 @@ var TerminalModeEngine = class {
     this.stopWatching(postId);
     this.reservedNames.delete(postId);
     this.sessions.delete(postId);
+    this.releaseStateSub();
   }
   async kill(postId) {
     let session = this.sessions.get(postId);
@@ -16938,6 +17131,7 @@ var TerminalModeEngine = class {
     const removedPostId = session.postId;
     this.reservedNames.delete(removedPostId);
     this.sessions.delete(removedPostId);
+    this.releaseStateSub();
     this.emitter.emitSessionRemoved(removedPostId);
   }
   destroy() {
@@ -17070,18 +17264,18 @@ var TerminalModeEngine = class {
         this.reservedNames.values()
       );
       this.reservedNames.set(session.postId, workName);
-      const { path: path17 } = await addWorktree(
+      const { path: path18 } = await addWorktree(
         this.core.target(),
         workName,
         branch,
         "terminal"
       );
-      session.workspacePath = path17;
+      session.workspacePath = path18;
       await setGitIdentity(
         this.core.target(),
         config.gitName,
         config.gitEmail,
-        path17
+        path18
       );
       this.emitter.addLog(session, "system", "Worktree ready.");
     } else {
@@ -17143,11 +17337,11 @@ var TerminalModeEngine = class {
   }
   async bareFsList({
     postId,
-    path: path17
+    path: path18
   }) {
     const target = this.getBareTarget(postId);
     const root = this.getBareRoot(postId);
-    const abs = this.resolveBarePath(path17, root);
+    const abs = this.resolveBarePath(path18, root);
     const relRoot = abs.slice(root.length) || "/";
     const out = await target.run([
       "sh",
@@ -17197,30 +17391,30 @@ var TerminalModeEngine = class {
   }
   async bareFsRead({
     postId,
-    path: path17
+    path: path18
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path17, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path18, this.getBareRoot(postId));
     const b64 = (await target.sh(`base64 < ${shEscape(abs)} | tr -d '
 '`)).trim();
     return { content: b64, encoding: "base64" };
   }
   async bareFsWrite({
     postId,
-    path: path17,
+    path: path18,
     content,
     encoding
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path17, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path18, 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), path17);
+    this.expectWrite(String(postId), path18);
     await writeBase64File(target, abs, b64);
     const session = this.sessions.get(String(postId));
-    if (session) delete session.buffers[path17];
+    if (session) delete session.buffers[path18];
   }
   /** 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).
@@ -17270,39 +17464,39 @@ var TerminalModeEngine = class {
   }
   bareOpenFile({
     postId: rawPostId,
-    path: path17
+    path: path18
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    if (!session.openedFiles.includes(path17)) {
-      session.openedFiles.push(path17);
+    if (!session.openedFiles.includes(path18)) {
+      session.openedFiles.push(path18);
     }
   }
   bareCloseFile({
     postId: rawPostId,
-    path: path17
+    path: path18
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    session.openedFiles = session.openedFiles.filter((p) => p !== path17);
-    delete session.buffers[path17];
+    session.openedFiles = session.openedFiles.filter((p) => p !== path18);
+    delete session.buffers[path18];
   }
   bareBufferSet({
     postId: rawPostId,
-    path: path17,
+    path: path18,
     content
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    session.buffers[path17] = content;
+    session.buffers[path18] = content;
   }
   async bareFsDelete({
     postId,
-    path: path17
+    path: path18
   }) {
     const target = this.getBareTarget(postId);
     const root = this.getBareRoot(postId);
-    const abs = this.resolveBarePath(path17, root);
+    const abs = this.resolveBarePath(path18, root);
     if (abs === root) {
       throw new Error("Refusing to delete the repo root.");
     }
@@ -17310,10 +17504,10 @@ var TerminalModeEngine = class {
   }
   async bareFsMkdir({
     postId,
-    path: path17
+    path: path18
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path17, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path18, this.getBareRoot(postId));
     await target.sh(`mkdir -p ${shEscape(abs)}`);
   }
   async bareReview({
@@ -17456,53 +17650,63 @@ var TerminalModeEngine = class {
       return [];
     }
   }
-  /** Pane pids for this card's tabs, keyed by tab id. The pane's own shell is
-   *  the root of everything the user started in that tab. */
+  /** This card's panes: the pid its tree hangs off, and the pane id its
+   *  processes carry in their environment. */
   async panePids(target, postId) {
     const prefix = `terminal-${postId.replace(/[^a-zA-Z0-9._-]/g, "_")}-`;
     const stdout = await target.sh(
-      `${tmuxCli(target)} list-panes -a -F '#{session_name}|#{pane_pid}' 2>/dev/null || true`
+      `${tmuxCli(target)} list-panes -a -F '#{session_name}|#{pane_pid}|#{pane_id}' 2>/dev/null || true`
     ).catch(() => "");
     const panes = [];
     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 pid = Number(rest.slice(sep + 1));
-      if (!Number.isInteger(pid) || pid <= 0) continue;
-      panes.push({ tabId: rest.slice(0, sep), pid });
+      const [tabId, rawPid, paneId] = line.slice(prefix.length).split("|");
+      const pid = Number(rawPid);
+      if (!tabId || !paneId || !Number.isInteger(pid) || pid <= 0) continue;
+      panes.push({ tabId, pid, paneId });
     }
     return panes;
   }
+  /**
+   * Every process this card is running, by pid. Shared with bareKillProcess,
+   * so stopping a process accepts exactly the set the panel shows.
+   *
+   * The `-p <pids>` on the environment call is required, not a saving: macOS
+   * omits environments from an unscoped `ps -axeww` — see panesByPid.
+   */
+  async cardProcesses(target, postId) {
+    const panes = await this.panePids(target, postId);
+    if (panes.length === 0) return /* @__PURE__ */ new Map();
+    const table = parsePsTable(
+      await target.run(["ps", "-axo", PS_FORMAT]).catch(() => "")
+    );
+    return processesForCard(
+      panes,
+      table,
+      async (pids) => panesByPid(
+        await target.run(["ps", "eww", "-o", "pid=,command=", "-p", pids.join(",")]).catch(() => "")
+      )
+    );
+  }
   async bareListProcesses({
     postId: rawPostId
   }) {
     const postId = String(rawPostId);
     const target = this.getBareTarget(postId);
-    const panes = await this.panePids(target, postId);
-    if (panes.length === 0) return [];
-    const table = parsePsTable(
-      await target.run(["ps", "-axo", PS_FORMAT]).catch(() => "")
-    );
-    const found = [];
-    for (const pane of panes) {
-      for (const row of processesForPane(table, pane.pid)) {
-        found.push({
-          pid: row.pid,
-          tabId: pane.tabId,
-          command: commandOf(row.args),
-          args: row.args,
-          cpu: row.cpu,
-          memoryKb: row.rssKb,
-          elapsed: row.elapsed,
-          ports: [],
-          connections: 0
-        });
-      }
-    }
-    if (found.length === 0) return [];
+    const mine = await this.cardProcesses(target, postId);
+    if (mine.size === 0) return [];
+    const found = Array.from(mine.values(), ({ tabId, row }) => ({
+      pid: row.pid,
+      tabId,
+      command: commandOf(row.args),
+      args: row.args,
+      cpu: row.cpu,
+      memoryKb: row.rssKb,
+      elapsed: row.elapsed,
+      ports: [],
+      connections: 0
+    }));
     const sockets = await socketsFor(
       target,
       found.map((p) => p.pid)
@@ -17525,14 +17729,8 @@ var TerminalModeEngine = class {
     if (!Number.isInteger(pid) || pid <= 1) {
       throw new Error("Not a process this card can stop.");
     }
-    const panes = await this.panePids(target, postId);
-    const table = parsePsTable(
-      await target.run(["ps", "-axo", PS_FORMAT]).catch(() => "")
-    );
-    const mine = panes.some(
-      (pane) => processesForPane(table, pane.pid).some((row) => row.pid === pid)
-    );
-    if (!mine) {
+    const mine = await this.cardProcesses(target, postId);
+    if (!mine.has(pid)) {
       throw new Error("That process is not running in this card.");
     }
     await target.run(["kill", "-TERM", String(pid)]);
@@ -17991,8 +18189,8 @@ async function pollGithubDeviceCode(clientId, deviceCode) {
       };
   }
 }
-async function githubApi(token, path17) {
-  const res = await fetch(`${API_BASE}${path17}`, {
+async function githubApi(token, path18) {
+  const res = await fetch(`${API_BASE}${path18}`, {
     headers: {
       Authorization: `Bearer ${token}`,
       Accept: "application/vnd.github+json",
@@ -18001,7 +18199,7 @@ async function githubApi(token, path17) {
   });
   if (!res.ok) {
     throw new Error(
-      `GitHub ${path17} failed (${res.status}): ${await res.text()}`
+      `GitHub ${path18} failed (${res.status}): ${await res.text()}`
     );
   }
   return await res.json();
@@ -18508,6 +18706,59 @@ async function getDriveRoot(accessToken) {
   };
 }
 
+// ../../shared/all/helpers/board-agent-core/plugin.ts
+var import_fs3 = require("fs");
+var import_promises6 = require("fs/promises");
+var import_os3 = __toESM(require("os"));
+var import_path9 = __toESM(require("path"));
+var PLUGIN_ID = "factiii@factiii-runner";
+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_fs3.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 renderPlugin(boardMcpUrl) {
+  const source = pluginRoot();
+  if (!source) return null;
+  const dest = renderedPluginRoot();
+  const manifest = import_path9.default.join(dest, "factiii", ".mcp.json");
+  const want = `${JSON.stringify(boardMcpConfig(boardMcpUrl), null, 2)}
+`;
+  const have = await (0, import_promises6.readFile)(manifest, "utf8").catch(() => null);
+  if (have === want) return dest;
+  await (0, import_promises6.mkdir)(import_path9.default.dirname(dest), { recursive: true });
+  await (0, import_promises6.cp)(source, dest, { recursive: true, force: true });
+  await (0, import_promises6.writeFile)(manifest, want);
+  return dest;
+}
+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/board-agent-core/toolchain.ts
 var TOOLS = [
   { bin: "git" },
@@ -18765,10 +19016,6 @@ var SpaceCore = class {
         enabled: this.isOneDriveConnected()
       });
     }
-    const board = this.boardMcp();
-    if (board) {
-      lanes.push({ mcp: board, tokenEnv: BOARD_MCP_TOKEN_ENV, enabled: true });
-    }
     return lanes;
   }
   isReady() {
@@ -18919,6 +19166,7 @@ var SpaceCore = class {
         await Promise.all([
           this.provisionGitLane(status),
           this.provisionMcpLane(),
+          this.provisionPluginLane(),
           // Covers a host signed in outside the one-click button, which would
           // otherwise meet the wizard the first time it opens a terminal.
           markOnboardingComplete(target).catch(() => {
@@ -18961,17 +19209,53 @@ var SpaceCore = class {
       target.paths.repo
     );
   }
+  /** Install the factiii plugin into both CLIs: the hooks behind the session
+   *  status dot, the skills this workspace provides, and the board MCP.
+   *
+   *  A plugin rather than hand-written config because it is additive — unlike
+   *  pointing CLAUDE_CONFIG_DIR or CODEX_HOME at our own directory, which
+   *  would hide the user's own settings, skills, MCP entries and auth.
+   *
+   *  Both CLIs read the same manifest, so one marketplace serves both, and
+   *  adding a marketplace or plugin that is already there is a no-op in each —
+   *  which is what makes this safe on every ensure. */
+  async provisionPluginLane() {
+    const board = this.boardMcp();
+    const root = board ? await renderPlugin(board.url).catch(() => null) : null;
+    if (!root) return;
+    const q = `'${root}'`;
+    const cmd = [
+      `claude plugin marketplace add ${q} >/dev/null 2>&1 || true`,
+      `claude plugin install ${PLUGIN_ID} --scope user >/dev/null 2>&1 || true`,
+      `codex plugin marketplace add ${q} >/dev/null 2>&1 || true`,
+      `codex plugin add ${PLUGIN_ID} >/dev/null 2>&1 || true`
+    ].join("; ");
+    try {
+      await this.target().sh(cmd);
+    } catch {
+    }
+  }
   // Register this space's MCPs with both CLIs, user-scoped, and clear the ones
   // it cannot currently offer. Registering regardless left every space holding
   // an entry it never uses, which the CLI then fails to handshake with on every
   // run. Removal is unconditional so a disconnect cleans itself up.
+  //
+  // No early return on an empty lane list: since the board lane moved into the
+  // plugin, a host with no OneDrive has nothing to add and still has the old
+  // board entries to drop.
   async provisionMcpLane() {
     const lanes = this.mcpLanes();
-    if (!lanes.length) return;
+    const board = this.boardMcp();
+    const boardCodexTable = board?.name.replace(/-/g, "_");
     const cmd = [
       // Pre-rename entries, when the name was the same for every space.
       `claude mcp remove factiii-onedrive --scope user >/dev/null 2>&1 || true`,
       `codex mcp remove factiii_onedrive >/dev/null 2>&1 || true`,
+      // The board lane moved into the plugin; drop what the old path wrote.
+      ...board ? [
+        `claude mcp remove ${board.name} --scope user >/dev/null 2>&1 || true`,
+        `codex mcp remove ${boardCodexTable} >/dev/null 2>&1 || true`
+      ] : [],
       ...lanes.flatMap(({ mcp, tokenEnv, enabled }) => {
         const codexTable = mcp.name.replace(/-/g, "_");
         const claudeJson = JSON.stringify({
@@ -19588,7 +19872,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_path9.dirname)(spaceDir), spaceDir };
+    return { configDir: (0, import_path10.dirname)(spaceDir), spaceDir };
   }
   async deploySecretsStatus() {
     return {
@@ -20646,10 +20930,10 @@ ${c.content.trim() || "(no description)"}`
 // ../../shared/all/helpers/board-agent-core/index-service.ts
 var import_child_process5 = require("child_process");
 var import_crypto3 = require("crypto");
-var import_fs3 = require("fs");
-var import_promises6 = __toESM(require("fs/promises"));
+var import_fs4 = require("fs");
+var import_promises7 = __toESM(require("fs/promises"));
 var import_net2 = require("net");
-var import_path10 = require("path");
+var import_path11 = require("path");
 var import_util7 = require("util");
 var execFileAsync4 = (0, import_util7.promisify)(import_child_process5.execFile);
 var IndexService = class {
@@ -20708,7 +20992,7 @@ var IndexService = class {
     const log = await this.openLog();
     this.proc = (0, import_child_process5.spawn)(
       process.execPath,
-      [(0, import_path10.join)(this.opts.indexDir, "index.js")],
+      [(0, import_path11.join)(this.opts.indexDir, "index.js")],
       {
         cwd: this.opts.indexDir,
         env: {
@@ -20736,8 +21020,8 @@ var IndexService = class {
    *  opened (a missing log must never stop the service from starting). */
   async openLog() {
     try {
-      await import_promises6.default.mkdir(this.opts.dataDir, { recursive: true });
-      return (0, import_fs3.openSync)((0, import_path10.join)(this.opts.dataDir, "index.log"), "a");
+      await import_promises7.default.mkdir(this.opts.dataDir, { recursive: true });
+      return (0, import_fs4.openSync)((0, import_path11.join)(this.opts.dataDir, "index.log"), "a");
     } catch {
       return null;
     }
@@ -20746,10 +21030,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_fs3.existsSync)((0, import_path10.join)(dir, "node_modules"))) return;
-    await import_promises6.default.copyFile(
-      (0, import_path10.join)(dir, "image-package.json"),
-      (0, import_path10.join)(dir, "package.json")
+    if ((0, import_fs4.existsSync)((0, import_path11.join)(dir, "node_modules"))) return;
+    await import_promises7.default.copyFile(
+      (0, import_path11.join)(dir, "image-package.json"),
+      (0, import_path11.join)(dir, "package.json")
     );
     await execFileAsync4(
       "npm",
@@ -20761,15 +21045,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_path10.join)(this.opts.dataDir, ".port");
-    const saved = Number(await import_promises6.default.readFile(file, "utf-8").catch(() => ""));
+    const file = (0, import_path11.join)(this.opts.dataDir, ".port");
+    const saved = Number(await import_promises7.default.readFile(file, "utf-8").catch(() => ""));
     if (Number.isInteger(saved) && saved > 0 && await isFree(saved)) {
       return saved;
     }
     const port = await freePort();
-    await import_promises6.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
+    await import_promises7.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
     });
-    await import_promises6.default.writeFile(file, String(port), "utf-8").catch(() => {
+    await import_promises7.default.writeFile(file, String(port), "utf-8").catch(() => {
     });
     return port;
   }
@@ -20936,25 +21220,25 @@ async function pairWithBrowser(serverUrl) {
 }
 
 // src/config.ts
-var import_fs7 = __toESM(require("fs"));
-var import_os5 = __toESM(require("os"));
-var import_path15 = __toESM(require("path"));
+var import_fs8 = __toESM(require("fs"));
+var import_os6 = __toESM(require("os"));
+var import_path16 = __toESM(require("path"));
 
 // src/secureFile.ts
 var import_crypto6 = __toESM(require("crypto"));
-var import_fs6 = __toESM(require("fs"));
-var import_path14 = __toESM(require("path"));
+var import_fs7 = __toESM(require("fs"));
+var import_path15 = __toESM(require("path"));
 
 // src/keychain.ts
 var import_child_process7 = require("child_process");
 var import_crypto4 = __toESM(require("crypto"));
-var import_fs4 = __toESM(require("fs"));
-var import_os3 = __toESM(require("os"));
-var import_path11 = __toESM(require("path"));
+var import_fs5 = __toESM(require("fs"));
+var import_os4 = __toESM(require("os"));
+var import_path12 = __toESM(require("path"));
 var SERVICE = "factiii-runner";
 var ACCOUNT = "config-encryption-key";
-var DPAPI_KEY_FILE = import_path11.default.join(
-  import_os3.default.homedir(),
+var DPAPI_KEY_FILE = import_path12.default.join(
+  import_os4.default.homedir(),
   ".factiii-runner",
   "config-key.dpapi"
 );
@@ -21034,7 +21318,7 @@ function linuxWrite(key) {
 function winRead() {
   let wrapped;
   try {
-    wrapped = import_fs4.default.readFileSync(DPAPI_KEY_FILE, "utf-8").trim();
+    wrapped = import_fs5.default.readFileSync(DPAPI_KEY_FILE, "utf-8").trim();
   } catch {
     return { state: "missing" };
   }
@@ -21059,8 +21343,8 @@ function winWrite(key) {
     "-Command",
     `ConvertTo-SecureString -String '${key.toString("base64")}' -AsPlainText -Force | ConvertFrom-SecureString`
   ]);
-  import_fs4.default.mkdirSync(import_path11.default.dirname(DPAPI_KEY_FILE), { recursive: true });
-  import_fs4.default.writeFileSync(DPAPI_KEY_FILE, `${out.trim()}
+  import_fs5.default.mkdirSync(import_path12.default.dirname(DPAPI_KEY_FILE), { recursive: true });
+  import_fs5.default.writeFileSync(DPAPI_KEY_FILE, `${out.trim()}
 `, { mode: 384 });
 }
 function keychainBackend() {
@@ -21222,22 +21506,22 @@ function keychainStatus() {
 
 // src/secureStore.ts
 var import_crypto5 = __toESM(require("crypto"));
-var import_fs5 = __toESM(require("fs"));
-var import_path13 = __toESM(require("path"));
+var import_fs6 = __toESM(require("fs"));
+var import_path14 = __toESM(require("path"));
 
 // src/paths.ts
-var import_os4 = __toESM(require("os"));
-var import_path12 = __toESM(require("path"));
-var CONFIG_DIR = import_path12.default.join(import_os4.default.homedir(), ".factiii-runner");
+var import_os5 = __toESM(require("os"));
+var import_path13 = __toESM(require("path"));
+var CONFIG_DIR = import_path13.default.join(import_os5.default.homedir(), ".factiii-runner");
 function safeSlug(spaceSlug) {
   return spaceSlug.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
 function spaceDirPath(spaceSlug) {
-  return import_path12.default.join(CONFIG_DIR, safeSlug(spaceSlug));
+  return import_path13.default.join(CONFIG_DIR, safeSlug(spaceSlug));
 }
 
 // src/secureStore.ts
-var VAULT_KEY_FILE = import_path13.default.join(CONFIG_DIR, "vault-key.json");
+var VAULT_KEY_FILE = import_path14.default.join(CONFIG_DIR, "vault-key.json");
 var SCRYPT_N2 = 1 << 15;
 var MIN_PASSWORD_LENGTH = 8;
 var SecureStoreError = class extends Error {
@@ -21310,7 +21594,7 @@ function unseal(box, key) {
 function readVaultFile() {
   try {
     const parsed = JSON.parse(
-      import_fs5.default.readFileSync(VAULT_KEY_FILE, "utf-8")
+      import_fs6.default.readFileSync(VAULT_KEY_FILE, "utf-8")
     );
     return parsed.v === 1 ? parsed : null;
   } catch {
@@ -21318,11 +21602,11 @@ function readVaultFile() {
   }
 }
 function writeVaultFile(file) {
-  import_fs5.default.mkdirSync(CONFIG_DIR, { recursive: true });
+  import_fs6.default.mkdirSync(CONFIG_DIR, { recursive: true });
   const tmp = `${VAULT_KEY_FILE}.${process.pid}.tmp`;
-  import_fs5.default.writeFileSync(tmp, `${JSON.stringify(file, null, 2)}
+  import_fs6.default.writeFileSync(tmp, `${JSON.stringify(file, null, 2)}
 `, { mode: 384 });
-  import_fs5.default.renameSync(tmp, VAULT_KEY_FILE);
+  import_fs6.default.renameSync(tmp, VAULT_KEY_FILE);
 }
 var unlockedDek = null;
 function createVault(machineKey) {
@@ -21559,15 +21843,15 @@ function parseEnvelope(raw) {
   }
 }
 function atomicWrite(filePath, body) {
-  import_fs6.default.mkdirSync(import_path14.default.dirname(filePath), { recursive: true });
+  import_fs7.default.mkdirSync(import_path15.default.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.tmp`;
-  import_fs6.default.writeFileSync(tmp, body, { mode: 384 });
-  import_fs6.default.renameSync(tmp, filePath);
+  import_fs7.default.writeFileSync(tmp, body, { mode: 384 });
+  import_fs7.default.renameSync(tmp, filePath);
 }
 function readSecureBuffer(filePath) {
   let raw;
   try {
-    raw = import_fs6.default.readFileSync(filePath, "utf-8");
+    raw = import_fs7.default.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -21624,7 +21908,7 @@ function writeSecureJson(filePath, value2) {
 function readBootJson(filePath) {
   let raw;
   try {
-    raw = import_fs6.default.readFileSync(filePath, "utf-8");
+    raw = import_fs7.default.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -21674,8 +21958,8 @@ function writeBootJson(filePath, value2) {
 }
 
 // src/config.ts
-var CONFIG_DIR2 = import_path15.default.join(import_os5.default.homedir(), ".factiii-runner");
-var CONFIG_FILE = import_path15.default.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = import_path16.default.join(import_os6.default.homedir(), ".factiii-runner");
+var CONFIG_FILE = import_path16.default.join(CONFIG_DIR2, "config.json");
 function readRunnerConfig() {
   return readBootJson(CONFIG_FILE);
 }
@@ -21683,7 +21967,7 @@ function writeRunnerConfig(config) {
   writeBootJson(CONFIG_FILE, config);
 }
 function configExists() {
-  return import_fs7.default.existsSync(CONFIG_FILE);
+  return import_fs8.default.existsSync(CONFIG_FILE);
 }
 
 // src/promptPassword.ts
@@ -21845,9 +22129,9 @@ function makeChunkReassembler() {
 
 // src/daemon.ts
 var import_crypto7 = require("crypto");
-var import_fs9 = __toESM(require("fs"));
+var import_fs10 = __toESM(require("fs"));
 var import_node_datachannel = require("node-datachannel");
-var import_path17 = __toESM(require("path"));
+var import_path18 = __toESM(require("path"));
 
 // ../../node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
 var XMLHttpRequestModule = __toESM(require_XMLHttpRequest(), 1);
@@ -23027,12 +23311,12 @@ function parse2(str) {
   uri.queryKey = queryKey(uri, uri["query"]);
   return uri;
 }
-function pathNames(obj, path17) {
-  const regx = /\/{2,9}/g, names = path17.replace(regx, "/").split("/");
-  if (path17.slice(0, 1) == "/" || path17.length === 0) {
+function pathNames(obj, path18) {
+  const regx = /\/{2,9}/g, names = path18.replace(regx, "/").split("/");
+  if (path18.slice(0, 1) == "/" || path18.length === 0) {
     names.splice(0, 1);
   }
-  if (path17.slice(-1) == "/") {
+  if (path18.slice(-1) == "/") {
     names.splice(names.length - 1, 1);
   }
   return names;
@@ -23651,7 +23935,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, path17 = "", loc) {
+function url(uri, path18 = "", loc) {
   let obj = uri;
   loc = loc || typeof location !== "undefined" && location;
   if (null == uri)
@@ -23685,7 +23969,7 @@ function url(uri, path17 = "", 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 + path17;
+  obj.id = obj.protocol + "://" + host + ":" + obj.port + path18;
   obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
   return obj;
 }
@@ -25319,8 +25603,8 @@ function lookup(uri, opts) {
   const parsed = url(uri, opts.path || "/socket.io");
   const source = parsed.source;
   const id = parsed.id;
-  const path17 = parsed.path;
-  const sameNamespace = cache[id] && path17 in cache[id]["nsps"];
+  const path18 = parsed.path;
+  const sameNamespace = cache[id] && path18 in cache[id]["nsps"];
   const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
   let io;
   if (newConnection) {
@@ -25362,8 +25646,8 @@ 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(path17) {
-  return `Read ${path17} - it is the Factiii card this session was opened from. Use it as the context and start working on it.`;
+function cardContextPrompt(path18) {
+  return `Read ${path18} - 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.";
@@ -25527,11 +25811,11 @@ var TerminalManager = class {
 };
 
 // src/agent-adapter.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path16 = __toESM(require("path"));
-var RUNNER_CONFIG_PATH = import_path16.default.join(CONFIG_DIR, "runner-config.json");
+var import_fs9 = __toESM(require("fs"));
+var import_path17 = __toESM(require("path"));
+var RUNNER_CONFIG_PATH = import_path17.default.join(CONFIG_DIR, "runner-config.json");
 function connectionPath(spaceSlug) {
-  return import_path16.default.join(CONFIG_DIR, `space-${safeSlug(spaceSlug)}.onedrive.json`);
+  return import_path17.default.join(CONFIG_DIR, `space-${safeSlug(spaceSlug)}.onedrive.json`);
 }
 function writeJson(filePath, value2) {
   writeSecureJson(filePath, value2);
@@ -25558,14 +25842,14 @@ function migrateLegacyConfigs() {
   const file = { boards: {} };
   let legacy = [];
   try {
-    legacy = import_fs8.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".json")).filter((f) => !f.endsWith(".onedrive.json"));
+    legacy = import_fs9.default.readdirSync(CONFIG_DIR).filter((f) => f.startsWith("space-") && f.endsWith(".json")).filter((f) => !f.endsWith(".onedrive.json"));
   } catch {
     return file;
   }
   for (const name of legacy) {
     const slug = name.slice("space-".length, -".json".length);
     const parsed = readSecureJson(
-      import_path16.default.join(CONFIG_DIR, name)
+      import_path17.default.join(CONFIG_DIR, name)
     );
     if (!parsed) continue;
     if (!file.defaultSlug) {
@@ -25585,14 +25869,14 @@ function encryptStrayPlaintextConfigs() {
   const OURS = /^(config|runner-config|space-.*)\.json(\.bak-\d+)?$/;
   let names = [];
   try {
-    names = import_fs8.default.readdirSync(CONFIG_DIR).filter((f) => OURS.test(f));
+    names = import_fs9.default.readdirSync(CONFIG_DIR).filter((f) => OURS.test(f));
   } catch {
     return;
   }
   for (const name of names) {
-    const filePath = import_path16.default.join(CONFIG_DIR, name);
+    const filePath = import_path17.default.join(CONFIG_DIR, name);
     try {
-      const raw = import_fs8.default.readFileSync(filePath, "utf-8");
+      const raw = import_fs9.default.readFileSync(filePath, "utf-8");
       if (!raw.startsWith("{")) continue;
       writeSecureJson(filePath, JSON.parse(raw));
     } catch {
@@ -25623,7 +25907,7 @@ async function getConfiguredConnections() {
   }
   if (await isSignedIn(hostTarget(CONFIG_DIR), "claude")) kinds.add("claude");
   try {
-    const hasOneDrive = import_fs8.default.readdirSync(CONFIG_DIR).some((f) => f.endsWith(".onedrive.json"));
+    const hasOneDrive = import_fs9.default.readdirSync(CONFIG_DIR).some((f) => f.endsWith(".onedrive.json"));
     if (hasOneDrive) kinds.add("onedrive");
   } catch {
   }
@@ -25694,7 +25978,7 @@ var localConfigProvider = {
   writeOneDriveConnection(spaceSlug, connection) {
     const filePath = connectionPath(spaceSlug);
     if (!connection) {
-      import_fs8.default.rmSync(filePath, { force: true });
+      import_fs9.default.rmSync(filePath, { force: true });
       return;
     }
     writeJson(filePath, connection);
@@ -25719,7 +26003,7 @@ var localConfigProvider = {
       "claude",
       "codex"
     ]) {
-      import_fs8.default.mkdirSync(import_path16.default.join(dir, sub), { recursive: true });
+      import_fs9.default.mkdirSync(import_path17.default.join(dir, sub), { recursive: true });
     }
     return dir;
   }
@@ -25893,15 +26177,15 @@ async function startDaemon(config) {
     }
   );
   const indexCandidates = [
-    import_path17.default.join(__dirname, "..", "index"),
-    import_path17.default.join(__dirname, "..", "..", "index", "image")
+    import_path18.default.join(__dirname, "..", "index"),
+    import_path18.default.join(__dirname, "..", "..", "index", "image")
   ];
-  const indexDir = indexCandidates.find((p) => import_fs9.default.existsSync(p)) ?? indexCandidates[0];
+  const indexDir = indexCandidates.find((p) => import_fs10.default.existsSync(p)) ?? indexCandidates[0];
   const odIndex = new IndexService({
     controlToken: (0, import_crypto7.createHash)("sha256").update(config.authToken).digest("hex"),
     embedUrl: () => config.serverUrl,
     indexDir,
-    dataDir: import_path17.default.join(CONFIG_DIR, "index-data")
+    dataDir: import_path18.default.join(CONFIG_DIR, "index-data")
   });
   void odIndex.ensureRunning().catch((err) => {
     console.error(