Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* Regression guards for the autopilot↔ChildWorkerSupervisor wiring.
*
* autopilot.ts:148+ used to have its own inline spawn-and-respawn loop
* (separate from MinionSupervisor's). It had the same bug class fixed
* in #1003 but on a parallel implementation. The fix wave refactored
* autopilot to use the shared ChildWorkerSupervisor core, eliminating
* the parallel-supervisor footgun.
*
* Because the autopilot spawn path is deep inside `runAutopilot()` and
* gated by `spawnManagedWorker` (which needs a Postgres engine), a full
* integration test would require a DATABASE_URL fixture. Instead, these
* static-shape regressions read the source file and pin the load-bearing
* constants:
*
* - the worker is spawned with an auto-sized `--max-rss` (issue #1678)
* - `maxCrashes: 5` matches the prior `crashCount >= 5` give-up rule
* - The autopilot composes ChildWorkerSupervisor (not the legacy
* inline `child.on('exit')` loop)
* - The shutdown path drains via the supervisor's killChild/awaitChildExit
*
* If any of these regress in a future refactor, the test fails with a
* pointer at autopilot.ts.
*/
import { describe, expect, it } from 'bun:test';
import { surfaceFileSource, surfaceSource } from './helpers/source-surface.ts';
// W4 autopilot: containment reads the autopilot surface; positional spans name the module that holds the daemon code.
const AUTOPILOT_SRC = surfaceSource('autopilot');
const DAEMON_SRC = surfaceFileSource('autopilot', 'src/commands/autopilot-daemon.ts');
describe('autopilot.ts ↔ ChildWorkerSupervisor wiring', () => {
it('imports ChildWorkerSupervisor from the shared core', () => {
expect(AUTOPILOT_SRC).toContain(
"import { ChildWorkerSupervisor } from '../core/minions/child-worker-supervisor.ts';",
);
});
it('does not retain the legacy inline spawn loop (`startWorker` + child.on)', () => {
// The old code at autopilot.ts:165-197 defined `startWorker` and called
// `child.on('exit', ...)` directly. The refactor must drop those names.
expect(AUTOPILOT_SRC).not.toContain('const startWorker');
expect(AUTOPILOT_SRC).not.toContain("child.on('exit'");
// Also drop the parallel crash-tracking state that lived in autopilot.
expect(AUTOPILOT_SRC).not.toContain('let crashCount');
expect(AUTOPILOT_SRC).not.toContain('let lastWorkerStartTime');
expect(AUTOPILOT_SRC).not.toContain('STABLE_RUN_RESET_MS');
});
it("spawns the worker with an auto-sized --max-rss (issue #1678)", () => {
// Post-v0.41.39.0 the flat 2048 default is gone: autopilot resolves
// resolveDefaultMaxRssMb() (cgroup-aware) and passes it as the cap. The
// argv must still carry the --max-rss flag token + the resolved value.
expect(AUTOPILOT_SRC).toContain("resolveDefaultMaxRssMb");
expect(AUTOPILOT_SRC).toContain("'--max-rss', String(autopilotMaxRssMb)");
expect(AUTOPILOT_SRC).toContain("'jobs', 'work'");
// The footgun literal must NOT come back.
expect(AUTOPILOT_SRC).not.toContain("'--max-rss', '2048'");
});
it('uses managed processing state and strips GBRAIN_SUPERVISED so the worker keeps stall detection', () => {
// Mandatory readiness publication keys on the status channel env that
// processingState hands off, not on GBRAIN_SUPERVISED. An inherited =1
// would disable the worker's stall detection, and autopilot has no
// progress watchdog to replace it. Behavioral proof lives in
// supervisor-configuration-blocked.test.ts.
expect(AUTOPILOT_SRC).toContain('processingState: processingState ?? undefined');
expect(AUTOPILOT_SRC).toMatch(
/env:\s*\{\s*\.\.\.process\.env,\s*GBRAIN_SUPERVISED:\s*undefined\s*\}/,
);
});
it("constructs ChildWorkerSupervisor with maxCrashes: 5", () => {
// Matches the legacy `crashCount >= 5` give-up rule from the inline
// loop. The shared core uses this to decide when to fire
// onMaxCrashesExceeded → autopilot's shutdown('max_crashes').
expect(AUTOPILOT_SRC).toMatch(/maxCrashes:\s*5\b/);
});
it('routes onMaxCrashesExceeded to autopilot.shutdown (not process.exit directly)', () => {
// Pre-refactor: autopilot.ts called process.exit(1) directly when the
// crash counter tripped, bypassing its own dispatch-loop cleanup and
// lockfile removal. Post-refactor: the callback routes through
// shutdown('max_crashes') so cleanup runs.
expect(DAEMON_SRC).toMatch(/onMaxCrashesExceeded:[\s\S]{0,300}shutdown\('max_crashes'\)/);
});
it('shutdown drains via supervisor.killChild + awaitChildExit (not workerProc.kill)', () => {
// The legacy shutdown reached into `workerProc` directly. Post-refactor
// those calls go through the supervisor's typed surface, which lets the
// class encapsulate the kill/drain sequence.
expect(AUTOPILOT_SRC).toContain("childSupervisor.killChild('SIGTERM')");
expect(AUTOPILOT_SRC).toContain('childSupervisor.awaitChildExit(35_000)');
expect(AUTOPILOT_SRC).not.toContain('workerProc');
});
});