@brainervirus/workit-core 7.4.0 → 7.5.1

package/src/fanout-check.ts

@@ -9,14 +9,22 @@
 //   PRs that would conflict once the first lands are caught before either
 //   does. A pairwise conflict is charged to the slice that lands later; the
 //   earlier one stays landable.
+// - case: a file or directory it adds that the trunk spells differently only
+//   in case (one path on macOS and Windows checkouts).
+// A slice that already landed (fanout-landed.ts: its PR merged, squash
+// merges included, or git shows its change on the trunk) is done: it is not
+// checked, and slices that depend on it no longer wait for it.
 // The landing order puts dependencies first, then the plan's order. A slice
 // is ready when none of the above fired and every slice it depends on is
-// ready. Verdicts are reported (`workit ledger check`) but gated by
+// ready or landed. Verdicts are reported (`workit ledger check`) but gated by
 // `workit pr merge`, not here. Refs are read as they are locally: fetch first.
+import type { ResolvedForge } from "./forge/resolve";
 import { checkVerdicts, readLedger, type ReadRow } from "./ledger";
 import {
   FANOUT_VERSION,
   branchRef,
+  caseClash,
+  caseIndex,
   fanoutFail,
   gitRun,
   inScope,
@@ -27,8 +35,15 @@ import {
   type FanoutResult,
   type Slice,
 } from "./fanout";
+import {
+  detectLanding,
+  forgeBreaker,
+  sliceStart,
+  type LandingContext,
+  type SliceLanding,
+} from "./fanout-landed";
 
-export type SliceStatus = "ready" | "blocked";
+export type SliceStatus = "ready" | "blocked" | "landed";
 
 export type SliceCheck = {
   id: string;
@@ -38,10 +53,14 @@ export type SliceCheck = {
   status: SliceStatus;
   changed: number;
   outOfScope: string[];
+  /** Paths it adds that the trunk spells differently only in case: `ours ~ trunk's`. */
+  caseCollisions: string[];
   trunkConflicts: string[];
   siblingConflicts: Array<{ with: string; paths: string[] }>;
   waitsFor: string[];
   verdict: { accepted: boolean; basis: string };
+  /** How it landed, when it did (then nothing else was checked). */
+  landed: { how: string; pr: number | null } | null;
   reasons: string[];
 };
 
@@ -68,6 +87,13 @@ export type CheckOutcome = {
   notes: string[];
 };
 
+export type CheckOptions = {
+  only?: readonly string[];
+  trunkRef?: string | null;
+  /** Asks the forge whether a slice's PR merged; null checks with git alone. */
+  forge?: ResolvedForge | null;
+};
+
 const SAFE = (value: string | null): value is string => Boolean(value) && !value?.startsWith("-");
 
 /** Paths both sides change incompatibly, [] when clean, or an error. */
@@ -97,7 +123,7 @@ const isAncestor = (cwd: string, a: string, b: string): boolean =>
 export function checkFanout(
   cwd: string,
   plan: FanoutFile,
-  options: { only?: readonly string[]; trunkRef?: string | null } = {},
+  options: CheckOptions = {},
 ): FanoutResult<CheckOutcome> {
   const unknown = (options.only ?? []).filter((id) => !plan.slices.some((s) => s.id === id));
   if (unknown.length)
@@ -119,10 +145,22 @@ export function checkFanout(
   const ledger = readLedger(cwd);
   const rows: readonly ReadRow[] = ledger.ok ? ledger.value.rows : [];
 
+  const breaker = forgeBreaker(options.forge ?? null);
+  const landings = sliceLandings(cwd, plan, trunk, tips, rows, breaker.forge);
+  const trunkCase = caseIndex(
+    nulList(gitRun(cwd, ["ls-tree", "-r", "-z", "--name-only", trunk]).stdout),
+  );
   const checks = new Map<string, SliceCheck>();
   const changedBy = new Map<string, string[]>();
-  for (const slice of plan.slices)
-    checks.set(slice.id, inspect(cwd, plan, slice, trunk, tips, rows, changedBy));
+  for (const slice of plan.slices) {
+    const landing = landings.get(slice.id) as SliceLanding;
+    checks.set(
+      slice.id,
+      landing.landed
+        ? landedCheck(slice, tips.get(slice.id) ?? null, landing)
+        : inspect(cwd, plan, slice, { trunk, trunkCase, tips, landings, rows }, changedBy),
+    );
+  }
 
   // Pairwise siblings: skip a pair where one contains the other (a stacked child).
   const conflicts: SiblingConflict[] = [];
@@ -132,6 +170,7 @@ export function checkFanout(
       const second = order[j];
       const a = tips.get(first);
       const b = tips.get(second);
+      if (landings.get(first)?.landed || landings.get(second)?.landed) continue;
       if (!a || !b || isAncestor(cwd, a, b) || isAncestor(cwd, b, a)) continue;
       const check = checks.get(second) as SliceCheck;
       const theirs = new Map(
@@ -173,8 +212,9 @@ export function checkFanout(
 
   for (const id of order) {
     const check = checks.get(id) as SliceCheck;
+    if (check.status === "landed") continue;
     check.waitsFor = (byId.get(id)?.dependsOn ?? []).filter(
-      (dep) => checks.get(dep)?.status !== "ready",
+      (dep) => checks.get(dep)?.status !== "ready" && checks.get(dep)?.status !== "landed",
     );
     if (check.waitsFor.length) check.reasons.push(`waits for ${check.waitsFor.join(", ")}`);
     check.status = check.reasons.length ? "blocked" : "ready";
@@ -184,7 +224,7 @@ export function checkFanout(
   const slices = order
     .filter((id) => !selected || selected.has(id))
     .map((id) => checks.get(id) as SliceCheck);
-  const ready = slices.every((check) => check.status === "ready");
+  const ready = slices.every((check) => check.status !== "blocked");
   const blocked = slices.find((check) => check.status === "blocked");
   const notes =
     plan.v === FANOUT_VERSION
@@ -192,9 +232,21 @@ export function checkFanout(
       : [
           `plan file version ${plan.v} is not ${FANOUT_VERSION}; read leniently (re-plan to rewrite it)`,
         ];
+  const forgeErrors = [...landings.values()].flatMap((landing) =>
+    landing.forgeError ? [landing.forgeError] : [],
+  );
+  if (!options.forge)
+    notes.push("landed slices detected with git only (no forge): a squash merge may be missed");
+  else if (breaker.down())
+    notes.push(`forge went down (${breaker.down()}); git alone decided the remaining slices`);
+  else if (forgeErrors.length)
+    notes.push(`forge lookups failed (${forgeErrors[0]}); git alone decided those slices`);
+  const toLand = slices.filter((check) => check.status === "ready").map((check) => check.id);
   const next = blocked
     ? unblockFor(blocked, plan)
-    : `land in this order: ${slices.map((check) => check.id).join(", ")} (workit pr merge each once verified; stacked slices with workit stack land)`;
+    : toLand.length
+      ? `land in this order: ${toLand.join(", ")} (workit pr merge each once verified; stacked slices with workit stack land)`
+      : "every slice has landed";
   return {
     ok: true,
     data: {
@@ -216,40 +268,132 @@ export function checkFanout(
 const resolves = (cwd: string, ref: string): boolean =>
   gitRun(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]).ok;
 
-function inspect(
+/** Landed state per slice, dependencies first (a child's base is its parent's merged head). */
+export function sliceLandings(
   cwd: string,
   plan: FanoutFile,
-  slice: Slice,
   trunk: string,
   tips: ReadonlyMap<string, string | null>,
   rows: readonly ReadRow[],
+  forge: ResolvedForge | null,
+): Map<string, SliceLanding> {
+  const ctx: LandingContext = { cwd, trunk, forge };
+  const out = new Map<string, SliceLanding>();
+  const byId = new Map(plan.slices.map((slice) => [slice.id, slice]));
+  for (const id of landingOrder(plan.slices)) {
+    const slice = byId.get(id) as Slice;
+    const parent = plan.slices.find((other) => other.branch === slice.base);
+    const parentHead = parent
+      ? (tips.get(parent.id) ?? out.get(parent.id)?.landedHead ?? null)
+      : null;
+    out.set(
+      id,
+      detectLanding(ctx, slice, {
+        head: tips.get(id) ?? null,
+        createdFrom: sliceStart(cwd, rows, plan.name, slice),
+        parentHead,
+        fanout: plan.name,
+        since: plan.createdAt || null,
+        rows,
+      }),
+    );
+  }
+  return out;
+}
+
+const blank = (slice: Slice, head: string | null): SliceCheck => ({
+  id: slice.id,
+  branch: slice.branch,
+  head,
+  base: slice.base,
+  status: "blocked",
+  changed: 0,
+  outOfScope: [],
+  caseCollisions: [],
+  trunkConflicts: [],
+  siblingConflicts: [],
+  waitsFor: [],
+  verdict: { accepted: false, basis: "missing" },
+  landed: null,
+  reasons: [],
+});
+
+function landedCheck(slice: Slice, head: string | null, landing: SliceLanding): SliceCheck {
+  return {
+    ...blank(slice, head),
+    status: "landed",
+    landed: { how: landing.how ?? "pr_merged", pr: landing.pr?.number ?? null },
+  };
+}
+
+type InspectContext = {
+  trunk: string;
+  trunkCase: ReadonlyMap<string, ReadonlySet<string>>;
+  tips: ReadonlyMap<string, string | null>;
+  landings: ReadonlyMap<string, SliceLanding>;
+  rows: readonly ReadRow[];
+};
+
+/** Files at `rev`, or null when it cannot be listed. */
+const treeFiles = (cwd: string, rev: string | null): Set<string> | null => {
+  if (!rev) return null;
+  const run = gitRun(cwd, ["ls-tree", "-r", "-z", "--name-only", rev]);
+  return run.ok ? new Set(nulList(run.stdout)) : null;
+};
+
+/**
+ * Paths the slice adds or changes that the trunk spells differently only in
+ * case, unless the slice removed the trunk's spelling (a case rename).
+ */
+function trunkCaseCollisions(
+  cwd: string,
+  ctx: InspectContext,
+  head: string,
+  changed: readonly string[],
+): string[] {
+  const headFiles = treeFiles(cwd, head);
+  const forkFiles = treeFiles(
+    cwd,
+    gitRun(cwd, ["merge-base", head, ctx.trunk]).stdout.trim() || null,
+  );
+  if (!headFiles) return [];
+  const present = (files: ReadonlySet<string> | null, prefix: string): boolean =>
+    Boolean(
+      files && (files.has(prefix) || [...files].some((file) => file.startsWith(`${prefix}/`))),
+    );
+  const out = new Set<string>();
+  for (const file of changed) {
+    if (!headFiles.has(file)) continue;
+    const clash = caseClash(ctx.trunkCase, file);
+    if (!clash) continue;
+    // The slice deleted the trunk's spelling it had: a deliberate case rename.
+    if (present(forkFiles, clash.trunk) && !present(headFiles, clash.trunk)) continue;
+    out.add(`${clash.path} ~ ${clash.trunk}`);
+  }
+  return [...out].toSorted();
+}
+
+function inspect(
+  cwd: string,
+  plan: FanoutFile,
+  slice: Slice,
+  ctx: InspectContext,
   changedBy: Map<string, string[]>,
 ): SliceCheck {
+  const { trunk, tips, rows } = ctx;
   const head = tips.get(slice.id) ?? null;
-  const check: SliceCheck = {
-    id: slice.id,
-    branch: slice.branch,
-    head,
-    base: slice.base,
-    status: "blocked",
-    changed: 0,
-    outOfScope: [],
-    trunkConflicts: [],
-    siblingConflicts: [],
-    waitsFor: [],
-    verdict: { accepted: false, basis: "missing" },
-    reasons: [],
-  };
+  const check = blank(slice, head);
   if (!head) {
-    check.reasons.push(`branch ${slice.branch} not found (not started, landed, or not fetched)`);
+    check.reasons.push(`branch ${slice.branch} not found (not started, or not fetched)`);
     return check;
   }
   const parent = plan.slices.find((other) => other.branch === slice.base);
+  // A landed parent whose branch is gone: diff against the head that merged.
   const baseRef =
     slice.base === plan.trunk
       ? trunk
       : parent
-        ? (tips.get(parent.id) ?? null)
+        ? (tips.get(parent.id) ?? ctx.landings.get(parent.id)?.landedHead ?? null)
         : branchRef(cwd, slice.base);
   if (!SAFE(baseRef)) {
     check.reasons.push(`base ${slice.base} not found`);
@@ -267,6 +411,11 @@ function inspect(
   check.outOfScope = changed.filter((file) => !inScope(plan, slice, file)).toSorted();
   if (check.outOfScope.length)
     check.reasons.push(`edits outside its scope: ${check.outOfScope.join(", ")}`);
+  check.caseCollisions = trunkCaseCollisions(cwd, ctx, head, changed);
+  if (check.caseCollisions.length)
+    check.reasons.push(
+      `differs only in case from ${plan.trunk}: ${check.caseCollisions.join(", ")}`,
+    );
   const trunkResult = mergeConflicts(cwd, trunk, head);
   if (Array.isArray(trunkResult)) {
     check.trunkConflicts = trunkResult;
@@ -280,9 +429,11 @@ function inspect(
 
 function unblockFor(check: SliceCheck, plan: FanoutFile): string {
   if (!check.head)
-    return `start or fetch ${check.branch}, then workit fanout check; if it landed, re-plan without slice ${check.id}`;
+    return `start or fetch ${check.branch}, then workit fanout check (a landed slice is detected through its merged PR when the forge is reachable)`;
   if (check.outOfScope.length)
     return `move ${check.outOfScope.join(", ")} off ${check.branch} (a follow-up slice), or widen slice ${check.id}'s scope with workit fanout plan, then workit fanout check`;
+  if (check.caseCollisions.length)
+    return `rename to ${plan.trunk}'s spelling on ${check.branch} (git mv), then workit fanout check`;
   if (check.trunkConflicts.length)
     return `rebase ${check.branch} onto ${plan.trunk} and resolve ${check.trunkConflicts.join(", ")}, then workit fanout check`;
   if (check.siblingConflicts.length) {

package/src/fanout-landed.ts

@@ -0,0 +1,313 @@
+// Has a fanout slice landed? Shared by `fanout status` and `fanout check`, so
+// a landed slice is done for both and its dependents stop waiting.
+//
+// With the forge, the slice branch's PR reads merged. A squash merge never
+// makes the branch an ancestor of the trunk, so this is the only reliable
+// signal; it holds while the branch has nothing newer than the merged head.
+// Without the forge (offline, no gh/glab, no PR yet), git decides:
+// - on_trunk: the branch tip is on the trunk and its reflog proves commits of
+//   its own (a commit, cherry-pick or rebase made on it, inside start..head);
+//   a branch only fast-forwarded to a newer trunk or parent has none;
+// - squash_patch: the branch's change has the same patch-id as one trunk
+//   commit (a squash merge that applied without the trunk touching the same
+//   lines). Anything else reads as not landed.
+// A merged PR whose branch is gone counts only when the ledger links that
+// branch to this slice (a worktree row, or a row recorded on its merged
+// head), so a reused branch name from older work is not taken for this slice.
+// A landing whose changed paths read on the trunk exactly as before it (a
+// revert) is not landed; the note says so.
+// The forge is asked through a breaker: after the first unavailable answer
+// (gh/glab missing, not logged in, timed out) it is not asked again in the
+// same run, and git decides the rest.
+import { spawnSync } from "node:child_process";
+import { GIT_TIMEOUTS, hasCommit, mergeBase, patchId } from "./git/rev";
+import type { ResolvedForge } from "./forge/resolve";
+import type { ForgeResult, PrRef } from "./forge/types";
+import { gitRun, type Slice } from "./fanout";
+
+export type LandedHow = "pr_merged" | "on_trunk" | "squash_patch";
+
+export type SliceLanding = {
+  landed: boolean;
+  how: LandedHow | null;
+  /** The slice's PR when the forge was asked and has one (open, closed or merged). */
+  pr: PrRef | null;
+  /** The merged head: a stacked child's diff base once the branch is gone. */
+  landedHead: string | null;
+  /** Why the forge could not answer for this slice; null when it did or was not asked. */
+  forgeError: string | null;
+  note: string | null;
+};
+
+export type LandingContext = {
+  cwd: string;
+  /** The trunk ref (e.g. refs/remotes/origin/main). */
+  trunk: string;
+  forge: ResolvedForge | null;
+  /** Trunk patch-ids per fork point, filled lazily. */
+  cache?: Map<string, Set<string>>;
+};
+
+export type ForgeBreaker = {
+  /** The forge whose calls stop after the first unavailable answer; null when there is none. */
+  forge: ResolvedForge | null;
+  /** Why it went down during this run, else null. */
+  down: () => string | null;
+};
+
+/**
+ * Wrap the forge so a missing, logged-out or hanging gh/glab costs one call
+ * per run, not one timeout per slice: after the first `unavailable` answer
+ * every later call fails at once with the same error.
+ */
+export function forgeBreaker(resolved: ResolvedForge | null): ForgeBreaker {
+  if (!resolved) return { forge: null, down: () => null };
+  let tripped: string | null = null;
+  const guard =
+    <A extends unknown[], T>(call: (...args: A) => ForgeResult<T>) =>
+    (...args: A): ForgeResult<T> => {
+      if (tripped) return { ok: false, code: "unavailable", error: tripped };
+      const result = call(...args);
+      if (!result.ok && result.code === "unavailable") tripped = result.error;
+      return result;
+    };
+  const inner = resolved.forge;
+  const forge = Object.create(inner) as typeof inner;
+  forge.findPr = guard(inner.findPr.bind(inner));
+  forge.prStatus = guard(inner.prStatus.bind(inner));
+  return { forge: { ...resolved, forge }, down: () => tripped };
+}
+
+const isAncestor = (cwd: string, a: string, b: string): boolean =>
+  gitRun(cwd, ["merge-base", "--is-ancestor", a, b]).ok;
+
+/** Where a local branch began (its oldest reflog entry), or null. */
+export function branchCreatedAt(cwd: string, branch: string): string | null {
+  if (!branch || branch.startsWith("-")) return null;
+  const log = gitRun(cwd, ["log", "-g", "--format=%H", `refs/heads/${branch}`, "--"]);
+  if (!log.ok) return null;
+  return log.stdout.trim().split("\n").findLast(Boolean) ?? null;
+}
+
+/**
+ * Does the branch's reflog show a commit made on it inside `start..head`?
+ * A commit, cherry-pick or rebased pick counts; a fast-forward, reset or
+ * branch creation does not, and neither does a rebase that only moved it.
+ */
+export function hasOwnCommits(
+  cwd: string,
+  branch: string,
+  start: string | null,
+  head: string,
+): boolean {
+  if (!branch || branch.startsWith("-")) return false;
+  const log = gitRun(cwd, ["log", "-g", "--format=%H%x00%gs", `refs/heads/${branch}`, "--"]);
+  if (!log.ok) return false;
+  for (const line of log.stdout.split("\n")) {
+    const [sha, subject = ""] = line.split("\0");
+    if (!sha) continue;
+    const made =
+      /^(?:commit(?: \((?:initial|amend)\))?|cherry-pick|rebase(?: -i)? \(pick\)):/u.test(subject);
+    const onto = /^rebase(?: -i)? \(finish\): \S+ onto ([0-9a-f]+)/u.exec(subject)?.[1];
+    if (!made && !(onto && !sha.startsWith(onto) && !onto.startsWith(sha))) continue;
+    if (sha !== head && !isAncestor(cwd, sha, head)) continue;
+    if (start && (sha === start || isAncestor(cwd, sha, start))) continue;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * The landing was undone: every path the change touched reads on the trunk
+ * exactly as before it (`git revert`, or a manual undo).
+ */
+function reverted(cwd: string, trunk: string, landedHead: string, start: string | null): boolean {
+  const fork = mergeBase(cwd, landedHead, trunk);
+  if (fork && fork !== landedHead) return unchangedSince(cwd, fork, landedHead, trunk);
+  // On the trunk already (merge or fast-forward): compare with where it began.
+  const before =
+    start && start !== landedHead && isAncestor(cwd, start, landedHead)
+      ? start
+      : gitRun(cwd, ["rev-parse", "--verify", "-q", `${landedHead}^1`]).stdout.trim();
+  return before ? unchangedSince(cwd, before, landedHead, trunk) : false;
+}
+
+function unchangedSince(cwd: string, before: string, after: string, trunk: string): boolean {
+  const paths = gitRun(cwd, ["diff", "--name-only", "--no-renames", "-z", before, after]);
+  const files = paths.ok ? paths.stdout.split("\0").filter(Boolean) : [];
+  if (files.length === 0) return false;
+  return gitRun(cwd, ["diff", "--quiet", before, trunk, "--", ...files]).ok;
+}
+
+const TRUNK_SCAN = 500;
+
+/** Stable patch-ids of the trunk's own commits since `fork` (same pinned diff options as patchId). */
+function trunkPatchIds(ctx: LandingContext, fork: string): Set<string> {
+  const cache = (ctx.cache ??= new Map());
+  const known = cache.get(fork);
+  if (known) return known;
+  const ids = new Set<string>();
+  const log = gitRun(ctx.cwd, [
+    "log",
+    "--no-merges",
+    `--max-count=${TRUNK_SCAN}`,
+    "-p",
+    "--format=commit %H",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${fork}..${ctx.trunk}`,
+    "--",
+  ]);
+  if (log.ok && log.stdout.trim()) {
+    const run = spawnSync("git", ["patch-id", "--stable"], {
+      cwd: ctx.cwd,
+      input: log.stdout,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUTS.local,
+      windowsHide: true,
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    for (const line of (run.stdout ?? "").split("\n")) {
+      const id = line.trim().split(/\s+/u)[0];
+      if (id) ids.add(id);
+    }
+  }
+  cache.set(fork, ids);
+  return ids;
+}
+
+/** The ledger links `branch` to this slice: a worktree row, or a row recorded on `head`. */
+function linked(
+  rows: readonly Record<string, unknown>[],
+  input: Pick<LandingInput, "fanout" | "since">,
+  slice: Pick<Slice, "id" | "branch">,
+  head: string | null,
+): boolean {
+  // Only rows from this run of the fanout: a plan of the same name made
+  // earlier must not lend its merged PRs to this one.
+  const since = input.since ? Date.parse(input.since) : Number.NaN;
+  return rows.some(
+    (row) =>
+      (Number.isNaN(since) || Date.parse(String(row.at)) >= since) &&
+      ((row.type === "fanout.worktree.created" &&
+        row.fanout === input.fanout &&
+        row.slice === slice.id) ||
+        (head !== null && row.branch === slice.branch && row.head === head)),
+  );
+}
+
+export type LandingInput = {
+  /** The branch tip; null when the branch is gone. */
+  head: string | null;
+  /** The commit it began at when known (reflog or the worktree ledger row). */
+  createdFrom: string | null;
+  /** Its dependency branch's tip (or merged head) for a stacked slice. */
+  parentHead: string | null;
+  fanout: string;
+  /** When this fanout plan was first made (FanoutFile.createdAt): older rows do not link. */
+  since: string | null;
+  rows: readonly Record<string, unknown>[];
+};
+
+/** Has `slice` landed on the trunk? */
+export function detectLanding(
+  ctx: LandingContext,
+  slice: Pick<Slice, "id" | "branch">,
+  input: LandingInput,
+): SliceLanding {
+  const out: SliceLanding = {
+    landed: false,
+    how: null,
+    pr: null,
+    landedHead: null,
+    forgeError: null,
+    note: null,
+  };
+  const landed = (how: LandedHow, landedHead: string): SliceLanding => {
+    if (
+      !hasCommit(ctx.cwd, landedHead) ||
+      !reverted(ctx.cwd, ctx.trunk, landedHead, input.createdFrom)
+    )
+      return { ...out, landed: true, how, landedHead };
+    return {
+      ...out,
+      note: `landed (${how}${out.pr ? ` #${out.pr.number}` : ""}), then reverted on the trunk: its paths read as before it`,
+    };
+  };
+  const { head } = input;
+  if (ctx.forge) {
+    const found = ctx.forge.forge.findPr(slice.branch, {
+      owner: ctx.forge.headRepo.split("/")[0] ?? null,
+      projectId: ctx.forge.headProjectId,
+      sha: head,
+    });
+    if (!found.ok) out.forgeError = found.error;
+    else if (found.data) {
+      out.pr = found.data;
+      if (found.data.state === "merged") {
+        const merged = found.data.headSha;
+        const label = `#${found.data.number}`;
+        if (!head) {
+          if (!linked(input.rows, input, slice, merged)) {
+            out.pr = null;
+            out.note = `${slice.branch} is gone; merged ${label} is not linked to this slice in the ledger (an older branch of the same name?)`;
+            return out;
+          }
+          return merged ? landed("pr_merged", merged) : { ...out, landed: true, how: "pr_merged" };
+        }
+        if (!merged || head === merged || isAncestor(ctx.cwd, head, merged))
+          return landed("pr_merged", merged ?? head);
+        out.note = isAncestor(ctx.cwd, merged, head)
+          ? `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} is ahead of it with newer commits`
+          : `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} has diverged from it (rewritten after the merge)`;
+        return out;
+      }
+    }
+  }
+  if (!head) return out;
+  const fork = mergeBase(ctx.cwd, head, ctx.trunk);
+  if (fork === head) {
+    // On the trunk: landed only when commits were made on the branch itself.
+    return hasOwnCommits(ctx.cwd, slice.branch, input.createdFrom, head)
+      ? landed("on_trunk", head)
+      : out;
+  }
+  if (!fork) return out;
+  const trunkIds = trunkPatchIds(ctx, fork);
+  if (trunkIds.size === 0) return out;
+  const froms = [fork];
+  if (input.parentHead && input.parentHead !== head && isAncestor(ctx.cwd, input.parentHead, head))
+    froms.push(input.parentHead);
+  for (const from of froms) {
+    const id = patchId(ctx.cwd, from, head);
+    if (id && trunkIds.has(id)) return landed("squash_patch", head);
+  }
+  return out;
+}
+
+/** The commit a slice branch began at: its reflog, else `fanout worktree create`'s ledger row. */
+export function sliceStart(
+  cwd: string,
+  rows: readonly Record<string, unknown>[],
+  fanout: string,
+  slice: Pick<Slice, "id" | "branch">,
+): string | null {
+  const reflog = branchCreatedAt(cwd, slice.branch);
+  if (reflog) return reflog;
+  const row = rows.findLast(
+    (candidate) =>
+      candidate.type === "fanout.worktree.created" &&
+      candidate.fanout === fanout &&
+      candidate.slice === slice.id &&
+      typeof candidate.baseSha === "string",
+  );
+  return (row?.baseSha as string | undefined) ?? null;
+}