@bitkyc08/opencodex 2.48.0-preview.20260908 → 2.49.0

package/src/storage/cleanup.ts

@@ -96,6 +96,7 @@ export interface CleanupResult {
   trashDir?: string;
   error?: CleanupErrorCode;
   removedPaths: string[];
+  skippedReferencedPaths?: string[];
 }
 
 const STATE_DB_FILE = /^state_(\d+)\.sqlite$/;
@@ -684,52 +685,59 @@ function loadMatchingThreads(db: Database, candidates: ArchivedCandidate[], code
 }
 
 /**
- * True when any matched thread is still linked to a thread outside the delete set
- * (spawn edges) or uses paginated history that other live threads may depend on via fork.
- * Throws real DB errors (busy/corruption) so callers can refuse cleanup.
+ * Partition matched threads into deletable and referenced snapshots. Linked spawn/fork
+ * history and paginated histories stay in the skipped set. Throws real DB errors.
  */
-function findReferencedHistory(
+function filterReferencedHistory(
   db: Database,
   threads: ThreadSnapshot[],
-): boolean {
-  if (threads.length === 0) return false;
-  const ids = threads.map(t => t.id);
-  const idSet = new Set(ids);
-
-  // Paginated history keeps durable projections tied to the rollout — refuse cleanup.
-  if (threads.some(t => (t.history_mode ?? "").toLowerCase() === "paginated")) {
-    return true;
-  }
-
-  // Spawn edges that cross the delete boundary keep history reachable.
-  if (tableExists(db, "thread_spawn_edges")) {
-    for (const chunk of chunkIds(ids, SQLITE_ID_CHUNK)) {
+): { safe: ThreadSnapshot[]; skipped: ThreadSnapshot[] } {
+  let safe = threads.filter(t => (t.history_mode ?? "").toLowerCase() !== "paginated");
+  const skipped = new Map(threads
+    .filter(t => (t.history_mode ?? "").toLowerCase() === "paginated")
+    .map(t => [t.id, t]));
+
+  while (safe.length > 0) {
+    const idSet = new Set(safe.map(t => t.id));
+    const unsafeIds = new Set<string>();
+
+    // Spawn edges that cross the delete boundary keep history reachable.
+    if (tableExists(db, "thread_spawn_edges")) {
+      for (const chunk of chunkIds([...idSet], SQLITE_ID_CHUNK)) {
       const placeholders = chunk.map(() => "?").join(",");
       const edges = db.query<{ parent_thread_id: string; child_thread_id: string }, string[]>(
         `SELECT parent_thread_id, child_thread_id FROM thread_spawn_edges
          WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`,
       ).all(...chunk, ...chunk);
       for (const edge of edges) {
-        if (!idSet.has(edge.parent_thread_id) || !idSet.has(edge.child_thread_id)) {
-          return true;
+        if (!idSet.has(edge.parent_thread_id)) unsafeIds.add(edge.child_thread_id);
+        if (!idSet.has(edge.child_thread_id)) unsafeIds.add(edge.parent_thread_id);
+      }
+    }
+    }
+
+    // Other threads that list one of ours as forked_from / parent (when columns exist).
+    for (const column of ["forked_from_id", "parent_thread_id", "source_thread_id"] as const) {
+      if (!columnExists(db, "threads", column)) continue;
+      for (const chunk of chunkIds([...idSet], SQLITE_ID_CHUNK * 2)) {
+        const placeholders = chunk.map(() => "?").join(",");
+        const rows = db.query<{ id: string; ref: string }, string[]>(
+          `SELECT id, ${column} AS ref FROM threads WHERE ${column} IN (${placeholders})`,
+        ).all(...chunk);
+        for (const row of rows) {
+          if (!idSet.has(row.id)) unsafeIds.add(row.ref);
         }
       }
     }
-  }
 
-  // Other threads that list one of ours as forked_from / parent (when columns exist).
-  for (const column of ["forked_from_id", "parent_thread_id", "source_thread_id"] as const) {
-    if (!columnExists(db, "threads", column)) continue;
-    for (const chunk of chunkIds(ids, SQLITE_ID_CHUNK * 2)) {
-      const placeholders = chunk.map(() => "?").join(",");
-      const rows = db.query<{ id: string }, string[]>(
-        `SELECT id FROM threads WHERE ${column} IN (${placeholders})`,
-      ).all(...chunk);
-      if (rows.some(r => !idSet.has(r.id))) return true;
+    if (unsafeIds.size === 0) break;
+    for (const thread of safe) {
+      if (unsafeIds.has(thread.id)) skipped.set(thread.id, thread);
     }
+    safe = safe.filter(thread => !unsafeIds.has(thread.id));
   }
 
-  return false;
+  return { safe, skipped: [...skipped.values()] };
 }
 
 function tableExists(db: Database, name: string): boolean {
@@ -778,6 +786,7 @@ function deleteThreadsAndDependents(db: Database, threadIds: string[]): void {
 interface ReconcileOk {
   ok: true;
   threads: ThreadSnapshot[];
+  skipped: ThreadSnapshot[];
 }
 interface ReconcileErr {
   ok: false;
@@ -1463,14 +1472,14 @@ function withWritableDb(
   }
 }
 
-/** Load matching archived threads and refuse referenced history — no deletes yet. */
+/** Load matching archived threads and retain referenced history — no deletes yet. */
 function loadThreadsForCleanup(
   stateDbPath: string,
   candidates: ArchivedCandidate[],
   codexHome: string,
   busyTimeoutMs: number,
 ): ReconcileOk | ReconcileErr {
-  if (!stateDbPath || !existsSync(stateDbPath)) return { ok: true, threads: [] };
+  if (!stateDbPath || !existsSync(stateDbPath)) return { ok: true, threads: [], skipped: [] };
   let db: Database | undefined;
   try {
     db = openDbWritable(stateDbPath, busyTimeoutMs);
@@ -1478,10 +1487,8 @@ function loadThreadsForCleanup(
     if (threads.some(t => Number(t.is_pinned ?? 0) === 1)) {
       return { ok: false, error: "pinned_thread" };
     }
-    if (findReferencedHistory(db, threads)) {
-      return { ok: false, error: "referenced_history" };
-    }
-    return { ok: true, threads };
+    const filtered = filterReferencedHistory(db, threads);
+    return { ok: true, threads: filtered.safe, skipped: filtered.skipped };
   } catch (error) {
     return { ok: false, error: mapDbError(error) };
   } finally {
@@ -1504,7 +1511,7 @@ function reconcileDeletedThreads(
   stageDir: string,
   hooks?: ReconcileTestHooks,
 ): ReconcileOk | ReconcileErr {
-  if (!paths.state || !existsSync(paths.state)) return { ok: true, threads: [] };
+  if (!paths.state || !existsSync(paths.state)) return { ok: true, threads: [], skipped: [] };
 
   if (hooks?.beforeReconcileLock) hooks.beforeReconcileLock();
 
@@ -1546,7 +1553,7 @@ function reconcileDeletedThreads(
       stateDb.exec("ROLLBACK");
       return { ok: false, error: "pinned_thread" };
     }
-    if (findReferencedHistory(stateDb, threads)) {
+    if (filterReferencedHistory(stateDb, threads).safe.length !== threads.length) {
       stateDb.exec("ROLLBACK");
       return { ok: false, error: "referenced_history" };
     }
@@ -1582,7 +1589,7 @@ function reconcileDeletedThreads(
       if (hooks?.afterSatelliteMutations) hooks.afterSatelliteMutations();
 
       // Re-check under the same lock before committing state deletes.
-      if (findReferencedHistory(stateDb, threads)) {
+      if (filterReferencedHistory(stateDb, threads).safe.length !== threads.length) {
         stateDb.exec("ROLLBACK");
         return failWithRestore("referenced_history");
       }
@@ -1590,7 +1597,7 @@ function reconcileDeletedThreads(
       if (hooks?.failBeforeStateCommit) throw new Error("test_fail_before_state_commit");
       stateDb.exec("COMMIT");
       // Keep satellite-backup.json for quarantine restore; permanent purge removes the stage.
-      return { ok: true, threads };
+      return { ok: true, threads, skipped: [] };
     } catch (error) {
       if (satelliteLocks) rollbackAllSatelliteLocks(satelliteLocks);
       throw error;
@@ -1895,7 +1902,30 @@ export function executeArchivedCleanup(options: ExecuteCleanupOptions): CleanupR
     const normalized = normalizeArchivedRolloutPath(thread.rollout_path, codexHome);
     if (normalized) threadByRelPath.set(normalized, thread);
   }
-  const manifestEntries: CleanupManifestEntry[] = preview.candidates.map(candidate => {
+  const skippedReferencedPaths = loaded.skipped
+    .map(thread => normalizeArchivedRolloutPath(thread.rollout_path, codexHome))
+    .filter((path): path is string => path !== null);
+  const matchedPaths = new Set([
+    ...threadByRelPath.keys(),
+    ...skippedReferencedPaths,
+  ]);
+  const candidates = preview.candidates.filter(candidate => {
+    return !matchedPaths.has(candidate.relPath) || threadByRelPath.has(candidate.relPath);
+  });
+  if (candidates.length === 0) {
+    removeStageIfEmpty(stageDir, []);
+    removeEmptyTrashRoot(codexHome);
+    return {
+      ok: true,
+      mode,
+      percent,
+      count: 0,
+      bytes: 0,
+      removedPaths: [],
+      ...(skippedReferencedPaths.length ? { skippedReferencedPaths } : {}),
+    };
+  }
+  const manifestEntries: CleanupManifestEntry[] = candidates.map(candidate => {
     const thread = threadByRelPath.get(candidate.relPath);
     return {
       relPath: candidate.relPath,
@@ -1936,7 +1966,7 @@ export function executeArchivedCleanup(options: ExecuteCleanupOptions): CleanupR
     return fail(mode, percent, "fs_failed");
   }
 
-  const stageResult = stageCandidates(codexHome, preview.candidates, stageDir, {
+  const stageResult = stageCandidates(codexHome, candidates, stageDir, {
     blockDestBasenames: blockStageDest.size > 0 ? blockStageDest : undefined,
   });
   if (!stageResult.ok) {
@@ -1956,7 +1986,7 @@ export function executeArchivedCleanup(options: ExecuteCleanupOptions): CleanupR
 
   const deleted = reconcileDeletedThreads(
     paths,
-    preview.candidates,
+    candidates,
     codexHome,
     busyTimeoutMs,
     stageDir,
@@ -1973,8 +2003,8 @@ export function executeArchivedCleanup(options: ExecuteCleanupOptions): CleanupR
     return fail(mode, percent, deleted.error, keepTrash ? { trashDir } : undefined);
   }
 
-  const removedPaths = preview.candidates.map(c => c.relPath);
-  const bytes = preview.candidates.reduce((sum, c) => sum + c.bytes, 0);
+  const removedPaths = candidates.map(c => c.relPath);
+  const bytes = candidates.reduce((sum, c) => sum + c.bytes, 0);
 
   if (mode === "quarantine") {
     return {
@@ -1985,6 +2015,7 @@ export function executeArchivedCleanup(options: ExecuteCleanupOptions): CleanupR
       bytes,
       trashDir,
       removedPaths,
+      ...(skippedReferencedPaths.length ? { skippedReferencedPaths } : {}),
     };
   }
 
@@ -2038,6 +2069,7 @@ export function executeArchivedCleanup(options: ExecuteCleanupOptions): CleanupR
     count: removedPaths.length,
     bytes,
     removedPaths,
+    ...(skippedReferencedPaths.length ? { skippedReferencedPaths } : {}),
   };
 }
 

package/src/types/config.ts

@@ -693,6 +693,12 @@ export interface OcxConfig {
    * non-loopback binds, whose admission token contract is unchanged.
    */
   codexDesktopAuthless?: boolean;
+  /**
+   * Opt into Codex-owned client compaction while keeping OpenCodex routing. On an authenticated
+   * loopback bind, inject the dedicated `opencodex` model provider instead of overriding the
+   * built-in `openai` provider, so Codex does not select native remote compaction. Default off.
+   */
+  codexClientCompaction?: boolean;
   /**
    * Compatibility mode: temporarily rewrite Codex resume-history metadata while the proxy is active
    * so Codex App can show old OpenAI chats and opencodex-created exec chats under its default
@@ -753,7 +759,7 @@ export interface OcxConfig {
    */
   codexAccountPickerEnabled?: boolean;
   /**
-   * Show the GPT-5.3-Codex-Spark weekly window on Codex quota surfaces. Default false.
+   * Show the GPT-5.3-Codex-Spark 5-hour and weekly windows on Codex quota surfaces. Default false.
    *
    * Spark is a single-model window that reads 0% for most operators, and on a multi-account
    * pool it doubles the bar count for information almost nobody acts on. Hidden by default and

package/src/usage/log.ts

@@ -172,6 +172,10 @@ export interface PersistedUsageEntry {
   closeReason?: "terminal" | "client_cancel" | "non_stream" | "body_stall" | "body_overflow";
   /** Already redacted + capped at capture (request-log.ts redactSecretString().slice(0,500)). */
   upstreamError?: string;
+  /** Where the terminal/failure was observed; absent on historic rows. */
+  transportPhase?: "pre_headers" | "mid_stream" | "terminal_sse";
+  /** Whether the terminal came from upstream or a proxy-generated tail. */
+  terminalSource?: "upstream" | "synthetic";
   /**
    * Bounded route-decision trace (RI-01): why this provider/model/account was
    * selected. Additive field; old rows without it parse unchanged. Never
@@ -217,6 +221,22 @@ export function isKnownInboundProtocol(value: unknown): value is NonNullable<Per
   return typeof value === "string" && KNOWN_INBOUND_PROTOCOLS.has(value as NonNullable<PersistedUsageEntry["inboundProtocol"]>);
 }
 
+const KNOWN_TRANSPORT_PHASES = new Set<NonNullable<PersistedUsageEntry["transportPhase"]>>([
+  "pre_headers", "mid_stream", "terminal_sse",
+]);
+
+export function isKnownTransportPhase(value: unknown): value is NonNullable<PersistedUsageEntry["transportPhase"]> {
+  return typeof value === "string" && KNOWN_TRANSPORT_PHASES.has(value as NonNullable<PersistedUsageEntry["transportPhase"]>);
+}
+
+const KNOWN_TERMINAL_SOURCES = new Set<NonNullable<PersistedUsageEntry["terminalSource"]>>([
+  "upstream", "synthetic",
+]);
+
+export function isKnownTerminalSource(value: unknown): value is NonNullable<PersistedUsageEntry["terminalSource"]> {
+  return typeof value === "string" && KNOWN_TERMINAL_SOURCES.has(value as NonNullable<PersistedUsageEntry["terminalSource"]>);
+}
+
 export function usageLogPath(configDir?: string): string {
   return join(configDir ?? getConfigDir(), "usage.jsonl");
 }
@@ -511,6 +531,8 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
   const responseServiceTier = sanitizeLogMetadataString(entry.responseServiceTier);
   const shadowCallRewrittenFrom = sanitizeLogMetadataString(entry.shadowCallRewrittenFrom);
   const claudeCompatibility = normalizeClaudeCompatibilityUsageLog(entry.claudeCompatibility);
+  const transportPhase = isKnownTransportPhase(entry.transportPhase) ? entry.transportPhase : undefined;
+  const terminalSource = isKnownTerminalSource(entry.terminalSource) ? entry.terminalSource : undefined;
   const routeDecision = entry.routeDecision
     ? normalizeRouteDecisionTrace(entry.routeDecision)
     : undefined;
@@ -579,6 +601,8 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
     ...(entry.usage ? { usage: normalizeUsageValue(entry.usage) } : {}),
     ...(typeof entry.totalTokens === "number" ? { totalTokens: entry.totalTokens } : {}),
     ...(Array.isArray(entry.attempts) ? { attempts } : {}),
+    ...(transportPhase ? { transportPhase } : {}),
+    ...(terminalSource ? { terminalSource } : {}),
     ...(entry.errorCode ? { errorCode: entry.errorCode } : {}),
     ...(entry.terminalStatus ? { terminalStatus: entry.terminalStatus } : {}),
     ...(entry.closeReason ? { closeReason: entry.closeReason } : {}),

package/src/vision/anthropic-describe.ts

@@ -200,6 +200,7 @@ export async function describeImageAnthropic(
     const res = await fetchWithResetRetry(
       recovery => fetch(`${base}/v1/messages`, applyUpstreamRecoveryInit({
         method: "POST",
+        redirect: "manual",
         headers,
         body: JSON.stringify(body),
         signal: linkedSignal.signal,

package/src/web-search/anthropic-executor.ts

@@ -210,6 +210,7 @@ export async function runAnthropicWebSearch(
       // ignored a bare `Connection: close` (oven-sh/bun#20492).
       recovery => fetch(url, applyUpstreamRecoveryInit({
         method: "POST",
+        redirect: "manual",
         headers,
         body: JSON.stringify(body),
         signal: linkedSignal.signal,

package/src/web-search/loop.ts

@@ -478,6 +478,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
                 // replay on this leg eligible for the same dead socket the reset came from.
                 return requestFetch(request.url, applyUpstreamRecoveryInit({
                   method: request.method,
+                  redirect: "manual",
                   headers: h,
                   body: request.body,
                   signal: headerDeadline.signal,

package/src/web-search/progress-stream.ts

@@ -303,6 +303,10 @@ export async function* parseStreamWithProgress(
         }
         if (event.type === "done" || event.type === "incomplete") {
           heldTerminal = event;
+          // Response-byte inactivity ends once the adapter has produced a terminal event.
+          // From here the separate post-terminal drain guard owns the bounded wait for
+          // iterator cleanup, so leaving the inactivity timer armed creates a false timeout.
+          clearInactivity();
           continue;
         }
         await handoff.deliver(event);