@zergai/ztc 0.2.6-dev.36101352252 → 0.2.7-dev.36236183737

package/dist/ui/widgets/status_line_panel.js

@@ -14,12 +14,11 @@
  * reordering hard to land, so the pickup is explicit and you can see the row
  * travel.
  */
-import { box, text } from '../core/index.js';
 import { displayWidth, padEndDisplay } from '../core/text_width.js';
 import { TERMINAL_THEME } from '../views/theme.js';
 import { fuzzyMatch } from '../../utils/fuzzy_match.js';
 import { cycleStatusLineVariant, resolveStatusLineVariants, statusLineItemGroups, statusLineItemOptions, STATUS_LINE_VARIANT_LABELS, } from '../status_line_config.js';
-import { bodyBand, bottomBorder, clipText, dropLastGrapheme, fitSegments, framedLine, isInsideBand, joinColumns, lineText, planPanelSplit, sideBySideBands, stackedBands, topBorder, } from './panel_frame.js';
+import { bodyBand, bottomBorder, clipText, dropLastGrapheme, fitSegments, framedLine, isInsideBand, joinColumns, lineText, planPanelSplit, sideBySideBands, stackedBands, topBorder, buildWidgetFrameView, widgetFrameGeometry, } from './panel_frame.js';
 /** The order pane is the point of this page, so it keeps a workable width. */
 const ORDER_PANE_MIN_WIDTH = 34;
 /** Below this the panes stack instead of splitting. */
@@ -34,6 +33,15 @@ function sideLabel(side) {
 export class StatusLinePanelWidget {
     host;
     active = null;
+    /**
+     * Column the painted frame starts on, in surface coordinates.
+     *
+     * Zero unless the terminal is wide enough to trigger the shared cap, in which
+     * case it is that centring margin. The wheel bands add it back: a notch lands
+     * in terminal columns, so without it a capped page would scroll from a pane
+     * that is no longer under the pointer.
+     */
+    frameInset = 0;
     draft = {
         left: [],
         right: [],
@@ -620,17 +628,7 @@ export class StatusLinePanelWidget {
         const lines = this.buildSurfaceLines(cols, maxRows);
         return {
             content: lines.map(lineText).join('\n'),
-            view: box(lines.map(line => box(line.segments.map(segment => text(segment.text, segment.style)), {
-                flexDirection: 'row',
-                height: 1,
-                flexShrink: 0,
-                backgroundColor: line.backgroundColor,
-            })), {
-                flexDirection: 'column',
-                height: lines.length,
-                flexShrink: 0,
-                backgroundColor: TERMINAL_THEME.bg,
-            }),
+            view: buildWidgetFrameView(lines, this.frameInset),
             lineCount: lines.length,
         };
     }
@@ -643,9 +641,10 @@ export class StatusLinePanelWidget {
         if (maxRows !== undefined && maxRows <= 0)
             return [];
         const termCols = Math.max(1, Math.floor(cols || process.stdout.columns || 80));
-        // The host embeds the surface in a `paddingX: 1` column, so `cols - 2` is
-        // the full usable width. No cap: a wide terminal gets wider panes.
-        const width = Math.max(1, termCols - 2);
+        // The host embeds the surface in a `paddingX: 1` column, so the frame asks
+        // for `termCols - 2` and the shared cap centres whatever is left over.
+        const { width, inset } = widgetFrameGeometry(termCols);
+        this.frameInset = inset;
         const height = Math.max(1, Math.floor(maxRows ?? 20));
         const innerWidth = Math.max(0, width - 4);
         const lines = [topBorder(width, 'Status line', `${this.sideItems(this.side).length} on ${this.side}`)];
@@ -690,7 +689,7 @@ export class StatusLinePanelWidget {
                     ...padRow(order.rows[index], split.previewWidth),
                 ], width));
             }
-            const bands = sideBySideBands(sideBandTop, lines.length - 1, split.listWidth, split.previewWidth);
+            const bands = sideBySideBands(sideBandTop, lines.length - 1, split.listWidth, split.previewWidth, this.frameInset);
             this.fieldBand = bands.list;
             this.lineBand = bands.preview;
         }
