@tablation/crew 0.47.2 → 0.48.0

package/dist/cli.js

@@ -4117,15 +4117,36 @@ function remoteBranchForIssue(cwd, remote, issueKey, templates = { name: "issue-
   }
   return null;
 }
-function materializeRemoteBranch(cwd, remote, branch) {
-  if (!remoteBranchExists(cwd, remote, branch)) {
-    return gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) !== null;
+function levelRemoteBranch(cwd, remote, branch) {
+  const local = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]);
+  if (!remoteBranchExists(cwd, remote, branch)) return { exists: local !== null };
+  if (local === null) {
+    return { exists: gitOk(cwd, ["branch", "--track", branch, `${remote}/${branch}`]) !== null };
+  }
+  const remoteTip2 = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/remotes/${remote}/${branch}`]);
+  if (!remoteTip2 || remoteTip2 === local) return { exists: true };
+  if (!isAncestor(cwd, local, remoteTip2)) return { exists: true };
+  const holder = worktrees(cwd).find((w) => w.branch === branch && !w.prunable);
+  if (holder) {
+    if (gitOk(holder.path, ["status", "--porcelain"])) {
+      return {
+        exists: true,
+        problem: `${branch} is behind ${remote}/${branch} and the worktree ${holder.path} that holds it has uncommitted or mid-merge changes`
+      };
+    }
+    try {
+      git(holder.path, ["merge", "--ff-only", "--quiet", `${remote}/${branch}`]);
+    } catch (e) {
+      return { exists: true, problem: `could not fast-forward ${branch} in ${holder.path}: ${e.message}` };
+    }
+    return { exists: true };
   }
-  if (gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) === null) {
-    return gitOk(cwd, ["branch", "--track", branch, `${remote}/${branch}`]) !== null;
+  try {
+    git(cwd, ["fetch", "--quiet", remote, `${branch}:${branch}`]);
+  } catch (e) {
+    return { exists: true, problem: `could not move ${branch} to ${remote}/${branch}: ${e.message}` };
   }
-  gitOk(cwd, ["fetch", "--quiet", remote, `${branch}:${branch}`]);
-  return true;
+  return { exists: true };
 }
 function deleteRemoteBranch(cwd, remote, branch) {
   if (!remoteBranchExists(cwd, remote, branch)) return true;
@@ -6285,10 +6306,11 @@ function locateBranchForTicket(dir, cfg, t, role, fetchedDirs) {
   const found = remoteBranchForIssue(dir, remote, t.issue_id, branchTemplates(cfg, t), branchRenderer(t, role));
   return found ? { branch: found, where: "remote" } : null;
 }
-function materializeBranchForTicket(dir, cfg, t, role) {
+function materializeBranchForTicket(dir, cfg, t, role, onProblem) {
   const loc = locateBranchForTicket(dir, cfg, t, role);
   if (!loc) return null;
-  materializeRemoteBranch(dir, cfg.branch.remote, loc.branch);
+  const r = levelRemoteBranch(dir, cfg.branch.remote, loc.branch);
+  if (r.problem) onProblem?.(r.problem);
   return loc.branch;
 }
 
@@ -6746,6 +6768,11 @@ function planConflictBounce(cwd, ticket, branch, base, paths, events) {
 function refreshBranch(worktree, base) {
   const dirty = gitOk(worktree, ["status", "--porcelain"]);
   if (dirty) return { clean: false, paths: [], why: "the worktree has uncommitted changes" };
+  const upstream = gitOk(worktree, ["rev-parse", "-q", "--verify", "@{upstream}"]);
+  const head = gitOk(worktree, ["rev-parse", "HEAD"]);
+  if (upstream && head && upstream !== head && isAncestor(worktree, head, upstream)) {
+    return { clean: false, paths: [], behind: true, why: "the branch is behind its remote; fast-forward it before merging the base in" };
+  }
   try {
     git(worktree, ["merge", "--no-edit", base]);
     return { clean: true, paths: [] };
@@ -6813,6 +6840,10 @@ async function applyConflictBounce(writer, b, contract, memberId, log, dryRun) {
       log.emit(`merged ${b.base} into ${b.branch} cleanly \u2014 it was stale, not conflicting`, t);
       return { kind: "refreshed" };
     }
+    if (r.behind) {
+      log.warn(`not handing ${b.ticket.issue_id} back: ${r.why}`, t);
+      return { kind: "failed", why: r.why ?? "branch behind its remote" };
+    }
     merged = r.paths.length > 0;
     if (r.why) log.warn(`could not merge ${b.base} into ${b.branch}: ${r.why}`, t);
     if (r.paths.length) b.paths = r.paths;
@@ -9050,6 +9081,30 @@ function releaseIdle(i) {
 }
 var renderTag = (template, version) => template.replace(/\{version\}/g, version);
 
+// src/verified-tip.ts
+var PUSHED_RE = /^pushed ([0-9a-f]{40}) to \S+$/;
+function parsePushedSha(message) {
+  return PUSHED_RE.exec((message ?? "").trim())?.[1] ?? null;
+}
+function verifiedShaFor(ticket, verifiedShaColumn, pushedEvents) {
+  const col = ticket[verifiedShaColumn];
+  if (typeof col === "string" && /^[0-9a-f]{7,40}$/i.test(col.trim())) return col.trim();
+  const when = (e) => Date.parse(e.occurred_at ?? e.created_at ?? "") || 0;
+  const newest = pushedEvents.filter((e) => e.record_id === ticket.id && parsePushedSha(e.message)).sort((a, b) => when(b) - when(a))[0];
+  return newest ? parsePushedSha(newest.message) : null;
+}
+function movedPastVerified(cwd, branch, verified) {
+  const tip = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}^{commit}`]);
+  const ver = gitOk(cwd, ["rev-parse", "-q", "--verify", `${verified}^{commit}`]);
+  if (!tip || !ver || tip === ver) return null;
+  if (isAncestor(cwd, tip, ver)) return null;
+  if (isAncestor(cwd, ver, tip)) {
+    const own = gitOk(cwd, ["rev-list", "--first-parent", "--no-merges", "--count", `${ver}..${tip}`]);
+    if (own === "0") return null;
+  }
+  return { tip, verified: ver };
+}
+
 // src/stamp.ts
 function planStamp(cwd, tickets, contract, fromSha, toSha, merged = /* @__PURE__ */ new Map()) {
   const range = fromSha ? `${fromSha.slice(0, 8)}..${toSha.slice(0, 8)}` : null;
@@ -9249,7 +9304,7 @@ ${h.prFailure.tail}
   }
   for (const q of outcome.requeues) {
     const t = q.ticket;
-    const body = `The branch is no longer what was verified: \`verified_sha\` is ${q.verified.slice(0, 8)}, the branch is now at ${q.head.slice(0, 8)}. Returned to ${contract.statuses.handoff} for QA to check what changed.`;
+    const body = `The branch is no longer what was verified: QA verified ${q.verified.slice(0, 8)}, the branch is now at ${q.head.slice(0, 8)}. Returned to ${contract.statuses.handoff} for QA to check what changed.`;
     if (dryRun) {
       emit.emit(`would return to ${contract.statuses.handoff} \u2014 branch moved past ${q.verified.slice(0, 8)}`, { ticket: t.issue_id });
       continue;
@@ -9660,11 +9715,45 @@ function reportHeld(o, held) {
   o.state?.noteHeldReported?.(signature);
 }
 async function runRelease(o) {
+  const movedPast2 = [];
+  const out = await runReleaseCycle(o, movedPast2);
+  return movedPast2.length ? { ...out, movedPast: movedPast2 } : out;
+}
+async function runReleaseCycle(o, movedPast2) {
   const scoped = (msg) => o.scope ? `${o.scope}: ${msg}` : msg;
   const tagPattern = o.repo.release.tagPattern ?? "v*";
   o.emit.enter("release");
   const fresh = refreshBase(o);
-  const decision = decideRelease(o.cwd, o.tickets, o.contract, {
+  let releasable = o.tickets;
+  if (!o.dryRun) {
+    const skipped = /* @__PURE__ */ new Set();
+    for (const t of o.tickets) {
+      if (t.status !== o.contract.statuses.verified) continue;
+      materializeBranchForTicket(o.cwd, o.repo, t, void 0, (problem) => {
+        skipped.add(t.id);
+        o.emit.error(`not releasing ${t.issue_id} this cycle: ${problem}`, { ticket: t.issue_id });
+      });
+    }
+    if (skipped.size) releasable = o.tickets.filter((t) => !skipped.has(t.id));
+  }
+  if (o.verifiedShas?.size) {
+    const drop = /* @__PURE__ */ new Set();
+    for (const t of releasable) {
+      const verified = o.verifiedShas.get(t.id);
+      if (t.status !== o.contract.statuses.verified || !verified) continue;
+      const branch = locateBranchForTicket(o.cwd, o.repo, t)?.branch;
+      const moved = branch ? movedPastVerified(o.cwd, branch, verified) : null;
+      if (!moved) continue;
+      drop.add(t.id);
+      movedPast2.push({ ticket: t, verified: moved.verified, head: moved.tip });
+      o.emit.error(
+        `not releasing ${t.issue_id}: ${branch} is at ${moved.tip.slice(0, 8)}, past the ${moved.verified.slice(0, 8)} QA verified`,
+        { ticket: t.issue_id }
+      );
+    }
+    if (drop.size) releasable = releasable.filter((t) => !drop.has(t.id));
+  }
+  const decision = decideRelease(o.cwd, releasable, o.contract, {
     tagPattern,
     base: o.repo.branch.base,
     blockerInfo: o.blockerInfo,
@@ -13419,6 +13508,21 @@ ${changed2.map((c) => `  - ${c}
       );
       reportUnplaceable(c.route, unplaceable, tracker.contract.statuses.verified, remit);
       const blockerInfo = blockerInfoMap(all, await tracker.ticketsByIds(missingBlockerIds(all)));
+      const verifiedStatus = tracker.contract.statuses.verified;
+      const verifiedTickets = tickets.filter((t) => t.status === verifiedStatus);
+      const verifiedShas = /* @__PURE__ */ new Map();
+      if (verifiedTickets.length && repo.release.mode !== "external") {
+        let pushedEvents = [];
+        try {
+          pushedEvents = await tracker.events("pushed");
+        } catch (e) {
+          remit.warn(`could not read hand-off events; not checking branches against what QA verified: ${e.message}`);
+        }
+        for (const t of verifiedTickets) {
+          const sha = verifiedShaFor(t, tracker.contract.columns.verifiedSha, pushedEvents);
+          if (sha) verifiedShas.set(t.id, sha);
+        }
+      }
       const outcome = await runRelease({
         cwd: target.dir,
         repo,
@@ -13427,6 +13531,7 @@ ${changed2.map((c) => `  - ${c}
         blockerInfo,
         emit: remit,
         scope,
+        verifiedShas,
         state: state.release(scope),
         reviewColumns: repo.release.mode === "external" ? await tracker.reviewColumns() : void 0,
         dryRun,
@@ -13522,6 +13627,18 @@ ${changed2.map((c) => `  - ${c}
           dryRun
         );
       }
+      if (outcome.movedPast?.length) {
+        await applyReview(
+          tracker,
+          tracker.contract,
+          { handoffs: [], requeues: outcome.movedPast },
+          repo.branch.remote,
+          remit,
+          releaseSeat(c),
+          { verifiedSha: false, prRef: false },
+          dryRun
+        );
+      }
       const news = describeRelease(outcome, scope);
       if (news) {
         const notified = await notify(c, cfg.ship, news, remit, dryRun);

package/package.json

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