@tablation/crew 0.69.0 → 0.69.1

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(

package/package.json

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