@@ -718,7 +717,7 @@ export class StatusLinePanelWidget {
             // Stacked, the panes share the width and are told apart by rows. The
             // field pane's top is the heading row it opened with (or the first row it
             // drew when the frame had no room for headings).
-            const bands = stackedBands({ top: stackedFieldBottom - fieldCapacity, bottom: stackedFieldBottom }, { top: stackedLineTop, bottom: lines.length - 1 }, innerWidth);
+            const bands = stackedBands({ top: stackedFieldBottom - fieldCapacity, bottom: stackedFieldBottom }, { top: stackedLineTop, bottom: lines.length - 1 }, innerWidth, this.frameInset);
             this.fieldBand = bands.list;
             this.lineBand = bands.preview;
         }
@@ -735,7 +734,7 @@ export class StatusLinePanelWidget {
                 lines.push(framedLine(windowed.rows[index]?.segments ?? [], width));
             }
             // Too short for two panes, so only the one on screen is a wheel target.
-            const band = bodyBand(singleTop, lines.length - 1, innerWidth);
+            const band = bodyBand(singleTop, lines.length - 1, innerWidth, this.frameInset);
             this.fieldBand = kind === 'fields' ? band : null;
             this.lineBand = kind === 'line' ? band : null;
         }

package/dist/ui/widgets/transcript_preview.d.ts

@@ -124,6 +124,14 @@ export interface TranscriptHeaderInput {
     focused: boolean;
     /** Heading before the separator, e.g. `PREVIEW`. */
     heading?: string;
+    /**
+     * Columns the heading has to fit in.
+     *
+     * Without it an over-long heading reports four facts and lets the frame cut
+     * the last one in half. With it the heading keeps the title and the first
+     * fact whole, and the caller clips words it can afford to lose.
+     */
+    maxWidth?: number;
 }
 /**
  * Pane heading: marker, title, and how much of the transcript is on screen.

package/dist/ui/widgets/transcript_preview.js

@@ -263,5 +263,15 @@ export function transcriptHeaderText(input) {
         const last = Math.min(total, input.scroll + rows);
         parts.push(`${first}-${last}/${total}`);
     }
+    // A narrow pane gets the title and the first fact, not four items clipped
+    // mid-word: the title says which session this is, and the first fact says how
+    // big it is. The caller drops whatever still does not fit, but it never has
+    // to cut a fact in half — each one is dropped whole.
+    if (input.maxWidth !== undefined && displayWidth(`${marker} ${heading} · ${parts.join(' · ')}`) > input.maxWidth) {
+        const kept = [parts[0]];
+        if (parts.length > 1)
+            kept.push(parts[1]);
+        return `${marker} ${heading} · ${kept.join(' · ')}`;
+    }
     return `${marker} ${heading} · ${parts.join(' · ')}`;
 }

package/dist/utils/context.js

@@ -44,6 +44,8 @@ export const MODEL_CONTEXT_WINDOWS = {
     // this bare key catches all gemini-* ids. Previously had no entry at all -> 128K.
     'gemini': 1000000,
     // GPT models
+    'gpt-6-sol': 1050000,
+    'gpt-6-luna': 1050000,
     'gpt-4': 8192,
     'gpt-4-32k': 32768,
     'gpt-4-turbo': 128000,

package/dist/utils/fireworks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Fireworks' curated pay-per-token Serverless chat/vision catalog.
+ *
+ * Mirrors zapps/zergrouter/server/lib/fireworks-models.ts. Router is the source
+ * of truth and its /v1/models endpoint wins when discovery succeeds; this local
+ * copy only keeps the picker populated and gives the funded default a name when
+ * discovery fails or returns nothing. Keep the slugs aligned with Router.
+ */
+export interface FireworksCatalogModel {
+    slug: string;
+    name: string;
+}
+export declare const FIREWORKS_CHAT_MODELS: readonly FireworksCatalogModel[];
+/**
+ * ZergRouter funds exactly this slug on platform credits
+ * (ZROUTER_FUNDED_DEEPSEEK_PROVIDER === 'fireworks' in fly.prod.toml), so it is
+ * the default a Router-only user can select without a personal Fireworks key.
+ */
+export declare const FIREWORKS_FUNDED_MODEL = "deepseek-v4p1-flash";
+export declare function getFireworksModelName(slug: string): string | undefined;

package/dist/utils/fireworks.js

