@tablation/crew 0.26.0 → 0.27.0

package/dist/cli.js

@@ -7,10 +7,157 @@ import { hostname as hostname2, homedir as homedir5 } from "os";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { resolve, dirname, isAbsolute, join as join2, basename as basename2 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { resolve, dirname as dirname2, isAbsolute, join as join3, basename as basename2 } from "path";
 import { homedir, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
+
+// src/events.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  existsSync,
+  statSync,
+  renameSync,
+  openSync,
+  closeSync,
+  rmSync
+} from "fs";
+import { join, dirname } from "path";
+function render(e) {
+  const scope = e.role ? `${e.step}[${e.role}]` : e.step;
+  const ticket = e.ticket ? ` ${e.ticket}` : "";
+  const level = e.level === "info" ? "" : `${e.level.toUpperCase()}: `;
+  return `${e.at} ${scope}:${ticket} ${level}${e.message}`;
+}
+var DEFAULT_EVENTS_ROTATE_BYTES = 64 * 1024 * 1024;
+var ROTATED_EVENTS_RE = /^events\.\d{8}T\d{6}Z(?:-\d+)?\.jsonl$/;
+var ROTATE_LOCK_STALE_MS = 6e4;
+function rotateEventsFile(file, maxBytes, now = /* @__PURE__ */ new Date()) {
+  try {
+    if (!existsSync(file) || statSync(file).size <= maxBytes) return void 0;
+  } catch {
+    return void 0;
+  }
+  const lock = `${file}.rotate.lock`;
+  try {
+    try {
+      closeSync(openSync(lock, "wx"));
+    } catch {
+      try {
+        if (Date.now() - statSync(lock).mtimeMs < ROTATE_LOCK_STALE_MS) return void 0;
+        rmSync(lock, { force: true });
+        closeSync(openSync(lock, "wx"));
+      } catch {
+        return void 0;
+      }
+    }
+    try {
+      if (statSync(file).size <= maxBytes) return void 0;
+      const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+      let dest = join(dirname(file), `events.${stamp}.jsonl`);
+      for (let n = 1; existsSync(dest); n++) dest = join(dirname(file), `events.${stamp}-${n}.jsonl`);
+      renameSync(file, dest);
+      return dest;
+    } finally {
+      rmSync(lock, { force: true });
+    }
+  } catch {
+    return void 0;
+  }
+}
+var Emitter = class _Emitter {
+  cycle;
+  opts;
+  now;
+  step = "poll";
+  role;
+  constructor(opts) {
+    this.opts = opts;
+    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
+    this.cycle = opts.cycleId ?? this.now().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+    for (const f of [opts.eventFile, opts.logFile]) {
+      if (!f) continue;
+      try {
+        mkdirSync(dirname(f), { recursive: true });
+      } catch {
+      }
+    }
+  }
+  /** Everything emitted after this belongs to `step`, until the next one. */
+  enter(step, role) {
+    this.step = step;
+    this.role = role;
+  }
+  emit(message, extra = {}) {
+    const e = {
+      at: this.now().toISOString(),
+      cycle: this.cycle,
+      route: this.opts.route,
+      step: extra.step ?? this.step,
+      level: extra.level ?? "info",
+      message,
+      ...extra.role ?? this.role ? { role: extra.role ?? this.role } : {},
+      ...extra.ticket ? { ticket: extra.ticket } : {},
+      ...extra.data ? { data: extra.data } : {}
+    };
+    const line = render(e);
+    try {
+      if (this.opts.eventFile && this.opts.rotateBytes) rotateEventsFile(this.opts.eventFile, this.opts.rotateBytes, this.now());
+    } catch {
+    }
+    try {
+      if (this.opts.eventFile) appendFileSync(this.opts.eventFile, `${JSON.stringify(e)}
+`);
+    } catch {
+    }
+    try {
+      if (this.opts.logFile) appendFileSync(this.opts.logFile, `${line}
+`);
+    } catch {
+    }
+    try {
+      (this.opts.console ?? ((l) => process.stderr.write(`${l}
+`)))(line);
+    } catch {
+    }
+    return e;
+  }
+  warn(message, extra = {}) {
+    return this.emit(message, { ...extra, level: "warn" });
+  }
+  error(message, extra = {}) {
+    return this.emit(message, { ...extra, level: "error" });
+  }
+  /**
+   * A view of this emitter labelling every event with a different route,
+   * sharing the same sinks and cycle id. For a fleet-wide run, the top-level
+   * Emitter is stamped with just one route (see cli.ts) — a phase that
+   * actually knows which route it's working (release, per-repo poll) uses
+   * this instead, so its events aren't all attributed to `routes[0]`.
+   */
+  forRoute(route) {
+    return new _Emitter({ ...this.opts, route, cycleId: this.cycle });
+  }
+  /** Times a step and emits its outcome, so a view can show duration. */
+  async timed(step, message, fn, role) {
+    this.enter(step, role);
+    const started = this.now().getTime();
+    try {
+      const result = await fn();
+      this.emit(message, { data: { ms: this.now().getTime() - started, ok: true } });
+      return result;
+    } catch (err) {
+      this.error(`${message} \u2014 ${err.message}`, {
+        data: { ms: this.now().getTime() - started, ok: false }
+      });
+      throw err;
+    }
+  }
+};
+var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
+
+// src/config.ts
 import { getSessionStore, hostFromUrl } from "@tablation/client";
 
 // src/platform.ts
@@ -50,8 +197,8 @@ function explain(ship, required) {
 }
 
 // src/repo-config.ts
-import { readFileSync, existsSync } from "fs";
-import { join, basename } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, basename } from "path";
 import { parse } from "yaml";
 var SPEC_VERSION = 1;
 var REPO_CONFIG_FILENAMES = [".crew.yaml", ".crew.yml", ".crew.json"];
