sneakoscope 4.2.0 → 4.4.0

package/dist/core/codex-control/codex-app-server-v2-client.js

@@ -8,10 +8,12 @@ export class CodexAppServerV2Client {
     cwd;
     timeoutMs;
     currentTimeProvider;
+    approvalPolicy;
     child = null;
     nextId = 1;
     pending = new Map();
     notifications = [];
+    listeners = new Set();
     stdoutBuffer = '';
     stderr = '';
     constructor(options) {
@@ -21,6 +23,7 @@ export class CodexAppServerV2Client {
         this.cwd = options.cwd || process.cwd();
         this.timeoutMs = Number(options.timeoutMs || 20_000);
         this.currentTimeProvider = options.currentTimeProvider || (() => new Date());
+        this.approvalPolicy = options.approvalPolicy || {};
     }
     async initialize() {
         this.start();
@@ -36,18 +39,58 @@ export class CodexAppServerV2Client {
                 optOutNotificationMethods: []
             }
         });
-        this.notify('notifications/initialized', {});
+        this.notify('initialized', {});
         return result;
     }
     async listThreads(params = {}) {
         return await this.request('thread/list', normalizeThreadListParams(params));
     }
+    async startThread(params = {}) {
+        return await this.request('thread/start', params);
+    }
+    async resumeThread(params = {}) {
+        return await this.request('thread/resume', params);
+    }
     async searchThreads(searchTerm, params = {}) {
         return await this.listThreads({ ...params, searchTerm });
     }
     async readThread(threadId, includeTurns = false) {
         return await this.request('thread/read', { threadId, includeTurns });
     }
+    async startTurn(params = {}) {
+        return await this.request('turn/start', params);
+    }
+    async steerTurn(params = {}) {
+        return await this.request('turn/steer', params);
+    }
+    async interruptTurn(params = {}) {
+        return await this.request('turn/interrupt', params);
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    waitForNotification(methods, timeoutMs = this.timeoutMs) {
+        const expected = new Set(Array.isArray(methods) ? methods.map(String) : [String(methods)]);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                dispose();
+                reject(new Error(`Timed out waiting for app-server notification: ${Array.from(expected).join(', ')}`));
+            }, timeoutMs);
+            timer.unref?.();
+            const dispose = this.onEvent((event) => {
+                if (event && expected.has(String(event.method || ''))) {
+                    clearTimeout(timer);
+                    dispose();
+                    resolve(event);
+                }
+            });
+        });
+    }
+    async waitForTurnCompletion(threadId, turnId, timeoutMs = this.timeoutMs) {
+        const expected = turnId ? ['turn/completed', 'thread/closed', 'thread/status/changed'] : ['turn/completed', 'thread/closed'];
+        return await this.waitForNotification(expected, timeoutMs);
+    }
     start() {
         if (this.child)
             return;
@@ -107,7 +150,14 @@ export class CodexAppServerV2Client {
                 void this.respondToServerRequest(message);
             }
             else {
-                this.notifications.push({ ...message, received_at: nowIso() });
+                const event = { ...message, received_at: nowIso() };
+                this.notifications.push(event);
+                for (const listener of this.listeners) {
+                    try {
+                        listener(event);
+                    }
+                    catch { }
+                }
             }
         }
     }
@@ -119,6 +169,38 @@ export class CodexAppServerV2Client {
                 this.write({ jsonrpc: '2.0', id, result: currentTimeResponse(this.currentTimeProvider()) });
                 return;
             }
