@senad-d/branchme 0.3.6 → 0.3.9

package/src/git-integration.ts

@@ -43,6 +43,7 @@ import type {
   IntegrateBranchDetails,
   IntegrateBranchToolInput,
   IntegrateBranchVerification,
+  WorkingTreeDetails,
 } from "./types.ts";
 
 export interface PreparedBranchIntegration {
@@ -216,6 +217,12 @@ async function integrationSourceHead(
   return head;
 }
 
+function integrationWorkingTreeIsClean(workingTree: WorkingTreeDetails, allowUntracked: boolean): boolean {
+  return allowUntracked
+    ? workingTree.staged + workingTree.unstaged === 0
+    : workingTree.state === "clean";
+}
+
 async function inspectIntegrationState(
   pi: Pick<ExtensionAPI, "exec">,
   prepared: PreparedBranchIntegration,
@@ -234,7 +241,8 @@ async function inspectIntegrationState(
     signal,
     timeout: GIT_STATUS_TIMEOUT_MS,
   });
-  const clean = parseWorkingTreeStatus(statusResult.stdout).workingTree.state === "clean";
+  const workingTree = parseWorkingTreeStatus(statusResult.stdout).workingTree;
+  const clean = integrationWorkingTreeIsClean(workingTree, prepared.remoteSource === true || prepared.sourceHeadFixed === true);
   const sourceIsAncestorOfTarget = await isCommitAncestor(
     pi,
     rootCtx,
@@ -767,7 +775,7 @@ export async function prepareBranchIntegration(
     timeout: GIT_STATUS_TIMEOUT_MS,
   });
   const workingTree = parseWorkingTreeStatus(statusResult.stdout).workingTree;
-  if (workingTree.state !== "clean") {
+  if (!integrationWorkingTreeIsClean(workingTree, remoteSource)) {
     throw new Error(
       "The control worktree must be clean, with no staged, unstaged, untracked, or unmerged changes, before integration.",
     );

package/src/git-landing.ts

@@ -1,6 +1,6 @@
 import { lstat, realpath } from "node:fs/promises";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { GIT_FETCH_TIMEOUT_MS, GIT_PULL_TIMEOUT_MS, MAX_SUMMARY_OUTPUT_CHARS } from "./constants.ts";
+import { GIT_FETCH_TIMEOUT_MS, GIT_MUTATION_TIMEOUT_MS, GIT_PULL_TIMEOUT_MS, MAX_SUMMARY_OUTPUT_CHARS } from "./constants.ts";
 import {
   canonicalizePathAllowMissing,
   collectWorktreeInventory,
@@ -20,6 +20,7 @@ import {
   pathIsInsideOrEqual,
   removeWorktreeWithinQueue,
   requireLosslessWorktreeIdentity,
+  requireNoTrackedChanges,
   runGit,
   validateBranchName,
   validateBranchNameInput,
@@ -29,6 +30,7 @@ import {
   type GitCommandContext,
 } from "./git.ts";
 import { retireBranchWithinQueue } from "./git-retirement.ts";
+import { blockerGuidance } from "./blocker-guidance.ts";
 import { redactSecrets } from "./redaction.ts";
 import { getGitHubPullRequest, parseGitHubRepository, repositoriesEqual, resolveGitHubRepository, resolveGitHubToken, type RelatedPullRequestLookupOptions } from "./github.ts";
 import type { AheadBehindCount } from "./types.ts";
@@ -60,6 +62,11 @@ export interface LandBranchReceipt {
     reason: string | null;
     deletedIgnoredPaths: string[];
   };
+  /** The primary checkout, switched from the merged source to the target so the source can be retired. */
+  checkout: {
+    outcome: "switched" | "not-needed" | "refused";
+    reason: string | null;
+  };
   branch: {
     outcome: "deleted" | "absent" | "refused";
     reason: string | null;
@@ -74,7 +81,7 @@ export interface LandBranchReceipt {
     reason: string | null;
   };
   steps: {
-    step: "repository" | "cwd" | "fetch" | "ancestry" | "worktree" | "branch" | "targetSync";
+    step: "repository" | "cwd" | "fetch" | "ancestry" | "worktree" | "checkout" | "branch" | "targetSync";
     outcome: string;
     reason: string | null;
   }[];
@@ -144,6 +151,7 @@ function newLandingReceipt(root: string, input: LandBranchInput): LandBranchRece
     mergeProof: null,
     pullRequest: null,
     worktree: { path: null, outcome: "refused", reason: "Not attempted.", deletedIgnoredPaths: [] },
+    checkout: { outcome: "refused", reason: "Not attempted." },
     branch: { outcome: "refused", reason: "Not attempted.", expectedHead: null },
     targetSync: { mode: "not-run", worktreePath: null, before: null, after: null, aheadBehind: null, reason: "Not attempted." },
     steps: [{ step: "repository", outcome: "resolved", reason: null }],
@@ -248,6 +256,29 @@ async function removeLandingWorktree(pi: GitAPI, receipt: LandBranchReceipt, sig
   worktree.deletedIgnoredPaths = removed.deletedIgnoredPaths;
 }
 
+// The primary checkout can never be removed, so a merged source branch checked out
+// there is released by switching that checkout to the target branch.
+async function releasePrimaryCheckout(pi: GitAPI, receipt: LandBranchReceipt, signal?: AbortSignal): Promise<void> {
+  const ctx = { cwd: receipt.repositoryRoot };
+  const inventory = await collectWorktreeInventory(pi, ctx, signal);
+  if (inventory.entries[0]?.record.branch !== receipt.sourceBranch) {
+    receipt.checkout.outcome = "not-needed";
+    receipt.checkout.reason = null;
+    return;
+  }
+  if (await captureLocalHead(pi, ctx, receipt.sourceBranch, signal) !== receipt.sourceHead) {
+    throw new Error("Source branch moved after the ancestry proof; primary checkout retained.");
+  }
+  await requireIdleWorktree(pi, ctx, signal);
+  await requireNoTrackedChanges(pi, ctx, "switching the primary checkout to the target branch", signal);
+  await runGit(pi, ctx, ["switch", "--no-overwrite-ignore", receipt.targetBranch], { signal, timeout: GIT_MUTATION_TIMEOUT_MS });
+  if ((await getCurrentBranch(pi, ctx, signal)).currentBranch !== receipt.targetBranch) {
+    throw new Error("git switch did not end on the target branch; the primary checkout was left as git reported it.");
+  }
+  receipt.checkout.outcome = "switched";
+  receipt.checkout.reason = null;
+}
+
 async function retireLandingBranch(pi: GitAPI, receipt: LandBranchReceipt, signal?: AbortSignal): Promise<void> {
   const ctx = { cwd: receipt.repositoryRoot };
   const head = await captureLocalHead(pi, ctx, receipt.sourceBranch, signal);
@@ -309,9 +340,9 @@ async function syncLandingTarget(pi: GitAPI, receipt: LandBranchReceipt, signal?
       throw new Error("Target checkout identity changed; sync refused.");
     }
     const status = await getWorkingTreeStatus(pi, targetCtx, signal);
-    if (status.workingTree.state !== "clean") {
+    if (status.workingTree.staged + status.workingTree.unstaged > 0) {
       sync.mode = "skipped-dirty";
-      sync.reason = "Target checkout is dirty; no pull attempted.";
+      sync.reason = "Target checkout has tracked changes; no pull attempted.";
       return;
     }
     await requireIdleWorktree(pi, targetCtx, signal);
@@ -377,7 +408,8 @@ async function refuseLanding(pi: GitAPI, receipt: LandBranchReceipt, error: unkn
     receipt.targetSync.reason = `${reason} Verification: ${landingError(verificationError)}`;
   }
   const recorded = new Set(receipt.steps.map((step) => step.step));
-  for (const step of ["cwd", "fetch", "ancestry", "worktree", "branch", "targetSync"] as const) {
+  receipt.checkout.reason = reason;
+  for (const step of ["cwd", "fetch", "ancestry", "worktree", "checkout", "branch", "targetSync"] as const) {
     if (!recorded.has(step)) receipt.steps.push({ step, outcome: "not-run", reason });
   }
   return receipt;
@@ -467,6 +499,12 @@ async function landBranchWithinQueue(
     receipt.worktree.reason = landingError(error);
   }
   receipt.steps.push({ step: "worktree", outcome: receipt.worktree.outcome, reason: receipt.worktree.reason });
+  try {
+    await releasePrimaryCheckout(pi, receipt, signal);
+  } catch (error) {
+    receipt.checkout.reason = landingError(error);
+  }
+  receipt.steps.push({ step: "checkout", outcome: receipt.checkout.outcome, reason: receipt.checkout.reason });
   try {
     await retireLandingBranch(pi, receipt, signal);
   } catch (error) {
@@ -493,9 +531,30 @@ export async function landBranch(pi: GitAPI, ctx: GitCommandContext, input: Land
   return withRepositoryMutationQueue(root, landBranchWithinQueue.bind(undefined, routedPi, ctx.cwd, root, input, signal, options));
 }
 
+function shortHead(head: string | null): string {
+  return head ? head.slice(0, 7) : "unknown";
+}
+
+function formatTargetSync(receipt: LandBranchReceipt): string {
+  const sync = receipt.targetSync;
+  const target = receipt.targetBranch;
+  switch (sync.mode) {
+    case "noop": return `${target} already matched ${receipt.remote}/${target} at ${shortHead(sync.after)}`;
+    case "fetch-refspec":
+    case "pull-ff": return `${target} fast-forwarded ${shortHead(sync.before)} -> ${shortHead(sync.after)}`;
+    case "skipped-dirty": return `${target} not updated (its checkout has tracked changes)`;
+    case "failed": return `${target} not updated (failed)`;
+    case "not-run": return `${target} not updated (not run)`;
+  }
+}
+
 export function formatLandBranch(receipt: LandBranchReceipt): string {
   const proof = receipt.pullRequest ? ` Verified merged PR #${receipt.pullRequest.number}; source ancestry: ${receipt.ancestry.isAncestor ?? "unknown"}.` : "";
-  const summary = `land_branch: worktree ${receipt.worktree.outcome}; branch ${receipt.branch.outcome}; target sync ${receipt.targetSync.mode}.${proof}`;
-  const reason = receipt.worktree.reason ?? receipt.branch.reason ?? receipt.targetSync.reason;
-  return reason ? `${summary} ${landingError(reason)}` : summary;
+  const checkout = receipt.checkout.outcome === "switched" ? `; primary checkout switched to ${receipt.targetBranch}` : "";
+  const summary = `land_branch: worktree ${receipt.worktree.outcome}${checkout}; branch ${receipt.branch.outcome}; target sync: ${formatTargetSync(receipt)}.${proof}`;
+  const reason = receipt.worktree.reason ?? receipt.checkout.reason ?? receipt.branch.reason ?? receipt.targetSync.reason;
+  if (!reason) return summary;
+  const guidance = blockerGuidance(reason);
+  const suffix = guidance ? `\n${guidance}` : "";
+  return `${summary} ${landingError(reason)}${suffix}`;
 }

package/src/git-transport.ts

@@ -0,0 +1,133 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { resolveGitHubToken } from "./github.ts";
+
+type ExecOptions = Parameters<ExtensionAPI["exec"]>[2];
+type ExecResult = Awaited<ReturnType<ExtensionAPI["exec"]>>;
+
+const NETWORK_GIT_COMMANDS = new Set(["fetch", "pull", "push", "ls-remote"]);
+const KILL_GRACE_MS = 5000;
+const GIT_EXECUTABLE_CANDIDATES = process.platform === "win32"
+  ? [String.raw`C:\Program Files\Git\cmd\git.exe`, String.raw`C:\Program Files\Git\bin\git.exe`]
+  : ["/usr/bin/git", "/usr/local/bin/git", "/opt/homebrew/bin/git", "/bin/git"];
+
+// Answers github.com HTTPS credential requests from the token BranchMe already uses
+// for the GitHub API. The token stays in the child environment, never in argv.
+// Git queries this after the user's own helpers, so an existing login still wins.
+// printf emits Git's credential protocol fields; no credential is stored in source.
+export const TOKEN_CREDENTIAL_HELPER = String.raw`!f() { test "$1" = get || exit 0; printf '%s=%s\n' username x-access-token password "$BRANCHME_GIT_TOKEN"; }; f`;
+
+/** The git subcommand after leading `-c <config>` and `-C <dir>` options. */
+export function gitSubcommand(args: readonly string[]): string | undefined {
+  let index = 0;
+  while (args[index] === "-c" || args[index] === "-C") index += 2;
+  return args[index];
+}
+
+/** Network commands use a fixed system-install location, never a PATH lookup. */
+export async function resolveGitExecutable(): Promise<string> {
+  for (const candidate of GIT_EXECUTABLE_CANDIDATES) {
+    try {
+      if (!(await stat(candidate)).isFile()) continue;
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      // Try the next fixed installation location.
+    }
+  }
+  throw new Error("Git was not found in a supported system installation directory; install Git before retrying.");
+}
+
+async function resolveTransportToken(env: NodeJS.ProcessEnv, cwd: string | undefined, signal?: AbortSignal): Promise<string | null> {
+  try {
+    return (await resolveGitHubToken(env, { cwd, signal })).token;
+  } catch {
+    return null;
+  }
+}
+
+interface GitProcessState {
+  child: ChildProcess;
+  stdout: string;
+  stderr: string;
+  killed: boolean;
+  closed: boolean;
+  timer?: ReturnType<typeof setTimeout>;
+  killTimer?: ReturnType<typeof setTimeout>;
+  signal?: AbortSignal;
+  onAbort: () => void;
+}
+
+function forceKillGit(state: GitProcessState): void {
+  if (!state.closed) state.child.kill("SIGKILL");
+}
+
+function killGit(state: GitProcessState): void {
+  if (state.killed || state.closed) return;
+  state.killed = true;
+  state.child.kill("SIGTERM");
+  state.killTimer = setTimeout(forceKillGit, KILL_GRACE_MS, state);
+  state.killTimer.unref();
+}
+
+function appendGitOutput(state: GitProcessState, stream: "stdout" | "stderr", data: string): void {
+  state[stream] += data;
+}
+
+function appendGitError(state: GitProcessState, error: Error): void {
+  state.stderr += error.message;
+}
+
+function finishGit(state: GitProcessState, resolve: (result: ExecResult) => void, code: number | null): void {
+  state.closed = true;
+  clearTimeout(state.timer);
+  clearTimeout(state.killTimer);
+  state.signal?.removeEventListener("abort", state.onAbort);
+  resolve({ stdout: state.stdout, stderr: state.stderr, code: code ?? 1, killed: state.killed });
+}
+
+function startGit(binary: string, args: string[], env: NodeJS.ProcessEnv, options: ExecOptions, resolve: (result: ExecResult) => void): void {
+  const child = spawn(binary, args, { cwd: options?.cwd, env, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+  const state: GitProcessState = { child, stdout: "", stderr: "", killed: false, closed: false, signal: options?.signal, onAbort: () => undefined };
+  state.onAbort = killGit.bind(undefined, state);
+  state.timer = options?.timeout ? setTimeout(killGit, options.timeout, state) : undefined;
+  state.signal?.addEventListener("abort", state.onAbort, { once: true });
+  child.stdout!.setEncoding("utf8").on("data", appendGitOutput.bind(undefined, state, "stdout"));
+  child.stderr!.setEncoding("utf8").on("data", appendGitOutput.bind(undefined, state, "stderr"));
+  child.on("error", appendGitError.bind(undefined, state));
+  child.on("close", finishGit.bind(undefined, state, resolve));
+}
+
+function spawnGit(binary: string, args: string[], env: NodeJS.ProcessEnv, options: ExecOptions): Promise<ExecResult> {
+  if (options?.signal?.aborted) return Promise.resolve({ stdout: "", stderr: "", code: 1, killed: true });
+  return new Promise(startGit.bind(undefined, binary, args, env, options));
+}
+
+async function execGit(
+  pi: Pick<ExtensionAPI, "exec">,
+  env: NodeJS.ProcessEnv,
+  command: string,
+  args: string[],
+  options: ExecOptions,
+): Promise<ExecResult> {
+  if (command !== "git" || !NETWORK_GIT_COMMANDS.has(gitSubcommand(args) ?? "")) return pi.exec(command, args, options);
+  // An agent cannot answer a credential prompt: without this git waits on the
+  // terminal until the timeout and reports only "killed".
+  const childEnv: NodeJS.ProcessEnv = { ...env, GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" };
+  const token = await resolveTransportToken(env, options?.cwd, options?.signal);
+  const binary = await resolveGitExecutable();
+  if (token === null) return spawnGit(binary, args, childEnv, options);
+  childEnv.BRANCHME_GIT_TOKEN = token;
+  return spawnGit(binary, ["-c", `credential.https://github.com.helper=${TOKEN_CREDENTIAL_HELPER}`, ...args], childEnv, options);
+}
+
+/**
+ * Pi's exec cannot set a child environment. Network git commands (fetch, pull,
+ * push, ls-remote) spawn git directly without a terminal prompt and with the
+ * GitHub token available to git; every other command goes to Pi's exec.
+ */
+export function withGitTransport(pi: Pick<ExtensionAPI, "exec">, env: NodeJS.ProcessEnv = process.env): Pick<ExtensionAPI, "exec"> {
+  return { exec: execGit.bind(undefined, pi, env) };
+}

package/src/git-workflow.ts

@@ -5,8 +5,8 @@ import type { IntegrateBranchDetails } from "./types.ts";
 import {
   fetchRemoteBranchWithinQueue, getCanonicalGitWorktreeRoot, getCurrentBranch,
   getGitOperationState, getLocalBranchCommit, getRemoteTrackingRefCommit, getUpstreamBranch,
-  getWorkingTreeStatus, inspectDirectRemoteTrackingRef, localBranchExists,
-  requireLosslessWorktreeIdentity, runGit, validateBranchName, withRepositoryMutationQueue,
+  inspectDirectRemoteTrackingRef, localBranchExists,
+  requireLosslessWorktreeIdentity, requireNoTrackedChanges, runGit, validateBranchName, withRepositoryMutationQueue,
   type GitCommandContext,
 } from "./git.ts";
 
@@ -40,13 +40,11 @@ export async function fetchWorkflowBase(pi: GitAPI, ctx: GitCommandContext, remo
   await fetchRemoteBranchWithinQueue(scopedPi, ctx, remote, branch, signal);
 }
 
-export async function requireCleanIdleCheckout(pi: GitAPI, ctx: GitCommandContext, signal?: AbortSignal): Promise<void> {
+export async function requireCleanIdleCheckout(pi: GitAPI, ctx: GitCommandContext, operation: string, signal?: AbortSignal): Promise<void> {
   if ((await getGitOperationState(pi, ctx, signal)).active.length > 0) {
     throw new Error("An in-progress Git operation must be completed or aborted first.");
   }
-  if ((await getWorkingTreeStatus(pi, ctx, signal)).workingTree.state !== "clean") {
-    throw new Error("The working tree must be clean before this operation.");
-  }
+  await requireNoTrackedChanges(pi, ctx, operation, signal);
 }
 
 async function trackBranchWithinQueue(pi: GitAPI, ctx: GitCommandContext, input: TrackBranchInput, signal?: AbortSignal): Promise<TrackBranchDetails> {
@@ -61,7 +59,7 @@ async function trackBranchWithinQueue(pi: GitAPI, ctx: GitCommandContext, input:
     throw new Error("track_branch requires branch names, not full refs.");
   }
   if (await localBranchExists(pi, ctx, input.branchName, signal)) throw new Error("Local branch already exists; use change_branch.");
-  await requireCleanIdleCheckout(pi, ctx, signal);
+  await requireCleanIdleCheckout(pi, ctx, "track_branch", signal);
   const previous = await getCurrentBranch(pi, ctx, signal);
   if (previous.currentBranch !== null) requireLosslessWorktreeIdentity(previous.currentBranch, "branch");
   await fetchWorkflowBase(pi, ctx, remote, remoteBranch, signal);
@@ -69,7 +67,7 @@ async function trackBranchWithinQueue(pi: GitAPI, ctx: GitCommandContext, input:
   const ref = await inspectDirectRemoteTrackingRef(pi, ctx, upstream, signal);
   const head = await getRemoteTrackingRefCommit(pi, ctx, upstream, signal);
   if (ref.status !== "present" || ref.objectId !== head) throw new Error("Fetched branch is not a direct remote-tracking commit ref.");
-  await requireCleanIdleCheckout(pi, ctx, signal);
+  await requireCleanIdleCheckout(pi, ctx, "track_branch", signal);
   try {
     await runGit(pi, ctx, ["switch", "--no-overwrite-ignore", "--track=direct", "-c", input.branchName, `refs/remotes/${upstream}`], {
       signal, timeout: GIT_MUTATION_TIMEOUT_MS,
@@ -79,7 +77,7 @@ async function trackBranchWithinQueue(pi: GitAPI, ctx: GitCommandContext, input:
         await getUpstreamBranch(pi, ctx) !== upstream) {
       throw new Error("Branch, commit, or configured upstream did not match the captured remote branch.");
     }
-    await requireCleanIdleCheckout(pi, ctx);
+    await requireCleanIdleCheckout(pi, ctx, "track_branch");
   } catch {
     throw new Error("Tracking checkout did not complete with verified postconditions; inspect the repository before retrying. No automatic rollback was attempted.");
   }
@@ -125,7 +123,7 @@ async function updateFromBaseWithinQueue(pi: GitAPI, ctx: GitCommandContext, inp
   requireLosslessWorktreeIdentity(remote, "branch");
   requireLosslessWorktreeIdentity(input.baseBranch, "branch");
   await validateBranchName(pi, ctx, input.baseBranch, signal);
-  await requireCleanIdleCheckout(pi, ctx, signal);
+  await requireCleanIdleCheckout(pi, ctx, "update_from_base", signal);
   const current = await getCurrentBranch(pi, ctx, signal);
   if (!current.currentBranch || current.detached) throw new Error("update_from_base requires a current local branch.");
   if (current.currentBranch === input.baseBranch) throw new Error("Use pull_branch for the base branch itself.");

package/src/git.ts

@@ -591,6 +591,34 @@ export async function hasWorkingTreeChanges(
     .some((line) => line.length > 0 && !line.startsWith("## "));
 }
 
+const TRACKED_CHANGE_PATH_LIMIT = 5;
+
+/**
+ * Refuses when tracked files have staged, unstaged, or unmerged changes. Untracked
+ * files (a local .env, editor or tool state) never block: git itself refuses a
+ * switch, pull, rebase, or merge that would overwrite one.
+ */
+export async function requireNoTrackedChanges(
+  pi: Pick<ExtensionAPI, "exec">,
+  ctx: GitCommandContext,
+  operation: string,
+  signal?: AbortSignal,
+): Promise<void> {
+  const result = await runGit(pi, ctx, ["status", "--porcelain=v1", "--branch"], {
+    signal,
+    timeout: GIT_STATUS_TIMEOUT_MS,
+  });
+  // Display only: git quotes unusual paths and shows renames as "old -> new".
+  const paths = result.stdout
+    .split("\n")
+    .filter((line) => line.length > 3 && !line.startsWith("## ") && !line.startsWith("?? ") && !line.startsWith("!! "))
+    .map((line) => line.slice(3));
+  if (paths.length === 0) return;
+  const shown = paths.slice(0, TRACKED_CHANGE_PATH_LIMIT).map((path) => JSON.stringify(safeDetail(path))).join(", ");
+  const more = paths.length > TRACKED_CHANGE_PATH_LIMIT ? ` and ${paths.length - TRACKED_CHANGE_PATH_LIMIT} more` : "";
+  throw new Error(`Tracked files have uncommitted changes; ${operation} refused: ${shown}${more}. Untracked files do not block ${operation}.`);
+}
+
 export interface WorkingTreeStatus {
   workingTree: WorkingTreeDetails;
   unstagedChanges: GitFileChangeSummary;
@@ -2714,9 +2742,7 @@ export async function changeExistingLocalBranch(
       throw new Error(`Already on branch '${redactSecrets(branchName)}'.`);
     }
 
-    if (await hasWorkingTreeChanges(pi, rootCtx, signal)) {
-      throw new Error("Working tree has uncommitted changes; clean it before changing branches.");
-    }
+    await requireNoTrackedChanges(pi, rootCtx, "change_branch", signal);
 
     await runGit(pi, rootCtx, ["switch", branchName], {
       signal,
@@ -2872,9 +2898,7 @@ export async function pullCurrentBranch(
 
   return withRepositoryMutationQueue(repoRoot, async () => {
     const currentBranch = await requireCurrentBranch(pi, rootCtx, signal);
-    if (await hasWorkingTreeChanges(pi, rootCtx, signal)) {
-      throw new Error("Working tree has uncommitted changes; clean it before pulling the current branch.");
-    }
+    await requireNoTrackedChanges(pi, rootCtx, "pull_branch", signal);
 
     const target = await resolveConfiguredUpstreamTarget(pi, rootCtx, currentBranch, "pull", signal);
     if (!target) {
@@ -2934,9 +2958,7 @@ export async function rebaseCurrentBranch(
 
   return withRepositoryMutationQueue(repoRoot, async () => {
     const currentBranch = await requireCurrentBranch(pi, rootCtx, signal);
-    if (await hasWorkingTreeChanges(pi, rootCtx, signal)) {
-      throw new Error("Working tree has uncommitted changes; clean it before rebasing the current branch.");
-    }
+    await requireNoTrackedChanges(pi, rootCtx, "rebase_branch", signal);
 
     const target = await resolveConfiguredUpstreamTarget(pi, rootCtx, currentBranch, "rebase", signal);
     if (!target) {