@@ -124,8 +271,8 @@ var MODES = ["local", "integrate", "ci_manual", "ci_auto", "external"];
 var PROVIDERS = ["github", "buildkite", "other", "none"];
 function findRepoConfig(dir) {
   for (const name of REPO_CONFIG_FILENAMES) {
-    const p = join(dir, name);
-    if (existsSync(p)) return p;
+    const p = join2(dir, name);
+    if (existsSync2(p)) return p;
   }
   return null;
 }
@@ -355,7 +502,7 @@ function parseRepoConfig(text, file) {
 function loadRepoConfig(dir) {
   const file = findRepoConfig(dir);
   if (!file) return null;
-  return parseRepoConfig(readFileSync(file, "utf8"), file);
+  return parseRepoConfig(readFileSync2(file, "utf8"), file);
 }
 function hookLabel(cfg, hook2) {
   return cfg.labels[hook2] ?? cfg.hooks[hook2] ?? hook2;
@@ -631,6 +778,7 @@ var SHIP_KEYS = /* @__PURE__ */ new Set([
   "apiKey",
   "maxConcurrentAgents",
   "streamRetentionDays",
+  "eventsRotateBytes",
   "reposBasePath",
   "relayHost",
   "relayPort",
@@ -767,11 +915,11 @@ function expand(p, base) {
   return isAbsolute(out) ? out : resolve(base, out);
 }
 function resolvePromptsDir(promptSet, crewHome, base) {
-  if (!promptSet) return join2(crewHome, "prompts", "default");
+  if (!promptSet) return join3(crewHome, "prompts", "default");
   if (promptSet.includes("/") || promptSet.startsWith(".") || promptSet.startsWith("~")) {
     return expand(promptSet, base);
   }
-  return join2(crewHome, "prompts", promptSet);
+  return join3(crewHome, "prompts", promptSet);
 }
 var Missing = class {
   paths = [];
@@ -795,7 +943,7 @@ var Missing = class {
 };
 function crewVersion(crewHome) {
   try {
-    const pkg = JSON.parse(readFileSync2(join2(crewHome, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(join3(crewHome, "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -805,26 +953,26 @@ function configSearchPath(crewHome) {
   if (process.env.CREW_CONFIG) return [resolve(process.env.CREW_CONFIG)];
   const xdg = process.env.XDG_CONFIG_HOME;
   return [
-    ...xdg ? [join2(xdg, "crew", "crew.yaml")] : [],
-    join2(homedir(), ".config", "crew", "crew.yaml"),
+    ...xdg ? [join3(xdg, "crew", "crew.yaml")] : [],
+    join3(homedir(), ".config", "crew", "crew.yaml"),
     resolve(crewHome, "crew.yaml")
   ];
 }
 function findConfigFile(crewHome) {
   const candidates = configSearchPath(crewHome);
-  return candidates.find((c) => existsSync2(c)) ?? candidates[candidates.length - 1];
+  return candidates.find((c) => existsSync3(c)) ?? candidates[candidates.length - 1];
 }
-var defaultConfigPath = () => join2(process.env.XDG_CONFIG_HOME ?? join2(homedir(), ".config"), "crew", "crew.yaml");
+var defaultConfigPath = () => join3(process.env.XDG_CONFIG_HOME ?? join3(homedir(), ".config"), "crew", "crew.yaml");
 function routeSlug(route) {
   return route.replace(/\//g, "-");
 }
 function resolvedPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join2(stateDir, "resolved", workspace, `${project}.json`);
+  return join3(stateDir, "resolved", workspace, `${project}.json`);
 }
 function apiKeyPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join2(stateDir, "keys", workspace, `${project}.env`);
+  return join3(stateDir, "keys", workspace, `${project}.env`);
 }
 function splitRoute(route) {
   const parts = route.split("/");
@@ -835,9 +983,9 @@ function splitRoute(route) {
 }
 function readResolvedFile(stateDir, route) {
   const path = resolvedPathFor(stateDir, route);
-  if (!existsSync2(path)) return void 0;
+  if (!existsSync3(path)) return void 0;
   try {
-    return JSON.parse(readFileSync2(path, "utf8"));
+    return JSON.parse(readFileSync3(path, "utf8"));
   } catch (e) {
     throw new ConfigError(`${path}: not valid JSON \u2014 ${e.message}`);
   }
@@ -893,23 +1041,23 @@ function parseResolved(raw, m, where) {
 }
 function loadConfig(crewHome, configFile, opts = {}) {
   const file = configFile ?? findConfigFile(crewHome);
-  if (opts.text === void 0 && !existsSync2(file)) {
+  if (opts.text === void 0 && !existsSync3(file)) {
     throw new ConfigError(
       `no config found. Looked in:
 ` + configSearchPath(crewHome).map((c) => `  - ${c}`).join("\n") + `
 
 Create the first of those:
-  mkdir -p ${dirname(defaultConfigPath())} && cp ${join2(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
+  mkdir -p ${dirname2(defaultConfigPath())} && cp ${join3(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
     );
   }
   let raw;
   try {
-    raw = parse2(opts.text ?? readFileSync2(file, "utf8"));
+    raw = parse2(opts.text ?? readFileSync3(file, "utf8"));
   } catch (e) {
     throw new ConfigError(`${file}: not valid YAML \u2014 ${e.message}`);
   }
   if (!raw || typeof raw !== "object") throw new ConfigError(`${file} is empty or not a mapping`);
-  const base = dirname(file);
+  const base = dirname2(file);
   const missing = new Missing();
   rejectUnknownKeys(raw, /* @__PURE__ */ new Set(["ship", "routes"]), "top-level", file);
   const shipRaw = raw.ship ?? {};
@@ -926,6 +1074,10 @@ Create the first of those:
   if (!Number.isInteger(streamRetentionDays) || streamRetentionDays < 1) {
     missing.add(`ship.streamRetentionDays must be a positive integer (got "${shipRaw.streamRetentionDays}")`);
   }
+  const eventsRotateBytes = shipRaw.eventsRotateBytes === void 0 ? DEFAULT_EVENTS_ROTATE_BYTES : Number(shipRaw.eventsRotateBytes);
+  if (!Number.isInteger(eventsRotateBytes) || eventsRotateBytes < 1) {
+    missing.add(`ship.eventsRotateBytes must be a positive integer (got "${shipRaw.eventsRotateBytes}")`);
+  }
   const maxThinkingTokens = shipRaw.agent?.maxThinkingTokens === void 0 ? DEFAULT_MAX_THINKING_TOKENS : Number(shipRaw.agent.maxThinkingTokens);
   if (!Number.isInteger(maxThinkingTokens) || maxThinkingTokens < 0) {
     missing.add(`ship.agent.maxThinkingTokens must be a non-negative integer (got "${shipRaw.agent?.maxThinkingTokens}")`);
@@ -968,10 +1120,11 @@ Create the first of those:
       useNvm: shipRaw.useNvm !== false,
       nvmSh: shipRaw.nvmSh,
       stateDir,
-      logFile: expand(shipRaw.logFile ?? join2(tmpdir(), "crew.log"), base),
+      logFile: expand(shipRaw.logFile ?? join3(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
       streamRetentionDays,
+      eventsRotateBytes,
       relayHost: shipRaw.relayHost ? String(shipRaw.relayHost) : void 0,
       // 2222 matches the relay's own RELAY_SSH_PORT default (crew-relay README).
       relayPort: shipRaw.relayPort !== void 0 ? Number(shipRaw.relayPort) : 2222,
@@ -1102,8 +1255,8 @@ function repoIdForName(r, name) {
 }
 function resolveApiKey(r) {
   if (r.apiKey) return r.apiKey;
-  if (r.apiKeyFile && r.apiKeyVar && existsSync2(r.apiKeyFile)) {
-    for (const line of readFileSync2(r.apiKeyFile, "utf8").split("\n")) {
+  if (r.apiKeyFile && r.apiKeyVar && existsSync3(r.apiKeyFile)) {
+    for (const line of readFileSync3(r.apiKeyFile, "utf8").split("\n")) {
       const m = line.match(new RegExp(`^${r.apiKeyVar}=(.*)$`));
       if (m) return (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     }
@@ -1166,7 +1319,7 @@ function configuredMembers(rt) {
   return out;
 }
 function defaultRepoDir(basePath, workspace, repoName) {
-  return join2(basePath, workspace, repoName);
+  return join3(basePath, workspace, repoName);
 }
 function reposOf(r) {
   const named = Object.entries(r.repos);
@@ -1190,7 +1343,7 @@ function passengerRepoTargets(r) {
   return reposOf(r).filter((t) => r.repoOverrides[t.name]?.hostPassengers !== false);
 }
 function passengerCheckoutDir(basePath, workspace, repoName) {
-  return join2(basePath, workspace, ".passenger-checkouts", repoName);
+  return join3(basePath, workspace, ".passenger-checkouts", repoName);
 }
 function passengerCheckoutTargets(r) {
   if (!r.hostPassengers) return [];
@@ -1322,17 +1475,17 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/state.ts
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync, rmSync, statSync } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync(dir, { recursive: true });
+    mkdirSync2(dir, { recursive: true });
   }
   path(...parts) {
-    return join3(this.dir, ...parts);
+    return join4(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -1343,7 +1496,7 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync3(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync4(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
@@ -1368,10 +1521,10 @@ var State = class _State {
   }
   /** Whole-crew pause, and the per-role sentinels one level down. */
   isPaused() {
-    return existsSync3(this.path(".crew-paused"));
+    return existsSync4(this.path(".crew-paused"));
   }
   isRolePaused(role) {
-    return existsSync3(this.path(`.role-paused-${role}`));
+    return existsSync4(this.path(`.role-paused-${role}`));
   }
   pausedRoles(roles) {
     return new Set(roles.filter((r) => this.isRolePaused(r)));
@@ -1380,7 +1533,7 @@ var State = class _State {
     writeFileSync(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
   resume(role) {
-    rmSync(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
+    rmSync2(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
   }
   /**
    * The release phase (merge, deploy, release) has its own sentinel, one
@@ -1388,11 +1541,11 @@ var State = class _State {
    * while agents keep working.
    */
   isReleasePaused() {
-    return existsSync3(this.path(".release-paused"));
+    return existsSync4(this.path(".release-paused"));
   }
   setReleasePaused(paused) {
     if (paused) writeFileSync(this.path(".release-paused"), "");
-    else rmSync(this.path(".release-paused"), { force: true });
+    else rmSync2(this.path(".release-paused"), { force: true });
   }
   /**
    * Why a release cycle must not run right now, or null when it may. Every
@@ -1429,7 +1582,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync3(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync4(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -1445,7 +1598,7 @@ var State = class _State {
       ok: true,
       release: () => {
         try {
-          rmSync(file, { force: true });
+          rmSync2(file, { force: true });
         } catch {
         }
       }
@@ -1523,7 +1676,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync3(this.path(f), "utf8").trim() || null;
+        return readFileSync4(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -1537,7 +1690,7 @@ var State = class _State {
         return n;
       },
       clearBlocked: () => {
-        rmSync(this.path(blocked), { force: true });
+        rmSync2(this.path(blocked), { force: true });
       },
       /**
        * The commit a deploy last failed on.
@@ -1553,7 +1706,7 @@ var State = class _State {
 `);
       },
       clearDeployFailed: () => {
-        rmSync(this.path(failed), { force: true });
+        rmSync2(this.path(failed), { force: true });
       },
       /**
        * Consecutive test-gate failures on the same head (CREW-1368). A failure
@@ -1568,12 +1721,12 @@ var State = class _State {
         return next;
       },
       clearTestGateFailed: () => {
-        rmSync(this.path(gateFailed), { force: true });
+        rmSync2(this.path(gateFailed), { force: true });
       },
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync3(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync4(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
@@ -1583,7 +1736,7 @@ var State = class _State {
 `);
       },
       clearHeldReported: () => {
-        rmSync(this.path(heldReported), { force: true });
+        rmSync2(this.path(heldReported), { force: true });
       },
       testGateReported: (sha) => read(gateReported) === sha,
       noteTestGateReported: (sha) => {
@@ -1610,13 +1763,13 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync3(this.path(f), "utf8").trim() || null;
+        return readFileSync4(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
     };
     const clear2 = () => {
-      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync(this.path(f), { force: true });
+      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync2(this.path(f), { force: true });
     };
     return {
       /** Consecutive cycles this route had actionable work and did not win. */
@@ -1675,7 +1828,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync3(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync4(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
@@ -1696,7 +1849,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync3(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync4(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
@@ -1720,7 +1873,7 @@ var State = class _State {
       },
       at: () => {
         try {
-          return statSync(this.path(file)).mtimeMs;
+          return statSync2(this.path(file)).mtimeMs;
         } catch {
           return null;
         }
@@ -1729,109 +1882,13 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync3(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync4(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
   }
 };
 
-// src/events.ts
-import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
-function render(e) {
-  const scope = e.role ? `${e.step}[${e.role}]` : e.step;
-  const ticket = e.ticket ? ` ${e.ticket}` : "";
-  const level = e.level === "info" ? "" : `${e.level.toUpperCase()}: `;
-  return `${e.at} ${scope}:${ticket} ${level}${e.message}`;
-}
-var Emitter = class _Emitter {
-  cycle;
-  opts;
-  now;
-  step = "poll";
-  role;
-  constructor(opts) {
-    this.opts = opts;
-    this.now = opts.now ?? (() => /* @__PURE__ */ new Date());
-    this.cycle = opts.cycleId ?? this.now().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
-    for (const f of [opts.eventFile, opts.logFile]) {
-      if (!f) continue;
-      try {
-        mkdirSync2(dirname2(f), { recursive: true });
-      } catch {
-      }
-    }
-  }
-  /** Everything emitted after this belongs to `step`, until the next one. */
-  enter(step, role) {
-    this.step = step;
-    this.role = role;
-  }
-  emit(message, extra = {}) {
-    const e = {
-      at: this.now().toISOString(),
-      cycle: this.cycle,
-      route: this.opts.route,
-      step: extra.step ?? this.step,
-      level: extra.level ?? "info",
-      message,
-      ...extra.role ?? this.role ? { role: extra.role ?? this.role } : {},
-      ...extra.ticket ? { ticket: extra.ticket } : {},
-      ...extra.data ? { data: extra.data } : {}
-    };
-    const line = render(e);
-    try {
-      if (this.opts.eventFile) appendFileSync(this.opts.eventFile, `${JSON.stringify(e)}
-`);
-    } catch {
-    }
-    try {
-      if (this.opts.logFile) appendFileSync(this.opts.logFile, `${line}
-`);
-    } catch {
-    }
-    try {
-      (this.opts.console ?? ((l) => process.stderr.write(`${l}
-`)))(line);
-    } catch {
-    }
-    return e;
-  }
-  warn(message, extra = {}) {
-    return this.emit(message, { ...extra, level: "warn" });
-  }
-  error(message, extra = {}) {
-    return this.emit(message, { ...extra, level: "error" });
-  }
-  /**
-   * A view of this emitter labelling every event with a different route,
-   * sharing the same sinks and cycle id. For a fleet-wide run, the top-level
-   * Emitter is stamped with just one route (see cli.ts) — a phase that
-   * actually knows which route it's working (release, per-repo poll) uses
-   * this instead, so its events aren't all attributed to `routes[0]`.
-   */
-  forRoute(route) {
-    return new _Emitter({ ...this.opts, route, cycleId: this.cycle });
-  }
-  /** Times a step and emits its outcome, so a view can show duration. */
-  async timed(step, message, fn, role) {
-    this.enter(step, role);
-    const started = this.now().getTime();
-    try {
-      const result = await fn();
-      this.emit(message, { data: { ms: this.now().getTime() - started, ok: true } });
-      return result;
-    } catch (err) {
-      this.error(`${message} \u2014 ${err.message}`, {
-        data: { ms: this.now().getTime() - started, ok: false }
-      });
-      throw err;
-    }
-  }
-};
-var eventFileFor = (stateDir) => join4(stateDir, "events.jsonl");
-
 // src/tracker.ts
 import { hostname } from "os";
 import { TablationClient } from "@tablation/client";
@@ -2131,7 +2188,7 @@ function describeRelease(o, route) {
 // src/install.ts
 import { dirname as dirname3, join as join5, extname } from "path";
 import { homedir as homedir2 } from "os";
-import { accessSync, constants, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync2, unlinkSync, realpathSync } from "fs";
+import { accessSync, constants, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, statSync as statSync3, writeFileSync as writeFileSync2, unlinkSync, realpathSync } from "fs";
 import { spawnSync } from "child_process";
 import { createHash } from "crypto";
 
@@ -2185,7 +2242,7 @@ function findOnPath(bin, searchPath) {
   for (const candidate of candidates) {
     try {
       accessSync(candidate, constants.X_OK);
-      if (statSync2(candidate).isFile()) return candidate;
+      if (statSync3(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -2648,10 +2705,10 @@ import { execFileSync } from "child_process";
 import {
   existsSync as existsSync6,
   mkdirSync as mkdirSync4,
-  openSync,
-  closeSync,
+  openSync as openSync2,
+  closeSync as closeSync2,
   writeSync,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync as unlinkSync2
 } from "fs";
 import { dirname as dirname4, basename as basename3 } from "path";
@@ -3047,10 +3104,10 @@ function acquireCheckoutLock(dir, timeoutMs = 3e4) {
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     try {
-      const fd = openSync(lockPath, "wx");
+      const fd = openSync2(lockPath, "wx");
       writeSync(fd, `${process.pid}
 `);
-      closeSync(fd);
+      closeSync2(fd);
       return () => {
         try {
           unlinkSync2(lockPath);
@@ -3061,7 +3118,7 @@ function acquireCheckoutLock(dir, timeoutMs = 3e4) {
       const err = e;
       if (err.code !== "EEXIST") throw err;
       try {
-        if (Date.now() - statSync3(lockPath).mtimeMs > CHECKOUT_LOCK_STALE_MS) {
+        if (Date.now() - statSync4(lockPath).mtimeMs > CHECKOUT_LOCK_STALE_MS) {
           try {
             unlinkSync2(lockPath);
           } catch {
@@ -5398,7 +5455,7 @@ var alreadyReported = (ticket, g, comments) => comments.some((c) => c.ticket_id
 
 // src/agent.ts
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync6, existsSync as existsSync7, statSync as statSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync7, statSync as statSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
 import { finished } from "stream/promises";
 import { join as join7, dirname as dirname5 } from "path";
 import { createHash as createHash2 } from "crypto";
@@ -5869,7 +5926,7 @@ function planAgentRun(o) {
   let digest;
   let ageSeconds;
   if (existsSync7(digestPath2)) {
-    ageSeconds = Math.floor((now() - statSync4(digestPath2).mtimeMs) / 1e3);
+    ageSeconds = Math.floor((now() - statSync5(digestPath2).mtimeMs) / 1e3);
     if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync6(digestPath2, "utf8");
   }
   const common = readFileSync6(commonPath, "utf8");
@@ -6600,7 +6657,7 @@ Wrote ${o.configPath}.
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync11, copyFileSync, mkdirSync as mkdirSync7, mkdtempSync, rmSync as rmSync2 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync11, copyFileSync, mkdirSync as mkdirSync7, mkdtempSync, rmSync as rmSync3 } from "fs";
 import { dirname as dirname8, join as join11 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
@@ -7383,7 +7440,7 @@ function openReleaseCheckout(o) {
   const dir = join11(root, "checkout");
   const close = () => {
     gitOk(o.cwd, ["worktree", "remove", "--force", dir]);
-    rmSync2(root, { recursive: true, force: true });
+    rmSync3(root, { recursive: true, force: true });
     gitOk(o.cwd, ["worktree", "prune"]);
     gitOk(o.cwd, ["branch", "-D", branch]);
   };
@@ -7866,7 +7923,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync12, statSync as statSync5, openSync as openSync2, readSync, closeSync as closeSync2 } from "fs";
+import { watch as watchFile, existsSync as existsSync12, statSync as statSync6, openSync as openSync3, readSync, closeSync as closeSync3 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -7968,13 +8025,13 @@ function renderHeaders(states, now = Date.now()) {
 }
 function readFrom(file, from) {
   if (!existsSync12(file)) return { events: [], offset: from };
-  const size = statSync5(file).size;
+  const size = statSync6(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
-  const fd = openSync2(file, "r");
+  const fd = openSync3(file, "r");
   const buf = Buffer.alloc(size - from);
   readSync(fd, buf, 0, buf.length, from);
-  closeSync2(fd);
+  closeSync3(fd);
   const text = buf.toString("utf8");
   const lastNewline = text.lastIndexOf("\n");
   if (lastNewline === -1) return { events: [], offset: from };
@@ -9465,7 +9522,7 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync16, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync6 } from "fs";
+import { existsSync as existsSync16, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync7 } from "fs";
 import { join as join15 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
@@ -9474,7 +9531,7 @@ function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
   const cutoff = now - retentionDays * DAY_MS2;
   return readdirSync3(dir).map((name) => join15(dir, name)).filter((path) => {
     try {
-      return statSync6(path).mtimeMs < cutoff;
+      return statSync7(path).mtimeMs < cutoff;
     } catch {
       return false;
     }
@@ -9488,7 +9545,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync3(path, { force: true });
+      rmSync4(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -9497,9 +9554,20 @@ function applyStreamSweep(paths, dryRun, log) {
   }
   return removed;
 }
+function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
+  if (!existsSync16(stateDir)) return [];
+  const cutoff = now - retentionDays * DAY_MS2;
+  return readdirSync3(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join15(stateDir, name)).filter((path) => {
+    try {
+      return statSync7(path).mtimeMs < cutoff;
+    } catch {
+      return false;
+    }
+  }).sort();
+}
 
 // src/cli.ts
-import { readFileSync as readFileSync14, existsSync as existsSync20, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync20, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync9 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
@@ -10237,7 +10305,7 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 }
 
 // src/daemon.ts
-import { readdirSync as readdirSync6, statSync as statSync7 } from "fs";
+import { readdirSync as readdirSync6, statSync as statSync8 } from "fs";
 import { join as join19 } from "path";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -10269,7 +10337,7 @@ async function runDaemonLoop(o) {
 function latestMtime(path) {
   let stat;
   try {
-    stat = statSync7(path);
+    stat = statSync8(path);
   } catch {
     return 0;
   }
@@ -10866,6 +10934,7 @@ if (command === "passenger-sync-daemon") {
   const emit = new Emitter({
     route: route?.route ?? "",
     eventFile: dryRun ? void 0 : eventFileFor(cfg.ship.stateDir),
+    rotateBytes: cfg.ship.eventsRotateBytes,
     logFile: dryRun ? void 0 : cfg.ship.logFile,
     console: (l) => process.stderr.write(`${l}
 `)
@@ -10968,7 +11037,10 @@ if (command === "passenger-sync-daemon") {
     emitReleaseSummary(emit, summaries);
     if (!dryRun) state.releaseHeartbeat().touch();
     try {
-      const paths = planStreamSweep(cfg.ship.stateDir, cfg.ship.streamRetentionDays);
+      const paths = [
+        ...planStreamSweep(cfg.ship.stateDir, cfg.ship.streamRetentionDays),
+        ...planEventsSweep(cfg.ship.stateDir, cfg.ship.streamRetentionDays)
+      ];
       if (paths.length) {
         emit.enter("worktree");
         const removed = applyStreamSweep(paths, dryRun, emit);
@@ -12020,6 +12092,7 @@ ${changed2.map((c) => `  - ${c}
           newEmitter: () => new Emitter({
             route: route.route,
             eventFile: eventFileFor(cfg.ship.stateDir),
+            rotateBytes: cfg.ship.eventsRotateBytes,
             logFile: cfg.ship.logFile,
             console: (l) => process.stderr.write(`${l}
 `)
@@ -12629,7 +12702,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
           writeFileSync9(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
-          renameSync(tmpPath, resolvedPath);
+          renameSync2(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
 `);
         }
@@ -12846,7 +12919,17 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           { step: "worktree" }
         );
       }
-      const streamPaths = planStreamSweep(cfg.ship.stateDir, cfg.ship.streamRetentionDays);
+      if (!dryRun) {
+        const rotated = rotateEventsFile(eventFileFor(cfg.ship.stateDir), cfg.ship.eventsRotateBytes);
+        if (rotated) {
+          anything = true;
+          emit.emit(`rotated oversized event log to ${rotated}`, { step: "worktree" });
+        }
+      }
+      const streamPaths = [
+        ...planStreamSweep(cfg.ship.stateDir, cfg.ship.streamRetentionDays),
+        ...planEventsSweep(cfg.ship.stateDir, cfg.ship.streamRetentionDays)
+      ];
       if (streamPaths.length) {
         anything = true;
         const removed = applyStreamSweep(streamPaths, dryRun, emit);
@@ -13349,6 +13432,15 @@ watermark:  ${state.watermark()}
 routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `
       );
+      try {
+        const evFile = eventFileFor(cfg.ship.stateDir);
+        const evSize = existsSync20(evFile) ? statSync9(evFile).size : 0;
+        process.stdout.write(
+          evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
+` : "events log:        ok\n"
+        );
+      } catch {
+      }
       const tracker = new Tracker(route, cfg.ship);
       const contractProblems = validateContract(tracker.contract);
       process.stdout.write(

package/package.json

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