@tablation/crew 0.79.9 → 0.80.0

package/dist/cli.js

@@ -2981,9 +2981,11 @@ function describeRelease(o, route) {
       level: "fail",
       headline: `${route}: release blocked \u2014 tests failed`,
       detail: withHookTail(
-        o.composition ? `the target stays on the previous release
+        (o.composition ? `the target stays on the previous release
 
-${describeComposition(o.composition)}` : "the target stays on the previous release",
+${describeComposition(o.composition)}` : "the target stays on the previous release") + (o.isolation ? `
+
+${o.isolation}` : ""),
         o.hookFailure
       ),
       ...o.composition ? { head: o.composition.head } : {}
@@ -3013,7 +3015,9 @@ ${describeComposition(o.composition)}` : "the target stays on the previous relea
     return {
       level: "fail",
       headline: `${route}: build FAILED`,
-      detail: withHookTail("the target stays on the previous release \u2014 nothing was deployed", o.hookFailure)
+      detail: withHookTail(`the target stays on the previous release \u2014 nothing was deployed${o.isolation ? `
+
+${o.isolation}` : ""}`, o.hookFailure)
     };
   }
   if (o.blockedCycles && o.blockedCycles >= 2) {
@@ -4326,7 +4330,7 @@ function reconcileHeldWorktrees(state, repo, log, stillRefused) {
   }
 }
 function openShipAttention(state, nowMs = Date.now()) {
-  const stale = staleRelease(state.releaseHeartbeat().at(), nowMs);
+  const stale = state.releaseInProgress() ? null : staleRelease(state.releaseHeartbeat().at(), nowMs);
   const stored = state.shipAttention().previous();
   return stale ? [...stored, stale] : stored;
 }
@@ -5465,7 +5469,7 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
 import { join as join16 } from "path";
 
 // src/ticket-branch.ts
@@ -5476,7 +5480,7 @@ import { hostname } from "os";
 import { TablationClient } from "@tablation/client";
 
 // src/state.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4, readdirSync as readdirSync5 } from "fs";
 import { join as join13 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
@@ -5605,6 +5609,35 @@ var State = class _State {
       }
     };
   }
+  /**
+   * Whether a release is running right now: any `.release-<scope>.lock` in the
+   * state directory naming a live process (the locks `releasePhase` takes per
+   * scope). A lock naming a dead pid is ignored, as `acquire` ignores it.
+   */
+  releaseInProgress() {
+    let names;
+    try {
+      names = readdirSync5(this.dir);
+    } catch {
+      return false;
+    }
+    for (const n of names) {
+      if (!/^\.release-.+\.lock$/.test(n)) continue;
+      let pid = 0;
+      try {
+        pid = Number.parseInt(readFileSync12(this.path(n), "utf8").trim(), 10);
+      } catch {
+        continue;
+      }
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  }
   /**
    * Like `acquire`, but for a resource with `max` interchangeable slots
    * rather than one exclusive holder — this machine's overall concurrency
@@ -7519,7 +7552,7 @@ function listPendingHandoffs(stateDir, route) {
   const dir = pendingDirFor(stateDir);
   if (!existsSync15(dir)) return [];
   const out = [];
-  for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
+  for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
       const rec = JSON.parse(readFileSync13(join16(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route || rec.route === route)) out.push(rec);
@@ -7639,7 +7672,7 @@ function expandSkillMarkers(text, lookup, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync6, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync7, existsSync as existsSync17 } from "fs";
 import { join as join18 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
@@ -8138,7 +8171,7 @@ function parseSkillFile(path) {
 function listLocalSkills(promptsDir) {
   const dir = join18(promptsDir, "skills");
   if (!existsSync17(dir)) return [];
-  return readdirSync6(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join18(dir, f)));
+  return readdirSync7(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join18(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -9725,7 +9758,7 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync7, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync8, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname9, join as join22 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
@@ -9820,7 +9853,7 @@ function removeState(stateDir, dryRun) {
   const out = [];
   const targets = [join22(stateDir, "resolved"), join22(stateDir, "keys"), clonedCheckoutsFile(stateDir), join22(stateDir, "connect-session.json"), join22(stateDir, "reload-requested"), join22(stateDir, "daemon.started")];
   try {
-    for (const name of readdirSync7(stateDir)) {
+    for (const name of readdirSync8(stateDir)) {
       if (name.startsWith(".") && statSync6(join22(stateDir, name)).isFile()) targets.push(join22(stateDir, name));
     }
   } catch {
@@ -11282,7 +11315,7 @@ function planBuildFailureBounce(cwd, c, base, remote) {
   return { ...c, base, remote, worktree: worktreeForBranch(cwd, c.branch) };
 }
 function buildFailureComment(b) {
-  const how = b.how === "files" ? `The failing output names files that only \`${b.branch}\` changed among the branches in that release.` : `Built alone on the previous \`${b.base}\`, \`${b.branch}\` fails the same hook.`;
+  const how = b.how === "pair" && b.sibling ? `Each branch passes the hook alone; \`${b.branch}\` together with ${b.sibling.key} (\`${b.sibling.branch}\`) fails it. ${b.sibling.key} was verified first, so the fix belongs on this branch: \`git merge ${b.remote}/${b.sibling.branch}\` first, then fix what disagrees. Fix it on this branch, never a fresh one.` : b.how === "files" ? `The failing output names files that only \`${b.branch}\` changed among the branches in that release.` : `Built alone on the previous \`${b.base}\`, \`${b.branch}\` fails the same hook.`;
   return `${BUILD_FAILURE_MARKER}
 
 **Back with the dev lane \u2014 this branch builds on its own but not on current \`${b.base}\`.**
@@ -11297,8 +11330,46 @@ ${b.tail.trimEnd()}
 
 Nothing was written to \`${b.base}\` for this ticket; the rest of the release shipped without it.`;
 }
