cli-jaw 2.2.3 → 2.2.4-preview.20260703203439

package/public/manager/src/settings/pages/Agent.tsx

@@ -13,10 +13,12 @@ import { FlushAgentSection } from './components/agent/FlushAgentSection';
 import { AgentEmployeesSection } from './components/agent/AgentEmployeesSection';
 import {
     metaFor,
+    normalizeCliMetaRegistry,
     optionList,
     runtimeEffortFor,
     runtimeModelFor,
     type ActiveOverride,
+    type CliMeta,
     type PerCliEntry,
 } from './components/agent/agent-meta';
 import {
@@ -75,6 +77,19 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
     const [employeeDraft, setEmployeeDraft] = useState<RuntimeEmployeeRecord[]>([]);
     const [employeeLoading, setEmployeeLoading] = useState(true);
     const [employeeError, setEmployeeError] = useState<string | null>(null);
+    const [cliMeta, setCliMeta] = useState<Record<string, CliMeta> | null>(null);
+
+    const loadCliMeta = useCallback(async () => {
+        try {
+            const response = await client.get<{ data?: unknown } | Record<string, unknown>>('/api/cli-registry');
+            const data = response && typeof response === 'object' && 'data' in response
+                ? (response as { data?: unknown }).data
+                : response;
+            setCliMeta(normalizeCliMetaRegistry(data));
+        } catch {
+            setCliMeta(null);
+        }
+    }, [client]);
 
     const loadFlush = useCallback(async () => {
         setFlushLoading(true);
@@ -107,24 +122,26 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
     }, [client]);
 
     useEffect(() => {
+        void loadCliMeta();
         void loadFlush();
         void loadEmployees();
-    }, [loadEmployees, loadFlush]);
+    }, [loadCliMeta, loadEmployees, loadFlush]);
 
     useEffect(() => {
         if (state.kind !== 'ready') return;
         const cliKeys = Object.keys(state.data.perCli || {});
         const cli = state.data.cli || cliKeys[0] || '';
         const permissions = parsePermissionsValue(state.data.permissions);
+        const meta = metaFor(cli, cliMeta);
         setDraft({
             cli,
-            provider: state.data.perCli?.[cli]?.provider || metaFor(cli).defaultProvider || '',
+            provider: state.data.perCli?.[cli]?.provider || meta.defaultProvider || '',
             model: runtimeModelFor(cli, state.data.perCli, state.data.activeOverrides),
             effort: runtimeEffortFor(cli, state.data.perCli, state.data.activeOverrides),
             workingDir: state.data.workingDir || '',
             permissions: permissions.mode === 'custom' ? permissions.tokens : 'auto',
         });
-    }, [state]);
+    }, [cliMeta, state]);
 
     useEffect(() => {
         return () => {
@@ -153,9 +170,10 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
         dirty.clear();
         if (freshSettings) setData(freshSettings as AgentSnapshot);
         await refresh();
+        await loadCliMeta();
         await loadFlush();
         await loadEmployees();
-    }, [client, dirty, employeeDraft, employeeOriginal, loadEmployees, loadFlush, refresh, setData]);
+    }, [client, dirty, employeeDraft, employeeOriginal, loadCliMeta, loadEmployees, loadFlush, refresh, setData]);
 
     useEffect(() => {
         if (!registerSave) return;
@@ -167,7 +185,7 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
     const perCli = settingsData.perCli || {};
     const activeOverrides = settingsData.activeOverrides || {};
     const cliOptions = useMemo(() => Object.keys(perCli), [perCli]);
-    const activeMeta = metaFor(draft.cli);
+    const activeMeta = metaFor(draft.cli, cliMeta);
     const activeProvider = draft.provider || activeMeta.defaultProvider || activeMeta.providers?.[0] || '';
     const isPiRuntime = draft.cli === 'pi';
     const hasProviders = !isPiRuntime && (activeMeta.providers?.length ?? 0) > 0;
@@ -212,11 +230,13 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
                 effortOptions={activeEffortOptions}
                 workingDir={draft.workingDir}
                 workingDirError={workingDirError}
+                cliMeta={cliMeta}
                 onCliChange={(next) => {
+                    const nextMeta = metaFor(next, cliMeta);
                     const nextDraft = {
                         ...draft,
                         cli: next,
-                        provider: perCli[next]?.provider || metaFor(next).defaultProvider || '',
+                        provider: perCli[next]?.provider || nextMeta.defaultProvider || '',
                         model: runtimeModelFor(next, perCli, activeOverrides),
                         effort: runtimeEffortFor(next, perCli, activeOverrides),
                     };
@@ -287,11 +307,12 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
                 flushCli={flushDraft.cli || ''}
                 flushModel={flushDraft.model || ''}
                 cliOptions={cliOptions}
-                modelOptions={optionList(metaFor(flushDraft.cli || draft.cli).models, flushDraft.model || '')}
+                cliMeta={cliMeta}
+                modelOptions={optionList(metaFor(flushDraft.cli || draft.cli, cliMeta).models, flushDraft.model || '')}
                 loading={flushLoading}
                 error={flushError}
                 onFlushCliChange={(next) => {
-                    const model = next ? metaFor(next).models[0] || '' : '';
+                    const model = next ? metaFor(next, cliMeta).models[0] || '' : '';
                     setFlushDraft({ cli: next, model });
                     setEntry('flushCli', { value: next, original: flushOriginal.cli || '', valid: true });
                     setEntry('flushModel', { value: model, original: flushOriginal.model || '', valid: true });
@@ -305,6 +326,7 @@ export default function Agent({ port, client, dirty, registerSave }: SettingsPag
                 roster={employeeDraft}
                 original={employeeOriginal}
                 cliOptions={cliOptions}
+                cliMeta={cliMeta}
                 loading={employeeLoading}
                 error={employeeError}
                 onRosterChange={(next) => {

package/public/manager/src/settings/pages/ModelProvider.tsx

@@ -12,8 +12,8 @@ import {
     usePageSnapshot,
 } from './page-shell';
 import { PerCliRow } from './components/PerCliRow';
-import { metaFor } from './components/agent/agent-meta';
-import type { PerCliEntry } from './components/agent/agent-meta';
+import { metaFor, normalizeCliMetaRegistry } from './components/agent/agent-meta';
+import type { CliMeta, PerCliEntry } from './components/agent/agent-meta';
 import type { PiSettingsView } from './components/pi-profile';
 import { expandPatch } from './path-utils';
 
@@ -58,6 +58,23 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
     const [codexCtx, setCodexCtx] = useState<{ contextWindowSize?: number; contextWindowCompactLimit?: number }>({});
     const [resetting, setResetting] = useState(false);
     const [resetError, setResetError] = useState<string | null>(null);
+    const [cliMeta, setCliMeta] = useState<Record<string, CliMeta> | null>(null);
+
+    const loadCliMeta = useCallback(async () => {
+        try {
+            const response = await client.get<{ data?: unknown } | Record<string, unknown>>('/api/cli-registry');
+            const data = response && typeof response === 'object' && 'data' in response
+                ? (response as { data?: unknown }).data
+                : response;
+            setCliMeta(normalizeCliMetaRegistry(data));
+        } catch {
+            setCliMeta(null);
+        }
+    }, [client]);
+
+    useEffect(() => {
+        void loadCliMeta();
+    }, [loadCliMeta]);
 
     useEffect(() => {
         if (state.kind !== 'ready') return;
@@ -101,7 +118,8 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
         setPerCliDraft({ ...(fresh.perCli || {}) });
         setFallback([...(fresh.fallbackOrder || [])]);
         await refresh();
-    }, [client, dirty, refresh, setData]);
+        await loadCliMeta();
+    }, [client, dirty, loadCliMeta, refresh, setData]);
 
     useEffect(() => {
         if (!registerSave) return;
@@ -159,7 +177,7 @@ export default function ModelProvider({ port, client, dirty, registerSave }: Set
                         <PerCliRow
                             key={cli}
                             cli={cli}
-                            meta={metaFor(cli)}
+                            meta={metaFor(cli, cliMeta)}
                             original={perCliOriginal[cli] || {}}
                             value={perCliDraft[cli] || perCliOriginal[cli] || {}}
                             setValue={(next) => setPerCliDraft({ ...perCliDraft, [cli]: next })}

package/public/manager/src/settings/pages/components/agent/AgentEmployeesSection.tsx

@@ -1,5 +1,6 @@
 import { SettingsSection } from '../../page-shell';
 import { RuntimeEmployeeRow } from './RuntimeEmployeeRow';
+import type { CliMeta } from './agent-meta';
 import {
     makeDefaultRuntimeEmployee,
     runtimeEmployeeChangeSummary,
@@ -11,6 +12,7 @@ type AgentEmployeesSectionProps = {
     roster: RuntimeEmployeeRecord[];
     original: RuntimeEmployeeRecord[];
     cliOptions: ReadonlyArray<string>;
+    cliMeta?: Record<string, CliMeta> | null;
     loading?: boolean;
     error?: string | null;
     onRosterChange(next: RuntimeEmployeeRecord[]): void;
@@ -20,6 +22,7 @@ export function AgentEmployeesSection({
     roster,
     original,
     cliOptions,
+    cliMeta,
     loading,
     error,
     onRosterChange,
@@ -58,6 +61,7 @@ export function AgentEmployeesSection({
                             employee={employee}
                             index={idx}
                             cliOptions={cliOptions}
+                            cliMeta={cliMeta ?? null}
                             onChange={(patch) => updateRow(idx, patch)}
                             onRemove={() => removeRow(idx)}
                         />
@@ -68,7 +72,7 @@ export function AgentEmployeesSection({
                 <button
                     type="button"
                     className="settings-action settings-action-discard"
-                    onClick={() => onRosterChange([...roster, makeDefaultRuntimeEmployee(cliOptions)])}
+                    onClick={() => onRosterChange([...roster, makeDefaultRuntimeEmployee(cliOptions, cliMeta)])}
                 >
                     + Add employee
                 </button>

package/public/manager/src/settings/pages/components/agent/FlushAgentSection.tsx

@@ -1,6 +1,6 @@
 import { SelectField } from '../../../fields';
 import { SettingsSection } from '../../page-shell';
-import { metaFor } from './agent-meta';
+import { metaFor, type CliMeta } from './agent-meta';
 
 type FlushAgentSectionProps = {
     activeCli: string;
@@ -8,6 +8,7 @@ type FlushAgentSectionProps = {
     flushModel: string;
     cliOptions: ReadonlyArray<string>;
     modelOptions: ReadonlyArray<{ value: string; label: string }>;
+    cliMeta?: Record<string, CliMeta> | null;
     loading?: boolean;
     error?: string | null;
     onFlushCliChange(next: string): void;
@@ -20,13 +21,14 @@ export function FlushAgentSection({
     flushModel,
     cliOptions,
     modelOptions,
+    cliMeta,
     loading,
     error,
     onFlushCliChange,
     onFlushModelChange,
 }: FlushAgentSectionProps) {
     const effectiveCli = flushCli || activeCli;
-    const effectiveCliLabel = effectiveCli ? metaFor(effectiveCli).label || effectiveCli : 'active';
+    const effectiveCliLabel = effectiveCli ? metaFor(effectiveCli, cliMeta).label || effectiveCli : 'active';
     return (
         <SettingsSection
             title="Flush Agent"
@@ -46,7 +48,7 @@ export function FlushAgentSection({
                         value={flushCli}
                         options={[
                             { value: '', label: '(active CLI)' },
-                            ...cliOptions.map((value) => ({ value, label: metaFor(value).label || value })),
+                            ...cliOptions.map((value) => ({ value, label: metaFor(value, cliMeta).label || value })),
                         ]}
                         onChange={onFlushCliChange}
                     />

package/public/manager/src/settings/pages/components/agent/RuntimeEmployeeRow.tsx

@@ -1,5 +1,5 @@
 import { SelectField, TextField } from '../../../fields';
-import { metaFor, optionList } from './agent-meta';
+import { metaFor, optionList, type CliMeta } from './agent-meta';
 import {
     isStaticEmployee,
     runtimeEmployeeError,
@@ -10,6 +10,7 @@ type RuntimeEmployeeRowProps = {
     employee: RuntimeEmployeeRecord;
     index: number;
     cliOptions: ReadonlyArray<string>;
+    cliMeta?: Record<string, CliMeta> | null;
     onChange(patch: Partial<RuntimeEmployeeRecord>): void;
     onRemove(): void;
 };
@@ -18,11 +19,12 @@ export function RuntimeEmployeeRow({
     employee,
     index,
     cliOptions,
+    cliMeta,
     onChange,
     onRemove,
 }: RuntimeEmployeeRowProps) {
     const locked = isStaticEmployee(employee);
-    const meta = metaFor(employee.cli);
+    const meta = metaFor(employee.cli, cliMeta);
     const modelOptions = optionList(meta.models, employee.model);
     const error = runtimeEmployeeError(employee);
     const cliChoices = Array.from(new Set([...cliOptions, employee.cli, 'claude'])).filter(Boolean);
@@ -47,9 +49,9 @@ export function RuntimeEmployeeRow({
                     label="CLI"
                     value={employee.cli}
                     disabled={locked}
-                    options={cliChoices.map((value) => ({ value, label: metaFor(value).label || value }))}
+                    options={cliChoices.map((value) => ({ value, label: metaFor(value, cliMeta).label || value }))}
                     onChange={(next) => {
-                        const nextModel = metaFor(next).models[0] || 'default';
+                        const nextModel = metaFor(next, cliMeta).models[0] || 'default';
                         onChange({ cli: next, model: nextModel });
                     }}
                 />

package/public/manager/src/settings/pages/components/agent/RuntimeHeader.tsx

@@ -1,6 +1,6 @@
 import { SelectField, TextField } from '../../../fields';
 import { SettingsSection } from '../../page-shell';
-import { metaFor, orderRuntimeCliOptions, PRIMARY_CLIS } from './agent-meta';
+import { metaFor, orderRuntimeCliOptions, PRIMARY_CLIS, type CliMeta } from './agent-meta';
 
 type RuntimeHeaderProps = {
     cli: string;
@@ -13,6 +13,7 @@ type RuntimeHeaderProps = {
     effortOptions: ReadonlyArray<string>;
     workingDir: string;
     workingDirError: string | null;
+    cliMeta?: Record<string, CliMeta> | null;
     onCliChange(next: string): void;
     onProviderChange?(next: string): void;
     onModelChange(next: string): void;
@@ -31,6 +32,7 @@ export function RuntimeHeader({
     effortOptions,
     workingDir,
     workingDirError,
+    cliMeta,
     onCliChange,
     onProviderChange,
     onModelChange,
@@ -50,7 +52,7 @@ export function RuntimeHeader({
                     id="agent-cli"
                     label="Active CLI"
                     value={cli}
-                    options={orderedCliOptions.map((value) => ({ value, label: metaFor(value).label || value }))}
+                    options={orderedCliOptions.map((value) => ({ value, label: metaFor(value, cliMeta).label || value }))}
                     collapsedAfter={orderedPrimaryCliCount}
                     onChange={onCliChange}
                 />

package/public/manager/src/settings/pages/components/agent/agent-meta.ts

@@ -26,6 +26,8 @@ export type ActiveOverride = {
     effort?: string;
 };
 
+const CODEX_MODELS: ReadonlyArray<string> = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex-spark'];
+
 export const PRIMARY_CLIS: ReadonlyArray<string> = ['pi', 'claude', 'claude-e', 'jwc', 'agy', 'codex', 'cursor', 'kiro-code', 'gemini'];
 
 export const CLI_META: Record<string, CliMeta> = {
@@ -48,11 +50,11 @@ export const CLI_META: Record<string, CliMeta> = {
         label: 'AI-E',
         defaultProvider: 'claude',
         providers: ['claude', 'codex', 'gemini', 'grok', 'copilot', 'kiro'],
-        models: ['opus', 'sonnet', 'haiku', 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gemini-3-flash-preview', 'grok-build', 'grok-composer-2.5-fast', 'gpt-5-mini'],
+        models: ['opus', 'sonnet', 'haiku', ...CODEX_MODELS, 'gemini-3-flash-preview', 'grok-build', 'grok-composer-2.5-fast', 'gpt-5-mini'],
         efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
         modelsByProvider: {
             claude: ['claude-fable-5', 'claude-opus-4-8', 'opus', 'sonnet', 'haiku'],
-            codex: ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'],
+            codex: CODEX_MODELS,
             gemini: ['gemini-3-flash-preview'],
             grok: ['grok-build', 'grok-composer-2.5-fast'],
             copilot: ['gpt-5-mini'],
@@ -64,7 +66,7 @@ export const CLI_META: Record<string, CliMeta> = {
             gemini: [],
             grok: [],
             copilot: ['low', 'medium', 'high'],
-            kiro: [],
+            kiro: ['low', 'medium', 'high', 'xhigh'],
         },
     },
     claude: {
@@ -126,12 +128,12 @@ export const CLI_META: Record<string, CliMeta> = {
     },
     codex: {
         label: 'Codex',
-        models: ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex'],
+        models: CODEX_MODELS,
         efforts: ['low', 'medium', 'high', 'xhigh'],
     },
     'codex-app': {
         label: 'Codex App',
-        models: ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex'],
+        models: CODEX_MODELS,
         efforts: ['low', 'medium', 'high', 'xhigh'],
     },
     cursor: {
@@ -171,8 +173,8 @@ export const CLI_META: Record<string, CliMeta> = {
             'glm-5',
             'qwen3-coder-next',
         ],
-        efforts: [],
-        effortNote: 'Kiro CLI has no separate effort flag',
+        efforts: ['low', 'medium', 'high', 'xhigh'],
+        effortNote: 'Kiro CLI forwards --effort; cli-jaw maps xhigh to Kiro max on the wire',
     },
     gemini: {
         label: 'Gemini',
@@ -197,8 +199,42 @@ export const CLI_META: Record<string, CliMeta> = {
     },
 };
 
-export function metaFor(cli: string): CliMeta {
-    return CLI_META[cli] || { label: cli, models: [], efforts: [] };
+function stringArray(value: unknown): string[] {
+    return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [];
+}
+
+function stringArrayRecord(value: unknown): Record<string, string[]> | undefined {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+    const out: Record<string, string[]> = {};
+    for (const [key, raw] of Object.entries(value as Record<string, unknown>)) out[key] = stringArray(raw);
+    return out;
+}
+
+export function normalizeCliMetaRegistry(raw: unknown): Record<string, CliMeta> {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+    const out: Record<string, CliMeta> = {};
+    for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+        const record = value as Record<string, unknown>;
+        const modelsByProvider = stringArrayRecord(record['modelsByProvider']);
+        const effortsByProvider = stringArrayRecord(record['effortsByProvider']);
+        out[key] = {
+            label: typeof record['label'] === 'string' ? record['label'] : key,
+            models: stringArray(record['models']),
+            efforts: stringArray(record['efforts']),
+            ...(typeof record['defaultProvider'] === 'string' ? { defaultProvider: record['defaultProvider'] } : {}),
+            ...(record['providers'] ? { providers: stringArray(record['providers']) } : {}),
+            ...(modelsByProvider ? { modelsByProvider } : {}),
+            ...(effortsByProvider ? { effortsByProvider } : {}),
+            ...(typeof record['effortNote'] === 'string' ? { effortNote: record['effortNote'] } : {}),
+            ...(typeof record['modelNote'] === 'string' ? { modelNote: record['modelNote'] } : {}),
+        };
+    }
+    return out;
+}
+
+export function metaFor(cli: string, registry?: Record<string, CliMeta> | null): CliMeta {
+    return registry?.[cli] || CLI_META[cli] || { label: cli, models: [], efforts: [] };
 }
 
 export function orderRuntimeCliOptions(cliOptions: ReadonlyArray<string>): string[] {

package/public/manager/src/settings/pages/components/agent/runtime-employees-helpers.ts

@@ -1,4 +1,5 @@
 import type { SettingsClient } from '../../../types';
+import type { CliMeta } from './agent-meta';
 
 export type RuntimeEmployeeSource = 'static' | 'db';
 
@@ -37,13 +38,17 @@ export function newRuntimeEmployeeId(): string {
     return `new:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 8)}`;
 }
 
-export function makeDefaultRuntimeEmployee(cliOptions: ReadonlyArray<string>): RuntimeEmployeeRecord {
+export function makeDefaultRuntimeEmployee(
+    cliOptions: ReadonlyArray<string>,
+    cliMeta?: Record<string, CliMeta> | null,
+): RuntimeEmployeeRecord {
     const cli = cliOptions[0] || 'claude';
+    const model = cliMeta?.[cli]?.models?.[0] || 'default';
     return {
         id: newRuntimeEmployeeId(),
         name: 'New Agent',
         cli,
-        model: 'default',
+        model,
         role: '',
         status: 'idle',
         source: 'db',

package/scripts/capture-agy-quota-fixture.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const FIXTURE_DIR = path.join(ROOT, 'tests', 'fixtures', 'agy-quota');
+const EMAIL_PLACEHOLDER = 'redacted@example.invalid';
+const REDACTED = '[REDACTED]';
+const REDACT_KEYS = new Set([
+    'email',
+    'account',
+    'accountid',
+    'user',
+    'id',
+    'requestid',
+    'request_id',
+    'token',
+    'accesstoken',
+    'refreshtoken',
+    'idtoken',
+    'apikey',
+    'secret',
+    'password',
+    'bearer',
+    'cookie',
+    'authorization',
+]);
+
+function usage() {
+    console.log(`Usage: node scripts/capture-agy-quota-fixture.mjs [--out <path>]
+
+Capture antigravity-usage --json, redact account identifiers, and write an AGY
+quota fixture. Review the output manually before committing.
+
+Options:
+  --out <path>  Write to a custom JSON path.
+  -h, --help    Show this help.
+`);
+}
+
+function parseArgs(argv) {
+    const args = { out: '' };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '-h' || arg === '--help') {
+            usage();
+            process.exit(0);
+        }
+        if (arg === '--out') {
+            const value = argv[i + 1];
+            if (!value) throw new Error('--out requires a path');
+            args.out = value;
+            i += 1;
+            continue;
+        }
+        throw new Error(`unknown argument: ${arg}`);
+    }
+    return args;
+}
+
+function runJson() {
+    const commands = [
+        ['antigravity-usage', ['--json']],
+        ['npx', ['--yes', 'antigravity-usage', '--json']],
+    ];
+    const errors = [];
+    for (const [binary, args] of commands) {
+        try {
+            return execFileSync(binary, args, {
+                encoding: 'utf8',
+                timeout: 15000,
+                maxBuffer: 1024 * 1024,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        } catch (error) {
+            errors.push(`${binary}: ${error.message}`);
+        }
+    }
+    throw new Error(`failed to run antigravity-usage JSON capture:\n${errors.join('\n')}`);
+}
+
+function redactString(value, forceEmail = false) {
+    if (forceEmail) return EMAIL_PLACEHOLDER;
+    return value.replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, EMAIL_PLACEHOLDER);
+}
+
+function redact(value, key = '') {
+    if (Array.isArray(value)) return value.map(item => redact(item));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [rawKey, rawValue] of Object.entries(value)) {
+            const normalized = rawKey.toLowerCase().replace(/[-_\s]/g, '');
+            if (REDACT_KEYS.has(normalized)) {
+                out[rawKey] = normalized === 'email'
+                    ? EMAIL_PLACEHOLDER
+                    : typeof rawValue === 'string'
+                        ? redactString(rawValue) === rawValue ? REDACTED : EMAIL_PLACEHOLDER
+                        : REDACTED;
+                continue;
+            }
+            out[rawKey] = redact(rawValue, rawKey);
+        }
+        return out;
+    }
+    if (typeof value === 'string') {
+        return redactString(value, key.toLowerCase() === 'email');
+    }
+    return value;
+}
+
+function defaultOutPath() {
+    const day = new Date().toISOString().slice(0, 10);
+    return path.join(FIXTURE_DIR, `live-redacted-${day}.json`);
+}
+
+function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const raw = runJson().trim();
+    if (!raw.startsWith('{')) throw new Error('antigravity-usage output is not a JSON object');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('antigravity-usage output must be a JSON object');
+    }
+    const redacted = redact(parsed);
+    const outPath = path.resolve(args.out || defaultOutPath());
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, `${JSON.stringify(redacted, null, 2)}\n`);
+    console.log(outPath);
+}
+
+try {
+    main();
+} catch (error) {
+    console.error((error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+}

package/scripts/fresh-install-smoke.ts

@@ -179,7 +179,7 @@ async function main(): Promise<void> {
         if (!cliRes.ok) throw new Error(`/api/cli-status HTTP ${cliRes.status}`);
         const cliJson = (await cliRes.json()) as Record<string, unknown> | null;
         const keys = Object.keys(cliJson ?? {});
-        const required: string[] = ['ai-e', 'claude', 'claude-e', 'codex', 'codex-app', 'copilot', 'cursor', 'kiro-code', 'gemini', 'grok', 'opencode'];
+        const required: string[] = ['ai-e', 'claude', 'claude-e', 'codex', 'codex-app', 'copilot', 'cursor', 'kiro-code', 'grok', 'opencode'];
         for (const k of required) {
             if (!keys.includes(k)) throw new Error(`missing cli key in status: ${k}`);
         }