@tablation/crew 0.69.0 → 0.70.0

package/dist/cli.js

@@ -6099,13 +6099,13 @@ var Tracker = class {
    * whatever wording the caller already used. Attributed to the seat's Crew
    * row, with the posting ship in `metadata`.
    */
-  async postEvent(ticketId, body, memberId, type = "note") {
+  async postEvent(ticketId, body, memberId, type = "note", extra) {
     const auth = await this.authorshipProbe();
     const res = await this.eventsFetch("POST", `/records/${ticketId}/events`, {
       type,
       message: body,
       actorRecordId: memberId,
-      ...auth.shipId ? { metadata: { ship_id: auth.shipId } } : {}
+      ...auth.shipId || extra ? { metadata: { ...auth.shipId ? { ship_id: auth.shipId } : {}, ...extra } } : {}
     });
     if (res.status === 404) throw new ConfigError(EVENT_LOG_MISSING);
     if (!res.ok) throw new Error(`posting a ${type} event failed: HTTP ${res.status}`);
@@ -10095,6 +10095,17 @@ var priorBounces = (ticket, events) => {
     (e) => e.event_type === "conflict_handed_back" && pushes.some((p) => p > stampOf(e))
   ).length;
 };
+var baseShaOf = (e) => {
+  const m = e.metadata?.base_sha;
+  if (typeof m === "string" && m) return m;
+  return /Base tip: `([0-9a-f]{7,40})`/.exec(e.message ?? "")?.[1] ?? null;
+};
+var lastActedHandBack = (ticket, events) => {
+  const mine = events.filter((e) => e.record_id === ticket.id);
+  const pushes = mine.filter((e) => e.event_type === "pushed").map(stampOf);
+  return mine.filter((e) => e.event_type === "conflict_handed_back" && pushes.some((p) => p > stampOf(e))).sort((a, b) => stampOf(b).localeCompare(stampOf(a)))[0];
+};
+var MAX_ABSORBED_HANDBACKS = 2;
 function planConflictBounce(cwd, ticket, branch, base, paths, events) {
   return {
     ticket,
@@ -10102,7 +10113,10 @@ function planConflictBounce(cwd, ticket, branch, base, paths, events) {
     base,
     paths,
     worktree: worktreeForBranch(cwd, branch),
-    priorBounces: priorBounces(ticket, events)
+    priorBounces: priorBounces(ticket, events),
+    cwd,
+    baseSha: gitOk(cwd, ["rev-parse", "--verify", "-q", base]) || null,
+    priorBaseSha: baseShaOf(lastActedHandBack(ticket, events) ?? { record_id: "", event_type: "" })
   };
 }
 function refreshBranch(worktree, base) {
@@ -10135,20 +10149,29 @@ function handBackComment(b, merged) {
 
 ${merged ? `\`${b.base}\` has been merged into \`${b.branch}\` in its worktree and the conflict is left in place, so \`git status\` there shows exactly what disagrees. Resolve it, commit, push as a plain fast-forward (the branch is pushed, so rebasing it is not an option) and hand back to QA as usual \u2014 \`git merge --abort\` backs the merge out if you would rather start differently.` : `This ship has no worktree for \`${b.branch}\`, so nothing has been merged for you. Merge \`${b.base}\` into the branch wherever it lives, resolve the conflict, and commit.`}
 
-Nothing was written to \`${b.base}\`: the failed merge was rewound, and the rest of the release shipped without this ticket. Re-verifying is what puts it back in the merge queue.`;
+${b.baseSha ? `Base tip: \`${b.baseSha}\`
+
+` : ""}Nothing was written to \`${b.base}\`: the failed merge was rewound, and the rest of the release shipped without this ticket. Re-verifying is what puts it back in the merge queue.`;
 }
 function escalateComment(b) {
+  const where = b.paths.length ? ` (${b.paths.map((p) => `\`${p}\``).join(", ")})` : "";
+  const absorbed = b.priorBounces >= MAX_ABSORBED_HANDBACKS;
   return `${BOUNCE_MARKER}
 
 **Conflicting again after a hand-back \u2014 stopping rather than looping.**
 
-\`${b.branch}\` was handed back once for a merge conflict, verified again, and conflicts against \`${b.base}\` a second time${b.paths.length ? ` (${b.paths.map((p) => `\`${p}\``).join(", ")})` : ""}.
+\`${b.branch}\` was handed back ${b.priorBounces === 1 ? "once" : `${b.priorBounces} times`} for a merge conflict, verified again, and conflicts against \`${b.base}\` ${b.priorBounces === 1 ? "a second time" : `again (conflict ${b.priorBounces + 1})`}${where}.
 
-Either \`${b.base}\` is moving faster than this branch can absorb it, or this ticket overlaps work that has already shipped and needs rethinking rather than merging. That is a call for a person, not another lap through the lanes.`;
+${absorbed ? `Each earlier hand-back was answered by merging \`${b.base}\` in, and \`${b.base}\` moved underneath the branch every time. This file is changing faster than the lanes can absorb it, so it needs a person to sequence this ticket against the others touching it.` : `The branch ${b.priorBaseSha ? `does not contain \`${b.priorBaseSha}\`, the \`${b.base}\` tip it was last handed back for` : "was pushed"} \u2014 the hand-back was answered without merging \`${b.base}\` in, or this ticket overlaps work that has already shipped and needs rethinking rather than merging.`}
+That is a call for a person, not another lap through the lanes.`;
 }
 async function applyConflictBounce(writer, b, contract, memberId, log, dryRun) {
   const t = { ticket: b.ticket.issue_id, step: "merge" };
-  if (b.priorBounces > 0) {
+  const absorbed = b.priorBounces > 0 && b.priorBounces < MAX_ABSORBED_HANDBACKS && !!b.priorBaseSha && isAncestor(b.worktree ?? b.cwd, b.priorBaseSha, b.branch);
+  if (absorbed) {
+    log.emit(`${b.ticket.issue_id} conflicts again, but ${b.base} moved since the hand-back was answered \u2014 handing back again`, t);
+  }
+  if (b.priorBounces > 0 && !absorbed) {
     if (dryRun) {
       log.emit(`would escalate to ${contract.statuses.needsHuman} \u2014 handed back before`, t);
       return { kind: "escalated" };
@@ -10196,7 +10219,13 @@ async function applyConflictBounce(writer, b, contract, memberId, log, dryRun) {
       { status: contract.statuses.building, assignee_id: null },
       b.ticket.updated_at
     );
-    await writer.postEvent(b.ticket.id, handBackComment(b, merged), memberId, "conflict_handed_back").catch(() => {
+    await writer.postEvent(
+      b.ticket.id,
+      handBackComment(b, merged),
+      memberId,
+      "conflict_handed_back",
+      b.baseSha ? { base_sha: b.baseSha } : void 0
+    ).catch(() => {
       log.warn("handed back, but the note failed to post", t);
     });
     log.emit(
@@ -15236,6 +15265,37 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   return endpoints;
 }
 
+// src/outage.ts
+var TRANSIENT_BACKOFF_MS = [15e3, 3e4, 6e4];
+var OUTAGE_ESCALATE_AFTER = 5;
+var TRACKER_OUTAGE_KEY = "tracker_unreachable";
+var NETWORK_CODES = ["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "EAI_AGAIN"];
+function transientBackoffMs(n) {
+  return TRANSIENT_BACKOFF_MS[Math.min(Math.max(n, 1), TRANSIENT_BACKOFF_MS.length) - 1];
+}
+function codeOf(e) {
+  const code = e?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function isTransientError(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message;
+  if (msg === "fetch failed" || msg.startsWith("fetch failed")) return true;
+  for (let e = err, depth = 0; e && depth < 4; e = e.cause, depth++) {
+    const code = codeOf(e);
+    if (code && NETWORK_CODES.includes(code)) return true;
+  }
+  if (NETWORK_CODES.some((c) => msg.includes(c))) return true;
+  if (/\b(?:HTTP|status)\s*:?\s*(502|503|504)\b/i.test(msg) || /^(502|503|504)\b/.test(msg)) return true;
+  if (err instanceof SyntaxError && /Unexpected token '?<|is not valid JSON|Unexpected end of JSON/.test(msg)) return true;
+  return false;
+}
+function describeCause(err) {
+  const first = (err instanceof Error ? err.message : String(err)).split("\n")[0];
+  const code = codeOf(err?.cause);
+  return code && !first.includes(code) ? `${first} (${code})` : first;
+}
+
 // src/daemon.ts
 import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync26, readdirSync as readdirSync13, rmSync as rmSync13, statSync as statSync9, writeFileSync as writeFileSync20 } from "fs";
 import { join as join33 } from "path";
@@ -15335,12 +15395,32 @@ async function runDaemonLoop(o) {
   const sleep = o.sleep ?? defaultSleep;
   let backoff = floor;
   let passes = 0;
+  const now = o.now ?? Date.now;
+  let transientRun = 0;
+  let downSince = 0;
   for (; ; ) {
     if (o.signal?.aborted) return "aborted";
     let result;
     try {
       result = await o.runPass();
+      if (transientRun > 0) {
+        o.onRecovered?.({ downMs: now() - downSince });
+        transientRun = 0;
+      }
     } catch (err) {
+      if (isTransientError(err)) {
+        passes++;
+        if (transientRun === 0) downSince = now();
+        transientRun++;
+        const wait = transientBackoffMs(transientRun);
+        const downMs = now() - downSince;
+        o.onTransient?.({ err, consecutive: transientRun, backoffMs: wait, downMs });
+        if (transientRun === OUTAGE_ESCALATE_AFTER) o.onOutage?.({ err, consecutive: transientRun, downMs });
+        if (o.maxPasses !== void 0 && passes >= o.maxPasses) return "maxPasses";
+        if (o.signal?.aborted) return "aborted";
+        await sleep(wait);
+        continue;
+      }
       passes++;
       o.onPassError?.(err);
       if (o.maxPasses !== void 0 && passes >= o.maxPasses) return "maxPasses";
@@ -17437,6 +17517,23 @@ ${changed2.map((c) => `  - ${c}
 `)
           })
         }),
+        onTransient: ({ err, consecutive, backoffMs }) => emit.warn(
+          `tracker unavailable (${describeCause(err)}); attempt ${consecutive}, retrying in ${Math.round(backoffMs / 1e3)}s`
+        ),
+        onOutage: ({ err, downMs }) => {
+          const msg = `tracker unreachable for ${Math.max(1, Math.round(downMs / 6e4))} minutes: ${describeCause(err)}`;
+          emit.error(msg);
+          void raiseShipAttention({ state, emit, route, ship: cfg.ship }, {
+            kind: "tracker_unreachable",
+            key: TRACKER_OUTAGE_KEY,
+            message: msg,
+            since: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        },
+        onRecovered: ({ downMs }) => {
+          clearShipAttention(state, TRACKER_OUTAGE_KEY);
+          emit.emit(`tracker is back after ${Math.max(1, Math.round(downMs / 1e3))}s`);
+        },
         onPassError: (err) => emit.error(
           `daemon pass failed, continuing: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
         ),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.69.0",
+  "version": "0.70.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",