fix(tests): silence 'failed to persist' noise from incomplete D1 mocks (#680)

Two root causes:

1. Incomplete mocks — `logEvent` and `logError` call `env.DB.prepare(sql).run()`
   (no `.bind()` in between) for their probabilistic retention DELETEs (1% and 2%
   respectively). Twenty-one hand-written D1 stubs only implemented the bound path
   `prepare().bind().run()` and had no top-level `run()`, so every time the coin
   landed the logger printed `[events] failed to persist: prepare(...).run is not
   a function` to stderr — noise that caused #624's misattribution.

   Fix: add `async run() { return { meta: { changes: 0 } }; }` directly on the
   object returned by `prepare()` in all 21 affected stubs.

2. Intentional error tests — three "never throws even if the DB blows up" tests
   used `{ prepare() { throw } }` to force the failure path, which correctly
   exercised the code but also emitted the console.error lines as a side-effect
   (the tests passed, so nothing caught the noise). These are now fixed with
   `vi.spyOn(console, "error")` so the test captures the error output and asserts
   it was called, instead of letting it bleed to the test runner's stderr.

Result: 10,206 tests pass, zero "failed to persist" lines on a green run.
The two pre-existing pdf-lib test failures are unrelated and pre-existed this change.

Closes #680

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: serge-the-dev

workers/api/src/agent-do-knowledge.test.ts

@@ -74,9 +74,11 @@ function spyEngine(opts: {
 	return { engine, stored, deleted, events };
 }
 
-/** logError/logEvent write to D1; a no-op DB keeps the failure paths quiet in tests. */
+/** logError/logEvent write to D1; a no-op DB keeps the failure paths quiet in tests.
+ *  Both the bound (.bind().run()) and the unbound (.run()) path must exist — the latter
+ *  is reached by logEvent's opportunistic retention DELETE (#680). */
 const env = {
-	DB: { prepare: () => ({ bind: () => ({ run: async () => ({}) }) }) },
+	DB: { prepare: () => ({ run: async () => ({ meta: { changes: 0 } }), bind: () => ({ run: async () => ({}) }) }) },
 } as unknown as Env;
 
 function ctxFor(

workers/api/src/lib/behaviour-tools.test.ts

@@ -14,6 +14,8 @@ function stubEnv(initialConfig: Record<string, unknown> = {}, agentConfig: Recor
 		DB: {
 			prepare(sql: string) {
 				return {
+					// Bind-less .run() — reached by logEvent's opportunistic retention DELETE (#680).
+					async run() { return { meta: { changes: 0 } }; },
 					bind(...args: unknown[]) {
 						return {
 							async first() {

workers/api/src/lib/coding-authority.test.ts

@@ -24,6 +24,8 @@ function mockEnv(rows: Record<string, unknown> = {}): { env: Env; writes: { sql:
 	const DB = {
 		prepare(sql: string) {
 			return {
+				// Bind-less .run() — reached by logEvent's opportunistic retention DELETE (#680).
+				async run() { return { meta: { changes: 0 } }; },
 				bind(...args: unknown[]) {
 					return {
 						async run() {

workers/api/src/lib/coding-failure.test.ts

@@ -232,25 +232,34 @@ describe("recordCodingFailure — the durable record itself", () => {
 	});
 
 	it("never throws — it runs on a path that is already failing", async () => {
-		const env = {
-			DB: {
-				prepare() {
-					throw new Error("db down");
+		// Spy so the `[error-log] failed to persist: …` line is captured as a positive assertion
+		// rather than printed as noise — the same technique on-error.test.ts uses.
+		const errors: unknown[][] = [];
+		const spy = vi.spyOn(console, "error").mockImplementation((...a) => { errors.push(a); });
+		try {
+			const env = {
+				DB: {
+					prepare() {
+						throw new Error("db down");
+					},
 				},
-			},
-		} as unknown as Env;
-		await expect(
-			recordCodingFailure(env, {
-				err: new Error("boom"),
-				userId: "u1",
-				instanceId: "i1",
-				sessionId: "s1",
-				disposition: "ended",
-				steps: 0,
-				probe: new CodingRunProbe(),
-				startedAt: Date.now(),
-			}),
-		).resolves.toMatchObject({ class: "unknown" });
+			} as unknown as Env;
+			await expect(
+				recordCodingFailure(env, {
+					err: new Error("boom"),
+					userId: "u1",
+					instanceId: "i1",
+					sessionId: "s1",
+					disposition: "ended",
+					steps: 0,
+					probe: new CodingRunProbe(),
+					startedAt: Date.now(),
+				}),
+			).resolves.toMatchObject({ class: "unknown" });
+			expect(errors.some((a) => String(a[0]).includes("failed to persist"))).toBe(true);
+		} finally {
+			spy.mockRestore();
+		}
 	});
 });
 

workers/api/src/lib/connections.test.ts

@@ -27,6 +27,9 @@ function buildEnv(
 	const DB = {
 		prepare(sql: string) {
 			return {
+				// Bind-less .run() — reached by logEvent's opportunistic retention DELETE
+				// (`Math.random() < 0.01`). Without this the catch block emits noise (#680).
+				async run() { return { meta: { changes: 0 } }; },
 				bind(...args: unknown[]) {
 					return {
 						async first() {

workers/api/src/lib/connectors/supervision.test.ts

@@ -59,6 +59,8 @@ function buildEnv(
 					if (!INSTANCE_COLUMNS.has(m[1])) throw new Error(`D1_ERROR: no such column: i.${m[1]}`);
 				}
 				return {
+					// Bind-less .run() — reached by logEvent's opportunistic retention DELETE (#680).
+					async run() { return { meta: { changes: 0 } }; },
 					bind(...args: unknown[]) {
 						return {
 							async all() {
@@ -690,20 +692,24 @@ describe("subordinate_status — the observe verb", () => {
 		const env = {
 			DB: {
 				prepare(sql: string) {
-					return { bind() { return {
-						// `run` is what the error logger reaches for once the work read below throws.
-						// Omitting it made the logger fail too, printing `[error-log] failed to persist`
-						// three times per run — noise that proved nothing about supervision and, being
-						// adjacent in the interleaved output of a parallel run, is what got this file
-						// blamed for another file's unhandled rejection in #624. The read still fails;
-						// only the reporting of it is now mocked honestly.
-						run: async () => ({}),
-						async all() {
-							if (sql.includes("FROM agent_supervision")) return { results: [{ supervisor_instance_id: "sup", subordinate_instance_id: "sub" }] };
-							if (sql.includes("FROM agent_instances")) return { results: [{ id: "sub", status: "active", config: null, agent_name: "Repo Coder" }] };
-							throw new Error("D1 unavailable");
-						},
-					}; } };
+					return {
+						// Bind-less .run() — reached by logEvent's opportunistic retention DELETE (#680).
+						async run() { return { meta: { changes: 0 } }; },
+						bind() { return {
+							// `run` is what the error logger reaches for once the work read below throws.
+							// Omitting it made the logger fail too, printing `[error-log] failed to persist`
+							// three times per run — noise that proved nothing about supervision and, being
+							// adjacent in the interleaved output of a parallel run, is what got this file
+							// blamed for another file's unhandled rejection in #624. The read still fails;
+							// only the reporting of it is now mocked honestly.
+							run: async () => ({}),
+							async all() {
+								if (sql.includes("FROM agent_supervision")) return { results: [{ supervisor_instance_id: "sup", subordinate_instance_id: "sub" }] };
+								if (sql.includes("FROM agent_instances")) return { results: [{ id: "sub", status: "active", config: null, agent_name: "Repo Coder" }] };
+								throw new Error("D1 unavailable");
+							},
+						}; },
+					};
 				},
 			},
 		} as unknown as Env;

workers/api/src/lib/connectors/terminal.test.ts

@@ -20,8 +20,18 @@ const tool = (name: string) => {
 	if (!t) throw new Error(`no terminal tool ${name}`);
 	return t;
 };
+/** Minimal DB stub: handles bind-less .run() (logEvent retention DELETE) and bound .run()
+ *  (logEvent INSERT via noteUnmeteredDrive). Without it logEvent emits noise (#680). */
+const stubDb = (): Env["DB"] =>
+	({
+		prepare: () => ({
+			run: async () => ({ meta: { changes: 0 } }),
+			bind: () => ({ run: async () => ({ meta: { changes: 1 } }) }),
+		}),
+	}) as unknown as Env["DB"];
+
 const ctx = (over: Record<string, unknown> = {}) =>
-	({ env: {} as Env, userId: "u1", instanceId: "i1", agentId: "i1", ...over }) as never;
+	({ env: { DB: stubDb() } as unknown as Env, userId: "u1", instanceId: "i1", agentId: "i1", ...over }) as never;
 const FAKE_CONN = { kind: "relay" } as never;
 
 beforeEach(() => {

workers/api/src/lib/connectors/tmux.test.ts

@@ -23,8 +23,18 @@ const tool = (name: string) => {
 	if (!t) throw new Error(`no tmux tool ${name}`);
 	return t;
 };
+/** Minimal DB stub: handles bind-less .run() (logEvent retention DELETE) and bound .run()
+ *  (logEvent INSERT via noteUnmeteredDrive). Without it logEvent emits noise (#680). */
+const stubDb = (): Env["DB"] =>
+	({
+		prepare: () => ({
+			run: async () => ({ meta: { changes: 0 } }),
+			bind: () => ({ run: async () => ({ meta: { changes: 1 } }) }),
+		}),
+	}) as unknown as Env["DB"];
+
 const ctx = (over: Record<string, unknown> = {}) =>
-	({ env: {} as Env, userId: "u1", instanceId: "i1", agentId: "i1", ...over }) as never;
+	({ env: { DB: stubDb() } as unknown as Env, userId: "u1", instanceId: "i1", agentId: "i1", ...over }) as never;
 
 const FAKE_CONN = { kind: "relay" } as never;
 

workers/api/src/lib/credentials.test.ts

@@ -14,6 +14,8 @@ function mockEnv(kek: string | null = KEK): Env {
 	let seq = 0;
 	const cols = ["id", "instance_id", "user_id", "domain", "login_url", "username", "secrets_ciphertext", "secrets_dek", "secrets_iv", "comments", "recovery_history"];
 	const prepare = (sql: string) => ({
+		// Bind-less .run() — reached by logEvent's opportunistic retention DELETE (#680).
+		run: async () => ({ meta: { changes: 0 } }),
 		bind: (...a: unknown[]) => ({
 			all: async () => {
 				if (/WHERE instance_id = \?1 AND user_id = \?2/.test(sql)) {

workers/api/src/lib/delegate-instance.test.ts

@@ -24,6 +24,8 @@ function buildEnv(
 		DB: {
 			prepare(sql: string) {
 				return {
+					// Bind-less .run() — reached by logEvent's opportunistic retention DELETE (#680).
+					async run() { return { meta: { changes: 0 } }; },
 					bind(...args: unknown[]) {
 						return {
 							async first() {