@tablation/crew 0.73.1 → 0.73.4

package/dist/cli.js

@@ -3563,7 +3563,7 @@ function remoteBranchForIssue(cwd, remote, issueKey, templates = { name: "issue-
   }
   return null;
 }
-function levelRemoteBranch(cwd, remote, branch) {
+function levelRemoteBranch(cwd, remote, branch, baseRef) {
   const local = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]);
   if (!remoteBranchExists(cwd, remote, branch)) return { exists: local !== null };
   if (local === null) {
@@ -3572,6 +3572,20 @@ function levelRemoteBranch(cwd, remote, branch) {
   const remoteTip2 = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/remotes/${remote}/${branch}`]);
   if (!remoteTip2 || remoteTip2 === local) return { exists: true };
   if (!isAncestor(cwd, local, remoteTip2)) {
+    if (baseRef && isAncestor(cwd, local, baseRef)) {
+      const holder3 = worktrees(cwd).find((w) => w.branch === branch && !w.prunable);
+      if (holder3) {
+        if (gitOk(holder3.path, ["status", "--porcelain"])) {
+          return { exists: true, problem: `${branch} holds only commits already on ${baseRef}, but the worktree ${holder3.path} that holds it has uncommitted changes` };
+        }
+        if (gitOk(holder3.path, ["reset", "--hard", "--quiet", remoteTip2]) === null) {
+          return { exists: true, problem: `could not reset ${branch} to ${remote}/${branch} in ${holder3.path}` };
+        }
+      } else if (gitOk(cwd, ["branch", "-f", branch, remoteTip2]) === null) {
+        return { exists: true, problem: `could not reset ${branch} to ${remote}/${branch}` };
+      }
+      return { exists: true, reset: `${branch} held only commits already on ${baseRef}; reset ${local.slice(0, 8)} -> ${remote}/${branch} at ${remoteTip2.slice(0, 8)}` };
+    }
     const diverged = !isAncestor(cwd, remoteTip2, local);
     const holder2 = diverged ? worktrees(cwd).find((w) => w.branch === branch && !w.prunable) : void 0;
     if (holder2) {
@@ -4225,7 +4239,7 @@ function describeComposition(c) {
 
 ${rows}
 
-The gate runs on the base plus every verified branch above, not on the base alone: reproduce on that composition.`;
+The gate runs on the base plus every verified branch above, not on the base alone: reproduce on that composition. A fix that compiles only on the composition belongs on one of those branches (the one owning the failing file, after merging the others into it), not on a new branch cut from the base: a separate fix branch conflicts with the branches it contains when the release squash-merges them all. Re-queue the touched ticket to QA and close this alert with a note.`;
 }
 
 // src/shell.ts
@@ -6483,11 +6497,12 @@ function locateBranchForTicket(dir, cfg, t, role, fetchedDirs) {
   const found = remoteBranchForIssue(dir, remote, t.issue_id, branchTemplates(cfg, t), branchRenderer(t, role, cfg.branch.lowercase));
   return found ? { branch: found, where: "remote" } : null;
 }
-function materializeBranchForTicket(dir, cfg, t, role, onProblem) {
+function materializeBranchForTicket(dir, cfg, t, role, onProblem, onReset) {
   const loc = locateBranchForTicket(dir, cfg, t, role);
   if (!loc) return null;
-  const r = levelRemoteBranch(dir, cfg.branch.remote, loc.branch);
+  const r = levelRemoteBranch(dir, cfg.branch.remote, loc.branch, `${cfg.branch.remote}/${cfg.branch.base}`);
   if (r.problem) onProblem?.(r.problem);
+  if (r.reset) onReset?.(r.reset);
   return loc.branch;
 }
 
@@ -6774,10 +6789,10 @@ function applyRunWorktree(dir, cfg, plan) {
     case "recut":
       git(dir, ["worktree", "remove", "--force", plan.path]);
       gitOk(dir, ["branch", "-D", plan.branch]);
-      git(dir, ["worktree", "add", "-b", plan.branch, plan.path, plan.base]);
+      git(dir, ["worktree", "add", "--no-track", "-b", plan.branch, plan.path, plan.base]);
       return plan.path;
     case "cut-fresh":
-      git(dir, ["worktree", "add", "-b", plan.branch, plan.path, plan.base]);
+      git(dir, ["worktree", "add", "--no-track", "-b", plan.branch, plan.path, plan.base]);
       return plan.path;
   }
 }
@@ -6785,6 +6800,19 @@ function worktreeHoldsUnpushed(path, remote) {
   const out = gitOk(path, ["for-each-ref", "--contains", "HEAD", "--count=1", "--format=%(refname)", `refs/remotes/${remote}/`]);
   return out === null || out.trim() === "";
 }
+function dropEmptyRunBranch(dir, cfg, branch) {
+  const { remote, base } = cfg.branch;
+  const baseRef = remoteConfigured(dir, remote) ? `${remote}/${base}` : base;
+  if (gitOk(dir, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) === null) return false;
+  if (remoteConfigured(dir, remote) && remoteBranchExists(dir, remote, branch)) return false;
+  if (countCommits(dir, `${baseRef}..${branch}`) !== 0) return false;
+  const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
+  if (wt && existsSync14(wt.path)) {
+    if (status(wt.path).length > 0) return false;
+    if (gitOk(dir, ["worktree", "remove", wt.path]) === null) return false;
+  }
+  return gitOk(dir, ["branch", "-D", branch]) !== null;
+}
 async function finishRunWorktree(dir, cfg, branch) {
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
   if (!wt || !existsSync14(wt.path)) return { kind: "none" };
@@ -6953,6 +6981,12 @@ async function guardRunHandoff(route, ship, tracker, role, workingId, log, since
       log
     });
     if (outcome.kind === "pushed") await retireRunWorktree(tracker, target.dir, cfg, t, role, seatId, ship.name, log);
+    else {
+      const branch = existingBranchForTicket(target.dir, cfg, t, role);
+      if (branch && dropEmptyRunBranch(target.dir, cfg, branch)) {
+        log.emit(`${t.issue_id}: dropped ${branch} \u2014 the run made no commits beyond ${cfg.branch.base}`, { ticket: t.issue_id, step: "handoff" });
+      }
+    }
     if (since2) await guardRunStrays(route, ship, tracker, role, workingId, since2, log);
     return outcome;
   } catch (e) {
@@ -10297,7 +10331,8 @@ var lastActedHandBack = (ticket, events) => {
   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) {
+function planConflictBounce(cwd, ticket, branch, base, paths, events, merged = []) {
+  const siblings = merged.filter((m) => m.branch !== branch && paths.some((p) => (gitOk(cwd, ["diff", "--name-only", `${base}...${m.branch}`, "--", p]) ?? "").trim() !== ""));
   return {
     ticket,
     branch,
@@ -10307,7 +10342,8 @@ function planConflictBounce(cwd, ticket, branch, base, paths, events) {
     priorBounces: priorBounces(ticket, events),
     cwd,
     baseSha: gitOk(cwd, ["rev-parse", "--verify", "-q", base]) || null,
-    priorBaseSha: baseShaOf(lastActedHandBack(ticket, events) ?? { record_id: "", event_type: "" })
+    priorBaseSha: baseShaOf(lastActedHandBack(ticket, events) ?? { record_id: "", event_type: "" }),
+    siblings
   };
 }
 function refreshBranch(worktree, base) {
@@ -10336,7 +10372,7 @@ function handBackComment(b, merged) {
 
 **Back with the dev lane \u2014 this branch no longer merges.**
 
-\`${b.branch}\` was verified, but squash-merging it into \`${b.base}\` conflicts in ${list}. Work that landed on \`${b.base}\` after this branch was cut has changed the same lines.
+\`${b.branch}\` was verified, but squash-merging it into \`${b.base}\` conflicts in ${list}. ${b.siblings?.length ? `This conflicts with ${b.siblings.map((x) => `${x.key} (\`${x.branch}\`)`).join(", ")}, merged earlier in the same release, not with a \`${b.base}\` that moved: merging \`${b.base}\` in will change nothing. Merge ${b.siblings.length === 1 ? "that branch" : "those branches"} into this one (or move this change onto ${b.siblings.length === 1 ? "it" : "one of them"}), resolve, and push.` : `Work that landed on \`${b.base}\` after this branch was cut has changed the same lines.`}
 
 ${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.`}
 
@@ -10584,6 +10620,19 @@ async function applyStrandedVerified(writer, s, contract, operatorId, memberId,
   }
 }
 
+// src/local-ref-skip.ts
+var LOCAL_REF_SKIP_MARKER = calloutHeader("WARNING", "Release Skipped");
+function localRefSkipComment(shipName2, problem) {
+  return `${LOCAL_REF_SKIP_MARKER}
+> ${problem}
+
+**This ticket is verified but was not released: the release ship's local branch disagrees with the remote.**
+
+Ship ${shipName2} found: ${problem}. The release refuses to squash a ref nobody verified and retries every cycle. If the local branch holds only commits already on the base, run \`git branch -f <branch> <remote>/<branch>\` in the release checkout (the crew now does this itself when it can); otherwise a person needs to reconcile the branch.
+`;
+}
+var localRefSkipReported = (ticket, problem, events) => events.some((e) => e.record_id === ticket.id && e.event_type === "local_ref_skip" && (e.message ?? "").includes(problem));
+
 // src/connect-wizard.ts
 import { delimiter, dirname as dirname10, join as join23 } from "path";
 import { accessSync as accessSync2, constants as constants2, existsSync as existsSync21, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
@@ -11641,7 +11690,7 @@ function openReleaseCheckout(o) {
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
-    git(o.cwd, ["worktree", "add", "-q", "-b", branch, dir, `${remote}/${base}`]);
+    git(o.cwd, ["worktree", "add", "-q", "--no-track", "-b", branch, dir, `${remote}/${base}`]);
   } catch (e) {
     close();
     throw e;
@@ -11667,10 +11716,15 @@ function reportHeld(o, held) {
 }
 async function runRelease(o) {
   const movedPast2 = [];
-  const out = await runReleaseCycle(o, movedPast2);
-  return movedPast2.length ? { ...out, movedPast: movedPast2 } : out;
+  const localRefSkips = [];
+  const out = await runReleaseCycle(o, movedPast2, localRefSkips);
+  return {
+    ...out,
+    ...movedPast2.length ? { movedPast: movedPast2 } : {},
+    ...localRefSkips.length ? { localRefSkips } : {}
+  };
 }
-async function runReleaseCycle(o, movedPast2) {
+async function runReleaseCycle(o, movedPast2, localRefSkips) {
   const scoped = (msg) => o.scope ? `${o.scope}: ${msg}` : msg;
   const tagPattern = o.repo.release.tagPattern ?? "v*";
   o.emit.enter("release");
@@ -11682,8 +11736,9 @@ async function runReleaseCycle(o, movedPast2) {
       if (t.status !== o.contract.statuses.verified) continue;
       materializeBranchForTicket(o.cwd, o.repo, t, void 0, (problem) => {
         skipped.add(t.id);
+        localRefSkips.push({ ticket: t, problem });
         o.emit.error(`not releasing ${t.issue_id} this cycle: ${problem}`, { ticket: t.issue_id });
-      });
+      }, (note) => o.emit.emit(`${t.issue_id}: ${note}`, { ticket: t.issue_id }));
     }
     if (skipped.size) releasable = o.tickets.filter((t) => !skipped.has(t.id));
   }
@@ -11702,6 +11757,10 @@ async function runReleaseCycle(o, movedPast2) {
           `not releasing ${t.issue_id}: local ${branch} at ${moved.tip.slice(0, 8)} is not on ${o.repo.branch.remote}/${branch} (${remoteTip2.slice(0, 8)}); not requeuing it`,
           { ticket: t.issue_id }
         );
+        localRefSkips.push({
+          ticket: t,
+          problem: `local ${branch} at ${moved.tip.slice(0, 8)} is not on ${o.repo.branch.remote}/${branch} (${remoteTip2.slice(0, 8)})`
+        });
         continue;
       }
       movedPast2.push({ ticket: t, verified: moved.verified, head: moved.tip, branch: pushedBranchForTicket(o.repo, t) });
@@ -14692,7 +14751,15 @@ function planFix(f) {
   const actions = [];
   const notes = [];
   for (const r of f.routes) {
-    if (!r.enabled && sound(r)) actions.push({ kind: "enable", route: r.route });
+    if (!r.enabled && sound(r)) {
+      actions.push({ kind: "enable", route: r.route });
+      const gaps = r.readiness ?? [];
+      if (gaps.length) {
+        notes.push(`${r.route}: ${gaps.length} release-readiness gap${gaps.length === 1 ? "" : "s"} (${gaps[0]}${gaps.length > 1 ? ", ..." : ""}) \u2014 the route will run, but releases stop at the first missing hook until it is added`);
+      }
+    } else if (!sound(r) && !r.enabled) {
+      notes.push(`${r.route}: not enabled \u2014 ${r.hasRepos ? r.problems[0] : "no checkout is configured"}`);
+    }
   }
   if (f.schedulerAbsent && f.routes.some(sound)) {
     if (f.host === "windows") notes.push("scheduler support is not built for Windows yet \u2014 nothing to install; run `crew run` by hand");
@@ -14702,12 +14769,15 @@ function planFix(f) {
 }
 async function gatherHealth(c, check) {
   let problems;
+  let readiness = [];
   try {
-    problems = await check();
+    const r = await check();
+    if (Array.isArray(r)) problems = r;
+    else ({ problems, readiness } = r);
   } catch (e) {
     problems = [`checks could not run: ${e instanceof Error ? e.message : String(e)}`];
   }
-  return { route: c.route, enabled: c.enabled, hasRepos: c.hasRepos, problems };
+  return { route: c.route, enabled: c.enabled, hasRepos: c.hasRepos, problems, readiness };
 }
 function routesInScope(routes, named) {
   return named ? routes.filter((r) => r.route === named) : routes;
@@ -17039,6 +17109,7 @@ if (command === "passenger-sync-daemon") {
   async function routeProblems(c) {
     const host = hostPlatform();
     const problems = [];
+    const readiness = [];
     if (c.hostPassengers) {
       if (!dockerAvailable()) problems.push("host passengers: docker is not available");
       if (!sshKeygenAvailable()) problems.push("host passengers: ssh-keygen is not available");
@@ -17048,7 +17119,7 @@ if (command === "passenger-sync-daemon") {
     for (const r of await resolvedRepos(c)) {
       if (!existsSync34(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
-      problems.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
+      readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
     try {
       const ships = await tracker.shipRows();
@@ -17060,7 +17131,7 @@ if (command === "passenger-sync-daemon") {
     } catch (e) {
       problems.push(`tracker unreachable: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return problems;
+    return { problems, readiness };
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
@@ -17401,6 +17472,18 @@ ${changed2.map((c) => `  - ${c}
           remit.warn(`could not note the red test gate on the board: ${e.message}`, { step: "merge" });
         }
       }
+      if (outcome.localRefSkips?.length && !dryRun) {
+        try {
+          const reported = await tracker.events("local_ref_skip");
+          const seat = releaseSeat(c);
+          for (const s of outcome.localRefSkips) {
+            if (localRefSkipReported(s.ticket, s.problem, reported)) continue;
+            await tracker.postEvent(s.ticket.id, localRefSkipComment(cfg.ship.name, s.problem), seat, "local_ref_skip");
+          }
+        } catch (e) {
+          remit.warn(`could not note the skipped release on the board: ${e.message}`, { step: "merge" });
+        }
+      }
       if (outcome.externalClosures?.length) {
         await applyExternalClosures(tracker, outcome.externalClosures, tracker.contract, remit, dryRun, target.dir);
       }
@@ -17490,7 +17573,8 @@ ${changed2.map((c) => `  - ${c}
               f.candidate.branch,
               repo.branch.base,
               f.paths,
-              handedBack
+              handedBack,
+              outcome.merged.filter((m) => m.branch).map((m) => ({ key: m.ticket.issue_id, branch: m.branch }))
             );
             const r = await applyConflictBounce(tracker, bounce, tracker.contract, seat, remit, dryRun);
             if (r.kind === "failed") {
@@ -19835,6 +19919,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             continue;
           }
           if (!s2.upstream) continue;
+          if (w.branch !== r.config.branch.base && s2.upstream === `${r.config.branch.remote}/${r.config.branch.base}`) continue;
           tracked++;
           if (s2.canFastForward) {
             acted++;
@@ -20334,6 +20419,9 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
               // Additive (CREW-1379): `unsafe` means a ship must not cut a
               // worktree or release from this base. `version` stays 1.
               baseBranch: baseHealth(r),
+              // Additive (CREW-2537): gaps that only matter once a ticket reaches
+              // release (no deploy hook, no CI provider...). They never stop a poll.
+              releaseReadiness: validateEffective(r.config),
               // Additive (CREW-2051): worktrees the sweep refuses to remove.
               heldWorktrees: openShipAttention(state).filter((i) => i.kind === "worktree_held" && i.held?.repo === r.name).map((i) => ({
                 path: i.held.path,
@@ -20543,7 +20631,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
           );
         }
         for (const p2 of validateEffective(config)) {
-          process.stdout.write(`                   - ${p2}
+          process.stdout.write(`                   - release readiness: ${p2}
 `);
         }
         const dh = doctorBaseReport(r, config.branch.base, baseHealth);

package/package.json

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