@yansigit/opencodex 2.36.1-dev.20260829.47 → 2.36.1-dev.20260829.50

package/src/responses/turn-termination.ts

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import type { OcxAssistantMessage, OcxMessage, OcxParsedRequest } from "../types";
+
+const DELIVERED_FINAL_ANSWER_TTL_MS = 60 * 60 * 1_000;
+const DELIVERED_FINAL_ANSWER_MAX_ENTRIES = 1_024;
+
+interface DeliveredFinalAnswerRecord {
+  fingerprint: string;
+  createdAt: number;
+}
+
+const scopesByRequest = new WeakMap<OcxParsedRequest, string>();
+const deliveredFinalAnswers = new Map<string, DeliveredFinalAnswerRecord>();
+
+function pruneDeliveredFinalAnswers(at = Date.now()): void {
+  for (const [scope, record] of deliveredFinalAnswers) {
+    if (at - record.createdAt > DELIVERED_FINAL_ANSWER_TTL_MS) deliveredFinalAnswers.delete(scope);
+  }
+  while (deliveredFinalAnswers.size > DELIVERED_FINAL_ANSWER_MAX_ENTRIES) {
+    const oldest = deliveredFinalAnswers.keys().next().value;
+    if (oldest === undefined) break;
+    deliveredFinalAnswers.delete(oldest);
+  }
+}
+
+function textFingerprint(text: string): string {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+function assistantText(message: OcxAssistantMessage): string | undefined {
+  if (message.content.some(part => part.type === "toolCall")) return undefined;
+  const text = message.content
+    .filter((part): part is Extract<typeof part, { type: "text" }> => part.type === "text")
+    .map(part => part.text)
+    .join("");
+  return text.trim().length > 0 ? text : undefined;
+}
+
+function deliveredFinalAnswerText(response: unknown): string | undefined {
+  if (!response || typeof response !== "object" || Array.isArray(response)) return undefined;
+  const output = (response as { output?: unknown }).output;
+  if (!Array.isArray(output)) return undefined;
+  for (let i = output.length - 1; i >= 0; i--) {
+    const item = output[i];
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const message = item as { type?: unknown; role?: unknown; phase?: unknown; content?: unknown };
+    if (message.type !== "message" || message.role !== "assistant" || message.phase !== "final_answer") continue;
+    if (!Array.isArray(message.content)) return undefined;
+    const text = message.content
+      .filter(part => !!part && typeof part === "object" && !Array.isArray(part)
+        && (part as { type?: unknown }).type === "output_text"
+        && typeof (part as { text?: unknown }).text === "string")
+      .map(part => (part as { text: string }).text)
+      .join("");
+    return text.trim().length > 0 ? text : undefined;
+  }
+  return undefined;
+}
+
+/** Bind the normalized per-conversation digest without adding proxy-private fields to the wire body. */
+export function bindTurnTerminationScope(parsed: OcxParsedRequest, scope: string | undefined): void {
+  // Only the normalized log-conversation digest may key this process-wide map. Refusing any raw
+  // fallback prevents a future caller from retaining a client header or account identifier here.
+  if (!scope || !/^[0-9a-f]{32}$/.test(scope)) return;
+  scopesByRequest.set(parsed, scope);
+}
+
+/** Remember only a final-answer message the proxy actually emitted for this exact conversation. */
+export function rememberDeliveredFinalAnswer(parsed: OcxParsedRequest, response: unknown): void {
+  const scope = scopesByRequest.get(parsed);
+  if (!scope) return;
+  const text = deliveredFinalAnswerText(response);
+  if (!text) return;
+  const at = Date.now();
+  pruneDeliveredFinalAnswers(at);
+  // Refresh insertion order so cap eviction removes the least recently delivered conversation.
+  deliveredFinalAnswers.delete(scope);
+  deliveredFinalAnswers.set(scope, { fingerprint: textFingerprint(text), createdAt: at });
+  pruneDeliveredFinalAnswers(at);
+}
+
+/**
+ * Match only when the delivered assistant answer is still the trailing content-bearing message.
+ * A later user/tool-result message is new work and must reach the provider, even though every
+ * legitimate next turn necessarily contains such a message somewhere in its history.
+ */
+export function hasRecordedTrailingDeliveredFinalAnswer(
+  parsed: OcxParsedRequest,
+  messages: readonly OcxMessage[],
+): boolean {
+  const scope = scopesByRequest.get(parsed);
+  if (!scope) return false;
+  pruneDeliveredFinalAnswers();
+  const record = deliveredFinalAnswers.get(scope);
+  if (!record) return false;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "assistant") return false;
+    const text = assistantText(message as OcxAssistantMessage);
+    if (text === undefined) {
+      if ((message as OcxAssistantMessage).content.some(part => part.type === "toolCall")) return false;
+      continue;
+    }
+    return textFingerprint(text) === record.fingerprint;
+  }
+  return false;
+}

