@brainervirus/workit-core 2.8.0 → 2.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/src/forge/pr-ops.ts

@@ -241,6 +241,11 @@ export type MergeInput = {
   method: MergeMethod;
   deleteBranch: boolean;
   actor: LedgerActor;
+  /**
+   * Stack landing (S12): refuse unless the PR still targets this base and
+   * comes from this branch, re-checked right before the merge call.
+   */
+  expect?: { base: string; branch: string };
 };
 
 export type MergeOutcome = {
@@ -266,7 +271,8 @@ export type MergeRefusal = {
     | "head_mismatch"
     | "already_merged"
     | "closed"
-    | "protected_branch";
+    | "protected_branch"
+    | "base_mismatch";
   next?: string;
   blockers?: string[];
   verdict?: Pick<VerdictCheck, "head" | "accepted" | "authors">;
@@ -340,6 +346,12 @@ export async function mergePullRequest(
       { reason: "not_ready", next: doc.next, blockers: doc.blockers },
     );
 
+  if (input.expect && (doc.base !== input.expect.base || doc.head.branch !== input.expect.branch))
+    return refuse(
+      `base_mismatch: ${label} is ${doc.head.branch} -> ${doc.base}, expected ${input.expect.branch} -> ${input.expect.base}`,
+      "workit stack sync  # retarget it, then land again",
+      { reason: "base_mismatch" },
+    );
   const branch = doc.head.branch;
   const head = doc.head.sha;
   // --delete-branch never deletes a protected branch, the base, or the

package/src/ledger.ts

@@ -847,6 +847,47 @@ function effectiveOf(rows: readonly ReadRow[], authors: Set<string>): ReadRow |
   return effective;
 }
 
+/**
+ * Stacked branches (S12): a verdict keyed against the trunk cannot carry
+ * through a restack after its parent was squash-merged, because the
+ * trunk-relative diff loses the parent's change. `workit stack sync` observes
+ * each restack itself and records `stack.restacked` with `patchEqual` when
+ * the change relative to the parent is identical (same patch-id AND same
+ * exact diff hash, D18). A verdict carries when such observed rows link its
+ * head to the current head.
+ */
+function restackCarries(
+  rows: readonly ReadRow[],
+  branch: string,
+  from: string | null,
+  to: string | null,
+): boolean {
+  if (!from || !to) return false;
+  const edges = new Map<string, string[]>();
+  for (const row of rows)
+    if (
+      row.type === "stack.restacked" &&
+      row.observer === "workit_cli" &&
+      row.branch === branch &&
+      row.patchEqual === true &&
+      typeof row.fromHead === "string" &&
+      row.head
+    )
+      edges.set(row.fromHead, [...(edges.get(row.fromHead) ?? []), row.head]);
+  const seen = new Set<string>([from]);
+  const queue = [from];
+  while (queue.length) {
+    const next = queue.shift() as string;
+    if (next === to) return true;
+    for (const target of edges.get(next) ?? [])
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push(target);
+      }
+  }
+  return false;
+}
+
 /** Current and accepted verdicts for `branch`, after carry-over (D18). */
 export function checkVerdicts(cwd: string, branch: string, rows: readonly ReadRow[]): VerdictCheck {
   const head = branchHead(cwd, branch);
@@ -872,7 +913,8 @@ export function checkVerdicts(cwd: string, branch: string, rows: readonly ReadRo
   for (const [kind, list] of byKind) {
     const row = effectiveOf(list, authors);
     if (!row) continue;
-    const basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    let basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    if (basis === "stale" && restackCarries(rows, branch, row.head, head)) basis = "carried";
     const current = basis !== "stale";
     const independence = independenceReasons(row, authors);
     const reasons: RejectReason[] = [