@@ -0,0 +1,23 @@
+export const FIREWORKS_CHAT_MODELS = [
+    { slug: 'deepseek-v4p1-flash', name: 'DeepSeek V4.1 Flash' },
+    { slug: 'glm-5p3-flash', name: 'GLM 5.3 Flash' },
+    { slug: 'glm-5p3', name: 'GLM 5.3' },
+    { slug: 'kimi-k3', name: 'Kimi K3' },
+    { slug: 'deepseek-v4-pro-0813', name: 'DeepSeek V4 Pro 0813' },
+    { slug: 'qwen3p8-max', name: 'Qwen 3.8 Max' },
+    { slug: 'muse-glimmer-30b', name: 'Muse Glimmer 30B' },
+    { slug: 'deepseek-v4-flash-0731', name: 'DeepSeek V4 Flash 0731' },
+    { slug: 'glm-5p2', name: 'GLM 5.2' },
+    { slug: 'kimi-k2p7-code', name: 'Kimi K2.7 Code' },
+    { slug: 'minimax-m3', name: 'MiniMax M3' },
+    { slug: 'ember-1', name: 'Ember-1' },
+];
+/**
+ * ZergRouter funds exactly this slug on platform credits
+ * (ZROUTER_FUNDED_DEEPSEEK_PROVIDER === 'fireworks' in fly.prod.toml), so it is
+ * the default a Router-only user can select without a personal Fireworks key.
+ */
+export const FIREWORKS_FUNDED_MODEL = 'deepseek-v4p1-flash';
+export function getFireworksModelName(slug) {
+    return FIREWORKS_CHAT_MODELS.find(model => model.slug === slug)?.name;
+}

package/dist/utils/models.d.ts

@@ -1,11 +1,12 @@
 import type { CodexReasoningEffort } from '../config/types.js';
