@tablation/crew 0.45.0 → 0.45.3

package/dist/cli.js

@@ -4804,7 +4804,6 @@ function referenceKeys(t) {
 }
 var RESOLVED_STATUSES = new Set(DEFAULT_CONTRACT.statuses.resolved);
 var encodeFilters = (f) => JSON.stringify(f);
-var encodeSort = (s) => JSON.stringify(s);
 var Tracker = class {
   // NB: explicit fields, not TypeScript parameter properties — node's
   // --experimental-strip-types cannot transform those, and the test runner
@@ -4864,37 +4863,41 @@ var Tracker = class {
     });
   }
   /**
-   * Tickets at a terminal, no-longer-open status — the worktree sweep's
-   * input (ISSUE-346).
+   * The tickets behind a set of ticket numbers — the cleanup sweeps' input
+   * (CREW-1593).
    *
-   * The exact complement of `openTickets()`: `closed_deployed`,
-   * `closed_wont_fix`, `closed_duplicate`. `verified` is excluded even
-   * though the contract counts it as resolved for a *blocker*'s purposes —
-   * it is still pre-release, and its worktree is exactly what the release
-   * phase is about to merge.
+   * The sweeps used to fetch "every closed ticket, newest `updated_at` first,
+   * capped at 500" and hope the tickets they cared about were in the page. They
+   * were not once the board held more than 500 closed tickets, and a bulk
+   * write gave 1457 of them one identical `updated_at`, so which ones made the
+   * page was arbitrary and a deployed ticket's worktree/branch was silently
+   * never swept. The caller now names the numbers it actually has a worktree
+   * or remote branch for, so the request is bounded by those and not by how
+   * many tickets are closed.
    *
-   * Sorted most-recently-updated first: a board can hold far more than
-   * `limit` closed tickets (this one already has), and an unordered fetch
-   * has no guarantee which ones a truncated page contains. Ordering by
-   * `updatedAt` descending means a truncated page still holds the tickets
-   * most likely to need their worktree swept — the ones that closed most
-   * recently — rather than an arbitrary, possibly stale slice (ISSUE-403).
+   * Matched on `issue_id`, in the raw, unpadded and 3-digit-padded spellings a
+   * number has been stored under. `onTruncated` is told when a page came back
+   * full, since anything past it would be missing without a trace.
    */
-  async terminalTickets() {
+  async ticketsByNumbers(nums, onTruncated) {
     const c = this.contract;
-    const statuses = closedStatuses(c);
-    if (!statuses.length) return [];
-    const filters = [
-      { columnName: c.columns.status, operator: "IN", value: statuses }
-    ];
-    const areaId = this.route.resolved?.areaId;
-    if (areaId) filters.push({ columnName: c.columns.slice, operator: "EQ", value: areaId });
-    const params = {
-      filters: encodeFilters(filters),
-      limit: 500,
-      sort: encodeSort([{ columnName: c.columns.updatedAt, direction: "desc" }])
-    };
-    return this.client.records.list(this.models.issues, params);
+    const keys = /* @__PURE__ */ new Set();
+    for (const raw of nums) {
+      const unpadded = String(Number.parseInt(raw, 10));
+      for (const n of [raw, unpadded, unpadded.padStart(3, "0")]) keys.add(`ISSUE-${n}`);
+    }
+    const all = [...keys];
+    const out = [];
+    const limit = 500;
+    for (let i = 0; i < all.length; i += 100) {
+      const page = await this.client.records.list(this.models.issues, {
+        filters: encodeFilters([{ columnName: c.columns.key, operator: "IN", value: all.slice(i, i + 100) }]),
+        limit
+      });
+      if (page.length >= limit) onTruncated?.(limit);
+      out.push(...page);
+    }
+    return out;
   }
   /**
    * Tickets by id, for blockers that have already closed and so are absent
@@ -11098,6 +11101,14 @@ function planWorktreeSweep(target, tickets, contract) {
   }
   return actions;
 }
+function worktreeTicketNumbers(target) {
+  const nums = /* @__PURE__ */ new Set();
+  for (const w of worktrees(target.dir)) {
+    const m = /(?:^|-)(\d+)$/.exec(basename8(w.path));
+    if (m) nums.add(m[1]);
+  }
+  return [...nums];
+}
 async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin") {
   let removed = 0;
   let keptBranches = 0;
@@ -11156,8 +11167,28 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
   }
   return { removed, keptBranches };
 }
