brainfile 0.21.0 → 0.21.2

package/dist/cli.mjs

@@ -18,8 +18,9 @@ import {
   boardBranch,
   boardIsDirty,
   boardRemote,
-  boardRemoteBranch,
+  boardRemoteRef,
   boardRepoKind,
+  boardWebUrl,
   clearPushLock,
   columnNotFound,
   columnNotFoundError,
@@ -74,7 +75,6 @@ import {
   renderCliError,
   require_dist,
   require_source,
-  resolveAgentName,
   resolveCliBrainfilePath,
   saveConfig,
   secondsSinceSync,
@@ -91,7 +91,7 @@ import {
   validationError,
   validationError2,
   workspaceRootFromBrainfilePath
-} from "./chunk-FOLBAGJS.mjs";
+} from "./chunk-7KU2R7QC.mjs";
 import {
   __commonJS,
   __export,
@@ -1263,7 +1263,7 @@ var require_command = __commonJS({
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
     var path27 = __require("node:path");
-    var fs24 = __require("node:fs");
+    var fs25 = __require("node:fs");
     var process4 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2257,7 +2257,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs24.existsSync(executableFile)) return;
+        if (fs25.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2276,10 +2276,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path27.resolve(baseDir, baseName);
-          if (fs24.existsSync(localBin)) return localBin;
+          if (fs25.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path27.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs24.existsSync(`${localBin}${ext}`)
+            (ext) => fs25.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2291,7 +2291,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs24.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs25.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
@@ -3530,7 +3530,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "brainfile",
-      version: "0.21.0",
+      version: "0.21.2",
       description: "Command-line interface for Brainfile task management",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3567,7 +3567,7 @@ var require_package = __commonJS({
         access: "public"
       },
       dependencies: {
-        "@brainfile/core": "^0.21.0",
+        "@brainfile/core": "^0.21.2",
         chalk: "^4.1.2",
         chokidar: "^4.0.3",
         commander: "^14.0.3",
@@ -3626,7 +3626,7 @@ var {
 } = import_index.default;
 
 // src/cli.ts
-import { readFileSync as readFileSync10, existsSync as existsSync19 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync20 } from "fs";
 import { join as join18, sep as sep3 } from "path";
 
 // src/commands/list.ts
@@ -4139,6 +4139,111 @@ function logAddSuccess(options, taskId, columnTitle, logger, createdChildren = [
   }
 }
 
+// src/utils/actor.ts
+import * as fs from "fs";
+import { spawnSync } from "child_process";
+var AGENT_BINARIES = {
+  claude: "claude",
+  codex: "codex",
+  "cursor-agent": "cursor",
+  gemini: "gemini",
+  opencode: "opencode",
+  goose: "goose",
+  droid: "droid",
+  crush: "crush",
+  aider: "aider",
+  cline: "cline",
+  amp: "amp",
+  qwen: "qwen",
+  copilot: "copilot"
+};
+var MAX_DEPTH = 32;
+function sanitize(name) {
+  return name.replace(/[[\]<>\r\n]/g, "").trim();
+}
+function agentFromCommand(words) {
+  for (const word of words.slice(0, 2)) {
+    const base = word.split("/").pop()?.replace(/\.(c|m)?js$/, "") ?? "";
+    if (AGENT_BINARIES[base]) return AGENT_BINARIES[base];
+  }
+  return null;
+}
+function linuxProc(pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+    const ppid = Number.parseInt(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1], 10);
+    const comm = stat.slice(stat.indexOf("(") + 1, stat.lastIndexOf(")"));
+    const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, "utf-8").split("\0").filter(Boolean);
+    return { ppid, words: [comm, ...cmdline] };
+  } catch {
+    return null;
+  }
+}
+function psTable() {
+  const r = spawnSync("ps", ["-A", "-o", "pid=,ppid=,args="], { encoding: "utf-8", timeout: 2e3 });
+  if (r.status !== 0 || !r.stdout) return null;
+  const table = /* @__PURE__ */ new Map();
+  for (const line of r.stdout.split("\n")) {
+    const m = /^\s*(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+    if (m) table.set(Number(m[1]), { ppid: Number(m[2]), words: m[3].split(/\s+/) });
+  }
+  return table;
+}
+function agentFromProcessTree(startPid = process.ppid) {
+  const useProc = process.platform === "linux" && fs.existsSync("/proc/self/stat");
+  const table = useProc ? null : process.platform === "win32" ? null : psTable();
+  if (!useProc && !table) return null;
+  let pid = startPid;
+  for (let depth = 0; depth < MAX_DEPTH && pid > 1; depth++) {
+    const info = useProc ? linuxProc(pid) : table?.get(pid) ?? null;
+    if (!info) return null;
+    const agent = agentFromCommand(info.words);
+    if (agent) return agent;
+    pid = info.ppid;
+  }
+  return null;
+}
+function agentFromEnvironment(env = process.env) {
+  if (env.CODEX_THREAD_ID || env.CODEX_SESSION_ID) return "codex";
+  if (env.GEMINI_CLI === "1") return "gemini";
+  if (env.CLAUDECODE === "1") return "claude";
+  const generic = env.AI_AGENT?.split("_")[0];
+  if (generic) return generic === "claude-code" ? "claude" : sanitize(generic) || null;
+  return null;
+}
+function flagValue(argv) {
+  const at = argv.indexOf("--agent");
+  if (at >= 0 && argv[at + 1] && !argv[at + 1].startsWith("-")) return argv[at + 1];
+  const inline = argv.find((a) => a.startsWith("--agent="));
+  return inline ? inline.slice("--agent=".length) : null;
+}
+var detected = null;
+function detectAgent(argv = process.argv, env = process.env) {
+  const flag = sanitize(flagValue(argv) ?? "");
+  if (flag) return { name: flag, source: "flag" };
+  const named = sanitize(env.BRAINFILE_AGENT ?? "");
+  if (named) return { name: named, source: "env" };
+  if (env.BRAINFILE_DETECT_AGENT === "off") return null;
+  if (!detected) {
+    let value = null;
+    try {
+      value = agentFromProcessTree();
+    } catch {
+      value = null;
+    }
+    detected = { value };
+  }
+  if (detected.value) return { name: detected.value, source: "process" };
+  const fingerprint = agentFromEnvironment(env);
+  return fingerprint ? { name: fingerprint, source: "fingerprint" } : null;
+}
+function resolveActor(cwd = process.cwd(), argv = process.argv) {
+  const agent = detectAgent(argv);
+  if (agent) return agent;
+  const user = sanitize(git(["config", "--get", "user.name"], cwd).stdout);
+  return user ? { name: user, source: "git" } : null;
+}
+
 // src/utils/board-commit-hooks.ts
 var SKIP_COMMANDS = /* @__PURE__ */ new Set(["mcp", "tui", "hooks", "auth", "sync", "merge-driver", "where"]);
 function topLevelCommandName(command) {
@@ -4167,7 +4272,7 @@ function beforeCommand(command) {
 function afterCommand(command) {
   const dotDir = boardDirForCommand(command);
   if (!dotDir) return false;
-  return commitBoard(dotDir, { message: describeCommandForCommit(command), agent: resolveAgentName() });
+  return commitBoard(dotDir, { message: describeCommandForCommit(command), agent: detectAgent()?.name });
 }
 
 // src/commands/move.ts
@@ -4254,7 +4359,7 @@ function moveCommandV2(options, filePath, logger) {
 
 // src/commands/template.ts
 var import_core7 = __toESM(require_dist());
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as path4 from "path";
 function templateCommand(options, logger = defaultLogger) {
   if (options.list) {
@@ -4282,7 +4387,7 @@ function templateCommand(options, logger = defaultLogger) {
       throw missingRequired("--title", 'brainfile template --use <template-id> --title "Task title"');
     }
     const filePath = resolveCliBrainfilePath(options.file);
-    if (!fs.existsSync(filePath)) {
+    if (!fs2.existsSync(filePath)) {
       throw fileNotFound(filePath);
     }
     const board = (0, import_core.readV2BoardConfig)(filePath);
@@ -4358,13 +4463,13 @@ ${availableTemplates}`
 // src/commands/lint.ts
 var import_core8 = __toESM(require_dist());
 var import_chalk4 = __toESM(require_source());
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 function lintCommand(options, logger = defaultLogger) {
   const filePath = resolveCliBrainfilePath(options.file);
-  if (!fs2.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     throw fileNotFound(filePath);
   }
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs3.readFileSync(filePath, "utf-8");
   logger.log(import_chalk4.default.blue(`
 \u{1F50D} Linting: ${filePath}
 `));
@@ -4395,7 +4500,7 @@ function lintCommand(options, logger = defaultLogger) {
   let fixedCount = 0;
   let fixed = false;
   if (options.fix && result.fixedContent) {
-    fs2.writeFileSync(filePath, result.fixedContent, "utf-8");
+    fs3.writeFileSync(filePath, result.fixedContent, "utf-8");
     fixedCount = fixable.length;
     fixed = true;
     logger.log(import_chalk4.default.green(`\u2713 Fixed ${fixable.length} issue${fixable.length > 1 ? "s" : ""}!
@@ -4430,11 +4535,11 @@ function lintCommand(options, logger = defaultLogger) {
 // src/commands/init.ts
 var import_chalk5 = __toESM(require_source());
 var import_core9 = __toESM(require_dist());
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path6 from "path";
 
 // src/utils/dot-brainfile.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path5 from "path";
 function getDotBrainfileDir(brainfilePath) {
   const abs = path5.resolve(brainfilePath);
@@ -4445,8 +4550,8 @@ function getDotBrainfileDir(brainfilePath) {
 function removeLegacyStateFile(brainfilePath) {
   const dotDir = getDotBrainfileDir(brainfilePath);
   const statePath = path5.join(dotDir, "state.json");
-  if (fs3.existsSync(statePath)) {
-    fs3.rmSync(statePath, { force: true });
+  if (fs4.existsSync(statePath)) {
+    fs4.rmSync(statePath, { force: true });
   }
   return statePath;
 }
@@ -4514,7 +4619,7 @@ function planInit(options) {
 }
 function isNonEmptyDir(dir) {
   try {
-    return fs4.statSync(dir).isDirectory() && fs4.readdirSync(dir).length > 0;
+    return fs5.statSync(dir).isDirectory() && fs5.readdirSync(dir).length > 0;
   } catch {
     return false;
   }
@@ -4531,11 +4636,11 @@ function initCommand(options) {
       console.log(import_chalk5.default.gray("Run ") + import_chalk5.default.cyan("brainfile migrate") + import_chalk5.default.gray(" before running init."));
       process.exit(1);
     }
-    if (probe.format === "v2" && fs4.existsSync(filePath) && !options.force) {
+    if (probe.format === "v2" && fs5.existsSync(filePath) && !options.force) {
       (0, import_core9.ensureDotBrainfileGitignore)(filePath);
       removeLegacyStateFile(filePath);
-      fs4.mkdirSync(path6.join(dotDir, "board"), { recursive: true });
-      fs4.mkdirSync(path6.join(dotDir, "logs"), { recursive: true });
+      fs5.mkdirSync(path6.join(dotDir, "board"), { recursive: true });
+      fs5.mkdirSync(path6.join(dotDir, "logs"), { recursive: true });
       console.log(import_chalk5.default.green(`A board already exists at ${displayPath(dotDir)}/`));
       if (mode !== "plain" && boardRepoKind(dotDir) === null) {
         console.log(import_chalk5.default.gray("  It is plain files. To keep it on its own branch and share it: ") + import_chalk5.default.cyan("brainfile migrate --to-branch"));
@@ -4543,7 +4648,7 @@ function initCommand(options) {
       console.log(import_chalk5.default.gray("  Where it lives and who has it: ") + import_chalk5.default.cyan("brainfile where"));
       return;
     }
-    if (fs4.existsSync(filePath) && !options.force) {
+    if (fs5.existsSync(filePath) && !options.force) {
       console.error(import_chalk5.default.red(`Error: File already exists: ${filePath}`));
       console.log(import_chalk5.default.gray("Use --force to overwrite"));
       process.exit(1);
@@ -4557,12 +4662,12 @@ function initCommand(options) {
       createOrphanBoardWorktree(plan.repoRoot, dotDir, boardBranch(plan.repoRoot));
     }
     (0, import_core9.ensureDotBrainfileGitignore)(filePath);
-    fs4.mkdirSync(dotDir, { recursive: true });
+    fs5.mkdirSync(dotDir, { recursive: true });
     const boardDir = path6.join(dotDir, "board");
     const logsDir = path6.join(dotDir, "logs");
-    fs4.mkdirSync(boardDir, { recursive: true });
-    fs4.mkdirSync(logsDir, { recursive: true });
-    fs4.writeFileSync(filePath, DEFAULT_BRAINFILE_V2, "utf-8");
+    fs5.mkdirSync(boardDir, { recursive: true });
+    fs5.mkdirSync(logsDir, { recursive: true });
+    fs5.writeFileSync(filePath, DEFAULT_BRAINFILE_V2, "utf-8");
     removeLegacyStateFile(filePath);
     if (mode === "standalone") {
       initStandaloneBoardRepo(dotDir);
@@ -4614,16 +4719,16 @@ var import_chalk7 = __toESM(require_source());
 var import_core11 = __toESM(require_dist());
 var import_core12 = __toESM(require_dist());
 var import_core13 = __toESM(require_dist());
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path8 from "path";
 
 // src/commands/migrate-tracked.ts
 var import_chalk6 = __toESM(require_source());
 var import_core10 = __toESM(require_dist());
 import * as crypto2 from "crypto";
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path7 from "path";
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 var SKIP_TOP_LEVEL = /* @__PURE__ */ new Set([".git"]);
 var STATE_DIR = "state";
 function locateBoard(rootDir) {
@@ -4634,28 +4739,28 @@ function locateBoard(rootDir) {
   return path7.dirname(found.absolutePath);
 }
 function copyBoardContents(from, to) {
-  for (const entry of fs5.readdirSync(from)) {
+  for (const entry of fs6.readdirSync(from)) {
     if (SKIP_TOP_LEVEL.has(entry)) continue;
-    fs5.cpSync(path7.join(from, entry), path7.join(to, entry), { recursive: true, force: true, verbatimSymlinks: true });
+    fs6.cpSync(path7.join(from, entry), path7.join(to, entry), { recursive: true, force: true, verbatimSymlinks: true });
   }
 }
 function mirrorBoardContents(from, to) {
-  for (const entry of fs5.readdirSync(to)) {
+  for (const entry of fs6.readdirSync(to)) {
     if (SKIP_TOP_LEVEL.has(entry)) continue;
-    fs5.rmSync(path7.join(to, entry), { recursive: true, force: true });
+    fs6.rmSync(path7.join(to, entry), { recursive: true, force: true });
   }
   copyBoardContents(from, to);
 }
 function hashBoardFiles(dir) {
   const out = /* @__PURE__ */ new Map();
   const walk = (current, prefix) => {
-    for (const entry of fs5.readdirSync(current, { withFileTypes: true })) {
+    for (const entry of fs6.readdirSync(current, { withFileTypes: true })) {
       if (prefix === "" && (SKIP_TOP_LEVEL.has(entry.name) || entry.name === STATE_DIR)) continue;
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
       const full = path7.join(current, entry.name);
       if (entry.isDirectory()) walk(full, rel);
-      else if (entry.isSymbolicLink()) out.set(rel, `link:${fs5.readlinkSync(full)}`);
-      else out.set(rel, crypto2.createHash("sha256").update(fs5.readFileSync(full)).digest("hex"));
+      else if (entry.isSymbolicLink()) out.set(rel, `link:${fs6.readlinkSync(full)}`);
+      else out.set(rel, crypto2.createHash("sha256").update(fs6.readFileSync(full)).digest("hex"));
     }
   };
   walk(dir, "");
@@ -4663,12 +4768,12 @@ function hashBoardFiles(dir) {
 }
 function asidePath(dotDir) {
   const candidate = `${dotDir}.migrating`;
-  if (fs5.existsSync(candidate)) throw new Error(`${candidate} already exists; remove it before migrating.`);
+  if (fs6.existsSync(candidate)) throw new Error(`${candidate} already exists; remove it before migrating.`);
   return candidate;
 }
 function restoreAside(aside, dotDir) {
-  if (fs5.existsSync(dotDir)) fs5.rmSync(dotDir, { recursive: true, force: true });
-  fs5.renameSync(aside, dotDir);
+  if (fs6.existsSync(dotDir)) fs6.rmSync(dotDir, { recursive: true, force: true });
+  fs6.renameSync(aside, dotDir);
 }
 function verifyBoardContents(aside, dotDir) {
   const before = hashBoardFiles(aside);
@@ -4692,16 +4797,16 @@ function verifyBoardContents(aside, dotDir) {
   }
 }
 function attributesExtend(aside, dotDir) {
-  const lines = (dir) => fs5.readFileSync(path7.join(dir, ".gitattributes"), "utf-8").split("\n").map((l) => l.trim());
+  const lines = (dir) => fs6.readFileSync(path7.join(dir, ".gitattributes"), "utf-8").split("\n").map((l) => l.trim());
   const after = new Set(lines(dotDir));
   return lines(aside).every((line) => after.has(line));
 }
 function stagedPatch(relPath, repoRoot) {
-  const r = spawnSync("git", ["diff", "--cached", "--binary", "--", relPath], { cwd: repoRoot, encoding: "utf-8" });
+  const r = spawnSync2("git", ["diff", "--cached", "--binary", "--", relPath], { cwd: repoRoot, encoding: "utf-8" });
   return r.status === 0 ? r.stdout : "";
 }
 function applyToIndex(patch, repoRoot) {
-  const r = spawnSync("git", ["apply", "--cached", "--binary", "-"], { cwd: repoRoot, input: patch, encoding: "utf-8" });
+  const r = spawnSync2("git", ["apply", "--cached", "--binary", "-"], { cwd: repoRoot, input: patch, encoding: "utf-8" });
   return r.status === 0;
 }
 var MigrationRollback = class {
@@ -4726,7 +4831,7 @@ var MigrationRollback = class {
     this.indexChanged = true;
   }
   moveAside() {
-    fs5.renameSync(this.dotDir, this.aside);
+    fs6.renameSync(this.dotDir, this.aside);
     this.movedAside = true;
   }
   /** Reverse every recorded step. Returns what could not be undone (empty when fully restored). */
@@ -4742,7 +4847,7 @@ var MigrationRollback = class {
     if (this.movedAside && boardRepoKind(this.dotDir) === "linked") {
       attempt("remove the board worktree", () => {
         const removed = git(["worktree", "remove", "--force", this.dotDir], this.repoRoot);
-        if (!removed.ok) fs5.rmSync(this.dotDir, { recursive: true, force: true });
+        if (!removed.ok) fs6.rmSync(this.dotDir, { recursive: true, force: true });
       });
     }
     if (this.movedAside) attempt(`move ${this.aside} back`, () => restoreAside(this.aside, this.dotDir));
@@ -4864,10 +4969,10 @@ function migrateToBranch(options = {}) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     const leftovers = rollback.undo();
     throw new Error(
-      leftovers.length === 0 ? `${message} Nothing was changed: the board is back where it was.` : `${message} Rolling back was incomplete; could not ${leftovers.join("; ")}. The original board is in ${fs5.existsSync(aside) ? aside : dotDir}.`
+      leftovers.length === 0 ? `${message} Nothing was changed: the board is back where it was.` : `${message} Rolling back was incomplete; could not ${leftovers.join("; ")}. The original board is in ${fs6.existsSync(aside) ? aside : dotDir}.`
     );
   }
-  fs5.rmSync(aside, { recursive: true, force: true });
+  fs6.rmSync(aside, { recursive: true, force: true });
   ensureExcludeEntry(repoRoot);
   console.log(import_chalk6.default.green(done));
   if (uncommittedImported) {
@@ -4909,7 +5014,7 @@ function migrateToPlain(options = {}) {
     return;
   }
   if (kind === "standalone") {
-    fs5.rmSync(path7.join(dotDir, ".git"), { recursive: true, force: true });
+    fs6.rmSync(path7.join(dotDir, ".git"), { recursive: true, force: true });
     console.log(import_chalk6.default.green("Board is now a plain directory (its git history was removed)."));
     return;
   }
@@ -4917,14 +5022,14 @@ function migrateToPlain(options = {}) {
   if (!repoRoot) throw new Error("Could not find the repository that owns this board worktree.");
   const branch = boardBranch(repoRoot);
   const aside = asidePath(dotDir);
-  fs5.mkdirSync(aside);
+  fs6.mkdirSync(aside);
   copyBoardContents(dotDir, aside);
   const remove = git(["worktree", "remove", "--force", dotDir], repoRoot);
   if (!remove.ok) {
-    fs5.rmSync(aside, { recursive: true, force: true });
+    fs6.rmSync(aside, { recursive: true, force: true });
     throw new Error(`git worktree remove failed: ${remove.stderr}`);
   }
-  fs5.renameSync(aside, dotDir);
+  fs6.renameSync(aside, dotDir);
   removeExcludeEntry(repoRoot);
   console.log(import_chalk6.default.green("Board is now a plain directory."));
   console.log(import_chalk6.default.gray(`  Branch '${branch}' still holds its history. Delete it with: git branch -D ${branch}`));
@@ -5008,42 +5113,42 @@ function migrateMixedWorkspace(probe, options) {
 }
 function migrateRootBrainfileToDotDir(probe, options) {
   const { rootBrainfilePath, dotDir, dotBrainfilePath } = probe.paths;
-  if (!fs6.existsSync(rootBrainfilePath)) {
+  if (!fs7.existsSync(rootBrainfilePath)) {
     throw new Error(`File not found: ${rootBrainfilePath}`);
   }
-  if (fs6.existsSync(dotBrainfilePath) && !options.force) {
+  if (fs7.existsSync(dotBrainfilePath) && !options.force) {
     throw new Error(
       `Target already exists: ${dotBrainfilePath}. Run \`brainfile migrate\` again after resolving conflicts, or use --force.`
     );
   }
-  fs6.mkdirSync(dotDir, { recursive: true });
-  if (fs6.existsSync(dotBrainfilePath) && options.force) {
-    fs6.rmSync(dotBrainfilePath, { force: true });
+  fs7.mkdirSync(dotDir, { recursive: true });
+  if (fs7.existsSync(dotBrainfilePath) && options.force) {
+    fs7.rmSync(dotBrainfilePath, { force: true });
   }
   try {
-    fs6.renameSync(rootBrainfilePath, dotBrainfilePath);
+    fs7.renameSync(rootBrainfilePath, dotBrainfilePath);
   } catch {
-    const contents = fs6.readFileSync(rootBrainfilePath);
-    fs6.writeFileSync(dotBrainfilePath, contents);
-    fs6.rmSync(rootBrainfilePath, { force: true });
+    const contents = fs7.readFileSync(rootBrainfilePath);
+    fs7.writeFileSync(dotBrainfilePath, contents);
+    fs7.rmSync(rootBrainfilePath, { force: true });
   }
   (0, import_core13.ensureDotBrainfileGitignore)(dotBrainfilePath);
   removeLegacyStateFile(dotBrainfilePath);
   console.log(import_chalk7.default.gray(`Moved: ${rootBrainfilePath} -> ${dotBrainfilePath}`));
 }
 function migrateBrainfileToV2(brainfilePath, options) {
-  if (!fs6.existsSync(brainfilePath)) {
+  if (!fs7.existsSync(brainfilePath)) {
     throw new Error(`File not found: ${brainfilePath}`);
   }
-  const content = fs6.readFileSync(brainfilePath, "utf-8");
+  const content = fs7.readFileSync(brainfilePath, "utf-8");
   const parsed = import_core11.Brainfile.parseWithErrors(content);
   if (!parsed.board) {
     throw new Error(`Failed to parse brainfile: ${parsed.error}`);
   }
   const board = parsed.board;
   const dotDir = path8.dirname(path8.resolve(brainfilePath));
-  const hasBoardDir = fs6.existsSync(path8.join(dotDir, "board"));
-  const hasLogsDir = fs6.existsSync(path8.join(dotDir, "logs"));
+  const hasBoardDir = fs7.existsSync(path8.join(dotDir, "board"));
+  const hasLogsDir = fs7.existsSync(path8.join(dotDir, "logs"));
   const hasEmbeddedColumnTasks = board.columns.some((column) => column.tasks.length > 0);
   const hasEmbeddedArchiveTasks = Array.isArray(board.archive) && (board.archive?.length ?? 0) > 0;
   if (hasBoardDir && hasLogsDir && !hasEmbeddedColumnTasks && !hasEmbeddedArchiveTasks) {
@@ -5051,15 +5156,15 @@ function migrateBrainfileToV2(brainfilePath, options) {
     return;
   }
   const backupPath = brainfilePath + ".v1.bak";
-  if (!fs6.existsSync(backupPath) || options.force) {
-    fs6.copyFileSync(brainfilePath, backupPath);
+  if (!fs7.existsSync(backupPath) || options.force) {
+    fs7.copyFileSync(brainfilePath, backupPath);
     console.log(import_chalk7.default.gray(`Backup: ${backupPath}`));
   } else {
     console.log(import_chalk7.default.gray(`Backup already exists: ${backupPath}`));
   }
   const dirs = (0, import_core.ensureV2Dirs)(brainfilePath);
-  const existingTaskFiles = fs6.existsSync(dirs.boardDir) ? fs6.readdirSync(dirs.boardDir).filter((f) => f.endsWith(".md")) : [];
-  const existingLogFiles = fs6.existsSync(dirs.logsDir) ? fs6.readdirSync(dirs.logsDir).filter((f) => f.endsWith(".md")) : [];
+  const existingTaskFiles = fs7.existsSync(dirs.boardDir) ? fs7.readdirSync(dirs.boardDir).filter((f) => f.endsWith(".md")) : [];
+  const existingLogFiles = fs7.existsSync(dirs.logsDir) ? fs7.readdirSync(dirs.logsDir).filter((f) => f.endsWith(".md")) : [];
   if ((existingTaskFiles.length > 0 || existingLogFiles.length > 0) && !options.force) {
     throw new Error(
       "board/ or logs/ already contains task files. Use --force to replace existing .md files in those directories."
@@ -5067,10 +5172,10 @@ function migrateBrainfileToV2(brainfilePath, options) {
   }
   if (options.force) {
     for (const name of existingTaskFiles) {
-      fs6.rmSync(path8.join(dirs.boardDir, name), { force: true });
+      fs7.rmSync(path8.join(dirs.boardDir, name), { force: true });
     }
     for (const name of existingLogFiles) {
-      fs6.rmSync(path8.join(dirs.logsDir, name), { force: true });
+      fs7.rmSync(path8.join(dirs.logsDir, name), { force: true });
     }
   }
   let activeCount = 0;
@@ -5131,7 +5236,7 @@ function migrateBrainfileToV2(brainfilePath, options) {
   delete configBoard.rules;
   configBoard.schema = "https://brainfile.md/v2/board.json";
   const configContent = import_core11.Brainfile.serialize(configBoard);
-  fs6.writeFileSync(brainfilePath, configContent, "utf-8");
+  fs7.writeFileSync(brainfilePath, configContent, "utf-8");
   (0, import_core13.ensureDotBrainfileGitignore)(brainfilePath);
   removeLegacyStateFile(brainfilePath);
   console.log(import_chalk7.default.green("Migration to v2 complete!"));
@@ -5154,7 +5259,7 @@ function migrateLogsToLedger(options) {
     return;
   }
   const { logsDir, boardDir } = probe.paths;
-  if (!fs6.existsSync(logsDir)) {
+  if (!fs7.existsSync(logsDir)) {
     console.log(import_chalk7.default.gray("No logs/ directory found. Nothing to migrate."));
     return;
   }
@@ -5165,8 +5270,8 @@ function migrateLogsToLedger(options) {
   }
   const ledgerPath = path8.join(logsDir, "ledger.jsonl");
   const existingLedgerIds = /* @__PURE__ */ new Set();
-  if (fs6.existsSync(ledgerPath)) {
-    const lines = fs6.readFileSync(ledgerPath, "utf-8").split("\n");
+  if (fs7.existsSync(ledgerPath)) {
+    const lines = fs7.readFileSync(ledgerPath, "utf-8").split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -5177,7 +5282,7 @@ function migrateLogsToLedger(options) {
       }
     }
   }
-  const boardDocs = fs6.existsSync(boardDir) ? (0, import_core12.readTasksDir)(boardDir) : [];
+  const boardDocs = fs7.existsSync(boardDir) ? (0, import_core12.readTasksDir)(boardDir) : [];
   const boardIdMap = new Map(boardDocs.map((d) => [d.task.id, d]));
   let migratedCount = 0;
   let skippedCount = 0;
@@ -5202,7 +5307,7 @@ function migrateLogsToLedger(options) {
       const renamedTask = { ...boardDoc.task, id: newId };
       const newBoardPath = path8.join(boardDir, (0, import_core12.taskFileName)(newId));
       (0, import_core12.writeTaskFile)(newBoardPath, renamedTask, boardDoc.body);
-      fs6.rmSync(boardDoc.filePath, { force: true });
+      fs7.rmSync(boardDoc.filePath, { force: true });
       console.log(import_chalk7.default.yellow(`  Conflict: board/${taskId} \u2192 ${newId} (completed task takes precedence)`));
       conflictCount++;
     }
@@ -5220,19 +5325,19 @@ function migrateLogsToLedger(options) {
 }
 function backupAndRemoveLegacyRoot(rootBrainfilePath, dotDir) {
   const backupPath = uniquePath(path8.join(dotDir, "brainfile.root.legacy.bak"));
-  fs6.mkdirSync(dotDir, { recursive: true });
-  fs6.copyFileSync(rootBrainfilePath, backupPath);
-  fs6.rmSync(rootBrainfilePath, { force: true });
+  fs7.mkdirSync(dotDir, { recursive: true });
+  fs7.copyFileSync(rootBrainfilePath, backupPath);
+  fs7.rmSync(rootBrainfilePath, { force: true });
   return backupPath;
 }
 function uniquePath(basePath) {
-  if (!fs6.existsSync(basePath)) return basePath;
+  if (!fs7.existsSync(basePath)) return basePath;
   const ext = path8.extname(basePath);
   const stem = basePath.slice(0, basePath.length - ext.length);
   let i = 1;
   while (true) {
     const candidate = `${stem}.${i}${ext}`;
-    if (!fs6.existsSync(candidate)) return candidate;
+    if (!fs7.existsSync(candidate)) return candidate;
     i++;
   }
 }
@@ -5240,21 +5345,27 @@ function uniquePath(basePath) {
 // src/commands/sync.ts
 var import_chalk8 = __toESM(require_source());
 var import_core14 = __toESM(require_dist());
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path9 from "path";
 var SYNC_COMMAND_HELP = `
 Examples:
-  brainfile sync                              Fetch, merge and push the board branch
+  brainfile sync                              Fetch, merge and push the board
   brainfile sync --pull                       Bring in other machines' changes only
   brainfile sync --set-remote origin          Share the board through the code remote
-  brainfile sync --set-remote git@host:me/boards.git --remote-branch myproject
+  brainfile sync --set-remote git@host:me/boards.git --board-name myproject
   brainfile sync --autosync full              Also fetch before reads (default: push after writes)
 
-Nothing leaves this machine until you choose a remote. \`brainfile where\` shows
-where the board lives and who has it.`;
+Nothing leaves this machine until you choose a remote. On the remote the board
+is stored as refs/brainfile/<name>, not as a branch, so it never appears in the
+branch list or pull requests. \`brainfile where\` shows where the board lives
+and who has it.`;
 function describe(result) {
   const message = syncMessage(result);
-  const text = message.tone === "ok" ? import_chalk8.default.green(message.text) : import_chalk8.default.yellow(message.text);
+  let text = message.tone === "ok" ? import_chalk8.default.green(message.text) : import_chalk8.default.yellow(message.text);
+  if (result.movedFromBranch && result.remoteRef) {
+    text += `
+${import_chalk8.default.gray(`  Moved the board off the '${result.movedFromBranch}' branch on ${result.remote}; it now lives in ${result.remoteRef}, outside your branches.`)}`;
+  }
   return message.detail ? `${text}
 ${import_chalk8.default.gray(`  (${message.detail})`)}` : text;
 }
@@ -5266,6 +5377,7 @@ function syncCommand(options, logger = defaultLogger) {
   if (Number.isFinite(wait) && wait > 0) sleep(wait);
   let dotDir = tryResolveBoardDir(options.file);
   if (dotDir && options.wait !== void 0) clearPushLock(dotDir);
+  const boardName = options.boardName ?? options.remoteBranch;
   if (options.setRemote !== void 0) {
     const cwd = dotDir ?? gitToplevel(process.cwd());
     if (!cwd) {
@@ -5273,25 +5385,28 @@ function syncCommand(options, logger = defaultLogger) {
     }
     let setting;
     try {
-      setting = setBoardRemote(cwd, options.setRemote, options.remoteBranch);
+      setting = setBoardRemote(cwd, options.setRemote, boardName);
     } catch (error48) {
       throw validationError2(error48 instanceof Error ? error48.message : String(error48));
     }
-    logger.log(import_chalk8.default.green(`This board is now shared through ${setting.remote}${setting.url ? ` (${setting.url})` : ""}, branch '${setting.remoteBranch}'.`));
+    logger.log(import_chalk8.default.green(`This board is now shared through ${setting.remote}${setting.url ? ` (${setting.url})` : ""}.`));
+    logger.log(import_chalk8.default.gray(`  It is stored there as ${setting.remoteRef}, not a branch, so it stays out of branch lists and pull requests.`));
     logger.log(import_chalk8.default.gray(`  Changes are sent automatically after each edit. Anyone who can read ${setting.remote} can read the board.`));
+    const web = boardWebUrl(setting.url, setting.remoteRef);
+    if (web) logger.log(import_chalk8.default.gray(`  See it on the web: ${web}`));
     if (!dotDir) {
-      dotDir = materializeBoardWorktree(cwd);
+      dotDir = materializeBoardWorktree(cwd, { fresh: true });
       if (!dotDir) {
-        logger.log(import_chalk8.default.yellow(`There is no board on ${setting.remote} yet (looked for branch '${setting.remoteBranch}').`) + import_chalk8.default.gray(" Start one with: brainfile init"));
+        logger.log(import_chalk8.default.yellow(`There is no board on ${setting.remote} yet (looked for ${setting.remoteRef}).`) + import_chalk8.default.gray(" Start one with: brainfile init"));
         return void 0;
       }
     }
-  } else if (options.remoteBranch !== void 0) {
-    throw validationError2("--remote-branch needs --set-remote");
+  } else if (boardName !== void 0) {
+    throw validationError2("--board-name needs --set-remote");
   }
   if (!dotDir) {
     const resolved = resolveCliBrainfilePath(options.file);
-    if (!fs7.existsSync(resolved)) throw operationFailed(`No board found (looked for ${path9.join(".brainfile", import_core14.BRAINFILE_BASENAME)}). Run: brainfile init`);
+    if (!fs8.existsSync(resolved)) throw operationFailed(`No board found (looked for ${path9.join(".brainfile", import_core14.BRAINFILE_BASENAME)}). Run: brainfile init`);
     dotDir = path9.dirname(resolved);
   }
   if (options.autosync !== void 0) {
@@ -5305,14 +5420,13 @@ function syncCommand(options, logger = defaultLogger) {
   const pushOnly = options.push === true && options.pull !== true;
   const result = syncBoard(dotDir, {
     pull: !pushOnly,
-    push: !pullOnly,
-    agent: resolveAgentName()
+    push: !pullOnly
   });
   if (options.json) {
     logger.log(JSON.stringify({
       ...result,
       remote: result.remote ?? boardRemote(dotDir),
-      remoteBranch: result.remoteBranch ?? boardRemoteBranch(dotDir),
+      remoteRef: result.remoteRef ?? boardRemoteRef(dotDir),
       autosync: boardAutosync(dotDir)
     }, null, 2));
   } else {
@@ -5324,7 +5438,7 @@ function syncCommand(options, logger = defaultLogger) {
 
 // src/commands/where.ts
 var import_chalk9 = __toESM(require_source());
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path10 from "path";
 function ago(seconds) {
   if (seconds < 60) return `${seconds}s ago`;
@@ -5337,14 +5451,17 @@ function whereReport(dotDir) {
   const storage = kind === "linked" ? "branch" : kind === "standalone" ? "repository" : "plain";
   const remote = kind ? boardRemote(dotDir) : null;
   const state = remote ? readSyncState(dotDir) : null;
+  const remoteUrl = remote ? git(["remote", "get-url", remote], dotDir).stdout || null : null;
+  const remoteRef = remote ? boardRemoteRef(dotDir) : null;
   return {
     path: dotDir,
     storage,
     branch: kind === "linked" ? boardBranch(dotDir) : null,
     repository: kind === "linked" ? gitToplevel(path10.dirname(dotDir)) : null,
     remote,
-    remoteUrl: remote ? git(["remote", "get-url", remote], dotDir).stdout || null : null,
-    remoteBranch: remote ? boardRemoteBranch(dotDir) : null,
+    remoteUrl,
+    remoteRef,
+    webUrl: remoteRef ? boardWebUrl(remoteUrl, remoteRef) : null,
     autosync: remote ? effectiveAutosync(dotDir) : null,
     lastSyncSecondsAgo: remote ? secondsSinceSync(dotDir) : null,
     lastSyncOk: state ? state.ok : null,
@@ -5353,7 +5470,7 @@ function whereReport(dotDir) {
 }
 function whereCommand(options, logger = defaultLogger) {
   const filePath = resolveCliBrainfilePath(options.file);
-  if (!fs8.existsSync(filePath)) throw fileNotFound(filePath);
+  if (!fs9.existsSync(filePath)) throw fileNotFound(filePath);
   const dotDir = path10.dirname(filePath);
   const report = whereReport(dotDir);
   if (options.json) {
@@ -5379,7 +5496,9 @@ function whereCommand(options, logger = defaultLogger) {
     return report;
   }
   const url2 = report.remoteUrl ? ` (${report.remoteUrl})` : "";
-  logger.log(`${label("Shared")}  through ${report.remote}${url2}, branch '${report.remoteBranch}'`);
+  logger.log(`${label("Shared")}  through ${report.remote}${url2}`);
+  more(import_chalk9.default.gray(`Stored there as ${report.remoteRef}, not a branch, so it stays out of branch lists and pull requests.`));
+  if (report.webUrl) more(import_chalk9.default.gray(`On the web: ${report.webUrl}`));
   const last = report.lastSyncSecondsAgo === null ? "" : report.lastSyncOk === false ? import_chalk9.default.yellow(`Last sync failed ${ago(report.lastSyncSecondsAgo)}; your changes are safe on this machine.`) : `Last synced ${ago(report.lastSyncSecondsAgo)}.`;
   const waiting = report.pendingChanges > 0 ? `${report.pendingChanges} change${report.pendingChanges === 1 ? "" : "s"} waiting to be sent.` : "Nothing waiting to be sent.";
   more([last, waiting].filter(Boolean).join(" "));
@@ -5500,7 +5619,7 @@ function patchCommand(options) {
 
 // src/commands/delete.ts
 var import_chalk11 = __toESM(require_source());
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path12 from "path";
 function isUnsafeTaskId2(taskId) {
   const trimmed = taskId.trim();
@@ -5540,7 +5659,7 @@ function deleteCommand(options) {
       console.log(import_chalk11.default.gray('Use --force to confirm deletion, or use "brainfile archive" to archive instead.'));
       process.exit(0);
     }
-    fs9.unlinkSync(taskPath);
+    fs10.unlinkSync(taskPath);
     console.log(import_chalk11.default.green("Task deleted successfully!"));
     console.log("");
     console.log(import_chalk11.default.gray(`  Task:   ${task.id} - ${task.title}`));
@@ -5553,7 +5672,7 @@ function deleteCommand(options) {
 // src/commands/archive.ts
 var import_core16 = __toESM(require_dist());
 var import_chalk12 = __toESM(require_source());
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path13 from "path";
 async function archiveCommand(options) {
   try {
@@ -5636,7 +5755,7 @@ function completeLocalV2(filePath, taskId, dryRun) {
 async function archiveSingleFromLogsV2(filePath, board, taskId, destination, dryRun, parsedDest) {
   const dirs = (0, import_core.getV2Dirs)(filePath);
   const logPath = path13.join(dirs.logsDir, (0, import_core16.taskFileName)(taskId));
-  if (!fs10.existsSync(logPath)) {
+  if (!fs11.existsSync(logPath)) {
     operationError(`Task not found in logs: ${taskId}`);
     return;
   }
@@ -5654,10 +5773,10 @@ async function archiveSingleFromLogsV2(filePath, board, taskId, destination, dry
   }
   if (destination === "github") {
     await archiveToGitHub(board, task, "Completed", dryRun, parsedDest);
-    fs10.unlinkSync(logPath);
+    fs11.unlinkSync(logPath);
   } else if (destination === "linear") {
     await archiveToLinear(board, task, "Completed", dryRun, parsedDest);
-    fs10.unlinkSync(logPath);
+    fs11.unlinkSync(logPath);
   }
 }
 async function archiveAllFromLogsV2(filePath, board, destination, dryRun) {
@@ -5707,7 +5826,7 @@ async function archiveAllFromLogsV2(filePath, board, destination, dryRun) {
         });
         if (result.success) {
           const logPath = path13.join(dirs.logsDir, (0, import_core16.taskFileName)(task.id));
-          fs10.unlinkSync(logPath);
+          fs11.unlinkSync(logPath);
           console.log(import_chalk12.default.green("  OK") + ` #${result.issueNumber}`);
           successCount++;
         } else {
@@ -5736,7 +5855,7 @@ async function archiveAllFromLogsV2(filePath, board, destination, dryRun) {
         });
         if (result.success) {
           const logPath = path13.join(dirs.logsDir, (0, import_core16.taskFileName)(task.id));
-          fs10.unlinkSync(logPath);
+          fs11.unlinkSync(logPath);
           console.log(import_chalk12.default.green("  OK") + ` ${result.issueId}`);
           successCount++;
         } else {
@@ -5898,12 +6017,12 @@ async function archiveToLinear(board, task, columnTitle, dryRun, parsedDest) {
 // src/commands/restore.ts
 var import_core18 = __toESM(require_dist());
 var import_chalk13 = __toESM(require_source());
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path15 from "path";
 
 // src/utils/archive.ts
 var import_core17 = __toESM(require_dist());
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path14 from "path";
 function getArchivePath(filePath) {
   const dir = path14.dirname(filePath);
@@ -5913,11 +6032,11 @@ function getArchivePath(filePath) {
 }
 function loadArchivedTasks(filePath) {
   const archivePath = getArchivePath(filePath);
-  if (!fs11.existsSync(archivePath)) {
+  if (!fs12.existsSync(archivePath)) {
     return { tasks: [], archivePath };
   }
   try {
-    const archiveContent = fs11.readFileSync(archivePath, "utf-8");
+    const archiveContent = fs12.readFileSync(archivePath, "utf-8");
     const parseResult = import_core17.Brainfile.parseWithErrors(archiveContent);
     if (parseResult.board && Array.isArray(parseResult.board.archive)) {
       return { tasks: parseResult.board.archive, archivePath };
@@ -5933,12 +6052,12 @@ function loadArchivedTasks(filePath) {
 }
 function restoreFromArchive(filePath, taskId, toColumnId) {
   const archivePath = getArchivePath(filePath);
-  if (!fs11.existsSync(archivePath)) {
+  if (!fs12.existsSync(archivePath)) {
     return { success: false, error: "Archive file not found" };
   }
   let archiveBoard;
   try {
-    const archiveContent = fs11.readFileSync(archivePath, "utf-8");
+    const archiveContent = fs12.readFileSync(archivePath, "utf-8");
     const parseResult = import_core17.Brainfile.parseWithErrors(archiveContent);
     if (!parseResult.board) {
       return { success: false, error: "Failed to parse archive file" };
@@ -5956,7 +6075,7 @@ function restoreFromArchive(filePath, taskId, toColumnId) {
   }
   let board;
   try {
-    const mainContent = fs11.readFileSync(filePath, "utf-8");
+    const mainContent = fs12.readFileSync(filePath, "utf-8");
     const parseResult = import_core17.Brainfile.parseWithErrors(mainContent);
     if (!parseResult.board) {
       return { success: false, error: "Failed to parse main brainfile" };
@@ -5976,9 +6095,9 @@ function restoreFromArchive(filePath, taskId, toColumnId) {
   archiveBoard.archive = archiveBoard.archive.filter((t) => t.id !== taskId);
   try {
     const mainContent = import_core17.Brainfile.serialize(board);
-    fs11.writeFileSync(filePath, mainContent, "utf-8");
+    fs12.writeFileSync(filePath, mainContent, "utf-8");
     const archiveContent = import_core17.Brainfile.serialize(archiveBoard);
-    fs11.writeFileSync(archivePath, archiveContent, "utf-8");
+    fs12.writeFileSync(archivePath, archiveContent, "utf-8");
   } catch (err) {
     return {
       success: false,
@@ -5998,10 +6117,10 @@ function restoreCommand(options) {
       missingRequiredError("--column", "brainfile restore --task <task-id> --column <column-name>");
     }
     const filePath = resolveCliBrainfilePath(options.file);
-    if (!fs12.existsSync(filePath)) {
+    if (!fs13.existsSync(filePath)) {
       fileNotFoundError(filePath);
     }
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs13.readFileSync(filePath, "utf-8");
     const result = import_core18.Brainfile.parseWithErrors(content);
     if (!result.board) {
       parseError(result.error);
@@ -6110,12 +6229,12 @@ function completeV2(filePath, taskId, force, logger) {
 
 // src/commands/log.ts
 var import_chalk15 = __toESM(require_source());
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path17 from "path";
 var import_core20 = __toESM(require_dist());
 function logCommand(options, logger = defaultLogger) {
   const filePath = resolveCliBrainfilePath(options.file);
-  if (!fs13.existsSync(filePath)) {
+  if (!fs14.existsSync(filePath)) {
     throw fileNotFound(filePath);
   }
   if (!(0, import_core.isV2)(filePath)) {
@@ -6138,7 +6257,7 @@ function logNoteCommand(options, logger = defaultLogger) {
     throw missingRequired("message", 'brainfile log note --task <task-id> "message"');
   }
   const filePath = resolveCliBrainfilePath(options.file);
-  if (!fs13.existsSync(filePath)) {
+  if (!fs14.existsSync(filePath)) {
     throw fileNotFound(filePath);
   }
   if (!(0, import_core.isV2)(filePath)) {
@@ -6151,7 +6270,8 @@ function logNoteCommand(options, logger = defaultLogger) {
   }
   const { doc, filePath: taskPath } = found;
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
-  const agentPrefix = options.agent ? `[${options.agent}] ` : "";
+  const actor = options.agent?.trim() || resolveActor(path17.dirname(filePath))?.name;
+  const agentPrefix = actor ? `[${actor}] ` : "";
   const entry = `- ${timestamp2}: ${agentPrefix}${options.message}`;
   const existingDesc = (0, import_core.extractDescription)(doc.body);
   const existingLog = (0, import_core.extractLog)(doc.body);
@@ -6248,8 +6368,8 @@ function listRecentLogs(dirs, logger) {
   const seenIds = new Set(logDocs.map((d) => d.task.id));
   const entries = logDocs.map((d) => ({ id: d.task.id, title: d.task.title, completedAt: d.task.completedAt }));
   const ledgerPath = path17.join(dirs.logsDir, "ledger.jsonl");
-  if (fs13.existsSync(ledgerPath)) {
-    for (const line of fs13.readFileSync(ledgerPath, "utf-8").split("\n")) {
+  if (fs14.existsSync(ledgerPath)) {
+    for (const line of fs14.readFileSync(ledgerPath, "utf-8").split("\n")) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       try {
@@ -6287,7 +6407,7 @@ function listRecentLogs(dirs, logger) {
 // src/commands/brief.ts
 var import_chalk16 = __toESM(require_source());
 var import_core21 = __toESM(require_dist());
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path18 from "path";
 var BRIEF_JSON_VERSION = "0.1";
 function briefCommand(options, logger = defaultLogger) {
@@ -6327,7 +6447,7 @@ function runBrief(options) {
     throw missingRequired("--agent", "brainfile brief --agent <name>");
   }
   const filePath = resolveCliBrainfilePath(options.file);
-  if (!fs14.existsSync(filePath)) {
+  if (!fs15.existsSync(filePath)) {
     throw fileNotFound(filePath);
   }
   if (!(0, import_core.isV2)(filePath)) {
@@ -6336,7 +6456,7 @@ function runBrief(options) {
     );
   }
   if (!options.offline) {
-    const sync = syncBoard(path18.dirname(filePath), { agent });
+    const sync = syncBoard(path18.dirname(filePath));
     if (!sync.skipped && !sync.ok) {
       process.stderr.write(`${syncMessage(sync).text}
 `);
@@ -32992,11 +33112,11 @@ var require_dist2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     if (!f) throw new Error(`Unknown format "${name}"`);
     return f;
   };
-  function addFormats2(ajv, list, fs24, exportName) {
+  function addFormats2(ajv, list, fs25, exportName) {
     var _a2;
     var _b;
     (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
-    for (const f of list) ajv.addFormat(f, fs24[f]);
+    for (const f of list) ajv.addFormat(f, fs25[f]);
   }
   module.exports = exports = formatsPlugin;
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -35089,14 +35209,14 @@ import * as path23 from "path";
 
 // src/mcp/helpers.ts
 var import_core31 = __toESM(require_dist());
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path19 from "path";
 function resolveBrainfile(filePath) {
   return path19.resolve(filePath);
 }
 function requireV2(filePath) {
   const resolvedPath = resolveBrainfile(filePath);
-  if (!fs15.existsSync(resolvedPath)) {
+  if (!fs16.existsSync(resolvedPath)) {
     return { content: [{ type: "text", text: `Error: File not found: ${resolvedPath}` }], isError: true };
   }
   if (!(0, import_core31.isV2)(resolvedPath)) {
@@ -35124,7 +35244,7 @@ function findGitRoot(startDir) {
   const root = path19.parse(currentDir).root;
   while (currentDir !== root) {
     const gitPath = path19.join(currentDir, ".git");
-    if (fs15.existsSync(gitPath)) {
+    if (fs16.existsSync(gitPath)) {
       return currentDir;
     }
     const parentDir = path19.dirname(currentDir);
@@ -35151,10 +35271,7 @@ function withBoardCommit(toolName, defaultFile, handler) {
         const filePath = typeof input.file === "string" && input.file ? input.file : defaultFile;
         const dotDir = path19.dirname(resolveBrainfile(filePath));
         if (isTrackedBoard(dotDir)) {
-          commitBoard(dotDir, {
-            message: describeToolCall(toolName, input),
-            agent: process.env.BRAINFILE_AGENT ?? null
-          });
+          commitBoard(dotDir, { message: describeToolCall(toolName, input), agent: detectAgent()?.name });
         }
       }
     } catch {
@@ -35859,7 +35976,7 @@ function registerTaskPatchTool(server, defaultFile) {
 }
 
 // src/mcp/tools/task_delete_tool.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 function registerTaskDeleteTool(server, defaultFile) {
   server.registerTool(
     "task_delete",
@@ -35885,7 +36002,7 @@ function registerTaskDeleteTool(server, defaultFile) {
           return { content: [{ type: "text", text: `Error: Task not found: ${task}` }], isError: true };
         }
         try {
-          fs16.unlinkSync(found.filePath);
+          fs17.unlinkSync(found.filePath);
           return {
             content: [{ type: "text", text: `Task ${task} deleted successfully` }],
             structuredContent: { id: task, deleted: true }
@@ -36079,9 +36196,9 @@ var import_core43 = __toESM(require_dist());
 
 // src/lib/contractRunner.ts
 var import_core40 = __toESM(require_dist());
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as path21 from "path";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 function detectDirectoryChangeWarning(command) {
   const patterns = [
     /\bcd\s+[^\s;|&]+/,
@@ -36099,7 +36216,7 @@ function detectDirectoryChangeWarning(command) {
   return void 0;
 }
 function requireV2Runner(resolvedFilePath) {
-  if (!fs17.existsSync(resolvedFilePath)) {
+  if (!fs18.existsSync(resolvedFilePath)) {
     return { error: `File not found: ${resolvedFilePath}` };
   }
   if (!(0, import_core.isV2)(resolvedFilePath)) {
@@ -36259,7 +36376,7 @@ function validateContractV2(ctx, resolvedFilePath) {
       continue;
     }
     const resolved = path21.isAbsolute(normalized.value) ? normalized.value : path21.join(baseDir, normalized.value);
-    if (!fs17.existsSync(resolved)) {
+    if (!fs18.existsSync(resolved)) {
       deliverableChecks.push({ deliverable: d, ok: false, resolvedPath: resolved, error: "File not found" });
     } else {
       deliverableChecks.push({ deliverable: d, ok: true, resolvedPath: resolved });
@@ -36282,7 +36399,7 @@ function validateContractV2(ctx, resolvedFilePath) {
       if (dirWarning) {
         warnings.push({ command: normalized.value, message: dirWarning });
       }
-      const res = spawnSync2(normalized.value, {
+      const res = spawnSync3(normalized.value, {
         shell: true,
         cwd: baseDir,
         encoding: "utf-8"
@@ -36937,7 +37054,7 @@ function registerContractTool(server, defaultFile) {
 
 // src/mcp/tools/task_complete_tool.ts
 var import_core44 = __toESM(require_dist());
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 function registerTaskCompleteTool(server, defaultFile) {
   server.registerTool(
     "task_complete",
@@ -37029,7 +37146,7 @@ ${result.incompleteChildren.map((c) => `  - ${c.id}: ${c.title}`).join("\n")}` :
             if (!ghResult.success) {
               return { content: [{ type: "text", text: `Error creating GitHub issue: ${ghResult.error}` }], isError: true };
             }
-            fs18.unlinkSync(found.filePath);
+            fs19.unlinkSync(found.filePath);
             return {
               content: [{ type: "text", text: `Task ${task} archived to GitHub Issue #${ghResult.issueNumber} (closed)
 
@@ -37081,7 +37198,7 @@ ${teamList}` }], isError: true };
           if (!linearResult.success) {
             return { content: [{ type: "text", text: `Error creating Linear issue: ${linearResult.error}` }], isError: true };
           }
-          fs18.unlinkSync(found.filePath);
+          fs19.unlinkSync(found.filePath);
           return {
             content: [{ type: "text", text: `Task ${task} archived to Linear Issue ${linearResult.issueId} (Done)
 
@@ -37130,7 +37247,7 @@ function registerBriefTool(server, defaultFile) {
         };
       }
       const resolvedPath = resolveBrainfile(filePath);
-      if (!offline) syncBoard(path22.dirname(resolvedPath), { agent: agentName });
+      if (!offline) syncBoard(path22.dirname(resolvedPath));
       const dirs = (0, import_core.getV2Dirs)(resolvedPath);
       const isPeek = peek === true;
       const state = (0, import_core45.readBriefState)(resolvedPath, agentName);
@@ -37234,7 +37351,7 @@ var import_chalk20 = __toESM(require_source());
 import * as readline2 from "readline";
 
 // src/utils/hook-settings.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as path24 from "path";
 import * as os from "os";
 function resolveHomeDir() {
@@ -37266,24 +37383,24 @@ function getSettingsPath(tool, scope) {
 function readToolSettings(tool, scope) {
   const settingsPath = getSettingsPath(tool, scope);
   if (tool === "cline") {
-    if (!fs19.existsSync(settingsPath)) {
+    if (!fs20.existsSync(settingsPath)) {
       return { hooks: {} };
     }
     const hooks = {};
     const hookFiles = ["PostToolUse", "UserPromptSubmit", "TaskStart"];
     for (const hookFile of hookFiles) {
       const hookPath = path24.join(settingsPath, hookFile);
-      if (fs19.existsSync(hookPath)) {
+      if (fs20.existsSync(hookPath)) {
         hooks[hookFile] = true;
       }
     }
     return { hooks };
   }
-  if (!fs19.existsSync(settingsPath)) {
+  if (!fs20.existsSync(settingsPath)) {
     return tool === "cursor" ? { version: 1, hooks: {} } : {};
   }
   try {
-    const content = fs19.readFileSync(settingsPath, "utf-8");
+    const content = fs20.readFileSync(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return tool === "cursor" ? { version: 1, hooks: {} } : {};
@@ -37292,10 +37409,10 @@ function readToolSettings(tool, scope) {
 function writeToolSettings(tool, scope, settings) {
   const settingsPath = getSettingsPath(tool, scope);
   const settingsDir = path24.dirname(settingsPath);
-  if (!fs19.existsSync(settingsDir)) {
-    fs19.mkdirSync(settingsDir, { recursive: true });
+  if (!fs20.existsSync(settingsDir)) {
+    fs20.mkdirSync(settingsDir, { recursive: true });
   }
-  fs19.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  fs20.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
 }
 function createClineHookScript(hookType) {
   const commandMap = {
@@ -37345,8 +37462,8 @@ function installBrainfileHooks(tool, scope) {
   const settings = readToolSettings(tool, scope);
   if (tool === "cline") {
     const hooksDir = getSettingsPath(tool, scope);
-    if (!fs19.existsSync(hooksDir)) {
-      fs19.mkdirSync(hooksDir, { recursive: true });
+    if (!fs20.existsSync(hooksDir)) {
+      fs20.mkdirSync(hooksDir, { recursive: true });
     }
     const hookTypes = [
       "PostToolUse",
@@ -37356,7 +37473,7 @@ function installBrainfileHooks(tool, scope) {
     for (const hookType of hookTypes) {
       const hookPath = path24.join(hooksDir, hookType);
       const scriptContent = createClineHookScript(hookType);
-      fs19.writeFileSync(hookPath, scriptContent, { mode: 493 });
+      fs20.writeFileSync(hookPath, scriptContent, { mode: 493 });
     }
     return;
   }
@@ -37446,16 +37563,16 @@ function installBrainfileHooks(tool, scope) {
 function uninstallBrainfileHooks(tool, scope) {
   if (tool === "cline") {
     const hooksDir = getSettingsPath(tool, scope);
-    if (!fs19.existsSync(hooksDir)) {
+    if (!fs20.existsSync(hooksDir)) {
       return;
     }
     const hookFiles = ["PostToolUse", "UserPromptSubmit", "TaskStart"];
     for (const hookFile of hookFiles) {
       const hookPath = path24.join(hooksDir, hookFile);
-      if (fs19.existsSync(hookPath)) {
-        const content = fs19.readFileSync(hookPath, "utf-8");
+      if (fs20.existsSync(hookPath)) {
+        const content = fs20.readFileSync(hookPath, "utf-8");
         if (content.includes("brainfile hooks")) {
-          fs19.unlinkSync(hookPath);
+          fs20.unlinkSync(hookPath);
         }
       }
     }
@@ -37502,15 +37619,15 @@ function uninstallBrainfileHooks(tool, scope) {
 }
 function areBrainfileHooksInstalled(tool, scope) {
   const settingsPath = getSettingsPath(tool, scope);
-  if (!fs19.existsSync(settingsPath)) {
+  if (!fs20.existsSync(settingsPath)) {
     return false;
   }
   if (tool === "cline") {
     const hookFiles = ["PostToolUse", "UserPromptSubmit", "TaskStart"];
     for (const hookFile of hookFiles) {
       const hookPath = path24.join(settingsPath, hookFile);
-      if (fs19.existsSync(hookPath)) {
-        const content = fs19.readFileSync(hookPath, "utf-8");
+      if (fs20.existsSync(hookPath)) {
+        const content = fs20.readFileSync(hookPath, "utf-8");
         if (content.includes("brainfile hooks")) {
           return true;
         }
@@ -37550,7 +37667,7 @@ function areBrainfileHooksInstalled(tool, scope) {
 
 // src/utils/brainfile-finder.ts
 var import_core47 = __toESM(require_dist());
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 function findBrainfile3() {
   const found = (0, import_core47.findBrainfile)(process.cwd());
   if (found && found.kind !== "dotdir") return null;
@@ -37558,7 +37675,7 @@ function findBrainfile3() {
 }
 function getFileAgeMinutes(filePath) {
   try {
-    const stats = fs20.statSync(filePath);
+    const stats = fs21.statSync(filePath);
     const now = Date.now();
     const modifiedTime = stats.mtimeMs;
     const ageMs = now - modifiedTime;
@@ -38021,17 +38138,17 @@ function flattenConfig(obj, prefix = "") {
 
 // src/commands/schema.ts
 var import_chalk22 = __toESM(require_source());
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as path25 from "path";
 var SCHEMA_BASE_URL = "https://brainfile.md/v1";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function getBundledSchemasDir() {
   const distPath = path25.join(__dirname, "..", "schemas");
   const srcPath = path25.join(__dirname, "..", "..", "src", "schemas");
-  if (fs21.existsSync(distPath)) {
+  if (fs22.existsSync(distPath)) {
     return distPath;
   }
-  if (fs21.existsSync(srcPath)) {
+  if (fs22.existsSync(srcPath)) {
     return srcPath;
   }
   return path25.join(__dirname, "schemas");
@@ -38117,14 +38234,14 @@ function schemaShowCommand(name, options, logger) {
   }
   const schemasDir = getBundledSchemasDir();
   const schemaPath = path25.join(schemasDir, schemaInfo.file);
-  if (!fs21.existsSync(schemaPath)) {
+  if (!fs22.existsSync(schemaPath)) {
     throw new CLIError(
       `Schema file not found: ${schemaInfo.file}`,
       ExitCode.USER_ERROR,
       `Expected at: ${schemaPath}`
     );
   }
-  const content = fs21.readFileSync(schemaPath, "utf-8");
+  const content = fs22.readFileSync(schemaPath, "utf-8");
   const schema2 = JSON.parse(content);
   if (options.json) {
     logger.log(JSON.stringify(schema2, null, 2));
@@ -38190,14 +38307,14 @@ async function schemaUpdateAsync(options, logger) {
       const remoteContent = await response.text();
       const remoteSchema = JSON.parse(remoteContent);
       let localSchema = null;
-      if (fs21.existsSync(localPath)) {
-        const localContent = fs21.readFileSync(localPath, "utf-8");
+      if (fs22.existsSync(localPath)) {
+        const localContent = fs22.readFileSync(localPath, "utf-8");
         localSchema = JSON.parse(localContent);
       }
       const remoteStr = JSON.stringify(remoteSchema);
       const localStr = localSchema ? JSON.stringify(localSchema) : "";
       if (remoteStr !== localStr) {
-        fs21.writeFileSync(localPath, JSON.stringify(remoteSchema, null, 2));
+        fs22.writeFileSync(localPath, JSON.stringify(remoteSchema, null, 2));
         results.push({ id: schemaInfo.id, status: "updated" });
       } else {
         results.push({ id: schemaInfo.id, status: "current" });
@@ -38274,8 +38391,8 @@ async function checkForUpdatesAsync(logger) {
       }
       const remoteContent = await response.text();
       const remoteSchema = JSON.parse(remoteContent);
-      if (fs21.existsSync(localPath)) {
-        const localContent = fs21.readFileSync(localPath, "utf-8");
+      if (fs22.existsSync(localPath)) {
+        const localContent = fs22.readFileSync(localPath, "utf-8");
         const localSchema = JSON.parse(localContent);
         const remoteStr = JSON.stringify(remoteSchema);
         const localStr = JSON.stringify(localSchema);
@@ -38299,7 +38416,7 @@ async function checkForUpdatesAsync(logger) {
 // src/commands/adr.ts
 var import_chalk23 = __toESM(require_source());
 var import_core48 = __toESM(require_dist());
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as path26 from "path";
 var ADR_COMMAND_HELP = `
 Examples:
@@ -38326,7 +38443,7 @@ function adrPromoteCommand(options, logger = defaultLogger) {
     );
   }
   const resolvedPath = resolveCliBrainfilePath(options.file);
-  if (!fs22.existsSync(resolvedPath)) {
+  if (!fs23.existsSync(resolvedPath)) {
     throw fileNotFound(resolvedPath);
   }
   if (!(0, import_core.isV2)(resolvedPath)) {
@@ -38353,13 +38470,13 @@ function adrPromoteCommand(options, logger = defaultLogger) {
   };
   delete promotedTask.column;
   delete promotedTask.position;
-  fs22.mkdirSync(dirs.logsDir, { recursive: true });
+  fs23.mkdirSync(dirs.logsDir, { recursive: true });
   const logPath = path26.join(dirs.logsDir, (0, import_core48.taskFileName)(task.id));
-  if (fs22.existsSync(logPath)) {
+  if (fs23.existsSync(logPath)) {
     throw operationFailed(`Log already exists for ADR: ${task.id}`);
   }
   (0, import_core48.writeTaskFile)(logPath, promotedTask, doc.body);
-  fs22.unlinkSync(taskPath);
+  fs23.unlinkSync(taskPath);
   logger.log(import_chalk23.default.green("ADR promoted!"));
   logger.log("");
   logger.log(import_chalk23.default.gray(`  ADR:         ${task.id} - ${task.title}`));
@@ -38546,7 +38663,7 @@ function planLinkCommand(options, logger = defaultLogger) {
 }
 
 // src/commands/types.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 
 // ../node_modules/js-yaml/dist/js-yaml.mjs
 function getDefaultExportFromCjs(x) {
@@ -40315,7 +40432,7 @@ function requireLoader() {
     const _tag = state.tag;
     const _anchor = state.anchor;
     const _result = [];
-    let detected = false;
+    let detected2 = false;
     if (state.firstTabInLine !== -1) return false;
     if (state.anchor !== null) {
       storeAnchor(state, state.anchor, _result);
@@ -40333,7 +40450,7 @@ function requireLoader() {
       if (!isWsOrEol(following)) {
         break;
       }
-      detected = true;
+      detected2 = true;
       state.position++;
       if (skipSeparationSpace(state, true, -1)) {
         if (state.lineIndent <= nodeIndent) {
@@ -40353,7 +40470,7 @@ function requireLoader() {
         break;
       }
     }
-    if (detected) {
+    if (detected2) {
       state.tag = _tag;
       state.anchor = _anchor;
       state.kind = "sequence";
@@ -40375,7 +40492,7 @@ function requireLoader() {
     let keyNode = null;
     let valueNode = null;
     let atExplicitKey = false;
-    let detected = false;
+    let detected2 = false;
     if (state.firstTabInLine !== -1) return false;
     if (state.anchor !== null) {
       storeAnchor(state, state.anchor, _result);
@@ -40394,7 +40511,7 @@ function requireLoader() {
             storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
             keyTag = keyNode = valueNode = null;
           }
-          detected = true;
+          detected2 = true;
           atExplicitKey = true;
           allowCompact = true;
         } else if (atExplicitKey) {
@@ -40426,19 +40543,19 @@ function requireLoader() {
               storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
               keyTag = keyNode = valueNode = null;
             }
-            detected = true;
+            detected2 = true;
             atExplicitKey = false;
             allowCompact = false;
             keyTag = state.tag;
             keyNode = state.result;
-          } else if (detected) {
+          } else if (detected2) {
             throwError(state, "can not read an implicit mapping pair; a colon is missed");
           } else {
             state.tag = _tag;
             state.anchor = _anchor;
             return true;
           }
-        } else if (detected) {
+        } else if (detected2) {
           throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
         } else {
           state.tag = _tag;
@@ -40475,13 +40592,13 @@ function requireLoader() {
     if (atExplicitKey) {
       storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
     }
-    if (detected) {
+    if (detected2) {
       state.tag = _tag;
       state.anchor = _anchor;
       state.kind = "mapping";
       state.result = _result;
     }
-    return detected;
+    return detected2;
   }
   function readTagProperty(state) {
     let isVerbatim = false;
@@ -41647,11 +41764,11 @@ ${yamlContent}---
 ${doc.body}`;
 }
 function readFrontmatter(filePath) {
-  const content = fs23.readFileSync(filePath, "utf-8");
+  const content = fs24.readFileSync(filePath, "utf-8");
   return parseFrontmatter(content);
 }
 function writeFrontmatter(filePath, doc) {
-  fs23.writeFileSync(filePath, serializeFrontmatter(doc), "utf-8");
+  fs24.writeFileSync(filePath, serializeFrontmatter(doc), "utf-8");
 }
 function sanitizeTypesConfig(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -41773,11 +41890,11 @@ function typesAddCommand(options, logger = defaultLogger) {
 
 // src/cli.ts
 async function runTui(options) {
-  const { tuiCommand } = await import("./tui-M2KWIG2E.mjs");
+  const { tuiCommand } = await import("./tui-3Z7ZJV7M.mjs");
   return tuiCommand(options);
 }
 var packageJson = JSON.parse(
-  readFileSync10(join18(__dirname, "..", "package.json"), "utf8")
+  readFileSync11(join18(__dirname, "..", "package.json"), "utf8")
 );
 var SUBCOMMANDS = ["init", "migrate", "list", "show", "add", "move", "patch", "delete", "archive", "restore", "complete", "log", "note", "brief", "search", "subtask", "template", "lint", "tui", "hooks", "mcp", "auth", "config", "contract", "schema", "adr", "plan", "types", "sync", "where", "merge-driver", "help"];
 function shouldLaunchTUI() {
@@ -41795,7 +41912,7 @@ function shouldLaunchTUI() {
   if (SUBCOMMANDS.includes(firstArg)) {
     return { launch: false, file: "" };
   }
-  if (firstArg.includes(".") || firstArg.includes("/") || firstArg.endsWith(sep3) || existsSync19(firstArg)) {
+  if (firstArg.includes(".") || firstArg.includes("/") || firstArg.endsWith(sep3) || existsSync20(firstArg)) {
     return { launch: true, file: firstArg };
   }
   return { launch: false, file: "" };
@@ -41892,13 +42009,13 @@ ${ADD_COMMAND_HELP}`);
   program2.command("log").description("View, search, and manage completed task logs (v2 only)").option("-f, --file <path>", "Path to brainfile file (auto-detect by default)", "brainfile.md").option("-t, --task <id>", "View a specific task log").option("-s, --search <query>", "Search across all logs").option("--recent", "List recently completed tasks").action((options) => {
     logCommand(options);
   });
-  program2.command("note").description("Append a timestamped note to a task log").option("-f, --file <path>", "Path to brainfile file (auto-detect by default)", "brainfile.md").option("-t, --task <id>", "Task ID to add note to (required)").option("--agent <name>", "Agent name for attribution").argument("[message]", "Log message to append").action((message, options) => {
+  program2.command("note").description("Append a timestamped note to a task log").option("-f, --file <path>", "Path to brainfile file (auto-detect by default)", "brainfile.md").option("-t, --task <id>", "Task ID to add note to (required)").option("--agent <name>", "Who wrote it (default: the detected agent, else your git user.name)").argument("[message]", "Log message to append").action((message, options) => {
     logNoteCommand({ ...options, message });
   });
   program2.command("brief").description("Per-agent brief: what changed since this agent last checked in").option("-f, --file <path>", "Path to brainfile file (auto-detect by default)", "brainfile.md").option("--agent <name>", "Agent identifier (required \u2014 brief state is per-agent)").option("--peek", "Read the brief without marking it as seen").option("--offline", "Skip syncing a shared board before the brief").option("--json", "Output as JSON").action((options) => {
     briefCommand(options);
   });
-  const syncCmd = program2.command("sync").description("Share a tracked board through a git remote: fetch, merge, push").option("-f, --file <path>", "Path to brainfile file (auto-detect by default)", "brainfile.md").option("--pull", "Fetch and merge only").option("--push", "Push only").option("--set-remote <name|url>", 'Remote to sync with: an existing remote name, or a URL registered as remote "board"').option("--remote-branch <name>", 'Branch on the remote (default: board branch; folder name for a standalone board; "home" for -g)').option("--autosync <mode>", "off | push (after writes, default once a remote is set) | full (also fetch before reads)").option("--json", "Output as JSON").addOption(new Option("--wait <ms>", "Sleep before syncing (autosync child)").hideHelp()).action((options) => {
+  const syncCmd = program2.command("sync").description("Share a tracked board through a git remote: fetch, merge, push").option("-f, --file <path>", "Path to brainfile file (auto-detect by default)", "brainfile.md").option("--pull", "Fetch and merge only").option("--push", "Push only").option("--set-remote <name|url>", 'Remote to sync with: an existing remote name, or a URL registered as remote "board"').option("--board-name <name>", 'Name on the remote, stored as refs/brainfile/<name> (default: "board"; folder name for a standalone board; "home" for -g)').addOption(new Option("--remote-branch <name>", "0.21.0 spelling of --board-name").hideHelp()).option("--autosync <mode>", "off | push (after writes, default once a remote is set) | full (also fetch before reads)").option("--json", "Output as JSON").addOption(new Option("--wait <ms>", "Sleep before syncing (autosync child)").hideHelp()).action((options) => {
     syncCommand(options);
   });
   syncCmd.addHelpText("after", `