automata-cli 0.8.0-develop.331 → 0.8.0-develop.353

package/README.md

@@ -74,12 +74,12 @@ Checks that the PR exists and is merged, the working tree is clean, and the remo
 Execute the full GitFlow release sequence and push to `origin`. Only requires `git`.
 
 ```bash
-automata git publish-release            # auto-detect version from master tag
+automata git publish-release            # auto-detect version from the trunk tag
 automata git publish-release 2.0.0      # explicit version
 automata git publish-release --dry-run  # preview without executing
 ```
 
-When no version is given, the latest semver tag on `master` is detected and the minor segment is incremented (e.g. `1.2.0 → 1.3.0`).
+When no version is given, the trunk branch is resolved from `origin` (`main`, `master` or whatever the remote calls it), tags are fetched, and the latest semver tag on `origin/<trunk>` is detected and the minor segment incremented (e.g. `1.2.0 → 1.3.0`). See [docs/git.md](docs/git.md#automata-git-publish-release).
 
 ---
 

package/dist/{ConfigWizard-D6NYL2E6.js → ConfigWizard-GULICHML.js}

@@ -36,7 +36,7 @@ var EXECUTOR_OPTIONS = [
   { label: "Claude Code", value: "claude" },
   { label: "Codex", value: "codex" }
 ];
-var MAIN_MENU_OPTIONS = ["Remote / Mode", "Implement-Next", "Prompts", "Issue Watch", "Do Work"];
+var MAIN_MENU_OPTIONS = ["Remote / Mode", "Implement-Next", "Prompts", "Issue Watch", "Do Work", "Git"];
 var PROMPTS_MENU_OPTIONS = [
   "Sonar",
   "Fix-Comments",
@@ -173,6 +173,7 @@ function ConfigWizard() {
   const [doWorkPrOrphanPrompt, setDoWorkPrOrphanPrompt] = useState(
     existing.doWork?.prompts?.prOrphan ?? DEFAULT_DO_WORK_PR_ORPHAN_PROMPT
   );
+  const [gitTrunkBranch, setGitTrunkBranch] = useState(existing.git?.trunkBranch ?? "");
   const [pendingRemote, setPendingRemote] = useState(existing.remoteType ?? "gh");
   const [pendingTechnique, setPendingTechnique] = useState(
     existing.issueDiscoveryTechnique ?? "label"
@@ -379,6 +380,16 @@ function ConfigWizard() {
         setScreen("prompts-menu");
       },
       onBack: () => setScreen("prompts-menu")
+    },
+    "git-trunk-branch": {
+      setValue: setGitTrunkBranch,
+      onSubmit: () => {
+        const branch = gitTrunkBranch.trim();
+        const current = readRawConfig();
+        writeConfig({ ...current, git: { ...current.git, trunkBranch: branch || void 0 } });
+        exit();
+      },
+      onBack: () => setScreen("main")
     }
   };
   const menus = {
@@ -392,6 +403,7 @@ function ConfigWizard() {
         else if (chosen === "Implement-Next") setScreen("technique");
         else if (chosen === "Issue Watch") setScreen("allowed-users");
         else if (chosen === "Do Work") setScreen("do-work-base-branch");
+        else if (chosen === "Git") setScreen("git-trunk-branch");
         else setScreen("prompts-menu");
       }
     },
@@ -550,6 +562,12 @@ function ConfigWizard() {
       label: "Instructions for a pull request with no linked issue:",
       value: doWorkPrOrphanPrompt,
       hint: `Type prompt \xB7 Enter to save \xB7 ${BACK}`
+    },
+    "git-trunk-branch": {
+      title: "Git \u2014 Trunk Branch",
+      label: "Branch publish-release releases to (blank = detect it from the remote):",
+      value: gitTrunkBranch,
+      hint: `Type branch \xB7 Enter to save \xB7 ${BACK}`
     }
   };
   const menuViews = {

package/dist/index.js

@@ -214,12 +214,23 @@ var configSetDoWorkPrompt = new Command("do-work-prompt").description("Set the t
   process.stdout.write(`do-work ${turnKind} prompt set.
 `);
 });
-var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt).addCommand(configSetAllowedUsers).addCommand(configSetAgentUser).addCommand(configSetDoWorkBaseBranch).addCommand(configSetDoWorkProtectedBranches).addCommand(configSetDoWorkExecutor).addCommand(configSetDoWorkModel).addCommand(configSetDoWorkEffort).addCommand(configSetDoWorkMaxRuns).addCommand(configSetDoWorkLockStaleMinutes).addCommand(configSetDoWorkPrompt);
+var configSetGitTrunkBranch = new Command("git-trunk-branch").description("Pin the branch `publish-release` releases to, instead of detecting it").argument("<value>", "Branch name (unset = detect it from the remote)").action((value) => {
+  const branch = value.trim();
+  if (branch.length === 0) {
+    process.stderr.write("Error: git-trunk-branch requires a non-empty branch name.\n");
+    process.exit(1);
+  }
+  const current = readRawConfig();
+  writeConfig({ ...current, git: { ...current.git, trunkBranch: branch } });
+  process.stdout.write(`git trunk branch set to: ${branch}
+`);
+});
+var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt).addCommand(configSetAllowedUsers).addCommand(configSetAgentUser).addCommand(configSetDoWorkBaseBranch).addCommand(configSetDoWorkProtectedBranches).addCommand(configSetDoWorkExecutor).addCommand(configSetDoWorkModel).addCommand(configSetDoWorkEffort).addCommand(configSetDoWorkMaxRuns).addCommand(configSetDoWorkLockStaleMinutes).addCommand(configSetDoWorkPrompt).addCommand(configSetGitTrunkBranch);
 var configCommand = new Command("config").description("Configure automata settings").addCommand(configSet).action(async () => {
   const [{ render }, React, { ConfigWizard }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./ConfigWizard-D6NYL2E6.js")
+    import("./ConfigWizard-GULICHML.js")
   ]);
   const { waitUntilExit } = render(React.createElement(ConfigWizard));
   await waitUntilExit();
@@ -230,6 +241,7 @@ import { Command as Command2 } from "commander";
 
 // src/git/gitService.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync } from "fs";
 
 // src/config/azdoService.ts
 import { spawnSync } from "child_process";
@@ -279,6 +291,44 @@ function getPrInfo() {
   };
 }
 