+function remoteBranchTicketNumbers(cwd, remote, base) {
+  if (!remoteConfigured(cwd, remote)) return [];
+  const prefix = `refs/remotes/${remote}/`;
+  const refs = (gitOk(cwd, ["for-each-ref", "--format=%(refname)", prefix]) ?? "").split("\n").filter(Boolean);
+  const nums = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    const name = ref.slice(prefix.length);
+    if (name === "HEAD" || name === base) continue;
+    const m = /^.+?-(\d+)(?:-.*)?$/.exec(name);
+    if (m) nums.add(m[1]);
+  }
+  return [...nums];
+}
 function planRemoteBranchCleanup(cwd, remote, base, tickets, contract) {
   if (!remoteConfigured(cwd, remote)) return [];
+  const stems = deployedBranchStems(tickets, contract);
+  if (stems.size === 0) return [];
+  const prefix = `refs/remotes/${remote}/`;
+  const refs = (gitOk(cwd, ["for-each-ref", "--format=%(refname)", prefix]) ?? "").split("\n").filter(Boolean);
+  return refs.map((ref) => ref.slice(prefix.length)).filter((name) => isTicketBranch(name, base, stems));
+}
+function deployedBranchStems(tickets, contract) {
   const stems = /* @__PURE__ */ new Set();
   for (const t of tickets) {
     if (t.status !== contract.statuses.deployed) continue;
@@ -11169,17 +11200,48 @@ function planRemoteBranchCleanup(cwd, remote, base, tickets, contract) {
       stems.add(`${p}-${unpadded}`);
     }
   }
+  return stems;
+}
+function isTicketBranch(name, base, stems) {
+  if (name === "HEAD" || name === base) return false;
+  const m = /^(.+?-\d+)(?:-.*)?$/.exec(name);
+  return !!m && stems.has(m[1]);
+}
+function sweepCandidatesExist(cwd, base) {
+  const linked = worktrees(cwd).slice(1);
+  if (linked.some((w) => /(?:^|-)\d+$/.test(basename8(w.path)))) return true;
+  return localBranches(cwd).some((b) => b !== base && /-\d+(?:-.*)?$/.test(b));
+}
+function localBranchTicketNumbers(cwd, base) {
+  const nums = /* @__PURE__ */ new Set();
+  for (const b of localBranches(cwd)) {
+    const m = b === base ? null : /^.+?-(\d+)(?:-.*)?$/.exec(b);
+    if (m) nums.add(m[1]);
+  }
+  return [...nums];
+}
+function localBranches(cwd) {
+  return (gitOk(cwd, ["branch", "--list", "--format=%(refname:short)"]) ?? "").split("\n").filter(Boolean);
+}
+function planLocalBranchCleanup(cwd, base, tickets, contract) {
+  const stems = deployedBranchStems(tickets, contract);
   if (stems.size === 0) return [];
-  const prefix = `refs/remotes/${remote}/`;
-  const refs = (gitOk(cwd, ["for-each-ref", "--format=%(refname)", prefix]) ?? "").split("\n").filter(Boolean);
-  const out = [];
-  for (const ref of refs) {
-    const name = ref.slice(prefix.length);
-    if (name === "HEAD" || name === base) continue;
-    const m = /^(.+?-\d+)(?:-.*)?$/.exec(name);
-    if (m && stems.has(m[1])) out.push(name);
+  const checkedOut = new Set(worktrees(cwd).map((w) => w.branch).filter((b) => !!b));
+  return localBranches(cwd).filter((b) => !checkedOut.has(b) && isTicketBranch(b, base, stems));
+}
+function applyLocalBranchCleanup(cwd, branches2, dryRun, log) {
+  let deleted = 0;
+  for (const b of branches2) {
+    if (dryRun) {
+      log.emit(`would delete local branch ${b} \u2014 its ticket is deployed`, { step: "worktree" });
+      continue;
+    }
+    if (gitOk(cwd, ["branch", "-D", b]) !== null) {
+      deleted++;
+      log.emit(`deleted local branch ${b} \u2014 its ticket is deployed`, { step: "worktree" });
+    } else log.warn(`could not delete local branch ${b} \u2014 leaving it for the next sweep`, { step: "worktree" });
   }
-  return out;
+  return deleted;
 }
 function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
   let deleted = 0;
@@ -12984,6 +13046,30 @@ ${changed2.map((c) => `  - ${c}
     }
     return `${who2}; ${lock2}`;
   }
+  async function sweepClosedTickets(c, target, branch, tracker, dryRun2, remit, idle = false) {
+    try {
+      if (idle && !sweepCandidatesExist(target.dir, branch.base)) return;
+      const truncated = (limit) => remit.warn(`ticket lookup for the sweep hit its ${limit}-row limit; some tickets may be missed`, { step: "worktree" });
+      const nums = /* @__PURE__ */ new Set([
+        ...worktreeTicketNumbers(target),
+        ...localBranchTicketNumbers(target.dir, branch.base),
+        ...remoteBranchTicketNumbers(target.dir, branch.remote, branch.base)
+      ]);
+      const scoped = ticketsByRepo(c, await tracker.ticketsByNumbers([...nums], truncated)).byRepo.get(target.name) ?? [];
+      const actions = planWorktreeSweep(target, scoped, tracker.contract);
+      if (actions.length) {
+        remit.enter("worktree");
+        const r = await applyWorktreeSweep(target.dir, actions, dryRun2, remit, branch.remote);
+        remit.emit(`swept ${r.removed} worktree(s), kept ${r.keptBranches} branch(es)`, { step: "worktree" });
+      }
+      const orphaned = planLocalBranchCleanup(target.dir, branch.base, scoped, tracker.contract);
+      if (orphaned.length) applyLocalBranchCleanup(target.dir, orphaned, dryRun2, remit);
+      const stale = planRemoteBranchCleanup(target.dir, branch.remote, branch.base, scoped, tracker.contract);
+      if (stale.length) applyRemoteBranchCleanup(target.dir, branch.remote, stale, dryRun2, remit);
+    } catch (e) {
+      remit.warn(`worktree sweep failed: ${e.message}`, { step: "worktree" });
+    }
+  }
   const precheckTickets = /* @__PURE__ */ new Map();
   async function releasePhase(c, target, opts = {}) {
     const scope = releaseLockScope(c.route, target.name);
@@ -13053,6 +13139,7 @@ ${changed2.map((c) => `  - ${c}
           unstamped
         })) {
           remit.emit(`${target.name}: nothing verified \u2014 not locking`, { step: "release" });
+          await sweepClosedTickets(c, target, repo.branch, tracker, dryRun, remit, true);
           return { scope, tests: "skipped", outcome: "skipped", detail: "nothing verified \u2014 not locking" };
         }
       }
