@feigi/fleet-ctl 3.80.2 → 3.81.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feigi/fleet-ctl",
-  "version": "3.80.2",
+  "version": "3.81.1",
   "description": "Agent fleet: run-team controller, merge bot, PR reviewer, and the ticket pipeline they share",
   "license": "Apache-2.0",
   "repository": {

package/scripts/fleet-tick.mjs

@@ -51,14 +51,17 @@
 //             GitHub's `mergeable` — the merge queue, which PRs are owed a
 //             review, which conflict, and the PR half of the In-flight count:
 //             every open PR that closes an issue, whoever opened it and
-//             whatever its state. Also, for each ticket holding the
-//             implementer row on a tier mismatch or owed a replacement,
-//             whether its issue is CLOSED (`gh issue view`): a closed
-//             ticket's mismatch holds nothing and its owed replacement is not
-//             in flight. And, for each in-flight `review=` token whose PR
-//             the open list does not carry, whether that PR is MERGED or
-//             CLOSED (`gh pr view`): a review cannot be running against a
-//             finished PR, so its dangling token is not a review unit.
+//             whatever its state. Also, for each in-flight `review=` token
+//             whose PR the open list does not carry, and for each ticket's
+//             latest settled `impl-*=PR#<M>` PR the open list does not carry,
+//             that PR's state (`gh pr view`, once per PR): a review cannot
+//             be running against a finished PR, so its dangling token is not
+//             a review unit, and a PR CLOSED unmerged prints an ESCALATE line
+//             for its ticket. And, for each ticket holding the implementer
+//             row on a tier mismatch, owed a replacement, or whose keyed PR
+//             read CLOSED or unread, whether its issue is CLOSED (`gh issue
+//             view`): a closed ticket's mismatch holds nothing, its owed
+//             replacement is not in flight, and its PR prints no line.
 //   main      The main checkout against the run-start baseline
 //             `.fleet/main-checkout.sha`, through main-checkout.mjs.
 //             Anything but `clean` — dirty, unknown, no baseline — prints one
@@ -146,16 +149,38 @@ export function reconcile(s) {
   const rev = reviewers(s);
   // The conflict rows only ask the controller to write a record — never to
   // dispatch — so they stand outside the dispatch hold: the fix-applier a
-  // conflict hold leads to obeys the hold through its own role's row.
+  // conflict hold leads to obeys the hold through its own role's row. The
+  // closed-PR rows dispatch nothing either.
   return [
     ...dispatchHold(s, [...implementers(s), ...rev.rows]),
     ...rev.conflictRows,
+    ...prClosedRows(s),
     ...dispatchHold(s, [mergeBot(s)]),
     ...shortlistRows(s),
     ...routerRows(s),
   ];
 }
 
+// A ticket whose PR closed unmerged while its issue stays open: unknown
+// intent, so the line is the maintainer's and not actionable. One line per
+// ticket, beside the implementer row and never in it — it takes no slot and
+// counts toward no bound. While a member on PR M is live the line names it:
+// nothing resolves the ticket until that member settles. A state probe that
+// could not answer prints its own line, and the next tick probes again.
+function prClosedRows(s) {
+  const live = (k) => (k.live.length ? ` — ${k.live.join(", ")} live` : "");
+  return [
+    ...s.prClosed.map((k) => ({
+      role: "tickets", action: `ESCALATE pr-closed #${k.n} PR#${k.pr}${live(k)}`, acts: false,
+      detail: `PR#${k.pr} closed unmerged and #${k.n} is open: the maintainer's — dispatch nothing for #${k.n}`,
+    })),
+    ...s.prUnchecked.map((k) => ({
+      role: "tickets", action: `ESCALATE pr-unchecked #${k.n} PR#${k.pr}`, acts: false,
+      detail: `gh could not read PR#${k.pr}'s state; read again next tick`,
+    })),
+  ];
+}
+
 // A main checkout changed since the run's baseline — or one the tick
 // could not compare — holds every DISPATCHING row: one HOLD per role,
 // keeping its counts, in place of whatever it would have dispatched. Placed
@@ -919,7 +944,10 @@ export function foldLedger({ rows, dispatched }, open, { lenient = false } = {})
 export const pastPinDue = (st, head) => st !== undefined && st.pastPinHalt && !st.inFlight && st.reviewedHead !== null
   && !String(head).toLowerCase().startsWith(st.reviewedHead);
 
-export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed = new Set(), finished = new Set()) {
+// The states `gh pr view --json state` answers: anything else is no answer.
+const PR_STATES = ["OPEN", "MERGED", "CLOSED"];
+
+export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed = new Set(), prStates = new Map()) {
   const open = new Set(prs.map((p) => p.number));
   const { members, byPr, verdicts, claimed, excluded } = foldLedger({ rows, dispatched }, open);
   // `## Retired` lines as every reader reads them: a line's name before its
@@ -951,6 +979,41 @@ export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed
   // A still-open ticket keeps its hold.
   const mismatched = (m) => m.outcome === "tier-mismatch" || verdicts.mismatch.has(m.name);
   const tierMismatch = newest.filter((m) => mismatched(m) && !closed.has(m.number)).map((m) => m.name);
+  // A ticket whose PR closed unmerged. Each ticket is keyed on its LATEST impl
+  // member settled `PR#<M>`, walked the way `newest` is — never on rowPr(),
+  // which stays first-wins for the per-PR fold — and left alone while an impl
+  // member after that one is live (a replacement is running) or once one
+  // after it settled `released` (the claim was released). A later `bailed`,
+  // `blocked` or `killed` leaves the key on M. So does a later
+  // `tier-mismatch`, but the ticket says nothing while the implementer row
+  // holds on that mismatch: the row owes the replacement at its tier — the
+  // maintainer's `replace` carried on — and holds every Pull until it is
+  // dispatched, so a line saying to dispatch nothing for the ticket would
+  // stall it. Once that replacement settles the walk reads it like any other.
+  // A mismatch on the keyed member itself is no replacement of M and still
+  // prints. A keyed PR the open list carries is normal flow; one it does not
+  // is named in `prKeyed` for the caller's state probe, `prStates` its
+  // answers (null for a probe that could not answer, none by default).
+  // CLOSED escalates, an unanswered probe escalates as unchecked, OPEN and
+  // MERGED say nothing, and a ticket whose issue the caller found CLOSED
+  // (`closed`) says nothing either way.
+  const settledPr = (m) => (m.outcome?.startsWith("PR#") ? Number(m.outcome.slice("PR#".length)) : null);
+  const supersedes = (o) => settledPr(o) !== null || o.outcome === null || o.outcome === "released";
+  const latestPr = impls.filter((m, i) => settledPr(m) !== null
+    && !impls.some((o, j) => j > i && o.number === m.number && supersedes(o)));
+  const keyed = new Set(latestPr.map((m) => m.name));
+  const replacementHeld = new Set(newest.filter((m) => tierMismatch.includes(m.name) && !keyed.has(m.name)).map((m) => m.number));
+  const prKeyed = latestPr.filter((m) => !replacementHeld.has(m.number)).map((m) => ({ n: m.number, pr: settledPr(m) }))
+    .filter((k) => !open.has(k.pr)).sort((a, b) => a.n - b.n);
+  const prSurfaced = prKeyed.filter((k) => !closed.has(k.n));
+  // Who on PR M is live: an unsettled fix-applier or finisher bound to it, and
+  // a live merge bot when M's latest finisher attempt settled `labelled` with
+  // no `label-off=` after it — the ledger's reading of M in the merge queue.
+  const queuedOnLedger = new Set(latestFinisherAttempts({ rows, dispatched }, new Set(prSurfaced.map((k) => k.pr)))
+    .filter((u) => u.outcome === "labelled").map((u) => u.pr));
+  const liveOn = (pr) => all.filter((m) => m.outcome === null
+    && (((m.family === "fix-pr" || m.family === "finisher-pr") && m.number === pr) || (m.family === "merge-bot" && queuedOnLedger.has(pr))))
+    .map((m) => m.name).sort();
   const cleared = (m) => verdicts.ok.has(m.name) || verdicts.unverifiable.has(m.name);
   const tierUnchecked = newest.filter((m) => !mismatched(m) && !cleared(m)).map((m) => m.name);
   // The In-flight count: tickets between a Claim and their PR's merge. Read off
@@ -1005,12 +1068,13 @@ export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed
   // A `review=` token with no `reviewed=` after it reads as in flight, and the
   // ledger alone never says otherwise: a review whose own `reviewed=` write
   // never landed stays in flight after its PR merges, counting as a review unit
-  // for good. `finished` is the PR numbers the caller has found MERGED or
-  // CLOSED, and a finished PR has no review running against it. A PR on the
-  // open list is open whatever `finished` says, and none is the default, so a
+  // for good. A PR the caller's probe found MERGED or CLOSED (`prStates`) is
+  // finished, and a finished PR has no review running against it. A PR on the
+  // open list is open whatever the probe says, and none is the default, so a
   // PR nobody has asked about keeps its review live.
   const reviewing = [...byPr.entries()].filter(([, st]) => st.inFlight);
-  const liveReviews = reviewing.filter(([n]) => open.has(n) || !finished.has(n));
+  const finished = (n) => prStates.get(n) === "MERGED" || prStates.get(n) === "CLOSED";
+  const liveReviews = reviewing.filter(([n]) => open.has(n) || !finished(n));
   const unsettled = all.filter((m) => m.outcome === null).map((m) => m.name);
   return {
     implLive: live("impl"),
@@ -1019,6 +1083,15 @@ export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed
     inFlightPrs: prsIn.length,
     owedReplacement,
     owedCounted,
+    // Each ticket's keyed PR the open list does not carry, `{n, pr}` ascending
+    // by ticket: the PRs the caller probes the state of.
+    prKeyed,
+    // The tickets whose keyed PR the probe read CLOSED, each with `live`, the
+    // members on PR M still unsettled; and those whose probe did not answer.
+    // Additive lines beside the implementer row: neither counts toward
+    // anything above.
+    prClosed: prSurfaced.filter((k) => prStates.get(k.pr) === "CLOSED").map((k) => ({ ...k, live: liveOn(k.pr) })),
+    prUnchecked: prSurfaced.filter((k) => !PR_STATES.includes(prStates.get(k.pr))),
     fixLive: live("fix-pr"),
     mergeBotLive,
     // The number of every merge bot settled `done`: each is a merge pass
@@ -1026,7 +1099,7 @@ export function deriveRun({ rows, dispatched, drain, retired = [] }, prs, closed
     mergeBotDone: all.filter((m) => m.family === "merge-bot" && m.outcome === "done").map((m) => m.number).sort(asc),
     reviewsLive: liveReviews.length,
     // The in-flight reviews of PRs the open list does not carry: the ones
-    // `finished` could retire, so the caller asks gh about these and no others.
+    // the probe could retire, so the caller asks gh about these and no others.
     reviewsOffList: reviewing.filter(([n]) => !open.has(n)).map(([n]) => n).sort(asc),
     // A returned review whose survived or unverified findings no review
     // fix-applier has answered — `ledger.mjs dispatch` refuses a finisher
@@ -1687,21 +1760,27 @@ function liftedPremise(excluded, entries, prs) {
 }
 
 // The tickets whose issue is CLOSED, of those the tick would otherwise keep
-// counting or holding on: every ticket holding the implementer row on a tier
-// mismatch, and every ticket owed a replacement. One live read deriveRun needs
-// to lift a hold, and uncount a ticket, whose replacement has nothing left to
-// replace. One `gh issue view` per ticket, deduped (a tier-mismatch outcome is
+// counting, holding on or escalating: every ticket holding the implementer row
+// on a tier mismatch, every ticket owed a replacement, and every ticket whose
+// keyed PR the state probe read CLOSED or could not read (`surfacing`). One
+// live read deriveRun needs to lift a hold, uncount a ticket whose replacement
+// has nothing left to replace, and drop a closed-PR line for a ticket that is
+// done. One `gh issue view` per ticket, deduped (a tier-mismatch outcome is
 // both), and none when nothing is owed. A probe that cannot answer — a nonzero
 // exit, or a reply carrying no issue state — is disclosed, and the ticket
-// stays counted and its hold stands: an unreadable state never uncounts.
-function closedTickets(mismatched, owed) {
+// stays counted, its hold stands and its line prints: an unreadable state
+// never uncounts.
+function closedTickets(mismatched, owed, surfacing) {
   const closed = new Set();
   const mismatchedNumbers = new Set(mismatched.map((name) => parseMember(name).number));
-  const numbers = new Set([...mismatchedNumbers, ...owed.map((name) => parseMember(name).number)]);
+  const owedNumbers = new Set(owed.map((name) => parseMember(name).number));
+  const numbers = new Set([...mismatchedNumbers, ...owedNumbers, ...surfacing]);
   for (const number of numbers) {
     const unconfirmed = mismatchedNumbers.has(number)
       ? `tier mismatch on #${number} unconfirmed closed, hold stands`
-      : `replacement owed on #${number} unconfirmed closed, ticket stays counted`;
+      : owedNumbers.has(number)
+        ? `replacement owed on #${number} unconfirmed closed, ticket stays counted`
+        : `#${number} unconfirmed closed, its closed-PR line stands`;
     const r = spawnSync("gh", ["issue", "view", String(number), "--json", "state"], { encoding: "utf8", timeout: GH_TIMEOUT_MS, env: gitEnv({ GH_REPO: "" }) });
     if (r.error || r.status !== 0) {
       console.error(`${NAME}: ${failure(r, `gh issue view ${number}`)} — ${unconfirmed}`);
@@ -1719,29 +1798,36 @@ function closedTickets(mismatched, owed) {
   return closed;
 }
 
-// The PRs, of those whose review the ledger reads as in flight yet the open
-// list does not carry, that gh says are MERGED or CLOSED. A review cannot be
-// running against a finished PR, so the ledger's dangling `review=` token must
-// not count as a review unit for good. A probe that cannot answer — a nonzero
-// exit, a reply carrying no state, a state that is none of the three — is
-// disclosed and the review keeps its unit: an unreadable state is never read
-// as finished. A PR gh calls OPEN keeps it quietly.
-function finishedReviewPrs(offList) {
-  const finished = new Set();
-  for (const number of offList) {
+// The state of each PR the tick asks gh about, one `gh pr view --json state`
+// per PR however many readings need it: `reviews`, the PRs whose review the
+// ledger reads as in flight yet the open list does not carry, and `keyed`,
+// each ticket's keyed PR the open list does not carry (deriveRun's
+// `prKeyed`). The answer is OPEN, MERGED or CLOSED, or null for a probe that
+// could not answer — a nonzero exit, a reply carrying no state, a state that
+// is none of the three — which is disclosed with what it leaves standing.
+function prStates(reviews, keyed) {
+  const states = new Map();
+  const reviewed = new Set(reviews);
+  // Two tickets can be keyed on one PR: each is named, on its one probe.
+  const ticketsOf = new Map();
+  for (const k of keyed) ticketsOf.set(k.pr, [...(ticketsOf.get(k.pr) ?? []), k.n]);
+  for (const number of [...new Set([...reviews, ...ticketsOf.keys()])].sort((a, b) => a - b)) {
+    const unconfirmed = [
+      ...(reviewed.has(number) ? [`review on PR#${number} unconfirmed finished, its unit stands`] : []),
+      ...(ticketsOf.get(number) ?? []).map((n) => `#${n}'s PR#${number} unconfirmed closed, printed as pr-unchecked`),
+    ].join("; ");
+    states.set(number, null);
     const r = spawnSync("gh", ["pr", "view", String(number), "--json", "state"], { encoding: "utf8", timeout: GH_TIMEOUT_MS, env: gitEnv({ GH_REPO: "" }) });
     if (r.error || r.status !== 0) {
-      console.error(`${NAME}: ${failure(r, `gh pr view ${number}`)} — review on PR#${number} unconfirmed finished, its unit stands`);
+      console.error(`${NAME}: ${failure(r, `gh pr view ${number}`)} — ${unconfirmed}`);
       continue;
     }
     let st = null;
     try { st = JSON.parse(r.stdout).state; } catch { /* no state: disclosed below */ }
-    if (st === "MERGED" || st === "CLOSED") finished.add(number);
-    else if (st !== "OPEN") {
-      console.error(`${NAME}: gh pr view ${number} printed no PR state — review on PR#${number} unconfirmed finished, its unit stands`);
-    }
+    if (PR_STATES.includes(st)) states.set(number, st);
+    else console.error(`${NAME}: gh pr view ${number} printed no PR state — ${unconfirmed}`);
   }
-  return finished;
+  return states;
 }
 
 // shortlist.mjs, run by the tick itself. Its per-ticket stderr is
@@ -1885,15 +1971,21 @@ export function controllerState(controller, name = NAME) {
   }
 }
 
-// The run off the ledger, with the closed tickets and finished reviews gh
-// says the ledger cannot. A ledger it cannot read refuses the tick.
+// The run off the ledger, with the closed tickets, finished reviews and keyed
+// PR states gh says the ledger cannot. A review cannot be running against a
+// MERGED or CLOSED PR, so its dangling `review=` token stops counting as a
+// review unit; an unread state is never read as finished. The issue probe asks
+// only about the tickets whose keyed PR read CLOSED or could not be read: OPEN
+// and MERGED print nothing whatever the issue says. A ledger it cannot read
+// refuses the tick.
 function readRun(prs) {
   try {
     const ledger = readLedger();
     const run = deriveRun(ledger, prs);
-    const closed = closedTickets(run.tierMismatch, run.owedReplacement);
-    const finished = finishedReviewPrs(run.reviewsOffList);
-    return closed.size || finished.size ? deriveRun(ledger, prs, closed, finished) : run;
+    const states = prStates(run.reviewsOffList, run.prKeyed);
+    const surfacing = run.prKeyed.filter((k) => states.get(k.pr) !== "OPEN" && states.get(k.pr) !== "MERGED").map((k) => k.n);
+    const closed = closedTickets(run.tierMismatch, run.owedReplacement, surfacing);
+    return deriveRun(ledger, prs, closed, states);
   } catch (e) {
     if (e instanceof LedgerError) die(e.message);
     throw e;

package/scripts/stranded.mjs

@@ -18,7 +18,13 @@
 // be read, is `none`.
 //   dead      every open in-progress issue with no open PR: `resume` when
 //             exactly one worktree for it sits under this checkout's
-//             `.worktrees/` and its directory is there, `report` otherwise
+//             `.worktrees/` and its directory is there, `report` otherwise.
+//             That worktree's branch is listed first, every PR state: every
+//             one CLOSED unmerged — none OPEN, none MERGED — is `report` with
+//             `why` `PR #<M> closed unmerged` — an unmerged close is the
+//             maintainer's to rule on — and a list that does not answer, or a
+//             detached worktree whose branch cannot be asked about, is
+//             `report` too, never `resume`.
 //   ancestor  this session's earlier run: no claim listed — its members may
 //             still be live, and rotate carried their tokens forward;
 //             `carried` lists them instead, for the controller to reconcile
@@ -95,6 +101,30 @@ function ghList(what, args) {
   return rows;
 }
 
+// The PRs a claim's branch opened, every state: `{closed}`, the highest PR
+// number when every one of them is CLOSED unmerged — none OPEN, none MERGED,
+// at least one — else null; or `{failed}`, why the list did not answer. Never
+// a refusal of the step: an unanswered list leaves this one claim unresumed,
+// and the others classify.
+function closedHeadPr(branch) {
+  const r = spawnSync("gh", ["pr", "list", "--state", "all", "--head", branch, "--json", "number,state", "--limit", String(LIMIT)], {
+    encoding: "utf8", maxBuffer: MAX_BUFFER, timeout: GH_TIMEOUT_MS, env: gitEnv({ GH_REPO: "" }),
+  });
+  if (r.error || r.status !== 0) return { failed: how(r) };
+  let rows;
+  try {
+    rows = JSON.parse(r.stdout);
+  } catch (e) {
+    return { failed: `unparsable: ${e.message}` };
+  }
+  if (!Array.isArray(rows) || !rows.every((p) => Number.isInteger(p?.number) && ["OPEN", "CLOSED", "MERGED"].includes(p.state))) {
+    return { failed: "not a list of {number, state}" };
+  }
+  if (rows.length >= LIMIT) return { failed: `at its cap of ${LIMIT}` };
+  const closed = rows.length > 0 && rows.every((p) => p.state === "CLOSED");
+  return { closed: closed ? Math.max(...rows.map((p) => p.number)) : null };
+}
+
 // Every registered worktree: its path, branch (null when detached) and
 // whether git calls it prunable — its directory gone.
 function worktrees(cwd) {
@@ -205,13 +235,21 @@ function main() {
     const inside = mine.filter((w) => real(dirname(w.path)) === home);
     const outside = mine.filter((w) => !inside.includes(w));
     const one = inside.length === 1 ? inside[0] : null;
+    // A dead claim's branch that opened a PR: every one CLOSED unmerged is
+    // reported in place of the resume, and so is a branch whose PRs cannot be
+    // listed — or cannot be asked about at all, its worktree detached. A
+    // branch that never opened one resumes as before.
+    const head = prior === "dead" && one?.branch ? closedHeadPr(one.branch) : null;
     let why;
     if (prior !== "dead") why = "no record proves the previous run dead, so nothing is resumed";
+    else if (one && !one.branch) why = "its worktree is detached, so whether its branch opened a PR cannot be told — nothing is resumed";
+    else if (head?.failed) why = `gh pr list --head ${one.branch} did not answer (${head.failed}) — whether its branch opened a PR is unknown, so nothing is resumed`;
+    else if (head?.closed) why = `PR #${head.closed} closed unmerged`;
     else if (one) why = "its worktree is in this checkout";
     else if (inside.length > 1) why = `several worktrees for it in this checkout: ${inside.map((w) => w.path).join(", ")}`;
     else if (outside.length > 0) why = `its worktree is outside this checkout's .worktrees/: ${outside.map((w) => w.path).join(", ")}`;
     else why = "no worktree for it in this checkout";
-    const action = prior === "dead" && one && mentioned.length === 0 ? "resume" : "report";
+    const action = prior === "dead" && one?.branch && mentioned.length === 0 && !head?.failed && !head?.closed ? "resume" : "report";
     // Not taken for its PR — but never resumed past one that might be.
     if (mentioned.length > 0) why += `; ${mentioned.join(", ")} carries the number outside the ticket position, so check whether it is this claim's`;
     claims.push({ n: issue.number, t: issue.title, action, worktree: one?.path ?? null, branch: one?.branch ?? null, why });

package/skills/run-team/SKILL.md

@@ -74,13 +74,14 @@ phase, or in any later one, asks the maintainer which tickets to take.
      run `phase0.mjs` again. `RECIPE NOT PROVEN` → stall: report `STALL —
      Recipe not proven: <cause>` to the maintainer with the deriver's reason
      verbatim, and claim, Pull and review nothing.
-   - `NEED resume #<n> <worktree> <branch>` — a dead run's claim with no PR.
+   - `NEED resume #<n> <worktree> <branch>` — a dead run's claim: no PR, or not only `CLOSED` ones.
      Dispatch a stranded `impl-<n>-b` the ordinary way (record it with
      `ledger.mjs row`, render its brief, `ledger.mjs dispatch`, the `task`
      call, the tier check), in that worktree and branch, and never with
      `claim-ticket.sh`: the claim stands. A re-run finds the need met once its
      row is written. A `report #<n> — <why>` line is the maintainer's and
      nothing else, and a `carried` line is a live token to reconcile first.
+     A closed-PR `report` takes `replace`/`release #<n>`.
    - `NEED review PR#<pr> (closes no issue)` — an open PR a prior run left
      that no row can queue. Advice, never an exit status: hand-dispatch its
      review exactly as ticket work, or leave it.
@@ -273,6 +274,7 @@ depth** guard table applied in code. Act on each line as it reads:
 - `ESCALATE unlabelled PR#<M> …` — a second finisher settled `labelled` and the label is still off: not actionable, the maintainer's.
 - `CONFLICT PR#<M> …` — record the hold with `fleet-event.mjs conflict <M>`, never with the `ledger.mjs row` form; the tick then prints `DISPATCH fix-pr`.
 - `ESCALATE conflict PR#<M> …` — PR M reads CONFLICTING again after two conflict fix-appliers: comment on the PR and flag it for a human, write no hold, dispatch no fix-applier.
+- `ESCALATE pr-closed #<N> PR#<M>`, `… pr-unchecked …` — the maintainer's: tell them once per ticket per run; no dispatch or comment for #N. Reopening M or closing #N clears it. Only `replace #N` (`NEED resume`, same row) or `release #N` (closed-PR `release-ticket.sh --apply`, settle `released`) acts, once no live member names M.
 - `HOLD (…)` — the row is held and its detail names the clearing step: dispatch nothing on that row until it clears; a tier mismatch is yours to clear by dispatching the replacement.
 - `AT CAP`, `IDLE OK` — nothing to do on that row.
 - `MAIN-CHECKOUT-DIRTY …` — dispatch nothing new and tell the maintainer; once they have resolved the paths, `main-checkout.mjs --record`; never revert the paths or re-baseline over them yourself.
@@ -1218,13 +1220,8 @@ Names follow the unit of work: `impl-<issue#>`, `fix-pr-<pr#>`,
 `review-pr-<pr#>`, `finisher-pr-<pr#>`, `merge-bot-<n>`. See
 references/member-lifecycle.md.
 
-**Fresh context per member.** One member, one unit of work, gone. Never
-re-task a finished member — waking it drags the old ticket back in. Refill =
-**new** member, **new** name. Sending is still right for pinging a live
-member for a report it owes, or resuming a truncated reply — never for
-handing a finished member the next ticket.
-
-`hub send` to an idle peer wakes it into its old transcript the same way; re-dispatching under the same name does not reset it — omp auto-suffixes a fresh peer (`name-2`) instead.
+**Fresh context per member.** One member, one unit of work, gone. Refill =
+**new** member, **new** name.
 
 See references/member-lifecycle.md.
 

package/skills/run-team/references/phase-0.md

@@ -389,7 +389,12 @@ token, row}]}`:
 
 - `prior: dead` — every open `in-progress` issue with no open PR (one with
   an open PR is the fold-in's): `resume` when exactly one worktree for it
-  sits under this checkout's `.worktrees/`, `report` otherwise.
+  sits under this checkout's `.worktrees/`, `report` otherwise. That
+  worktree's branch is asked `gh pr list --state all --head <branch>` first:
+  PRs that all read CLOSED unmerged — none OPEN, none MERGED — make it
+  `report` with `why` `PR #<M> closed unmerged`, and so does a list that
+  does not answer, or a detached worktree whose branch cannot be asked
+  about, never `resume`.
 - `prior: ancestor` — this session's own earlier run: no claim is listed.
   `carried` lists every live token rotate carried — its member or runner
   `name` (a `review=wf:` launch's runId), the `token` as the ledger holds
@@ -428,7 +433,10 @@ impl-<N>-b …`, then `ledger.mjs dispatch <N> impl-<N>-b`, then the `task`
 call naming the `agent` it printed, then the tier check — and never
 `claim-ticket.sh`: the claim already stands. A `report` goes to the
 maintainer as `#<N> — <why>` and nothing else: no dispatch, no label change,
-no release. Exit 2 is a list that did not answer — a `gh` or `git`
+no release. One whose `why` reads `PR #<M> closed unmerged` waits on the
+maintainer's `replace #<N>` or `release #<N>`, the two words the tick's
+`ESCALATE pr-closed` line takes (references/tick-rows.md), and on nothing
+else. Exit 2 is a list that did not answer — a `gh` or `git`
 failure, a list at its cap, a worktree whose presence cannot be told, or,
 after `ancestor`, a ledger that cannot be read — and is never nothing
 stranded.

package/skills/run-team/references/tick-rows.md

@@ -60,6 +60,41 @@ The full text of each row `fleet-tick.mjs` prints and what it asks of the contro
   and flag it for a human; write no hold and dispatch no fix-applier. Not
   actionable; it repeats while the PR reads CONFLICTING and clears once it
   stops, closes or merges.
+- `ESCALATE pr-closed #<N> PR#<M>` — PR M, ticket N's latest PR (the latest
+  `impl-<N>…=PR#<M>` on the row), is CLOSED unmerged while issue #N is not
+  read CLOSED (an issue gh cannot read counts as open), and no
+  `impl-<N>-<x>` after it is live or settled `released`. An unmerged
+  close is unknown intent, so the line is the maintainer's and not
+  actionable: tell the maintainer once per ticket per run, dispatch nothing
+  for #N, and post no GitHub comment. It prints beside the implementer row,
+  never in it, takes no implementer slot and counts toward no bound. While a
+  member on PR M is live — `fix-pr-<M>…`, `finisher-pr-<M>…`, or a live
+  `merge-bot-<n>` while M's latest finisher settled `labelled` with no
+  `label-off=` after it — the line ends ` — <member> live`. Reopening PR M,
+  or closing #N, clears it by itself on the next tick. Act only on the
+  maintainer's `replace #N` or `release #N`, and only once the line names no
+  live member:
+  - `replace #N` — the `NEED resume` procedure (phase 0): `impl-<N>-b`, or
+    one letter past the highest `impl-<N>-<x>` the ticket has used, in the
+    existing worktree and branch, never `claim-ticket.sh`. Its new PR settles
+    onto the same row, and that two-PR row is a legitimate shape: the tick
+    keys the row on the newer PR from then on.
+  - `release #N` — `release-ticket.sh <N> impl-<N> implementer --apply`,
+    which runs its closed-PR mode on a branch whose PRs all read CLOSED, then
+    settle `released`: `ledger.mjs row <N> "<text> · impl-<N>-<x>"`, the next
+    letter, and `ledger.mjs settle impl-<N>-<x> released`, which ends the
+    line.
+
+  A replacement that settles `bailed`, `blocked` or `killed` brings the line
+  back on M, and one whose own PR M′ closes unmerged prints it on M′. One the
+  implementer row holds on a tier mismatch (`HOLD (tier mismatch …)`) keeps
+  the line off while that row asks for the next replacement — the `replace`
+  carried on at the right tier — and once that one settles, the line reads it
+  the same way. A tier mismatch on the member that settled `PR#<M>` itself
+  replaces nothing, so the line stands beside that hold.
+- `ESCALATE pr-unchecked #<N> PR#<M>` — the same ticket, but `gh pr view
+  <M>` could not answer, so whether M closed is unknown. The maintainer's on
+  the same terms as `pr-closed`; the next tick probes again.
 - `HOLD (…)` — the row is held and says why: draining, a tier mismatch, an
   unchecked tier, the In-flight bound reached (`HOLD (in-flight <n>/<B>)` —
   nothing to do unless its detail names a replacement to dispatch, else a