-async function applyBuildFailureBounce(writer, b, contract, memberId, log, dryRun) {
+function priorBuildFailures(ticket, events) {
+  const stamp = (e) => e.occurred_at ?? e.created_at ?? "";
+  const mine = events.filter((e) => e.record_id === ticket.id);
+  const pushes = mine.filter((e) => e.event_type === "pushed").map(stamp);
+  return mine.filter((e) => e.event_type === "build_failed" && pushes.some((p) => p > stamp(e))).length;
+}
+function buildFailureEscalation(b) {
+  return `${BUILD_FAILURE_MARKER}
+
+**Failed the release gate again after a hand-back \u2014 stopping rather than looping.**
+
+\`${b.branch}\` was handed back for breaking the \`${b.hook}\` hook, pushed, verified again, and breaks it once more. That is a call for a person, not another lap through the lanes.
+
+\`\`\`
+${b.tail.trimEnd()}
+\`\`\``;
+}
+async function applyBuildFailureBounce(writer, b, contract, memberId, log, dryRun, prior = { count: 0 }) {
   const t = { ticket: b.ticket.issue_id, step: "release" };
+  if (prior.count > 0) {
+    if (dryRun) {
+      log.emit(`would escalate to ${contract.statuses.needsHuman} \u2014 handed back for the ${b.hook} hook before`, t);
+      return { kind: "escalated" };
+    }
+    try {
+      await writer.updateTicket(
+        b.ticket.id,
+        { status: contract.statuses.needsHuman, ...prior.operatorId ? { assignee_id: prior.operatorId } : {} },
+        b.ticket.updated_at
+      );
+      await writer.postEvent(b.ticket.id, buildFailureEscalation(b), memberId, "build_failed_escalated").catch(() => {
+        log.warn("escalated, but the note failed to post", t);
+      });
+      log.warn(`breaks the ${b.hook} hook again after a hand-back \u2014 escalated to ${contract.statuses.needsHuman}`, t);
+      return { kind: "escalated" };
+    } catch (e) {
+      if (e instanceof StaleWriteError8) return { kind: "stale" };
+      return { kind: "failed", why: e.message };
+    }
+  }
   if (dryRun) {
     log.emit(`would hand ${b.ticket.issue_id} back to ${contract.statuses.building} \u2014 its branch breaks the ${b.hook} hook`, t);
     return { kind: "handed-back" };
@@ -11312,6 +11383,13 @@ async function applyBuildFailureBounce(writer, b, contract, memberId, log, dryRu
     await writer.postEvent(b.ticket.id, buildFailureComment(b), memberId, "build_failed").catch(() => {
       log.warn("handed back, but the note failed to post", t);
     });
+    await writer.postEvent(
+      b.ticket.id,
+      `${b.ticket.issue_tag ?? b.ticket.issue_id} left out of the release: ${b.hook} hook, found by ${b.how}${b.sibling ? `, together with ${b.sibling.key} (${b.sibling.branch})` : ""}`,
+      memberId,
+      "release_culprit"
+    ).catch(() => {
+    });
     log.emit(`handed back to ${contract.statuses.building} \u2014 breaks the ${b.hook} hook once merged with the rest`, t);
     return { kind: "handed-back" };
   } catch (e) {
@@ -12643,6 +12721,25 @@ async function runReleaseCycle(o, movedPast2, localRefSkips) {
     }
   }
 }
+var MAX_ISOLATE_PAIRS = 10;
+function pairOrder(n, max = MAX_ISOLATE_PAIRS) {
+  const pairs = [];
+  let truncated = false;
+  outer: for (let j = 1; j < n; j++) {
+    for (let i = 0; i < j; i++) {
+      if (pairs.length >= max) {
+        truncated = true;
+        break outer;
+      }
+      pairs.push([i, j]);
+    }
+  }
+  return { pairs, truncated };
+}
+function selfRepairLine(maxCandidates) {
+  const cap = maxCandidates ?? DEFAULT_ISOLATE_MAX_CANDIDATES;
+  return cap === 0 ? "culprit isolation is off (release.isolateFailures.maxCandidates: 0); a failed gate files an alert" : `culprit isolation up to ${cap} merged branches, ${MAX_ISOLATE_PAIRS} pairs before bisecting; a ticket handed back twice after a push escalates with an alert`;
+}
 var isolateCap = (o) => o.repo.release.isolateFailures?.maxCandidates ?? DEFAULT_ISOLATE_MAX_CANDIDATES;
 async function isolateAndRetry(o, name, output, merged, preMerge, decision, fresh, releaseBranch) {
   const applied = merged.filter((c) => c.sha && c.branch);
@@ -12667,13 +12764,13 @@ async function isolateAndRetry(o, name, output, merged, preMerge, decision, fres
     if (baseRun && baseRun.code !== 0) {
       o.emit.warn(`${name} fails on the base without ${only.branch} \u2014 not blaming the branch`, { ticket: only.ticket.issue_id });
       gitOk(o.cwd, ["reset", "--hard", head]);
-      return null;
+      return { tried: `Isolation found no culprit: the ${name} hook also fails on the base alone, without ${only.branch}, so there is no branch to hand back.` };
     }
     o.emit.warn(`${name} failed with only ${only.branch} merged and passes without it \u2014 treating it as the culprit`, { ticket: only.ticket.issue_id });
     culprits.push({ c: only, how: "solo", tail: lastLines(output, HOOK_FAILURE_TAIL_LINES) });
   } else if (applied.length > cap) {
     o.emit.warn(`${name} failed with ${applied.length} branches merged, over release.isolateFailures.maxCandidates (${cap}) \u2014 not isolating`);
-    return null;
+    return { tried: `Isolation was skipped: ${applied.length} branches were merged, over release.isolateFailures.maxCandidates (${cap}).` };
   } else {
     o.emit.warn(`${name} failed with ${applied.length} branches merged \u2014 building each alone to find the culprit`);
     for (const c of applied) {
@@ -12686,12 +12783,51 @@ async function isolateAndRetry(o, name, output, merged, preMerge, decision, fres
         culprits.push({ c, how: "solo", tail: lastLines(r.output, HOOK_FAILURE_TAIL_LINES) });
       }
     }
+    if (culprits.length === 0) {
+      const { pairs, truncated } = pairOrder(applied.length);
+      for (const [i, j] of pairs) {
+        gitOk(o.cwd, ["reset", "--hard", preMerge]);
+        const a = mergeOne(o, applied[i]);
+        const b = typeof a === "object" && "conflict" in a ? a : mergeOne(o, applied[j]);
+        if (typeof b === "object" && "conflict" in b) continue;
+        const r = await hook(o, name);
+        if (r && r.code !== 0) {
+          o.emit.warn(`${applied[j].branch} fails the ${name} hook together with ${applied[i].branch}`, { ticket: applied[j].ticket.issue_id });
+          culprits.push({ c: applied[j], how: "pair", sibling: applied[i], tail: lastLines(r.output, HOOK_FAILURE_TAIL_LINES) });
+          break;
+        }
+      }
+      if (culprits.length === 0 && truncated) {
+        let lo = 2, hi = applied.length;
+        let tail = lastLines(output, HOOK_FAILURE_TAIL_LINES);
+        while (lo < hi) {
+          const mid = Math.floor((lo + hi) / 2);
+          gitOk(o.cwd, ["reset", "--hard", preMerge]);
+          let clean = true;
+          for (const c of applied.slice(0, mid)) {
+            const m = mergeOne(o, c);
+            if (typeof m === "object" && "conflict" in m) {
+              clean = false;
+              break;
+            }
+          }
+          const r = clean ? await hook(o, name) : null;
+          if (r && r.code !== 0) {
+            hi = mid;
+            tail = lastLines(r.output, HOOK_FAILURE_TAIL_LINES);
+          } else lo = mid + 1;
+        }
+        const owner = applied[hi - 1];
+        o.emit.warn(`${owner.branch} is the first branch whose prefix fails the ${name} hook (bisected over ${applied.length})`, { ticket: owner.ticket.issue_id });
+        culprits.push({ c: owner, how: "pair", sibling: applied[hi - 2], tail });
+      }
+    }
   }
   gitOk(o.cwd, ["reset", "--hard", preMerge]);
   if (culprits.length === 0) {
     o.emit.warn("no single branch could be blamed \u2014 failing the release as a whole");
     gitOk(o.cwd, ["reset", "--hard", head]);
-    return null;
+    return { tried: `Isolation found no culprit: each of the ${applied.length} merged branches passes the ${name} hook alone and no pair among them fails it.` };
   }
   const out = new Set(culprits.map((x) => x.c.ticket.id));
   const rest = decision.merges.filter((c) => !out.has(c.ticket.id));
@@ -12703,7 +12839,8 @@ async function isolateAndRetry(o, name, output, merged, preMerge, decision, fres
       branch: x.c.branch,
       hook: name,
       tail: x.tail,
-      how: x.how
+      how: x.how,
+      ...x.sibling ? { sibling: { key: x.sibling.ticket.issue_tag ?? x.sibling.ticket.issue_id, branch: x.sibling.branch } } : {}
     }))
   };
 }
