@factiii/runner 0.9.6 → 0.9.8

package/dist/cli.js

@@ -963,8 +963,8 @@ var require_command = __commonJS({
   "node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path16 = require("node:path");
-    var fs13 = require("node:fs");
+    var path17 = require("node:path");
+    var fs14 = require("node:fs");
     var process2 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1896,11 +1896,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path16.resolve(baseDir, baseName);
-          if (fs13.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path16.extname(baseName))) return void 0;
+          const localBin = path17.resolve(baseDir, baseName);
+          if (fs14.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path17.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs13.existsSync(`${localBin}${ext}`)
+            (ext) => fs14.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1912,21 +1912,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs13.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs14.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path16.resolve(
-            path16.dirname(resolvedScriptPath),
+          executableDir = path17.resolve(
+            path17.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path16.basename(
+            const legacyName = path17.basename(
               this._scriptPath,
-              path16.extname(this._scriptPath)
+              path17.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1937,7 +1937,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path16.extname(executableFile));
+        launchWithNode = sourceExt.includes(path17.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 = path16.basename(filename, path16.extname(filename));
+        this._name = path17.basename(filename, path17.extname(filename));
         return this;
       }
       /**
@@ -2791,9 +2791,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path17) {
-        if (path17 === void 0) return this._executableDir;
-        this._executableDir = path17;
+      executableDir(path18) {
+        if (path18 === void 0) return this._executableDir;
+        this._executableDir = path18;
         return this;
       }
       /**
@@ -3026,9 +3026,9 @@ var require_commander = __commonJS({
 // ../../node_modules/xmlhttprequest-ssl/lib/XMLHttpRequest.js
 var require_XMLHttpRequest = __commonJS({
   "../../node_modules/xmlhttprequest-ssl/lib/XMLHttpRequest.js"(exports2, module2) {
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var Url = require("url");
-    var spawn4 = require("child_process").spawn;
+    var spawn5 = require("child_process").spawn;
     module2.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -3184,7 +3184,7 @@ var require_XMLHttpRequest = __commonJS({
             throw new Error("XMLHttpRequest: Only GET method is supported");
           }
           if (settings.async) {
-            fs13.readFile(unescape(url2.pathname), function(error, data2) {
+            fs14.readFile(unescape(url2.pathname), function(error, data2) {
               if (error) {
                 self.handleError(error, error.errno || -1);
               } else {
@@ -3196,7 +3196,7 @@ var require_XMLHttpRequest = __commonJS({
             });
           } else {
             try {
-              this.response = fs13.readFileSync(unescape(url2.pathname));
+              this.response = fs14.readFileSync(unescape(url2.pathname));
               this.responseText = this.response.toString("utf8");
               this.status = 200;
               setState(self.DONE);
@@ -3322,15 +3322,15 @@ var require_XMLHttpRequest = __commonJS({
         } else {
           var contentFile = ".node-xmlhttprequest-content-" + process.pid;
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
-          fs13.writeFileSync(syncFile, "", "utf8");
+          fs14.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn4(process.argv[0], ["-e", execString]);
+          var syncProc = spawn5(process.argv[0], ["-e", execString]);
           var statusText;
-          while (fs13.existsSync(syncFile)) {
+          while (fs14.existsSync(syncFile)) {
           }
-          self.responseText = fs13.readFileSync(contentFile, "utf8");
+          self.responseText = fs14.readFileSync(contentFile, "utf8");
           syncProc.stdin.end();
-          fs13.unlinkSync(contentFile);
+          fs14.unlinkSync(contentFile);
           if (self.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
             var errorObj = JSON.parse(self.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, ""));
             self.handleError(errorObj, 503);
@@ -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 os5 = require("os");
+    var os6 = 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 = os5.release().split(".");
+        const osRelease = os6.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: path16, errorMaps, issueData } = params;
-  const fullPath = [...path16, ...issueData.path || []];
+  const { data, path: path17, errorMaps, issueData } = params;
+  const fullPath = [...path17, ...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, path16, key) {
+  constructor(parent, value2, path17, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value2;
-    this._path = path16;
+    this._path = path17;
     this._key = key;
   }
   get path() {
@@ -12908,7 +12908,7 @@ ${diff.slice(0, 8e3)}`,
 }
 
 // ../../shared/all/helpers/board-agent-core/engine.ts
-var import_path8 = require("path");
+var import_path9 = require("path");
 
 // ../../shared/all/domains/electron.ts
 var SETUP_LOG_PREFIX = "
log ";
@@ -12922,6 +12922,7 @@ function hostSpacePaths(spaceDir) {
     repo: import_path.default.join(spaceDir, "repo"),
     worktrees: import_path.default.join(spaceDir, "worktrees"),
     workspace: import_path.default.join(spaceDir, "workspace"),
+    skills: import_path.default.join(spaceDir, "skills"),
     state: import_path.default.join(spaceDir, "state"),
     backups: import_path.default.join(spaceDir, "backups"),
     builds: import_path.default.join(spaceDir, "builds"),
@@ -12951,9 +12952,23 @@ function buildCloneUrl(repoUrl, githubToken) {
 async function gitInDir(target, workdir, ...args) {
   return target.run(["git", "-C", workdir, ...args]);
 }
-var WORK_BRANCH_PREFIX = "factiii/card-";
-function cardWorkBranch(workName) {
-  return `${WORK_BRANCH_PREFIX}${workName.replace(/[^a-zA-Z0-9._-]/g, "-")}`;
+var WORK_BRANCH_PREFIXES = {
+  card: "card/",
+  terminal: "terminal/"
+};
+var LEGACY_WORK_BRANCH_PREFIX = "factiii/card-";
+var ALL_WORK_BRANCH_PREFIXES = [
+  ...Object.values(WORK_BRANCH_PREFIXES),
+  LEGACY_WORK_BRANCH_PREFIX
+].sort((a, b) => b.length - a.length);
+function workBranch(workName, kind) {
+  return `${WORK_BRANCH_PREFIXES[kind]}${workName.replace(/[^a-zA-Z0-9._-]/g, "-")}`;
+}
+function workNameFromBranch(branch) {
+  for (const prefix of ALL_WORK_BRANCH_PREFIXES) {
+    if (branch.startsWith(prefix)) return branch.slice(prefix.length);
+  }
+  return null;
 }
 async function listWorkNames(target) {
   const dirs = await target.sh(`ls -1 ${target.paths.worktrees} 2>/dev/null || true`).catch(() => "");
@@ -12966,10 +12981,8 @@ async function listWorkNames(target) {
   ).catch(() => "");
   const names = new Set(dirs.split("\n").map((line) => line.trim()));
   for (const line of branches.split("\n")) {
-    const name = line.trim();
-    if (name.startsWith(WORK_BRANCH_PREFIX)) {
-      names.add(name.slice(WORK_BRANCH_PREFIX.length));
-    }
+    const workName = workNameFromBranch(line.trim());
+    if (workName) names.add(workName);
   }
   names.delete("");
   return [...names];
@@ -13003,10 +13016,18 @@ async function ensurePrimaryClone(target, cloneUrl, branch) {
   });
   await target.sh(`mkdir -p ${target.paths.worktrees}`);
 }
-async function addWorktree(target, workName, baseBranch) {
-  const path16 = worktreeFor(target.paths, workName);
-  const branch = cardWorkBranch(workName);
-  await removeWorktree(target, path16).catch(() => {
+async function addWorktree(target, workName, baseBranch, kind) {
+  const path17 = worktreeFor(target.paths, workName);
+  const branch = workBranch(workName, kind);
+  await gitInDir(
+    target,
+    target.paths.repo,
+    "fetch",
+    "origin",
+    baseBranch
+  ).catch(() => {
+  });
+  await removeWorktree(target, path17).catch(() => {
   });
   await gitInDir(
     target,
@@ -13015,29 +13036,45 @@ async function addWorktree(target, workName, baseBranch) {
     "add",
     "-B",
     branch,
-    path16,
+    path17,
     `origin/${baseBranch}`
   );
-  return { path: path16, branch };
+  return { path: path17, branch };
 }
-async function removeWorktree(target, path16) {
+async function removeWorktree(target, path17) {
   await gitInDir(
     target,
     target.paths.repo,
     "worktree",
     "remove",
     "--force",
-    path16
+    path17
   );
 }
+async function removeWorktreeAndBranch(target, path17) {
+  const branch = await gitInDir(
+    target,
+    path17,
+    "rev-parse",
+    "--abbrev-ref",
+    "HEAD"
+  ).then((out) => out.trim()).catch(() => "");
+  await removeWorktree(target, path17);
+  if (branch && branch !== "HEAD") {
+    await gitInDir(target, target.paths.repo, "branch", "-D", branch).catch(
+      () => {
+      }
+    );
+  }
+}
 async function pruneWorktrees(target) {
   await gitInDir(target, target.paths.repo, "worktree", "prune").catch(
     () => {
     }
   );
 }
-function isWorktreePath(target, path16) {
-  return path16.startsWith(`${target.paths.worktrees}/`);
+function isWorktreePath(target, path17) {
+  return path17.startsWith(`${target.paths.worktrees}/`);
 }
 async function setGitIdentity(target, name, email, workdir = target.paths.workspace) {
   if (name) await gitInDir(target, workdir, "config", "user.name", name);
@@ -13218,7 +13255,8 @@ async function putSessionCard(s, target, prompt2 = "") {
 }
 async function teardownSession(s, target) {
   if (isWorktreeSession(s, target)) {
-    await removeWorktree(target, s.workspacePath).catch(() => {
+    const drop = s.mode === "bare" ? removeWorktreeAndBranch : removeWorktree;
+    await drop(target, s.workspacePath).catch(() => {
     });
   }
   await deleteCard(target, s.postId).catch(() => {
@@ -14064,17 +14102,18 @@ var ClaudeModeEngine = class _ClaudeModeEngine {
     await this.core.ensureSpaceWorkspace();
     await assertAgentSignedIn(session.provider, this.core.target());
     if (hasGit) {
-      const { path: path16 } = await addWorktree(
+      const { path: path17 } = await addWorktree(
         this.core.target(),
         session.taskId,
-        baseBranch || config.mainBranch || "main"
+        baseBranch || config.mainBranch || "main",
+        "card"
       );
-      session.workspacePath = path16;
+      session.workspacePath = path17;
       await setGitIdentity(
         this.core.target(),
         config.gitName,
         config.gitEmail,
-        path16
+        path17
       );
       this.emitter.addLog(session, "system", "Worktree ready.");
     } else {
@@ -14296,17 +14335,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: path16 } = await addWorktree(
+    const { path: path17 } = await addWorktree(
       this.core.target(),
       session.taskId,
-      config.mainBranch || "main"
+      config.mainBranch || "main",
+      "card"
     );
-    session.workspacePath = path16;
+    session.workspacePath = path17;
     await setGitIdentity(
       this.core.target(),
       config.gitName,
       config.gitEmail,
-      path16
+      path17
     );
     await this.putCard(session);
     const patchDir = `${this.core.target().paths.root}/patches/${session.taskId}`;
@@ -14733,19 +14773,19 @@ var WorkspaceWatcher = class {
   }
   record(kind, relPath) {
     if (this.closed) return;
-    const path16 = "/" + relPath;
-    const expiry = this.selfWrites.get(path16);
+    const path17 = "/" + relPath;
+    const expiry = this.selfWrites.get(path17);
     if (expiry !== void 0) {
       if (expiry > Date.now()) return;
-      this.selfWrites.delete(path16);
+      this.selfWrites.delete(path17);
     }
     const { added, changed, removed } = this.pending;
-    added.delete(path16);
-    changed.delete(path16);
-    removed.delete(path16);
-    if (kind === "added") added.add(path16);
-    else if (kind === "changed") changed.add(path16);
-    else removed.add(path16);
+    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);
     if (added.size + changed.size + removed.size > MAX_BATCH) {
       this.pending = { ...emptyPending(), resync: true };
     }
@@ -14764,8 +14804,8 @@ var WorkspaceWatcher = class {
     this.pending = emptyPending();
     if (!resync && !added.size && !changed.size && !removed.size) return;
     const now = Date.now();
-    for (const [path16, expiry] of this.selfWrites) {
-      if (expiry <= now) this.selfWrites.delete(path16);
+    for (const [path17, expiry] of this.selfWrites) {
+      if (expiry <= now) this.selfWrites.delete(path17);
     }
     this.emit({
       added: resync ? [] : [...added],
@@ -14850,8 +14890,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, path16) {
-    this.watchers.get(postId)?.expectWrite(posixNormalize(path16));
+  expectWrite(postId, path17) {
+    this.watchers.get(postId)?.expectWrite(posixNormalize(path17));
   }
   // ── Lifecycle / ModeEngine ──
   start(base, args) {
@@ -14923,8 +14963,32 @@ var TerminalModeEngine = class {
     this.reservedNames.clear();
     this.sessions.clear();
   }
-  teardown(session) {
-    return teardownSession(session, this.core.target());
+  /** 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());
@@ -15025,13 +15089,18 @@ var TerminalModeEngine = class {
         this.reservedNames.values()
       );
       this.reservedNames.set(session.postId, workName);
-      const { path: path16 } = await addWorktree(this.core.target(), workName, branch);
-      session.workspacePath = path16;
+      const { path: path17 } = await addWorktree(
+        this.core.target(),
+        workName,
+        branch,
+        "terminal"
+      );
+      session.workspacePath = path17;
       await setGitIdentity(
         this.core.target(),
         config.gitName,
         config.gitEmail,
-        path16
+        path17
       );
       this.emitter.addLog(session, "system", "Worktree ready.");
     } else {
@@ -15093,11 +15162,11 @@ var TerminalModeEngine = class {
   }
   async bareFsList({
     postId,
-    path: path16
+    path: path17
   }) {
     const target = this.getBareTarget(postId);
     const root = this.getBareRoot(postId);
-    const abs = this.resolveBarePath(path16, root);
+    const abs = this.resolveBarePath(path17, root);
     const relRoot = abs.slice(root.length) || "/";
     const out = await target.sh(`cd ${shEscape(abs)} && for f in .* *; do
         case "$f" in
@@ -15143,32 +15212,32 @@ var TerminalModeEngine = class {
   }
   async bareFsRead({
     postId,
-    path: path16
+    path: path17
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path16, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path17, this.getBareRoot(postId));
     const b64 = (await target.sh(`base64 < ${shEscape(abs)} | tr -d '
 '`)).trim();
     return { content: b64, encoding: "base64" };
   }
   async bareFsWrite({
     postId,
-    path: path16,
+    path: path17,
     content,
     encoding
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path16, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path17, 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), path16);
+    this.expectWrite(String(postId), path17);
     await target.sh(
       `mkdir -p ${shEscape(posixDirname(abs))} && printf %s ${shEscape(b64)} | base64 -d > ${shEscape(abs)}`
     );
     const session = this.sessions.get(String(postId));
-    if (session) delete session.buffers[path16];
+    if (session) delete session.buffers[path17];
   }
   /** Write a dropped image to the per-space drops dir (`paths.root`, OUTSIDE the
    *  card worktree so it never touches the repo) and return its absolute path. */
@@ -15213,39 +15282,39 @@ var TerminalModeEngine = class {
   }
   bareOpenFile({
     postId: rawPostId,
-    path: path16
+    path: path17
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    if (!session.openedFiles.includes(path16)) {
-      session.openedFiles.push(path16);
+    if (!session.openedFiles.includes(path17)) {
+      session.openedFiles.push(path17);
     }
   }
   bareCloseFile({
     postId: rawPostId,
-    path: path16
+    path: path17
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    session.openedFiles = session.openedFiles.filter((p) => p !== path16);
-    delete session.buffers[path16];
+    session.openedFiles = session.openedFiles.filter((p) => p !== path17);
+    delete session.buffers[path17];
   }
   bareBufferSet({
     postId: rawPostId,
-    path: path16,
+    path: path17,
     content
   }) {
     const session = this.sessions.get(String(rawPostId));
     if (!session || session.mode !== "bare") return;
-    session.buffers[path16] = content;
+    session.buffers[path17] = content;
   }
   async bareFsDelete({
     postId,
-    path: path16
+    path: path17
   }) {
     const target = this.getBareTarget(postId);
     const root = this.getBareRoot(postId);
-    const abs = this.resolveBarePath(path16, root);
+    const abs = this.resolveBarePath(path17, root);
     if (abs === root) {
       throw new Error("Refusing to delete the repo root.");
     }
@@ -15253,10 +15322,10 @@ var TerminalModeEngine = class {
   }
   async bareFsMkdir({
     postId,
-    path: path16
+    path: path17
   }) {
     const target = this.getBareTarget(postId);
-    const abs = this.resolveBarePath(path16, this.getBareRoot(postId));
+    const abs = this.resolveBarePath(path17, this.getBareRoot(postId));
     await target.sh(`mkdir -p ${shEscape(abs)}`);
   }
   async bareReview({
@@ -15825,8 +15894,8 @@ async function pollGithubDeviceCode(clientId, deviceCode) {
       };
   }
 }
-async function githubApi(token, path16) {
-  const res = await fetch(`${API_BASE}${path16}`, {
+async function githubApi(token, path17) {
+  const res = await fetch(`${API_BASE}${path17}`, {
     headers: {
       Authorization: `Bearer ${token}`,
       Accept: "application/vnd.github+json",
@@ -15835,7 +15904,7 @@ async function githubApi(token, path16) {
   });
   if (!res.ok) {
     throw new Error(
-      `GitHub ${path16} failed (${res.status}): ${await res.text()}`
+      `GitHub ${path17} failed (${res.status}): ${await res.text()}`
     );
   }
   return await res.json();
@@ -15911,7 +15980,39 @@ async function hostGit(cwd, ...args) {
   });
   return stdout;
 }
-async function checkDeployStatus(opts) {
+async function gitCatFileBatch(cwd, shas) {
+  const out = /* @__PURE__ */ new Map();
+  const wanted = [...new Set(shas.filter(Boolean))];
+  if (!wanted.length) return out;
+  const child = (0, import_child_process3.spawn)("git", [...GIT_NO_HELPER, "cat-file", "--batch"], {
+    cwd,
+    env: GIT_ENV
+  });
+  const chunks = [];
+  child.stdout.on("data", (c) => chunks.push(c));
+  const done = new Promise((resolve2) => {
+    child.on("close", () => resolve2());
+    child.on("error", () => resolve2());
+  });
+  child.stdin.end(`${wanted.join("\n")}
+`);
+  await done;
+  let buf = Buffer.concat(chunks);
+  while (buf.length) {
+    const nl = buf.indexOf(10);
+    if (nl === -1) break;
+    const header = buf.subarray(0, nl).toString("utf-8");
+    buf = buf.subarray(nl + 1);
+    const [sha, type, sizeText] = header.split(" ");
+    if (type === void 0 || sizeText === void 0) continue;
+    const size = Number(sizeText);
+    if (!Number.isFinite(size)) break;
+    out.set(sha, buf.subarray(0, size).toString("utf-8"));
+    buf = buf.subarray(size + 1);
+  }
+  return out;
+}
+async function ensureWorkspaceClone(opts) {
   const workspace = import_path5.default.join(opts.spaceDir, "workspace");
   const branch = (opts.mainBranch || "main").replace(/[^\w./-]/g, "");
   const url2 = buildCloneUrl(opts.repoUrl, opts.githubToken);
@@ -15920,6 +16021,15 @@ async function checkDeployStatus(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(() => []);
+    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 execFileAsync2(
       "git",
       [...GIT_NO_HELPER, "clone", "--branch", branch, url2, workspace],
@@ -15928,6 +16038,10 @@ async function checkDeployStatus(opts) {
     cloned = true;
   }
   if (!cloned) await hostGit(workspace, "fetch", "origin", branch);
+  return { workspace, branch };
+}
+async function checkDeployStatus(opts) {
+  const { workspace, branch } = await ensureWorkspaceClone(opts);
   const has = async (refPath) => {
     try {
       await hostGit(workspace, "cat-file", "-e", refPath);
@@ -16621,6 +16735,1151 @@ ${clean}`;
   }
 }
 
+// ../../shared/all/helpers/board-agent-core/host-skills.ts
+var import_promises5 = __toESM(require("fs/promises"));
+var import_os2 = __toESM(require("os"));
+var import_path8 = __toESM(require("path"));
+
+// ../../shared/all/domains/posts.ts
+var postDataSort = /* @__PURE__ */ ((postDataSort2) => {
+  postDataSort2["DAILY"] = "DAILY";
+  postDataSort2["WEEKLY"] = "WEEKLY";
+  postDataSort2["MONTHLY"] = "MONTHLY";
+  return postDataSort2;
+})(postDataSort || {});
+
+// ../../shared/all/domains/user.ts
+var USER_TAG_VALUES = [
+  "HUMAN",
+  "BOT",
+  "GOVERNMENT",
+  "ACADEMIA",
+  "BUSINESS",
+  "NEW",
+  "WAITLIST",
+  "VERIFIED"
+];
+var detailsCookieSchema = external_exports.object({
+  userId: external_exports.number(),
+  updatedAt: external_exports.string(),
+  username: external_exports.string(),
+  name: external_exports.string().nullable(),
+  email: external_exports.string().nullable(),
+  tag: external_exports.enum(USER_TAG_VALUES),
+  avatarKey: external_exports.string().nullable(),
+  robohash: external_exports.string().nullable(),
+  hasPassword: external_exports.boolean(),
+  // Defaulted so a client cookie minted before these fields existed still parses
+  // (the server re-issues it with real values on the next refresh) instead of
+  // failing the whole payload and flashing the user as logged out.
+  hasPasskey: external_exports.boolean().default(false),
+  twoFaEnabled: external_exports.boolean(),
+  oauthProviders: external_exports.array(external_exports.enum(["GOOGLE", "APPLE"])).default([]),
+  // Defaulted, not just nullable: a required-but-missing key is what breaks old
+  // clients, so this stays parseable once the server stops sending it.
+  oauthProvider: external_exports.enum(["GOOGLE", "APPLE"]).nullable().default(null),
+  emailVerificationStatus: external_exports.enum(["UNVERIFIED", "PENDING", "VERIFIED"]),
+  isPrivate: external_exports.boolean(),
+  isIncognito: external_exports.boolean(),
+  onboardingPath: external_exports.string().nullable(),
+  bio: external_exports.string().nullable(),
+  bannerKey: external_exports.string().nullable(),
+  tronsBalance: external_exports.number(),
+  verificationRequestedAt: external_exports.string().nullable(),
+  deletionScheduledAt: external_exports.string().nullable()
+});
+var UserType = /* @__PURE__ */ ((UserType2) => {
+  UserType2["PRIVATE"] = "PRIVATE";
+  UserType2["INCOGNITO"] = "INCOGNITO";
+  UserType2["PREMIUM"] = "PREMIUM";
+  UserType2["PAID"] = "PAID";
+  UserType2["INVITE"] = "INVITE";
+  return UserType2;
+})(UserType || {});
+
+// ../../shared/all/uploadTypes.ts
+var _EXT_TO_CONTENT_TYPE = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  heic: "image/heic",
+  heif: "image/heif",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  mpeg: "video/mpeg",
+  pdf: "application/pdf",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+var EXT_TO_CONTENT_TYPE = _EXT_TO_CONTENT_TYPE;
+var ALLOWED_CONTENT_TYPES = [
+  ...new Set(Object.values(EXT_TO_CONTENT_TYPE))
+];
+var ALLOWED_CONTENT_TYPES_TUPLE = ALLOWED_CONTENT_TYPES;
+var CONTENT_TYPE_TO_EXT = Object.fromEntries(
+  Object.entries(EXT_TO_CONTENT_TYPE).map(([ext, mime]) => [mime, ext])
+);
+var DROPZONE_ACCEPT = Object.entries(
+  EXT_TO_CONTENT_TYPE
+).reduce((acc, [ext, mime]) => {
+  (acc[mime] ??= []).push(`.${ext}`);
+  return acc;
+}, {});
+var FILE_INPUT_ACCEPT = ALLOWED_CONTENT_TYPES.join(",");
+
+// ../../shared/all/validators.ts
+var usernameValidationRegex = /^[a-zA-Z0-9_]+$/;
+var signupSchema = external_exports.object({
+  username: external_exports.string().min(1).regex(usernameValidationRegex, {
+    message: "Username can only contain letters, numbers, and underscores"
+  }),
+  email: external_exports.string().email(),
+  password: external_exports.string().min(8, { message: "Password must contain at least 8 characters" }),
+  types: external_exports.array(external_exports.nativeEnum(UserType)),
+  referrerUserId: external_exports.number().optional(),
+  instanceId: external_exports.number()
+});
+var usernameSchema = external_exports.string().min(1).regex(usernameValidationRegex, {
+  message: "Username can only contain letters, numbers, and underscores"
+});
+var baseRegisterSchema = external_exports.object({
+  username: usernameSchema,
+  types: external_exports.array(external_exports.nativeEnum(UserType)).default([]),
+  referrerUserId: external_exports.number().optional(),
+  instanceId: external_exports.number(),
+  platform: external_exports.enum(["web", "mobile"]).optional()
+});
+var passwordRegisterSchema = baseRegisterSchema.extend({
+  password: external_exports.string().min(8, { message: "Password must contain at least 8 characters" }),
+  recaptchaToken: external_exports.string().optional()
+});
+var createSourceSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  description: external_exports.string().optional(),
+  requirements: external_exports.array(
+    external_exports.enum([
+      "GOVERNMENT_SOURCE" /* GOVERNMENT_SOURCE */,
+      "ENTERPRISE_SOURCE" /* ENTERPRISE_SOURCE */,
+      "ANONYMOUS_SOURCE" /* ANONYMOUS_SOURCE */,
+      "HUMAN_SOURCE" /* HUMAN_SOURCE */
+    ])
+  )
+});
+var contactFormSchema = external_exports.object({
+  name: external_exports.string().min(1).max(100),
+  email: external_exports.string().max(254).optional(),
+  phone: external_exports.string().max(20).optional(),
+  message: external_exports.string().min(1).max(2e3),
+  age: external_exports.string().optional()
+}).refine((data) => !!data.email || !!data.phone, {
+  message: "Either email or phone is required"
+});
+var donationSchema = external_exports.object({
+  amount: external_exports.number().int().min(100).max(1e6),
+  // Amount in cents (integer)
+  email: external_exports.string().email()
+});
+var getUploadUrlsSchema = external_exports.object({
+  contentType: external_exports.enum(ALLOWED_CONTENT_TYPES_TUPLE),
+  name: external_exports.string().optional(),
+  width: external_exports.number().int().positive().max(25e3).optional(),
+  height: external_exports.number().int().positive().max(25e3).optional(),
+  isPrivate: external_exports.boolean().optional().default(false),
+  // Chat attachments pass the conversation instead of an isPrivate flag: the
+  // server resolves privacy from the channel's space so the client can't
+  // decide to make a PRIVATE space's files public. See uploads.getUploadUrls.
+  conversationId: external_exports.string().uuid().optional(),
+  isFactiii: external_exports.boolean().default(false),
+  factiiiId: external_exports.number().int().positive().optional(),
+  rawSha256: external_exports.string().regex(/^[a-f0-9]{64}$/i, "rawSha256 must be 64 hex chars")
+}).refine(
+  (d) => d.width === void 0 && d.height === void 0 || d.width !== void 0 && d.height !== void 0,
+  { message: "width and height must be provided together" }
+).refine((d) => !d.isFactiii || d.factiiiId !== void 0, {
+  message: "factiiiId is required when isFactiii is true"
+});
+var finalizeUploadSchema = external_exports.object({
+  uploadId: external_exports.string(),
+  isFactiii: external_exports.boolean(),
+  raw: external_exports.object({
+    // Bare-uuid keys; variant kind is the DB-level discriminator, no S3 prefix.
+    key: external_exports.string().min(1),
+    size: external_exports.number().int().positive(),
+    sha256: external_exports.string().regex(/^[a-f0-9]{64}$/i),
+    width: external_exports.number().int().positive().optional(),
+    height: external_exports.number().int().positive().optional()
+  }),
+  view: external_exports.object({
+    key: external_exports.string().min(1),
+    size: external_exports.number().int().positive(),
+    sha256: external_exports.string().regex(/^[a-f0-9]{64}$/i),
+    width: external_exports.number().int().positive(),
+    height: external_exports.number().int().positive()
+  }).nullable()
+  // null for non-image uploads
+});
+var variantKindSchema = external_exports.enum([
+  "RAW",
+  "VIEW",
+  "PREMIUM_HD",
+  "PREMIUM_RAW",
+  "THUMBNAIL"
+]);
+var adminUploadsGetVariantUrlSchema = external_exports.object({
+  uploadId: external_exports.string(),
+  kind: variantKindSchema,
+  expiresIn: external_exports.number().int().positive().max(3600).default(300)
+});
+var getUploadSchema = external_exports.object({
+  id: external_exports.string()
+});
+var priceSchema = external_exports.number().int().min(0, "Price must be a positive integer in cents");
+var checkPurchaseSchema = external_exports.object({
+  productId: external_exports.string(),
+  type: external_exports.enum(["STRIPE", "GOOGLE", "APPLE"]),
+  receivedPrice: external_exports.number().int().min(0, "Received price must be a positive integer in cents"),
+  currency: external_exports.string().length(3).default("USD")
+});
+var creditPurchaseSchema = external_exports.object({
+  orderId: external_exports.string(),
+  transactionDate: external_exports.number(),
+  receivedPrice: external_exports.number().int().min(0, "Received price must be a positive integer in cents"),
+  type: external_exports.enum(["STRIPE", "GOOGLE", "APPLE"]),
+  secret: external_exports.string(),
+  // Required for APPLE/GOOGLE IAP — used for server-side receipt verification
+  purchaseToken: external_exports.string().optional()
+});
+var dsarFormSchema = external_exports.object({
+  name: external_exports.string().trim().min(1, "Please enter your name.").max(100, "Please keep your name under 100 characters."),
+  email: external_exports.string().trim().min(1, "Please enter your email address.").email("Please enter a valid email address."),
+  selectedAs: external_exports.enum(["person", "agent"]),
+  requestUnder: external_exports.enum(["GDPR", "CCPA", "OTHER"]),
+  selectedTo: external_exports.enum(["knowledge", "delete", "optOut", "optIn", "other"]),
+  details: external_exports.string().trim().min(1, "Please provide details about your request.").max(5e3, "Please keep details under 5000 characters."),
+  confirmAccuracy: external_exports.boolean().refine((value2) => value2, "Please confirm your information is accurate."),
+  confirmConsequences: external_exports.boolean().refine(
+    (value2) => value2,
+    "Please acknowledge the deletion/restriction consequences."
+  ),
+  confirmVerification: external_exports.boolean().refine((value2) => value2, "Please acknowledge the email verification step.")
+});
+var mapLinkSchema = external_exports.object({
+  startPosition: external_exports.object({
+    postId: external_exports.string().optional(),
+    latitude: external_exports.number().min(-90).max(90, { message: "Latitude must be between -90 and 90" }),
+    longitude: external_exports.number().min(-180).max(180, { message: "Longitude must be between -180 and 180" })
+  }),
+  pins: external_exports.array(
+    external_exports.object({
+      postId: external_exports.string().uuid({ message: "Pin ID must be a valid UUID" }),
+      latitude: external_exports.number().min(-90).max(90, { message: "Pin latitude must be between -90 and 90" }),
+      longitude: external_exports.number().min(-180).max(180, { message: "Pin longitude must be between -180 and 180" })
+    })
+  ).optional().default([])
+});
+var mapLinkPostIds = mapLinkSchema.transform((data) => {
+  return {
+    startPosition: {
+      postId: data.startPosition.postId,
+      latitude: data.startPosition.latitude,
+      longitude: data.startPosition.longitude
+    },
+    pins: data.pins.map((pin) => ({
+      postId: pin.postId,
+      latitude: pin.latitude,
+      longitude: pin.longitude
+    }))
+  };
+});
+var mapLinkHref = mapLinkSchema.transform((data) => {
+  const latParam = `latitude=${encodeURIComponent(data.startPosition.latitude)}`;
+  const lonParam = `longitude=${encodeURIComponent(
+    data.startPosition.longitude
+  )}`;
+  const pinsParam = data.pins.length > 0 ? `pins=${encodeURIComponent(JSON.stringify(data.pins))}` : "";
+  return {
+    startPosition: {
+      postId: data.startPosition.postId,
+      latitude: data.startPosition.latitude,
+      longitude: data.startPosition.longitude
+    },
+    href: `${data.startPosition.postId ? `postId=${data.startPosition.postId}&` : ""}${latParam}&${lonParam}${pinsParam ? `&${pinsParam}` : ""}`
+  };
+});
+var wikipediaUrlSchema = external_exports.string().refine(
+  (url2) => {
+    try {
+      const parsedUrl = new URL(url2);
+      return parsedUrl.hostname.endsWith(".wikipedia.org") && parsedUrl.protocol === "https:" && parsedUrl.pathname.startsWith("/wiki/") && parsedUrl.pathname.length > 6;
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "Invalid Wikipedia URL. Must be a valid HTTPS URL from wikipedia.org with /wiki/ path and article title"
+  }
+);
+var localPreferenceSchema = external_exports.object({
+  postFilterType: external_exports.enum(["trending", "new", "popular"]),
+  postSortBy: external_exports.nativeEnum(postDataSort),
+  filterBot: external_exports.boolean(),
+  filterNew: external_exports.boolean(),
+  showBoards: external_exports.boolean(),
+  displayMode: external_exports.enum(["data", "posts", "sortByFactiii", "mediaSearch"]),
+  postModeType: external_exports.enum(["home", "explore"]),
+  muteVideo: external_exports.boolean(),
+  theme: external_exports.enum(["dark", "light"]),
+  selectedFactiiis: external_exports.array(external_exports.number()),
+  dataFilter: external_exports.string(),
+  mediaSearch: external_exports.string()
+});
+var localPreferenceUrlParamsSchema = external_exports.object({
+  postFilterType: external_exports.enum(["trending", "new", "popular"]).optional(),
+  postSortBy: external_exports.nativeEnum(postDataSort).optional(),
+  filterBot: external_exports.preprocess((val) => val === "true", external_exports.boolean()).optional(),
+  showBoards: external_exports.preprocess((val) => val === "true", external_exports.boolean()).optional(),
+  displayMode: external_exports.enum(["data", "posts", "sortByFactiii", "mediaSearch"]).optional(),
+  postModeType: external_exports.enum(["home", "explore"]).optional(),
+  selectedFactiiis: external_exports.preprocess((val) => {
+    if (!val || typeof val !== "string") return [];
+    return val.split(",").map(Number).filter((id) => !isNaN(id));
+  }, external_exports.array(external_exports.number())).optional()
+});
+var productSchema = external_exports.object({
+  id: external_exports.number(),
+  title: external_exports.string(),
+  description: external_exports.string().nullable(),
+  price: external_exports.number(),
+  createdAt: external_exports.date(),
+  active: external_exports.boolean(),
+  originalInventory: external_exports.number().optional().nullable().transform((val) => val === void 0 ? null : val),
+  inventory: external_exports.number(),
+  discount: external_exports.number(),
+  type: external_exports.enum(["TRON", "MONTHLY_SUBSCRIPTION", "FOUNDERS_TOKEN", "DONATION"]),
+  appStoreProductId: external_exports.string().nullable(),
+  playStoreProductId: external_exports.string().nullable(),
+  stripePriceId: external_exports.string().nullable(),
+  spaceSlug: external_exports.string(),
+  images: external_exports.array(external_exports.string()),
+  // Trons granted to the buyer on purchase + premium days granted. Only meaningful
+  // for TRON and FOUNDERS_TOKEN; other product types ignore these. Optional so the
+  // admin form can omit them when editing subscription/donation rows.
+  tronQuantity: external_exports.number().int().min(0).optional(),
+  tronPremiumDays: external_exports.number().int().min(0).optional()
+});
+var adminTransferSpaceOwnershipSchema = external_exports.object({
+  spaceId: external_exports.number(),
+  newOwnerUserId: external_exports.number()
+});
+var baseSchema = {
+  cursor: external_exports.union([external_exports.string(), external_exports.number()]).optional(),
+  type: external_exports.enum(["new", "trending", "popular", "board"]).optional(),
+  filterBots: external_exports.boolean().optional(),
+  // Omitted = show; hiding new accounts is opt-in via the quick filter.
+  filterNewAccounts: external_exports.boolean().optional(),
+  showBoards: external_exports.boolean().optional(),
+  factiiiIds: external_exports.number().array().optional(),
+  strictFactiiiIds: external_exports.number().array().optional(),
+  //used for getting posts by relatedfactiiicountgroup
+  dataFilter: external_exports.string().optional(),
+  start: external_exports.date().optional(),
+  end: external_exports.date().optional()
+};
+var postFeedInputSchema = external_exports.discriminatedUnion("source", [
+  external_exports.object({
+    source: external_exports.literal("home"),
+    ...baseSchema
+  }),
+  external_exports.object({
+    source: external_exports.literal("explore"),
+    ...baseSchema
+  }),
+  external_exports.object({
+    source: external_exports.literal("user"),
+    username: external_exports.string(),
+    ...baseSchema
+  }),
+  external_exports.object({
+    source: external_exports.literal("space"),
+    spaceSlug: external_exports.string(),
+    spaceRenderType: external_exports.enum(["USER_FACING", "SPACE_FACING", "BOTH"]).optional(),
+    ...baseSchema
+  }),
+  external_exports.object({
+    source: external_exports.literal("saved"),
+    ...baseSchema
+  }),
+  external_exports.object({
+    source: external_exports.literal("factiiis"),
+    ...baseSchema
+  }),
+  // Every anonymous post, author masked. Backs /user/Anonymous%20User, which is
+  // where anonymous posts' author links point.
+  external_exports.object({
+    source: external_exports.literal("anonymous"),
+    ...baseSchema
+  }),
+  external_exports.object({
+    source: external_exports.literal("search"),
+    query: external_exports.string().optional(),
+    spaceRenderType: external_exports.enum(["USER_FACING", "SPACE_FACING", "BOTH"]).optional(),
+    userIds: external_exports.number().array().optional(),
+    spaceIds: external_exports.number().array().optional(),
+    ...baseSchema
+  })
+]);
+var donateTronsSchema = external_exports.object({
+  amount: external_exports.number().int().positive()
+});
+var communityPoolModeSchema = external_exports.enum(["OFF", "WHITELIST", "OPEN"]);
+var communityPoolConfigSchema = external_exports.object({
+  mode: communityPoolModeSchema,
+  userCapPer4h: external_exports.number().int().min(0),
+  poolCapPer4h: external_exports.number().int().min(0)
+});
+var crossPostPlatformEnum = external_exports.enum([
+  "TIKTOK",
+  "YOUTUBE",
+  "INSTAGRAM",
+  "FACEBOOK",
+  "TWITTER",
+  "LINKEDIN",
+  "REDDIT"
+]);
+var crossPostSchema = external_exports.object({
+  postId: external_exports.number().int().positive(),
+  platforms: external_exports.array(crossPostPlatformEnum).min(1)
+});
+var tiktokPostOptionsSchema = external_exports.object({
+  postId: external_exports.number().int().positive(),
+  privacyLevel: external_exports.enum([
+    "PUBLIC_TO_EVERYONE",
+    "MUTUAL_FOLLOW_FRIENDS",
+    "FOLLOWER_OF_CREATOR",
+    "SELF_ONLY"
+  ]),
+  disableComment: external_exports.boolean().default(false),
+  disableDuet: external_exports.boolean().default(false),
+  disableStitch: external_exports.boolean().default(false),
+  videoCoverTimestampMs: external_exports.number().int().min(0).optional(),
+  isAiGenerated: external_exports.boolean().default(false)
+});
+var crossPostSubmitSchema = external_exports.object({
+  postId: external_exports.string(),
+  platforms: external_exports.array(crossPostPlatformEnum).min(1).max(5)
+});
+var apiCostUpdateSchema = external_exports.object({
+  platform: crossPostPlatformEnum,
+  readCostTrons: external_exports.number().int().min(0),
+  pushCostTrons: external_exports.number().int().min(0),
+  costSource: external_exports.enum(["manual", "api"]),
+  notes: external_exports.string().max(500).optional()
+});
+var startSessionSchema = external_exports.object({
+  isDaily: external_exports.boolean().default(false)
+});
+var submitAnswerSchema = external_exports.object({
+  sessionId: external_exports.number().int(),
+  postId: external_exports.number().int(),
+  answeredFact: external_exports.boolean(),
+  timeMs: external_exports.number().int().min(0).max(15e3)
+});
+var endSessionSchema = external_exports.object({
+  sessionId: external_exports.number().int()
+});
+var getLeaderboardSchema = external_exports.object({
+  period: external_exports.enum(["daily", "weekly", "allTime"]),
+  limit: external_exports.number().int().min(1).max(50).default(50)
+});
+var getSessionResultSchema = external_exports.object({
+  sessionId: external_exports.number().int()
+});
+var forgeElementName = external_exports.string().trim().min(1).max(24);
+var forgeCombineSchema = external_exports.object({
+  a: forgeElementName,
+  b: forgeElementName
+});
+var forgeLeaderboardSchema = external_exports.object({
+  limit: external_exports.number().int().min(1).max(50).default(25)
+});
+var arcadeGameSlug = external_exports.enum([
+  "circle",
+  "password",
+  "forge",
+  "spend",
+  "dilemmas",
+  "clicker",
+  "deep",
+  "robot",
+  "space"
+]);
+var recordGameStatSchema = external_exports.object({
+  game: arcadeGameSlug,
+  /** Canonical sortable score for that game; direction is decided client-side. */
+  best: external_exports.number().finite(),
+  /** Per-game extras, kept small — this lands in a JSON column. */
+  detail: external_exports.record(external_exports.string(), external_exports.union([external_exports.string(), external_exports.number()])).optional()
+});
+var dilemmaVoteSchema = external_exports.object({
+  dilemmaId: external_exports.number().int().min(1).max(200),
+  pulled: external_exports.boolean()
+});
+var SKILL_NAME_REGEX = /^[a-zA-Z0-9._-]+$/;
+var skillNameSchema = external_exports.string().min(1).max(64).regex(SKILL_NAME_REGEX, {
+  message: "Use only letters, numbers, dots, dashes and underscores"
+});
+var skillFrontmatterSchema = external_exports.object({
+  name: skillNameSchema,
+  description: external_exports.string().min(1, { message: "Description is required" }),
+  // Both CLIs accept a comma-separated string or a YAML list; normalised to
+  // a list on parse and written back as a list.
+  "allowed-tools": external_exports.array(external_exports.string()).optional(),
+  model: external_exports.string().optional(),
+  license: external_exports.string().optional(),
+  metadata: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  "disable-model-invocation": external_exports.literal(false).optional()
+}).strict();
+var skillAgentSchema = external_exports.enum(["claude", "codex"]);
+var skillScopeSchema = external_exports.enum(["global", "repo"]);
+
+// ../../shared/all/helpers/board-agent-core/skill-format.ts
+var EMPTY_FRONTMATTER = { name: "", description: "" };
+function splitKey(line) {
+  const at = line.indexOf(":");
+  if (at < 1) return null;
+  return { key: line.slice(0, at).trim(), value: line.slice(at + 1).trim() };
+}
+function stripQuotes(value2) {
+  const quoted = value2.startsWith('"') && value2.endsWith('"') || value2.startsWith("'") && value2.endsWith("'");
+  return quoted && value2.length > 1 ? value2.slice(1, -1) : value2;
+}
+function parseSkill(raw) {
+  const text = raw.replace(/^/, "");
+  if (!text.startsWith("---")) {
+    return {
+      frontmatter: EMPTY_FRONTMATTER,
+      body: text,
+      errors: ["Must start with YAML frontmatter (---)."]
+    };
+  }
+  const lines = text.split("\n");
+  const end = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+  if (end === -1) {
+    return {
+      frontmatter: EMPTY_FRONTMATTER,
+      body: text,
+      errors: ["Frontmatter is never closed (missing the second ---)."]
+    };
+  }
+  const errors = [];
+  const fields = {};
+  let pendingKey = "";
+  let list = [];
+  let map = {};
+  const flush = () => {
+    if (pendingKey) {
+      if (list.length) fields[pendingKey] = list;
+      else if (Object.keys(map).length) fields[pendingKey] = map;
+    }
+    pendingKey = "";
+    list = [];
+    map = {};
+  };
+  for (const line of lines.slice(1, end)) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const indented = /^\s/.test(line);
+    if (indented && pendingKey) {
+      if (line.trim().startsWith("- ")) {
+        list.push(stripQuotes(line.trim().slice(2).trim()));
+      } else {
+        const nested = splitKey(line);
+        if (nested) map[nested.key] = stripQuotes(nested.value);
+        else errors.push(`Cannot read indented line: ${line.trim()}`);
+      }
+      continue;
+    }
+    if (indented) {
+      errors.push(`Cannot read indented line: ${line.trim()}`);
+      continue;
+    }
+    flush();
+    const pair = splitKey(line);
+    if (!pair) {
+      errors.push(`Cannot read line: ${line.trim()}`);
+      continue;
+    }
+    if (pair.value === "") {
+      pendingKey = pair.key;
+      continue;
+    }
+    fields[pair.key] = stripQuotes(pair.value);
+  }
+  flush();
+  const tools = fields["allowed-tools"];
+  if (typeof tools === "string") {
+    fields["allowed-tools"] = tools.split(",").map((tool) => tool.trim()).filter(Boolean);
+  }
+  if (fields["disable-model-invocation"] === "true") {
+    errors.push("disable-model-invocation must be false.");
+    delete fields["disable-model-invocation"];
+  }
+  if (fields["disable-model-invocation"] === "false") {
+    fields["disable-model-invocation"] = false;
+  }
+  const body = lines.slice(end + 1).join("\n").replace(/^\n/, "");
+  const parsed = skillFrontmatterSchema.safeParse(fields);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      errors.push(`${issue.path.join(".") || "frontmatter"}: ${issue.message}`);
+    }
+    return {
+      frontmatter: {
+        name: typeof fields.name === "string" ? fields.name : "",
+        description: typeof fields.description === "string" ? fields.description : ""
+      },
+      body,
+      errors
+    };
+  }
+  return { frontmatter: parsed.data, body, errors };
+}
+function resolveSkillDir(root, name) {
+  if (!SKILL_NAME_REGEX.test(name) || name === "." || name === "..") {
+    throw new Error(`Invalid skill name: ${name}`);
+  }
+  return `${root.replace(/[/\\]+$/, "")}/${name}`;
+}
+
+// ../../shared/all/helpers/board-agent-core/host-skills.ts
+var AGENTS_ROOT = ".agents/skills";
+var CLAUDE_ROOT = ".claude/skills";
+var CLI_ROOTS = [CLAUDE_ROOT, ".codex/skills"];
+function globalAgentsRoot() {
+  return import_path8.default.join(import_os2.default.homedir(), ".agents", "skills");
+}
+var AGENTS_LINK_TARGET = "../.agents/skills";
+var BRANCH_PREFIX = "skill/";
+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_path8.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_promises5.default.readlink(linkPath).catch(() => "");
+  return target.replace(/\/+$/, "") === AGENTS_LINK_TARGET ? "linked" : "missing";
+}
+async function globalLinkState() {
+  const states = await Promise.all(CLI_ROOTS.map(rootLinkState));
+  if (states.includes("blocked")) return "blocked";
+  return states.includes("missing") ? "missing" : "linked";
+}
+async function listGlobal() {
+  const root = globalAgentsRoot();
+  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_path8.default.join(root, entry.name);
+    const raw = await import_promises5.default.readFile(import_path8.default.join(dir, "SKILL.md"), "utf-8").catch(() => "");
+    if (!raw) continue;
+    out.push(
+      summarize(raw, {
+        name: entry.name,
+        scope: "global",
+        dir,
+        status: "live",
+        pendingBranch: ""
+      })
+    );
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function strayRepoSkills(liveBlobs) {
+  return [...liveBlobs.keys()].filter((key) => CLI_ROOTS.some((root) => key.startsWith(`${root}/`))).sort();
+}
+async function treeAt(repo, ref) {
+  const raw = await hostGit(
+    repo,
+    "ls-tree",
+    "-r",
+    ref,
+    "--",
+    AGENTS_ROOT,
+    ...CLI_ROOTS
+  ).catch(() => "");
+  return raw.split("\n").filter(Boolean).map((line) => {
+    const [meta, filePath] = line.split("	");
+    const [mode, , sha] = meta.split(/\s+/);
+    return { mode, sha, filePath };
+  }).filter((entry) => Boolean(entry.filePath));
+}
+function skillBlobs(entries) {
+  const blobs = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const match = /^(.+\/skills)\/([^/]+)\/SKILL\.md$/.exec(entry.filePath);
+    if (match) blobs.set(`${match[1]}/${match[2]}`, entry.sha);
+  }
+  return blobs;
+}
+async function skillLinks(repo, entries) {
+  const links = /* @__PURE__ */ new Map();
+  const linkEntries = entries.filter(
+    (entry) => entry.mode === SYMLINK_MODE && /^.+\/skills(\/[^/]+)?$/.test(entry.filePath)
+  );
+  const targets = await gitCatFileBatch(
+    repo,
+    linkEntries.map((entry) => entry.sha)
+  );
+  for (const entry of linkEntries) {
+    const target = targets.get(entry.sha)?.trim();
+    if (target) links.set(entry.filePath, target);
+  }
+  return links;
+}
+function resolveRepoSkills(liveBlobs, pending) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const key of liveBlobs.keys()) {
+    if (key.startsWith(`${AGENTS_ROOT}/`)) keys.add(key);
+  }
+  for (const entry of pending) {
+    for (const key of entry.blobs.keys()) {
+      if (key.startsWith(`${AGENTS_ROOT}/`)) keys.add(key);
+    }
+  }
+  const out = [];
+  for (const key of [...keys].sort()) {
+    const name = key.slice(AGENTS_ROOT.length + 1);
+    const live = liveBlobs.get(key) || "";
+    const onBranch = pending.find((entry) => {
+      const sha = entry.blobs.get(key);
+      return Boolean(sha) && sha !== live;
+    });
+    const status = live ? onBranch ? "pending-edit" : "live" : "pending-new";
+    out.push({
+      name,
+      dir: key,
+      status,
+      pendingBranch: status === "live" ? "" : onBranch?.branch || "",
+      sha: live || onBranch?.blobs.get(key) || ""
+    });
+  }
+  return out;
+}
+async function repoSkills(ctx) {
+  const skills = resolveRepoSkills(ctx.liveBlobs, ctx.pending);
+  const cache2 = /* @__PURE__ */ new Map();
+  const missing = skills.map((skill) => skill.sha).filter((sha) => sha && !cache2.has(sha));
+  for (const [sha, text] of await gitCatFileBatch(ctx.repo, missing)) {
+    cache2.set(sha, text);
+  }
+  return skills.map(
+    (skill) => summarize(cache2.get(skill.sha) ?? "", {
+      name: skill.name,
+      scope: "repo",
+      dir: skill.dir,
+      status: skill.status,
+      pendingBranch: skill.pendingBranch
+    })
+  );
+}
+async function pendingBranches(repo, mainBranch) {
+  const refs = await hostGit(
+    repo,
+    "for-each-ref",
+    "--sort=-committerdate",
+    "--format=%(refname:short)",
+    `refs/remotes/origin/${BRANCH_PREFIX}*`
+  ).catch(() => "");
+  const branches = await Promise.all(
+    refs.split("\n").filter(Boolean).map(async (ref) => {
+      const merged = await hostGit(
+        repo,
+        "merge-base",
+        "--is-ancestor",
+        ref,
+        `origin/${mainBranch}`
+      ).then(
+        () => true,
+        () => false
+      );
+      if (merged) return null;
+      return {
+        branch: ref.replace(/^origin\//, ""),
+        blobs: skillBlobs(await treeAt(repo, ref))
+      };
+    })
+  );
+  return branches.filter((entry) => entry !== null);
+}
+function requireRepo(opts) {
+  if (!opts.repoUrl || !opts.githubToken) {
+    throw new Error("Set the repository URL and GitHub token first.");
+  }
+  return {
+    spaceDir: opts.spaceDir,
+    repoUrl: opts.repoUrl,
+    mainBranch: opts.mainBranch,
+    githubToken: opts.githubToken
+  };
+}
+async function ensureSkillsRepo(opts) {
+  const { spaceDir, repoUrl, mainBranch, githubToken } = requireRepo(opts);
+  const paths = hostSpacePaths(spaceDir);
+  const branch = (mainBranch || "main").replace(/[^\w./-]/g, "");
+  const url2 = buildCloneUrl(repoUrl, githubToken);
+  try {
+    await hostGit(paths.repo, "rev-parse", "--git-dir");
+    await hostGit(paths.repo, "remote", "set-url", "origin", url2);
+  } catch {
+    await hostGit(paths.root, "clone", "--branch", branch, url2, paths.repo);
+  }
+  await hostGit(
+    paths.repo,
+    "fetch",
+    "origin",
+    branch,
+    `+refs/heads/${BRANCH_PREFIX}*:refs/remotes/origin/${BRANCH_PREFIX}*`
+  );
+  return { repo: paths.repo, branch };
+}
+async function ensureSkillsWorktree(spaceDir, branch) {
+  const { repo, skills: worktree } = hostSpacePaths(spaceDir);
+  try {
+    await hostGit(worktree, "rev-parse", "--git-dir");
+  } catch {
+    await hostGit(repo, "worktree", "prune").catch(() => {
+    });
+    await import_promises5.default.rm(worktree, { recursive: true, force: true });
+    await hostGit(
+      repo,
+      "worktree",
+      "add",
+      "--detach",
+      worktree,
+      `origin/${branch}`
+    );
+  }
+  return worktree;
+}
+async function repoContext(opts) {
+  const { repo, branch } = await ensureSkillsRepo(opts);
+  const liveTree = await treeAt(repo, `origin/${branch}`);
+  const [links, pending] = await Promise.all([
+    skillLinks(repo, liveTree),
+    pendingBranches(repo, branch)
+  ]);
+  return {
+    repo,
+    branch,
+    liveTree,
+    liveBlobs: skillBlobs(liveTree),
+    links,
+    pending
+  };
+}
+function findRepoSkill(ctx, name) {
+  return resolveRepoSkills(ctx.liveBlobs, ctx.pending).find(
+    (skill) => skill.name === name
+  ) ?? null;
+}
+var workspaceQueues = /* @__PURE__ */ new Map();
+function withWorkspace(spaceDir, run2) {
+  const next = (workspaceQueues.get(spaceDir) ?? Promise.resolve()).then(
+    run2,
+    run2
+  );
+  workspaceQueues.set(
+    spaceDir,
+    next.catch(() => {
+    })
+  );
+  return next;
+}
+function repoLinkState(ctx) {
+  const target = ctx.links.get(CLAUDE_ROOT);
+  if (target) return target === AGENTS_LINK_TARGET ? "linked" : "missing";
+  return [...ctx.liveBlobs.keys()].some(
+    (key) => key.startsWith(`${CLAUDE_ROOT}/`)
+  ) ? "blocked" : "missing";
+}
+async function listSkillsImpl(opts) {
+  const [global2, globalLink] = await Promise.all([
+    listGlobal(),
+    globalLinkState()
+  ]);
+  if (!opts.repoUrl || !opts.githubToken) {
+    return {
+      global: global2,
+      repo: [],
+      globalLink,
+      repoLink: "linked",
+      repoBranch: "",
+      repoAvailable: false
+    };
+  }
+  const ctx = await repoContext(opts);
+  const repo = await repoSkills(ctx);
+  return {
+    global: global2,
+    repo,
+    globalLink,
+    repoLink: repoLinkState(ctx),
+    repoBranch: ctx.branch,
+    repoAvailable: true
+  };
+}
+async function bundleFilesOnDisk(dir) {
+  const out = [];
+  const walk = async (current, prefix, depth) => {
+    if (depth > 3 || out.length >= 200) return;
+    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_path8.default.join(current, entry.name), rel, depth + 1);
+      } else if (rel !== "SKILL.md") {
+        out.push(rel);
+      }
+    }
+  };
+  await walk(dir, "", 0);
+  return out.sort();
+}
+async function readSkillImpl(opts) {
+  if (opts.scope === "global") {
+    const dir = resolveSkillDir(globalAgentsRoot(), opts.name);
+    const content2 = await import_promises5.default.readFile(import_path8.default.join(dir, "SKILL.md"), "utf-8");
+    const { frontmatter: frontmatter2, errors: errors2 } = parseSkill(content2);
+    return {
+      name: opts.name,
+      scope: "global",
+      content: content2,
+      frontmatter: frontmatter2,
+      errors: errors2,
+      bundleFiles: await bundleFilesOnDisk(dir),
+      status: "live",
+      pendingBranch: ""
+    };
+  }
+  const ctx = await repoContext(opts);
+  const skill = findRepoSkill(ctx, opts.name);
+  if (!skill) throw new Error(`No repo skill named ${opts.name}.`);
+  const draft = skill.pendingBranch ? ctx.pending.find((entry) => entry.branch === skill.pendingBranch)?.blobs.get(skill.dir) : "";
+  const content = await hostGit(ctx.repo, "cat-file", "-p", draft || skill.sha);
+  const { frontmatter, errors } = parseSkill(content);
+  const tree = draft ? await treeAt(ctx.repo, `origin/${skill.pendingBranch}`) : ctx.liveTree;
+  const bundleFiles = tree.filter(
+    (entry) => entry.filePath.startsWith(`${skill.dir}/`) && entry.filePath !== `${skill.dir}/SKILL.md`
+  ).map((entry) => entry.filePath.slice(skill.dir.length + 1)).sort();
+  return {
+    name: skill.name,
+    scope: "repo",
+    content,
+    frontmatter,
+    errors,
+    bundleFiles,
+    status: skill.status,
+    pendingBranch: skill.pendingBranch
+  };
+}
+async function moveIntoAgents(from, to) {
+  if (await import_promises5.default.access(to).then(
+    () => true,
+    () => false
+  )) {
+    throw new Error(
+      `${import_path8.default.basename(to)} exists in both roots. Remove one copy, then migrate.`
+    );
+  }
+  await import_promises5.default.mkdir(import_path8.default.dirname(to), { recursive: true });
+  try {
+    await import_promises5.default.rename(from, to);
+  } catch {
+    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_path8.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_promises5.default.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.isFile() || entry.isSymbolicLink()) continue;
+      const src = import_path8.default.join(dir, entry.name);
+      if (!await import_promises5.default.access(import_path8.default.join(src, "SKILL.md")).then(
+        () => true,
+        () => false
+      )) {
+        continue;
+      }
+      await moveIntoAgents(src, import_path8.default.join(globalAgentsRoot(), entry.name));
+      moved.push(entry.name);
+    }
+    await import_promises5.default.rmdir(dir).catch(() => {
+    });
+  }
+  for (const root of CLI_ROOTS) {
+    const linkPath = import_path8.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_promises5.default.mkdir(import_path8.default.dirname(linkPath), { recursive: true });
+    await import_promises5.default.symlink(AGENTS_LINK_TARGET, linkPath, "dir");
+  }
+  return moved;
+}
+async function migrateSkillsImpl(opts) {
+  if (opts.scope === "global") {
+    return { branch: "", moved: await migrateGlobal() };
+  }
+  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: [] };
+  }
+  const { branch } = ctx;
+  const workspace = await ensureSkillsWorktree(opts.spaceDir, branch);
+  const target = `${BRANCH_PREFIX}migrate`;
+  await hostGit(workspace, "checkout", "-B", target, `origin/${branch}`);
+  await hostGit(workspace, "clean", "-fd");
+  if (opts.gitName) {
+    await hostGit(workspace, "config", "user.name", opts.gitName);
+  }
+  if (opts.gitEmail) {
+    await hostGit(workspace, "config", "user.email", opts.gitEmail);
+  }
+  const moved = [];
+  for (const stray of strays) {
+    const name = stray.slice(stray.lastIndexOf("/") + 1);
+    const dest = `${AGENTS_ROOT}/${name}`;
+    if (ctx.liveBlobs.has(dest)) {
+      throw new Error(
+        `${name} exists in both ${AGENTS_ROOT} and ${stray}. Remove one copy, then migrate.`
+      );
+    }
+    await import_promises5.default.mkdir(import_path8.default.join(workspace, AGENTS_ROOT), { recursive: true });
+    await hostGit(workspace, "mv", stray, dest);
+    moved.push(name);
+  }
+  const linkPath = import_path8.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: [] };
+  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 };
+}
+function assertWritable(name, content) {
+  const parsed = parseSkill(content);
+  if (parsed.errors.length) {
+    throw new Error(`Fix the skill first: ${parsed.errors.join(" ")}`);
+  }
+  if (parsed.frontmatter.name !== name) {
+    throw new Error(
+      `Frontmatter name (${parsed.frontmatter.name}) must match the skill directory (${name}).`
+    );
+  }
+}
+async function writeGlobalSkill(opts) {
+  assertWritable(opts.name, opts.content);
+  const dir = resolveSkillDir(globalAgentsRoot(), opts.name);
+  await import_promises5.default.mkdir(dir, { recursive: true });
+  await import_promises5.default.writeFile(import_path8.default.join(dir, "SKILL.md"), opts.content, "utf-8");
+}
+async function deleteGlobalSkill(opts) {
+  const dir = resolveSkillDir(globalAgentsRoot(), opts.name);
+  await import_promises5.default.rm(dir, { recursive: true, force: true });
+}
+async function proposeRepoSkillImpl(opts) {
+  assertWritable(opts.name, opts.content);
+  if (!SKILL_NAME_REGEX.test(opts.name)) {
+    throw new Error(`Invalid skill name: ${opts.name}`);
+  }
+  const ctx = await repoContext(opts);
+  const known = findRepoSkill(ctx, opts.name);
+  const dir = known?.dir || `${AGENTS_ROOT}/${opts.name}`;
+  const { branch } = ctx;
+  const workspace = await ensureSkillsWorktree(opts.spaceDir, branch);
+  const target = `${BRANCH_PREFIX}${opts.name}`;
+  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/${target}`);
+  } else {
+    await hostGit(workspace, "checkout", "-B", target, `origin/${branch}`);
+  }
+  await hostGit(workspace, "clean", "-fd");
+  if (opts.gitName) {
+    await hostGit(workspace, "config", "user.name", opts.gitName);
+  }
+  if (opts.gitEmail) {
+    await hostGit(workspace, "config", "user.email", opts.gitEmail);
+  }
+  await import_promises5.default.mkdir(import_path8.default.join(workspace, dir), { recursive: true });
+  await import_promises5.default.writeFile(
+    import_path8.default.join(workspace, dir, "SKILL.md"),
+    opts.content,
+    "utf-8"
+  );
+  const dirty = await hostGit(workspace, "status", "--porcelain");
+  if (!dirty.trim()) return { branch: target };
+  await hostGit(workspace, "add", "-A");
+  await hostGit(
+    workspace,
+    "commit",
+    "-m",
+    `${known ? "Update" : "Add"} skill: ${opts.name}`
+  );
+  await hostGit(workspace, "push", "origin", target);
+  return { branch: target };
+}
+function listSkills(opts) {
+  return withWorkspace(opts.spaceDir, () => listSkillsImpl(opts));
+}
+function readSkill(opts) {
+  return withWorkspace(opts.spaceDir, () => readSkillImpl(opts));
+}
+function migrateSkills(opts) {
+  return withWorkspace(opts.spaceDir, () => migrateSkillsImpl(opts));
+}
+function proposeRepoSkill(opts) {
+  return withWorkspace(opts.spaceDir, () => proposeRepoSkillImpl(opts));
+}
+
 // ../../shared/all/helpers/board-agent-core/onedrive-auth.ts
 var DEVICECODE_URL = "https://login.microsoftonline.com/consumers/oauth2/v2.0/devicecode";
 var TOKEN_URL2 = "https://login.microsoftonline.com/consumers/oauth2/v2.0/token";
@@ -17365,6 +18624,48 @@ var BoardAgentEngine = class _BoardAgentEngine {
       githubToken: config.githubToken
     });
   }
+  // ── Agent skills (SKILL.md) ──
+  // Repo opts are optional here, unlike deploy: the global roots are readable
+  // with no repo configured, and listSkills reports repoAvailable: false.
+  skillOpts() {
+    const config = this.core.readConfig();
+    return {
+      spaceDir: this.core.spaceDir(),
+      repoUrl: config.repoUrl,
+      mainBranch: config.mainBranch,
+      githubToken: config.githubToken
+    };
+  }
+  skillsList() {
+    return listSkills(this.skillOpts());
+  }
+  skillRead(payload) {
+    return readSkill({ ...this.skillOpts(), ...payload });
+  }
+  skillWriteGlobal(payload) {
+    return writeGlobalSkill(payload);
+  }
+  skillDeleteGlobal(payload) {
+    return deleteGlobalSkill(payload);
+  }
+  skillMigrate(payload) {
+    const config = this.core.readConfig();
+    return migrateSkills({
+      ...this.skillOpts(),
+      ...payload,
+      gitName: config.gitName,
+      gitEmail: config.gitEmail
+    });
+  }
+  skillProposeRepo(payload) {
+    const config = this.core.readConfig();
+    return proposeRepoSkill({
+      ...this.skillOpts(),
+      ...payload,
+      gitName: config.gitName,
+      gitEmail: config.gitEmail
+    });
+  }
   deployCreatorState() {
     return this.creatorState;
   }
@@ -17747,7 +19048,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_path8.dirname)(spaceDir), spaceDir };
+    return { configDir: (0, import_path9.dirname)(spaceDir), spaceDir };
   }
   async deploySecretsStatus() {
     return {
@@ -18537,6 +19838,28 @@ ${c.content.trim() || "(no description)"}`
         return await this.bareWorkNames();
       case "deployStatus":
         return await this.deployStatus();
+      case "skillsList":
+        return await this.skillsList();
+      case "skillRead":
+        return await this.skillRead(
+          payload
+        );
+      case "skillWriteGlobal":
+        return await this.skillWriteGlobal(
+          payload
+        );
+      case "skillDeleteGlobal":
+        return await this.skillDeleteGlobal(
+          payload
+        );
+      case "skillMigrate":
+        return await this.skillMigrate(
+          payload
+        );
+      case "skillProposeRepo":
+        return await this.skillProposeRepo(
+          payload
+        );
       case "deployCreateSkill":
         return await this.deployCreateSkill(
           payload,
@@ -18748,9 +20071,9 @@ ${c.content.trim() || "(no description)"}`
 var import_child_process5 = require("child_process");
 var import_crypto3 = require("crypto");
 var import_fs3 = require("fs");
-var import_promises5 = __toESM(require("fs/promises"));
+var import_promises6 = __toESM(require("fs/promises"));
 var import_net2 = require("net");
-var import_path9 = require("path");
+var import_path10 = require("path");
 var import_util7 = require("util");
 var execFileAsync4 = (0, import_util7.promisify)(import_child_process5.execFile);
 var IndexService = class {
@@ -18809,7 +20132,7 @@ var IndexService = class {
     const log = await this.openLog();
     this.proc = (0, import_child_process5.spawn)(
       process.execPath,
-      [(0, import_path9.join)(this.opts.indexDir, "index.js")],
+      [(0, import_path10.join)(this.opts.indexDir, "index.js")],
       {
         cwd: this.opts.indexDir,
         env: {
@@ -18837,8 +20160,8 @@ var IndexService = class {
    *  opened (a missing log must never stop the service from starting). */
   async openLog() {
     try {
-      await import_promises5.default.mkdir(this.opts.dataDir, { recursive: true });
-      return (0, import_fs3.openSync)((0, import_path9.join)(this.opts.dataDir, "index.log"), "a");
+      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");
     } catch {
       return null;
     }
@@ -18847,10 +20170,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_path9.join)(dir, "node_modules"))) return;
-    await import_promises5.default.copyFile(
-      (0, import_path9.join)(dir, "image-package.json"),
-      (0, import_path9.join)(dir, "package.json")
+    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")
     );
     await execFileAsync4(
       "npm",
@@ -18862,15 +20185,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_path9.join)(this.opts.dataDir, ".port");
-    const saved = Number(await import_promises5.default.readFile(file, "utf-8").catch(() => ""));
+    const file = (0, import_path10.join)(this.opts.dataDir, ".port");
+    const saved = Number(await import_promises6.default.readFile(file, "utf-8").catch(() => ""));
     if (Number.isInteger(saved) && saved > 0 && await isFree(saved)) {
       return saved;
     }
     const port = await freePort();
-    await import_promises5.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
+    await import_promises6.default.mkdir(this.opts.dataDir, { recursive: true }).catch(() => {
     });
-    await import_promises5.default.writeFile(file, String(port), "utf-8").catch(() => {
+    await import_promises6.default.writeFile(file, String(port), "utf-8").catch(() => {
     });
     return port;
   }
@@ -19038,24 +20361,24 @@ async function pairWithBrowser(serverUrl) {
 
 // src/config.ts
 var import_fs7 = __toESM(require("fs"));
-var import_os4 = __toESM(require("os"));
-var import_path14 = __toESM(require("path"));
+var import_os5 = __toESM(require("os"));
+var import_path15 = __toESM(require("path"));
 
 // src/secureFile.ts
 var import_crypto6 = __toESM(require("crypto"));
 var import_fs6 = __toESM(require("fs"));
-var import_path13 = __toESM(require("path"));
+var import_path14 = __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_os2 = __toESM(require("os"));
-var import_path10 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+var import_path11 = __toESM(require("path"));
 var SERVICE = "factiii-runner";
 var ACCOUNT = "config-encryption-key";
-var DPAPI_KEY_FILE = import_path10.default.join(
-  import_os2.default.homedir(),
+var DPAPI_KEY_FILE = import_path11.default.join(
+  import_os3.default.homedir(),
   ".factiii-runner",
   "config-key.dpapi"
 );
@@ -19160,7 +20483,7 @@ function winWrite(key) {
     "-Command",
     `ConvertTo-SecureString -String '${key.toString("base64")}' -AsPlainText -Force | ConvertFrom-SecureString`
   ]);
-  import_fs4.default.mkdirSync(import_path10.default.dirname(DPAPI_KEY_FILE), { recursive: true });
+  import_fs4.default.mkdirSync(import_path11.default.dirname(DPAPI_KEY_FILE), { recursive: true });
   import_fs4.default.writeFileSync(DPAPI_KEY_FILE, `${out.trim()}
 `, { mode: 384 });
 }
@@ -19324,21 +20647,21 @@ function keychainStatus() {
 // src/secureStore.ts
 var import_crypto5 = __toESM(require("crypto"));
 var import_fs5 = __toESM(require("fs"));
-var import_path12 = __toESM(require("path"));
+var import_path13 = __toESM(require("path"));
 
 // src/paths.ts
-var import_os3 = __toESM(require("os"));
-var import_path11 = __toESM(require("path"));
-var CONFIG_DIR = import_path11.default.join(import_os3.default.homedir(), ".factiii-runner");
+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");
 function safeSlug(spaceSlug) {
   return spaceSlug.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
 function spaceDirPath(spaceSlug) {
-  return import_path11.default.join(CONFIG_DIR, safeSlug(spaceSlug));
+  return import_path12.default.join(CONFIG_DIR, safeSlug(spaceSlug));
 }
 
 // src/secureStore.ts
-var VAULT_KEY_FILE = import_path12.default.join(CONFIG_DIR, "vault-key.json");
+var VAULT_KEY_FILE = import_path13.default.join(CONFIG_DIR, "vault-key.json");
 var SCRYPT_N2 = 1 << 15;
 var MIN_PASSWORD_LENGTH = 8;
 var SecureStoreError = class extends Error {
@@ -19660,7 +20983,7 @@ function parseEnvelope(raw) {
   }
 }
 function atomicWrite(filePath, body) {
-  import_fs6.default.mkdirSync(import_path13.default.dirname(filePath), { recursive: true });
+  import_fs6.default.mkdirSync(import_path14.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);
@@ -19775,8 +21098,8 @@ function writeBootJson(filePath, value2) {
 }
 
 // src/config.ts
-var CONFIG_DIR2 = import_path14.default.join(import_os4.default.homedir(), ".factiii-runner");
-var CONFIG_FILE = import_path14.default.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = import_path15.default.join(import_os5.default.homedir(), ".factiii-runner");
+var CONFIG_FILE = import_path15.default.join(CONFIG_DIR2, "config.json");
 function readRunnerConfig() {
   return readBootJson(CONFIG_FILE);
 }
@@ -19948,7 +21271,7 @@ function makeChunkReassembler() {
 var import_crypto7 = require("crypto");
 var import_fs9 = __toESM(require("fs"));
 var import_node_datachannel = require("node-datachannel");
-var import_path16 = __toESM(require("path"));
+var import_path17 = __toESM(require("path"));
 
 // ../../node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
 var XMLHttpRequestModule = __toESM(require_XMLHttpRequest(), 1);
@@ -21128,12 +22451,12 @@ function parse2(str) {
   uri.queryKey = queryKey(uri, uri["query"]);
   return uri;
 }
-function pathNames(obj, path16) {
-  const regx = /\/{2,9}/g, names = path16.replace(regx, "/").split("/");
-  if (path16.slice(0, 1) == "/" || path16.length === 0) {
+function pathNames(obj, path17) {
+  const regx = /\/{2,9}/g, names = path17.replace(regx, "/").split("/");
+  if (path17.slice(0, 1) == "/" || path17.length === 0) {
     names.splice(0, 1);
   }
-  if (path16.slice(-1) == "/") {
+  if (path17.slice(-1) == "/") {
     names.splice(names.length - 1, 1);
   }
   return names;
@@ -21752,7 +23075,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, path16 = "", loc) {
+function url(uri, path17 = "", loc) {
   let obj = uri;
   loc = loc || typeof location !== "undefined" && location;
   if (null == uri)
@@ -21786,7 +23109,7 @@ function url(uri, path16 = "", 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 + path16;
+  obj.id = obj.protocol + "://" + host + ":" + obj.port + path17;
   obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
   return obj;
 }
@@ -23420,8 +24743,8 @@ function lookup(uri, opts) {
   const parsed = url(uri, opts.path || "/socket.io");
   const source = parsed.source;
   const id = parsed.id;
-  const path16 = parsed.path;
-  const sameNamespace = cache[id] && path16 in cache[id]["nsps"];
+  const path17 = parsed.path;
+  const sameNamespace = cache[id] && path17 in cache[id]["nsps"];
   const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
   let io;
   if (newConnection) {
@@ -23463,8 +24786,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(path16) {
-  return `Read ${path16} - it is the Factiii card this session was opened from. Use it as the context and start working on it.`;
+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.`;
 }
 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.";
@@ -23629,10 +24952,10 @@ var TerminalManager = class {
 
 // src/agent-adapter.ts
 var import_fs8 = __toESM(require("fs"));
-var import_path15 = __toESM(require("path"));
-var RUNNER_CONFIG_PATH = import_path15.default.join(CONFIG_DIR, "runner-config.json");
+var import_path16 = __toESM(require("path"));
+var RUNNER_CONFIG_PATH = import_path16.default.join(CONFIG_DIR, "runner-config.json");
 function connectionPath(spaceSlug) {
-  return import_path15.default.join(CONFIG_DIR, `space-${safeSlug(spaceSlug)}.onedrive.json`);
+  return import_path16.default.join(CONFIG_DIR, `space-${safeSlug(spaceSlug)}.onedrive.json`);
 }
 function writeJson(filePath, value2) {
   writeSecureJson(filePath, value2);
@@ -23666,7 +24989,7 @@ function migrateLegacyConfigs() {
   for (const name of legacy) {
     const slug = name.slice("space-".length, -".json".length);
     const parsed = readSecureJson(
-      import_path15.default.join(CONFIG_DIR, name)
+      import_path16.default.join(CONFIG_DIR, name)
     );
     if (!parsed) continue;
     if (!file.defaultSlug) {
@@ -23691,7 +25014,7 @@ function encryptStrayPlaintextConfigs() {
     return;
   }
   for (const name of names) {
-    const filePath = import_path15.default.join(CONFIG_DIR, name);
+    const filePath = import_path16.default.join(CONFIG_DIR, name);
     try {
       const raw = import_fs8.default.readFileSync(filePath, "utf-8");
       if (!raw.startsWith("{")) continue;
@@ -23820,7 +25143,7 @@ var localConfigProvider = {
       "claude",
       "codex"
     ]) {
-      import_fs8.default.mkdirSync(import_path15.default.join(dir, sub), { recursive: true });
+      import_fs8.default.mkdirSync(import_path16.default.join(dir, sub), { recursive: true });
     }
     return dir;
   }
@@ -23842,12 +25165,18 @@ function toRtcIceServers(servers) {
         continue;
       }
       const [, scheme, hostname, port, transport] = turn;
+      if (scheme === "turns" || transport === "tcp") continue;
       out.push({
         hostname,
         port: Number(port ?? (scheme === "turns" ? 5349 : 3478)),
         username: server.username,
         password: server.credential,
-        relayType: scheme === "turns" ? import_node_datachannel.RelayType.TurnTls : transport === "tcp" ? import_node_datachannel.RelayType.TurnTcp : import_node_datachannel.RelayType.TurnUdp
+        // String literals, not the RelayType members: it is a `const enum`,
+        // so it is erased at compile time and has no runtime object to read —
+        // `RelayType.TurnUdp` threw, which killed the offer handler before it
+        // could answer and made every connection fail, not just the relayed
+        // ones. The enum's values are exactly these strings.
+        relayType: scheme === "turns" ? "TurnTls" : transport === "tcp" ? "TurnTcp" : "TurnUdp"
       });
     }
   }
@@ -23988,15 +25317,15 @@ async function startDaemon(config) {
     }
   );
   const indexCandidates = [
-    import_path16.default.join(__dirname, "..", "index"),
-    import_path16.default.join(__dirname, "..", "..", "index", "image")
+    import_path17.default.join(__dirname, "..", "index"),
+    import_path17.default.join(__dirname, "..", "..", "index", "image")
   ];
   const indexDir = indexCandidates.find((p) => import_fs9.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_path16.default.join(CONFIG_DIR, "index-data")
+    dataDir: import_path17.default.join(CONFIG_DIR, "index-data")
   });
   void odIndex.ensureRunning().catch((err) => {
     console.error(
@@ -24133,16 +25462,50 @@ async function startDaemon(config) {
     console.log(`Received WebRTC offer from ${data.fromSocketId}`);
     const scope = toChannelScope(data.scope);
     try {
-      const iceServers = toRtcIceServers(data.iceServers);
+      let iceServers;
+      try {
+        iceServers = toRtcIceServers(data.iceServers);
+      } catch (error) {
+        console.error("[webrtc] ICE server list unusable, using STUN:", error);
+        iceServers = ["stun:stun.l.google.com:19302"];
+      }
       console.log(
         `[webrtc] ICE servers: ${iceServers.map(
           (u) => typeof u === "string" ? u : `${u.relayType}:${u.hostname}:${u.port} user=${u.username?.slice(0, 8)}\u2026`
         ).join(", ")}`
       );
       const peer = new import_node_datachannel.PeerConnection("runner", { iceServers });
+      const view = {
+        local: /* @__PURE__ */ new Set(),
+        remote: /* @__PURE__ */ new Set(),
+        relays: 0,
+        gathering: "new",
+        ice: "new"
+      };
+      const candidateType = (candidate) => /\btyp (\w+)/.exec(candidate)?.[1] ?? "unknown";
+      let reported = false;
+      const report = (outcome) => {
+        if (reported || !data.linkId) return;
+        reported = true;
+        socket.emit("runnerLinkReport", {
+          linkId: data.linkId,
+          peerSocketId: data.fromSocketId,
+          outcome,
+          detail: [
+            `ice=${view.ice} gathering=${view.gathering} relays=${view.relays}`,
+            `local=${[...view.local].join(",") || "none"}`,
+            `remote=${[...view.remote].join(",") || "none"}`,
+            // Hostname and port only — the credential never leaves the runner.
+            `turn=${iceServers.map(
+              (u) => typeof u === "string" ? u : `${u.relayType}:${u.hostname}:${u.port}`
+            ).join(" ")}`
+          ].join("\n")
+        });
+      };
       const iceCandidateHandler = (msg) => {
         if (msg.fromSocketId === data.fromSocketId) {
           console.log(`[webrtc] remote ICE candidate: ${msg.candidate.candidate.slice(0, 60)}...`);
+          view.remote.add(candidateType(msg.candidate.candidate));
           peer.addRemoteCandidate(
             msg.candidate.candidate,
             msg.candidate.sdpMid || ""
@@ -24158,18 +25521,31 @@ async function startDaemon(config) {
       };
       peer.onStateChange((state) => {
         console.log(`[webrtc] peer state: ${state}`);
+        view.ice = state;
+        if (state === "connected") report("connected");
         if (state === "failed" || state === "closed" || state === "disconnected") {
+          if (state === "failed") report("failed");
           detachIceHandler();
         }
       });
       peer.onGatheringStateChange((state) => {
         console.log(`[webrtc] gathering state: ${state}`);
+        view.gathering = state;
       });
       peer.onLocalCandidate((candidate, mid) => {
         console.log(`[webrtc] local ICE candidate: ${candidate.slice(0, 60)}...`);
+        const type = candidateType(candidate);
+        view.local.add(type);
+        if (type === "relay") view.relays += 1;
         socket.emit("runnerIceCandidate", {
           targetSocketId: data.fromSocketId,
-          candidate: { candidate, sdpMid: mid, sdpMLineIndex: null }
+          // 0 rather than null. A browser accepts a null index, but a mobile
+          // client on the New Architecture passes this straight into codegen'd
+          // JSI bindings that type-check it as a number, and null throws there —
+          // rejecting every candidate we send and stranding the link at
+          // checking. sdpMid identifies the m-line on its own, so the index is
+          // redundant here anyway.
+          candidate: { candidate, sdpMid: mid, sdpMLineIndex: 0 }
         });
       });
       peer.onLocalDescription((sdp, _type) => {