fix(codex): adopt compacted context-engine transcripts

jalehman · jalehman · commit a3f06bf1608f · 2026-05-15T17:32:32.000-07:00
diff --git a/extensions/codex/src/app-server/compact.test.ts b/extensions/codex/src/app-server/compact.test.ts
@@ -513,6 +513,67 @@ describe("maybeCompactCodexAppServerSession", () => {
     );
   });
 
+  it("adopts successor transcript handles after owning context-engine compaction", async () => {
+    const sessionFile = await writeTestBinding();
+    const successorFile = path.join(tempDir, "session.compacted.jsonl");
+    await writeCodexAppServerBinding(successorFile, {
+      threadId: "thread-successor",
+      cwd: tempDir,
+    });
+    const compact = vi.fn(async () => ({
+      ok: true,
+      compacted: true,
+      result: {
+        summary: "engine summary",
+        firstKeptEntryId: "entry-1",
+        tokensBefore: 55,
+        sessionId: "session-1-compacted",
+        sessionFile: successorFile,
+      },
+    }));
+    const maintain = vi.fn(
+      async (_params: Parameters<NonNullable<ContextEngine["maintain"]>>[0]) => ({
+        changed: false,
+        bytesFreed: 0,
+        rewrittenEntries: 0,
+      }),
+    );
+    const contextEngine: ContextEngine = {
+      info: { id: "lossless-claw", name: "Lossless Claw", ownsCompaction: true },
+      assemble: vi.fn() as never,
+      ingest: vi.fn() as never,
+      compact,
+      maintain,
+    };
+
+    const result = requireCompactResult(
+      await maybeCompactCodexAppServerSession({
+        sessionId: "session-1",
+        sessionKey: "agent:main:session-1",
+        sessionFile,
+        workspaceDir: tempDir,
+        contextEngine,
+      }),
+    );
+
+    expect(result.ok).toBe(true);
+    expect(result.compacted).toBe(true);
+    expect(result.result?.sessionId).toBe("session-1-compacted");
+    expect(result.result?.sessionFile).toBe(successorFile);
+    expect(await readCodexAppServerBinding(sessionFile)).toBeUndefined();
+    expect(await readCodexAppServerBinding(successorFile)).toBeUndefined();
+    expect(maintain).toHaveBeenCalledTimes(1);
+    const [maintainCall] = maintain.mock.calls[0] ?? [];
+    const maintainParams = maintainCall as
+      | {
+          sessionId?: string;
+          sessionFile?: string;
+        }
+      | undefined;
+    expect(maintainParams?.sessionId).toBe("session-1-compacted");
+    expect(maintainParams?.sessionFile).toBe(successorFile);
+  });
+
   it("returns context-engine compaction success when maintenance fails", async () => {
     const sessionFile = await writeTestBinding();
     const compact = vi.fn(async () => ({
diff --git a/extensions/codex/src/app-server/compact.ts b/extensions/codex/src/app-server/compact.ts
@@ -105,24 +105,29 @@ async function compactOwningContextEngine(
   }
 
   if (result.ok && result.compacted) {
+    const compactedSessionId = result.result?.sessionId ?? params.sessionId;
+    const compactedSessionFile = result.result?.sessionFile ?? params.sessionFile;
     try {
       await runHarnessContextEngineMaintenance({
         contextEngine,
-        sessionId: params.sessionId,
+        sessionId: compactedSessionId,
         sessionKey: params.sessionKey,
-        sessionFile: params.sessionFile,
+        sessionFile: compactedSessionFile,
         reason: "compaction",
         runtimeContext: params.contextEngineRuntimeContext,
         config: params.config,
       });
     } catch (error) {
       embeddedAgentLog.warn("context engine compaction maintenance failed", {
-        sessionId: params.sessionId,
+        sessionId: compactedSessionId,
         engineId: contextEngine.info.id,
         error: formatErrorMessage(error),
       });
     }
     await clearCodexAppServerBinding(params.sessionFile);
+    if (compactedSessionFile !== params.sessionFile) {
+      await clearCodexAppServerBinding(compactedSessionFile);
+    }
   }
 
   embeddedAgentLog.info("completed context-engine-owned Codex app-server compaction", {