package/src/server/index.ts

@@ -38,6 +38,11 @@ import {
   setLiveStateStoreConfig,
 } from "../lib/state-store-registrations";
 import { startUserCostOverlayReconciler } from "../usage/user-cost-overlay-reconciler";
+import {
+  getStorageCleanupPolicyJobState,
+  getStorageCleanupPolicyTestStreamResponse,
+  requestStorageCleanupPolicyRun,
+} from "../storage/policy-job";
 import {
   configureAppOwnedMemoryBudget,
   enforceAppOwnedMemoryBudget,
@@ -537,6 +542,11 @@ export function startServer(port?: number, deps: StartServerDeps = {}): Server<W
   const managementApi: ManagementApiDeps = {
     saveConfigPreservingClaudeCode,
     mutatePersistedConfig,
+    storageCleanupPolicyJob: {
+      getState: getStorageCleanupPolicyJobState,
+      getTestStream: getStorageCleanupPolicyTestStreamResponse,
+      requestRun: requestStorageCleanupPolicyRun,
+    },
     ...deps.managementApi,
   };
   const localAttestationSecret = deps.localAttestationSecret ?? createLocalAttestationSecret();

package/src/server/management/context.ts

@@ -1,4 +1,5 @@
 import type { OcxConfig } from "../../types";
+import type { PersistedConfigMutation, PersistedConfigMutationOutcome } from "../../config";
 import type { NativeProfileApiDeps } from "../../codex/native-profile-api";
 import type { CodexLogGuardProtectionDeps } from "../../codex/log-guard/protection";
 import type { CodexLogGuardMaintenanceDeps } from "../../codex/log-guard/maintenance";
@@ -40,6 +41,12 @@ export interface ManagementApiDeps {
   saveConfigPreservingClaudeCode?: (config: OcxConfig) => void;
   /** Config-mutation seam for routes that commit through `mutatePersistedConfig`. */
   mutatePersistedConfig?: typeof import("../../config").mutatePersistedConfig;
+  /** Storage-policy job seam keeps management routes off persistence-bearing worker modules. */
+  storageCleanupPolicyJob?: {
+    getState: typeof import("../../storage/policy-job").getStorageCleanupPolicyJobState;
+    getTestStream: typeof import("../../storage/policy-job").getStorageCleanupPolicyTestStreamResponse;
+    requestRun: typeof import("../../storage/policy-job").requestStorageCleanupPolicyRun;
+  };
   /** Test-only fetch injection for Replit gateway install probes. */
   probeFetch?: typeof globalThis.fetch;
   /**
@@ -142,11 +149,11 @@ export function saveManagementConfig(deps: ManagementApiDeps, config: OcxConfig)
 /** The only locked, field-scoped on-disk mutation boundary available to management routes. */
 export function mutateManagementConfig<T>(
   deps: ManagementApiDeps,
-  mutate: Parameters<NonNullable<ManagementApiDeps["mutatePersistedConfig"]>>[0],
-): ReturnType<NonNullable<ManagementApiDeps["mutatePersistedConfig"]>> {
+  mutate: (config: OcxConfig) => PersistedConfigMutation<T>,
+): PersistedConfigMutationOutcome<T> {
   if (!deps.mutatePersistedConfig) throw new MissingManagementPersistenceError();
   try {
-    return deps.mutatePersistedConfig(mutate) as ReturnType<NonNullable<ManagementApiDeps["mutatePersistedConfig"]>>;
+    return deps.mutatePersistedConfig(mutate);
   } catch (error) {
     throw new ManagementPersistenceError(error);
   }

package/src/server/management/logs-usage-routes.ts

@@ -20,7 +20,7 @@ import {
   submitManualLoginCode,
   upsertOAuthProvider,
 } from "../../oauth";
-import { getAccountSet, removeCredential } from "../../oauth/store";
+import { removeCredential } from "../../oauth/store";
 import { providerDestinationResolvedError } from "../../lib/destination-policy";
 import { enrichProviderFromCatalog, listKeyLoginProviders } from "../../oauth/key-providers";
 import { deriveProviderPresets } from "../../providers/derive";
@@ -31,21 +31,13 @@ import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
 import { clearThreadAccountMap } from "../../codex/routing";
 import { primeCodexPoolQuotas } from "../../codex/auth-api";
 import { DEFAULT_PROVIDER_CONTEXT_CAP, globalContextCapValue, providerContextCap, providerContextCaps, setAllProviderContextCaps, setGlobalContextCapValue, setProviderContextCap } from "../../providers/context-cap";
-import { resolveCodexHomeDir } from "../../codex/home";
-import { scanStorage } from "../../storage/scanner";
 import { executeArchivedCleanup, listTrashEntries, pickWireCleanupTestHooks, previewArchivedCleanup, type CleanupMode, type RestoreErrorCode } from "../../storage/cleanup";
 import { runArchivedCleanupJob } from "../../storage/cleanup-job";
 import { getRestoreTrashTestStreamResponse, runRestoreTrashEntryJob } from "../../storage/restore-job";
 import {
   normalizeStorageCleanupPolicy,
   parseStorageCleanupPolicyInput,
-  writeStorageCleanupPolicyToConfig,
-} from "../../storage/policy";
-import {
-  getStorageCleanupPolicyJobState,
-  getStorageCleanupPolicyTestStreamResponse,
-  requestStorageCleanupPolicyRun,
-} from "../../storage/policy-job";
+} from "../../storage/policy-input";
 import {
   currentUsageLogRevision,
   readUsageSnapshotForManagement,
@@ -77,7 +69,7 @@ import { applySystemEnvToggle } from "../system-env";
 
 import { isPlainRecord, parseDebugLogQuery, tokPerSecondResult, unavailableCostReason, costResult, requestLogDto, stripRegistryOnlyStaticHeaders, fetchAllModels } from "./shared";
 import type { MetricUnavailableReason, TokPerSecondResult, CostEstimateReason, CostResult, MetricSource } from "./shared";
-import type { ManagementContext } from "./context";
+import { MissingManagementPersistenceError, mutateManagementConfig, type ManagementContext } from "./context";
 import { readManagementJsonBody, rethrowManagementBodyTooLarge } from "./body";
 import {
   discardUsageSummaryCacheEntry,
@@ -131,6 +123,7 @@ function snapshotWindow(entries: PersistedUsageEntry[]): { start: number | null;
 
 export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Response | null> {
   const { req, url, config, deps, syncClaudeAgentDefsBestEffort } = ctx;
+  const storagePolicyJobState = () => deps.storageCleanupPolicyJob?.getState() ?? { status: "idle" as const };
 
   if (url.pathname === "/api/logs" && req.method === "GET") {
     const all = getRequestLogEntries();
@@ -203,16 +196,10 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
     const filter = {
       provider: url.searchParams.get("provider"),
       model: url.searchParams.get("model"),
-      account: url.searchParams.get("account"),
     };
-    const fallbackAccounts: Record<string, string> = {};
-    for (const p of listOAuthProviders()) {
-      const set = getAccountSet(p);
-      if (set && set.accounts.length === 1 && set.activeAccountId) fallbackAccounts[p] = set.activeAccountId;
-    }
     const project = <T extends UsageSummary>(summary: T, entries?: PersistedUsageEntry[]) =>
-      projectUsageSummary(summary, filter, entries, fallbackAccounts);
-    const filterRequested = Boolean(filter.provider ?? filter.model ?? filter.account);
+      projectUsageSummary(summary, filter, entries);
+    const filterRequested = Boolean(filter.provider ?? filter.model);
     const now = Date.now();
     try {
       const cacheKey = `${range}:${surface}`;
@@ -247,7 +234,7 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
       const revisionReadAt = Date.now();
       const window = snapshotWindow(snapshot.entries);
       const summary = {
-        ...summarizeUsage(snapshot.entries, range, now, surface, fallbackAccounts),
+        ...summarizeUsage(snapshot.entries, range, now, surface),
         historyTruncated: snapshot.truncatedPrefixBytes > 0 || snapshot.entriesTruncated,
         truncatedPrefixBytes: snapshot.truncatedPrefixBytes,
         entriesTruncated: snapshot.entriesTruncated,
@@ -275,7 +262,7 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
       for (const nextRange of ranges) {
         for (const nextSurface of surfaces) {
           const nextSummary = nextRange === range && nextSurface === surface ? summary : {
-            ...summarizeUsage(snapshot.entries, nextRange, now, nextSurface, fallbackAccounts),
+            ...summarizeUsage(snapshot.entries, nextRange, now, nextSurface),
             historyTruncated: summary.historyTruncated,
             truncatedPrefixBytes: summary.truncatedPrefixBytes,
             entriesTruncated: summary.entriesTruncated,
@@ -348,20 +335,6 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
     }
   }
 
-  if (url.pathname === "/api/storage" && req.method === "GET") {
-    try {
-      return jsonResponse(scanStorage());
-    } catch {
-      return jsonResponse({
-        codexHome: resolveCodexHomeDir(),
-        generatedAt: Date.now(),
-        total: { bytes: 0, fileCount: 0 },
-        buckets: [],
-        error: "scan_failed",
-      });
-    }
-  }
-
   if (url.pathname === "/api/storage/cleanup/preview" && req.method === "POST") {
     let body: { percent?: unknown };
     try { body = await readManagementJsonBody(req); } catch (error) { rethrowManagementBodyTooLarge(error); return jsonResponse({ error: "invalid_json" }, 400); }
@@ -555,7 +528,7 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
   }
 
   if (url.pathname === "/api/storage/cleanup-policy/test-stream" && req.method === "GET") {
-    const stream = getStorageCleanupPolicyTestStreamResponse();
+    const stream = deps.storageCleanupPolicyJob?.getTestStream();
     if (stream) return stream;
     // Production: hook is off. Return an explicit JSON 404 — do not fall through to the GUI.
     return jsonResponse({ error: "not_found" }, 404);
@@ -565,7 +538,7 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
     const policy = normalizeStorageCleanupPolicy(config.storageCleanupPolicy);
     return jsonResponse({
       ...policy,
-      job: getStorageCleanupPolicyJobState(),
+      job: storagePolicyJobState(),
     });
   }
 
@@ -575,17 +548,25 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
     const previous = normalizeStorageCleanupPolicy(config.storageCleanupPolicy);
     const parsed = parseStorageCleanupPolicyInput(raw, previous);
     if (!parsed.ok) return jsonResponse({ error: parsed.error }, 400);
-    // Never enable implicitly: if client omitted enabled, keep previous (default false).
     const body = raw as Record<string, unknown>;
-    if (body.enabled === undefined) parsed.policy.enabled = previous.enabled;
-    const saved = writeStorageCleanupPolicyToConfig(parsed.policy);
-    config.storageCleanupPolicy = saved;
-    return jsonResponse({ ok: true, policy: saved, job: getStorageCleanupPolicyJobState() });
+    const persisted = mutateManagementConfig(deps, disk => {
+      const latest = normalizeStorageCleanupPolicy(disk.storageCleanupPolicy);
+      const rebased = parseStorageCleanupPolicyInput(raw, latest);
+      if (!rebased.ok) throw new Error(rebased.error);
+      // Never enable implicitly: if client omitted enabled, keep the latest persisted value.
+      if (body.enabled === undefined) rebased.policy.enabled = latest.enabled;
+      disk.storageCleanupPolicy = rebased.policy;
+      return { changed: true, value: structuredClone(rebased.policy) };
+    });
+    if (persisted.status === "unavailable") return jsonResponse({ error: "management persistence unavailable" }, 500);
+    config.storageCleanupPolicy = persisted.value;
+    return jsonResponse({ ok: true, policy: persisted.value, job: storagePolicyJobState() });
   }
 
   if (url.pathname === "/api/storage/cleanup-policy/run" && req.method === "POST") {
     try {
-      const accepted = requestStorageCleanupPolicyRun({ reason: "manual", force: true });
+      if (!deps.storageCleanupPolicyJob) throw new MissingManagementPersistenceError();
+      const accepted = deps.storageCleanupPolicyJob.requestRun({ reason: "manual", force: true });
       if (!accepted.accepted) {
         return jsonResponse({
           ok: false,