@feigi/fleet-ctl 3.22.1 → 3.22.3

package/package.json

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

package/scripts/compute-spend.mjs

@@ -60,9 +60,12 @@ export function classifyRole(signals) {
   // #1505: a dispatch that recorded `memory-housekeeper` books memory whatever
   // it called the member, so the eleven rows that shared one definition across
   // three buckets collapse to one. The NAME stays a signal beside it because a
-  // missing definition is a real category here rather than a hole — an
-  // untyped `task` dispatch records none at all — and the memory members named
-  // `memory-proxy-session-review-2-3` have nothing else to be classified on;
+  // definition that says nothing about the role is a real category here rather
+  // than a hole — an untyped dispatch records the generic `task` (the
+  // transcript's `session_init` writes it for the default agent; the field is
+  // blank only where that line itself is absent), which names no memory agent
+  // and matches none of the definition branches below — and the memory members
+  // named `memory-proxy-session-review-2-3` have nothing else to be classified on;
   // drop it and they fall to "other", which is the same defect wearing the
   // other shoe. `desc` is excluded on purpose: every memory-adjacent fleet
   // member's own prompt says "memory-proxy" somewhere, so blending the prose

package/scripts/compute-spend.test.mjs

@@ -177,13 +177,26 @@ test("the memory exclusion reads the recorded DEFINITION, so any member name boo
   assert.equal(classifyRole({ agentDefinition: "memory-proxy", memberName: "review-eval", spawnDepth: 2 }), "memory");
 });
 
-test("an untyped dispatch that recorded no definition still classifies by its NAME", () => {
-  // #1505's other half. A dispatch before typed agents existed records no
-  // definition at all — a closed category, not a hole — so the name is the only
-  // memory signal those members have. Measured over the sidecars on disk: three
-  // live members rest on this, and dropping it would put `memory-housekeeper`
-  // (named for its own definition, at depth 1) in the SPECIALIST bucket, which
-  // is the very defect #1505 reports.
+test("an untyped dispatch, recorded as the generic `task` or as no definition, still classifies by its NAME", () => {
+  // #1505's other half. The default agent records the literal `task` in
+  // `session_init`, and a transcript with no `session_init` line records no
+  // definition at all; neither names a memory agent or any fleet definition, so
+  // the name is the only memory signal those members have. Re-measured
+  // 2026-10-04: over the Claude Code `meta.json` sidecars under
+  // ~/.claude/projects (the reader #1505 fixed, since dropped from
+  // member-record.mjs) three members booked memory on their name alone, each
+  // with no definition recorded and none with `task`; over the omp members on
+  // disk none did, under `task` or without a definition. Dropping the name
+  // would put `memory-housekeeper` (named for its own definition, at depth 1)
+  // in the SPECIALIST bucket, which is the very defect #1505 reports.
+  assert.equal(foldOmpTranscript(JSON.stringify({ type: "session_init", agent: "task" }), "/fake/omp.jsonl").agent, "task");
+  assert.equal(foldOmpTranscript(JSON.stringify({ type: "session" }), "/fake/omp.jsonl").agent, null);
+  assert.equal(classifyRole({ agentDefinition: "task", memberName: "memory-proxy-session-review-2-3" }), "memory");
+  assert.equal(classifyRole({ agentDefinition: "task", memberName: "memory-housekeeper", spawnDepth: 1 }), "memory");
+  // `task` matches no definition branch, so with a name it is the name that
+  // decides and without one nothing does.
+  assert.equal(classifyRole({ agentDefinition: "task", memberName: "fix-pr-1380" }), "reviewer");
+  assert.equal(classifyRole({ agentDefinition: "task" }), "other");
   assert.equal(classifyRole({ agentDefinition: "", memberName: "memory-proxy-session-review-2-3" }), "memory");
   assert.equal(classifyRole({ agentDefinition: "", memberName: "memory-housekeeper", spawnDepth: 1 }), "memory");
   // ...and it is still not a guess: a name carrying no memory agent falls

package/scripts/member-record.mjs

@@ -19,8 +19,9 @@
 // alternate-tier pair from two members whose models already happened to
 // differ, and both readers keep it because it is derived rather than
 // authored and survives a regeneration. `""` is NOT the hole use; it means
-// the dispatch named no agent definition, the ordinary shape of an untyped
-// `task` call.
+// the transcript carried no `session_init` agent to read (no such line, or
+// one without a string `agent`). An untyped `task` dispatch is not that
+// shape: the omp reader records the generic `task` for it.
 import { readdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, basename, relative, isAbsolute, sep } from "node:path";
 

package/scripts/reap.test.mjs

@@ -13,7 +13,7 @@ import assert from "node:assert/strict";
 import { execFileSync, spawnSync } from "node:child_process";
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+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";
@@ -41,8 +41,14 @@ const ENV = {
   GIT_CONFIG_SYSTEM: "/dev/null",
 };
 
+// `maintenance.auto=false` on every fixture call: fetch, commit and merge start
+// a detached `git maintenance run --auto`, whose `worktree-prune` task can erase
+// a deliberately faulted `gitdir` before the script under test reads the
+// registry, leaving the test to check a consistent registry instead of the
+// fault. Kept out of ENV, which also reaches reap.sh's own git calls and would
+// hide a lapse in net_git's own suppression.
 const git = (cwd, ...args) =>
-  execFileSync("git", args, { cwd, env: ENV, encoding: "utf8" }).trim();
+  execFileSync("git", ["-c", "maintenance.auto=false", ...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"));
@@ -4398,3 +4404,29 @@ for (const m of SIBLING_MUTATIONS) {
     assert.equal(branchExists(w, "feature/free"), false);
   });
 }
+
+// The `maintenance.auto=false` the `git` helper carries (see the comment above
+// it) cannot be pinned by the gitdir fault fixtures: the race it prevents is
+// timing-dependent, so those stay green with the flag gone. What is
+// deterministic is the spawn itself — a commit or a fetch through the helper
+// must leave no `git maintenance run` in a GIT_TRACE. The trace is switched on
+// through ENV, the object the helper hands its child, because the helper takes
+// no env of its own; node:test runs a file's tests one at a time, so nothing
+// else spawns git while it is set. The first two assertions are the positive
+// control: without them a trace the child never wrote would pass the last.
+test("the fixture git() helper suppresses the detached auto-maintenance run", (t) => {
+  const w = repo(t);
+  const trace = join(dirname(w), "trace.txt");
+  writeFileSync(trace, "");
+  ENV.GIT_TRACE = trace;
+  try {
+    commit(w, "probe");
+    git(w, "fetch", "-q", "--prune", "origin");
+  } finally {
+    delete ENV.GIT_TRACE;
+  }
+  const traced = readFileSync(trace, "utf8");
+  assert.match(traced, /built-in: git commit/, "the trace reached the commit");
+  assert.match(traced, /built-in: git fetch/, "the trace reached the fetch");
+  assert.doesNotMatch(traced, /maintenance run/);
+});