await expect(readdir(tempParent)).resolves.toStrictEqual([]);

});

it("reports command spawn errors instead of leaking unhandled child errors", async () => {

const tempParent = await mkdtemp(path.join(os.tmpdir(), "qa-gateway-spawn-fail-"));

cleanups.push(async () => {

await rm(tempParent, { recursive: true, force: true });

});

qaTempPathState.preferredTmpDir = tempParent;

const missingExecutable = path.join(tempParent, "missing-openclaw-node");

await expect(

startQaGatewayChild({

repoRoot: process.cwd(),

command: {

executablePath: missingExecutable,

usePackagedPlugins: true,

},

transport: {

requiredPluginIds: [],

createGatewayConfig: () => ({}),

},

transportBaseUrl: "http://127.0.0.1:43123",

}),

).rejects.toThrow(/gateway failed to spawn: .*ENOENT/u);

await expect(readdir(tempParent)).resolves.toStrictEqual([]);

});

it("keeps the slow-reply QA opt-out enabled under fast mode", () => {

const env = buildQaRuntimeEnv({

...createParams(),

};

}

function monitorQaGatewayChildSpawnError(

child: ChildProcess,

output: { push(chunk: Buffer): void },

) {

let spawnError: unknown = null;

child.once("error", (error) => {

spawnError = error;

output.push(

Buffer.from(`[qa-lab] gateway child process error: ${formatErrorMessage(error)}\n`),

);

});

return () => spawnError;

}

async function fetchLocalGatewayHealth(params: {

baseUrl: string;

healthPath: "/readyz" | "/healthz";

exitCode: number | null;

signalCode: NodeJS.Signals | null;

};

getSpawnError?: () => unknown;

timeoutMs?: number;

}) {

const startedAt = Date.now();

while (Date.now() - startedAt < (params.timeoutMs ?? 60_000)) {

const spawnError = params.getSpawnError?.();

if (spawnError) {

throw new QaSuiteInfraError(

"gateway_startup_unhealthy",

`gateway failed to spawn: ${formatErrorMessage(spawnError)}\n${params.logs()}`,

{ cause: spawnError },

);

}

if (params.child.exitCode !== null || params.child.signalCode !== null) {

throw new QaSuiteInfraError(

"gateway_startup_unhealthy",

stderrLog.write(buffer);

});

child = attemptChild;

const getAttemptSpawnError = monitorQaGatewayChildSpawnError(attemptChild, output);

try {

await waitForGatewayReady({

baseUrl,

logs,

child: attemptChild,

getSpawnError: getAttemptSpawnError,

timeoutMs: 120_000,

});

const attemptRpcClient = await startQaGatewayRpcClient({

baseUrl,

logs,

child: attemptChild,

getSpawnError: getAttemptSpawnError,

timeoutMs: QA_GATEWAY_CHILD_RPC_RETRY_HEALTH_TIMEOUT_MS,

});

}

output.push(buffer);

stderrLog.write(buffer);

});

const getNextSpawnError = monitorQaGatewayChildSpawnError(nextChild, output);

try {

await waitForGatewayReady({

baseUrl,

logs,

child: nextChild,

getSpawnError: getNextSpawnError,

timeoutMs: 120_000,

});

const nextRpcClient = await startQaGatewayRpcClient({

baseUrl,

logs,

child: nextChild,

getSpawnError: getNextSpawnError,

timeoutMs: 15_000,

});

}