@lesscap/baton-cli 0.7.2 → 0.7.3

package/README.md

@@ -24,8 +24,12 @@ in (the worker spawns it to run each turn). Override the path with
 cd /path/to/your-repo
 
 # 2. register this machine as a worker for a project
-baton worker register --url https://baton.fmap.dev/api --project <projectId> --name my-machine
-#    → writes ./.baton.json { server, project, worker token }
+baton worker register \
+  --url https://baton.fmap.dev/api \
+  --project <projectId> \
+  --name my-machine \
+  --baseBranch main
+#    → generates ./.baton.json with server, project, base branch, and worker token
 
 # 3. run the worker daemon (foreground; Ctrl-C to stop)
 baton worker run
@@ -35,12 +39,18 @@ The worker authenticates with its own bearer token — **no login needed**. Once
 running, it shows up (alive) under the project's workers in the web back-office;
 new sessions / inbound DingTalk messages are then executed by it.
 
-`.baton.json` is per-directory local state (gitignored by convention). You can
-also create it by hand before registering:
-
-```json
-{ "server": "https://baton.fmap.dev/api", "project": 2 }
-```
+`.baton.json` is per-directory local state (gitignored by convention) and is
+generated by `baton worker register`; `baton init` is optional. `--baseBranch`
+wins over `BATON_BASE_BRANCH`, then an existing saved value. If none is set,
+registration records the repo's current branch, falling back to `main`.
+
+Before creating each new session worktree, the worker fetches that branch and
+forks from the updated `origin/<branch>` ref without moving the source checkout.
+Repositories without an `origin` use their local branch. Environments that keep
+Git credentials in a separate broker can set `BATON_GIT_SYNC_BIN` to a trusted
+executable; Baton invokes it as `<executable> <repo> <branch>`, then verifies the
+updated remote-tracking ref before creating the worktree. The helper must print
+the synced commit hash to stdout.
 
 ## Other commands
 

package/dist/baton.mjs

@@ -4684,11 +4684,11 @@ var channelClient = (baseUrl) => {
       if (!res.ok) throw new Error(`GET channel \u2192 ${res.status}: ${await res.text()}`);
       return await res.json();
     },
