brainfile 0.21.0 → 0.21.1

package/dist/{chunk-FOLBAGJS.mjs → chunk-MUV7XTFA.mjs}

@@ -1003,7 +1003,7 @@ var require_ansi_styles = __commonJS({
       });
     };
     var colorConvert;
-    var makeDynamicStyles = (wrap, targetSpace, identity2, isBackground) => {
+    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
       if (colorConvert === void 0) {
         colorConvert = require_color_convert();
       }
@@ -1012,7 +1012,7 @@ var require_ansi_styles = __commonJS({
       for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
         const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
         if (sourceSpace === targetSpace) {
-          styles[name] = wrap(identity2, offset);
+          styles[name] = wrap(identity, offset);
         } else if (typeof suite === "object") {
           styles[name] = wrap(suite[targetSpace], offset);
         }
@@ -11549,18 +11549,34 @@ import * as path2 from "path";
 import { spawnSync } from "child_process";
 var DEFAULT_BOARD_BRANCH = "brainfile";
 var BOARD_BRANCH_CONFIG_KEY = "brainfile.branch";
+var BOARD_REF_NAMESPACE = "refs/brainfile";
+var BOARD_NAME_CONFIG_KEY = "brainfile.boardName";
+var LEGACY_REMOTE_BRANCH_CONFIG_KEY = "brainfile.remoteBranch";
+var DEFAULT_BOARD_NAME = "board";
+function remoteBoardRef(name) {
+  return `${BOARD_REF_NAMESPACE}/${name}`;
+}
+function boardTrackingRef(remote, name) {
+  return `${BOARD_REF_NAMESPACE}/remotes/${remote}/${name}`;
+}
+var NETWORK_TIMEOUT_MS = 8e3;
+var NO_PROMPT_ENV = { GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "echo", SSH_ASKPASS: "echo" };
+function gitNetwork(args, cwd) {
+  return git(args, cwd, NO_PROMPT_ENV, NETWORK_TIMEOUT_MS);
+}
 var EXCLUDE_ENTRY = ".brainfile/";
 var EXCLUDE_MARKER = "# brainfile: board worktree (managed by `brainfile`)";
 var FALLBACK_IDENTITY_NAME = "brainfile";
 var FALLBACK_IDENTITY_EMAIL = "brainfile@localhost";
 var MAX_MESSAGE_LENGTH = 72;
 var BOARD_SUBDIRS = ["board", "logs"];
-function git(args, cwd, env) {
+function git(args, cwd, env, timeoutMs) {
   const result = spawnSync("git", args, {
     cwd,
     encoding: "utf-8",
     env: env ? { ...process.env, ...env } : process.env,
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    ...timeoutMs ? { timeout: timeoutMs, killSignal: "SIGKILL" } : {}
   });
   return {
     ok: result.status === 0,
@@ -11625,25 +11641,75 @@ function findTrackedBoardDir(cwd) {
   if (!hit) return null;
   return fs2.existsSync(path2.join(hit.path, "brainfile.md")) ? hit.path : null;
 }
-function materializeBoardWorktree(cwd) {
-  const branch = boardBranch(cwd);
-  const hasLocal = git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], cwd).ok;
-  const configuredRemote = git(["config", "--get", "brainfile.remote"], cwd).stdout || null;
-  const configuredBranch = git(["config", "--get", "brainfile.remoteBranch"], cwd).stdout || branch;
-  let upstream = null;
-  if (!hasLocal) {
-    if (configuredRemote) {
-      const ref = `${configuredRemote}/${configuredBranch}`;
-      if (!git(["rev-parse", "--verify", "--quiet", `refs/remotes/${ref}`], cwd).ok) {
-        git(["fetch", "--quiet", configuredRemote, configuredBranch], cwd);
-      }
-      if (git(["rev-parse", "--verify", "--quiet", `refs/remotes/${ref}`], cwd).ok) upstream = ref;
-    }
-    if (!upstream && git(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${branch}`], cwd).ok) {
-      upstream = `origin/${branch}`;
-    }
+var PROBE_MISS_TTL_MS = 10 * 6e4;
+function probeMissFile(cwd) {
+  const common = gitCommonDir(cwd);
+  return common ? path2.join(common, "brainfile-probe.json") : null;
+}
+function recentProbeMiss(cwd, remote) {
+  const file = probeMissFile(cwd);
+  if (!file) return false;
+  try {
+    const miss = JSON.parse(fs2.readFileSync(file, "utf-8"));
+    return miss.remote === remote && typeof miss.at === "number" && Date.now() - miss.at < PROBE_MISS_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+function recordProbeMiss(cwd, remote) {
+  const file = probeMissFile(cwd);
+  if (!file) return;
+  try {
+    fs2.writeFileSync(file, JSON.stringify({ remote, at: Date.now() }), "utf-8");
+  } catch {
+  }
+}
+function clearProbeMiss(cwd) {
+  const file = probeMissFile(cwd);
+  if (file) fs2.rmSync(file, { force: true });
+}
+function listRemoteBoards(cwd, remote) {
+  const r = gitNetwork(["ls-remote", "--quiet", remote, `${BOARD_REF_NAMESPACE}/*`], cwd);
+  if (!r.ok) return null;
+  const names = [];
+  for (const line of r.stdout.split("\n")) {
+    const ref = line.split("	")[1] ?? "";
+    const name = ref.slice(BOARD_REF_NAMESPACE.length + 1);
+    if (ref.startsWith(`${BOARD_REF_NAMESPACE}/`) && name && !name.includes("/")) names.push(name);
   }
-  if (!hasLocal && !upstream) return null;
+  return names;
+}
+function findBoardStart(cwd, branch, options) {
+  if (git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], cwd).ok) return { ref: branch, remote: null };
+  const configuredRemote = git(["config", "--get", "brainfile.remote"], cwd).stdout || null;
+  const remote = configuredRemote ?? (git(["remote", "get-url", "origin"], cwd).ok ? "origin" : null);
+  if (!remote) return null;
+  const configuredName = git(["config", "--get", BOARD_NAME_CONFIG_KEY], cwd).stdout || git(["config", "--get", LEGACY_REMOTE_BRANCH_CONFIG_KEY], cwd).stdout || null;
+  const knownName = configuredName ?? DEFAULT_BOARD_NAME;
+  const known = boardTrackingRef(remote, knownName);
+  if (git(["rev-parse", "--verify", "--quiet", known], cwd).ok) return { ref: known, remote, name: knownName };
+  if (options.fresh || !recentProbeMiss(cwd, remote)) {
+    const names = listRemoteBoards(cwd, remote);
+    const name = names === null ? null : configuredName ? names.includes(configuredName) ? configuredName : null : names.includes(DEFAULT_BOARD_NAME) ? DEFAULT_BOARD_NAME : names.length === 1 ? names[0] : null;
+    if (name) {
+      const tracking = boardTrackingRef(remote, name);
+      if (gitNetwork(["fetch", "--quiet", "--no-tags", remote, `+${remoteBoardRef(name)}:${tracking}`], cwd).ok) {
+        clearProbeMiss(cwd);
+        return { ref: tracking, remote, name };
+      }
+    }
+  }
+  const legacyBranch = configuredName ?? branch;
+  const legacy = `refs/remotes/${remote}/${legacyBranch}`;
+  if (!git(["rev-parse", "--verify", "--quiet", legacy], cwd).ok && configuredRemote && (options.fresh || !recentProbeMiss(cwd, remote))) {
+    gitNetwork(["fetch", "--quiet", "--no-tags", remote, `+refs/heads/${legacyBranch}:${legacy}`], cwd);
+  }
+  if (git(["rev-parse", "--verify", "--quiet", legacy], cwd).ok) return { ref: legacy, remote };
+  recordProbeMiss(cwd, remote);
+  return null;
+}
+function materializeBoardWorktree(cwd, options = {}) {
+  const branch = boardBranch(cwd);
   const worktrees = listWorktrees(cwd);
   if (worktrees.length === 0) return null;
   if (worktrees.some((w) => w.branch === `refs/heads/${branch}`)) return null;
@@ -11657,15 +11723,21 @@ function materializeBoardWorktree(cwd) {
     target = path2.join(main.path, ".brainfile");
   }
   if (fs2.existsSync(target)) return null;
-  const r = hasLocal ? git(["worktree", "add", "--quiet", target, branch], cwd) : git(["worktree", "add", "--quiet", "--track", "-b", branch, target, upstream], cwd);
+  const start = findBoardStart(cwd, branch, options);
+  if (!start) return null;
+  const r = start.remote ? git(["worktree", "add", "--quiet", "--no-track", "-b", branch, target, start.ref], cwd) : git(["worktree", "add", "--quiet", target, branch], cwd);
   if (!r.ok) return null;
   ensureExcludeEntry(cwd);
   for (const sub of BOARD_SUBDIRS) fs2.mkdirSync(path2.join(target, sub), { recursive: true });
-  const cameFrom = upstream ? upstream.slice(0, upstream.indexOf("/")) : null;
-  if (cameFrom && !configuredRemote) git(["config", "brainfile.remote", cameFrom], cwd);
+  if (start.remote) {
+    if (!git(["config", "--get", "brainfile.remote"], cwd).stdout) git(["config", "brainfile.remote", start.remote], cwd);
+    if (start.name && start.name !== DEFAULT_BOARD_NAME && !git(["config", "--get", BOARD_NAME_CONFIG_KEY], cwd).stdout) {
+      git(["config", BOARD_NAME_CONFIG_KEY, start.name], cwd);
+    }
+  }
   const relative3 = path2.relative(process.cwd(), target) || ".";
   process.stderr.write(
-    cameFrom ? `Checked out the shared board from ${cameFrom} into ${relative3}/
+    start.remote ? `Checked out the shared board from ${start.remote} into ${relative3}/
 ` : `Checked out the board from the '${branch}' branch into ${relative3}/
 `
   );
@@ -11731,9 +11803,6 @@ function identityArgs(dotDir) {
   if (!git(["config", "--get", "user.email"], dotDir).stdout) args.push("-c", `user.email=${FALLBACK_IDENTITY_EMAIL}`);
   return args;
 }
-function sanitizeAgent(agent) {
-  return agent.replace(/[<>\r\n]/g, "").trim();
-}
 var commitListeners = [];
 function onBoardCommitted(listener) {
   if (!commitListeners.includes(listener)) commitListeners.push(listener);
@@ -11768,17 +11837,12 @@ function commitBoard(dotDir, options) {
   if (unmergedFiles(dotDir).length > 0) return false;
   if (!git(["add", "-A"], dotDir).ok) return false;
   if (!boardIsDirty(dotDir)) return false;
-  const env = {};
-  const agent = options.agent ? sanitizeAgent(options.agent) : "";
-  if (agent) {
-    env.GIT_AUTHOR_NAME = agent;
-    env.GIT_AUTHOR_EMAIL = `${agent}@brainfile.local`;
-  }
-  const message = oneLine(options.message);
+  const agent = options.agent?.replace(/[[\]<>\r\n]/g, "").trim();
+  const suffix = agent ? ` [${agent}]` : "";
+  const message = oneLine(options.message, suffix);
   const r = git(
     [...identityArgs(dotDir), "-c", "commit.gpgsign=false", "commit", "--quiet", "--no-verify", "-m", message],
-    dotDir,
-    env
+    dotDir
   );
   if (r.ok) notifyCommitted(dotDir);
   return r.ok;
@@ -11794,13 +11858,6 @@ function commitHandEdits(dotDir) {
   const summary = files.length <= 3 ? files.join(", ") : `${files.length} files`;
   return commitBoard(dotDir, { message: `edit: ${summary}` });
 }
-function resolveAgentName(argv = process.argv) {
-  if (process.env.BRAINFILE_AGENT) return process.env.BRAINFILE_AGENT;
-  const flag = argv.indexOf("--agent");
-  if (flag >= 0 && argv[flag + 1] && !argv[flag + 1].startsWith("-")) return argv[flag + 1];
-  const inline = argv.find((a) => a.startsWith("--agent="));
-  return inline ? inline.slice("--agent=".length) : null;
-}
 function homeBoardDir() {
   return path2.join(os.homedir(), ".brainfile");
 }
@@ -11808,9 +11865,10 @@ function isGlobalBoardRequested(argv = process.argv) {
   if (process.env.BRAINFILE_GLOBAL === "1") return true;
   return argv.includes("-g") || argv.includes("--global");
 }
-function oneLine(message) {
+function oneLine(message, suffix = "") {
   const flat = message.replace(/\s+/g, " ").trim();
-  return flat.length > MAX_MESSAGE_LENGTH ? `${flat.slice(0, MAX_MESSAGE_LENGTH - 1)}\u2026` : flat;
+  const room = Math.max(1, MAX_MESSAGE_LENGTH - suffix.length);
+  return `${flat.length > room ? `${flat.slice(0, room - 1)}\u2026` : flat}${suffix}`;
 }
 function describeCommandForCommit(command) {
   const names = [];
@@ -11833,7 +11891,7 @@ var exitHookInstalled = false;
 function scheduleBoardCommit(brainfilePath, message, delayMs = 2e3) {
   const dotDir = path2.dirname(path2.resolve(brainfilePath));
   if (!isTrackedBoard(dotDir)) return;
-  const entry = pendingCommits.get(dotDir) ?? { messages: [], agent: resolveAgentName() };
+  const entry = pendingCommits.get(dotDir) ?? { messages: [] };
   entry.messages.push(message);
   pendingCommits.set(dotDir, entry);
   if (flushTimer) clearTimeout(flushTimer);
@@ -11852,7 +11910,7 @@ function flushBoardCommits() {
   for (const [dotDir, entry] of pendingCommits) {
     const [first, ...rest] = entry.messages;
     const message = rest.length === 0 ? first : `${first} (+${rest.length} more)`;
-    commitBoard(dotDir, { message, agent: entry.agent });
+    commitBoard(dotDir, { message });
   }
   pendingCommits.clear();
 }
@@ -12130,7 +12188,7 @@ import * as fs7 from "fs";
 import * as os3 from "os";
 import * as path7 from "path";
 var REMOTE_CONFIG_KEY = "brainfile.remote";
-var REMOTE_BRANCH_CONFIG_KEY = "brainfile.remoteBranch";
+var LEGACY_CHECKED_CONFIG_KEY = "brainfile.legacyBranchChecked";
 var AUTOSYNC_CONFIG_KEY = "brainfile.autosync";
 var URL_REMOTE_NAME = "board";
 var MERGE_DRIVER_NAME = "brainfile";
@@ -12152,14 +12210,23 @@ function configSet(dotDir, key, value) {
 function boardRemote(dotDir) {
   return configGet(dotDir, REMOTE_CONFIG_KEY);
 }
-function boardRemoteBranch(dotDir) {
-  const configured = configGet(dotDir, REMOTE_BRANCH_CONFIG_KEY);
+function boardRemoteName(dotDir) {
+  const configured = configGet(dotDir, BOARD_NAME_CONFIG_KEY) ?? configGet(dotDir, LEGACY_REMOTE_BRANCH_CONFIG_KEY);
   if (configured) return configured;
+  return defaultName(dotDir, DEFAULT_BOARD_NAME);
+}
+function defaultName(dotDir, inRepo) {
   if (path7.resolve(dotDir) === path7.resolve(homeBoardDir())) return "home";
   if (boardRepoKind(dotDir) === "standalone" && path7.basename(path7.resolve(dotDir)) === ".brainfile") {
-    return path7.basename(path7.dirname(path7.resolve(dotDir))) || boardBranch(dotDir);
+    return path7.basename(path7.dirname(path7.resolve(dotDir))) || inRepo;
   }
-  return boardBranch(dotDir);
+  return inRepo;
+}
+function boardRemoteRef(dotDir) {
+  return remoteBoardRef(boardRemoteName(dotDir));
+}
+function legacyRemoteBranch(dotDir) {
+  return configGet(dotDir, LEGACY_REMOTE_BRANCH_CONFIG_KEY) ?? defaultName(dotDir, boardBranch(dotDir));
 }
 function boardAutosync(dotDir) {
   const value = configGet(dotDir, AUTOSYNC_CONFIG_KEY);
@@ -12176,7 +12243,7 @@ function looksLikeRemoteUrl(target) {
   if (target.includes("/") && fs7.existsSync(target)) return true;
   return false;
 }
-function setBoardRemote(cwd, target, remoteBranch) {
+function setBoardRemote(cwd, target, boardName) {
   const trimmed = target.trim();
   if (!trimmed) throw new Error("remote is required");
   let remote;
@@ -12194,13 +12261,16 @@ function setBoardRemote(cwd, target, remoteBranch) {
       throw new Error(`'${remote}' is not a git remote here.${hint} Pass a URL to add one.`);
     }
   }
+  if (boardName !== void 0 && !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(boardName)) {
+    throw new Error(`'${boardName}' is not a usable board name: use letters, digits, '.', '_' or '-'.`);
+  }
   configSet(cwd, REMOTE_CONFIG_KEY, remote);
-  if (remoteBranch) configSet(cwd, REMOTE_BRANCH_CONFIG_KEY, remoteBranch);
+  if (boardName) configSet(cwd, BOARD_NAME_CONFIG_KEY, boardName);
   registerMergeDriver(cwd);
   return {
     remote,
     url: git(["remote", "get-url", remote], cwd).stdout || null,
-    remoteBranch: remoteBranch ?? boardRemoteBranch(cwd)
+    remoteRef: boardRemoteRef(cwd)
   };
 }
 function registerMergeDriver(cwd, command) {
@@ -12255,18 +12325,12 @@ function commitCount(dotDir, range) {
   const r = git(["rev-list", "--count", range], dotDir);
   return r.ok ? Number.parseInt(r.stdout, 10) || 0 : 0;
 }
-function identity(dotDir, agent) {
+function identityArgs2(dotDir) {
   const args = ["-c", "commit.gpgsign=false"];
   if (!git(["config", "--get", "user.email"], dotDir).ok) {
     args.push("-c", "user.name=brainfile", "-c", "user.email=brainfile@localhost");
   }
-  const env = {};
-  const name = agent?.replace(/[\r\n<>]/g, "").trim();
-  if (name) {
-    env.GIT_AUTHOR_NAME = name;
-    env.GIT_AUTHOR_EMAIL = `${name}@brainfile.local`;
-  }
-  return { args, env };
+  return args;
 }
 function resolveCompleteVersusEdit(dotDir) {
   const status = git(["status", "--porcelain", "-z"], dotDir);
@@ -12310,16 +12374,49 @@ ${entryLine}
   }
   return resolved;
 }
+function mergeIncoming(dotDir, incoming, result) {
+  if (git(["merge-base", "--is-ancestor", incoming, "HEAD"], dotDir).ok) return { ok: true, pulled: 0 };
+  const before = git(["rev-parse", "HEAD"], dotDir).stdout;
+  const id = identityArgs2(dotDir);
+  const merge = git([...id, "merge", "--quiet", "--no-edit", incoming], dotDir);
+  if (!merge.ok) {
+    resolveCompleteVersusEdit(dotDir);
+    const remaining = unmergedFiles(dotDir);
+    if (remaining.length > 0) {
+      return {
+        ok: false,
+        result: {
+          ...result,
+          ok: false,
+          failure: "conflict",
+          conflicts: remaining,
+          warning: `merge left conflicts in ${remaining.join(", ")} \u2014 resolve them in ${dotDir}, then run sync again`
+        }
+      };
+    }
+    const commit = git([...id, "commit", "--quiet", "--no-edit", "--no-verify"], dotDir);
+    if (!commit.ok) {
+      return { ok: false, result: { ...result, ok: false, failure: "error", warning: `merge commit failed: ${firstLine(commit.stderr)}` } };
+    }
+  }
+  return { ok: true, pulled: commitCount(dotDir, `${before}..${incoming}`) };
+}
+function legacyChecked(dotDir, remote) {
+  return configGet(dotDir, LEGACY_CHECKED_CONFIG_KEY) === remote;
+}
 function syncBoard(dotDir, options = {}) {
-  const pull = options.pull ?? true;
   const push = options.push ?? true;
   const result = { ok: true, pulled: 0, pushed: 0, conflicts: [] };
   if (!isTrackedBoard(dotDir)) return { ...result, skipped: "not-tracked" };
   const remote = boardRemote(dotDir);
   if (!remote) return { ...result, skipped: "no-remote" };
-  const remoteBranch = boardRemoteBranch(dotDir);
+  const name = boardRemoteName(dotDir);
+  const remoteRef = remoteBoardRef(name);
+  const tracking = boardTrackingRef(remote, name);
   result.remote = remote;
-  result.remoteBranch = remoteBranch;
+  result.remoteRef = remoteRef;
+  const checkLegacy = !legacyChecked(dotDir, remote);
+  const pull = (options.pull ?? true) || checkLegacy;
   const stuck = unmergedFiles(dotDir);
   if (stuck.length > 0) {
     return finish(dotDir, { ...result, ok: false, failure: "conflict", conflicts: stuck, warning: `unresolved conflicts: ${stuck.join(", ")}` });
@@ -12328,41 +12425,38 @@ function syncBoard(dotDir, options = {}) {
   if (ensureBoardAttributes(dotDir)) commitBoard(dotDir, { message: "chore: merge attributes" });
   registerMergeDriver(dotDir);
   let fetched = false;
+  let legacy = null;
+  let legacyAbsent = false;
   if (pull) {
-    const fetch2 = git(["fetch", "--quiet", remote, remoteBranch], dotDir);
+    const fetch2 = git(["fetch", "--quiet", "--no-tags", remote, `+${remoteRef}:${tracking}`], dotDir);
     if (fetch2.ok) {
       fetched = true;
     } else if (!isMissingRemoteRef(fetch2.stderr)) {
       return finish(dotDir, { ...result, ok: false, failure: "offline", warning: `fetch from ${remote} failed: ${firstLine(fetch2.stderr)}` });
+    } else {
+      git(["update-ref", "-d", tracking], dotDir);
     }
-    if (fetched && !git(["merge-base", "--is-ancestor", "FETCH_HEAD", "HEAD"], dotDir).ok) {
-      const before = git(["rev-parse", "HEAD"], dotDir).stdout;
-      const id = identity(dotDir, options.agent);
-      const merge = git([...id.args, "merge", "--quiet", "--no-edit", "FETCH_HEAD"], dotDir, id.env);
-      if (!merge.ok) {
-        resolveCompleteVersusEdit(dotDir);
-        const remaining = unmergedFiles(dotDir);
-        if (remaining.length > 0) {
-          return finish(dotDir, {
-            ...result,
-            ok: false,
-            failure: "conflict",
-            conflicts: remaining,
-            warning: `merge left conflicts in ${remaining.join(", ")} \u2014 resolve them in ${dotDir}, then run sync again`
-          });
-        }
-        const commit = git([...id.args, "commit", "--quiet", "--no-edit", "--no-verify"], dotDir, id.env);
-        if (!commit.ok) {
-          return finish(dotDir, { ...result, ok: false, failure: "error", warning: `merge commit failed: ${firstLine(commit.stderr)}` });
-        }
+    if (checkLegacy) {
+      const branch = legacyRemoteBranch(dotDir);
+      const old = git(["fetch", "--quiet", "--no-tags", remote, `refs/heads/${branch}`], dotDir);
+      if (old.ok) {
+        legacy = { branch, sha: git(["rev-parse", "FETCH_HEAD"], dotDir).stdout };
+      } else if (isMissingRemoteRef(old.stderr)) {
+        legacyAbsent = true;
       }
-      result.pulled = commitCount(dotDir, `${before}..FETCH_HEAD`);
+    }
+    for (const incoming of [fetched ? tracking : null, legacy?.sha ?? null]) {
+      if (!incoming) continue;
+      const merged = mergeIncoming(dotDir, incoming, result);
+      if (!merged.ok) return finish(dotDir, merged.result);
+      result.pulled += merged.pulled;
     }
   }
   if (push) {
-    const ahead = fetched ? commitCount(dotDir, "FETCH_HEAD..HEAD") : pendingChanges(dotDir);
+    const known = git(["rev-parse", "--verify", "--quiet", tracking], dotDir).ok;
+    const ahead = commitCount(dotDir, known ? `${tracking}..HEAD` : "HEAD");
     if (ahead > 0) {
-      const pushed = git(["push", "--quiet", remote, `HEAD:refs/heads/${remoteBranch}`], dotDir);
+      const pushed = git(["push", "--quiet", remote, `HEAD:${remoteRef}`], dotDir);
       if (!pushed.ok) {
         const rejected = /rejected|non-fast-forward|fetch first/i.test(pushed.stderr);
         return finish(dotDir, {
@@ -12372,8 +12466,24 @@ function syncBoard(dotDir, options = {}) {
           warning: rejected ? `push to ${remote} rejected (the remote moved) \u2014 run sync again` : `push to ${remote} failed: ${firstLine(pushed.stderr)}`
         });
       }
+      git(["update-ref", tracking, "HEAD"], dotDir);
       result.pushed = ahead;
     }
+    if (legacy && git(["merge-base", "--is-ancestor", legacy.sha, tracking], dotDir).ok) {
+      const removed = git(
+        ["push", "--quiet", `--force-with-lease=refs/heads/${legacy.branch}:${legacy.sha}`, remote, `:refs/heads/${legacy.branch}`],
+        dotDir
+      );
+      if (removed.ok) {
+        git(["update-ref", "-d", `refs/remotes/${remote}/${legacy.branch}`], dotDir);
+        result.movedFromBranch = legacy.branch;
+        configSet(dotDir, LEGACY_CHECKED_CONFIG_KEY, remote);
+      }
+    }
+  }
+  if (legacyAbsent) {
+    git(["update-ref", "-d", `refs/remotes/${remote}/${legacyRemoteBranch(dotDir)}`], dotDir);
+    configSet(dotDir, LEGACY_CHECKED_CONFIG_KEY, remote);
   }
   return finish(dotDir, result);
 }
@@ -12381,7 +12491,7 @@ function finish(dotDir, result) {
   writeSyncState(dotDir, {
     at: (/* @__PURE__ */ new Date()).toISOString(),
     remote: result.remote ?? "",
-    remoteBranch: result.remoteBranch ?? "",
+    remoteRef: result.remoteRef ?? "",
     ok: result.ok,
     ...result.warning ? { warning: result.warning } : {}
   });
@@ -12406,10 +12516,15 @@ function syncStatusLabel(dotDir, now = Date.now()) {
 function pendingChanges(dotDir) {
   const remote = boardRemote(dotDir);
   if (!remote) return 0;
-  const tracking = `refs/remotes/${remote}/${boardRemoteBranch(dotDir)}`;
+  const tracking = boardTrackingRef(remote, boardRemoteName(dotDir));
   const known = git(["rev-parse", "--verify", "--quiet", tracking], dotDir).ok;
   return commitCount(dotDir, known ? `${tracking}..HEAD` : "HEAD");
 }
+function boardWebUrl(remoteUrl, remoteRef) {
+  if (!remoteUrl) return null;
+  const m = /^(?:https:\/\/(?:[^@/]+@)?github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(remoteUrl);
+  return m ? `https://github.com/${m[1]}/${m[2]}/commits/${remoteRef}` : null;
+}
 var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 function syncMessage(result) {
   if (result.skipped === "not-tracked") {
@@ -13442,7 +13557,6 @@ export {
   boardIsDirty,
   commitBoard,
   commitHandEdits,
-  resolveAgentName,
   homeBoardDir,
   isGlobalBoardRequested,
   describeCommandForCommit,
@@ -13456,7 +13570,7 @@ export {
   import_core5 as import_core,
   mergeDriverCommand,
   boardRemote,
-  boardRemoteBranch,
+  boardRemoteRef,
   boardAutosync,
   setBoardAutosync,
   setBoardRemote,
@@ -13467,6 +13581,7 @@ export {
   secondsSinceSync,
   syncStatusLabel,
   pendingChanges,
+  boardWebUrl,
   syncMessage,
   effectiveAutosync,
   clearPushLock,