codex-multi-auth 2.17.0 → 2.17.3

package/dist/lib/quota-cache.js

@@ -1,9 +1,11 @@
-import { existsSync, promises as fs } from "node:fs";
+import { promises as fs } from "node:fs";
 import { basename, join } from "node:path";
 import { withRetry } from "./fs-retry.js";
 import { logWarn } from "./logger.js";
 import { getCodexMultiAuthDir } from "./runtime-paths.js";
 import { tempPathFor } from "./temp-path.js";
+import { withFileTransactionLock } from "./storage/file-lock.js";
+import { assertJsonStoreFileMtimeUnchanged, getJsonStoreFileMtimeMs, withJsonStoreCasRetry, } from "./storage/json-store-lock.js";
 import { isRecord } from "./utils.js";
 const QUOTA_CACHE_PATH = join(getCodexMultiAuthDir(), "quota-cache.json");
 const QUOTA_CACHE_LABEL = basename(QUOTA_CACHE_PATH);
@@ -127,29 +129,71 @@ export function getQuotaCachePath() {
  *          will be empty if the on-disk file is absent, malformed, or could not be read.
  */
 export async function loadQuotaCache() {
-    if (!existsSync(QUOTA_CACHE_PATH)) {
-        return { byAccountId: {}, byEmail: {} };
-    }
     try {
-        const content = await readCacheFileWithRetry(QUOTA_CACHE_PATH);
-        const parsed = JSON.parse(content);
-        if (!isRecord(parsed)) {
-            return { byAccountId: {}, byEmail: {} };
-        }
-        if (parsed.version !== 1) {
-            logWarn(`Quota cache rejected due to version mismatch: ${String(parsed.version)}`);
-            return { byAccountId: {}, byEmail: {} };
-        }
-        return {
-            byAccountId: normalizeEntryMap(parsed.byAccountId),
-            byEmail: normalizeEntryMap(parsed.byEmail),
-        };
+        return await readQuotaCache();
     }
     catch (error) {
         logWarn(`Failed to load quota cache from ${QUOTA_CACHE_LABEL}: ${error instanceof Error ? error.message : String(error)}`);
         return { byAccountId: {}, byEmail: {} };
     }
 }
+/** Only a missing file is empty for writers; read failures must never erase concurrent data. */
+async function readQuotaCache() {
+    let content;
+    try {
+        content = await readCacheFileWithRetry(QUOTA_CACHE_PATH);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { byAccountId: {}, byEmail: {} };
+        throw error;
+    }
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed) || parsed.version !== 1) {
+        throw Error("Quota cache rejected due to version mismatch or invalid payload");
+    }
+    return {
+        byAccountId: normalizeEntryMap(parsed.byAccountId),
+        byEmail: normalizeEntryMap(parsed.byEmail),
+        ...(parsed.byWorkspace ? { byWorkspace: normalizeEntryMap(parsed.byWorkspace) } : {}),
+    };
+}
+/** Reapply this run's changed entries, preserving unrelated or newer concurrent observations. */
+function mergeQuotaChanges(current, proposed, baseline) {
+    const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    for (const namespace of ["byAccountId", "byEmail", "byWorkspace"]) {
+        const before = baseline[namespace] ?? {}, next = proposed[namespace] ?? {};
+        for (const key of new Set([...Object.keys(before), ...Object.keys(next)])) {
+            if (same(before[key], next[key]))
+                continue;
+            const latest = current[namespace]?.[key], update = next[key];
+            if (update) {
+                if (!latest || update.updatedAt >= latest.updatedAt) {
+                    current[namespace] ??= {};
+                    current[namespace][key] = update;
+                }
+                else if (same(latest, before[key])) {
+                    // The on-disk entry is still exactly the one this caller's
+                    // baseline saw, so nothing concurrent touched this key:
+                    // `update` is a deliberate write whose lower stamp can only
+                    // come from a backward clock jump on this writer. Re-stamp
+                    // it just ahead instead of silently losing it. A raced key
+                    // (`!same`) falls through and keeps the on-disk entry: its
+                    // higher stamp marks a newer observation, and bumping an
+                    // older one past it would let stale quota data overwrite
+                    // fresher data.
+                    update.updatedAt = latest.updatedAt + 1;
+                    current[namespace] ??= {};
+                    current[namespace][key] = update;
+                }
+            }
+            else if (same(latest, before[key])) {
+                delete current[namespace]?.[key];
+            }
+        }
+    }
+    return current;
+}
 /**
  * Persist the quota cache to the on-disk JSON file used by the multi-auth runtime.
  *
@@ -157,8 +201,9 @@ export async function loadQuotaCache() {
  * quota cache path. Failures are logged and do not throw, so callers should handle
  * eventual consistency or retry as needed.
  *
- * Concurrency: concurrent writers may race and overwrite each other; callers should
- * serialize writes if strong consistency is required.
+ * Concurrency: reload, apply changes since `baseline`, and atomically write under
+ * a cross-process lock. Pass the pre-edit snapshot for read–modify–write callers.
+ * Without a baseline, supplied entries are upserts; omitted entries are retained.
  *
  * Filesystem notes: Windows path length, permissions, or antivirus locks may cause
  * write failures; such errors are logged rather than thrown.
@@ -168,54 +213,65 @@ export async function loadQuotaCache() {
  *
  * @param data - The quota cache data (byAccountId and byEmail maps) to persist; callers
  *               should pass normalized QuotaCacheData.
+ * @param baseline - The unmodified pre-edit snapshot; only changes since it are applied.
  */