-export declare const OFFICIAL_CODEX_MODEL_IDS: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex", "gpt-5.2"];
+export declare const OFFICIAL_CODEX_MODEL_IDS: readonly ["gpt-6-sol", "gpt-6-luna", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex", "gpt-5.2"];
 export interface OfficialCodexModelInfo {
     displayName: string;
     description: string;
     defaultReasoningEffort: CodexReasoningEffort;
     supportedReasoningEfforts: readonly CodexReasoningEffort[];
 }
+export declare const GPT_6_API_EFFORTS: readonly ["none", "low", "medium", "high", "xhigh", "max"];
 export declare const CODEX_LEGACY_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh"];
 /** Picker metadata mirrored from Codex App Server model/list. */
 export declare const OFFICIAL_CODEX_MODEL_INFO: Record<(typeof OFFICIAL_CODEX_MODEL_IDS)[number], OfficialCodexModelInfo>;

package/dist/utils/models.js

@@ -6,6 +6,8 @@
 import { isCodexAppServerProvider, isCodexLegacyProvider } from '../agent/backends/provider_ids.js';
 import { DEEPSEEK_FLASH_EFFORTS, DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_EFFORTS, isModalDeepSeekFlashModel, isDeepSeekFlashModel } from './deepseek.js';
 export const OFFICIAL_CODEX_MODEL_IDS = [
+    'gpt-6-sol',
+    'gpt-6-luna',
     'gpt-5.6-sol',
     'gpt-5.6-terra',
     'gpt-5.6-luna',
@@ -18,9 +20,22 @@ export const OFFICIAL_CODEX_MODEL_IDS = [
 const STANDARD_CODEX_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
 const GPT_5_6_EFFORTS = [...STANDARD_CODEX_EFFORTS, 'max'];
 const GPT_5_6_ULTRA_EFFORTS = [...GPT_5_6_EFFORTS, 'ultra'];
+export const GPT_6_API_EFFORTS = ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const CODEX_LEGACY_EFFORTS = ['none', 'minimal', ...STANDARD_CODEX_EFFORTS];
 /** Picker metadata mirrored from Codex App Server model/list. */
 export const OFFICIAL_CODEX_MODEL_INFO = {
+    'gpt-6-sol': {
+        displayName: 'GPT-6 Sol',
+        description: 'Frontier agentic coding model.',
+        defaultReasoningEffort: 'medium',
+        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS,
+    },
+    'gpt-6-luna': {
+        displayName: 'GPT-6 Luna',
+        description: 'Fast and affordable model for everyday work.',
+        defaultReasoningEffort: 'medium',
+        supportedReasoningEfforts: GPT_5_6_EFFORTS,
+    },
     'gpt-5.6-sol': {
         displayName: 'GPT-5.6 Sol',
         description: 'Latest frontier agentic coding model.',
@@ -208,6 +223,10 @@ export function getSupportedCodexReasoningEfforts(model, provider) {
     const appServerEfforts = getOfficialCodexModelInfo(model)?.supportedReasoningEfforts;
     if (!appServerEfforts)
         return getSupportedClaudeReasoningEfforts(model);
+    if ((provider === 'openai' || provider === 'openai_compatible')
+        && (model === 'gpt-6-sol' || model === 'gpt-6-luna')) {
+        return GPT_6_API_EFFORTS;
+    }
     if (provider && isCodexLegacyProvider(provider))
         return CODEX_LEGACY_EFFORTS;
     if (provider === undefined) {

package/dist/web/accounts_mirror.d.ts

@@ -13,6 +13,7 @@ import type { LoginCommand } from '../agent/backends/account_pool.js';
 import type { AccountCredentialSource } from '../agent/backends/account_pool.js';
 import type { LoginAttempt } from '../agent/backends/account_login.js';
 import { AccountStateStore } from '../agent/backends/account_state.js';
+import { type CodexAccountStatus } from '../agent/backends/codex_account_status.js';
 import { type KimiDeviceFlowStart, type KimiDeviceLoginResult } from '../agent/backends/kimi_code_auth.js';
 import type { AccountProvider } from '../config/types.js';
 export declare const ACCOUNT_PROVIDER_LABELS: Record<AccountProvider, string>;
@@ -31,6 +32,7 @@ export interface AccountView {
     active: boolean;
     /** How this account's credentials are backed (isolated / shared_keychain / none). */
     credentialSource: AccountCredentialSource;
+    codexStatus?: CodexAccountStatus;
     /** Epoch ms reset when this account is cooling in the rotation sidecar, else absent. */
     cooldownUntil?: number;
     /**
@@ -110,6 +112,10 @@ export interface AccountsPayload {
     loginStates?: Record<string, KimiLoginState>;
 }
 export declare function getAccountsPayload(store?: ConfigStore, deps?: AccountsQueryDeps): AccountsPayload;
+export declare function getAccountsPayloadWithCodexStatus(store?: ConfigStore, deps?: AccountsQueryDeps & {
+    readCodexStatus?: (home: string) => Promise<CodexAccountStatus>;
+    forceCodexStatus?: boolean;
+}): Promise<AccountsPayload>;
 export interface ActiveAccountBadge {
     provider: AccountProvider;
     providerLabel: string;
@@ -201,6 +207,7 @@ export interface AccountOpResult {
  * without spawning the real claude/codex CLIs. Production leaves them defaulted.
  */
 export interface AccountOpDeps {
+    readCodexStatus?: (home: string) => Promise<CodexAccountStatus>;
     runLogin?: (login: LoginCommand, isUsable: () => boolean) => Promise<LoginAttempt>;
     autoRunEnabled?: () => boolean;
     onAccountsChanged?: () => void;

package/dist/web/accounts_mirror.js

@@ -11,10 +11,11 @@
 import { homedir } from 'os';
 import { join } from 'path';
 import { configStore as defaultStore } from '../config.js';
-import { accountCredentialSource, buildLoginCommand, canonicalAccountProvider, defaultAccountDir, defaultSourceFor, ensureAccountDir, isAccountProvider, probeAccountUsable, sharedClaudeKeychainPresent, sourceDir, } from '../agent/backends/account_pool.js';
+import { accountCredentialSource, buildLoginCommand, canonicalAccountProvider, defaultAccountDir, defaultSourceFor, ensureAccountDir, findCodexHomeCollision, isAccountProvider, probeAccountUsable, sharedClaudeKeychainPresent, sourceDir, } from '../agent/backends/account_pool.js';
 import { loginAutoRunEnabled, runLoginCommand } from '../agent/backends/account_login.js';
 import { notifyAccountsChanged } from '../agent/backends/account_events.js';
 import { AccountStateStore } from '../agent/backends/account_state.js';
+import { codexStatusCache } from '../agent/backends/codex_account_status.js';
 import { hasUsableClaudeCodeAuth } from '../agent/backends/claude_code_auth.js';
 import { hasUsableCodexAuth } from '../agent/backends/codex_auth.js';
 import { hasUsableKimiCodeAuth, runKimiDevicePollLoop, startKimiDeviceFlow, } from '../agent/backends/kimi_code_auth.js';
@@ -276,6 +277,33 @@ export function getAccountsPayload(store = defaultStore, deps = {}) {
         ...(Object.keys(loginStates).length > 0 ? { loginStates } : {}),
     };
 }
+export async function getAccountsPayloadWithCodexStatus(store = defaultStore, deps = {}) {
+    const payload = getAccountsPayload(store, deps);
+    const accounts = await Promise.all(payload.accounts.map(async (account) => {
+        if (account.provider !== 'codex_app_server')
+            return account;
+        // The Default row is the machine's own ~/.codex, already verified usable
+        // by its native credential store. The status probe pins the file store, so
+        // it would call a keychain login signed out, and every cache miss would
+        // refresh the main login's token.
+        if (account.id.startsWith(AMBIENT_ACCOUNT_ID_PREFIX))
+            return account;
+        if (!account.usable && !deps.readCodexStatus) {
+            return { ...account, codexStatus: { state: 'reauth_required', windows: [] } };
+        }
+        try {
+            const status = await (deps.readCodexStatus
+                ? deps.readCodexStatus(account.path)
+                : codexStatusCache.read(account.path, deps.forceCodexStatus));
+            return { ...account, codexStatus: status,
+                usable: status.state === 'ready' || status.state === 'quota_unavailable' };
+        }
+        catch {
+            return { ...account, codexStatus: { state: 'unavailable', windows: [] } };
+        }
+    }));
+    return { ...payload, accounts };
+}
 /**
  * The display-only badge payload: the live account per provider (only those with
  * one configured) plus any cooldown, read from the sidecar. Drives the system-bar
@@ -385,6 +413,17 @@ export async function applyAccountOp(body, store = defaultStore, reload, deps =
             const account = store.getAccount(id);
             if (!account)
                 return { ok: false, error: `No account "${id}".` };
+            if (account.source.kind === 'codex_home') {
+                const status = await (deps.readCodexStatus
+                    ? deps.readCodexStatus(account.source.path)
+                    : codexStatusCache.read(account.source.path, true));
+                if (status.state === 'reauth_required') {
+                    return { ok: false, error: `"${account.label}" needs a fresh ChatGPT sign-in. Sign in, then select it again.` };
+                }
+                if (status.state === 'unavailable') {
+                    return { ok: false, error: `"${account.label}" could not be verified. Refresh its status or sign in, then select it again.` };
+                }
+            }
             store.setActiveAccount(account.provider, account.id);
             await store.save();
             // Explicit operator selection overrides a stranded cooldown. Clear it BEFORE
@@ -420,6 +459,11 @@ export async function applyAccountOp(body, store = defaultStore, reload, deps =
             const label = asString(body.label) ?? id;
             const dir = asString(body.path) ?? defaultAccountDir(provider, id);
             const source = defaultSourceFor(provider, dir);
+            // Check for a shared credential home before creating anything, so a
+            // refused add leaves no stray directory behind.
+            const collision = findCodexHomeCollision(store.listAccounts(), source);
+            if (collision)
+                return { ok: false, error: `That Codex credential home is already used by "${collision.label}".` };
             ensureAccountDir(source);
             const beforeActive = store.getActiveAccount(store.getProvider())?.id;
             store.addAccount({ id, label, provider: provider, source });
@@ -583,18 +627,26 @@ export async function applyAccountOp(body, store = defaultStore, reload, deps =
             // `accounts` SSE refreshes when the sign-in finishes (or fails).
             const run = deps.runLogin ?? ((l, u) => runLoginCommand(l, u));
             const notify = deps.onAccountsChanged ?? notifyAccountsChanged;
-            // If this is the CURRENT provider's active account, a successful sign-in makes
-            // its creds usable, so the live agent must hot-swap onto them.
-            const isCurrentActive = store.getActiveAccount(store.getProvider())?.id === account.id;
+            // Check the active pointer again when the detached login finishes: the user
+            // may have selected a different account while completing browser OAuth.
             void run(login, () => probeAccountUsable(account))
-                .then((attempt) => {
+                .then(async (attempt) => {
                 // A successful sign-in mints fresh creds, so a stranded cooldown (an
                 // auth-failover rest that account_rotation cools "until the user
                 // re-auths") is now stale. Clear it before the reload rebuilds the pool.
-                if (attempt.outcome === 'succeeded')
+                let verified = attempt.outcome === 'succeeded';
+                if (verified && account.source.kind === 'codex_home') {
+                    codexStatusCache.invalidate(account.source.path);
+                    const status = await (deps.readCodexStatus
+                        ? deps.readCodexStatus(account.source.path)
+                        : codexStatusCache.read(account.source.path, true));
+                    verified = status.state === 'ready' || status.state === 'quota_unavailable';
+                }
+                if (verified) {
                     (deps.stateStore ?? new AccountStateStore()).clear(account.id);
+                }
                 notify();
-                if (reload && isCurrentActive && attempt.outcome === 'succeeded')
+                if (reload && verified && store.getActiveAccount(store.getProvider())?.id === account.id)
                     reload();
             })
                 .catch(() => notify());

package/dist/web/mirror_stream.js

@@ -31,7 +31,7 @@ import { MemoryHistoryStore, JsonlHistoryStore } from './event_history_store.js'
 import { PaneRegistry } from './pane_registry.js';
 import { createMirrorAuthenticatorFromEnv, } from './mirror_authenticator.js';
 import { areMirrorCorsRequestHeadersAllowed, getMirrorOriginPolicy, MIRROR_CORS_ALLOW_HEADERS, rejectReasonForUnsafeMirrorWrite, } from './mirror_origin_policy.js';
-import { getAccountsPayload, applyAccountOp, getActiveAccountsSummary } from './accounts_mirror.js';
+import { getAccountsPayload, getAccountsPayloadWithCodexStatus, applyAccountOp, getActiveAccountsSummary } from './accounts_mirror.js';
 import { onAccountsChanged } from '../agent/backends/account_events.js';
 import { getMirrorCommandUsages } from '../agent/commands/mirror_usages.js';
 const MAX_MIRROR_IMAGE_BYTES = 10 * 1024 * 1024;
@@ -864,9 +864,8 @@ export class MirrorStreamServer {
             // settings_page is a live-only navigation signal: replaying it on
             // reconnect would hijack the user's view every time.
             && event.type !== 'settings_page'
-            // open_accounts is the same: a one-shot command that pops the Accounts
-            // modal. Retaining it would replay via /events on any reload / new tab /
-            // --resume restart and spring the modal open unbidden.
+            // Legacy open_accounts is also live-only: replay would navigate a fresh
+            // browser tab to Accounts without a new user command.
             && event.type !== 'open_accounts') {
             this.history.append(fullEvent);
         }
@@ -2662,8 +2661,23 @@ export class MirrorStreamServer {
                 res.end(JSON.stringify({ error: 'Host account details are unavailable in hosted mode.' }));
                 return;
             }
+            // Codex status carries the ChatGPT email, plan and quota, and a refresh
+            // spawns the host's Codex App Server against the operator's login. Both
+            // are operator-only. A forced refresh also needs a same-origin request:
+            // an auth-disabled loopback mirror treats every caller as the operator,
+            // including a cross-site <img> pointing at ?refresh=1.
+            const operator = this.canMutateAccounts(auth);
+            const originPolicy = getMirrorOriginPolicy(req);
+            const fetchSite = String(req.headers['sec-fetch-site'] || '').trim().toLowerCase();
+            const sameOrigin = fetchSite !== 'cross-site'
+                && !(originPolicy.requestOrigin && !originPolicy.isTrustedOrigin);
+            const payload = operator
+                ? await getAccountsPayloadWithCodexStatus(undefined, {
+                    forceCodexStatus: sameOrigin && url.searchParams.get('refresh') === '1',
+                })
+                : getAccountsPayload();
             res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' });
-            res.end(JSON.stringify(getAccountsPayload()));
+            res.end(JSON.stringify(payload));
             return;
         }
         if (url.pathname === '/mirror/account' && req.method === 'POST') {