@@ -12714,6 +12851,7 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch, isolated = fal
   const conflicts = [];
   const unbuildable = [];
   let applied = 0;
+  let isolation;
   for (const c of decision.merges) {
     if (!c.branch || c.mergedSha) {
       if (c.skipReason === "already-released") {
@@ -12826,7 +12964,8 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch, isolated = fal
       }
       if (r && r.code !== 0 && !isolated) {
         const out = await isolateAndRetry(o, "test", r.output, merged, preMerge, decision, fresh, releaseBranch);
-        if (out) return out;
+        if (out && "tried" in out) isolation = out.tried;
+        else if (out) return out;
       }
       if (r && r.code !== 0) {
         o.emit.error(`test gate FAILED \u2014 not deploying; the target stays on the previous release`);
@@ -12847,7 +12986,7 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch, isolated = fal
           label: hookLabel(o.repo, "test"),
           tail: failureSummary(r.output, HOOK_FAILURE_TAIL_LINES)
         };
-        return { merged, conflicts, unbuildable, deployed: false, stopped: "tests failed", decision, gateRed, hookFailure: hookFailure2, composition };
+        return { merged, conflicts, unbuildable, deployed: false, stopped: "tests failed", decision, gateRed, hookFailure: hookFailure2, composition, ...isolation ? { isolation } : {} };
       }
       o.state?.clearTestGateFailed?.();
     }