-    update: async (channelId, patch2) => {
+    update: async (channelId, patch) => {
       const res = await fetch(u(`/channels/${channelId}`), {
         method: "PATCH",
         headers: JSON_CT,
-        body: JSON.stringify(patch2)
+        body: JSON.stringify(patch)
       });
       if (!res.ok) throw new Error(`PATCH channel \u2192 ${res.status}: ${await res.text()}`);
       return await res.json();
@@ -4797,10 +4797,6 @@ var saveProjectConfig = (path, config) => {
   writeFileSync(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 };
-var patch = (path, fn) => {
-  saveProjectConfig(path, fn(loadProjectConfig(path)));
-};
-var setWorker = (path, w) => patch(path, (cfg) => ({ ...cfg, worker: w }));
 var requireBase = (cfg) => {
   if (!cfg.server || !cfg.project || !cfg.worker)
     throw new Error("project-config missing server/project/worker \u2014 run `baton worker register`");
@@ -4811,6 +4807,7 @@ var viewWorker = (cfg) => {
   return {
     server,
     projectId: project2,
+    baseBranch: cfg.baseBranch,
     workerId: worker2.id,
     agentKind: worker2.agentKind ?? "claude-code",
     name: worker2.name,
@@ -4821,6 +4818,7 @@ var viewWorker = (cfg) => {
 var worktreeConfig = (cfg) => ({
   server: cfg.server,
   project: cfg.projectId,
+  baseBranch: cfg.baseBranch,
   worker: {
     id: cfg.workerId,
     name: cfg.name,
@@ -4944,7 +4942,7 @@ var projectClient = (baseUrl) => {
     create: (input) => request(u("/projects"), { method: "POST", body: input }),
     listByWorkspace: (workspaceId) => request(u(`/workspaces/${workspaceId}/projects`), { method: "GET" }),
     get: (id) => request(u(`/projects/${id}`), { method: "GET" }),
-    update: (id, patch2) => request(u(`/projects/${id}`), { method: "PATCH", body: patch2 }),
+    update: (id, patch) => request(u(`/projects/${id}`), { method: "PATCH", body: patch }),
     remove: (id) => request(u(`/projects/${id}`), { method: "DELETE" })
   };
 };
@@ -4967,7 +4965,7 @@ var requirementClient = (baseUrl) => {
     listByProject: (projectId) => request(u(`/projects/${projectId}/requirements`), { method: "GET" }),
     get: (id) => request(u(`/requirements/${id}`), { method: "GET" }),
     getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "requirement"),
-    update: (id, patch2) => request(u(`/requirements/${id}`), { method: "PATCH", body: patch2 }),
+    update: (id, patch) => request(u(`/requirements/${id}`), { method: "PATCH", body: patch }),
     setStatus: (id, status) => request(u(`/requirements/${id}`), { method: "PATCH", body: { status } }),
     remove: (id) => request(u(`/requirements/${id}`), { method: "DELETE" })
   };
@@ -5061,7 +5059,7 @@ var taskClient = (baseUrl) => {
     listByRequirement: (requirementId) => request(u(`/requirements/${requirementId}/tasks`), { method: "GET" }),
     get: (id) => request(u(`/tasks/${id}`), { method: "GET" }),
     getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "task"),
-    update: (id, patch2) => request(u(`/tasks/${id}`), { method: "PATCH", body: patch2 }),
+    update: (id, patch) => request(u(`/tasks/${id}`), { method: "PATCH", body: patch }),
     setStatus: (id, status) => request(u(`/tasks/${id}`), { method: "PATCH", body: { status } }),
     remove: (id) => request(u(`/tasks/${id}`), { method: "DELETE" }),
     listComments: (id) => request(u(`/tasks/${id}/comments`), { method: "GET" }),
@@ -5097,7 +5095,7 @@ var workspaceClient = (baseUrl) => {
     create: (input) => request(u("/workspaces"), { method: "POST", body: input }),
     list: () => request(u("/workspaces"), { method: "GET" }),
     get: (id) => request(u(`/workspaces/${id}`), { method: "GET" }),
-    update: (id, patch2) => request(u(`/workspaces/${id}`), { method: "PATCH", body: patch2 }),
+    update: (id, patch) => request(u(`/workspaces/${id}`), { method: "PATCH", body: patch }),
     remove: (id) => request(u(`/workspaces/${id}`), { method: "DELETE" })
   };
 };
@@ -5855,11 +5853,11 @@ var loopSetCommand = defineCommand({
   },
   run: async ({ args }) => {
     const c = clientFor(args);
-    const patch2 = {};
-    if (args.message !== void 0) patch2.message = args.message;
-    if (args.every !== void 0 && args.every !== "") patch2.intervalSec = parseDuration(args.every);
-    if (args.name !== void 0) patch2.name = args.name;
-    const loop2 = await c.loops.update(Number(args.loop), patch2);
+    const patch = {};
+    if (args.message !== void 0) patch.message = args.message;
+    if (args.every !== void 0 && args.every !== "") patch.intervalSec = parseDuration(args.every);
+    if (args.name !== void 0) patch.name = args.name;
+    const loop2 = await c.loops.update(Number(args.loop), patch);
     console.log(renderOne(loop2, fmtLoop, Boolean(args.json)));
   }
 });
@@ -5882,7 +5880,7 @@ var loop = defineCommand({
 var createProject = (c, input, json) => c.projects.create(input).then((p) => renderOne(p, fmtProject, json));
 var listProjects = (c, workspaceId, json) => c.projects.listByWorkspace(workspaceId).then((ps) => renderList(ps, fmtProject, json));
 var getProject = (c, id, json) => c.projects.get(id).then((p) => renderOne(p, fmtProject, json));
-var updateProject = (c, id, patch2, json) => c.projects.update(id, patch2).then((p) => renderOne(p, fmtProject, json));
+var updateProject = (c, id, patch, json) => c.projects.update(id, patch).then((p) => renderOne(p, fmtProject, json));
 var removeProject = (c, id, json) => c.projects.remove(id).then(() => removed("project", id, json));
 var project = defineCommand({
   meta: { name: "project", description: "manage projects" },
@@ -5932,13 +5930,13 @@ var project = defineCommand({
         ...common
       },
       run: async ({ args }) => {
-        const patch2 = {
+        const patch = {
           ...args.name !== void 0 ? { name: args.name } : {},
           ...args.desc !== void 0 ? { description: args.desc } : {}
         };
-        if (Object.keys(patch2).length === 0) throw new Error("pass --name and/or --desc");
+        if (Object.keys(patch).length === 0) throw new Error("pass --name and/or --desc");
         console.log(
-          await updateProject(clientFor(args), Number(args.id), patch2, Boolean(args.json))
+          await updateProject(clientFor(args), Number(args.id), patch, Boolean(args.json))
         );
       }
     }),
@@ -6131,7 +6129,7 @@ var relay = defineCommand({
 
 // src/commands/requirement.ts
 var createRequirement = (c, input, json) => c.requirements.create(input).then((r) => renderOne(r, fmtRequirement, json));
-var updateRequirement = (c, id, patch2, json) => c.requirements.update(id, patch2).then((r) => renderOne(r, fmtRequirement, json));
+var updateRequirement = (c, id, patch, json) => c.requirements.update(id, patch).then((r) => renderOne(r, fmtRequirement, json));
 var listRequirements = (c, projectId, json) => c.requirements.listByProject(projectId).then((rs) => renderList(rs, fmtRequirement, json));
 var getRequirement = (c, id, json) => c.requirements.get(id).then((r) => renderOne(r, fmtRequirement, json));
 var setRequirementStatus = (c, id, status, json) => c.requirements.setStatus(id, status).then((r) => renderOne(r, fmtRequirement, json));
@@ -6174,14 +6172,14 @@ var requirement = defineCommand({
         ...common
       },
       run: async ({ args }) => {
-        const patch2 = {
+        const patch = {
           ...args.title !== void 0 ? { title: args.title } : {},
           ...args.body !== void 0 ? { body: args.body } : {}
         };
-        if (Object.keys(patch2).length === 0) throw new Error("pass --title and/or --body");
+        if (Object.keys(patch).length === 0) throw new Error("pass --title and/or --body");
         const c = clientFor(args);
         const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateRequirement(c, id, patch2, Boolean(args.json)));
+        console.log(await updateRequirement(c, id, patch, Boolean(args.json)));
       }
     }),
     ls: defineCommand({
@@ -7423,7 +7421,7 @@ var session = defineCommand({
 
 // src/commands/task.ts
 var createTask = (c, input, json) => c.tasks.create(input).then((t) => renderOne(t, fmtTask, json));
-var updateTask = (c, id, patch2, json) => c.tasks.update(id, patch2).then((t) => renderOne(t, fmtTask, json));
+var updateTask = (c, id, patch, json) => c.tasks.update(id, patch).then((t) => renderOne(t, fmtTask, json));
 var listTasks = (c, requirementId, json) => c.tasks.listByRequirement(requirementId).then((ts) => renderList(ts, fmtTask, json));
 var getTask = (c, id, json) => c.tasks.get(id).then((t) => renderOne(t, fmtTask, json));
 var setTaskStatus = (c, id, status, json) => c.tasks.setStatus(id, status).then((t) => renderOne(t, fmtTask, json));
@@ -7477,14 +7475,14 @@ var task = defineCommand({
         ...common
       },
       run: async ({ args }) => {
-        const patch2 = {
+        const patch = {
           ...args.title !== void 0 ? { title: args.title } : {},
           ...args.body !== void 0 ? { body: args.body } : {}
         };
-        if (Object.keys(patch2).length === 0) throw new Error("pass --title and/or --body");
+        if (Object.keys(patch).length === 0) throw new Error("pass --title and/or --body");
         const c = clientFor(args);
         const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateTask(c, id, patch2, Boolean(args.json)));
+        console.log(await updateTask(c, id, patch, Boolean(args.json)));
       }
     }),
     ls: defineCommand({
@@ -7583,6 +7581,155 @@ var task = defineCommand({
 // src/commands/worker/index.ts
 import { hostname as osHostname } from "node:os";
 
+// src/session/worktree.ts
+import { execFile, execFileSync, spawnSync as spawnSync2 } from "node:child_process";
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, resolve } from "node:path";
+import { promisify } from "node:util";
+var git = (repo, args) => spawnSync2("git", ["-C", repo, ...args], {
+  stdio: "pipe",
+  encoding: "utf8"
+});
+var commandError = (result) => {
+  const raw = result.stderr || result.stdout || result.error?.message || `exit ${result.status}`;
+  return raw.trim().replace(/(https?:\/\/)[^/@\s]+@/g, "$1***@");
+};
+var execFileAsync = promisify(execFile);
+var DEFAULT_SYNC_TIMEOUT_MS = 6e4;
+var asyncCommandError = (error, timeoutMs) => {
+  const failure = error;
+  if (failure.killed || failure.code === "ETIMEDOUT") return `timed out after ${timeoutMs}ms`;
+  const raw = failure.stderr || failure.stdout || failure.message || String(error);
+  return raw.trim().replace(/(https?:\/\/)[^/@\s]+@/g, "$1***@");
+};
+var validateBaseBranch = (branch) => {
+  const normalized = branch.trim();
+  const valid = spawnSync2("git", ["check-ref-format", "--branch", normalized], {
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (valid.status !== 0)
+    throw new Error(`invalid base branch "${normalized}": ${commandError(valid)}`);
+  return normalized;
+};
+var createWorktree = (input) => {
+  if (existsSync4(input.worktreePath))
+    throw new Error(`worktree path already exists: ${input.worktreePath}`);
+  const head = spawnSync2("git", ["-C", input.repo, "rev-parse", "--verify", "-q", "HEAD"], {
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (head.status !== 0)
+    throw new Error(
+      `repo has no commits (unborn HEAD) \u2014 create an initial commit before starting sessions`
+    );
+  mkdirSync3(dirname(input.worktreePath), { recursive: true });
+  const branch = `baton/${input.sessionCode}`;
+  const r = spawnSync2(
+    "git",
+    ["-C", input.repo, "worktree", "add", "-b", branch, input.worktreePath, input.base],
+    { stdio: "pipe", encoding: "utf8" }
+  );
+  if (r.status !== 0) {
+    throw new Error(`git worktree add failed: ${r.stderr || r.stdout || `exit ${r.status}`}`);
+  }
+};
+var repoHeadBranch = (repo) => {
+  const r = git(repo, ["symbolic-ref", "--short", "HEAD"]);
+  const branch = r.status === 0 ? r.stdout.trim() : "";
+  return branch || "main";
+};
+var syncBaseBranch = async (repo, branch, options = {}) => {
+  const checkedBranch = validateBaseBranch(branch);
+  const env = options.env ?? process.env;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS;
+  const origin = git(repo, ["remote", "get-url", "origin"]);
+  if (origin.status !== 0) {
+    const localRef = `refs/heads/${checkedBranch}`;
+    const verified2 = git(repo, ["rev-parse", "--verify", "-q", localRef]);
+    if (verified2.status !== 0) throw new Error(`local base branch does not exist: ${checkedBranch}`);
+    return localRef;
+  }
+  const helper = env.BATON_GIT_SYNC_BIN?.trim();
+  const command = helper ?? "git";
+  const args = helper ? [repo, checkedBranch] : [
+    "-C",
+    repo,
+    "fetch",
+    "--no-tags",
+    "origin",
+    `+refs/heads/${checkedBranch}:refs/remotes/origin/${checkedBranch}`
+  ];
+  let synced;
+  try {
+    synced = await execFileAsync(command, args, {
+      encoding: "utf8",
+      env: { ...env, GIT_TERMINAL_PROMPT: "0" },
+      timeout: timeoutMs
+    });
+  } catch (error) {
+    const via = helper ? ` via ${helper}` : "";
+    throw new Error(
+      `git sync failed for origin/${checkedBranch}${via}: ${asyncCommandError(error, timeoutMs)}`
+    );
+  }
+  const remoteRef = `refs/remotes/origin/${checkedBranch}`;
+  const verified = git(repo, ["rev-parse", "--verify", "-q", remoteRef]);
+  if (verified.status !== 0) throw new Error(`git sync succeeded but ${remoteRef} does not exist`);
+  if (helper) {
+    const reportedCommit = synced.stdout.trim();
+    const actualCommit = verified.stdout.trim();
+    if (!/^[0-9a-f]{40,64}$/i.test(reportedCommit))
+      throw new Error("git sync helper did not report the synced commit on stdout");
+    if (reportedCommit !== actualCommit)
+      throw new Error(`git sync helper reported a commit that does not match ${remoteRef}`);
+  }
+  return remoteRef;
+};
+var ensureExcluded = (repo, pattern) => {
+  try {
+    const r = spawnSync2("git", ["-C", repo, "rev-parse", "--git-path", "info/exclude"], {
+      stdio: "pipe",
+      encoding: "utf8"
+    });
+    if (r.status !== 0) return;
+    const rel = r.stdout.trim();
+    const path = isAbsolute2(rel) ? rel : resolve(repo, rel);
+    const current = existsSync4(path) ? readFileSync5(path, "utf8") : "";
+    if (current.split("\n").includes(pattern)) return;
+    mkdirSync3(dirname(path), { recursive: true });
+    const sep = current === "" || current.endsWith("\n") ? "" : "\n";
+    appendFileSync(path, `${sep}${pattern}
+`, "utf8");
+  } catch {
+  }
+};
+var removeWorktree = (repo, worktreePath) => {
+  if (!existsSync4(worktreePath)) return;
+  try {
+    execFileSync("git", ["-C", repo, "worktree", "remove", "--force", worktreePath], {
+      stdio: "pipe"
+    });
+  } catch {
+  }
+};
+var restoreWorktree = async (repo, worktreePath, sessionCode, baseBranch = repoHeadBranch(repo)) => {
+  spawnSync2("git", ["-C", repo, "worktree", "prune"], { stdio: "pipe" });
+  mkdirSync3(dirname(worktreePath), { recursive: true });
+  const branch = `baton/${sessionCode}`;
+  const reuse = spawnSync2("git", ["-C", repo, "worktree", "add", worktreePath, branch], {
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (reuse.status === 0) return;
+  createWorktree({
+    repo,
+    worktreePath,
+    sessionCode,
+    base: await syncBaseBranch(repo, baseBranch)
+  });
+};
+
 // src/worker/watchdog.ts
 var stale = (okAt, now, thresholdMs) => now - okAt > thresholdMs;
 var streamWedged = (isOpen, okAt, now, thresholdMs) => !isOpen && stale(okAt, now, thresholdMs);
@@ -7726,79 +7873,6 @@ var generateTitle = async (input) => {
   return !title || isDeclined(title) ? { kind: "declined" } : { kind: "titled", title };
 };
 
-// src/session/worktree.ts
-import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
-import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
-import { dirname, isAbsolute as isAbsolute2, resolve } from "node:path";
-var createWorktree = (input) => {
-  if (existsSync4(input.worktreePath))
-    throw new Error(`worktree path already exists: ${input.worktreePath}`);
-  const head = spawnSync2("git", ["-C", input.repo, "rev-parse", "--verify", "-q", "HEAD"], {
-    stdio: "pipe",
-    encoding: "utf8"
-  });
-  if (head.status !== 0)
-    throw new Error(
-      `repo has no commits (unborn HEAD) \u2014 create an initial commit before starting sessions`
-    );
-  mkdirSync3(dirname(input.worktreePath), { recursive: true });
-  const branch = `baton/${input.sessionCode}`;
-  const r = spawnSync2(
-    "git",
-    ["-C", input.repo, "worktree", "add", "-b", branch, input.worktreePath, input.base],
-    { stdio: "pipe", encoding: "utf8" }
-  );
-  if (r.status !== 0) {
-    throw new Error(`git worktree add failed: ${r.stderr || r.stdout || `exit ${r.status}`}`);
-  }
-};
-var repoHeadBranch = (repo) => {
-  const r = spawnSync2("git", ["-C", repo, "symbolic-ref", "--short", "HEAD"], {
-    stdio: "pipe",
-    encoding: "utf8"
-  });
-  const branch = r.status === 0 ? r.stdout.trim() : "";
-  return branch || "main";
-};
-var ensureExcluded = (repo, pattern) => {
-  try {
-    const r = spawnSync2("git", ["-C", repo, "rev-parse", "--git-path", "info/exclude"], {
-      stdio: "pipe",
-      encoding: "utf8"
-    });
-    if (r.status !== 0) return;
-    const rel = r.stdout.trim();
-    const path = isAbsolute2(rel) ? rel : resolve(repo, rel);
-    const current = existsSync4(path) ? readFileSync5(path, "utf8") : "";
-    if (current.split("\n").includes(pattern)) return;
-    mkdirSync3(dirname(path), { recursive: true });
-    const sep = current === "" || current.endsWith("\n") ? "" : "\n";
-    appendFileSync(path, `${sep}${pattern}
-`, "utf8");
-  } catch {
-  }
-};
-var removeWorktree = (repo, worktreePath) => {
-  if (!existsSync4(worktreePath)) return;
-  try {
-    execFileSync("git", ["-C", repo, "worktree", "remove", "--force", worktreePath], {
-      stdio: "pipe"
-    });
-  } catch {
-  }
-};
-var restoreWorktree = (repo, worktreePath, sessionCode) => {
-  spawnSync2("git", ["-C", repo, "worktree", "prune"], { stdio: "pipe" });
-  mkdirSync3(dirname(worktreePath), { recursive: true });
-  const branch = `baton/${sessionCode}`;
-  const reuse = spawnSync2("git", ["-C", repo, "worktree", "add", worktreePath, branch], {
-    stdio: "pipe",
-    encoding: "utf8"
-  });
-  if (reuse.status === 0) return;
-  createWorktree({ repo, worktreePath, sessionCode, base: repoHeadBranch(repo) });
-};
-
 // src/worker/proc.ts
 var killProcessGroup = (proc) => {
   if (proc.pid === void 0) return;
@@ -7817,7 +7891,26 @@ var binPath = () => {
 var createSessionSupervisor = (deps) => {
   const { client, cfg, repo, log, hasTerminal, closeTerminal } = deps;
   const worktreeDir = defaultWorktreeDir();
+  const baseBranch = cfg.baseBranch ?? repoHeadBranch(repo);
+  const syncBase = deps.syncBase ?? syncBaseBranch;
+  let syncInFlight = null;
+  const syncedBase = () => {
+    if (syncInFlight) return syncInFlight;
+    const pending = syncBase(repo, baseBranch);
+    syncInFlight = pending;
+    const clear = () => {
+      if (syncInFlight === pending) syncInFlight = null;
+    };
+    void pending.then(clear, clear);
+    return pending;
+  };
   const children = /* @__PURE__ */ new Map();
+  const starts = /* @__PURE__ */ new Map();
+  const startEpochs = /* @__PURE__ */ new Map();
+  const currentStartEpoch = (sessionId) => startEpochs.get(sessionId) ?? 0;
+  const cancelStart = (sessionId) => {
+    startEpochs.set(sessionId, currentStartEpoch(sessionId) + 1);
+  };
   const spawnChild = (sessionId, worktreePath) => {
     if (children.has(sessionId)) return;
     const child = spawn(process.execPath, [binPath(), "session", "run", String(sessionId)], {
@@ -7834,26 +7927,33 @@ var createSessionSupervisor = (deps) => {
       });
     });
   };
-  const start = async (sessionId, name) => {
+  const startOne = async (sessionId, name, epoch) => {
+    const wasCanceled = () => currentStartEpoch(sessionId) !== epoch;
+    if (wasCanceled()) return;
     if (hasTerminal(sessionId))
       return log(`session #${sessionId} has an open terminal \u2014 skipping headless start`);
     if (children.has(sessionId)) return log(`session #${sessionId} already running`);
     const session2 = await client.sessions.get(sessionId);
+    if (wasCanceled()) return log(`session #${sessionId} start canceled before materializing`);
     let worktreePath = session2.worktreePath;
     if (!session2.agentSessionId || !worktreePath) {
       const sessionCode = randomUUID();
       const agentSessionId = session2.agentKind === "codex" ? `pending:${sessionCode}` : sessionCode;
       worktreePath = join7(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
+      const base = await syncedBase();
+      if (wasCanceled()) return log(`session #${sessionId} start canceled during git sync`);
       createWorktree({
         repo,
         worktreePath,
         sessionCode: sessionCode.slice(0, 8),
-        base: repoHeadBranch(repo)
+        base
       });
       await client.sessions.materialize(sessionId, { agentSessionId, worktreePath }, cfg.apiToken);
+      if (wasCanceled()) return log(`session #${sessionId} start canceled after materializing`);
       log(`materialized session #${sessionId} \u2192 ${worktreePath}`);
     } else if (!existsSync5(worktreePath)) {
-      restoreWorktree(repo, worktreePath, session2.agentSessionId.slice(0, 8));
+      await restoreWorktree(repo, worktreePath, session2.agentSessionId.slice(0, 8), baseBranch);
+      if (wasCanceled()) return log(`session #${sessionId} start canceled during worktree restore`);
       log(`recreated session #${sessionId} worktree (was missing) \u2192 ${worktreePath}`);
     }
     ensureExcluded(repo, PROJECT_CONFIG_NAME);
@@ -7862,7 +7962,23 @@ var createSessionSupervisor = (deps) => {
       return log(`session #${sessionId} terminal opened mid-start \u2014 skipping headless start`);
     spawnChild(sessionId, worktreePath);
   };
+  const start = (sessionId, name) => {
+    const epoch = currentStartEpoch(sessionId);
+    const existing = starts.get(sessionId);
+    if (existing?.epoch === epoch) return existing.promise;
+    const pending = existing ? existing.promise.then(
+      () => startOne(sessionId, name, epoch),
+      () => startOne(sessionId, name, epoch)
+    ) : startOne(sessionId, name, epoch);
+    starts.set(sessionId, { epoch, promise: pending });
+    const clear = () => {
+      if (starts.get(sessionId)?.promise === pending) starts.delete(sessionId);
+    };
+    void pending.then(clear, clear);
+    return pending;
+  };
   const stop = (sessionId) => {
+    cancelStart(sessionId);
     closeTerminal(sessionId);
     const entry = children.get(sessionId);
     if (!entry) return;
@@ -7871,6 +7987,7 @@ var createSessionSupervisor = (deps) => {
     log(`stopped session #${sessionId}`);
   };
   const remove = (sessionId, worktreePath) => {
+    cancelStart(sessionId);
     closeTerminal(sessionId);
     const entry = children.get(sessionId);
     if (entry) {
@@ -8146,6 +8263,11 @@ var parseAgentKind = (value) => {
   if (raw === "claude-code" || raw === "codex") return raw;
   throw new Error(`invalid agent kind "${raw}" (expected claude-code or codex)`);
 };
+var nonEmptyString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var resolveBaseBranch = (input) => {
+  const branch = nonEmptyString(input.flag) ?? nonEmptyString(input.env) ?? nonEmptyString(input.saved) ?? repoHeadBranch(input.repo ?? process.cwd());
+  return validateBaseBranch(branch);
+};
 var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
   const out = await client.workers.register({
     projectId: input.projectId,
@@ -8154,17 +8276,19 @@ var registerWorker = async (client, input, cfgPath = projectConfigPath()) => {
     name: input.name,
     hostname: input.hostname
   });
-  try {
-    loadProjectConfig(cfgPath);
-  } catch {
-    saveProjectConfig(cfgPath, { server: input.server, project: input.projectId });
-  }
-  setWorker(cfgPath, {
-    id: out.worker.id,
-    name: out.worker.name,
-    agentKind: out.worker.agentKind,
-    machineId: out.worker.machineId,
-    apiToken: out.apiToken
+  const existing = loadProjectConfigOrNull(cfgPath) ?? {};
+  saveProjectConfig(cfgPath, {
+    ...existing,
+    server: input.server,
+    project: input.projectId,
+    baseBranch: input.baseBranch,
+    worker: {
+      id: out.worker.id,
+      name: out.worker.name,
+      agentKind: out.worker.agentKind,
+      machineId: out.worker.machineId,
+      apiToken: out.apiToken
+    }
   });
   return { out, configPath: cfgPath };
 };
@@ -8187,6 +8311,10 @@ var worker = defineCommand({
           type: "string",
           description: "agent engine for new sessions: claude-code or codex"
         },
+        baseBranch: {
+          type: "string",
+          description: "branch new session worktrees start from (default: current branch, then main)"
+        },
         ...common
       },
       run: async ({ args }) => {
@@ -8197,9 +8325,15 @@ var worker = defineCommand({
           );
         if (!args.json) console.log(`registering against ${server}`);
         const cfgPath = configPathFromArgs(args);
-        const fileToken = loadProjectConfigOrNull(cfgPath)?.worker?.apiToken;
+        const savedConfig = loadProjectConfigOrNull(cfgPath);
+        const fileToken = savedConfig?.worker?.apiToken;
         const auth = resolveAuth(process.env, fileToken);
         const c = createClient(server, auth && auth !== "cookie" ? auth : void 0);
+        const baseBranch = resolveBaseBranch({
+          flag: args.baseBranch,
+          env: process.env.BATON_BASE_BRANCH,
+          saved: savedConfig?.baseBranch
+        });
         const hostname = osHostname();
         const machineId = readOrCreateMachineId();
         const name = args.name ?? hostname;
@@ -8212,16 +8346,18 @@ var worker = defineCommand({
             server,
             hostname,
             machineId,
-            agentKind
+            agentKind,
+            baseBranch
           },
           cfgPath
         );
         if (args.json) {
-          console.log(toJson({ ...out, configPath, machineIdPath: machineIdPath() }));
+          console.log(toJson({ ...out, baseBranch, configPath, machineIdPath: machineIdPath() }));
           return;
         }
         console.log(`worker #${out.worker.id} (${out.worker.name}) \u2014 ${out.outcome}`);
         console.log(`  agentKind:      ${out.worker.agentKind}`);
+        console.log(`  baseBranch:     ${baseBranch}`);
         console.log(`  hostname:       ${out.worker.hostname}`);
         console.log(`  machineId:      ${out.worker.machineId}`);
         console.log(`  machineId file: ${machineIdPath()}`);
@@ -8330,13 +8466,22 @@ var worker = defineCommand({
           console.log("(no worker registered for this project \u2014 run `baton worker register`)");
           return;
         }
+        const baseBranch = resolveBaseBranch({ saved: cfg.baseBranch });
         if (args.json) {
-          console.log(toJson({ ...worker2, server: cfg?.server, projectId: cfg?.project }));
+          console.log(
+            toJson({
+              ...worker2,
+              server: cfg.server,
+              projectId: cfg.project,
+              baseBranch
+            })
+          );
           return;
         }
         console.log(`worker #${worker2.id} (${worker2.name})`);
         console.log(`  machineId: ${worker2.machineId}`);
         console.log(`  agentKind: ${worker2.agentKind ?? "claude-code"}`);
+        console.log(`  baseBranch: ${baseBranch}`);
         console.log(`  server:    ${cfg?.server}`);
       }
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "license": "MIT",
   "publishConfig": {
     "access": "public"