-export async function saveQuotaCache(data) {
-    const payload = {
-        version: 1,
-        byAccountId: data.byAccountId,
-        byEmail: data.byEmail,
-    };
+export async function saveQuotaCache(data, baseline = { byAccountId: {}, byEmail: {} }) {
+    // Snapshot at invocation, not after waiting behind other writers.
+    const proposed = structuredClone(data), before = structuredClone(baseline);
     const writeTask = async () => {
         try {
-            const cacheDir = getCodexMultiAuthDir();
-            // The quota cache lives alongside other at-rest secrets, so keep the
-            // directory owner-only on POSIX (mode is a no-op on win32 / ACL-based).
-            await fs.mkdir(cacheDir, { recursive: true, mode: 0o700 });
-            // mkdir's mode only applies to a freshly-created dir; an upgrade with a
-            // pre-existing multi-auth dir keeps its old (possibly world-listable)
-            // perms, so re-assert 0o700 on POSIX. Best-effort: a chmod failure must
-            // not break the cache write (the 0o600 file below still protects data).
-            if (process.platform !== "win32") {
-                try {
-                    await fs.chmod(cacheDir, 0o700);
-                }
-                catch {
-                    // Best-effort hardening only.
-                }
-            }
-            const tempPath = tempPathFor(QUOTA_CACHE_PATH);
-            await fs.writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, {
-                encoding: "utf8",
-                mode: 0o600,
-            });
-            let renamed = false;
-            try {
-                await withRetry(() => fs.rename(tempPath, QUOTA_CACHE_PATH), {
-                    maxAttempts: 5,
-                    backoffMs: (attempt) => 10 * 2 ** (attempt - 1),
-                });
-                renamed = true;
-            }
-            finally {
-                if (!renamed) {
+            // The transaction lock gives the read-merge-write cross-process mutual
+            // exclusion; the mtime CAS retry inside it is the second-line guard for
+            // writers that do not take the lock: every attempt re-stats, re-reads
+            // the freshest on-disk cache, and re-merges this call's diff onto it
+            // (matching the config save's reload-and-retry ESTALE semantics).
+            await withFileTransactionLock(QUOTA_CACHE_PATH, async () => {
+                await withJsonStoreCasRetry(async () => {
+                    const expectedMtimeMs = await getJsonStoreFileMtimeMs(QUOTA_CACHE_PATH);
+                    const merged = mergeQuotaChanges(await readQuotaCache(), proposed, before);
+                    const payload = { version: 1, ...merged };
+                    const cacheDir = getCodexMultiAuthDir();
+                    // The quota cache lives alongside other at-rest secrets, so keep the
+                    // directory owner-only on POSIX (mode is a no-op on win32 / ACL-based).
+                    await fs.mkdir(cacheDir, { recursive: true, mode: 0o700 });
+                    // mkdir's mode only applies to a freshly-created dir; an upgrade with a
+                    // pre-existing multi-auth dir keeps its old (possibly world-listable)
+                    // perms, so re-assert 0o700 on POSIX. Best-effort: a chmod failure must
+                    // not break the cache write (the 0o600 file below still protects data).
+                    if (process.platform !== "win32") {
+                        try {
+                            await fs.chmod(cacheDir, 0o700);
+                        }
+                        catch {
+                            // Best-effort hardening only.
+                        }
+                    }
+                    const tempPath = tempPathFor(QUOTA_CACHE_PATH);
+                    await fs.writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, {
+                        encoding: "utf8",
+                        mode: 0o600,
+                    });
+                    let renamed = false;
                     try {
-                        await fs.unlink(tempPath);
+                        await assertJsonStoreFileMtimeUnchanged(QUOTA_CACHE_PATH, expectedMtimeMs);
+                        await withRetry(() => fs.rename(tempPath, QUOTA_CACHE_PATH), {
+                            maxAttempts: 5,
+                            backoffMs: (attempt) => 10 * 2 ** (attempt - 1),
+                        });
+                        renamed = true;
                     }
-                    catch {
-                        // Best effort temp cleanup.
+                    finally {
+                        if (!renamed) {
+                            try {
+                                await fs.unlink(tempPath);
+                            }
+                            catch {
+                                // Best effort temp cleanup.
+                            }
+                        }
                     }
-                }
-            }
+                });
+            });
         }
         catch (error) {
             logWarn(`Failed to save quota cache to ${QUOTA_CACHE_LABEL}: ${error instanceof Error ? error.message : String(error)}`);

package/dist/lib/quota-probe.d.ts

@@ -85,4 +85,3 @@ export interface ProbeCodexQuotaOptions {
  * @throws If no candidate model produces a quota snapshot, throws the last encountered error or a generic failure error.
  */
 export declare function fetchCodexQuotaSnapshot(options: ProbeCodexQuotaOptions): Promise<CodexQuotaSnapshot>;
-//# sourceMappingURL=quota-probe.d.ts.map

package/dist/lib/quota-probe.js

@@ -4,7 +4,7 @@ import { QUOTA_PROBE_MODEL_CHAIN, resolveProbeReasoningEffort, } from "./request
 import { CodexUnavailableError, isCodexUnavailableError } from "./errors.js";
 import { getCodexInstructions } from "./prompts/codex.js";
 import { mutateRuntimeObservabilitySnapshot } from "./runtime/runtime-observability.js";
-import { isRecord } from "./utils.js";
+import { combineSignals, isRecord } from "./utils.js";
 import { FirstUseProbeError, finishSubscriptionFirstUse, needsSubscriptionFirstUse } from "./runtime/subscription-first-use.js";
 /**
  * Human-readable note shown when a live probe fails solely because the account
@@ -371,7 +371,10 @@ export async function fetchCodexQuotaSnapshot(options) {
                     method: "POST",
                     headers,
                     body: JSON.stringify(probeBody),
-                    signal: options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal,
+                    // combineSignals wraps AbortSignal.any with null-tolerance:
+                    // the composite detaches from a long-lived caller signal once
+                    // this probe completes, instead of pinning a listener on it.
+                    signal: options.signal ? combineSignals(controller.signal, options.signal) : controller.signal,
                 });
             }
             finally {

package/dist/lib/quota-readiness.d.ts

@@ -1,6 +1,6 @@
 import type { QuotaCacheData, QuotaCacheEntry } from "./quota-cache.js";
 import type { AccountMetadataV3 } from "./storage.js";
-export type QuotaCacheAccountRef = Pick<AccountMetadataV3, "accountId" | "email">;
+export type QuotaCacheAccountRef = Pick<AccountMetadataV3, "accountId" | "email" | "recordId" | "workspaces" | "currentWorkspaceIndex"> & Partial<Pick<AccountMetadataV3, "refreshToken" | "addedAt">>;
 export declare function normalizeQuotaAccountId(value: string | undefined): string | null;
 export declare function normalizeQuotaEmail(value: string | undefined): string | null;
 export declare function hasUniqueQuotaAccountId(accounts: readonly QuotaCacheAccountRef[], account: QuotaCacheAccountRef): boolean;
@@ -15,5 +15,9 @@ export declare function quotaUsedPercentIsExhausted(usedPercent: number | undefi
 export declare function isQuotaCacheEntryExhausted(entry: Pick<QuotaCacheEntry, "primary" | "secondary"> & {
     updatedAt?: number;
 } | null | undefined, now?: number): boolean;
-export declare function findQuotaCacheEntryForAccount(cache: QuotaCacheData | null | undefined, account: QuotaCacheAccountRef, accounts: readonly QuotaCacheAccountRef[], emailFallbackState?: ReadonlyMap<string, QuotaEmailFallbackState>): QuotaCacheEntry | null;
-//# sourceMappingURL=quota-readiness.d.ts.map
+/** Cache identity includes the credential record, so shared organization IDs cannot collide. */
+export declare function quotaWorkspaceKey(account: QuotaCacheAccountRef, workspaceId: string): string | undefined;
+/** Display the selected workspace; callers routing another scope must pass that exact workspace. */
+export declare function quotaWorkspaceId(account: QuotaCacheAccountRef): string | undefined;
+/** Read exact-workspace quota, using legacy binding entries only for that binding. */
+export declare function findQuotaCacheEntryForAccount(cache: QuotaCacheData | null | undefined, account: QuotaCacheAccountRef, accounts: readonly QuotaCacheAccountRef[], emailFallbackState?: ReadonlyMap<string, QuotaEmailFallbackState>, workspaceId?: string | undefined): QuotaCacheEntry | null;

package/dist/lib/quota-readiness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quota-readiness.d.ts","sourceRoot":"","sources":["../../lib/quota-readiness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAoB,MAAM,kBAAkB,CAAC;AAC1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC;AAIlF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAGhF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAG5E;AAED,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,OAAO,EAAE,oBAAoB,GAC3B,OAAO,CAQT;AAED,MAAM,MAAM,uBAAuB,GAAG;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,SAAS,oBAAoB,EAAE,GACvC,WAAW,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAiB9C;AAED,wBAAgB,yBAAyB,CACxC,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAChE,OAAO,EAAE,oBAAoB,GAC3B,OAAO,CAMT;AAED,wBAAgB,wBAAwB,CACvC,WAAW,EAAE,MAAM,GAAG,SAAS,GAC7B,MAAM,GAAG,SAAS,CAKpB;AAQD,wBAAgB,2BAA2B,CAC1C,WAAW,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAMT;AA2BD,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,WAAW,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACjG,GAAG,SAAa,GACd,OAAO,CAQT;AAED,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACxC,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,kBAAkB,+CAAyC,GACzD,eAAe,GAAG,IAAI,CAWxB"}
+{"version":3,"file":"quota-readiness.d.ts","sourceRoot":"","sources":["../../lib/quota-readiness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAoB,MAAM,kBAAkB,CAAC;AAC1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,YAAY,GAAG,uBAAuB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAAC,CAAC,CAAC;AAIvM,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAGhF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAG5E;AAED,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,OAAO,EAAE,oBAAoB,GAC3B,OAAO,CAQT;AAED,MAAM,MAAM,uBAAuB,GAAG;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,SAAS,oBAAoB,EAAE,GACvC,WAAW,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAiB9C;AAED,wBAAgB,yBAAyB,CACxC,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAChE,OAAO,EAAE,oBAAoB,GAC3B,OAAO,CAMT;AAED,wBAAgB,wBAAwB,CACvC,WAAW,EAAE,MAAM,GAAG,SAAS,GAC7B,MAAM,GAAG,SAAS,CAKpB;AAQD,wBAAgB,2BAA2B,CAC1C,WAAW,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAMT;AA2BD,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,WAAW,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACjG,GAAG,SAAa,GACd,OAAO,CAQT;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIxG;AAED,oGAAoG;AACpG,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS,CAIlF;AAED,sFAAsF;AACtF,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACxC,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,SAAS,oBAAoB,EAAE,EACzC,kBAAkB,+CAAyC,EAC3D,WAAW,qBAA4B,GACrC,eAAe,GAAG,IAAI,CAgBxB"}

package/dist/lib/quota-readiness.js

@@ -1,3 +1,5 @@
+import { createHash } from "node:crypto";
+import { resolveAccountRecordId } from "./storage/record-identity.js";
 export function normalizeQuotaAccountId(value) {
     const trimmed = value?.trim();
     return trimmed && trimmed.length > 0 ? trimmed : null;
@@ -89,16 +91,35 @@ export function isQuotaCacheEntryExhausted(entry, now = Date.now()) {
     return (quotaWindowIsExhausted(entry?.primary, now, updatedAt) ||
         quotaWindowIsExhausted(entry?.secondary, now, updatedAt));
 }
-export function findQuotaCacheEntryForAccount(cache, account, accounts, emailFallbackState = buildQuotaEmailFallbackState(accounts)) {
+/** Cache identity includes the credential record, so shared organization IDs cannot collide. */
+export function quotaWorkspaceKey(account, workspaceId) {
+    const recordId = account.recordId?.trim() || (account.refreshToken !== undefined && account.addedAt !== undefined
+        ? resolveAccountRecordId({ ...account, refreshToken: account.refreshToken, addedAt: account.addedAt }) : undefined);
+    return recordId ? createHash("sha256").update(JSON.stringify(["oauth", recordId, workspaceId.trim()])).digest("hex") : undefined;
+}
+/** Display the selected workspace; callers routing another scope must pass that exact workspace. */
+export function quotaWorkspaceId(account) {
+    return account.workspaces?.length
+        ? account.workspaces[account.currentWorkspaceIndex ?? 0]?.id.trim()
+        : account.accountId?.trim();
+}
+/** Read exact-workspace quota, using legacy binding entries only for that binding. */
+export function findQuotaCacheEntryForAccount(cache, account, accounts, emailFallbackState = buildQuotaEmailFallbackState(accounts), workspaceId = quotaWorkspaceId(account)) {
     if (!cache)
         return null;
+    const key = workspaceId && quotaWorkspaceKey(account, workspaceId);
+    const scoped = key ? cache.byWorkspace?.[key] : undefined;
+    // Legacy entries describe only the stored binding, never a sibling workspace.
+    if (normalizeQuotaAccountId(workspaceId) !== normalizeQuotaAccountId(account.accountId))
+        return scoped ?? null;
     const accountId = normalizeQuotaAccountId(account.accountId);
+    const newer = (legacy) => scoped && (!legacy || scoped.updatedAt >= legacy.updatedAt) ? scoped : legacy ?? null;
     if (accountId && hasUniqueQuotaAccountId(accounts, account) && cache.byAccountId[accountId]) {
-        return cache.byAccountId[accountId] ?? null;
+        return newer(cache.byAccountId[accountId]);
     }
     const email = normalizeQuotaEmail(account.email);
     if (email && hasSafeQuotaEmailFallback(emailFallbackState, account) && cache.byEmail[email]) {
-        return cache.byEmail[email] ?? null;
+        return newer(cache.byEmail[email]);
     }
-    return null;
+    return scoped ?? null;
 }

package/dist/lib/recovery/constants.d.ts

@@ -9,4 +9,3 @@ export declare const PART_STORAGE: string;
 export declare const THINKING_TYPES: Set<string>;
 export declare const META_TYPES: Set<string>;
 export declare const CONTENT_TYPES: Set<string>;
-//# sourceMappingURL=constants.d.ts.map

package/dist/lib/recovery/storage.d.ts

@@ -41,4 +41,3 @@ export declare function findEmptyMessageByIndex(sessionID: string, targetIndex:
 export declare function findMessageByIndexNeedingThinking(sessionID: string, targetIndex: number): string | null;
 export declare function replaceEmptyTextParts(messageID: string, replacementText: string): boolean;
 export declare function findMessagesWithEmptyTextParts(sessionID: string): string[];
-//# sourceMappingURL=storage.d.ts.map

package/dist/lib/recovery/types.d.ts

@@ -105,4 +105,3 @@ export interface ToolResultPart {
     content: string;
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/lib/recovery.d.ts

@@ -28,4 +28,3 @@ export interface SessionRecoveryContext {
     directory: string;
 }
 export declare function createSessionRecoveryHook(ctx: SessionRecoveryContext, config: PluginConfig): SessionRecoveryHook | null;
-//# sourceMappingURL=recovery.d.ts.map

package/dist/lib/redaction.d.ts

@@ -14,4 +14,3 @@
 export declare function maskEmail(value: string): string;
 /** Mask every address embedded in a free-text string. */
 export declare function redactEmails(value: string): string;
-//# sourceMappingURL=redaction.d.ts.map

package/dist/lib/refresh-guardian.d.ts

@@ -31,4 +31,3 @@ export declare class RefreshGuardian {
     private applyRefreshOutcome;
     tick(): Promise<void>;
 }
-//# sourceMappingURL=refresh-guardian.d.ts.map

package/dist/lib/refresh-lease.d.ts

@@ -47,4 +47,3 @@ export declare class RefreshLeaseCoordinator {
     private pruneExpiredArtifacts;
 }
 export {};
-//# sourceMappingURL=refresh-lease.d.ts.map

package/dist/lib/refresh-queue.d.ts

@@ -113,4 +113,3 @@ export declare function resetRefreshQueue(): void;
  * @returns Token result
  */
 export declare function queuedRefresh(refreshToken: string): Promise<TokenResult>;
-//# sourceMappingURL=refresh-queue.d.ts.map

package/dist/lib/request/client-cancellation.d.ts

@@ -2,4 +2,3 @@
 export declare class ClientCancellationError extends Error {
     constructor();
 }
-//# sourceMappingURL=client-cancellation.d.ts.map

package/dist/lib/request/error-classification.d.ts

@@ -79,4 +79,3 @@ export declare function isWorkspaceDisabledError(status: number, code: unknown,
  * @returns A 403 Response with a JSON body describing the entitlement error and guidance for resolving it
  */
 export declare function createEntitlementErrorResponse(_bodyText: string): Response;
-//# sourceMappingURL=error-classification.d.ts.map

package/dist/lib/request/failover-config.d.ts

@@ -1,4 +1,3 @@
 import type { FailoverMode } from "./failure-policy.js";
 export declare function parseFailoverMode(value: string | undefined): FailoverMode;
 export declare function parseEnvInt(value: string | undefined): number | undefined;
-//# sourceMappingURL=failover-config.d.ts.map

package/dist/lib/request/failure-policy.d.ts

@@ -39,4 +39,3 @@ export declare function evaluateFailurePolicy(input: FailurePolicyInput, overrid
     networkCooldownMs?: number;
     serverCooldownMs?: number;
 }): FailurePolicyDecision;
-//# sourceMappingURL=failure-policy.d.ts.map

package/dist/lib/request/fetch-helpers.d.ts

@@ -79,4 +79,3 @@ export declare function handleSuccessResponse(response: Response, isStreaming: b
     onUsage?: (usage: UsageTokenCounts) => void;
     streamStallTimeoutMs?: number;
 }): Promise<Response>;
-//# sourceMappingURL=fetch-helpers.d.ts.map

package/dist/lib/request/headers.d.ts

@@ -30,4 +30,3 @@ export declare function createCodexHeaders(init: RequestInit | undefined, accoun
  * @internal Exported only for sibling lib/request modules; import via fetch-helpers.ts elsewhere.
  */
 export declare function logDeprecationHeaders(response: Response): void;
-//# sourceMappingURL=headers.d.ts.map

package/dist/lib/request/helpers/input-utils.d.ts

@@ -4,4 +4,3 @@ export declare function isHostSystemPrompt(item: InputItem, cachedPrompt: string
 export declare function filterHostSystemPromptsWithCachedPrompt(input: InputItem[] | undefined, cachedPrompt: string | null): InputItem[] | undefined;
 export declare const normalizeOrphanedToolOutputs: (input: InputItem[]) => InputItem[];
 export declare const injectMissingToolOutputs: (input: InputItem[]) => InputItem[];
-//# sourceMappingURL=input-utils.d.ts.map

package/dist/lib/request/helpers/input-utils.js

@@ -49,47 +49,78 @@ const extractHostContext = (contentText) => {
         return null;
     return contentText.slice(earliestIndex).trimStart();
 };
-export function isHostSystemPrompt(item, cachedPrompt) {
-    const isSystemRole = item.role === "developer" || item.role === "system";
-    if (!isSystemRole)
-        return false;
-    const contentText = getContentText(item);
+/**
+ * Normalizes the cached host prompt once per filter pass so the per-item
+ * checks do not re-trim/re-slice the same string.
+ */
+const prepareCachedPrompt = (cachedPrompt) => {
+    if (!cachedPrompt)
+        return null;
+    const trimmed = cachedPrompt.trim();
+    return { trimmed, prefix: trimmed.substring(0, 200) };
+};
+const isHostPromptContent = (contentText, cached) => {
     if (!contentText)
         return false;
-    if (cachedPrompt) {
+    if (cached) {
         const contentTrimmed = contentText.trim();
-        const cachedTrimmed = cachedPrompt.trim();
-        if (contentTrimmed === cachedTrimmed) {
+        if (contentTrimmed === cached.trimmed) {
             return true;
         }
-        if (contentTrimmed.startsWith(cachedTrimmed)) {
+        if (contentTrimmed.startsWith(cached.trimmed)) {
             return true;
         }
         const contentPrefix = contentTrimmed.substring(0, 200);
-        const cachedPrefix = cachedTrimmed.substring(0, 200);
-        if (contentPrefix === cachedPrefix) {
+        if (contentPrefix === cached.prefix) {
             return true;
         }
     }
     const normalized = contentText.trimStart().toLowerCase();
     return HOST_PROMPT_SIGNATURES.some((signature) => normalized.startsWith(signature));
+};
+export function isHostSystemPrompt(item, cachedPrompt) {
+    const isSystemRole = item.role === "developer" || item.role === "system";
+    if (!isSystemRole)
+        return false;
+    return isHostPromptContent(getContentText(item), prepareCachedPrompt(cachedPrompt));
 }
 export function filterHostSystemPromptsWithCachedPrompt(input, cachedPrompt) {
     if (!Array.isArray(input))
         return input;
-    return input.flatMap((item) => {
-        if (item.role === "user")
-            return [item];
-        if (!isHostSystemPrompt(item, cachedPrompt)) {
-            return [item];
+    const cached = prepareCachedPrompt(cachedPrompt);
+    // Copy-on-write: most items pass through untouched, so the result array is
+    // only materialized once an item is actually dropped or rewritten.
+    let filtered = null;
+    for (let i = 0; i < input.length; i++) {
+        // flatMap skips sparse holes entirely; an explicit `undefined` element
+        // still reaches the callback and throws on `.role` — mirrored below.
+        if (!(i in input)) {
+            if (filtered === null)
+                filtered = input.slice(0, i);
+            continue;
+        }
+        const item = input[i];
+        const isSystemRole = item.role === "developer" || item.role === "system";
+        if (!isSystemRole) {
+            if (filtered !== null)
+                filtered.push(item);
+            continue;
         }
         const contentText = getContentText(item);
+        if (!isHostPromptContent(contentText, cached)) {
+            if (filtered !== null)
+                filtered.push(item);
+            continue;
+        }
         const preservedContext = extractHostContext(contentText);
+        if (filtered === null) {
+            filtered = input.slice(0, i);
+        }
         if (preservedContext) {
-            return [replaceContentText(item, preservedContext)];
+            filtered.push(replaceContentText(item, preservedContext));
         }
-        return [];
-    });
+    }
+    return filtered ?? input;
 }
 const getCallId = (item) => {
     const rawCallId = item.call_id;
@@ -103,13 +134,16 @@ const convertOrphanedOutputToMessage = (item, callId) => {
         ? item.name
         : "tool";
     const labelCallId = callId ?? "unknown";
+    // Read `.output` once: the catch fallback must use the same value —
+    // re-reading a throwing getter inside the catch would just re-throw.
+    const out = item.output;
     let text;
     try {
-        const out = item.output;
-        text = typeof out === "string" ? out : JSON.stringify(out);
+        text =
+            typeof out === "string" ? out : (JSON.stringify(out) ?? "");
     }
     catch {
-        text = String(item.output ?? "");
+        text = String(out ?? "");
     }
     if (text.length > 16000) {
         text = text.slice(0, 16000) + "\n...[truncated]";
@@ -146,31 +180,43 @@ const collectCallIds = (input) => {
 };
 export const normalizeOrphanedToolOutputs = (input) => {
     const { functionCallIds, localShellCallIds, customToolCallIds } = collectCallIds(input);
-    return input.map((item) => {
+    // Copy-on-write: items pass through by reference until an output actually
+    // needs converting; an unchanged input returns the original array instead
+    // of a per-item `map` copy.
+    let mapped = null;
+    for (let i = 0; i < input.length; i++) {
+        const item = input[i];
+        let converted = item;
         if (item.type === "function_call_output") {
             const callId = getCallId(item);
             const hasMatch = !!callId &&
                 (functionCallIds.has(callId) || localShellCallIds.has(callId));
             if (!hasMatch) {
-                return convertOrphanedOutputToMessage(item, callId);
+                converted = convertOrphanedOutputToMessage(item, callId);
             }
         }
-        if (item.type === "custom_tool_call_output") {
+        else if (item.type === "custom_tool_call_output") {
             const callId = getCallId(item);
             const hasMatch = !!callId && customToolCallIds.has(callId);
             if (!hasMatch) {
-                return convertOrphanedOutputToMessage(item, callId);
+                converted = convertOrphanedOutputToMessage(item, callId);
             }
         }
-        if (item.type === "local_shell_call_output") {
+        else if (item.type === "local_shell_call_output") {
             const callId = getCallId(item);
             const hasMatch = !!callId && localShellCallIds.has(callId);
             if (!hasMatch) {
-                return convertOrphanedOutputToMessage(item, callId);
+                converted = convertOrphanedOutputToMessage(item, callId);
             }
         }
-        return item;
-    });
+        if (converted !== item && mapped === null) {
+            mapped = input.slice(0, i);
+        }
+        if (mapped !== null) {
+            mapped.push(converted);
+        }
+    }
+    return mapped ?? input;
 };
 const CANCELLED_TOOL_OUTPUT = "Operation cancelled by user";
 const collectOutputCallIds = (input) => {
@@ -188,9 +234,14 @@ const collectOutputCallIds = (input) => {
 };
 export const injectMissingToolOutputs = (input) => {
     const outputCallIds = collectOutputCallIds(input);
-    const result = [];
-    for (const item of input) {
-        result.push(item);
+    // Copy-on-write: items pass through by reference; the result array is only
+    // materialized when a synthetic output is actually injected.
+    let result = null;
+    for (let i = 0; i < input.length; i++) {
+        const item = input[i];
+        if (result !== null) {
+            result.push(item);
+        }
         if (item.type === "function_call" ||
             item.type === "local_shell_call" ||
             item.type === "custom_tool_call") {
@@ -201,6 +252,9 @@ export const injectMissingToolOutputs = (input) => {
                     : item.type === "local_shell_call"
                         ? "local_shell_call_output"
                         : "custom_tool_call_output";
+                if (result === null) {
+                    result = input.slice(0, i + 1);
+                }
                 result.push({
                     type: outputType,
                     call_id: callId,
@@ -209,5 +263,5 @@ export const injectMissingToolOutputs = (input) => {
             }
         }
     }
-    return result;
+    return result ?? input;
 };

package/dist/lib/request/helpers/model-map.d.ts

@@ -99,4 +99,3 @@ export declare function resolveProbeReasoningEffort(model: string | undefined):
  * `resolveNormalizedModel()` if you want the fallback behavior.
  */
 export declare function isKnownModel(modelId: string): boolean;
-//# sourceMappingURL=model-map.d.ts.map