+// src/git/trunkDetection.ts
+var TRUNK_CANDIDATES = ["main", "master"];
+var TRUNK_BRANCH_CONFIG_KEY = "git.trunkBranch";
+var ORIGIN_HEAD_PREFIX = "refs/remotes/origin/";
+var SYMREF_PREFIX = "ref: refs/heads/";
+function parseOriginHeadRef(stdout) {
+  const ref = stdout.trim();
+  if (!ref.startsWith(ORIGIN_HEAD_PREFIX)) return null;
+  const branch = ref.slice(ORIGIN_HEAD_PREFIX.length);
+  return branch.length > 0 ? branch : null;
+}
+function parseLsRemoteSymref(stdout) {
+  for (const line of stdout.split("\n")) {
+    const trimmed2 = line.trim();
+    if (!trimmed2.startsWith(SYMREF_PREFIX)) continue;
+    const branch = trimmed2.slice(SYMREF_PREFIX.length).split(/\s+/)[0];
+    if (branch.length > 0) return branch;
+  }
+  return null;
+}
+function describeTrunkSource(source, branch) {
+  switch (source) {
+    case "config":
+      return `configured as ${TRUNK_BRANCH_CONFIG_KEY}`;
+    case "origin-head":
+      return "from origin/HEAD";
+    case "ls-remote":
+      return "from the remote's advertised HEAD";
+    case "probe":
+      return `probed as origin/${branch}`;
+  }
+}
+function unresolvedTrunkMessage(attempted) {
+  return `Could not determine the trunk branch of 'origin'.
+Tried: ${attempted.join(", ")}.
+Set it explicitly with: automata config set git-trunk-branch <branch>`;
+}
+
 // src/git/gitService.ts
 function run2(cmd, args) {
   const result = spawnSync2(cmd, args, { encoding: "utf8" });
@@ -752,7 +802,7 @@ function checkoutAndPull(targetBranch) {
   if (checkout.status !== 0) {
     throw new Error(`Failed to checkout ${targetBranch}: ${checkout.stderr.trim()}`);
   }
-  const pull = run2("git", ["pull"]);
+  const pull = run2("git", ["pull", "--ff-only"]);
   if (pull.status !== 0) {
     throw new Error(`Failed to pull ${targetBranch}: ${pull.stderr.trim()}`);
   }
@@ -785,6 +835,41 @@ function isAncestorCommit(maybeAncestor, descendant) {
 function resetHardTo(ref) {
   return gitCommand(["reset", "--hard", ref]);
 }
+var CHERRY_LINE = /^([+-]) ([0-9a-f]+)$/;
+function describeDivergence(upstream, head) {
+  const cherry = run2("git", ["cherry", upstream, head]);
+  if (cherry.status !== 0) return null;
+  const commits = [];
+  for (const line of cherry.stdout.split("\n")) {
+    const trimmed2 = line.trim();
+    if (trimmed2.length === 0) continue;
+    const match = CHERRY_LINE.exec(trimmed2);
+    if (match === null) return null;
+    commits.push({ sha: match[2], alreadyUpstream: match[1] === "-" });
+  }
+  const merges = run2("git", ["rev-list", "--count", "--merges", `${upstream}..${head}`]);
+  if (merges.status !== 0) return null;
+  const count = Number.parseInt(merges.stdout.trim(), 10);
+  if (!Number.isInteger(count)) return null;
+  return { commits, merges: count };
+}
+function rebaseOnto(ref) {
+  const { stdout, stderr, status } = run2("git", ["rebase", "--no-reapply-cherry-picks", ref]);
+  const detail = [stdout.trim(), stderr.trim()].filter((part) => part.length > 0).join("\n");
+  return { ok: status === 0, stderr: detail };
+}
+function abortRebase() {
+  return gitCommand(["rebase", "--abort"]);
+}
+var REBASE_STATE_PATHS = ["rebase-merge", "rebase-apply/rebasing"];
+function isRebaseInProgress() {
+  return REBASE_STATE_PATHS.some((name) => {
+    const { stdout, status } = run2("git", ["rev-parse", "--git-path", name]);
+    if (status !== 0) return false;
+    const path = stdout.trim();
+    return path.length > 0 && existsSync(path);
+  });
+}
 function fetchPrune() {
   const result = run2("git", ["fetch", "--prune"]);
   if (result.status !== 0) {
@@ -927,7 +1012,63 @@ function resolveCurrentBranchComments() {
   return { ok: true, branch, comments: raw };
 }
 var SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/;
-function getLatestTagOnMaster() {
+function remoteBranchExists(branch) {
+  return !isUpstreamGone(branch);
+}
+function resolveTrunkBranch() {
+  const configured = readRawConfig().git?.trunkBranch?.trim();
+  if (configured) {
+    return { ok: true, branch: configured, source: "config" };
+  }
+  const attempted = [];
+  attempted.push("origin/HEAD");
+  const head = run2("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+  if (head.status === 0) {
+    const branch = parseOriginHeadRef(head.stdout);
+    if (branch !== null) return { ok: true, branch, source: "origin-head" };
+  }
+  attempted.push("git ls-remote --symref origin HEAD");
+  const symref = run2("git", ["ls-remote", "--symref", "origin", "HEAD"]);
+  if (symref.status === 0) {
+    const branch = parseLsRemoteSymref(symref.stdout);
+    if (branch !== null) return { ok: true, branch, source: "ls-remote" };
+  }
+  for (const candidate of TRUNK_CANDIDATES) {
+    attempted.push(`origin/${candidate}`);
+    if (remoteBranchExists(candidate)) {
+      return { ok: true, branch: candidate, source: "probe" };
+    }
+  }
+  return { ok: false, attempted };
+}
+function fetchTrunkAndTags(trunk) {
+  const { status, stderr } = run2("git", [
+    "fetch",
+    "--tags",
+    "origin",
+    `+refs/heads/${trunk}:refs/remotes/origin/${trunk}`
+  ]);
+  if (status !== 0) {
+    return { ok: false, message: stderr.trim() || `git fetch --tags origin ${trunk} failed.` };
+  }
+  return { ok: true };
+}
+function localBranchExists(branch) {
+  const { status } = run2("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]);
+  return status === 0;
+}
+function trunkBehindCount(trunk) {
+  if (!localBranchExists(trunk)) return 0;
+  const { stdout, status } = run2("git", [
+    "rev-list",
+    "--count",
+    `refs/heads/${trunk}..refs/remotes/origin/${trunk}`
+  ]);
+  if (status !== 0) return 0;
+  const count = Number.parseInt(stdout.trim(), 10);
+  return Number.isNaN(count) ? 0 : count;
+}
+function getLatestTagOnTrunk(ref) {
   const { stdout, status } = run2("git", [
     "describe",
     "--tags",
@@ -936,7 +1077,7 @@ function getLatestTagOnMaster() {
     "[0-9]*.[0-9]*.[0-9]*",
     "--match",
     "v[0-9]*.[0-9]*.[0-9]*",
-    "master"
+    ref
   ]);
   if (status !== 0) return null;
   const tag = stdout.trim();
@@ -957,17 +1098,45 @@ ${stderr.trim()}`);
   }
   return stdout.trim().length > 0;
 }
-function publishRelease(version2, dryRun) {
+function checkReleasePreconditions() {
+  let branch;
+  try {
+    branch = getCurrentBranch();
+  } catch (err) {
+    return { ok: false, message: err.message };
+  }
+  if (branch !== "develop") {
+    return {
+      ok: false,
+      message: `publish-release must be run from the 'develop' branch (currently on '${branch}').`
+    };
+  }
+  if (hasUncommittedChanges()) {
+    return {
+      ok: false,
+      message: "You have uncommitted changes. Commit or stash them before publishing a release."
+    };
+  }
+  return { ok: true };
+}
+function publishRelease(version2, dryRun, trunk) {
   const releaseBranch = `release/${version2}`;
+  const checkoutTrunk = localBranchExists(trunk) ? { args: ["checkout", trunk], desc: `git checkout ${trunk}` } : {
+    args: ["checkout", "-b", trunk, `origin/${trunk}`],
+    desc: `git checkout -b ${trunk} origin/${trunk}`
+  };
   const steps = [
     { args: ["checkout", "-b", releaseBranch], desc: `git checkout -b ${releaseBranch}` },
-    { args: ["checkout", "master"], desc: `git checkout master` },
+    checkoutTrunk,
     { args: ["merge", "--no-ff", releaseBranch], desc: `git merge --no-ff ${releaseBranch}` },
     { args: ["tag", version2], desc: `git tag ${version2}` },
     { args: ["checkout", "develop"], desc: `git checkout develop` },
     { args: ["merge", "--no-ff", releaseBranch], desc: `git merge --no-ff ${releaseBranch}` },
     { args: ["branch", "-d", releaseBranch], desc: `git branch -d ${releaseBranch}` },
-    { args: ["push", "origin", "develop", "master", version2], desc: `git push origin develop master ${version2}` }
+    {
+      args: ["push", "origin", "develop", trunk, version2],
+      desc: `git push origin develop ${trunk} ${version2}`
+    }
   ];
   for (const step of steps) {
     if (dryRun) {
@@ -983,6 +1152,29 @@ ${stderr.trim()}`);
   }
 }
 
+// src/git/releaseVersion.ts
+var SEMVER_ARG_RE = /^\d+\.\d+\.\d+$/;
+function resolveReleaseVersion(requested, trunkRef, latestTag) {
+  if (requested !== void 0) {
+    if (!SEMVER_ARG_RE.test(requested)) {
+      return {
+        ok: false,
+        message: `Version '${requested}' is not valid semver. Use X.Y.Z format (e.g. 1.2.0).`
+      };
+    }
+    return { ok: true, version: requested, notice: null };
+  }
+  const latest = latestTag();
+  if (latest === null) {
+    return {
+      ok: false,
+      message: `No semver tag found on ${trunkRef}. Pass a version explicitly: automata git publish-release <X.Y.Z>`
+    };
+  }
+  const version2 = bumpMinorVersion(latest);
+  return { ok: true, version: version2, notice: `Auto-detected version: ${latest} \u2192 ${version2}` };
+}
+
 // src/commands/git.ts
 var FAIL_CONCLUSIONS = /* @__PURE__ */ new Set(["FAILURE", "TIMED_OUT", "ACTION_REQUIRED", "CANCELLED"]);
 var SKIP_CONCLUSIONS = /* @__PURE__ */ new Set(["SKIPPED", "NEUTRAL"]);
@@ -1347,59 +1539,58 @@ var finishFeatureCmd = new Command2("finish-feature").description("Clean up a me
     process.exit(1);
   }
 });
-var SEMVER_ARG_RE = /^\d+\.\d+\.\d+$/;
-var publishReleaseCmd = new Command2("publish-release").description("Execute the full GitFlow release sequence and push to origin").argument("[version]", "Release version in X.Y.Z format (auto-detected from master tag if omitted)").option("--dry-run", "Print git commands without executing them").addHelpText(
+var publishReleaseCmd = new Command2("publish-release").description("Execute the full GitFlow release sequence and push to origin").argument("[version]", "Release version in X.Y.Z format (auto-detected from the trunk tag if omitted)").option("--dry-run", "Print git commands without executing them").addHelpText(
   "after",
   `
 Release sequence:
   1. git checkout -b release/<version>
-  2. git checkout master && git merge --no-ff release/<version>
+  2. git checkout <trunk> && git merge --no-ff release/<version>
   3. git tag <version>
   4. git checkout develop && git merge --no-ff release/<version>
   5. git branch -d release/<version>
-  6. git push origin develop master <version>
+  6. git push origin develop <trunk> <version>
 
-When [version] is omitted the latest semver tag on master is detected and the
-minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
+<trunk> is resolved from origin \u2014 git.trunkBranch in .automata/config.json if
+set, else origin/HEAD, the remote's advertised HEAD, or a probe of main/master.
+Tags are fetched from origin first, in --dry-run too, so the version a dry run
+prints is the one a real run would use.
+
+When [version] is omitted the latest semver tag on origin/<trunk> is detected
+and the minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
 ).action((version2, options) => {
   const dryRun = options.dryRun ?? false;
-  let branch;
-  try {
-    branch = getCurrentBranch();
-  } catch (err) {
-    process.stderr.write(`Error: ${err.message}
+  const preconditions = checkReleasePreconditions();
+  if (!preconditions.ok) {
+    process.stderr.write(`Error: ${preconditions.message}
 `);
     process.exit(1);
   }
-  if (branch !== "develop") {
-    process.stderr.write(
-      `Error: publish-release must be run from the 'develop' branch (currently on '${branch}').
-`
-    );
+  const trunk = resolveTrunkBranch();
+  if (!trunk.ok) {
+    process.stderr.write(`Error: ${unresolvedTrunkMessage(trunk.attempted)}
+`);
     process.exit(1);
   }
-  if (hasUncommittedChanges()) {
-    process.stderr.write("Error: You have uncommitted changes. Commit or stash them before publishing a release.\n");
+  const trunkBranch = trunk.branch;
+  const trunkRef = `origin/${trunkBranch}`;
+  process.stdout.write(`Trunk branch: ${trunkBranch} (${describeTrunkSource(trunk.source, trunkBranch)})
+`);
+  const fetched = fetchTrunkAndTags(trunkBranch);
+  if (!fetched.ok) {
+    process.stderr.write(`Error: Failed to fetch ${trunkBranch} and tags from origin.
+${fetched.message}
+`);
     process.exit(1);
   }
-  let resolvedVersion;
-  if (version2 !== void 0) {
-    if (!SEMVER_ARG_RE.test(version2)) {
-      process.stderr.write(`Error: Version '${version2}' is not valid semver. Use X.Y.Z format (e.g. 1.2.0).
+  const versionResult = resolveReleaseVersion(version2, trunkRef, () => getLatestTagOnTrunk(trunkRef));
+  if (!versionResult.ok) {
+    process.stderr.write(`Error: ${versionResult.message}
 `);
-      process.exit(1);
-    }
-    resolvedVersion = version2;
-  } else {
-    const latest = getLatestTagOnMaster();
-    if (latest === null) {
-      process.stderr.write(
-        "Error: No semver tag found on master. Pass a version explicitly: automata git publish-release <X.Y.Z>\n"
-      );
-      process.exit(1);
-    }
-    resolvedVersion = bumpMinorVersion(latest);
-    process.stdout.write(`Auto-detected version: ${latest} \u2192 ${resolvedVersion}
+    process.exit(1);
+  }
+  const resolvedVersion = versionResult.version;
+  if (versionResult.notice !== null) {
+    process.stdout.write(`${versionResult.notice}
 `);
   }
   if (tagExists(resolvedVersion)) {
@@ -1407,6 +1598,14 @@ minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
 `);
     process.exit(1);
   }
+  const behind = trunkBehindCount(trunkBranch);
+  if (behind > 0) {
+    process.stderr.write(
+      `Error: Local branch '${trunkBranch}' is ${String(behind)} commit(s) behind ${trunkRef}. Update it (git checkout ${trunkBranch} && git merge --ff-only ${trunkRef}) or delete it, then re-run.
+`
+    );
+    process.exit(1);
+  }
   if (dryRun) {
     process.stdout.write(`Dry-run: release ${resolvedVersion}
 `);
@@ -1415,7 +1614,7 @@ minor segment is incremented (e.g. 1.2.0 \u2192 1.3.0).`
 `);
   }
   try {
-    publishRelease(resolvedVersion, dryRun);
+    publishRelease(resolvedVersion, dryRun, trunkBranch);
   } catch (err) {
     process.stderr.write(`Error: ${err.message}
 `);
@@ -2035,7 +2234,7 @@ function parseCreatedPrUrl(stdout, head) {
 // src/claude/claudeService.ts
 import { spawn, spawnSync as spawnSync5 } from "child_process";
 import { createInterface } from "readline";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { delimiter, join } from "path";
 
 // src/cli/spawnUtils.ts
@@ -2129,7 +2328,7 @@ function resolveCommand(name) {
   const pathDirs = (process.env["PATH"] ?? "").split(delimiter);
   for (const dir of pathDirs) {
     const candidate = join(dir, name);
-    if (existsSync(candidate)) return candidate;
+    if (existsSync2(candidate)) return candidate;
   }
   return name;
 }
@@ -3668,7 +3867,7 @@ function prepareBaseBranch(baseBranch) {
   if (!pull.ok) {
     return { ok: false, reason: "pull-failed", detail: pull.stderr };
   }
-  return { ok: true, branch: baseBranch };
+  return { ok: true, branch: baseBranch, strategy: "fast-forward" };
 }
 function resetToForcePushedRemote(headRefName, previousRemoteSha) {
   const localSha = revParse(`refs/heads/${headRefName}`);
@@ -3678,7 +3877,81 @@ function resetToForcePushedRemote(headRefName, previousRemoteSha) {
   if (!reset.ok) {
     return { ok: false, reason: "pull-failed", detail: reset.stderr };
   }
-  return { ok: true, branch: headRefName };
+  return { ok: true, branch: headRefName, strategy: "reset-to-remote" };
+}
+function rebaseOntoAlreadyAppliedRemote(headRefName) {
+  const upstream = `refs/remotes/origin/${headRefName}`;
+  const divergence = describeDivergence(upstream, `refs/heads/${headRefName}`);
+  if (divergence === null) return null;
+  if (divergence.merges > 0) return null;
+  if (divergence.commits.length === 0) return null;
+  if (divergence.commits.some((commit) => !commit.alreadyUpstream)) return null;
+  if (isRebaseInProgress()) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `a rebase is already in progress in this checkout and automata did not start it, so ${headRefName} was left untouched; finish it with \`git rebase --continue\` or drop it with \`git rebase --abort\``
+    };
+  }
+  const rebase = rebaseOnto(upstream);
+  if (!rebase.ok) {
+    if (!isRebaseInProgress()) {
+      return {
+        ok: false,
+        reason: "pull-failed",
+        detail: `${rebase.stderr} \u2014 the rebase never started, so ${headRefName} is untouched`
+      };
+    }
+    const aborted = abortRebase();
+    const restored = aborted.ok ? `the rebase was aborted, so ${headRefName} is back where it was` : `the rebase could NOT be aborted (${aborted.stderr}) \u2014 run \`git rebase --abort\` in the checkout`;
+    return {
+      ok: false,
+      reason: "rebase-conflict",
+      detail: `${rebase.stderr} \u2014 ${restored}`
+    };
+  }
+  const local = revParse(`refs/heads/${headRefName}`);
+  const remote = revParse(upstream);
+  if (local === null || remote === null || local !== remote) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `the rebase of ${headRefName} onto origin/${headRefName} reported success but did not land on the remote tip, so the branch is still out of sync; compare them with \`git log origin/${headRefName}..${headRefName}\``
+    };
+  }
+  return { ok: true, branch: headRefName, strategy: "rebase" };
+}
+function divergenceRefusal(headRefName, pullError) {
+  const divergence = describeDivergence(
+    `refs/remotes/origin/${headRefName}`,
+    `refs/heads/${headRefName}`
+  );
+  if (divergence === null) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `${pullError} \u2014 how the local ${headRefName} relates to origin/${headRefName} could not be established, so nothing was changed and ${headRefName} is untouched; inspect it with \`git log --oneline origin/${headRefName}...${headRefName}\` before deciding what to do`
+    };
+  }
+  const unpushedCount = divergence.commits.filter((c) => !c.alreadyUpstream).length + divergence.merges;
+  if (unpushedCount === 0) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      detail: `${pullError} \u2014 no commit of the local ${headRefName} is missing from origin/${headRefName}, so this is not a divergence; ${headRefName} is untouched and git's own error above is the cause to fix`
+    };
+  }
+  let unpushed;
+  if (unpushedCount === 1) {
+    unpushed = `1 of its commits is not on origin/${headRefName}`;
+  } else {
+    unpushed = `${String(unpushedCount)} of its commits are not on origin/${headRefName}`;
+  }
+  return {
+    ok: false,
+    reason: "pull-failed",
+    detail: `${pullError} \u2014 the local ${headRefName} has diverged from origin/${headRefName} and ${unpushed}, so it was not synchronized automatically; inspect them with \`git log origin/${headRefName}..${headRefName}\` and \`git reset --hard origin/${headRefName}\` yourself once they are safe to lose`
+  };
 }
 function preparePrBranch(headRefName) {
   if (hasUncommittedChanges([RUN_LOCK_RELATIVE_PATH])) return dirtyTree();
@@ -3687,25 +3960,28 @@ function preparePrBranch(headRefName) {
   if (!fetched.ok) {
     return { ok: false, reason: "checkout-failed", detail: fetched.stderr };
   }
+  const localExisted = revParse(`refs/heads/${headRefName}`) !== null;
   const checkout = checkoutBranch(headRefName);
   if (!checkout.ok) {
     const created = createTrackingBranch(headRefName);
     if (!created.ok) {
       return { ok: false, reason: "checkout-failed", detail: created.stderr };
     }
-    return { ok: true, branch: headRefName };
+    return { ok: true, branch: headRefName, strategy: "tracking-branch" };
   }
   const pull = pullFastForwardOnly(headRefName);
   if (!pull.ok) {
     const reset = resetToForcePushedRemote(headRefName, previousRemoteSha);
     if (reset !== null) return reset;
-    return {
-      ok: false,
-      reason: "pull-failed",
-      detail: `${pull.stderr} \u2014 the local ${headRefName} has commits origin/${headRefName} does not, so it was not reset automatically; inspect them and \`git reset --hard origin/${headRefName}\` yourself`
-    };
+    const rebased = rebaseOntoAlreadyAppliedRemote(headRefName);
+    if (rebased !== null) return rebased;
+    return divergenceRefusal(headRefName, pull.stderr);
   }
-  return { ok: true, branch: headRefName };
+  return {
+    ok: true,
+    branch: headRefName,
+    strategy: localExisted ? "fast-forward" : "tracking-branch"
+  };
 }
 
 // src/git/repoHygiene.ts
@@ -4073,6 +4349,18 @@ function repoField(repo) {
   const flat = oneLine(repo);
   return flat.length === 0 ? "-" : flat;
 }
+var QUIET_SYNC = /* @__PURE__ */ new Set(["fast-forward", "tracking-branch"]);
+function summarizeSync(items) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.sync === void 0) continue;
+    const key = oneLine(item.sync);
+    if (key.length === 0 || QUIET_SYNC.has(key)) continue;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  if (counts.size === 0) return null;
+  return [...counts].map(([strategy, count]) => `${strategy}:${String(count)}`).join(",");
+}
 function formatExecutionLine(tick) {
   const counts = {
     answered: 0,
@@ -4096,6 +4384,8 @@ function formatExecutionLine(tick) {
     `exit=${String(tick.exitCode)}`,
     `dur=${(tick.durationMs / 1e3).toFixed(1)}s`
   ];
+  const sync = summarizeSync(tick.items);
+  if (sync !== null) fields.push(`sync=${sync}`);
   if (tick.note !== void 0 && tick.note.length > 0) fields.push(`note=${tick.note}`);
   return fields.join(" ") + "\n";
 }
@@ -4112,13 +4402,18 @@ function describeItemExecution(item) {
   const effort = item.effort === void 0 ? "" : ` effort=${oneLine(item.effort)}`;
   return ` [${oneLine(item.executor)}${model}${effort}]`;
 }
+function describeItemSync(item) {
+  if (item.sync === void 0) return "";
+  const flat = oneLine(item.sync);
+  return flat.length === 0 ? "" : ` sync=${flat}`;
+}
 function formatWorkRecord(tick) {
   const ran = tick.items.filter((item) => item.ranExecutor);
   if (ran.length === 0) return null;
   const header = `=== ${tick.timestamp.toISOString()} ${repoField(tick.repo)} ===
 `;
   const lines = ran.map(
-    (item) => `${oneLine(item.subject)} ${item.turn === null ? "-" : oneLine(item.turn)} ${item.outcome}${describeItemExecution(item)} \u2014 ${briefDetail(item.detail)}
+    (item) => `${oneLine(item.subject)} ${item.turn === null ? "-" : oneLine(item.turn)} ${item.outcome}${describeItemExecution(item)}${describeItemSync(item)} \u2014 ${briefDetail(item.detail)}
 `
   );
   return header + lines.join("") + "\n";
@@ -4202,6 +4497,7 @@ function recordTick(tick, dir = operationLogDirectory()) {
 
 // src/commands/doWork.ts
 var inFlightMarker = null;
+var inFlightSync = null;
 function subjectLabel(issue, pr) {
   if (issue !== null) return `#${String(issue)}`;
   return pr === null ? "#?" : `PR #${String(pr)}`;
@@ -4840,6 +5136,7 @@ async function processItem(planned, settings, silent, preflightCauses) {
   progress(`
 ${itemLabel(planned)} ${planned.turn}: ${planned.reason}
 `);
+  inFlightSync = null;
   const refreshed = refreshItem(planned, settings);
   if (refreshed.kind === "skip") {
     progress(`  skipped: ${refreshed.detail}
@@ -4872,9 +5169,18 @@ ${itemLabel(planned)} ${planned.turn}: ${planned.reason}
     return {
       ...base,
       outcome: "skipped",
-      detail: `${prepared.reason}: ${prepared.detail}${why}`
+      detail: `${prepared.reason}: ${prepared.detail}${why}`,
+      sync: prepared.reason
     };
   }
+  base.sync = prepared.strategy;
+  inFlightSync = prepared.strategy;
+  if (prepared.strategy !== "fast-forward" && prepared.strategy !== "tracking-branch") {
+    progress(
+      `  ${prepared.branch} had diverged from origin; synchronized by ${prepared.strategy}.
+`
+    );
+  }
   claimIssue(item, settings);
   if (item.turn === "pr-work" && item.pr !== null && item.prNeedsAssignment) {
     claimPr(item.pr.number, settings.participants.agentUser);
@@ -5077,7 +5383,8 @@ function toTickLogItem(report) {
     ranExecutor: report.ranExecutor ?? false,
     executor: report.execution?.executor,
     model: report.execution?.model,
-    effort: report.execution?.effort
+    effort: report.execution?.effort,
+    sync: report.sync
   };
 }
 function logTick(reports, exitCode, startedAt, note) {
@@ -5183,7 +5490,8 @@ ${describePlan(decisions)}`;
         title: itemTitle(item),
         turn: item.turn,
         outcome: "failed",
-        detail: err.message
+        detail: err.message,
+        sync: inFlightSync ?? void 0
       };
     }
     if (report.ranExecutor === true) runsUsed++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.8.0-develop.331",
+  "version": "0.8.0-develop.353",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {
@@ -37,14 +37,14 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^26.5.0",
+    "@types/node": "^26.6.1",
     "@types/react": "^19.3.0",
     "eslint": "^10.10.0",
     "ink-testing-library": "^4.0.0",
-    "prettier": "^3.9.6",
+    "prettier": "^3.9.7",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.70.0",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.1"
   }
 }