@biffo/cli 0.309.0 → 0.309.1

package/dist/index.js

@@ -630,6 +630,7 @@ import { Command as Command3 } from "commander";
 // src/adapters/git/index.ts
 import { randomUUID } from "crypto";
 import { existsSync as existsSync6, mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "fs";
+import { readFile as readFile2, rm } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join6 } from "path";
 
@@ -1237,6 +1238,51 @@ var GitAdapter = class {
   async hasFleetWorktreeClaim(worktreePath) {
     return existsSync6(join6(worktreePath, ".fleet-worktree-claim"));
   }
+  /**
+   * Milliseconds since `worktreePath`'s `.fleet-worktree-claim` lock was
+   * written (biffo-template#1948), or `null` when there is no lock, or its
+   * `holder` file cannot be read and parsed.
+   *
+   * `bin/fleet.sh worktree-claim` (biffo-fleet) writes the holder token on
+   * line 1 and a UTC ISO-8601 timestamp (`now()`, i.e. `date -u
+   * +%Y-%m-%dT%H:%M:%SZ`) on line 2 — this reads that second line and diffs
+   * it against the current time. `null` is the fail-closed default for
+   * "cannot tell": `doctor-reaper.ts` treats it exactly like a live claim,
+   * never like a stale one, the same posture `hasFleetWorktreeClaim` already
+   * takes and fleet.sh's own comment on an unwritten holder file takes ("An
+   * unwritten holder is still a HELD lock").
+   */
+  async fleetWorktreeClaimAgeMs(worktreePath) {
+    try {
+      const raw = await readFile2(join6(worktreePath, ".fleet-worktree-claim", "holder"), "utf8");
+      const claimedAt = raw.split("\n")[1]?.trim();
+      if (!claimedAt) return null;
+      const claimedMs = Date.parse(claimedAt);
+      return Number.isNaN(claimedMs) ? null : Date.now() - claimedMs;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Removes a `.fleet-worktree-claim` lock directory outright (biffo-template#1948).
+   *
+   * Used only once `doctor --fix` has independently judged the lock stale —
+   * see `FLEET_CLAIM_STALE_AFTER_MS` in `lib/doctor-reaper.ts`. Needed because
+   * the lock directory is untracked: leaving it in place after deciding to
+   * disregard it would trip `hasUncommittedChanges`'s `git status
+   * --porcelain` and keep the worktree anyway, under the less specific
+   * `uncommitted-changes` reason, defeating the point of ignoring it.
+   *
+   * Best-effort — swallows any error, so a permissions problem or a
+   * concurrent release falls back to the existing `isDirty` keep path rather
+   * than crashing the whole `--fix` sweep.
+   */
+  async clearStaleFleetWorktreeClaim(worktreePath) {
+    try {
+      await rm(join6(worktreePath, ".fleet-worktree-claim"), { recursive: true, force: true });
+    } catch {
+    }
+  }
   /** Best-effort fetch of the tracking remote, so the ahead/behind check below
    * compares against reality rather than a stale local ref (#394). Never throws:
    * offline or a missing remote must not block an upgrade on its own — the
@@ -16232,6 +16278,7 @@ function runDoctorChecks(facts) {
 }
 
 // src/lib/doctor-reaper.ts
+var FLEET_CLAIM_STALE_AFTER_MS = 4 * 60 * 60 * 1e3;
 function classifyReapCandidate(facts) {
   if (facts.hasFleetClaim) return { action: "keep", reason: "fleet-worktree-claimed" };
   if (facts.isDetached) return { action: "keep", reason: "detached-head" };
@@ -16259,12 +16306,23 @@ function findReapCandidates(branches, worktrees) {
 }
 async function reapCandidate(cwd, candidate, deps) {
   const { git, github } = deps;
-  const [current, isDirty, hasFleetClaim] = await Promise.all([
+  const [current, claimExists] = await Promise.all([
     git.currentBranch(candidate.worktreePath),
-    git.hasUncommittedChanges(candidate.worktreePath),
     git.hasFleetWorktreeClaim(candidate.worktreePath)
   ]);
   const isDetached = current === "HEAD" || current === "";
+  let hasFleetClaim = false;
+  let staleClaimCleared = false;
+  if (claimExists) {
+    const ageMs = await git.fleetWorktreeClaimAgeMs(candidate.worktreePath);
+    if (ageMs === null || ageMs < FLEET_CLAIM_STALE_AFTER_MS) {
+      hasFleetClaim = true;
+    } else {
+      await git.clearStaleFleetWorktreeClaim(candidate.worktreePath);
+      staleClaimCleared = true;
+    }
+  }
+  const isDirty = await git.hasUncommittedChanges(candidate.worktreePath);
   const prVerdict = isDetached || isDirty || hasFleetClaim ? "unknown" : await github.prVerdictForBranch(cwd, candidate.branch);
   let mergeContainsHead = true;
   if (prVerdict === "merged") {
@@ -16282,10 +16340,10 @@ async function reapCandidate(cwd, candidate, deps) {
     mergeContainsHead
   });
   if (verdict.action === "keep") {
-    return { candidate, verdict, worktreeRemoved: null };
+    return { candidate, verdict, worktreeRemoved: null, staleClaimCleared };
   }
   const worktreeRemoved = await git.removeWorktree(cwd, candidate.worktreePath);
-  return { candidate, verdict, worktreeRemoved };
+  return { candidate, verdict, worktreeRemoved, staleClaimCleared };
 }
 async function reapAll(cwd, branches, worktrees, currentBranch, deps) {
   const candidates = findReapCandidates(branches, worktrees).filter(
@@ -16486,28 +16544,36 @@ function printReapOutcomes(outcomes) {
   const kept = outcomes.filter((o) => o.verdict.action === "keep");
   const removed = attempted.filter((o) => o.worktreeRemoved === true);
   const failed = attempted.filter((o) => o.worktreeRemoved !== true);
+  const staleClaims = outcomes.filter((o) => o.staleClaimCleared);
   console.log("");
   for (const o of attempted) {
+    const staleNote = o.staleClaimCleared ? " (after clearing a stale fleet-worktree-claim lock)" : "";
     if (o.worktreeRemoved === true) {
-      console.log(chalk21.green(`  removed  ${o.candidate.worktreePath} (${o.candidate.branch})`));
+      console.log(
+        chalk21.green(`  removed  ${o.candidate.worktreePath} (${o.candidate.branch})${staleNote}`)
+      );
     } else {
       console.log(
         chalk21.red(
-          `  FAILED   ${o.candidate.worktreePath} (${o.candidate.branch}) \u2014 judged safe to remove but 'git worktree remove' did not succeed; left as-is`
+          `  FAILED   ${o.candidate.worktreePath} (${o.candidate.branch}) \u2014 judged safe to remove but 'git worktree remove' did not succeed; left as-is${staleNote}`
         )
       );
     }
   }
   for (const o of kept) {
     const reason = o.verdict.reason === void 0 ? "unknown" : KEEP_REASON_TEXT[o.verdict.reason];
+    const staleNote = o.staleClaimCleared ? " (its stale fleet-worktree-claim lock was cleared first)" : "";
     console.log(
-      chalk21.dim(`  kept     ${o.candidate.worktreePath} (${o.candidate.branch}) \u2014 ${reason}`)
+      chalk21.dim(
+        `  kept     ${o.candidate.worktreePath} (${o.candidate.branch}) \u2014 ${reason}${staleNote}`
+      )
     );
   }
+  const staleClaimNote = staleClaims.length > 0 ? ` (${String(staleClaims.length)} had a stale fleet-worktree-claim lock cleared)` : "";
   console.log(
     chalk21.dim(
       `
-  --fix: ${String(removed.length)} removed, ${String(failed.length)} failed, ${String(kept.length)} kept, of ${String(outcomes.length)} worktree(s) considered.
+  --fix: ${String(removed.length)} removed, ${String(failed.length)} failed, ${String(kept.length)} kept, of ${String(outcomes.length)} worktree(s) considered${staleClaimNote}.
 `
     )
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biffo/cli",
-  "version": "0.309.0",
+  "version": "0.309.1",
   "description": "Biffo project scaffolding CLI",
   "license": "MIT",
   "type": "module",