@feigi/fleet-ctl 3.23.14 → 3.23.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feigi/fleet-ctl",
-  "version": "3.23.14",
+  "version": "3.23.16",
   "description": "Agent fleet: run-team controller, merge bot, PR reviewer, and the ticket pipeline they share",
   "license": "Apache-2.0",
   "repository": {

package/scripts/citation-sweep-prose.test.mjs

@@ -499,7 +499,16 @@ const FILES = [
     // other number straight back in, and this file already carried the
     // identical stale number at two independent sites.
     path: ["scripts", "fleet-heartbeat.mjs"],
-    stale: [/run-merge-bot\.md:\d+/],
+    // #2667. The header once said run-merge-bot.md's CI gate holds its wait
+    // "and re-issuing it", and the several-holds paragraph once called the
+    // heartbeat "the same remedy the CI gate reached for". The CI wait holds
+    // in one `eval` cell and re-issues nothing. Tolerant of a re-wrap: the
+    // comment is hard-wrapped, so either phrase can break across a `//` line.
+    stale: [
+      /run-merge-bot\.md:\d+/,
+      /re-issuing\s+(?:\/\/\s*)?it\b/,
+      /same remedy the\s+(?:\/\/\s*)?CI gate/,
+    ],
     // One needle per SITE — either can revert independently of the other.
     live: [
       "run-merge-bot.md's CI wait rule already states",

package/scripts/fleet-heartbeat.mjs

@@ -18,7 +18,7 @@
 //   roughly two hours; neither ever woke it. run-merge-bot.md's CI gate states
 //   the same rule as a rule — "whatever wakes you is external and may never
 //   come" — and cures it the same way this file does, by holding the wait
-//   inside one blocking command and re-issuing it.
+//   inside one blocking call.
 //
 //   So the heartbeat is not a Monitor, not a cron entry and not a paragraph of
 //   prose. A cron entry that ran the reconcile would print its rows to nobody:
@@ -66,9 +66,8 @@ export function interval({ quiet, base, ceiling, multiplier }) {
 // rule already states.
 //
 // So a long interval is served by SEVERAL holds, and the elapsed total is
-// persisted rather than counted in prose. That is the same remedy the CI gate
-// reached for, made mechanical: the script says how much remains, so the
-// controller re-issues without tracking arithmetic across turns.
+// persisted rather than counted in prose: the script says how much remains, so
+// the controller re-issues without tracking arithmetic across turns.
 export function heldThisCall({ elapsed, target, hold }) {
   return Math.min(hold, Math.max(0, target - elapsed));
 }

package/scripts/release-ticket-reap-pairing-prose.test.mjs

@@ -0,0 +1,63 @@
+// release-ticket.sh's comment above its branch delete contrasts the release's
+// pairing (the `ahead` and `git cherry` guards, the recount at the delete, the
+// fresh worktree check) with reap.sh's. It said reap.sh authorizes its own
+// [gone] deletes with `git cherry` ALONE, but reap.sh also re-reads the
+// worktree listing and keeps any branch `wt_holding` reports held or cannot
+// resolve, before the same kind of compare-and-swap delete. What reap.sh does
+// lack is the `ahead` count and the recount: `git cherry` is the only check
+// there that asks whether the branch is merged.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { phrase, runAbove, stripHashGutter } from "./prose-pin.mjs";
+
+const RELEASE = readFileSync(join(import.meta.dirname, "release-ticket.sh"), "utf8");
+// reap.sh's code lines only: a whole-line `#` comment that mentions a command
+// is neither a call nor a guard, so it must satisfy no check below and fail none.
+const REAP = readFileSync(join(import.meta.dirname, "reap.sh"), "utf8")
+  .split("\n")
+  .filter((line) => !/^\s*#/.test(line))
+  .join("\n");
+
+const deleteComment = () => {
+  const comment = stripHashGutter(
+    runAbove(RELEASE, 'echo "\\$ git update-ref -d refs/heads/$branch $tip" >&2', "release-ticket.sh branch delete", "#"),
+  );
+  // runAbove returns "" rather than throwing when no comment run sits directly
+  // above the anchor; without this the negative pin would pass on nothing.
+  assert.notEqual(comment, "", "no comment run sits directly above release-ticket.sh's branch delete — the pins have nothing to read");
+  return comment;
+};
+
+test("release-ticket.sh: the delete comment does not say reap.sh deletes on `git cherry` alone", () => {
+  assert.doesNotMatch(
+    deleteComment(),
+    new RegExp(phrase("deletes with `git cherry` alone").source, "i"),
+    "release-ticket.sh's delete comment says reap.sh authorizes its [gone] deletes with `git cherry` alone — reap.sh also re-checks the worktree with `wt_holding` before its delete",
+  );
+});
+
+test("release-ticket.sh: the delete comment still says how reap.sh's pairing differs", () => {
+  // Input the pin above must ACCEPT: the contrast the sentence exists for —
+  // reap.sh has no `ahead` count and no recount — survives, beside the
+  // worktree check reap.sh shares with the release.
+  const comment = deleteComment();
+  assert.match(comment, phrase("with `git cherry` alone — no `ahead` count, no recount"));
+  assert.match(comment, phrase("re-checks the worktree with `wt_holding`"));
+});
+
+test("reap.sh: the branch delete still follows a `wt_holding` check and has no `ahead` recount", () => {
+  // The target side of the comment's claim, so a change to reap.sh that makes
+  // it false reds here rather than leaving release-ticket.sh's prose stale.
+  const held = REAP.indexOf('if wt_holding "refs/heads/$b"');
+  const del = REAP.indexOf('git update-ref --no-deref -d "refs/heads/$b" "$tip"');
+  assert.ok(held !== -1, "reap.sh no longer checks `wt_holding` on the [gone] branch");
+  assert.ok(del !== -1, "reap.sh no longer deletes the [gone] branch with a compare-and-swap `update-ref -d`");
+  assert.ok(held < del, "reap.sh's `wt_holding` check no longer runs before its branch delete");
+  assert.doesNotMatch(
+    REAP,
+    /rev-list\b[^\n]*--count|--count[^\n]*rev-list/,
+    "reap.sh now counts commits ahead — release-ticket.sh's comment says it has no `ahead` count",
+  );
+});

package/scripts/release-ticket.sh

@@ -1679,9 +1679,11 @@ else
 
     # update-ref, authorized by the `ahead` and `git cherry` guards above,
     # this recount, and the worktree check above — and carrying its own
-    # compare-and-swap on $tip on top, which `-D` never had. reap.sh
-    # authorizes its own [gone] deletes with `git cherry` ALONE — not this
-    # pairing. `-d` measures against HEAD and the branch's upstream, and a
+    # compare-and-swap on $tip on top, which `-D` never had. reap.sh asks
+    # whether its own [gone] branches are merged with `git cherry` alone — no
+    # `ahead` count, no recount — so not this pairing, though it too
+    # re-checks the worktree with `wt_holding` before its own compare-and-swap
+    # delete. `-d` measures against HEAD and the branch's upstream, and a
     # claim has no upstream until its first push (claim-ticket.sh passes
     # --no-track), so `-d` falls back to local HEAD alone and refuses a
     # pristine claim whenever local main is behind origin/main —