fix(retarget): exempt retarget-base-not-found from blocking the operation

Repos skipped because the old base branch is missing (retarget-base-not-found)
no longer block other repos from being retargeted. The ahead count that
triggered this flag was measured against the fallback default branch, not the
missing base, so it incorrectly blocked repos where the old base never existed.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: henrikje

decisions/0101-retarget-base-not-found-exempt.md

@@ -0,0 +1,37 @@
+# Exempt retarget-base-not-found from blocking retarget
+
+Date: 2026-04-10
+
+## Context
+
+`arb retarget` applies an all-or-nothing gate: if any skipped repo has a non-exempt skip flag, the entire operation is blocked. The `retarget-base-not-found` flag fires when the old base branch is missing (neither remote nor local) and `status.base.ahead > 0`. The original intent was to block retarget when a repo has stacked work whose rebase boundary cannot be determined.
+
+However, `ahead` is measured against the fallback default branch (e.g., `main`), not the missing old base — because when the configured base is gone, base resolution falls back to the default branch. This means any feature branch with commits ahead of `main` triggers the flag, even when the old base branch was never present on that repo. In multi-repo workspaces where only some repos have the old base branch, this blocks the entire retarget unnecessarily.
+
+## Options
+
+### Exempt retarget-base-not-found
+Add the flag to `RETARGET_EXEMPT_SKIPS` alongside `no-base-branch` and `retarget-target-not-found`.
+- **Pros:** Simple one-line change. Follows the existing flat-set exemption pattern. Repos with this flag are already skipped (not operated on), so the exemption only controls whether they block other repos.
+- **Cons:** Does not distinguish "old base was never here" from "old base existed but was deleted." Both cases become non-blocking.
+
+### Split into two distinct flags
+Introduce `retarget-base-never-present` (exempt) and `retarget-base-deleted` (blocking) to preserve the safety distinction.
+- **Pros:** More precise safety model in theory.
+- **Cons:** The distinction cannot be reliably determined — when a branch is gone from both remote and local, there is no evidence of whether it was ever present. The `ahead` count is unreliable for this purpose (measured against fallback, not the missing base). Disproportionate complexity for no practical safety gain.
+
+## Decision
+
+Exempt `retarget-base-not-found` by adding it to `RETARGET_EXEMPT_SKIPS`.
+
+## Reasoning
+
+The exemption is safe because repos with this flag are already being skipped — they will not be rebased. The change only determines whether the skip also prevents other repos from being retargeted. After the retarget completes, the workspace config is updated to the new base, and the next `arb rebase` evaluates each repo freshly against the new base.
+
+The split-flag approach is not implementable without maintaining per-repo history of which branches have existed, and even if it were, the "deleted" case is equally safe to exempt for the same reason: the repo is skipped, not operated on.
+
+## Consequences
+
+- Multi-repo workspaces where only some repos have the old base branch can now be retargeted without manual intervention.
+- The `retarget-base-not-found` skip is still surfaced in the plan table (with attention styling via `BENIGN_SKIPS`), so the user sees which repos were skipped and why.
+- If a future scenario arises where a repo's stacked work truly depends on the deleted old base, the repo is still skipped — no data loss occurs. The user would need to manually resolve the branch state before rebasing that repo.

src/lib/status/skip-flags.test.ts

@@ -22,11 +22,11 @@ describe("RETARGET_EXEMPT_SKIPS", () => {
   test("contains retarget exemptions", () => {
     expect(RETARGET_EXEMPT_SKIPS.has("no-base-branch")).toBe(true);
     expect(RETARGET_EXEMPT_SKIPS.has("retarget-target-not-found")).toBe(true);
+    expect(RETARGET_EXEMPT_SKIPS.has("retarget-base-not-found")).toBe(true);
   });
 
   test("does not contain blocking flags", () => {
     expect(RETARGET_EXEMPT_SKIPS.has("dirty")).toBe(false);
     expect(RETARGET_EXEMPT_SKIPS.has("wrong-branch")).toBe(false);
-    expect(RETARGET_EXEMPT_SKIPS.has("retarget-base-not-found")).toBe(false);
   });
 });

src/lib/status/skip-flags.ts

@@ -34,6 +34,10 @@ export const BENIGN_SKIPS: ReadonlySet<SkipFlag> = new Set([
   "no-base-branch",
 ]);
 
-export const RETARGET_EXEMPT_SKIPS: ReadonlySet<SkipFlag> = new Set(["no-base-branch", "retarget-target-not-found"]);
+export const RETARGET_EXEMPT_SKIPS: ReadonlySet<SkipFlag> = new Set([
+  "no-base-branch",
+  "retarget-target-not-found",
+  "retarget-base-not-found",
+]);
 
 export const EXTRACT_EXEMPT_SKIPS: ReadonlySet<SkipFlag> = new Set(["no-base-branch"]);

test/integration/retarget.test.ts

@@ -463,7 +463,7 @@ describe("explicit retarget to non-default branch", () => {
       expect(result.output).not.toContain("may not be merged");
     }));
 
-  test("arb retarget blocks when old base ref is missing in truly stacked repo", () =>
+  test("arb retarget proceeds when old base ref is missing in stacked repo", () =>
     withEnv(async (env) => {
       const repoA = join(env.projectDir, ".arb/repos/repo-a");
       await git(repoA, ["checkout", "-b", "feat/auth"]);
@@ -499,14 +499,14 @@ describe("explicit retarget to non-default branch", () => {
       }
 
       // repo-a is truly stacked (base exists), repo-b's base is gone (both remote and local)
-      // Retarget can't compute the --onto boundary for repo-b → blocks all-or-nothing check
+      // repo-b is skipped (retarget-base-not-found) but does not block the operation
       const result = await arb(env, ["retarget", "main", "--yes"], {
         cwd: join(env.projectDir, "stacked"),
       });
-      expect(result.exitCode).not.toBe(0);
-      expect(result.output).toContain("Cannot retarget");
+      expect(result.exitCode).toBe(0);
+      expect(result.output).toContain("Retargeted");
       expect(result.output).toContain("repo-b");
-      expect(result.output).toContain("not found");
+      expect(result.output).toContain("skipped");
     }));
 
   test("arb retarget rejects retargeting to the current feature branch", () =>