typescript-e2e-fixture-battery

Answer

The battery is a self-contained TypeScript orchestrator (e2e/fixture-battery/run.ts) that runs one E2E-001 pass per tick within the 5-tick window (#265–270) against an idle project (no new commits). Each pass runs: pnpm test:run, pnpm tsc --noEmit, pnpm test:http on fresh daemons, then a pgrep stray-process audit.

1. Battery orchestrator — fresh daemons, tracked PIDs, watchdog reaping (BUG-038 fix):

// e2e/fixture-battery/run.ts
import { spawn, type ChildProcess } from 'node:child_process';

const WATCHDOG = 30_000; // ms

/** BUG-038: daemons were spawned detached without pid tracking, leaking
 *  orphans between ticks. Fix: record every PID we own, attach exit
 *  handlers, and let the watchdog reap anything that outlives its slot. */
export class DaemonFarm {
  private owned = new Map<number, ChildProcess>();

  spawnFresh(name: string, args: string[]): number {
    const child = spawn('node', args, { detached: true, stdio: 'pipe' });
    child.unref();
    this.owned.set(child.pid!, child);
    child.on('exit', () => this.owned.delete(child.pid!));
    return child.pid!;
  }

  /** Returns PIDs that are still ours but should be gone — the strays. */
  audit(expected: number[]): number[] {
    const got = new Set(
      this.owned.size ? [...this.owned.keys()] : [],
    );
    return [...got].filter((pid) => !expected.includes(pid));
  }
}

const farm = new DaemonFarm();
const expectedPids = [
  farm.spawnFresh('daemon', ['dist/daemon.js', '--long-lived']),
  farm.spawnFresh('stdio-mcp', ['dist/stdio-mcp.js']),
  farm.spawnFresh('watchdog', ['dist/watchdog.js']),
];

// pnpm test:run / tsc / test:http run against these fresh daemons…
const unit = await run('pnpm', ['test:run']);
const tsc = await run('pnpm', ['tsc', '--noEmit']);
const http = await run('pnpm', ['test:http']);

// Stray audit: exactly the three long-lived PIDs may remain.
const strays = farm.audit(expectedPids);
if (strays.length > 0) throw new Error(`BUG-038 regression: strays ${strays}`);

2. Board event with parquet-only commit:

# append_board_event_parquet.py
# --set ticks_total=<n> ticks_idle=<n> last_commit=<sha|''> cooldown_s=<n>
import argparse, pyarrow as pa, pyarrow.parquet as pq
from datetime import datetime, timezone

def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--board", default="board/events.parquet")
    ap.add_argument("--set", nargs="+", required=True)
    args = ap.parse_args()
    kv = dict(k.split("=", 1) for k in args.set)

    schema = pa.schema([
        ("ts", pa.timestamp("us", tz="UTC")),
        ("ticks_total", pa.int64()), ("ticks_idle", pa.int64()),
        ("last_commit", pa.string()), ("cooldown_s", pa.int64()),
    ])
    row = pa.table({
        "ts": [datetime.now(timezone.utc)],
        "ticks_total": [int(kv["ticks_total"])],
        "ticks_idle":   [int(kv["ticks_idle"])],
        "last_commit":  [kv.get("last_commit", "")],
        "cooldown_s":   [int(kv["cooldown_s"])],
    }, schema=schema)

    try:
        old = pq.read_table(args.board, schema=schema)
        out = pa.concat_tables([old, row])
    except FileNotFoundError:
        out = row
    pq.write_table(out, args.board)  # atomic via temp-file rename in practice
    print(f"appended tick {kv['ticks_total']}: idle={kv['ticks_idle']}")

if __name__ == "__main__":
    main()

Commit after append is parquet-only: git commit -m "board: tick 265 event (auditor note: informational — no source change)" — the auditor entry is recorded as informational since the battery is verification-only on an idle project.

3. Idle-counter semantics (fixture does NOT reset): the counter is monotonic across the whole window:

// e2e/fixture-battery/idle-counter.ts
export class IdleCounter {
  constructor(private value = 0) {}
  tick() { this.value += 1; return this.value; }   // never resets
  get current() { return this.value; }
}

The battery asserts ticks_idle_at_tick_n == ticks_idle_at_tick_{n-1} + 1 for every tick in #265–270; it never writes ticks_idle=0 unless the project leaves idle state.