+            if (method === 'item/commandExecution/requestApproval' || method === 'commandExecution/requestApproval') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.commandExecution?.(message.params) || { decision: 'cancel' } });
+                return;
+            }
+            if (method === 'item/fileChange/requestApproval' || method === 'fileChange/requestApproval') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.fileChange?.(message.params) || { decision: 'cancel' } });
+                return;
+            }
+            if (method === 'item/permissions/requestApproval' || method === 'permissions/requestApproval') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.permissions?.(message.params) || { permissions: { network: { enabled: false }, fileSystem: { read: [], write: [], entries: [] } }, scope: 'turn', strictAutoReview: true } });
+                return;
+            }
+            if (method === 'item/tool/requestUserInput') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.toolRequestUserInput?.(message.params) || { answers: {} } });
+                return;
+            }
+            if (method === 'item/tool/call') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.dynamicToolCall?.(message.params) || { contentItems: [], success: false } });
+                return;
+            }
+            if (method === 'mcpServer/elicitation/request') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.mcpElicitation?.(message.params) || { contentItems: [], success: false } });
+                return;
+            }
+            if (method === 'attestation/generate') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.attestation?.(message.params) || { decision: 'cancel' } });
+                return;
+            }
+            if (method === 'account/chatgptAuthTokens/refresh') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.chatgptAuthTokensRefresh?.(message.params) || { ok: false } });
+                return;
+            }
             this.write({
                 jsonrpc: '2.0',
                 id,
@@ -182,6 +264,8 @@ export async function createCodexAppServerV2Client(options = {}) {
         clientOptions.timeoutMs = options.timeoutMs;
     if (options.currentTimeProvider !== undefined)
         clientOptions.currentTimeProvider = options.currentTimeProvider;
+    if (options.approvalPolicy !== undefined)
+        clientOptions.approvalPolicy = options.approvalPolicy;
     return {
         client: new CodexAppServerV2Client(clientOptions),
         runtimeIdentity: runtime.identity

package/dist/core/codex-control/codex-reliability-shield.js

@@ -37,6 +37,7 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
             break;
     }
     const blockers = attempts.flatMap((attempt) => attempt.blockers);
+    const modelCapacityRetryCount = attempts.filter((attempt) => attempt.model_capacity_error && attempt.retryable).length;
     const report = {
         schema: CODEX_RELIABILITY_SHIELD_SCHEMA,
         generated_at: nowIso(),
@@ -52,6 +53,8 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
         heartbeat_count: attempts.reduce((sum, attempt) => sum + attempt.heartbeat_count, 0),
         repaired_tool_result_count: attempts.reduce((sum, attempt) => sum + attempt.repaired_tool_result_count, 0),
         no_duplicate_streamed_output: attempts.slice(0, -1).every((attempt) => attempt.meaningful_event_count === 0),
+        model_capacity_retry_count: modelCapacityRetryCount,
+        selected_model_capacity_fallback: selectedAttempt > 1 && modelCapacityRetryCount > 0,
         blockers
     };
     return {
@@ -61,24 +64,27 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
 }
 export function evaluateCodexReliabilityAttempt(result, events, policy, attempt) {
     const meaningful = events.filter(isMeaningfulEvent);
-    const fatal = hasFatalError(result, events);
+    const modelCapacity = isCodexModelCapacityError(result, events);
+    const fatal = !modelCapacity && hasFatalError(result, events);
     const idle = hasIdleTimeout(events, policy.idleTimeoutMs);
     const empty = events.length === 0 || (!String(result.finalResponse || '').trim() && meaningful.length === 0);
     const partial = meaningful.length > 0 && !result.structuredOutput;
     const blockers = [];
     let retryable = false;
     let retryReason = null;
-    if (idle && partial)
+    if (modelCapacity)
+        blockers.push('codex_model_capacity_unavailable');
+    if (!modelCapacity && idle && partial)
         blockers.push('codex_reliability_idle_after_partial_output');
-    if (partial && !idle)
+    if (!modelCapacity && partial && !idle)
         blockers.push('codex_reliability_partial_output_without_structured_result');
     if (fatal)
         blockers.push('codex_reliability_fatal_error_no_retry');
-    if (!fatal && idle && meaningful.length === 0) {
+    if (!modelCapacity && !fatal && idle && meaningful.length === 0) {
         retryable = true;
         retryReason = 'stream_idle_before_meaningful_event';
     }
-    else if (!fatal && empty) {
+    else if (!modelCapacity && !fatal && empty) {
         retryable = true;
         retryReason = 'empty_sdk_result_before_meaningful_event';
     }
@@ -92,11 +98,26 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
         retry_reason: retryReason,
         idle_timeout: idle,
         fatal_error: fatal,
+        model_capacity_error: modelCapacity,
+        capacity_fallback_hint: null,
         repaired_tool_result_count: 0,
         heartbeat_count: 0,
         blockers
     };
 }
+export function isCodexModelCapacityError(result, events) {
+    const text = [
+        String(result.finalResponse || ''),
+        ...(Array.isArray(result.blockers) ? result.blockers : []),
+        ...events.map((event) => [
+            event?.error?.message,
+            event?.message,
+            event?.item?.text,
+            event?.raw?.failed_event?.error?.message
+        ].filter(Boolean).join('\n'))
+    ].join('\n');
+    return /selected model is at capacity|model(?:\s+[\w.-]+)?\s+is\s+at\s+capacity|try a different model|capacity(?:\s+is)?\s+exhausted|temporarily at capacity/i.test(text);
+}
 export function repairToolCallSequence(events) {
     const repaired = [...events];
     const openToolCalls = new Set();

package/dist/core/codex-control/codex-task-runner.js

@@ -118,6 +118,8 @@ export async function runCodexTask(input) {
         patchEnvelopePath,
         blockers: finalBlockers,
         reliabilityShield: adapterResult?.reliabilityShield || null,
+        capacityFallback: adapterResult?.reliabilityShield?.selected_model_capacity_fallback === true,
+        modelCapacityRetryCount: Number(adapterResult?.reliabilityShield?.model_capacity_retry_count || 0),
         ultraRouterDecision: routerDecision,
         outputSchemaId: task.outputSchemaId,
         finalResponse: adapterResult?.finalResponse || '',
@@ -146,7 +148,11 @@ export async function runCodexTask(input) {
         result,
         capability: capability,
         sandbox,
-        envProof: runtime.env.proof,
+        envProof: {
+            ...runtime.env.proof,
+            capacity_fallback_selected: result.capacityFallback === true,
+            model_capacity_retry_count: result.modelCapacityRetryCount
+        },
         config: runtime.config,
         reliabilityShield: adapterResult?.reliabilityShield || null,
         routerDecision: routerDecision,

package/dist/core/codex-control/model-call-concurrency.js

@@ -56,7 +56,7 @@ export function defaultModelCallBudget(provider) {
     const text = String(provider || '');
     if (text === 'local-llm' || text === 'ollama')
         return envInt('SKS_LOCAL_LLM_MAX_PARALLEL_REQUESTS', 4);
-    return envInt('SKS_REMOTE_API_PARALLEL_BUDGET', 12);
+    return envInt('SKS_REMOTE_API_PARALLEL_BUDGET', 3);
 }
 class ModelCallSemaphoreImpl {
     provider;

package/dist/core/commands/qa-loop-command.js

@@ -17,6 +17,8 @@ import { runCodexAppHandoff, qaLoopShouldRequestAppHandoff } from '../codex-app/
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodexAccountUsageArtifacts } from '../usage/codex-account-usage.js';
 import { buildQaLoopBudgetPolicy, selectQaLoopEscalatedEffort } from '../qa-loop/qa-loop-budget-policy.js';
+import { initializeQaRuntimeArtifacts } from '../qa-loop/qa-runtime-artifacts.js';
+import { DEFAULT_QA_MAX_CYCLES, QA_SURFACE_SELECTION_ARTIFACT } from '../qa-loop/qa-types.js';
 import { writeCodexModelEffortCapabilityArtifact } from '../codex-control/codex-model-capabilities.js';
 import { discoverImageArtifactsInDir, writeImageArtifactPathContract } from '../image/image-artifact-path-contract.js';
 import { pluginAppTemplatePolicy } from '../codex-plugins/codex-plugin-json.js';
@@ -41,7 +43,7 @@ export async function qaLoopCommand(sub, args = []) {
 Usage:
   sks qa-loop prepare "target"
   sks qa-loop answer <mission-id|latest> <answers.json>
-  sks qa-loop run <mission-id|latest> [--mock] [--max-cycles N] [--app-handoff] [--app-handoff-required] [--app-handoff-launch] [--app-handoff-artifact-only]
+  sks qa-loop run <mission-id|latest> [--mock] [--max-cycles N] [--surface auto|codex_in_app_browser|codex_chrome_extension|codex_computer_use] [--report-only] [--app-handoff] [--app-handoff-required] [--app-handoff-launch] [--app-handoff-artifact-only]
   sks qa-loop app-confirm <mission-id|latest> --verdict pass|fail --notes "..."
   sks qa-loop status <mission-id|latest> [--desktop]
 `);
@@ -126,6 +128,17 @@ async function qaLoopRun(args) {
         await writeQaLoopArtifacts(dir, mission, contract);
     else
         await ensureQaLoopVisualEvidenceContract(dir, mission, contract);
+    const requestedSurface = readFlagValue(args, '--surface', 'auto');
+    const reportOnly = flag(args, '--report-only');
+    await initializeQaRuntimeArtifacts(dir, {
+        ...contract,
+        prompt: mission.prompt || contract.prompt,
+        mission_id: id
+    }, {
+        missionId: id,
+        requestedSurface,
+        reportOnly
+    }).catch(() => null);
     const safetyScan = await scanDbSafety(root);
     if (!safetyScan.ok) {
         console.error('QA-LOOP cannot run: SKS safety scan found unsafe project data-tool configuration.');
@@ -133,7 +146,7 @@ async function qaLoopRun(args) {
         process.exitCode = 2;
         return;
     }
-    const fallbackCycles = Number.parseInt(contract.answers?.MAX_QA_CYCLES, 10) || 8;
+    const fallbackCycles = Number.parseInt(contract.answers?.MAX_QA_CYCLES, 10) || DEFAULT_QA_MAX_CYCLES;
     const maxCycles = readMaxCycles(args, fallbackCycles);
     const requestedAgents = readBoundedIntegerFlag(args, '--agents', 3, 1, 20);
     const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', requestedAgents, 1, 20);
@@ -141,15 +154,18 @@ async function qaLoopRun(args) {
     const minimumWorkItems = readBoundedIntegerFlag(args, '--minimum-work-items', targetActiveSlots, 1, 200);
     const maxQueueExpansion = readBoundedIntegerFlag(args, '--max-queue-expansion', 10, 0, 200);
     const profile = readFlagValue(args, '--profile', 'sks-logic-high') || 'sks-logic-high';
-    const writeMode = readFlagValue(args, '--write-mode', flag(args, '--parallel-write') ? 'parallel' : 'off');
-    const applyPatches = flag(args, '--apply-patches');
+    const mock = flag(args, '--mock');
+    const sourceFixesEnabled = !reportOnly;
+    const writeMode = readFlagValue(args, '--write-mode', sourceFixesEnabled && !mock ? (flag(args, '--parallel-write') ? 'parallel' : 'proof-safe') : 'off');
+    const applyPatches = sourceFixesEnabled && !mock && !flag(args, '--no-fix');
     const dryRunPatches = flag(args, '--dry-run-patches') || flag(args, '--dryrun-patches');
     const maxWriteAgents = readBoundedIntegerFlag(args, '--max-write-agents', Math.min(requestedAgents, 5), 1, 20);
-    const mock = flag(args, '--mock');
     const qaGate = await readJson(path.join(dir, 'qa-gate.json'), {});
     const reportFile = qaGate.qa_report_file;
     const executionProfile = await readJson(path.join(dir, 'qa-loop', 'execution-profile.json'), null);
     const uiRequired = qaUiRequired(contract.answers || {});
+    const surfaceSelection = await readJson(path.join(dir, QA_SURFACE_SELECTION_ARTIFACT), null);
+    const selectedSurface = surfaceSelection?.selected_surface || null;
     const gptImage2ReviewRequired = qaGptImage2AnnotatedReviewRequired(contract, mission.prompt);
     const capabilityArtifact = await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), report: null }));
     const usageArtifact = await writeCodexAccountUsageArtifacts(root, { missionId: id }).catch((err) => ({ error: err?.message || String(err), snapshot: null }));
@@ -246,7 +262,7 @@ async function qaLoopRun(args) {
             return;
         }
     }
-    if (uiRequired && !mock) {
+    if (uiRequired && !mock && selectedSurface === 'codex_chrome_extension') {
         const chrome = await codexChromeExtensionStatus();
         if (!chrome.ok) {
             const blockedGate = {
@@ -277,7 +293,7 @@ async function qaLoopRun(args) {
             await setCurrent(root, { mission_id: id, mode: 'QALOOP', phase: 'QALOOP_BLOCKED_CHROME_EXTENSION_SETUP_REQUIRED', questions_allowed: true });
             if (flag(args, '--json'))
                 return console.log(JSON.stringify({ schema: 'sks.qa-loop-run.v1', ok: false, status: 'blocked', blocker: 'codex_chrome_extension_setup_required', mission_id: id, chrome_extension: chrome, gate: blockedGate }, null, 2));
-            console.error('QA-LOOP blocked: install/enable the Codex Chrome Extension first, then tell SKS installation is complete before resuming.');
+            console.error('QA-LOOP blocked: this journey was routed to @Chrome, but the Codex Chrome Extension is not connected. Install/enable it, then resume.');
             console.error(chrome.docs_url);
             process.exitCode = 2;
             return;

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '4.2.0';
+export const PACKAGE_VERSION = '4.4.0';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/hooks-runtime.js

@@ -590,7 +590,7 @@ function clarificationAnswerToolAllowed(payload = {}) {
         return true;
     if (/\bpipeline\s+answer\b/i.test(command))
         return true;
-    return !/\b(npm|git|selftest|packcheck|release:check|publish:dry|publish:npm|doctor|team|qa-loop|wiki|db|test)\b/i.test(command);
+    return !/\b(npm|git|selftest|packcheck|release:check|publish:dry|publish:ignore-scripts|publish:npm|doctor|team|qa-loop|wiki|db|test)\b/i.test(command);
 }
 function payloadMentionsAnswersJson(payload = {}) {
     try {

package/dist/core/qa-loop/qa-app-server-driver.js

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
+import { QA_ACTION_LEDGER_ARTIFACT, QA_LIVE_SESSION_ARTIFACT, QA_RUNTIME_EVENT_LEDGER_ARTIFACT } from './qa-types.js';
+export async function runQaAppServerDriver(input) {
+    const events = [];
+    const dispose = input.client.onEvent?.((event) => {
+        events.push(event);
+    });
+    const startedAt = nowIso();
+    const blockers = [];
+    let threadId = null;
+    let turnId = null;
+    try {
+        await input.client.initialize?.();
+        const thread = await input.client.startThread({
+            cwd: input.cwd,
+            ...input.threadStartParams
+        });
+        threadId = extractThreadId(thread);
+        if (!threadId)
+            blockers.push('app_server_thread_id_missing');
+        if (threadId) {
+            const turn = await input.client.startTurn({
+                threadId,
+                cwd: input.cwd,
+                input: [{ type: 'text', text: input.prompt }],
+                ...input.turnStartParams
+            });
+            turnId = extractTurnId(turn);
+            if (!turnId)
+                blockers.push('app_server_turn_id_missing');
+            if (input.client.waitForTurnCompletion) {
+                const completed = await input.client.waitForTurnCompletion(threadId, turnId, input.timeoutMs);
+                events.push({ method: 'turn/completed', params: completed, received_at: nowIso() });
+            }
+        }
+    }
+    catch (err) {
+        blockers.push(`app_server_driver_failed:${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        dispose?.();
+    }
+    await writeAppServerEventLedgers(input.missionDir, input.missionId, input.surfaceSelection.selected_surface, threadId, turnId, events);
+    const session = {
+        schema: 'sks.qa-loop-live-session.v2',
+        started_at: startedAt,
+        completed_at: nowIso(),
+        mission_id: input.missionId,
+        status: blockers.length ? 'blocked' : 'completed',
+        selected_surface: input.surfaceSelection.selected_surface,
+        thread_id: threadId,
+        turn_id: turnId,
+        event_count: events.length,
+        item_event_count: events.filter(isItemEvent).length,
+        action_event_count: events.filter(isActionLikeEvent).length,
+        observation_event_count: events.filter(isObservationLikeEvent).length,
+        blockers,
+        unverified: events.some(isActionLikeEvent) ? [] : ['app_server_action_event_unverified'],
+        artifacts: {
+            runtime_events: QA_RUNTIME_EVENT_LEDGER_ARTIFACT,
+            action_ledger: QA_ACTION_LEDGER_ARTIFACT
+        }
+    };
+    await writeJsonAtomic(path.join(input.missionDir, QA_LIVE_SESSION_ARTIFACT), session);
+    return session;
+}
+async function writeAppServerEventLedgers(missionDir, missionId, surface, threadId, turnId, events) {
+    for (const event of events) {
+        const method = String(event.method || event.type || event.params?.method || 'app_server_event');
+        await appendJsonlBounded(path.join(missionDir, QA_RUNTIME_EVENT_LEDGER_ARTIFACT), {
+            schema: 'sks.qa-loop-app-server-event.v2',
+            ts: nowIso(),
+            mission_id: missionId,
+            thread_id: event.params?.threadId || event.threadId || threadId,
+            turn_id: event.params?.turnId || event.params?.turn?.id || event.turnId || turnId,
+            item_id: event.params?.itemId || event.params?.item?.id || event.itemId || null,
+            surface,
+            kind: method,
+            status: 'observed',
+            data: redactEvent(event)
+        });
+        if (isActionLikeEvent(event)) {
+            await appendJsonlBounded(path.join(missionDir, QA_ACTION_LEDGER_ARTIFACT), {
+                schema: 'sks.qa-loop-action.v2',
+                ts: nowIso(),
+                mission_id: missionId,
+                thread_id: event.params?.threadId || event.threadId || threadId,
+                turn_id: event.params?.turnId || event.params?.turn?.id || event.turnId || turnId,
+                item_id: event.params?.itemId || event.params?.item?.id || event.itemId || null,
+                surface,
+                kind: method,
+                status: 'observed',
+                real: true,
+                data: redactEvent(event)
+            });
+        }
+    }
+}
+function extractThreadId(value) {
+    const obj = value;
+    return stringOrNull(obj?.thread?.id || obj?.threadId || obj?.id);
+}
+function extractTurnId(value) {
+    const obj = value;
+    return stringOrNull(obj?.turn?.id || obj?.turnId || obj?.id);
+}
+function stringOrNull(value) {
+    const text = String(value || '').trim();
+    return text || null;
+}
+function isItemEvent(event) {
+    return /^item\//.test(String(event.method || event.type || ''));
+}
+function isActionLikeEvent(event) {
+    const method = String(event.method || event.type || '');
+    return /^item\/.*(?:tool|action|commandExecution|computer|browser|chrome)/i.test(method)
+        || /(?:tool|action|click|type|scroll|navigate|screenshot|observation)/i.test(JSON.stringify(event.params || event));
+}
+function isObservationLikeEvent(event) {
+    const method = String(event.method || event.type || '');
+    return /observation|completed|screenshot|browser|chrome|computer/i.test(method)
+        || /observation|screenshot|visual|page|window/i.test(JSON.stringify(event.params || event));
+}
+function redactEvent(event) {
+    return JSON.parse(JSON.stringify(event, (key, value) => {
+        if (/(password|passwd|token|secret|cookie|authorization|credential)/i.test(String(key)))
+            return '[REDACTED]';
+        if (typeof value === 'string' && /(Bearer\s+[A-Za-z0-9._-]+|sk-[A-Za-z0-9_-]+)/.test(value))
+            return '[REDACTED]';
+        return value;
+    }));
+}
+//# sourceMappingURL=qa-app-server-driver.js.map