@feigi/fleet-ctl 3.18.11 → 3.18.12

package/package.json

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

package/scripts/claim-lifecycle.test.mjs

@@ -18,6 +18,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeExecStub } from "./exec-stub.mjs";
+import { worktreeNames } from "./worktree-porcelain.mjs";
 
 const CLAIM = fileURLToPath(new URL("./claim-ticket.sh", import.meta.url));
 const REAP = fileURLToPath(new URL("./reap.sh", import.meta.url));
@@ -111,7 +112,7 @@ test("a freshly claimed branch is not [gone], and reap.sh leaves it alone", (t)
   assert.deepEqual(JSON.parse(reaped.stdout).reaped, []);
   // Positive control on the same run: the branch and its worktree survived.
   assert.equal(f.git(f.w, "rev-parse", "--verify", "refs/heads/fix/42-slug").length, 40);
-  assert.match(f.git(f.w, "worktree", "list"), /42-slug/);
+  assert.ok(worktreeNames(f.git(f.w, "worktree", "list", "--porcelain")).includes("42-slug"));
 });
 
 test("after push -u, merge and prune, reap.sh does see the branch as [gone]", (t) => {

package/scripts/reap.test.mjs

@@ -17,6 +17,7 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { slowTransport, SSH_URL } from "./slow-transport.mjs";
 import { writeExecStub } from "./exec-stub.mjs";
+import { hasAttribute, worktreeNames } from "./worktree-porcelain.mjs";
 
 const SCRIPT = fileURLToPath(new URL("./reap.sh", import.meta.url));
 
@@ -43,6 +44,9 @@ const ENV = {
 const git = (cwd, ...args) =>
   execFileSync("git", args, { cwd, env: ENV, encoding: "utf8" }).trim();
 
+/** worktreeNames() of `w`'s listing: never its paths, which carry TMPDIR (#2531). */
+const listedNames = (w) => worktreeNames(git(w, "worktree", "list", "--porcelain"));
+
 // Absolute path to the real git, for any test that shadows `git` on PATH.
 const REAL_GIT = execFileSync("sh", ["-c", "command -v git"], { encoding: "utf8" }).trim();
 
@@ -746,14 +750,14 @@ test("a successful --apply run still reaps, still prunes, and exits 0 unchanged"
   const wtDir = join(w, "..", "stale-wt");
   git(w, "worktree", "add", "-q", "-b", "scratch/stale", wtDir, "main");
   rmSync(wtDir, { recursive: true, force: true });
-  assert.match(git(w, "worktree", "list"), /stale-wt/, "fixture must start with a prunable registration");
+  assert.ok(listedNames(w).includes("stale-wt"), "fixture must start with a prunable registration");
 
   const { code, json } = runReap(w, ["--apply"]);
 
   assert.equal(code, 0);
   assert.deepEqual(json.reaped, ["feature/merged"]);
   assert.deepEqual(json.kept, []);
-  assert.doesNotMatch(git(w, "worktree", "list"), /stale-wt/, "the prune must still run and clear the stale registration");
+  assert.ok(!listedNames(w).includes("stale-wt"), "the prune must still run and clear the stale registration");
 });
 
 // The other half of the same guard, and the half no test had: the default
@@ -1307,7 +1311,7 @@ test("a [gone] branch whose worktree directory was deleted by hand is reaped, ne
   const w = repo(t);
   const wt = mergedGoneBranchWithWorktree(w, "feature/merged", "merged work");
   rmSync(wt, { recursive: true, force: true });
-  assert.match(git(w, "worktree", "list"), /feature\/merged/, "fixture: the stale registration must still be listed");
+  assert.ok(listedNames(w).includes("feature/merged"), "fixture: the stale registration must still be listed");
 
   const { code, json } = runReap(w, ["--apply"]);
 
@@ -1315,7 +1319,7 @@ test("a [gone] branch whose worktree directory was deleted by hand is reaped, ne
   assert.deepEqual(json.reaped, ["feature/merged"], "a directory that is not there holds no work to protect");
   assert.deepEqual(json.kept, []);
   assert.equal(branchExists(w, "feature/merged"), false);
-  assert.doesNotMatch(git(w, "worktree", "list"), /feature\/merged/, "the stale registration must not survive the run");
+  assert.ok(!listedNames(w).includes("feature/merged"), "the stale registration must not survive the run");
 });
 
 test("a dry run and --apply agree about a deleted worktree directory (#128)", (t) => {
@@ -2010,7 +2014,7 @@ test("a refusal that LEFT the registration in place is reported as such, distinc
   assert.doesNotMatch(json.kept[0].reason, /\n/, "git's message here really is two lines — it must arrive flattened");
   assert.match(stderr, /KEEP feature\/merged/);
 
-  assert.match(git(w, "worktree", "list", "--porcelain"), /feature\/merged/, "the registration really did survive");
+  assert.ok(listedNames(w).includes("feature/merged"), "the registration really did survive");
   assert.equal(existsSync(wt), true);
   assert.equal(branchExists(w, "feature/merged"), true);
 });
@@ -2543,9 +2547,9 @@ test("the dry run removes nothing, and still cannot predict a refusal (#391)", (
   // Nothing was touched: directories, registrations and branches all intact.
   assert.equal(existsSync(healthy), true, "a dry run must not remove the worktree it COULD have removed");
   assert.equal(existsSync(locked), true);
-  const reg = git(w, "worktree", "list", "--porcelain");
-  assert.match(reg, /feature\/a-healthy/);
-  assert.match(reg, /feature\/b-locked/);
+  const reg = listedNames(w);
+  assert.ok(reg.includes("feature/a-healthy"));
+  assert.ok(reg.includes("feature/b-locked"));
   assert.equal(branchExists(w, "feature/a-healthy"), true);
   assert.equal(branchExists(w, "feature/b-locked"), true);
 });
@@ -2663,7 +2667,8 @@ test("a detached worktree whose HEAD is merged is removed, not walked past (#381
   const w = repo(t);
   const wt = detachedMergedWorktree(w, "docs/79-brief", "work that landed");
   assert.ok(existsSync(wt), "fixture");
-  assert.match(git(w, "worktree", "list"), /\(detached HEAD\)/, "fixture: the worktree must really be detached");
+  assert.ok(hasAttribute(git(w, "worktree", "list", "--porcelain"), "detached"), "fixture: the worktree must really be detached");
+  assert.ok(listedNames(w).includes("79-brief"), "fixture: the worktree must start out listed");
 
   const { code, json, stderr } = runReap(w, ["--apply"]);
 
@@ -2674,7 +2679,7 @@ test("a detached worktree whose HEAD is merged is removed, not walked past (#381
   assert.ok(stderr.includes(`    REMOVED worktree ${wt}`), `the removal must be reported: ${stderr}`);
   // The registration goes with it, or the in-flight probe still reads the
   // ticket as taken — the whole cost this ticket exists to stop.
-  assert.doesNotMatch(git(w, "worktree", "list", "--porcelain"), /79-brief/);
+  assert.ok(!listedNames(w).includes("79-brief"));
 });
 
 test("a branchless sweep whose awk cannot read the listing declines, never sweeps silently (#993)", (t) => {
@@ -2798,7 +2803,7 @@ test("a detached worktree whose HEAD git cannot resolve is kept, never swept (#3
   writeFileSync(join(adminEntry(w, wt), "HEAD"), "not an object id\n");
   assert.match(
     git(w, "worktree", "list", "--porcelain"),
-    /HEAD 0{40}/,
+    /^HEAD 0{40}$/m,
     "fixture: git must report the null object id for this worktree",
   );
 
@@ -2958,14 +2963,15 @@ test("a detached worktree whose directory was deleted by hand still has its regi
   const w = repo(t);
   const wt = detachedMergedWorktree(w, "docs/79-brief", "work that landed");
   rmSync(wt, { recursive: true, force: true });
-  assert.match(git(w, "worktree", "list", "--porcelain"), /prunable/, "fixture: the stale registration must still be listed");
+  assert.ok(hasAttribute(git(w, "worktree", "list", "--porcelain"), "prunable"), "fixture: the stale registration must still be listed");
+  assert.ok(listedNames(w).includes("79-brief"), "fixture: the stale registration must be listed by name before the run");
 
   const { code, json } = runReap(w, ["--apply"]);
 
   assert.equal(code, 0);
   assert.deepEqual(json.worktreesRemoved, [wt]);
   assert.deepEqual(json.kept, []);
-  assert.doesNotMatch(git(w, "worktree", "list", "--porcelain"), /79-brief/);
+  assert.ok(!listedNames(w).includes("79-brief"));
 });
 
 test("a detached worktree behind an unreadable parent is kept, never removed as absent (#381, #83)", (t) => {

package/scripts/release-ticket.test.mjs

@@ -22,6 +22,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { slowTransport, SSH_URL } from "./slow-transport.mjs";
 import { writeExecStub } from "./exec-stub.mjs";
+import { hasAttribute } from "./worktree-porcelain.mjs";
 
 const SCRIPT = fileURLToPath(new URL("./release-ticket.sh", import.meta.url));
 const INFLIGHT = fileURLToPath(new URL("./inflight.sh", import.meta.url));
@@ -994,6 +995,7 @@ test("the locked-stray unlock hint survives a literal ' in the worktree path (#1
   git(c.wt, "checkout", "-q", "--detach", "HEAD");
   git(r.w, "worktree", "lock", c.wt, "--reason", "held by a review");
   rmSync(c.wt, { recursive: true, force: true });
+  assert.ok(hasAttribute(git(r.w, "worktree", "list", "--porcelain"), "locked"), "fixture: the stray must really be locked before the remedy runs");
 
   const { code, json, stderr } = release(r, c);
   assert.equal(code, 1, stderr);
@@ -1005,7 +1007,7 @@ test("the locked-stray unlock hint survives a literal ' in the worktree path (#1
   execFileSync("sh", ["-c", remedy], { cwd: r.w, encoding: "utf8", env: ENV });
 
   assert.ok(
-    !git(r.w, "worktree", "list", "--porcelain").includes("locked"),
+    !hasAttribute(git(r.w, "worktree", "list", "--porcelain"), "locked"),
     `the pasted command actually unlocked the real entry, not a truncated one: ${remedy}`,
   );
 });
@@ -1034,6 +1036,7 @@ test("the locked-stray unlock hint survives a plain space in the worktree path (
   git(c.wt, "checkout", "-q", "--detach", "HEAD");
   git(r.w, "worktree", "lock", c.wt, "--reason", "held by a review");
   rmSync(c.wt, { recursive: true, force: true });
+  assert.ok(hasAttribute(git(r.w, "worktree", "list", "--porcelain"), "locked"), "fixture: the stray must really be locked before the remedy runs");
 
   const { code, json, stderr } = release(r, c);
   assert.equal(code, 1, stderr);
@@ -1045,7 +1048,7 @@ test("the locked-stray unlock hint survives a plain space in the worktree path (
   execFileSync("sh", ["-c", remedy], { cwd: r.w, encoding: "utf8", env: ENV });
 
   assert.ok(
-    !git(r.w, "worktree", "list", "--porcelain").includes("locked"),
+    !hasAttribute(git(r.w, "worktree", "list", "--porcelain"), "locked"),
     `the pasted command actually unlocked the real entry, not a truncated one: ${remedy}`,
   );
 });
@@ -2732,7 +2735,7 @@ test("an unrelated prunable worktree does not block release of a branch it never
   const stale = join(r.w, "..", "stale-wt");
   git(r.w, "worktree", "add", "-q", "--detach", stale, "origin/main");
   rmSync(stale, { recursive: true, force: true });
-  assert.match(git(r.w, "worktree", "list", "--porcelain"), /prunable/, "fixture: the stale registration must still be listed");
+  assert.ok(hasAttribute(git(r.w, "worktree", "list", "--porcelain"), "prunable"), "fixture: the stale registration must still be listed");
 
   const { code, json, stderr } = release(r, c);
   assert.equal(code, 0, stderr);
@@ -2748,7 +2751,7 @@ test("a prunable sibling that genuinely holds the claim via a stopped rebase sti
   // no longer exists to be entered.
   const { r, c, sib } = heldSibling(t, stopAtEditRebase);
   rmSync(sib, { recursive: true, force: true });
-  assert.match(git(r.w, "worktree", "list", "--porcelain"), /prunable/, "fixture: the sibling's directory must be gone, its registration still there");
+  assert.ok(hasAttribute(git(r.w, "worktree", "list", "--porcelain"), "prunable"), "fixture: the sibling's directory must be gone, its registration still there");
 
   const { code, json, stderr } = release(r, c);
   assert.equal(code, 2, stderr);
@@ -3605,9 +3608,8 @@ test("a worktree with no surviving ancestor below / still releases, never a perm
   // died BEFORE it, so a fix that merely downgraded that `die` to a warning
   // would exit 0 here too, with the stale registration still standing and the
   // claim reported released — the same false success from the other side.
-  assert.doesNotMatch(
-    git(r.w, "worktree", "list", "--porcelain"),
-    /nonexistent-top-level-178/,
+  assert.ok(
+    !git(r.w, "worktree", "list", "--porcelain").split("\n").includes(`worktree ${dest}`),
     "the registration must actually be gone, not merely un-refused",
   );
 });

package/scripts/worktree-porcelain.mjs

@@ -0,0 +1,35 @@
+// What a test guard may ask of a `git worktree list --porcelain` listing.
+//
+// Every `worktree` line carries the full path, and a fixture's path starts
+// with the operator's TMPDIR, so a guard that greps the whole listing for a
+// fixture's name or for an attribute answers for TMPDIR as well: one holding
+// `locked`, `stale-wt` or `79-brief` failed the guard that looks for its
+// absence (#2531). These read only the parts a fixture controls.
+
+/**
+ * The names the listing gives its worktrees: each `worktree` line's last path
+ * component, and each `branch refs/heads/` line's branch. The directories
+ * above a worktree are never a name.
+ */
+export const worktreeNames = (porcelain) =>
+  porcelain.split("\n").flatMap((l) =>
+    l.startsWith("worktree ") ? [l.slice("worktree ".length).replace(/.*\//, "")]
+    : l.startsWith("branch refs/heads/") ? [l.slice("branch refs/heads/".length)]
+    : []);
+
+const ATTRIBUTES = new Set(["locked", "prunable", "detached"]);
+
+/**
+ * Whether any worktree in the listing carries the attribute `attr`
+ * (`locked`, `prunable`, `detached`). git prints an attribute on a line of its
+ * own, the bare word or the word, a space and a reason, so the line is matched
+ * whole and a path containing the word never is. Any other `attr` throws: a
+ * misspelling would answer false for ever, and a guard that asserts the
+ * attribute's absence would pass on it.
+ */
+export const hasAttribute = (porcelain, attr) => {
+  if (!ATTRIBUTES.has(attr)) {
+    throw new Error(`hasAttribute: unknown attribute ${JSON.stringify(attr)}; one of ${[...ATTRIBUTES].join(", ")}`);
+  }
+  return porcelain.split("\n").some((l) => l === attr || l.startsWith(`${attr} `));
+};

package/scripts/worktree-porcelain.test.mjs

@@ -0,0 +1,102 @@
+// worktree-porcelain.mjs against real `git worktree list --porcelain` output.
+// Zero deps: `node --test plugin/scripts/worktree-porcelain.test.mjs`.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { hasAttribute, worktreeNames } from "./worktree-porcelain.mjs";
+
+const ENV = {
+  ...process.env,
+  GIT_DIR: undefined,
+  GIT_WORK_TREE: undefined,
+  GIT_AUTHOR_NAME: "t",
+  GIT_AUTHOR_EMAIL: "t@example.com",
+  GIT_COMMITTER_NAME: "t",
+  GIT_COMMITTER_EMAIL: "t@example.com",
+  GIT_CONFIG_GLOBAL: "/dev/null",
+  GIT_CONFIG_SYSTEM: "/dev/null",
+};
+
+const git = (cwd, ...args) =>
+  execFileSync("git", args, { cwd, env: ENV, encoding: "utf8" }).trim();
+
+/**
+ * A checkout on `main` whose parent directories spell the attributes the guards
+ * look for (`locked`, `prunable`, `detached`) and some of the names they look
+ * for (`feature/merged`, `79-brief`), the way an operator's TMPDIR can.
+ */
+function repoUnder(t) {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "worktree-porcelain-")));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  const w = join(root, "locked", "prunable", "detached", "feature", "merged", "79-brief", "w");
+  mkdirSync(w, { recursive: true });
+  execFileSync("git", ["-c", "init.defaultBranch=main", "init", "-q", w], { env: ENV });
+  git(w, "commit", "-q", "--allow-empty", "-m", "root");
+  return w;
+}
+
+const listing = (w) => git(w, "worktree", "list", "--porcelain");
+
+test("a name or attribute that is only in a worktree's parent directories is not reported", (t) => {
+  const w = repoUnder(t);
+  git(w, "worktree", "add", "-q", "-b", "fix/9-x", join(w, ".worktrees", "9-x"), "main");
+  const l = listing(w);
+  for (const word of ["locked", "prunable", "detached", "feature/merged", "79-brief"]) {
+    assert.ok(l.includes(word), `fixture: the listing must carry ${word} in a path: ${l}`);
+  }
+
+  assert.deepEqual(worktreeNames(l), ["w", "main", "9-x", "fix/9-x"]);
+  for (const attr of ["locked", "prunable", "detached"]) {
+    assert.equal(hasAttribute(l, attr), false, `${attr} is only a parent directory here: ${l}`);
+  }
+});
+
+test("a worktree's own basename, branch and attributes are reported", (t) => {
+  const w = repoUnder(t);
+  const brief = join(w, ".worktrees", "79-brief");
+  git(w, "worktree", "add", "-q", "-b", "feature/merged", brief, "main");
+  const lone = join(w, ".worktrees", "lone");
+  git(w, "worktree", "add", "-q", "--detach", lone, "main");
+
+  assert.deepEqual(worktreeNames(listing(w)), ["w", "main", "79-brief", "feature/merged", "lone"]);
+  assert.equal(hasAttribute(listing(w), "detached"), true, "the bare-word form");
+
+  git(w, "worktree", "lock", brief, "--reason", "held by a review");
+  assert.match(listing(w), /^locked held by a review$/m, "fixture: a reason follows the word on its line");
+  assert.equal(hasAttribute(listing(w), "locked"), true, "the word-and-reason form");
+  git(w, "worktree", "unlock", brief);
+  git(w, "worktree", "lock", brief);
+  assert.equal(hasAttribute(listing(w), "locked"), true);
+  git(w, "worktree", "unlock", brief);
+  assert.equal(hasAttribute(listing(w), "locked"), false);
+
+  rmSync(lone, { recursive: true, force: true });
+  assert.equal(hasAttribute(listing(w), "prunable"), true);
+});
+
+test("a lock reason that spells a guard's prefix is not a name", (t) => {
+  const w = repoUnder(t);
+  const a = join(w, ".worktrees", "a");
+  git(w, "worktree", "add", "-q", "-b", "fix/a", a, "main");
+  git(w, "worktree", "lock", a, "--reason", "worktree on usb");
+  const b = join(w, ".worktrees", "b");
+  git(w, "worktree", "add", "-q", "-b", "fix/b", b, "main");
+  git(w, "worktree", "lock", b, "--reason", "branch refs/heads/held");
+  const c = join(w, ".worktrees", "c");
+  git(w, "worktree", "add", "-q", "-b", "fix/c", c, "main");
+  git(w, "worktree", "lock", c, "--reason", "see refs/heads/held");
+  const l = listing(w);
+  for (const reason of ["worktree on usb", "branch refs/heads/held", "see refs/heads/held"]) {
+    assert.match(l, new RegExp(`^locked ${reason}$`, "m"), `fixture: the reason is on its own line: ${l}`);
+  }
+
+  assert.deepEqual(worktreeNames(l), ["w", "main", "a", "fix/a", "b", "fix/b", "c", "fix/c"]);
+});
+
+test("an attribute git never prints is refused, not answered false", () => {
+  assert.throws(() => hasAttribute("worktree /x\nlocked\n", "lock"), /unknown attribute "lock"/);
+});