@@ -12886,7 +13025,8 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch, isolated = fal
       }
       if (r && r.code !== 0 && !isolated) {
         const out = await isolateAndRetry(o, "build", r.output, merged, preMerge, decision, fresh, releaseBranch);
-        if (out) return out;
+        if (out && "tried" in out) isolation = out.tried;
+        else if (out) return out;
       }
       if (r && r.code !== 0) {
         o.emit.error("build failed \u2014 not deploying");
@@ -12894,7 +13034,7 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch, isolated = fal
           git(o.cwd, ["reset", "--hard", preBump]);
           o.emit.warn(`dropped the unreleased version commit for ${version} (reset ${o.repo.branch.base} to ${preBump.slice(0, 8)}) so a retry starts clean`);
         }
-        return { merged, conflicts, unbuildable, version, deployed: false, stopped: "build failed", decision, hookFailure: hookFailure(o, "build", r.output) };
+        return { merged, conflicts, unbuildable, version, deployed: false, stopped: "build failed", decision, hookFailure: hookFailure(o, "build", r.output), ...isolation ? { isolation } : {} };
       }
     }
   }
@@ -15506,7 +15646,7 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync9 } from "fs";
 import { basename as basename11, dirname as dirname18, join as join30, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
@@ -15566,7 +15706,7 @@ function siblingWorktreeDirs(target) {
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
   try {
-    names = readdirSync8(parent);
+    names = readdirSync9(parent);
   } catch {
     return [];
   }
@@ -15782,14 +15922,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync28, readdirSync as readdirSync9, rmSync as rmSync13, statSync as statSync8 } from "fs";
+import { existsSync as existsSync28, readdirSync as readdirSync10, rmSync as rmSync13, statSync as statSync8 } from "fs";
 import { join as join31 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
   const dir = join31(stateDir, "streams");
   if (!existsSync28(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(dir).map((name) => join31(dir, name)).filter((path) => {
+  return readdirSync10(dir).map((name) => join31(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -15817,7 +15957,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync28(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join31(stateDir, name)).filter((path) => {
+  return readdirSync10(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join31(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -15827,7 +15967,7 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync14 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync15 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
@@ -16084,7 +16224,7 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync11 } from "fs";
 import { randomInt } from "crypto";
 import { join as join33 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
@@ -16266,7 +16406,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
 function readAllPersistedWorkspaceIds(stateDir) {
   const dir = join33(stateDir, "passengers");
   if (!existsSync30(dir)) return [];
-  return readdirSync10(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  return readdirSync11(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -16386,7 +16526,7 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync12 } from "fs";
 import { join as join34 } from "path";
 
 // src/secret-compare.ts
@@ -16513,7 +16653,7 @@ function readAllPersistedSyncWorkspaceIds(stateDir) {
   const dir = join34(stateDir, "passengers");
   if (!existsSync31(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync11(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync12(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -16599,11 +16739,11 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync14, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
 import { join as join36 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync32, readdirSync as readdirSync12, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync32, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "fs";
 import { join as join35 } from "path";
 var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
 function interruptedComment(b) {
@@ -16635,7 +16775,7 @@ function orphanedStreams(o) {
   if (!existsSync32(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
-  for (const name of readdirSync12(dir)) {
+  for (const name of readdirSync13(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
     const streamPath = join35(dir, name);
     if (runFinished(streamPath)) continue;
@@ -16756,7 +16896,7 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync13(path, { withFileTypes: true })) {
+  for (const entry of readdirSync14(path, { withFileTypes: true })) {
     latest = Math.max(latest, latestMtime(join36(path, entry.name)));
   }
   return latest;
@@ -17531,6 +17671,7 @@ if (command === "passenger-sync-daemon") {
   }, releaseRefused = function() {
     const why = state.releaseSkipReason();
     if (!why) return false;
+    if (!dryRun) state.releaseHeartbeat().touch();
     emit.emit(`${why} \u2014 release skipped`, { step: "release" });
     return true;
   }, doctorMachineId = function(stateDir) {
@@ -18264,21 +18405,25 @@ ${changed2.map((c) => `  - ${c}
           dryRun
         );
       }
+      const alertPlacement = async () => {
+        const placement = {};
+        try {
+          const repoId = repoIdForName(c, target.name);
+          if (repoId) {
+            placement.repo_id = repoId;
+            const projectId = (await tracker.repoRow(repoId))?.project_id;
+            if (projectId) placement.project_id = projectId;
+          }
+        } catch {
+        }
+        return placement;
+      };
       const news = describeRelease(outcome, scope);
       if (news) {
         const notified = await notify(c, cfg.ship, news, remit, dryRun);
         if (!notified && news.level === "fail") {
           const memberId = releaseSeat(c);
-          const placement = {};
-          try {
-            const repoId = repoIdForName(c, target.name);
-            if (repoId) {
-              placement.repo_id = repoId;
-              const projectId = (await tracker.repoRow(repoId))?.project_id;
-              if (projectId) placement.project_id = projectId;
-            }
-          } catch {
-          }
+          const placement = await alertPlacement();
           await applyFailureAlert(tracker, news, scope, all, memberId, remit, dryRun, placement).catch((e) => {
             remit.warn(`could not file/update a failure ticket: ${e.message}`, { step: "release" });
           });
@@ -18302,13 +18447,36 @@ ${changed2.map((c) => `  - ${c}
       }
       if (outcome.buildCulprits?.length) {
         const seat = releaseSeat(c);
+        const prior = [...await tracker.events("build_failed"), ...await tracker.events("pushed")];
         for (const cu of outcome.buildCulprits) {
           try {
             const bounce = planBuildFailureBounce(target.dir, cu, repo.branch.base, repo.branch.remote);
-            const r = await applyBuildFailureBounce(tracker, bounce, tracker.contract, seat, remit, dryRun);
+            const r = await applyBuildFailureBounce(
+              tracker,
+              bounce,
+              tracker.contract,
+              seat,
+              remit,
+              dryRun,
+              { count: priorBuildFailures(cu.ticket, prior), operatorId: c.resolved?.operator }
+            );
             if (r.kind === "failed") {
               remit.warn(`could not hand back ${cu.ticket.issue_id}: ${r.why}`, { step: "release" });
             }
+            if (r.kind === "escalated" && !dryRun) {
+              const key = cu.ticket.issue_tag ?? cu.ticket.issue_id;
+              await applyFailureAlert(tracker, {
+                level: "fail",
+                headline: `${scope}: release blocked \u2014 ${key} broke the ${cu.hook} gate twice`,
+                detail: `${key} (\`${cu.branch}\`) was handed back after a failed ${cu.hook} gate, pushed and re-verified, and failed it again. Isolation found it both times (${cu.how}), so it is escalated to the operator instead of another lap.
+
+\`\`\`
+${cu.tail.trimEnd()}
+\`\`\``
+              }, scope, all, seat, remit, dryRun, await alertPlacement()).catch((e) => {
+                remit.warn(`could not file/update a failure ticket: ${e.message}`, { step: "release" });
+              });
+            }
           } catch (e) {
             remit.warn(`could not hand back ${cu.ticket.issue_id}: ${e.message}`, { step: "release" });
           }
@@ -19281,7 +19449,7 @@ ${changed2.map((c) => `  - ${c}
           if (!existsSync34(dir)) throw new ReposError(`${dir} does not exist on disk`);
           const files = { exists: (r) => existsSync34(resolvePath(dir, r)), list: (r) => {
             try {
-              return readdirSync14(resolvePath(dir, r));
+              return readdirSync15(resolvePath(dir, r));
             } catch {
               return [];
             }
@@ -19478,7 +19646,7 @@ ${changed2.map((c) => `  - ${c}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync14(plan2.target).length > 0)) {
+          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync15(plan2.target).length > 0)) {
             throw new ReposError(
               existsSync34(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
@@ -21030,7 +21198,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
       const fresh = !existsSync34(join37(dir, ".git"));
-      if (existsSync34(dir) && fresh && readdirSync14(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      if (existsSync34(dir) && fresh && readdirSync15(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
@@ -21516,6 +21684,8 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
           process.stdout.write(`                   - release readiness: ${p2}
 `);
         }
+        process.stdout.write(`                   release self-repair: ${selfRepairLine(config.release.isolateFailures?.maxCandidates)}
+`);
         const dh = doctorBaseReport(r, config.branch.base, baseHealth);
         process.stdout.write(dh.text);
         if (dh.failed) process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.79.9",
+  "version": "0.80.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",