@feigi/fleet-ctl 3.23.13 → 3.23.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feigi/fleet-ctl",
-  "version": "3.23.13",
+  "version": "3.23.15",
   "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/reaping-prose.test.mjs

@@ -48,7 +48,7 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { between, phrase, stripHashGutter } from "./prose-pin.mjs";
+import { between, paragraph, phrase, stripHashGutter } from "./prose-pin.mjs";
 
 const REPO = join(import.meta.dirname, "..");
 const REAPING = readFileSync(
@@ -141,6 +141,58 @@ test("run-team/SKILL.md: the release deletes the branch with update-ref's compar
   );
 });
 
+// The reap paragraph's twin of the release pin above. reap.sh deletes a
+// `[gone]` branch with `git update-ref --no-deref -d refs/heads/<b> <tip>`,
+// never `-D`, and keeps a branch the cherry check cleared whenever a fresh
+// worktree check finds it held — so naming `-D`, or the cherry check as the
+// delete's only authorizer, is false as written.
+const reapParagraph = () =>
+  paragraph(RUN_TEAM, "`~/.fleet/bin/fleet-run reap.sh --apply` recomputes every precondition", "run-team/SKILL.md's reap paragraph");
+
+test("run-team/SKILL.md: reap's cherry check authorizes the update-ref delete, with the fresh worktree check beside it", () => {
+  const p = reapParagraph();
+  assert.match(
+    p,
+    phrase("`git cherry origin/main` to authorize the `git update-ref -d` delete"),
+    "SKILL.md's reap paragraph no longer names the cherry check as authorizing the `git update-ref -d` delete",
+  );
+  assert.match(
+    p,
+    phrase("a fresh check that no worktree holds the branch"),
+    "SKILL.md's reap paragraph no longer names the fresh worktree check — reap.sh keeps a branch the cherry check cleared whenever a worktree holds it",
+  );
+  assert.doesNotMatch(p, /(?:^|[\s`])(?:git\s+branch\s+)?-D\b/, "SKILL.md's reap paragraph names `-D` — reap.sh deletes with `git update-ref -d`");
+  assert.doesNotMatch(
+    p,
+    /\bonly\s+by\b|\bnothing\s+else\b|\bsolely\b|\balone\b/i,
+    "SKILL.md's reap paragraph makes one check the delete's only authorizer — reap.sh's worktree check stops that delete too",
+  );
+});
+
+test("run-team/SKILL.md: the reap paragraph keeps the preconditions it already named", () => {
+  // Input the assertions above must ACCEPT: the corrected clause sits in a
+  // list whose other entries stay as they were.
+  const p = reapParagraph();
+  assert.match(p, phrase("`for-each-ref` for `[gone]`"));
+  assert.match(p, phrase("worktree removal without `--force`"));
+});
+
+test("reap.sh: the worktree check the reap paragraph names runs before the delete", () => {
+  // Live lines only: both names recur in comments, and a comment hit would
+  // read as the code.
+  const lines = readFileSync(join(REPO, "scripts", "reap.sh"), "utf8")
+    .split("\n")
+    .filter((l) => !/^\s*(?:#|echo\b)/.test(l));
+  const only = (re, what) => {
+    const hits = lines.flatMap((l, i) => (re.test(l) ? [i] : []));
+    assert.equal(hits.length, 1, `reap.sh: expected exactly one live line that ${what}, found ${hits.length}`);
+    return hits[0];
+  };
+  const check = only(/^\s*if\s+wt_holding\s+"refs\/heads\/\$b"/, "runs wt_holding on the branch");
+  const del = only(/\bgit\s+update-ref\s+--no-deref\s+-d\s+"refs\/heads\/\$b"\s+"\$tip"/, "runs `git update-ref -d` on the branch at its tip");
+  assert.ok(check < del, "reap.sh runs its worktree check after the delete, not before it");
+});
+
 test("run-team/SKILL.md: the by-hand fallback names worktree-audit.sh's no-argument contract", () => {
   // #525. The by-hand fallback for a claim `release-ticket.sh` refused sends
   // the reader to `worktree-audit.sh`, which takes NO argument and audits

package/skills/run-team/SKILL.md

@@ -3101,9 +3101,10 @@ included (phase 3, **Merge-bot pass reports done**). See references/reaping.md.
 
 `~/.fleet/bin/fleet-run reap.sh --apply` recomputes every precondition
 inside the same invocation as the delete — `for-each-ref` for `[gone]`, `git
-cherry origin/main` to authorize `-D`, worktree removal without `--force` — and
-reports reaped and kept-with-reason counts. Update the reaped tickets' ledger rows
-in the same step. See references/reaping.md.
+cherry origin/main` to authorize the `git update-ref -d` delete (plus a fresh
+check that no worktree holds the branch), worktree removal without `--force` —
+and reports reaped and kept-with-reason counts. Update the reaped tickets' ledger
+rows in the same step. See references/reaping.md.
 
 **It sweeps detached worktrees too — the shape a `[gone]` walk structurally
 cannot see.** Bounded to `.worktrees/`, so a checkout of yours outside it is