@feigi/fleet-ctl 3.81.2 → 3.81.4

package/package.json

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

package/scripts/main-checkout.mjs

@@ -446,10 +446,17 @@ export function describe(check, live = null) {
   switch (check.state) {
     case "clean":
       return null;
-    case "dirty":
-      // The HEAD entry is text, not a path: quoting it would blur it.
+    case "dirty": {
+      // The HEAD entry is text, not a path: quoting it would blur it, and
+      // ignoring cannot clear it, so only a path entry names the ignore remedy.
+      // An exclude hides untracked paths alone, and changedPaths reads a
+      // baseline entry that vanishes as changed, so the remedy is limited to
+      // untracked paths new since the baseline.
+      const hasPath = check.changed.some((p) => p !== check.headMove);
       return `MAIN-CHECKOUT-DIRTY ${check.changed.map((p) => (p === check.headMove ? p : shown(p))).join(" ")} — changed since the run's baseline${members}`
-        + ` — dispatch held: resolve the stray paths FIRST, then re-baseline with ${RECORD_COMMAND} (it overwrites, it does not compare)`;
+        + ` — dispatch held: resolve the stray paths FIRST, then re-baseline with ${RECORD_COMMAND} (it overwrites, it does not compare)`
+        + (hasPath ? " — or, for an untracked path new since the baseline, the maintainer may instead ignore it in .git/info/exclude or the global excludes file: it clears on the next check with no re-baseline, so long as the pattern matches no path the baseline holds; ignoring never clears a tracked or staged file's change" : "");
+    }
     case "absent":
       return `MAIN-CHECKOUT-NO-BASELINE no baseline at ${check.baseline} — dispatch held: record it at run start with ${RECORD_COMMAND}`;
     default:

package/skills/run-team/references/ci-watcher.md

@@ -47,14 +47,25 @@ bill a second one that `rate_limit` does not report; the boundary is per route,
 so `actions/runs/<id>/jobs` is on the reported counter. Every response says
 `X-Ratelimit-Resource: core`, so only the reset epoch and the used sequence tell
 the two apart, and the unreported bucket's remaining count is readable only from
-the `X-Ratelimit-Remaining` header of a call that bills it. **A second pass gate
-therefore probes it too**: one `gh api -i` read of
+the `X-Ratelimit-Remaining` header of a call that bills it. GitHub's REST
+rate-limit documentation does not describe this bucket (it says `core` covers
+"all non-search-related resources in the REST API"), so the gate rests on
+measurement (2026-10-13 and 2026-10-19), not on documentation. **A second pass
+gate therefore probes it too**: one `gh api -i` read of
 `actions/workflows?per_page=1` per tick, 1 unit of that bucket (measured
 2026-10-13: its remaining count fell by 1 per call while `rate_limit` stood
 still, and its reset epoch differed from `rate_limit`'s). A `ci-state` call
 spends 4 units of it on the common path — one `gh run list` and one `gh run view`
 cost 2 each (measured the same day) — so it is held to the same `200 + 4 × count`
-reserve. It has its own global latch (`hidden_out`) and its DEGRADED and
+reserve. 4 is the most one call spends on this bucket for a repo with at most 100
+workflows: 0 with no CI, 2 with no run on the PR's head, 4 otherwise. The
+dropped-required-jobs path adds only reported-bucket calls, and the workflow-name
+lookup pages 100 workflows per page, so a repo with more pays more per call. The
+bucket is account-wide, not per repository: probes on three unrelated
+repositories drew one countdown and one reset epoch (measured 2026-10-19), so
+another run on the same token, or any `gh run` use, spends it, and its
+DEGRADED line can fire with few open PRs on this repository. It has its own
+global latch (`hidden_out`) and its DEGRADED and
 RECOVERED lines name it, so a pause on this bucket is not misread as the
 reported budget running low. An unreadable header is an outage here exactly as a
 non-numeric `rate_limit` read is. The probe runs only when the reported-bucket

package/skills/run-team/references/phase-0.md

@@ -75,6 +75,7 @@ older-version baseline and a baseline whose commit is missing from the
 repository; Phase 3's tick lines say how each is cleared.
 `main-checkout.mjs --check` prints the same answer
 without a tick.
+On `MAIN-CHECKOUT-DIRTY` the maintainer may instead ignore a stray path that is untracked and new since the baseline: an entry in `.git/info/exclude` or in the global excludes file hides it from the check, and the hold clears on the next tick with no re-record. Ignoring never clears a tracked or staged file's change, which `git status` reports whatever the excludes say, nor a pattern that also matches a path the baseline holds, which then reads as changed. Ignoring is the maintainer's decision, never the controller's: the controller never writes an exclude or a `.gitignore` entry. Keep the pattern narrow, because an ignored path is invisible to this check, so a later member write that matches it is never seen.
 
 ## Run the pre-flight
 

package/skills/run-team/references/tick-rows.md

@@ -129,6 +129,7 @@ The full text of each row `fleet-tick.mjs` prints and what it asks of the contro
   checkout and the close-out commit's round trip through a branch; **Fix the
   tooling mid-run** and the commit section of references/close-out.md say how
   each is cleared.
+  The maintainer may instead ignore a stray path that is untracked and new since the baseline: an entry in `.git/info/exclude` or in the global excludes file hides it from the check, and the hold clears on the next tick with no re-baseline. Ignoring never clears a tracked or staged file's change, which `git status` reports whatever the excludes say, nor a pattern that also matches a path the baseline holds, which then reads as changed. Ignoring is the maintainer's decision; the controller never writes an exclude or a `.gitignore` entry. Keep the pattern narrow, because an ignored path is invisible to this check, so a member write that matches it is never seen.
 - `MAIN-CHECKOUT-UNKNOWN …` with `HOLD (main checkout unknown)` — the tick
   could not look: a git or hash read failed (`could not look:`), or the
   baseline exists but cannot be read (`baseline unreadable:`). Never clean,