@bitkyc08/opencodex 2.7.27 → 2.7.28

package/src/storage/scanner.ts

@@ -0,0 +1,223 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { resolveCodexHomeDir } from "../codex/home";
+
+/**
+ * Read-only CODEX_HOME storage scanner — Phase 1 of the Storage page epic
+ * (devlog/_plan/500_storage-page-session-cleanup). Pure measurement: sizes via
+ * fs.stat walks, DB row counts via short-timeout readonly opens that degrade to
+ * null on lock/corruption. Performs zero writes under CODEX_HOME.
+ */
+
+export type StorageBucketKey =
+  | "sessions"
+  | "archived_sessions"
+  | "logs_db"
+  | "state_db"
+  | "attachments"
+  | "deletion_manifests"
+  | "other";
+
+export interface StorageLargestEntry {
+  /** Path relative to CODEX_HOME, forward-slash separated on every platform. */
+  path: string;
+  bytes: number;
+}
+
+export interface StorageBucket {
+  key: StorageBucketKey;
+  label: string;
+  bytes: number;
+  fileCount: number;
+  /** Epoch ms of the oldest/newest file mtime; absent for empty buckets. */
+  oldest?: number;
+  newest?: number;
+  largest?: StorageLargestEntry[];
+  /** sqlite buckets only: row count from the newest versioned DB, null when locked/unreadable. */
+  rows?: number | null;
+}
+
+export interface StorageReport {
+  codexHome: string;
+  generatedAt: number;
+  total: { bytes: number; fileCount: number };
+  buckets: StorageBucket[];
+}
+
+const LARGEST_CAP = 5;
+
+const BUCKET_LABELS: Record<StorageBucketKey, string> = {
+  sessions: "Active sessions",
+  archived_sessions: "Archived sessions",
+  logs_db: "Logs database",
+  state_db: "State database",
+  attachments: "Attachments",
+  deletion_manifests: "Deletion manifests",
+  other: "Other",
+};
+
+/** Dirs under CODEX_HOME that map to a dedicated bucket; anything else is "other". */
+const DIR_BUCKETS: Record<string, StorageBucketKey> = {
+  sessions: "sessions",
+  archived_sessions: "archived_sessions",
+  attachments: "attachments",
+  deletion_manifests: "deletion_manifests",
+};
+
+// state_5.sqlite / logs_2.sqlite carry a version suffix and live WAL/SHM siblings.
+const STATE_DB_FILE = /^state_(\d+)\.sqlite(-wal|-shm)?$/;
+const LOGS_DB_FILE = /^logs_(\d+)\.sqlite(-wal|-shm)?$/;
+
+interface FileEntry {
+  relPath: string;
+  bytes: number;
+  mtimeMs: number;
+}
+
+/** Recursive fs.stat walk. Unreadable entries (races, broken symlinks) are skipped, never fatal. */
+function walkFiles(dir: string, relPrefix: string, out: FileEntry[]): void {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    const relPath = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+    try {
+      if (entry.isDirectory()) {
+        walkFiles(full, relPath, out);
+      } else if (entry.isFile()) {
+        const stat = statSync(full);
+        out.push({ relPath, bytes: stat.size, mtimeMs: stat.mtimeMs });
+      }
+    } catch {
+      /* entry vanished mid-scan — diagnostics tolerate racy trees */
+    }
+  }
+}
+
+function buildBucket(key: StorageBucketKey, files: FileEntry[]): StorageBucket {
+  const bucket: StorageBucket = {
+    key,
+    label: BUCKET_LABELS[key],
+    bytes: 0,
+    fileCount: files.length,
+  };
+  for (const file of files) {
+    bucket.bytes += file.bytes;
+    if (bucket.oldest === undefined || file.mtimeMs < bucket.oldest) bucket.oldest = file.mtimeMs;
+    if (bucket.newest === undefined || file.mtimeMs > bucket.newest) bucket.newest = file.mtimeMs;
+  }
+  if (files.length > 0) {
+    bucket.largest = [...files]
+      .sort((a, b) => b.bytes - a.bytes)
+      .slice(0, LARGEST_CAP)
+      .map(f => ({ path: f.relPath, bytes: f.bytes }));
+  }
+  return bucket;
+}
+
+/**
+ * Row count via a lock-safe readonly open (the same secondary-reader contract as
+ * codex/history-provider.ts): short busy timeout, and any lock/corruption/schema
+ * error degrades to null — "unknown", never a crash and never a write.
+ */
+function countRowsReadonly(dbPath: string, table: string): number | null {
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      db.exec("PRAGMA busy_timeout = 100");
+      const row = db.query<{ n: number }, []>(`SELECT count(*) AS n FROM "${table}"`).get();
+      return row?.n ?? null;
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
+
+/** Newest versioned DB main file (e.g. state_5.sqlite over state_4.sqlite), or null. */
+function newestVersionedDb(names: string[], pattern: RegExp): string | null {
+  let best: string | null = null;
+  let bestVersion = -1;
+  for (const name of names) {
+    const match = name.match(pattern);
+    if (!match || match[2]) continue; // -wal/-shm siblings never win
+    const version = Number(match[1]);
+    if (version > bestVersion) {
+      bestVersion = version;
+      best = name;
+    }
+  }
+  return best;
+}
+
+export function scanStorage(codexHome: string = resolveCodexHomeDir()): StorageReport {
+  const files: Record<StorageBucketKey, FileEntry[]> = {
+    sessions: [],
+    archived_sessions: [],
+    logs_db: [],
+    state_db: [],
+    attachments: [],
+    deletion_manifests: [],
+    other: [],
+  };
+
+  let rootNames: string[] = [];
+  try {
+    rootNames = readdirSync(codexHome);
+  } catch (error) {
+    // A missing home is a normal fresh-machine state — report zeros. Anything else
+    // (e.g. ENOTDIR: CODEX_HOME points at a file) is a broken setup the caller
+    // must surface as a scan failure, not silently render as an empty home.
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT") throw error;
+  }
+
+  for (const name of rootNames) {
+    const full = join(codexHome, name);
+    let stat;
+    try {
+      stat = statSync(full);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      walkFiles(full, name, files[DIR_BUCKETS[name] ?? "other"]);
+    } else if (stat.isFile()) {
+      const key: StorageBucketKey = STATE_DB_FILE.test(name) ? "state_db" : LOGS_DB_FILE.test(name) ? "logs_db" : "other";
+      files[key].push({ relPath: name, bytes: stat.size, mtimeMs: stat.mtimeMs });
+    }
+  }
+
+  const buckets = (Object.keys(files) as StorageBucketKey[]).map(key => buildBucket(key, files[key]));
+
+  const stateDbName = newestVersionedDb(rootNames, STATE_DB_FILE);
+  const stateBucket = buckets.find(b => b.key === "state_db");
+  if (stateBucket && stateBucket.fileCount > 0) {
+    stateBucket.rows = stateDbName ? countRowsReadonly(join(codexHome, stateDbName), "threads") : null;
+  }
+  const logsDbName = newestVersionedDb(rootNames, LOGS_DB_FILE);
+  const logsBucket = buckets.find(b => b.key === "logs_db");
+  if (logsBucket && logsBucket.fileCount > 0) {
+    logsBucket.rows = logsDbName ? countRowsReadonly(join(codexHome, logsDbName), "logs") : null;
+  }
+
+  let totalBytes = 0;
+  let totalFiles = 0;
+  for (const bucket of buckets) {
+    totalBytes += bucket.bytes;
+    totalFiles += bucket.fileCount;
+  }
+
+  return {
+    codexHome,
+    generatedAt: Date.now(),
+    total: { bytes: totalBytes, fileCount: totalFiles },
+    buckets,
+  };
+}

package/src/types.ts

@@ -430,7 +430,10 @@ export interface OcxConfig {
    * those are unset — Bun's fetch honors them for all outbound calls; localhost is excluded.
    */
   proxy?: string;
-  /** Upstream stall timeout (seconds). After this many seconds of no upstream data, emits response.incomplete. Default 90. Min 1. */
+  /**
+   * Upstream stall timeout (seconds). After this many seconds of no upstream data, emits
+   * response.incomplete. Default 300. Min 1.
+   */
   stallTimeoutSec?: number;
   /** Connect timeout (ms) for upstream fetch — covers DNS, TCP, TLS, and response header. Default 200000. */
   connectTimeoutMs?: number;

package/src/usage/expected-prices.ts

@@ -0,0 +1,112 @@
+/**
+ * Expected-price overlay for models whose jawcode cost rows are missing or all-zero
+ * (subscription/OAuth surfaces). Sourced from official pricing pages only
+ * (devlog/_plan/260720_toks_speed_price_columns/003 — Luna research, main-verified).
+ *
+ * Status semantics:
+ * - "verified": official page opened directly; the 4-tuple is the published API price.
+ * - "verified-derived": mapped from a verified base-model price (for example an
+ *   effort-suffix variant); propagates `estimated=true` downstream.
+ * - "unverified": research lead only. NEVER registered here and never returned by
+ *   the resolver — unverified prices live in the 003 §5 backlog until promoted.
+ */
+
+export interface Cost4 {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export type ExpectedPriceStatus = "verified" | "verified-derived" | "unverified";
+
+export interface ExpectedPriceOverlay {
+  provider: string;
+  modelId: string;
+  cost4: Cost4;
+  source: string;
+  verifiedAt: string;
+  status: ExpectedPriceStatus;
+}
+
+const GEMINI_31_PRO: Cost4 = { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 0 };
+const GEMINI_35_FLASH: Cost4 = { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 };
+const GEMINI_3_FLASH: Cost4 = { input: 0.5, output: 3, cacheRead: 0.05, cacheWrite: 0 };
+const MINIMAX_M21_HIGHSPEED: Cost4 = { input: 0.6, output: 2.4, cacheRead: 0.03, cacheWrite: 0.375 };
+const KIMI_K3: Cost4 = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3 };
+const KIMI_K27_CODE: Cost4 = { input: 0.95, output: 4, cacheRead: 0.19, cacheWrite: 0.95 };
+const KIMI_K27_CODE_HIGHSPEED: Cost4 = { input: 1.9, output: 8, cacheRead: 0.38, cacheWrite: 1.9 };
+const KIMI_K26: Cost4 = { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0.95 };
+const KIMI_K25: Cost4 = { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0.6 };
+
+const GEMINI_PRICING = "https://ai.google.dev/gemini-api/docs/pricing (2026-06-18); cacheWrite=0: storage is billed per-hour, not per-token";
+const MINIMAX_PRICING = "https://platform.minimax.io/docs/guides/pricing-paygo";
+const DEEPSEEK_PRICING = "https://api-docs.deepseek.com/quick_start/pricing-details-usd; V4 Flash alias transition scheduled 2026-07-24 — re-verify after";
+// Kimi official tables publish input/output/cache-hit only; cacheWrite is mapped to the
+// cache-miss input price (Kimi auto-caches with no separate write billing). 2026-07-20 re-verified.
+const KIMI_PRICING = "https://platform.kimi.ai/docs/pricing (official table; cacheWrite derived = input, Kimi auto-cache has no write billing)";
+
+export const EXPECTED_PRICE_OVERLAYS: readonly ExpectedPriceOverlay[] = [
+  // MiniMax M2.1 highspeed — published PAYG price (verified).
+  { provider: "minimax", modelId: "MiniMax-M2.1-highspeed", cost4: MINIMAX_M21_HIGHSPEED, source: MINIMAX_PRICING, verifiedAt: "2026-07-20", status: "verified" },
+  { provider: "minimax-cn", modelId: "MiniMax-M2.1-highspeed", cost4: MINIMAX_M21_HIGHSPEED, source: MINIMAX_PRICING, verifiedAt: "2026-07-20", status: "verified" },
+  // DeepSeek current-generation IDs (verified; cache-hit price mapped to cacheRead).
+  { provider: "deepseek", modelId: "deepseek-chat", cost4: { input: 0.27, output: 1.1, cacheRead: 0.07, cacheWrite: 0 }, source: DEEPSEEK_PRICING, verifiedAt: "2026-07-20", status: "verified" },
+  { provider: "deepseek", modelId: "deepseek-reasoner", cost4: { input: 0.55, output: 2.19, cacheRead: 0.14, cacheWrite: 0 }, source: DEEPSEEK_PRICING, verifiedAt: "2026-07-20", status: "verified" },
+  // Google Antigravity effort-suffix variants — derived from the verified base-model
+  // price (Google does not publish per-suffix prices; Agent inference bills at the
+  // base model's standard rate per the official Billing FAQ).
+  { provider: "google-antigravity", modelId: "gemini-3.1-pro-low", cost4: GEMINI_31_PRO, source: `derived: gemini-3.1-pro (<=200k tier) ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-3.1-pro-high", cost4: GEMINI_31_PRO, source: `derived: gemini-3.1-pro (<=200k tier) ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-3.5-flash-extra-low", cost4: GEMINI_35_FLASH, source: `derived: gemini-3.5-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-3.5-flash-low", cost4: GEMINI_35_FLASH, source: `derived: gemini-3.5-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-3.5-flash-mid", cost4: GEMINI_35_FLASH, source: `derived: gemini-3.5-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-3.5-flash-high", cost4: GEMINI_35_FLASH, source: `derived: gemini-3.5-flash ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gemini-3-flash-agent", cost4: GEMINI_3_FLASH, source: `derived: gemini-3-flash + Agent billing principle ${GEMINI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  // Google Vertex/Gemini API current model (verified — published table).
+  { provider: "google-antigravity", modelId: "gemini-3.1-pro-preview", cost4: GEMINI_31_PRO, source: GEMINI_PRICING, verifiedAt: "2026-07-20", status: "verified" },
+  // Antigravity-bundled third-party models — derived from the underlying vendor's
+  // official API price (Antigravity itself bills via subscription quota).
+  { provider: "google-antigravity", modelId: "claude-sonnet-4-6", cost4: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, source: "derived: anthropic official https://platform.claude.com/docs/en/about-claude/pricing (5m cache-write; 1h is $6)", verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "claude-opus-4-6-thinking", cost4: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }, source: "derived: anthropic official https://platform.claude.com/docs/en/about-claude/pricing (5m cache-write; 1h is $10)", verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "google-antigravity", modelId: "gpt-oss-120b-medium", cost4: { input: 0.03, output: 0.15, cacheRead: 0, cacheWrite: 0 }, source: "derived: gpt-oss-120b open-weights — OpenRouter advertised lowest https://openrouter.ai/openai/gpt-oss-120b/providers", verifiedAt: "2026-07-20", status: "verified-derived" },
+  // Kimi / Moonshot — official price tables are now published (2026-07-20 re-check;
+  // previously empty). kimi = Kimi Code OAuth surface, moonshot = CN key surface,
+  // kimi-code = API key surface (expected list price, not actual billing).
+  { provider: "kimi", modelId: "k3", cost4: KIMI_K3, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi", modelId: "k3[1m]", cost4: KIMI_K3, source: `derived: k3 (official docs: k3[1m] is the 1M-context compat notation for k3) ${KIMI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi", modelId: "kimi-k2.7-code", cost4: KIMI_K27_CODE, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi", modelId: "kimi-k2.7-code-highspeed", cost4: KIMI_K27_CODE_HIGHSPEED, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi", modelId: "kimi-k2.6", cost4: KIMI_K26, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi", modelId: "kimi-k2.5", cost4: KIMI_K25, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi", modelId: "kimi-for-coding", cost4: KIMI_K27_CODE, source: `derived: kimi-k2.7-code (Kimi Code maps to K2.7 Code per official model docs) ${KIMI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "moonshot", modelId: "kimi-k3", cost4: KIMI_K3, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "moonshot", modelId: "kimi-k2.7-code", cost4: KIMI_K27_CODE, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "moonshot", modelId: "kimi-k2.7-code-highspeed", cost4: KIMI_K27_CODE_HIGHSPEED, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "moonshot", modelId: "kimi-k2.6", cost4: KIMI_K26, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "moonshot", modelId: "kimi-k2.5", cost4: KIMI_K25, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "k3", cost4: KIMI_K3, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "k3[1m]", cost4: KIMI_K3, source: `derived: k3 ${KIMI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "kimi-k2.7-code", cost4: KIMI_K27_CODE, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "kimi-k2.7-code-highspeed", cost4: KIMI_K27_CODE_HIGHSPEED, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "kimi-k2.6", cost4: KIMI_K26, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "kimi-k2.5", cost4: KIMI_K25, source: KIMI_PRICING, verifiedAt: "2026-07-20", status: "verified-derived" },
+  { provider: "kimi-code", modelId: "kimi-for-coding", cost4: KIMI_K27_CODE, source: `derived: kimi-k2.7-code ${KIMI_PRICING}`, verifiedAt: "2026-07-20", status: "verified-derived" },
+  // Cursor Auto router — Cursor's published fixed token price (verified).
+  { provider: "cursor", modelId: "auto", cost4: { input: 1.25, output: 6, cacheRead: 0.25, cacheWrite: 1.25 }, source: "https://docs.cursor.com/account/pricing + https://cursor.com/blog/aug-2025-pricing", verifiedAt: "2026-07-20", status: "verified" },
+];
+
+/**
+ * Exact-key overlay lookup. Returns verified first, then verified-derived.
+ * NEVER returns "unverified" rows — fail-closed is enforced in code, not just docs.
+ * No fuzzy / case-fold / wire-model fallback.
+ */
+export function findExpectedPriceOverlay(
+  provider: string,
+  modelId: string,
+  overlays: readonly ExpectedPriceOverlay[] = EXPECTED_PRICE_OVERLAYS,
+): ExpectedPriceOverlay | undefined {
+  const exact = overlays.filter(row => row.provider === provider && row.modelId === modelId);
+  return exact.find(row => row.status === "verified")
+    ?? exact.find(row => row.status === "verified-derived");
+}

package/src/usage/log.ts

@@ -20,6 +20,8 @@ export interface PersistedUsageAttempt {
   adapter: string;
   status: number;
   durationMs: number;
+  /** TTFT relative to THIS attempt's start (WP4); unset for non-streaming/tool-only. */
+  firstOutputMs?: number;
   sendCount: number;
   recoveryKinds: AttemptRecoveryKind[];
   usageStatus: UsageStatus;
@@ -39,6 +41,8 @@ export interface PersistedUsageEntry {
   requestedModel?: string;
   status: number;
   durationMs: number;
+  /** TTFT relative to the request start (WP4); unset for non-streaming/tool-only. */
+  firstOutputMs?: number;
   usageStatus: UsageStatus;
   usage?: OcxUsage;
   totalTokens?: number;
@@ -151,6 +155,8 @@ function normalizeUsageAttempt(raw: unknown): PersistedUsageAttempt | null {
   }
   if ("inputTokenEstimate" in attempt
     && !isNonNegativeFiniteNumber(attempt.inputTokenEstimate)) return null;
+  if ("firstOutputMs" in attempt
+    && !isNonNegativeFiniteNumber(attempt.firstOutputMs)) return null;
   if ("totalTokens" in attempt
     && !isNonNegativeFiniteNumber(attempt.totalTokens)) return null;
   const usage = "usage" in attempt ? normalizeAttemptUsage(attempt.usage) : undefined;
@@ -168,6 +174,9 @@ function normalizeUsageAttempt(raw: unknown): PersistedUsageAttempt | null {
     adapter: attempt.adapter,
     status: attempt.status,
     durationMs: attempt.durationMs,
+    ...(isNonNegativeFiniteNumber(attempt.firstOutputMs)
+      ? { firstOutputMs: attempt.firstOutputMs }
+      : {}),
     sendCount: attempt.sendCount as number,
     recoveryKinds,
     usageStatus: attempt.usageStatus as UsageStatus,
@@ -200,6 +209,9 @@ function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
     ...(entry.requestedModel ? { requestedModel: entry.requestedModel } : {}),
     status: entry.status,
     durationMs: entry.durationMs,
+    ...(isNonNegativeFiniteNumber(entry.firstOutputMs)
+      ? { firstOutputMs: entry.firstOutputMs }
+      : {}),
     usageStatus: entry.usageStatus,
     ...(entry.usage ? { usage: normalizeUsageValue(entry.usage) } : {}),
     ...(typeof entry.totalTokens === "number" ? { totalTokens: entry.totalTokens } : {}),

package/src/usage/summary.ts

@@ -1,6 +1,7 @@
 import { baseProviderLabel } from "../providers/label";
 import { usageDisplayTotalTokens } from "./totals";
 import type { PersistedUsageEntry, UsageStatus } from "./log";
+import { estimateComboCost, estimateRequestCost } from "./cost";
 
 export type UsageRange = "7d" | "30d" | "all";
 export type UsageSurface = "all" | "codex" | "claude";
@@ -21,6 +22,15 @@ export interface UsageSummaryTotals {
   reasoningOutputTokens: number;
   totalTokens: number;
   coverageRatio: number;
+  /** Display-time estimated cost in USD for the filtered window (WP6, devlog 004).
+   *  Sums per-request estimateRequestCost / per-attempt combo costs; requests whose
+   *  price is unmatched are excluded from the sum and counted separately. */
+  estimatedCostUsd: number;
+  pricedRequests: number;
+  /** Requests with usage but no matched price anywhere (excluded from the sum). */
+  unpricedRequests: number;
+  /** Requests whose usage itself is missing/unsupported, so no cost can be computed. */
+  unmeteredRequests: number;
 }
 
 export interface UsageDay {
@@ -127,6 +137,10 @@ function blankTotals(): UsageSummaryTotals {
     reasoningOutputTokens: 0,
     totalTokens: 0,
     coverageRatio: 0,
+    estimatedCostUsd: 0,
+    pricedRequests: 0,
+    unpricedRequests: 0,
+    unmeteredRequests: 0,
   };
 }
 
@@ -215,6 +229,26 @@ function finalizeCoverage(totals: UsageSummaryTotals): void {
   totals.coverageRatio = totals.requests === 0 ? 0 : totals.measuredRequests / totals.requests;
 }
 
+function addEstimatedCost(
+  totals: UsageSummaryTotals,
+  entry: Pick<PersistedUsageEntry, "provider" | "model" | "usageStatus" | "usage" | "attempts">,
+): void {
+  if (entry.usageStatus === "unreported" || entry.usageStatus === "unsupported"
+    || (!entry.usage && !entry.attempts?.length)) {
+    totals.unmeteredRequests += 1;
+    return;
+  }
+  const estimate = entry.attempts?.length
+    ? estimateComboCost(entry.attempts)
+    : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus });
+  if (!estimate) {
+    totals.unpricedRequests += 1;
+    return;
+  }
+  totals.pricedRequests += 1;
+  totals.estimatedCostUsd += estimate.cost.total;
+}
+
 function buildDayGrid(range: UsageRange, since: number | null, now: number, entries: PersistedUsageEntry[]): UsageDay[] {
   const window = rangeWindow(range, now);
   const days = range === "all" ? dayCountForAllRange(entries, now) : window.days;
@@ -385,6 +419,7 @@ export function summarizeUsage(
     bumpStatus(totals, entry.usageStatus);
     totals.attemptCount += entry.attempts?.length ?? 1;
     addTokens(totals, entry);
+    addEstimatedCost(totals, entry);
   }
   finalizeCoverage(totals);
   return {

package/src/web-search/index.ts

@@ -3,6 +3,7 @@ import { modelInList } from "../types";
 import type { SidecarSettings } from "./executor";
 import type { ResolvedOpenAiForwardSidecar } from "../providers/openai-sidecar";
 import { getAccountSet } from "../oauth/store";
+import { DEFAULT_STALL_TIMEOUT_SEC } from "../stall-timeout";
 
 export { runWithWebSearch } from "./loop";
 export { buildWebSearchTool, extractHostedWebSearch, WEB_SEARCH_TOOL_NAME } from "./synthetic-tool";
@@ -18,8 +19,6 @@ const DEFAULT_MAX_SEARCHES = 3;
 const DEFAULT_TIMEOUT_MS = 200_000;
 const DEFAULT_ROUTED_MODEL_STALL_TIMEOUT_MS = 200_000;
 const MAX_ROUTED_MODEL_STALL_TIMEOUT_MS = 2_147_483_647;
-// Mirrors the bridge's stall default (bridge.ts `options?.stallTimeoutSec ?? 90`).
-const DEFAULT_STALL_TIMEOUT_SEC = 90;
 const STALL_MARGIN_SEC = 30;
 
 /**
@@ -47,7 +46,7 @@ function finiteCeil(value: number | undefined, fallback: number): number {
  * are individually bounded by the configured bridge stall, response-header connect timeout,
  * routed-model response-body inactivity timeout, or sidecar timeout. The stall deadline must cover
  * the largest unit plus a margin;
- * otherwise a legitimately slow search trips the bridge's 90s default upstream_stall_timeout and
+ * otherwise a legitimately slow search trips the bridge's default upstream_stall_timeout and
  * kills the whole turn. Stays finite so a genuine hang is still cut off.
  */
 export function webSearchStallTimeoutSec(

package/src/web-search/loop.ts

@@ -186,6 +186,8 @@ export interface WebSearchLoopDeps {
    * sidecar search, so a legitimately slow-but-progressing unit never trips the bridge watchdog.
    */
   stallTimeoutSec?: number;
+  /** One-shot TTFT callback: first non-empty model output observed (WP4). */
+  onFirstOutput?: () => void;
   /**
    * 429 key-failover hook: rotate the provider's active pool key and return a rebuilt adapter,
    * or null when the pool is exhausted (same semantics as the normal routed path).
@@ -550,6 +552,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       ...(deps.forceEmptyResponseId ? { responseId: "" } : {}),
       hideThinkingSummary: parsed.options.hideThinkingSummary,
       ...(deps.stallTimeoutSec !== undefined ? { stallTimeoutSec: deps.stallTimeoutSec } : {}),
+      ...(deps.onFirstOutput ? { onFirstOutput: deps.onFirstOutput } : {}),
     },
   );
   return new Response(sse, { headers: SSE_HEADERS });