mixdog 0.7.1

package/scripts/provider-cache-smoke.mjs

@@ -0,0 +1,687 @@
+#!/usr/bin/env node
+/**
+ * Provider cache smoke/diagnostic runner.
+ *
+ * Static mode (default) prints the provider cache capability matrix and an
+ * in-memory SmartBridge registry probe. Live mode makes small sequential
+ * calls to enabled providers and reports normalized usage/cache metrics
+ * without printing secrets or prompt bodies.
+ *
+ * Usage:
+ *   node scripts/provider-cache-smoke.mjs
+ *   node scripts/provider-cache-smoke.mjs --live --providers gemini,openai-oauth --repeat 2
+ *   node scripts/provider-cache-smoke.mjs --live --gemini-trace --stable-chars 6000
+ */
+
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = resolve(HERE, '..');
+
+const opts = parseArgs(process.argv.slice(2));
+if (opts.help) {
+    printHelp();
+    process.exit(0);
+}
+
+process.env.CLAUDE_PLUGIN_ROOT ||= PLUGIN_ROOT;
+process.env.CLAUDE_PLUGIN_DATA ||= join(homedir(), '.claude', 'plugins', 'data', 'mixdog-trib-plugin');
+if (opts.geminiTrace) process.env.MIXDOG_GEMINI_CACHE_TRACE = '1';
+if (opts.compatTrace) process.env.MIXDOG_COMPAT_CACHE_TRACE = '1';
+
+const { loadConfig, listPresets } = await import('../src/agent/orchestrator/config.mjs');
+const { initProviders, getAllProviders } = await import('../src/agent/orchestrator/providers/registry.mjs');
+const {
+    buildProviderCacheOpts,
+    cacheCapabilityForProvider,
+    computePrefixContent,
+    shouldMarkWarmForProvider,
+    shouldRecordObservedForProvider,
+} = await import('../src/agent/orchestrator/smart-bridge/cache-strategy.mjs');
+const { CacheRegistry } = await import('../src/agent/orchestrator/smart-bridge/registry.mjs');
+const { SmartBridge } = await import('../src/agent/orchestrator/smart-bridge/index.mjs');
+const { drainOpenaiWsPool } = await import('../src/agent/orchestrator/providers/openai-oauth-ws.mjs');
+const { createSession, closeSession } = await import('../src/agent/orchestrator/session/manager.mjs');
+
+const config = loadConfig();
+const allProviderNames = Object.keys(config.providers || {}).sort();
+const selectedProviders = opts.providers
+    ? opts.providers.filter(p => allProviderNames.includes(p))
+    : allProviderNames;
+
+const modelOverrides = parseModelOverrides(opts.model);
+const registryProbe = runRegistryProbe(selectedProviders);
+const staticRows = selectedProviders.map((provider) => {
+    const providerConfig = config.providers?.[provider] || {};
+    const cacheOpts = buildProviderCacheOpts(provider, 'provider-cache-smoke-session', 'provider-cache-smoke');
+    return {
+        provider,
+        enabled: providerConfig.enabled === true,
+        capability: cacheCapabilityForProvider(provider),
+        markWarm: shouldMarkWarmForProvider(provider),
+        observedOnly: shouldRecordObservedForProvider(provider),
+        cacheOpts: Object.keys(cacheOpts).sort(),
+        configuredModel: chooseModel(provider, config, modelOverrides) || '(provider default)',
+        registryWarm: registryProbe[provider]?.warm === true,
+        registryReason: registryProbe[provider]?.reason || 'not-probed',
+    };
+});
+
+let liveRows = [];
+let initError = null;
+if (opts.live) {
+    try {
+        if (opts.actualContext) await initActualContextRuntime();
+        else await initProviders(config.providers || {});
+    } catch (err) {
+        initError = sanitizeError(err);
+    }
+    if (!initError) {
+        const providers = getAllProviders();
+        for (const row of staticRows) {
+            if (!row.enabled) {
+                liveRows.push({ provider: row.provider, status: 'skipped', reason: 'disabled' });
+                continue;
+            }
+            const provider = providers.get(row.provider);
+            if (!provider) {
+                liveRows.push({ provider: row.provider, status: 'skipped', reason: 'not-initialized' });
+                continue;
+            }
+            liveRows.push(await runLiveProviderSmoke({
+                providerName: row.provider,
+                provider,
+                model: row.configuredModel === '(provider default)' ? undefined : row.configuredModel,
+                repeat: opts.repeat,
+                delayMs: opts.delayMs,
+                stableChars: opts.stableChars,
+                timeoutMs: opts.timeoutMs,
+                actualContext: opts.actualContext,
+                singleSession: opts.singleSession,
+                role: opts.role,
+                cwd: opts.cwd,
+            }));
+        }
+    }
+}
+
+const report = {
+    generatedAt: new Date().toISOString(),
+    pluginRoot: PLUGIN_ROOT,
+    pluginData: process.env.CLAUDE_PLUGIN_DATA,
+    live: opts.live,
+    actualContext: opts.actualContext,
+    singleSession: opts.singleSession,
+    role: opts.role,
+    cwd: opts.cwd,
+    repeat: opts.repeat,
+    delayMs: opts.delayMs,
+    stableChars: opts.stableChars,
+    providers: staticRows,
+    ...(opts.live ? { initError, liveResults: liveRows } : {}),
+};
+
+if (opts.json) {
+    console.log(JSON.stringify(report, null, 2));
+} else {
+    printHumanReport(report);
+}
+
+try { drainOpenaiWsPool('provider-cache-smoke-complete'); } catch {}
+
+if (opts.live && !opts.allowFail) {
+    const failed = initError || liveRows.some(r => r.status === 'failed');
+    if (failed) process.exitCode = 1;
+}
+
+function parseArgs(args) {
+    const out = {
+        live: false,
+        providers: null,
+        repeat: 2,
+        delayMs: 0,
+        stableChars: 6000,
+        timeoutMs: 90_000,
+        json: false,
+        geminiTrace: false,
+        compatTrace: false,
+        actualContext: false,
+        singleSession: false,
+        role: 'worker',
+        cwd: null,
+        model: [],
+        allowFail: false,
+        help: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') out.help = true;
+        else if (arg === '--live') out.live = true;
+        else if (arg === '--no-live') out.live = false;
+        else if (arg === '--json') out.json = true;
+        else if (arg === '--gemini-trace') out.geminiTrace = true;
+        else if (arg === '--compat-trace') out.compatTrace = true;
+        else if (arg === '--actual-context') out.actualContext = true;
+        else if (arg === '--single-session') out.singleSession = true;
+        else if (arg === '--allow-fail') out.allowFail = true;
+        else if (arg === '--providers') out.providers = parseCsv(args[++i]);
+        else if (arg.startsWith('--providers=')) out.providers = parseCsv(arg.slice('--providers='.length));
+        else if (arg === '--role') out.role = String(args[++i] || out.role);
+        else if (arg.startsWith('--role=')) out.role = String(arg.slice('--role='.length) || out.role);
+        else if (arg === '--cwd') out.cwd = normalizeCwdArg(args[++i]);
+        else if (arg.startsWith('--cwd=')) out.cwd = normalizeCwdArg(arg.slice('--cwd='.length));
+        else if (arg === '--repeat') out.repeat = clampInt(args[++i], 1, 10, out.repeat);
+        else if (arg.startsWith('--repeat=')) out.repeat = clampInt(arg.slice('--repeat='.length), 1, 10, out.repeat);
+        else if (arg === '--delay-ms') out.delayMs = clampInt(args[++i], 0, 60_000, out.delayMs);
+        else if (arg.startsWith('--delay-ms=')) out.delayMs = clampInt(arg.slice('--delay-ms='.length), 0, 60_000, out.delayMs);
+        else if (arg === '--stable-chars') out.stableChars = clampInt(args[++i], 256, 120_000, out.stableChars);
+        else if (arg.startsWith('--stable-chars=')) out.stableChars = clampInt(arg.slice('--stable-chars='.length), 256, 120_000, out.stableChars);
+        else if (arg === '--timeout-ms') out.timeoutMs = clampInt(args[++i], 5_000, 300_000, out.timeoutMs);
+        else if (arg.startsWith('--timeout-ms=')) out.timeoutMs = clampInt(arg.slice('--timeout-ms='.length), 5_000, 300_000, out.timeoutMs);
+        else if (arg === '--model') out.model.push(String(args[++i] || ''));
+        else if (arg.startsWith('--model=')) out.model.push(arg.slice('--model='.length));
+        else throw new Error(`unknown argument: ${arg}`);
+    }
+    return out;
+}
+
+function normalizeCwdArg(value) {
+    const raw = String(value || '').trim();
+    if (!raw || raw === 'null' || raw === 'none') return null;
+    return resolve(raw.replace(/^~(?=$|[\\/])/, homedir()));
+}
+
+function parseCsv(value) {
+    return String(value || '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean);
+}
+
+function clampInt(value, min, max, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n)) return fallback;
+    return Math.max(min, Math.min(max, Math.trunc(n)));
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function parseModelOverrides(values) {
+    const map = new Map();
+    for (const raw of values || []) {
+        for (const item of parseCsv(raw)) {
+            const idx = item.indexOf('=');
+            if (idx <= 0) continue;
+            const provider = item.slice(0, idx).trim();
+            const model = item.slice(idx + 1).trim();
+            if (provider && model) map.set(provider, model);
+        }
+    }
+    return map;
+}
+
+function chooseModel(provider, cfg, overrides) {
+    if (overrides.has(provider)) return overrides.get(provider);
+    const preset = listPresets(cfg).find(p => p?.provider === provider && p?.model);
+    if (preset?.model) return preset.model;
+    const fallback = {
+        anthropic: 'claude-haiku-4-5-20251001',
+        'anthropic-oauth': 'claude-haiku-4-5-20251001',
+        gemini: 'gemini-3.5-flash',
+        openai: 'gpt-5.5',
+        'openai-oauth': 'gpt-5.5',
+    };
+    return fallback[provider] || undefined;
+}
+
+function runRegistryProbe(providerNames) {
+    const registry = new CacheRegistry();
+    registry.loaded = true;
+    registry.data = { version: 2, profiles: {}, openaiKeys: {}, updatedAt: new Date().toISOString() };
+    registry.save = () => { registry.dirty = false; };
+    const bridge = new SmartBridge({ registry });
+    const profile = { id: 'provider-cache-smoke' };
+    const systemPrompt = ['stable-system'];
+    const tools = [{ name: 'noop', description: 'No-op smoke tool.', inputSchema: { type: 'object' } }];
+    const prefix = computePrefixContent(systemPrompt, tools);
+    const out = {};
+    for (const provider of providerNames) {
+        bridge.recordCall(profile, provider, {
+            systemPrompt,
+            tools,
+            usage: { inputTokens: 100, promptTokens: 100, cachedTokens: provider === 'gemini' ? 0 : 25 },
+        });
+        out[provider] = registry.checkWarm(profile.id, provider, prefix);
+    }
+    return out;
+}
+
+async function runLiveProviderSmoke({ providerName, provider, model, repeat, delayMs, stableChars, timeoutMs, actualContext, singleSession, role, cwd }) {
+    const started = Date.now();
+    const attempts = [];
+    const cacheKey = `mixdog-provider-cache-smoke-${providerName}`;
+    const cacheOpts = buildProviderCacheOpts(providerName, cacheKey, 'provider-cache-smoke');
+    let sharedActual = null;
+    let sharedMessages = null;
+    let sharedProviderState = undefined;
+
+    try {
+        if (actualContext && singleSession) {
+            sharedActual = buildActualRequestContext({
+                providerName,
+                model,
+                role,
+                cwd,
+                sourceName: `provider-cache-smoke-${providerName}`,
+            });
+        }
+
+        for (let i = 1; i <= repeat; i++) {
+            const ac = new AbortController();
+            const timer = setTimeout(() => {
+                try { ac.abort(new Error(`provider-cache-smoke timeout after ${timeoutMs}ms`)); } catch {}
+            }, timeoutMs);
+            if (timer.unref) timer.unref();
+            const t0 = Date.now();
+            let lastStage = null;
+            let actual = null;
+            try {
+                actual = actualContext
+                    ? (sharedActual || buildActualRequestContext({
+                        providerName,
+                        model,
+                        role,
+                        cwd,
+                        sourceName: `provider-cache-smoke-${providerName}`,
+                    }))
+                    : null;
+                let messages = actualContext
+                    ? actual.messages
+                    : makeSmokeMessages(stableChars);
+                if (actualContext && singleSession) {
+                    if (!sharedMessages) sharedMessages = [...actual.messages];
+                    else {
+                        sharedMessages = [
+                            ...sharedMessages,
+                            { role: 'user', content: `Reply with exactly: SMOKE_OK_${i}` },
+                        ];
+                    }
+                    messages = sharedMessages;
+                } else if (actualContext) {
+                    messages = makeActualSmokeMessages(actual.messages, i);
+                }
+                const tools = actual?.tools || [];
+                const sessionId = actual?.sessionId || `${cacheKey}-${Date.now()}-${i}`;
+                const result = await provider.send(messages, model, actualContext ? tools : [], {
+                    ...cacheOpts,
+                    sessionId,
+                    providerCacheKey: cacheKey,
+                    promptCacheKey: cacheKey,
+                    providerState: actualContext && singleSession ? sharedProviderState : undefined,
+                    role: 'provider-cache-smoke',
+                    iteration: i,
+                    signal: ac.signal,
+                    session: {
+                        id: sessionId,
+                        owner: 'smoke',
+                        role: 'provider-cache-smoke',
+                        permission: 'read',
+                        toolPermission: 'none',
+                        profileId: 'provider-cache-smoke',
+                        sourceType: 'diagnostic',
+                        sourceName: 'provider-cache-smoke',
+                    },
+                    onStageChange: (stage) => { lastStage = stage; },
+                    onStreamDelta: () => {},
+                });
+                attempts.push({
+                    iteration: i,
+                    status: 'ok',
+                    ms: Date.now() - t0,
+                    stage: lastStage,
+                    model: result?.model || model || null,
+                    textChars: String(result?.content || '').length,
+                    usage: summarizeUsage(result?.usage),
+                    ...(actual?.session ? { context: summarizeActualContext(actual.session, messages) } : (actual?.shape ? { context: actual.shape } : {})),
+                });
+                if (actualContext && singleSession) {
+                    sharedProviderState = result?.providerState ?? sharedProviderState;
+                    sharedMessages = [
+                        ...messages,
+                        {
+                            role: 'assistant',
+                            content: String(result?.content || ''),
+                            ...(typeof result?.reasoningContent === 'string' && result.reasoningContent
+                                ? { reasoningContent: result.reasoningContent }
+                                : {}),
+                        },
+                    ];
+                }
+            } catch (err) {
+                attempts.push({
+                    iteration: i,
+                    status: 'failed',
+                    ms: Date.now() - t0,
+                    stage: lastStage,
+                    error: sanitizeError(err),
+                });
+                break;
+            } finally {
+                clearTimeout(timer);
+                if (!singleSession && actual?.sessionId) {
+                    try { closeSession(actual.sessionId, 'provider-cache-smoke-complete'); } catch {}
+                }
+            }
+            if (delayMs > 0 && i < repeat) await sleep(delayMs);
+        }
+    } catch (err) {
+        attempts.push({
+            iteration: attempts.length + 1,
+            status: 'failed',
+            ms: Date.now() - started,
+            stage: null,
+            error: sanitizeError(err),
+        });
+    } finally {
+        if (sharedActual?.sessionId) {
+            try { closeSession(sharedActual.sessionId, 'provider-cache-smoke-complete'); } catch {}
+        }
+    }
+
+    const totals = attempts.reduce((acc, attempt) => {
+        if (attempt.status !== 'ok') return acc;
+        const u = attempt.usage || {};
+        acc.ok += 1;
+        acc.inputTokens += u.inputTokens || 0;
+        acc.promptTokens += u.promptTokens || 0;
+        acc.outputTokens += u.outputTokens || 0;
+        acc.cachedTokens += u.cachedTokens || 0;
+        acc.cacheWriteTokens += u.cacheWriteTokens || 0;
+        return acc;
+    }, { ok: 0, inputTokens: 0, promptTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0 });
+    totals.cacheHitRate = totals.promptTokens > 0
+        ? Number((totals.cachedTokens / totals.promptTokens).toFixed(6))
+        : null;
+
+    return {
+        provider: providerName,
+        status: attempts.every(a => a.status === 'ok') ? 'ok' : 'failed',
+        model: attempts.find(a => a.model)?.model || model || null,
+        ms: Date.now() - started,
+        totals,
+        attempts,
+    };
+}
+
+function makeActualSmokeMessages(baseMessages, iteration) {
+    const out = [...(baseMessages || [])];
+    for (let n = 2; n <= iteration; n++) {
+        out.push({ role: 'user', content: `Reply with exactly: SMOKE_OK_${n}` });
+    }
+    return out;
+}
+
+function buildActualRequestContext({ providerName, model, role, cwd, sourceName }) {
+    const preset = {
+        id: `provider-cache-smoke-${providerName}`,
+        name: `PROVIDER CACHE SMOKE ${providerName}`,
+        type: 'bridge',
+        provider: providerName,
+        model,
+        tools: 'full',
+    };
+    const session = createSession({
+        owner: 'bridge',
+        role,
+        preset,
+        cwd,
+        sourceType: 'diagnostic',
+        sourceName,
+        taskType: 'provider-cache-smoke',
+    });
+    const userMessage = { role: 'user', content: 'Reply with exactly: SMOKE_OK' };
+    const messages = [...session.messages, userMessage];
+    return {
+        sessionId: session.id,
+        session,
+        messages,
+        tools: session.tools || [],
+        shape: summarizeActualContext(session, messages),
+    };
+}
+
+function summarizeActualContext(session, messages) {
+    const systemMessages = messages.filter(m => m?.role === 'system').map(m => String(m.content || ''));
+    const nonSystem = messages.filter(m => m?.role !== 'system');
+    const tools = session.tools || [];
+    const toolShape = tools.map(t => ({
+        name: t?.name || null,
+        description: t?.description || '',
+        inputSchema: t?.inputSchema || null,
+    }));
+    return {
+        role: session.role || null,
+        provider: session.provider || null,
+        model: session.model || null,
+        owner: session.owner || null,
+        cwd: session.cwd || null,
+        messageCount: messages.length,
+        systemCount: systemMessages.length,
+        systemChars: systemMessages.reduce((n, s) => n + s.length, 0),
+        systemHash: shortHash(JSON.stringify(systemMessages)),
+        nonSystemTurns: nonSystem.map((m, index) => ({
+            index,
+            role: m?.role || null,
+            chars: String(m?.content || '').length,
+            hash: shortHash(String(m?.content || '')),
+        })),
+        toolCount: tools.length,
+        toolSchemaHash: shortHash(stableStringify(toolShape)),
+        toolNames: tools.map(t => t?.name).filter(Boolean).sort(),
+        promptCacheKey: session.promptCacheKey || null,
+        profileId: session.profileId || null,
+    };
+}
+
+async function initActualContextRuntime() {
+    const agentMod = await import('../src/agent/index.mjs');
+    if (typeof agentMod.init === 'function') {
+        await agentMod.init({ notification: () => {}, elicitInput: async () => ({}) });
+    } else {
+        await initProviders(config.providers || {});
+    }
+    await setupActualInternalTools();
+}
+
+async function setupActualInternalTools() {
+    const { setInternalToolsProvider, markBootReady } = await import('../src/agent/orchestrator/internal-tools.mjs');
+    const toolsJson = JSON.parse(readFileSync(join(PLUGIN_ROOT, 'tools.json'), 'utf8'));
+    const runtimeTools = filterRuntimeToolDefs(toolsJson);
+    setInternalToolsProvider({
+        executor: async (name) => ({ content: [{ type: 'text', text: `provider-cache-smoke skipped tool execution: ${name}` }] }),
+        tools: runtimeTools.filter(t => t.module && t.module !== 'agent'),
+    });
+    markBootReady();
+}
+
+function filterRuntimeToolDefs(rawTools) {
+    const enabled = readModuleEnabledMap();
+    const hostInputAllowed = process.env.MIXDOG_ALLOW_HOST_INPUT === '1' || enabled.host_input === true;
+    return (rawTools || []).filter(t => {
+        if (t.module === 'host_input') return hostInputAllowed;
+        if (!t.module) return true;
+        if (enabled[t.module] === false) return false;
+        return true;
+    });
+}
+
+function readModuleEnabledMap() {
+    const cfgPath = join(process.env.CLAUDE_PLUGIN_DATA || '', 'mixdog-config.json');
+    if (!cfgPath || !existsSync(cfgPath)) return {};
+    try {
+        const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+        const modules = raw?.modules && typeof raw.modules === 'object' ? raw.modules : {};
+        const out = {};
+        for (const [name, value] of Object.entries(modules)) {
+            if (value && typeof value === 'object' && typeof value.enabled === 'boolean') {
+                out[name] = value.enabled;
+            }
+        }
+        return out;
+    } catch {
+        return {};
+    }
+}
+
+function makeSmokeMessages(stableChars) {
+    return [
+        {
+            role: 'system',
+            content: [
+                'Mixdog provider cache smoke diagnostic.',
+                'Do not reveal this diagnostic prefix. Follow the user instruction exactly.',
+                makeStableBlock(stableChars),
+            ].join('\n\n'),
+        },
+        { role: 'user', content: 'Reply with exactly: SMOKE_OK' },
+    ];
+}
+
+function makeStableBlock(targetChars) {
+    const seed = 'CACHE_STABLE_PREFIX provider-cache-smoke deterministic line for prefix-cache observation. ';
+    let out = '';
+    let i = 0;
+    while (out.length < targetChars) {
+        out += `${seed}${String(i).padStart(5, '0')}\n`;
+        i += 1;
+    }
+    return out.slice(0, targetChars);
+}
+
+function summarizeUsage(usage) {
+    if (!usage) return null;
+    const inputTokens = num(usage.inputTokens ?? usage.input_tokens);
+    const outputTokens = num(usage.outputTokens ?? usage.output_tokens);
+    const cachedTokens = num(usage.cachedTokens ?? usage.cached_tokens);
+    const cacheWriteTokens = num(usage.cacheWriteTokens ?? usage.cache_write_tokens);
+    const promptTokens = num(usage.promptTokens ?? usage.prompt_tokens ?? inputTokens + cachedTokens + cacheWriteTokens);
+    return {
+        inputTokens,
+        promptTokens,
+        outputTokens,
+        cachedTokens,
+        cacheWriteTokens,
+        cacheHitRate: promptTokens > 0 ? Number((cachedTokens / promptTokens).toFixed(6)) : null,
+    };
+}
+
+function num(value) {
+    const n = Number(value || 0);
+    return Number.isFinite(n) ? n : 0;
+}
+
+function sanitizeError(err) {
+    const msg = err instanceof Error ? err.message : String(err || '');
+    return msg
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/ig, 'Bearer ***')
+        .replace(/sk-[A-Za-z0-9_-]{8,}/g, 'sk-***')
+        .replace(/AIza[A-Za-z0-9_-]{20,}/g, 'AIza***')
+        .replace(/access_token["']?\s*[:=]\s*["']?[^"',\s]+/ig, 'access_token=***')
+        .slice(0, 500);
+}
+
+function shortHash(value) {
+    return createHash('sha256').update(String(value ?? '')).digest('hex').slice(0, 16);
+}
+
+function stableStringify(value, seen = new WeakSet()) {
+    if (value === null || typeof value !== 'object') return JSON.stringify(value);
+    if (seen.has(value)) return JSON.stringify('[Circular]');
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const out = '[' + value.map(v => stableStringify(v, seen)).join(',') + ']';
+        seen.delete(value);
+        return out;
+    }
+    const parts = [];
+    for (const key of Object.keys(value).sort()) {
+        const v = value[key];
+        if (v === undefined || typeof v === 'function') continue;
+        parts.push(JSON.stringify(key) + ':' + stableStringify(v, seen));
+    }
+    seen.delete(value);
+    return '{' + parts.join(',') + '}';
+}
+
+function printHumanReport(report) {
+    console.log('Provider cache smoke');
+    console.log(`generatedAt=${report.generatedAt}`);
+    console.log(`pluginRoot=${report.pluginRoot}`);
+    console.log(`pluginData=${report.pluginData}`);
+    console.log('');
+    console.log('Static capability matrix');
+    console.log('| provider | enabled | capability | markWarm | observedOnly | cacheOpts | model | registry |');
+    console.log('|---|---:|---|---:|---:|---|---|---|');
+    for (const row of report.providers) {
+        console.log(`| ${row.provider} | ${row.enabled ? 'yes' : 'no'} | ${row.capability} | ${row.markWarm ? 'yes' : 'no'} | ${row.observedOnly ? 'yes' : 'no'} | ${row.cacheOpts.join(',') || '-'} | ${row.configuredModel} | ${row.registryWarm ? 'warm' : row.registryReason} |`);
+    }
+    if (!report.live) {
+        console.log('');
+        console.log('Live mode not requested. Add --live to call enabled providers.');
+        return;
+    }
+    console.log('');
+    console.log(`Live smoke repeat=${report.repeat} stableChars=${report.stableChars} actualContext=${report.actualContext ? 'yes' : 'no'} singleSession=${report.singleSession ? 'yes' : 'no'} role=${report.role || '-'}`);
+    if (report.initError) {
+        console.log(`provider init failed: ${report.initError}`);
+        return;
+    }
+    console.log('| provider | status | model | ok | input | prompt | cached | write | hit% | output | ms |');
+    console.log('|---|---|---|---:|---:|---:|---:|---:|---:|---:|---:|');
+    for (const row of report.liveResults) {
+        if (row.status === 'skipped') {
+            console.log(`| ${row.provider} | skipped:${row.reason} | - | 0 | 0 | 0 | 0 | 0 | - | 0 | 0 |`);
+            continue;
+        }
+        const t = row.totals || {};
+        const hit = t.cacheHitRate == null ? '-' : `${(t.cacheHitRate * 100).toFixed(1)}%`;
+        console.log(`| ${row.provider} | ${row.status} | ${row.model || '-'} | ${t.ok || 0} | ${t.inputTokens || 0} | ${t.promptTokens || 0} | ${t.cachedTokens || 0} | ${t.cacheWriteTokens || 0} | ${hit} | ${t.outputTokens || 0} | ${row.ms || 0} |`);
+        const context = row.attempts?.find(a => a.context)?.context;
+        if (context) {
+            console.log(`  - actual-context role=${context.role} messages=${context.messageCount} systemChars=${context.systemChars} tools=${context.toolCount} systemHash=${context.systemHash} toolSchemaHash=${context.toolSchemaHash}`);
+        }
+        for (const attempt of row.attempts || []) {
+            if (attempt.status === 'failed') {
+                console.log(`  - ${row.provider} iter${attempt.iteration} failed after ${attempt.ms}ms: ${attempt.error}`);
+            }
+        }
+    }
+}
+
+function printHelp() {
+    console.log(`Provider cache smoke
+
+Options:
+  --live                       Call enabled providers.
+  --providers a,b              Limit providers.
+  --repeat N                   Sequential calls per live provider (default 2).
+  --delay-ms N                 Delay between repeated live calls (default 0).
+  --stable-chars N             Stable system-prefix size for cache smoke (default 6000).
+  --actual-context             Use real createSession(owner=bridge) worker messages/tools.
+  --single-session             Reuse one actual-context session across repeated live calls.
+  --role NAME                  Bridge role for --actual-context (default worker).
+  --cwd PATH|null              cwd for actual context. Default null, matching internal bridge calls.
+  --timeout-ms N               Per-call timeout (default 90000).
+  --model provider=model       Override a provider model. Repeatable or comma-separated.
+  --gemini-trace               Enable MIXDOG_GEMINI_CACHE_TRACE=1 for this process.
+  --compat-trace               Enable MIXDOG_COMPAT_CACHE_TRACE=1 for OpenAI-compatible providers.
+  --json                       Print JSON.
+  --allow-fail                 Keep exit code 0 even if live providers fail.
+`);
+}