@@ -13257,21 +13344,7 @@ ${changed2.map((c) => `  - ${c}
           }
         }
       }
-      try {
-        const terminal = await tracker.terminalTickets();
-        const verifiedNow = (await tracker.openTickets()).filter((t) => t.status === tracker.contract.statuses.verified);
-        const scoped = ticketsByRepo(c, terminal).byRepo.get(target.name) ?? [];
-        const actions = planWorktreeSweep(target, [...scoped, ...ticketsByRepo(c, verifiedNow).byRepo.get(target.name) ?? []], tracker.contract);
-        if (actions.length) {
-          remit.enter("worktree");
-          const r = await applyWorktreeSweep(target.dir, actions, dryRun, remit, repo.branch.remote);
-          remit.emit(`swept ${r.removed} worktree(s), kept ${r.keptBranches} branch(es)`, { step: "worktree" });
-        }
-        const stale = planRemoteBranchCleanup(target.dir, repo.branch.remote, repo.branch.base, scoped, tracker.contract);
-        if (stale.length) applyRemoteBranchCleanup(target.dir, repo.branch.remote, stale, dryRun, remit);
-      } catch (e) {
-        remit.warn(`worktree sweep failed: ${e.message}`, { step: "worktree" });
-      }
+      await sweepClosedTickets(c, target, repo.branch, tracker, dryRun, remit);
       return summary;
     } catch (e) {
       remit.warn(`release phase failed: ${e.message}`, { step: "release" });
@@ -14672,15 +14745,15 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       if (!dryRun && orphans.length) await killGently(orphans.map((o) => o.pid));
       const tracker = new Tracker(route, cfg.ship);
-      const terminal = await tracker.terminalTickets();
-      const { byRepo } = ticketsByRepo(route, terminal);
-      const verifiedByRepo = ticketsByRepo(
-        route,
-        (await tracker.openTickets()).filter((t) => t.status === tracker.contract.statuses.verified)
-      ).byRepo;
+      const truncated = (limit) => emit.warn(`ticket lookup for the sweep hit its ${limit}-row limit; some tickets may be missed`, { step: "worktree" });
       for (const r of await resolvedRepos(route)) {
-        const actions = planWorktreeSweep(r, [...byRepo.get(r.name) ?? [], ...verifiedByRepo.get(r.name) ?? []], tracker.contract);
-        const stale = planRemoteBranchCleanup(r.dir, r.config.branch.remote, r.config.branch.base, byRepo.get(r.name) ?? [], tracker.contract);
+        const wtTickets = ticketsByRepo(route, await tracker.ticketsByNumbers(worktreeTicketNumbers(r), truncated)).byRepo.get(r.name) ?? [];
+        const brTickets = ticketsByRepo(
+          route,
+          await tracker.ticketsByNumbers(remoteBranchTicketNumbers(r.dir, r.config.branch.remote, r.config.branch.base), truncated)
+        ).byRepo.get(r.name) ?? [];
+        const actions = planWorktreeSweep(r, wtTickets, tracker.contract);
+        const stale = planRemoteBranchCleanup(r.dir, r.config.branch.remote, r.config.branch.base, brTickets, tracker.contract);
         if (stale.length) {
           anything = true;
           applyRemoteBranchCleanup(r.dir, r.config.branch.remote, stale, dryRun, emit);

package/package.json

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