@ai-dossier/sched 0.56.0 → 0.57.1

package/dist/recovery.d.ts

@@ -189,6 +189,44 @@ export declare function beginFixAttempt(state: SchedState, batchId: string, issu
 export declare function resolveFixAttempt(state: SchedState, batchId: string, issue: number, outcome: 'green' | 'red', deps: RecoveryDeps): {
     state: SchedState;
 };
+/** One of a batch's member branches, as it exists on origin (#840). */
+export interface RemoteMemberBranch {
+    /** `batch/<batchId>-m<index>-<issue>` */
+    branch: string;
+    index: number;
+    issue: number;
+}
+/**
+ * #840: this batch's member branches that exist on ORIGIN right now —
+ * `batch/<batchId>-m<n>-<issue>` (`memberBranchFor`'s shape), matched exactly
+ * so another batch whose id merely starts with this one's (`b1-a`, a halved
+ * split) or the integration branch (`batch/<id>-<date>`) never matches.
+ * Since #840 a member branch outlives its landing — it is deleted when the
+ * batch ships or dissolves (`teardownBatch`), so this is also how an
+ * aggregate-suite eviction finds the branch a landed member can be parked on.
+ * `null` when origin could not be read (never "no branches").
+ */
+export declare function listRemoteMemberBranches(exec: ExecFn, repoDir: string, batchId: string): RemoteMemberBranch[] | null;
+/** What {@link pruneMemberBranches} did (#840). */
+export interface MemberBranchPrune {
+    deleted: string[];
+    /** Branches a live queue entry still continues from — never deleted. */
+    kept: string[];
+    /** Branches whose delete failed (left on origin). */
+    failed: string[];
+}
+/**
+ * #840: the batch is over — delete its member branches from origin. They
+ * outlive landing so an aggregate-suite eviction can park a landed member on
+ * its branch; once the batch ships or dissolves (`teardownBatch`), or is
+ * abandoned (`sched abandon --batch`), nothing of the batch needs them —
+ * except a branch a NON-terminal queue entry's `failure_evidence.branch`
+ * still names (a parked member, or one requeued to continue from it): that
+ * branch is the member's work and is kept. One `git push --delete` per ref,
+ * so one already-gone ref cannot mask the others' outcome. `null` when
+ * origin could not be listed (nothing deleted). Never throws.
+ */
+export declare function pruneMemberBranches(exec: ExecFn, repoDir: string, state: SchedState, batchId: string): MemberBranchPrune | null;
 export interface EvictionInput {
     /** Members to evict; eviction-group partners are added automatically. */
     issues: readonly number[];
@@ -207,6 +245,12 @@ export interface EvictionOutcome {
     evicted: number[];
     /** Members actually put back on the queue (shipped members are not). */
     requeued: number[];
+    /**
+     * #840: members PARKED `evicted` on their still-live member branch instead
+     * of requeued — an operator's `sched requeue` continues them from it.
+     * Includes any a dissolve triggered by this eviction parked.
+     */
+    parked: number[];
     /** Commits reverted, in the order they were reverted (newest first). */
     reverted: string[];
     /** True when a revert conflicted — the batch dissolves instead. */
@@ -231,8 +275,9 @@ export interface EvictionOutcome {
  */
 export declare function expandEvictionGroups(batch: BatchEntry, issues: readonly number[]): number[];
 /**
- * `attributing → evicting`: revert the offending members' commits, requeue them
- * as full-cycle with their failure evidence, re-run the suite, and check the
+ * `attributing → evicting`: revert the offending members' commits, park each
+ * on its still-live member branch (#840; else requeue it as full-cycle) with
+ * its failure evidence, re-run the suite, and check the
  * batch's configurable dissolve threshold (`DissolvePolicy`, AC2/AC3/AC5).
  * Crossing it has two outcomes (#563): if the re-run suite came back green
  * for the survivors, the batch is PRESERVED — trimmed to its survivors and
@@ -357,7 +402,15 @@ export interface BlockOptions {
 export declare function blockBatch(state: SchedState, batchId: string, opts: BlockOptions, deps: RecoveryDeps): {
     state: SchedState;
 };
-export type PrConflictAction = 'reship' | 'dissolved';
+/**
+ * `reship` — rebased and re-shipping; `dissolved` — split into halves (no
+ * validated member); #840, with VALIDATED members landed: `regate` — the
+ * rebase worked but the suite is red, so the gate re-runs over the landed
+ * members; `blocked` — no clean rebase, the landed members wait for an
+ * operator (`dissolve-refused:<reason>`). In both #840 outcomes only the
+ * unvalidated members were split off.
+ */
+export type PrConflictAction = 'reship' | 'dissolved' | 'regate' | 'blocked';
 export interface PrConflictOutcome {
     state: SchedState;
     action: PrConflictAction;
@@ -372,8 +425,16 @@ export interface PrConflictOutcome {
  *
  * First occurrence: rebase the batch branch onto the base, re-run the suite,
  * and re-ship once. Second occurrence — or a rebase that conflicts, or a suite
- * that is red after a clean rebase — dissolves the batch into two half-batches:
- * the work is kept, the batch that could not land is not retried a third time.
+ * that is red after a clean rebase — gives up on re-shipping as-is:
+ *
+ * - no VALIDATED member → the batch dissolves into two half-batches: the work
+ *   is kept, the batch that could not land is not retried a third time.
+ * - #840: VALIDATED members exist → they are never re-batched or re-dispatched
+ *   (`keepLandedAndSplit`): they stay landed on the integration branch, and
+ *   only the unvalidated members are split into half-batches. When the rebase
+ *   onto the new base succeeded (red suite) the gate re-runs over the landed
+ *   members (`validating` — the shape of #822's `sched resume --batch`);
+ *   otherwise the batch blocks `dissolve-refused:<reason>` for an operator.
  */
 export declare function handlePrConflict(state: SchedState, batchId: string, deps: RecoveryDeps, opts?: {
     reason?: string;

package/dist/recovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,WAAW,EAIjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,UAAU,CAAC;AACpE,OAAO,EAIL,KAAK,gBAAgB,EAGtB,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAkBxC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,UAAU,EACf,KAAK,UAAU,EAGf,KAAK,cAAc,EAMnB,KAAK,YAAY,EAGjB,KAAK,SAAS,EAEd,KAAK,WAAW,EAEhB,KAAK,UAAU,EAGhB,MAAM,SAAS,CAAC;AAIjB,6CAA6C;AAC7C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,sEAAsE;IACtE,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,MAAM,WAAW,CAAC;AAE5C,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;CAC3D;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACtB;IACE,KAAK,EAAE,YAAY,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAAC;IAC9C,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B,GACD;IACE,KAAK,EAAE,OAAO,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IACzC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B,CAAC;AAEN;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG,CACjC,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,cAAc,KACtB,OAAO,CAAC;AAOb;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5C,oBAAoB,CAoBtB;AAED,wDAAwD;AACxD,MAAM,WAAW,YAAY;IAC3B,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,2FAA2F;IAC3F,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAwGD,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,mFAAmF;IACnF,MAAM,EAAE,iBAAiB,CAAC;IAC1B,6DAA6D;IAC7D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0CAA0C;IAC1C,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IACvC,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,qDAAqD;IACrD,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;CAC9B;AAED,+EAA+E;AAC/E,MAAM,WAAW,UAAU;IACzB,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,+DAA+D;IAC/D,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IACvC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,YAAY,GACjB;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,CAyEpD;AAID,0FAA0F;AAC1F,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAA;CAAO,GAC/F;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,CA4DrD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GAAG,KAAK,EACxB,IAAI,EAAE,YAAY,GACjB;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAyBvB;AAID,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IACjC,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,kBAAkB,EAAE,GAAG,IAAI,CAsB7B;AAwBD,mDAAmD;AACnD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,wEAAwE;IACxE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qDAAqD;IACrD,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,GACd,iBAAiB,GAAG,IAAI,CAmB1B;AAID,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,WAAW,EAAE,iBAAiB,CAAC;IAC/B,uEAAuE;IACvE,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;CACtD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,UAAU,CAAC;IAClB,qEAAqE;IACrE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,mEAAmE;IACnE,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,wGAAwG;IACxG,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,kEAAkE;IAClE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAoB3F;AAmBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,YAAY,GACjB,eAAe,CAmSjB;AA8CD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,EACjB,MAAM,GAAE,cAAwC,GAC/C,OAAO,CAIT;AA4CD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAE3D,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,0FAA0F;IAC1F,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,UAAU,CAAC;IAClB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gEAAgE;IAChE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB;;;;;OAKG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,kEAAkE;IAClE,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,YAAY,GACjB,eAAe,CA+HjB;AAkVD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,YAAY,GACjB;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAiCvB;AAID;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE7E,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,gBAAgB,CAAC;IACzB,6CAA6C;IAC7C,OAAO,EAAE,OAAO,CAAC;IACjB,gEAAgE;IAChE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7B,iBAAiB,CAgHnB"}

package/dist/recovery.js

@@ -37,6 +37,8 @@ exports.createExecMilestonePoster = createExecMilestonePoster;
 exports.beginAttribution = beginAttribution;
 exports.beginFixAttempt = beginFixAttempt;
 exports.resolveFixAttempt = resolveFixAttempt;
+exports.listRemoteMemberBranches = listRemoteMemberBranches;
+exports.pruneMemberBranches = pruneMemberBranches;
 exports.expandEvictionGroups = expandEvictionGroups;
 exports.evictMembers = evictMembers;
 exports.checkDissolveTrigger = checkDissolveTrigger;
@@ -302,6 +304,87 @@ function resolveFixAttempt(state, batchId, issue, outcome, deps) {
     }), now);
     return { state: next };
 }
+/**
+ * #840: this batch's member branches that exist on ORIGIN right now —
+ * `batch/<batchId>-m<n>-<issue>` (`memberBranchFor`'s shape), matched exactly
+ * so another batch whose id merely starts with this one's (`b1-a`, a halved
+ * split) or the integration branch (`batch/<id>-<date>`) never matches.
+ * Since #840 a member branch outlives its landing — it is deleted when the
+ * batch ships or dissolves (`teardownBatch`), so this is also how an
+ * aggregate-suite eviction finds the branch a landed member can be parked on.
+ * `null` when origin could not be read (never "no branches").
+ */
+function listRemoteMemberBranches(exec, repoDir, batchId) {
+    if (!attribution_1.SAFE_REF_RE.test(`batch/${batchId}`))
+        return null;
+    const out = exec('git', ['ls-remote', '--heads', 'origin', `refs/heads/batch/${batchId}-m*`], repoDir);
+    if (out === null)
+        return null;
+    const escaped = batchId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const shape = new RegExp(`^refs/heads/(batch/${escaped}-m(\\d+)-(\\d+))$`);
+    const found = [];
+    for (const line of out.split('\n')) {
+        const ref = line.trim().split(/\s+/)[1];
+        const match = ref === undefined ? null : shape.exec(ref);
+        if (match === null)
+            continue;
+        found.push({
+            branch: match[1],
+            index: Number(match[2]),
+            issue: Number(match[3]),
+        });
+    }
+    return found;
+}
+/**
+ * #840: the live member branch `issue`'s work sits on — the recorded one
+ * (parallel run / current serial member) when origin still has it, else the
+ * highest-indexed live `batch/<id>-m<n>-<issue>`. `null` when none is live.
+ * When origin could not be listed (`live === null`) nothing can be verified:
+ * a RECORDED branch (a parallel run's, or the current serial member's) is
+ * still parked on — a `sched requeue` onto a branch that turns out to be gone
+ * simply starts fresh (`runstate verify` → setup) — and anything else falls
+ * back to the full-cycle requeue, journaled by the caller.
+ */
+function liveMemberBranch(batch, issue, live) {
+    if (live === null)
+        return (0, state_1.recordedMemberBranch)(batch, issue);
+    const own = live.filter((b) => b.issue === issue);
+    const recorded = (0, state_1.recordedMemberBranch)(batch, issue);
+    if (recorded !== null && own.some((b) => b.branch === recorded))
+        return recorded;
+    return [...own].sort((a, b) => b.index - a.index)[0]?.branch ?? null;
+}
+/**
+ * #840: the batch is over — delete its member branches from origin. They
+ * outlive landing so an aggregate-suite eviction can park a landed member on
+ * its branch; once the batch ships or dissolves (`teardownBatch`), or is
+ * abandoned (`sched abandon --batch`), nothing of the batch needs them —
+ * except a branch a NON-terminal queue entry's `failure_evidence.branch`
+ * still names (a parked member, or one requeued to continue from it): that
+ * branch is the member's work and is kept. One `git push --delete` per ref,
+ * so one already-gone ref cannot mask the others' outcome. `null` when
+ * origin could not be listed (nothing deleted). Never throws.
+ */
+function pruneMemberBranches(exec, repoDir, state, batchId) {
+    const live = listRemoteMemberBranches(exec, repoDir, batchId);
+    if (live === null)
+        return null;
+    const referenced = new Set(state.entries
+        .filter((e) => !types_1.TERMINAL_ISSUE_STATUSES.has(e.status))
+        .map((e) => e.failure_evidence?.branch)
+        .filter((b) => typeof b === 'string'));
+    const out = { deleted: [], kept: [], failed: [] };
+    for (const { branch } of live) {
+        if (referenced.has(branch)) {
+            out.kept.push(branch);
+            continue;
+        }
+        const ok = exec('git', ['push', 'origin', '--delete', branch], repoDir) !== null;
+        (ok ? out.deleted : out.failed).push(branch);
+    }
+    return out;
+}
 /**
  * Every member that must leave with `issues`: an eviction group reverts
  * together (RFC-0001 §E.4), because a member built on another's API cannot
@@ -345,8 +428,9 @@ function orderRevertCommits(ranges, targets) {
         .map((commit) => commit.sha);
 }
 /**
- * `attributing → evicting`: revert the offending members' commits, requeue them
- * as full-cycle with their failure evidence, re-run the suite, and check the
+ * `attributing → evicting`: revert the offending members' commits, park each
+ * on its still-live member branch (#840; else requeue it as full-cycle) with
+ * its failure evidence, re-run the suite, and check the
  * batch's configurable dissolve threshold (`DissolvePolicy`, AC2/AC3/AC5).
  * Crossing it has two outcomes (#563): if the re-run suite came back green
  * for the survivors, the batch is PRESERVED — trimmed to its survivors and
@@ -378,6 +462,7 @@ function evictMembers(state, batchId, input, deps) {
             state: dissolve.state,
             evicted: [],
             requeued: dissolve.requeued,
+            parked: dissolve.parked,
             reverted: [],
             conflict: true,
             // #810: a refused dissolve (validated members kept) blocks instead.
@@ -432,7 +517,11 @@ function evictMembers(state, batchId, input, deps) {
         }
         record();
     }
-    // Requeue every reverted member with its evidence attached (AC2).
+    // Requeue every reverted member with its evidence attached (AC2) — or,
+    // since #840, PARK it `evicted` on its member branch when that branch is
+    // still live on origin (a landed member's branch now outlives the landing):
+    // the reverted work is exactly what is on it, and an operator's `sched
+    // requeue` continues it there instead of restarting from the base.
     //
     // A member already in `evictions[]` is skipped entirely (#595 AC1): the
     // reverts above are idempotent (each checks the branch history first), but a
@@ -444,7 +533,15 @@ function evictMembers(state, batchId, input, deps) {
     // never silently dropped.
     const alreadyEvicted = new Map(batch.evictions.map((e) => [e.issue, e]));
     const requeued = [];
+    const parked = [];
     const records = [];
+    const needsBranch = targets.some((t) => !alreadyEvicted.has(t));
+    const live = needsBranch ? listRemoteMemberBranches(deps.exec, deps.repoDir, batchId) : [];
+    if (live === null) {
+        journal(deps, (0, journal_1.unitEvent)('git-failed', `batch:${batchId}`, {
+            detail: `git ls-remote origin batch/${batchId}-m* failed — member branches unverifiable: only a recorded member branch is parked on, other evicted members requeue full-cycle from the base`,
+        }), now);
+    }
     for (const issue of targets) {
         const prior = alreadyEvicted.get(issue);
         if (prior) {
@@ -464,18 +561,31 @@ function evictMembers(state, batchId, input, deps) {
             reverted_commits: memberCommits,
             at: now.toISOString(),
         };
-        const result = (0, state_1.requeueMember)(next, issue, { mode: 'full', batch: null }, input.reason, now, {
-            failure_evidence: evidence,
-        });
-        next = result.state;
-        if (result.requeued)
-            requeued.push(issue);
+        const branch = liveMemberBranch(batch, issue, live);
+        const park = branch === null
+            ? { state: next, parked: false }
+            : (0, state_1.parkMember)(next, issue, 'evicted', input.reason, now, {
+                failure_evidence: { ...evidence, branch },
+            });
+        next = park.state;
+        if (park.parked) {
+            parked.push(issue);
+        }
+        else {
+            const result = (0, state_1.requeueMember)(next, issue, { mode: 'full', batch: null }, input.reason, now, {
+                failure_evidence: evidence,
+            });
+            next = result.state;
+            if (result.requeued)
+                requeued.push(issue);
+        }
         records.push({
             issue,
             reason: input.reason,
             attribution: input.attribution,
             reverted_commits: memberCommits,
             group: targets.filter((t) => t !== issue),
+            ...(park.parked ? { kind: 'evicted', branch } : {}),
             at: now.toISOString(),
         });
         journal(deps, (0, journal_1.unitEvent)('member-evicted', `batch:${batchId}`, {
@@ -484,9 +594,10 @@ function evictMembers(state, batchId, input, deps) {
             // on the branch while the queue says it was evicted, so the batch would
             // ship code it believes it removed. `reverted=0` alone reads as "an
             // empty range", which is why this says it in words.
-            detail: memberCommits.length === 0
+            detail: (memberCommits.length === 0
                 ? `${input.reason} reverted=0 — NO commits found for this member on the batch branch; its work was NOT reverted`
-                : `${input.reason} reverted=${memberCommits.length}`,
+                : `${input.reason} reverted=${memberCommits.length}`) +
+                (park.parked ? ` — parked on ${branch}` : ''),
         }), now);
     }
     // `appendEvictions` stays the state-level backstop; the loop above already
@@ -507,6 +618,7 @@ function evictMembers(state, batchId, input, deps) {
             reason: input.reason,
             evicted: targets.join(',') || 'none',
             requeued: requeued.join(',') || 'none',
+            ...(parked.length > 0 ? { parked: parked.join(',') } : {}),
             reverted: String(reverted.length),
             attribution: input.attribution,
             ...(withoutCommits.length > 0 ? { no_commits: withoutCommits.join(',') } : {}),
@@ -548,6 +660,7 @@ function evictMembers(state, batchId, input, deps) {
             // The surviving members the dissolve requeued belong here too — a caller
             // reading `requeued` must see everything that went back on the queue.
             requeued: [...new Set([...requeued, ...dissolve.requeued])].sort((a, b) => a - b),
+            parked: [...new Set([...parked, ...dissolve.parked])].sort((a, b) => a - b),
             reverted,
             conflict: false,
             dissolved,
@@ -559,6 +672,7 @@ function evictMembers(state, batchId, input, deps) {
         state: next,
         evicted: targets,
         requeued,
+        parked,
         reverted,
         conflict: false,
         dissolved: false,
@@ -582,6 +696,7 @@ function revertConflict(state, batchId, targets, deps, now, reverted, detail) {
         state: dissolve.state,
         evicted: [...targets],
         requeued: dissolve.requeued,
+        parked: dissolve.parked,
         reverted,
         conflict: true,
         // #810: a refused dissolve (validated members kept) blocks instead.
@@ -715,59 +830,10 @@ function dissolveBatch(state, batchId, opts, deps) {
     const requeued = [];
     const parked = [];
     if (strategy === 'halved' && unshipped.length > 0) {
-        // Split by POSITION, not by coupling: the halves are the first and second
-        // half of `unshipped` in member order. A coupled eviction group straddling
-        // the pivot is therefore broken up — accepted, because both halves re-run
-        // through the same validate/evict rails, where a member that cannot stand
-        // alone is evicted rather than silently shipped.
-        const pivot = Math.ceil(unshipped.length / 2);
-        const taken = new Set(next.batches.map((b) => b.id));
-        // A colliding id would produce two batches answering to one name:
-        // `findBatch` would return the first and `validateState` would refuse to
-        // load the file at all on the next start.
-        const freeId = (base) => {
-            let id = base;
-            let n = 2;
-            while (taken.has(id))
-                id = `${base}${n++}`;
-            taken.add(id);
-            return id;
-        };
-        const halves = [
-            { id: freeId(`${batchId}-a`), members: unshipped.slice(0, pivot) },
-            { id: freeId(`${batchId}-b`), members: unshipped.slice(pivot) },
-        ].filter((h) => h.members.length > 0);
-        for (const half of halves) {
-            next = {
-                ...next,
-                batches: [
-                    ...next.batches,
-                    (0, state_1.createBatch)(half.id, half.members, now, {
-                        base_branch: batch.base_branch,
-                        anchor: batch.anchor ?? undefined,
-                        run_id: batch.run_id ?? undefined,
-                        dispatch_profile: batch.dispatch_profile ?? undefined,
-                        // #565: a dissolve split is not a fresh batch — carry the
-                        // parent's priority forward, or an operator's `--priority`
-                        // (or `reprioritize`) is silently lost the moment a batch
-                        // dissolves into halves.
-                        priority: batch.priority,
-                        // Groups survive the split, restricted to the members that landed
-                        // in this half — a group spanning both halves is no longer a group.
-                        eviction_groups: batch.eviction_groups
-                            .map((group) => group.filter((m) => half.members.includes(m)))
-                            .filter((group) => group.length > 1),
-                    }),
-                ],
-            };
-            newBatches.push(half.id);
-            for (const issue of half.members) {
-                const result = (0, state_1.requeueMember)(next, issue, { mode: 'slot', batch: half.id }, opts.reason, now, { failure_evidence: { ...evidence, batch: half.id } });
-                next = result.state;
-                if (result.requeued)
-                    requeued.push(issue);
-            }
-        }
+        const split = splitIntoHalves(next, batch, unshipped, opts.reason, evidence, now);
+        next = split.state;
+        newBatches.push(...split.newBatches);
+        requeued.push(...split.requeued);
         journal(deps, (0, journal_1.unitEvent)('batch-split', `batch:${batchId}`, { detail: newBatches.join(',') }), now);
     }
     else {
@@ -813,6 +879,76 @@ function dissolveBatch(state, batchId, opts, deps) {
         validated: [],
     };
 }
+/**
+ * Split `members` of `batch` into two fresh `forming` half-batches and requeue
+ * each member into its half (§F.9: smaller batches, not abandoned work) — the
+ * `halved` dissolve's split, shared since #840 with `handlePrConflict`'s
+ * keep-landed path (which splits only the UNVALIDATED members).
+ *
+ * Split by POSITION, not by coupling: the halves are the first and second
+ * half of `members` in member order. A coupled eviction group straddling the
+ * pivot is therefore broken up — accepted, because both halves re-run
+ * through the same validate/evict rails, where a member that cannot stand
+ * alone is evicted rather than silently shipped.
+ */
+function splitIntoHalves(state, batch, members, reason, evidence, now) {
+    let next = state;
+    const newBatches = [];
+    const requeued = [];
+    if (members.length === 0)
+        return { state: next, newBatches, requeued };
+    const pivot = Math.ceil(members.length / 2);
+    const taken = new Set(next.batches.map((b) => b.id));
+    // A colliding id would produce two batches answering to one name:
+    // `findBatch` would return the first and `validateState` would refuse to
+    // load the file at all on the next start.
+    const freeId = (base) => {
+        let id = base;
+        let n = 2;
+        while (taken.has(id))
+            id = `${base}${n++}`;
+        taken.add(id);
+        return id;
+    };
+    const halves = [
+        { id: freeId(`${batch.id}-a`), members: members.slice(0, pivot) },
+        { id: freeId(`${batch.id}-b`), members: members.slice(pivot) },
+    ].filter((h) => h.members.length > 0);
+    for (const half of halves) {
+        next = {
+            ...next,
+            batches: [
+                ...next.batches,
+                (0, state_1.createBatch)(half.id, half.members, now, {
+                    base_branch: batch.base_branch,
+                    anchor: batch.anchor ?? undefined,
+                    run_id: batch.run_id ?? undefined,
+                    dispatch_profile: batch.dispatch_profile ?? undefined,
+                    // #565: a dissolve split is not a fresh batch — carry the
+                    // parent's priority forward, or an operator's `--priority`
+                    // (or `reprioritize`) is silently lost the moment a batch
+                    // dissolves into halves.
+                    priority: batch.priority,
+                    // Groups survive the split, restricted to the members that landed
+                    // in this half — a group spanning both halves is no longer a group.
+                    eviction_groups: batch.eviction_groups
+                        .map((group) => group.filter((m) => half.members.includes(m)))
+                        .filter((group) => group.length > 1),
+                }),
+            ],
+        };
+        newBatches.push(half.id);
+        for (const issue of half.members) {
+            const result = (0, state_1.requeueMember)(next, issue, { mode: 'slot', batch: half.id }, reason, now, {
+                failure_evidence: { ...evidence, batch: half.id },
+            });
+            next = result.state;
+            if (result.requeued)
+                requeued.push(issue);
+        }
+    }
+    return { state: next, newBatches, requeued };
+}
 /**
  * #810: sort a dissolving batch's members. `preserved` = no longer the
  * batch's to decide (shipped/terminal, redispatched elsewhere, or already
@@ -1050,8 +1186,16 @@ function blockBatch(state, batchId, opts, deps) {
  *
  * First occurrence: rebase the batch branch onto the base, re-run the suite,
  * and re-ship once. Second occurrence — or a rebase that conflicts, or a suite
- * that is red after a clean rebase — dissolves the batch into two half-batches:
- * the work is kept, the batch that could not land is not retried a third time.
+ * that is red after a clean rebase — gives up on re-shipping as-is:
+ *
+ * - no VALIDATED member → the batch dissolves into two half-batches: the work
+ *   is kept, the batch that could not land is not retried a third time.
+ * - #840: VALIDATED members exist → they are never re-batched or re-dispatched
+ *   (`keepLandedAndSplit`): they stay landed on the integration branch, and
+ *   only the unvalidated members are split into half-batches. When the rebase
+ *   onto the new base succeeded (red suite) the gate re-runs over the landed
+ *   members (`validating` — the shape of #822's `sched resume --batch`);
+ *   otherwise the batch blocks `dissolve-refused:<reason>` for an operator.
  */
 function handlePrConflict(state, batchId, deps, opts = {}) {
     const now = clock(deps);
@@ -1065,8 +1209,20 @@ function handlePrConflict(state, batchId, deps, opts = {}) {
     if (batch.status !== 'rebasing') {
         next = (0, state_1.transitionBatch)(next, batchId, 'rebasing', {}, now);
     }
-    /** Every give-up path here ends the same way: halve the batch, keep the work. */
+    /**
+     * Every give-up path here ends the same way: keep the work. Validated
+     * members stay landed (#840); everything else is halved.
+     */
     const bailToHalves = (from, bailReason, rebased = false, suite = null) => {
+        const { validated } = classifyDissolveMembers(from, batchOrThrow(from, batchId));
+        if (validated.length > 0) {
+            return keepLandedAndSplit(from, batchId, deps, {
+                reason: bailReason,
+                validated,
+                rebased,
+                suite,
+            });
+        }
         const dissolve = dissolveBatch(from, batchId, { strategy: 'halved', reason: bailReason, milestonePhase: 'batch-ship' }, deps);
         return { state: dissolve.state, action: 'dissolved', rebased, suite, dissolve };
     };
@@ -1126,4 +1282,98 @@ function handlePrConflict(state, batchId, deps, opts = {}) {
     }, now);
     return { state: next, action: 'reship', rebased: true, suite };
 }
+/**
+ * #840: `handlePrConflict`'s give-up path when VALIDATED members exist. They
+ * are never re-batched or re-dispatched: they stay in this batch, landed on
+ * its integration branch. Only the unshipped, unvalidated members leave — split
+ * into half-batches exactly as a `halved` dissolve would, and trimmed out of
+ * this batch (with their groups/ranges, like `preserveSurvivors`). Then:
+ *
+ * - `rebased` (the rebase onto the new base worked, the suite is red) →
+ *   `re-validating → validating` with `executing_member` pinned to the end,
+ *   so the engine re-runs the gate over the landed members and attributes /
+ *   evicts on the ordinary rail — the same shape as `sched resume --batch`.
+ * - otherwise (rebase conflict, failed fetch, a recurred conflict, …) → the
+ *   batch BLOCKS `dissolve-refused:<reason>`: the landed work waits for an
+ *   operator — resolve the conflict on the recorded PR by hand
+ *   (`reconcileStaleBlockedBatches` settles the batch once it merges), or
+ *   close that PR and `sched resume --batch` (which refuses while a PR is
+ *   recorded), or `sched abandon --batch`.
+ *
+ * Library behaviour: the engine does not yet route a conflicting batch PR
+ * here (#867).
+ */
+function keepLandedAndSplit(state, batchId, deps, ctx) {
+    const now = clock(deps);
+    const batch = batchOrThrow(state, batchId);
+    const { unshipped } = classifyDissolveMembers(state, batch);
+    // A member with a recorded range has commits ON the integration branch this
+    // batch keeps — splitting it off would ship its code here AND re-run it in
+    // a half. It stays (not validated, so the tail never names it; the re-run
+    // gate or the operator decides it). Only unlanded, unvalidated members go.
+    const landed = new Set(batch.ranges.map((r) => r.issue));
+    const toSplit = unshipped.filter((issue) => !ctx.validated.includes(issue) && !landed.has(issue));
+    const evidence = (0, state_1.memberExitEvidence)(batchId, ctx.reason, null, now);
+    const split = splitIntoHalves(state, batch, toSplit, ctx.reason, evidence, now);
+    let next = split.state;
+    if (split.newBatches.length > 0) {
+        journal(deps, (0, journal_1.unitEvent)('batch-split', `batch:${batchId}`, {
+            detail: `${split.newBatches.join(',')} — unvalidated member(s) ${toSplit.join(',')} only; validated ${ctx.validated.join(',')} stay landed`,
+        }), now);
+    }
+    const kept = batch.members.filter((issue) => !toSplit.includes(issue));
+    next = (0, state_1.patchBatch)(next, batchId, {
+        members: kept,
+        eviction_groups: batch.eviction_groups
+            .map((group) => group.filter((m) => kept.includes(m)))
+            .filter((group) => group.length > 1),
+        ranges: batch.ranges.filter((r) => kept.includes(r.issue)),
+        executing_member: kept.length,
+    }, now);
+    const dissolve = {
+        state: next,
+        requeued: split.requeued,
+        preserved: ctx.validated,
+        newBatches: split.newBatches,
+        parked: [],
+        blocked: !ctx.rebased,
+        validated: ctx.validated,
+    };
+    if (ctx.rebased) {
+        next = (0, state_1.transitionBatch)(next, batchId, 'validating', {}, now);
+        journal(deps, (0, journal_1.unitEvent)('batch-regate', `batch:${batchId}`, {
+            detail: `${ctx.reason} — gate re-runs over landed member(s) ${ctx.validated.join(',')} on the rebased branch; split=${split.newBatches.join(',') || 'none'}`,
+        }), now);
+        return {
+            state: next,
+            action: 'regate',
+            rebased: true,
+            suite: ctx.suite,
+            dissolve: { ...dissolve, state: next },
+        };
+    }
+    const blockedReason = `${exports.DISSOLVE_REFUSED_PREFIX}${ctx.reason}`;
+    next = (0, state_1.transitionBatch)(next, batchId, 'blocked', { blocked_reason: blockedReason }, now);
+    journal(deps, (0, journal_1.unitEvent)('batch-blocked', `batch:${batchId}`, {
+        detail: `${blockedReason} — validated member(s) ${ctx.validated.join(',')} stay landed on ${batch.branch ?? 'the integration branch'}; split=${split.newBatches.join(',') || 'none'}`,
+    }), now);
+    post(deps, batchOrThrow(next, batchId), {
+        phase: 'batch-ship',
+        status: 'blocked',
+        kv: {
+            reason: blockedReason,
+            dissolved: 'false',
+            validated: ctx.validated.join(','),
+            requeued: split.requeued.join(',') || 'none',
+            ...(split.newBatches.length > 0 ? { split_into: split.newBatches.join(',') } : {}),
+        },
+    }, now);
+    return {
+        state: next,
+        action: 'blocked',
+        rebased: false,
+        suite: ctx.suite,
+        dissolve: { ...dissolve, state: next },
+    };
+}
 //# sourceMappingURL=recovery.js.map