fix(agent-core-v2): retry a pending journal repair from flush

A repair that failed with no record appended afterwards left flush()
reporting success over an unrepaired journal: nothing was queued, so
there was no persisted error to surface. flush() now retries the pending
repair when the append path has not already tried it in this cycle.

Also cover the denied OpenAI Codex consent end to end through the flow,
not only through the callback server.

Author: elkaix

packages/agent-core-v2/src/wire/wireService.ts

@@ -214,6 +214,9 @@ export class WireService extends Service implements IWireService {
 
   async flush(): Promise<void> {
     await this.persistQueue;
+    if (this.pendingRepair !== undefined && this.persistError === undefined) {
+      await this.repairPendingJournal().catch(() => undefined);
+    }
     const persistError = this.persistError;
     this.persistError = undefined;
     if (persistError !== undefined) throw persistError;

packages/agent-core-v2/test/wire/wireService.test.ts

@@ -659,6 +659,47 @@ describe('WireService corruption repair', () => {
     ]);
   });
 
+  it('retries a pending repair on flush even when nothing was appended', async () => {
+    const capture: RepairCapture = { warnings: [], events: [] };
+    const svc = wireWithCapture(KEY, capture);
+    const prefix = `${currentMetadata()}\n`;
+    const raw = `${prefix}GARBAGE\n`;
+    await seedCorrupt(raw);
+    const originalWrite = storage.write.bind(storage);
+    storage.write = async (scope, key, data, options) => {
+      if (key === AGENT_WIRE_RECORD_KEY) throw new Error('disk full');
+      return originalWrite(scope, key, data, options);
+    };
+    await collect(svc.readJournal());
+    storage.write = originalWrite;
+
+    await svc.flush();
+
+    expect(await rawBytes()).toBe(prefix);
+    expect(await rawBytes(BACKUP_KEY)).toBe(raw);
+    expect(capture.events).toMatchObject([
+      { name: 'wire_repair', payload: { outcome: 'failed' } },
+      { name: 'wire_repair', payload: { outcome: 'repaired' } },
+    ]);
+  });
+
+  it('reports the still-broken journal from flush when nothing was appended', async () => {
+    const capture: RepairCapture = { warnings: [], events: [] };
+    const svc = wireWithCapture(KEY, capture);
+    const prefix = `${currentMetadata()}\n`;
+    const raw = `${prefix}GARBAGE\n`;
+    await seedCorrupt(raw);
+    const originalWrite = storage.write.bind(storage);
+    storage.write = async (scope, key, data, options) => {
+      if (key === AGENT_WIRE_RECORD_KEY) throw new Error('disk full');
+      return originalWrite(scope, key, data, options);
+    };
+    await collect(svc.readJournal());
+
+    await expect(svc.flush()).rejects.toThrow('Wire journal repair did not complete');
+    expect(await rawBytes()).toBe(raw);
+  });
+
   it('refuses to append behind the corrupted tail while a failed repair keeps failing', async () => {
     const capture: RepairCapture = { warnings: [], events: [] };
     const svc = wireWithCapture(KEY, capture);
@@ -681,7 +722,7 @@ describe('WireService corruption repair', () => {
       expect(await rawBytes()).toBe(raw);
       expect(unexpected).toHaveLength(1);
       expect(unexpected[0]).toBeInstanceOf(WireError);
-      expect((unexpected[0] as WireError).code).toBe(WireErrors.codes.RECORDS_WRITE_FAILED);
+      expect(unexpected[0]).toMatchObject({ code: WireErrors.codes.RECORDS_WRITE_FAILED });
       expect(capture.events).toEqual([
         {
           name: 'wire_repair',
@@ -729,7 +770,7 @@ describe('WireService corruption repair', () => {
       expect(await rawBytes()).toBe(raw);
       expect(unexpected).toHaveLength(1);
       expect(unexpected[0]).toBeInstanceOf(WireError);
-      expect((unexpected[0] as WireError).code).toBe(WireErrors.codes.RECORDS_WRITE_FAILED);
+      expect(unexpected[0]).toMatchObject({ code: WireErrors.codes.RECORDS_WRITE_FAILED });
       expect(capture.events).toEqual([
         {
           name: 'wire_repair',

packages/oauth/test/openai-codex-oauth.test.ts

@@ -10,7 +10,9 @@ import {
   fetchOpenAICodexModels,
   OPENAI_CODEX_AUTH_INPUT_MAX_LENGTH,
   parseOpenAICodexAuthorizationInput,
+  OAuthAccessDeniedError,
   OPENAI_CODEX_REDIRECT_URI,
+  runOpenAICodexOAuthFlow,
   startOpenAICodexCallbackServer,
   type OpenAICodexConfigShape,
 } from '../src/openai-codex-oauth';
@@ -327,6 +329,33 @@ describe('startOpenAICodexCallbackServer', () => {
     }
   });
 
+  it('fails the whole flow with OAuthAccessDeniedError when the user denies consent', async () => {
+    const probe = await startOpenAICodexCallbackServer('probe');
+    const loopback = probe.loopback;
+    probe.close();
+    if (!loopback) return;
+
+    let authorizeUrl: string | undefined;
+    const pending = runOpenAICodexOAuthFlow({
+      timeoutMs: 10_000,
+      openBrowser: (url) => {
+        authorizeUrl = url;
+      },
+    });
+    const settled = expect(pending).rejects.toBeInstanceOf(OAuthAccessDeniedError);
+
+    await vi.waitFor(() => expect(authorizeUrl).toBeDefined());
+    const state = new URL(authorizeUrl!).searchParams.get('state');
+    expect(state).toBeTruthy();
+
+    const url = new URL(OPENAI_CODEX_REDIRECT_URI);
+    url.searchParams.set('error', 'access_denied');
+    url.searchParams.set('state', state!);
+    await fetch(url);
+
+    await settled;
+  });
+
   it('reports any other callback error as a dead end the user can still paste past', async () => {
     const server = await startOpenAICodexCallbackServer('state-abc');
     try {