sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/codex-sdk-research-pipeline-check.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
+const researchCommand = readText('src/core/commands/research-command.ts');
+assertGate(researchCommand.includes("backend: mock ? 'fake' : 'codex-sdk'"), 'Research pipeline must default native agents to codex-sdk');
+assertGate(researchCommand.includes("flag(args, '--autoresearch') ? '$AutoResearch' : '$Research'"), 'Research/AutoResearch route selection missing');
+assertGate(researchCommand.includes('narutoWorkGraph: researchWorkGraph'), 'Research pipeline must pass the stage-aware Naruto work graph');
+assertGate(researchCommand.includes('readonly: true'), 'Research pipeline must force read-only native orchestration');
+assertGate(researchCommand.includes('quality_metrics'), 'Research pipeline JSON output must include quality metrics');
+assertGate(researchCommand.includes('const cycleResult = await runResearchCycle({'), 'Research default path must use runResearchCycle');
+assertGate(researchCommand.includes('--legacy-research-cycle'), 'Legacy final.md loop must be opt-in only');
+const researchCore = readText('src/core/research.ts');
+assertGate(researchCore.includes('readResearchQualityContract'), 'Research gate must read research-quality-contract.json');
+assertGate(researchCore.includes('claim_evidence_matrix_missing'), 'Research gate must require claim-evidence-matrix.json');
+assertGate(researchCore.includes('research_final_review_not_approved'), 'Research gate must require final reviewer approval');
+for (const [file, tokens] of Object.entries({
+    'src/core/research/research-work-graph.ts': ['buildResearchWorkGraph', 'source_shard_academic_literature'],
+    'src/core/research/research-cycle-runner.ts': ['runResearchCycle', 'Promise.race'],
+    'src/core/research/research-final-reviewer.ts': ['runResearchCodexFinalReviewer'],
+    'src/core/research/claim-evidence-matrix.ts': ['claim-evidence-matrix'],
+    'src/core/research/implementation-blueprint.ts': ['implementation-blueprint'],
+    'src/core/research/research-quality-contract.ts': ['research-quality-contract']
+})) {
+    const text = readText(file);
+    for (const token of tokens)
+        assertGate(text.includes(token), `${file} missing token ${token}`);
+}
+const research = await importDist('core/research.js');
+const fsx = await importDist('core/fsx.js');
+const dirShort = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-short-'));
+const planShort = await research.writeResearchPlan(dirShort, 'codex sdk short rejection fixture', { missionId: 'M-CODEX-SHORT' });
+await fsx.writeTextAtomic(path.join(dirShort, 'research-report.md'), `# Short Report\n\n${Array.from({ length: 300 }, (_unused, index) => `word${index}`).join(' ')}\n`);
+await fsx.writeJsonAtomic(path.join(dirShort, 'source-ledger.json'), { schema_version: 1, web_search_passes: 1, source_layers: [], sources: [], counterevidence_sources: [], triangulation: { cross_layer_checks: [] }, citation_coverage: { all_key_claims_cited: false }, blockers: [] });
+await fsx.writeJsonAtomic(path.join(dirShort, 'implementation-blueprint.json'), { schema: 'sks.research-implementation-blueprint.v1', sections: [] });
+const shortGate = await research.evaluateResearchGate(dirShort);
+assertGate(shortGate.passed === false, 'codex-sdk research pipeline must reject short report fixture', shortGate);
+assertGate((shortGate.reasons || []).includes('research_report_too_short'), 'short rejection must include report length reason', shortGate);
+const dirComplete = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-complete-'));
+const planComplete = await research.writeResearchPlan(dirComplete, 'codex sdk complete package fixture', { missionId: 'M-CODEX-COMPLETE' });
+const completeGate = await research.writeMockResearchResult(dirComplete, planComplete);
+assertGate(completeGate.passed === true, 'codex-sdk research pipeline must pass complete package fixture', completeGate);
+assertGate(completeGate.metrics?.final_review_approved === true, 'complete package must include approved final review', completeGate.metrics);
+emitGate('codex-sdk:research-pipeline', { route: '$Research', short_dir: dirShort, complete_dir: dirComplete });
+//# sourceMappingURL=codex-sdk-research-pipeline-check.js.map

package/dist/scripts/codex-sdk-sandbox-policy-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-sdk-sandbox-policy.js');
+const base = {
+    route: '$Agent',
+    missionId: 'M-sandbox',
+    cwd: process.cwd(),
+    prompt: 'sandbox fixture',
+    outputSchemaId: 'sks.agent-worker-result.v1',
+    outputSchema: {},
+    mutationLedgerRoot: process.cwd()
+};
+const readOnly = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'read-only', requestedScopeContract: { read_only: true } });
+const workspace = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'workspace-write', requestedScopeContract: { read_only: false, allowed_paths: ['tmp'], write_paths: ['tmp'] } });
+const fullBlocked = mod.mapCodexSdkSandboxPolicy({ ...base, sandboxPolicy: 'full-access', requestedScopeContract: { read_only: false } });
+assertGate(readOnly.ok && readOnly.sandboxMode === 'read-only', 'read-only sandbox mapping failed', readOnly);
+assertGate(workspace.ok && workspace.sandboxMode === 'workspace-write', 'workspace-write sandbox mapping failed', workspace);
+assertGate(!fullBlocked.ok && fullBlocked.blockers.includes('codex_sdk_full_access_requires_explicit_mad_scope'), 'full-access must require explicit authorization', fullBlocked);
+emitGate('codex-sdk:sandbox-policy', { read_only: readOnly.sandboxMode, workspace: workspace.sandboxMode, full_blockers: fullBlocked.blockers });
+//# sourceMappingURL=codex-sdk-sandbox-policy-check.js.map

package/dist/scripts/codex-sdk-structured-output-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, runFakeCodexSdkTaskFixture } from './lib/codex-sdk-gate-lib.js';
+const fixture = await runFakeCodexSdkTaskFixture('structured-output');
+assertGate(fixture.result.ok === true, 'Codex SDK fake run must pass', fixture.result);
+assertGate(fixture.result.structuredOutputValid === true, 'structured output must validate', fixture.result);
+assertGate(fixture.worker.backend === 'codex-sdk', 'worker backend must be codex-sdk', fixture.worker);
+assertGate(fixture.worker.verification?.checks?.includes('sks.agent-worker-result.v1'), 'worker verification must reference output schema', fixture.worker);
+emitGate('codex-sdk:structured-output', { output_schema_id: fixture.proof.output_schema_id, structured_output_valid: fixture.result.structuredOutputValid });
+//# sourceMappingURL=codex-sdk-structured-output-check.js.map

package/dist/scripts/codex-sdk-team-naruto-agent-pipeline-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const team = readText('src/core/commands/team-command.ts');
+const naruto = readText('src/core/commands/naruto-command.ts');
+const agent = readText('src/core/agents/agent-command-surface.ts');
+assertGate(team.includes('redirectTeamCreateToNaruto') && team.includes('narutoCommand'), 'Team create must redirect to Naruto codex-sdk SSOT');
+assertGate(naruto.includes("backend: 'codex-sdk'"), 'Naruto help/defaults must expose codex-sdk');
+assertGate(agent.includes("useLocalModel && !noOllama") && agent.includes("'local-llm'") && agent.includes("useOllamaProtocol && !noOllama"), 'Agent command surface must route --local-model to local-llm and --ollama to ollama explicitly');
+assertGate(agent.includes('backendExplicit'), 'Agent command surface must preserve explicit backend/local-model intent');
+emitGate('codex-sdk:team-naruto-agent-pipeline', { routes: ['$Team', '$Naruto', '$Agent'] });
+//# sourceMappingURL=codex-sdk-team-naruto-agent-pipeline-check.js.map

package/dist/scripts/codex-sdk-thread-registry-check.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, runFakeCodexSdkTaskFixture } from './lib/codex-sdk-gate-lib.js';
+const fixture = await runFakeCodexSdkTaskFixture('thread-registry', { zellijPaneId: 'pane-42' });
+const thread = fixture.registry.threads[0] || {};
+assertGate(fixture.registry.thread_count === 1, 'thread registry must record one thread', fixture.registry);
+assertGate(thread.sdk_thread_id === fixture.result.sdkThreadId, 'thread registry sdk_thread_id mismatch', { thread, result: fixture.result });
+assertGate(thread.zellij_pane_id === 'pane-42', 'thread registry must link zellij pane id when present', thread);
+assertGate(thread.output_schema_id === 'sks.agent-worker-result.v1', 'thread registry output schema mismatch', thread);
+emitGate('codex-sdk:thread-registry', { thread_count: fixture.registry.thread_count, sdk_thread_id: thread.sdk_thread_id });
+//# sourceMappingURL=codex-sdk-thread-registry-check.js.map

package/dist/scripts/codex-sdk-ux-ppt-review-pipeline-check.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, packageScripts } from './lib/codex-sdk-gate-lib.js';
+const scripts = packageScripts();
+assertGate(Boolean(scripts['ux-review:imagegen-blackbox']), 'UX review imagegen blackbox gate missing');
+assertGate(Boolean(scripts['ppt:imagegen-blackbox']), 'PPT imagegen blackbox gate missing');
+assertGate(Boolean(scripts['ux-ppt:structured-extraction']), 'UX/PPT structured extraction gate missing');
+emitGate('codex-sdk:ux-ppt-review-pipeline', { gates: ['ux-review:imagegen-blackbox', 'ppt:imagegen-blackbox', 'ux-ppt:structured-extraction'] });
+//# sourceMappingURL=codex-sdk-ux-ppt-review-pipeline-check.js.map

package/dist/scripts/codex-sdk-version-compat-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readJson } from './sks-1-18-gate-lib.js';
+const pkg = readJson('package.json');
+const lock = readJson('package-lock.json');
+const dep = pkg.dependencies?.['@openai/codex-sdk'];
+const lockDep = lock.packages?.['node_modules/@openai/codex-sdk']?.version;
+assertGate(dep === '0.142.0' && lockDep === '0.142.0', '@openai/codex-sdk must be pinned to 0.142.0 compatibility in package and lockfile', { dep, lockDep });
+emitGate('codex-sdk:version-compat', { dependency: dep, lock_version: lockDep });
+//# sourceMappingURL=codex-sdk-version-compat-check.js.map

package/dist/scripts/codex-sdk-zellij-pane-binding-check.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText, runFakeCodexSdkTaskFixture } from './lib/codex-sdk-gate-lib.js';
+const fixture = await runFakeCodexSdkTaskFixture('zellij-binding', { zellijPaneId: 'pane-999' });
+const swarmSource = readText('src/core/agents/native-cli-session-swarm.ts');
+const proofSource = readText('src/core/agents/agent-slot-pane-binding-proof.ts');
+const managerSource = readText('src/core/zellij/zellij-worker-pane-manager.ts');
+assertGate(fixture.proof.zellij_pane_id === 'pane-999', 'control proof must link zellij pane id', fixture.proof);
+assertGate(swarmSource.includes('codex_sdk_thread_started'), 'swarm must emit SDK thread event');
+assertGate(proofSource.includes('worker_codex_sdk') && proofSource.includes('slot_status_renderer'), 'slot-pane proof must accept worker command panes and compact slot renderer panes');
+assertGate(managerSource.includes('slot_status_renderer') && managerSource.includes('worker_codex_sdk'), 'worker pane manager must distinguish slot renderer and worker command pane kinds');
+emitGate('codex-sdk:zellij-pane-binding', { zellij_pane_id: fixture.proof.zellij_pane_id, sdk_thread_id: fixture.proof.sdk_thread_id });
+//# sourceMappingURL=codex-sdk-zellij-pane-binding-check.js.map

package/dist/scripts/codex-skill-rich-content-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
+await runDirective315Gate('codex-app:skill-rich-content');
+//# sourceMappingURL=codex-skill-rich-content-check.js.map

package/dist/scripts/codex-skill-sync-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('codex-app:skill-sync');
+//# sourceMappingURL=codex-skill-sync-check.js.map

package/dist/scripts/codex-thread-runtime-choice-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const runner = readText('src/core/codex-control/codex-task-runner.ts');
+const registry = readText('src/core/codex-control/codex-thread-registry.ts');
+assertGate(runner.includes('backendPreference'), 'Codex task runner must carry backend/runtime preference');
+assertGate(runner.includes('backend_family'), 'Codex task runner must persist backend family');
+assertGate(registry.includes('recordCodexThread'), 'Codex thread registry missing');
+emitGate('codex:thread-runtime-choice', { runtime_choice: 'backendPreference/backend_family' });
+//# sourceMappingURL=codex-thread-runtime-choice-check.js.map

package/dist/scripts/codex-web-adapter-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex/codex-web-search-adapter.js');
+const available = mod.detectCodexWebSearchCapability({ env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' } });
+const offline = mod.detectCodexWebSearchCapability({ offline: true });
+const evidence = await mod.runCodexWebSearch('fixture', { search: async () => [{ title: 'result', url: 'https://example.com' }], env: { SKS_CODEX_WEB_SEARCH_AVAILABLE: '1' } });
+assertGate(available.available === true, 'Codex Web capability env detector must pass');
+assertGate(offline.status === 'disabled_offline', 'offline mode must disable web search with reason');
+assertGate(evidence.ok === true && evidence.normalized_results.length === 1, 'Codex Web adapter must normalize results');
+emitGate('codex-web:adapter', { status: evidence.status, results: evidence.normalized_results.length });
+//# sourceMappingURL=codex-web-adapter-check.js.map

package/dist/scripts/computer-use-live-evidence-check.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runProcess } from '../core/fsx.js';
+const entry = './dist/bin/sks.js';
+const probe = await runProcess(process.execPath, [entry, 'computer-use', 'smoke', '--json'], {
+    env: { ...process.env, CI: 'true', SKS_TEST_REAL_COMPUTER_USE: '' },
+    timeoutMs: 20_000,
+    maxOutputBytes: 256 * 1024
+});
+const real = await runProcess(process.execPath, [entry, 'computer-use', 'smoke', '--real', '--capture-screenshot', '--json'], {
+    env: { ...process.env, CI: 'true', SKS_TEST_REAL_COMPUTER_USE: '' },
+    timeoutMs: 20_000,
+    maxOutputBytes: 256 * 1024
+});
+const probeJson = parseJson(probe.stdout);
+const realJson = parseJson(real.stdout);
+const text = `${probe.stdout}\n${probe.stderr}\n${real.stdout}\n${real.stderr}`;
+const forbidden = /mock.*live|fabricated|Computer Use blocked by safety policy|MAD-SKS disabled Computer Use/i.test(text);
+const ok = probe.code === 0
+    && probeJson.schema === 'sks.computer-use-live-smoke.v2'
+    && probeJson.evidence_mode === 'probe_only'
+    && probeJson.mock === false
+    && realJson.schema === 'sks.computer-use-live-smoke.v2'
+    && ['probe_only', 'live_capture_attempted', 'live_capture_success', 'live_capture_blocked'].includes(realJson.evidence_mode)
+    && realJson.mock === false
+    && Boolean(realJson.live_evidence_path)
+    && forbidden === false;
+console.log(JSON.stringify({
+    schema: 'sks.computer-use-live-evidence-check.v1',
+    ok,
+    probe: {
+        code: probe.code,
+        status: probeJson.status || null,
+        evidence_mode: probeJson.evidence_mode || null
+    },
+    real: {
+        code: real.code,
+        status: realJson.status || null,
+        evidence_mode: realJson.evidence_mode || null,
+        live_evidence_path: realJson.live_evidence_path || null,
+        image_voxel_linked: realJson.image_voxel_linked === true
+    },
+    forbidden_wording: forbidden
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=computer-use-live-evidence-check.js.map

package/dist/scripts/computer-use-live-optional-check.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runProcess } from '../core/fsx.js';
+const entry = './dist/bin/sks.js';
+const result = await runProcess(process.execPath, [entry, 'computer-use', 'smoke', '--json'], {
+    env: { ...process.env, CI: 'true', SKS_TEST_REAL_COMPUTER_USE: '' },
+    timeoutMs: 20_000,
+    maxOutputBytes: 256 * 1024
+});
+const text = `${result.stdout}\n${result.stderr}`;
+let parsed = {};
+try {
+    parsed = JSON.parse(result.stdout);
+}
+catch { }
+const structuredStatus = ['available', 'codex_app_missing', 'macos_permission_missing', 'codex_app_capability_missing', 'external_capability_blocked', 'not_macos', 'unknown'].includes(parsed.status);
+const ok = result.code === 0
+    && parsed.schema === 'sks.computer-use-live-smoke.v2'
+    && parsed.ok === true
+    && structuredStatus
+    && parsed.mock === false
+    && !/Computer Use blocked by safety policy|MAD-SKS disabled Computer Use|Computer Use access is unsafe/i.test(text);
+console.log(JSON.stringify({
+    schema: 'sks.computer-use-live-optional-check.v1',
+    ok,
+    status: parsed.status || null,
+    mode: parsed.evidence_mode || parsed.mode || null,
+    structured_status: structuredStatus
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=computer-use-live-optional-check.js.map

package/dist/scripts/computer-use-policy-check.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runProcess } from '../core/fsx.js';
+const entry = './dist/bin/sks.js';
+const status = await runProcess(process.execPath, [entry, 'computer-use', 'status', '--json'], {
+    env: { ...process.env, CI: 'true' },
+    timeoutMs: 20_000,
+    maxOutputBytes: 256 * 1024
+});
+const text = `${status.stdout}\n${status.stderr}`;
+const forbidden = [
+    /Computer Use blocked by safety policy/i,
+    /Computer Use access is unsafe/i,
+    /MAD-SKS disabled Computer Use/i,
+    /Computer Use 접근이 안전 정책상 차단/i
+].filter((pattern) => pattern.test(text)).map(String);
+let parsed = {};
+try {
+    parsed = JSON.parse(status.stdout);
+}
+catch { }
+const allowedStatus = ['available', 'codex_app_missing', 'macos_permission_missing', 'codex_app_capability_missing', 'external_capability_blocked', 'not_macos', 'unknown'];
+const ok = status.code === 0
+    && parsed.schema === 'sks.computer-use-status.v1'
+    && allowedStatus.includes(parsed.status)
+    && parsed.mad_sks_independent === true
+    && forbidden.length === 0;
+console.log(JSON.stringify({
+    schema: 'sks.computer-use-policy-check.v1',
+    ok,
+    status_code: status.code,
+    computer_use_status: parsed.status || null,
+    forbidden
+}, null, 2));
+if (!ok && forbidden.length)
+    await recordComputerUseWrongness(forbidden);
+if (!ok)
+    process.exitCode = 1;
+async function recordComputerUseWrongness(forbidden) {
+    const { addWrongnessRecord } = await import('../core/triwiki-wrongness/wrongness-ledger.js');
+    await addWrongnessRecord(process.cwd(), {
+        route: '$Computer-Use',
+        wrongness_kind: 'computer_use_policy_misclassification',
+        severity: 'high',
+        claim: { text: `Computer Use was described with forbidden safety/MAD-SKS block wording: ${forbidden.join(', ')}` },
+        detected_by: {
+            source: 'computer_use_policy_check',
+            command: 'npm run computer-use:policy-check',
+            artifact: 'dist/scripts/computer-use-policy-check.js',
+            detail: forbidden.join(', ')
+        },
+        root_cause: {
+            category: 'route_policy_gap',
+            explanation: 'Computer Use is a Codex App/macOS capability check, not a MAD-SKS or generic SKS safety block.'
+        },
+        corrective_action: {
+            summary: 'Separate Computer Use availability from safety policy wording and rerun the policy fixture.',
+            required_evidence: ['npm run computer-use:policy-check'],
+            patch_status: 'pending'
+        },
+        avoidance_rule: {
+            text: 'Do not classify macOS Computer Use as MAD-SKS or generic SKS safety block.',
+            applies_to: ['computer-use', '$Computer-Use', '$QA-LOOP', '$Image-UX-Review'],
+            severity: 'high'
+        },
+        links: { tests: ['npm run computer-use:policy-check'], files: ['dist/scripts/computer-use-policy-check.js'] }
+    });
+}
+//# sourceMappingURL=computer-use-policy-check.js.map

package/dist/scripts/computer-use-visual-route-fixture-check.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runProcess } from '../core/fsx.js';
+const entry = './dist/bin/sks.js';
+const routes = ['$Image-UX-Review', '$QA-LOOP', '$PPT', '$Computer-Use', '$From-Chat-IMG'];
+const results = [];
+for (const route of routes) {
+    const result = await runProcess(process.execPath, [entry, 'computer-use', 'require', '--route', route, '--json'], {
+        env: { ...process.env, CI: 'true' },
+        timeoutMs: 20_000,
+        maxOutputBytes: 256 * 1024
+    });
+    const text = `${result.stdout}\n${result.stderr}`;
+    let parsed = {};
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch { }
+    results.push({
+        route,
+        code: result.code,
+        schema: parsed.schema || null,
+        status: parsed.status || null,
+        ok_or_structured_blocker: parsed.ok === true || ['available', 'codex_app_missing', 'macos_permission_missing', 'codex_app_capability_missing', 'external_capability_blocked', 'not_macos', 'unknown', 'web_verification_uses_chrome_extension'].includes(parsed.status),
+        no_forbidden_wording: !/Computer Use blocked by safety policy|MAD-SKS disabled Computer Use|Computer Use access is unsafe/i.test(text),
+        evidence_status: parsed.evidence?.status || null
+    });
+}
+const ok = results.every((row) => row.schema === 'sks.computer-use-require.v1' && row.ok_or_structured_blocker && row.no_forbidden_wording);
+console.log(JSON.stringify({
+    schema: 'sks.computer-use-visual-route-fixture-check.v1',
+    ok,
+    results
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=computer-use-visual-route-fixture-check.js.map

package/dist/scripts/config-managed-merge-callsite-coverage-check.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const SCAN_DIRS = ['src/core', 'src/commands', 'src/cli'];
+const WRITE_CALL = /\b(?:writeTextAtomic|writeJsonAtomic|fs\.writeFile|fsp\.writeFile|writeFileSync|copyFile)\s*\(/;
+const PROTECTED_INDICATORS = [
+    ['codex-config-toml', /(?:config\.toml|generatedCodexConfigPath|codexLbConfigPath|\bconfigPath\b)/],
+    ['codex-auth-json', /(?:auth\.json|\bauthPath\b|codexAuthPath)/],
+    ['env-secret-file', /(?:(?:['"`][^'"`]*\.env[^'"`]*['"`])|sks-codex-lb\.env|\benvPath\b|status\.env_path|codexLbEnvPath)/],
+    ['mcp-json', /(?:mcp\.json|\bmcpPath\b|cursorMcpPath)/],
+    ['sneakoscope-config', /(?:\.sneakoscope\/config\.json|sneakoscopeConfigPath)/]
+];
+const ALLOWLIST = [
+    {
+        file: 'src/core/config/managed-config-merge.ts',
+        pattern: /writeTextAtomic|fs\.writeFile/,
+        reason: 'central managed config merge writer preserves protected keys and secret line hashes',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/config/secret-preservation.ts',
+        pattern: /writeTextAtomic|writeJsonAtomic|fs\.writeFile/,
+        reason: 'secret preservation guard backup, rollback, and sanitized report writer',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/init.ts',
+        pattern: /generatedCodexConfigPath|\.codex['"], ['"]SNEAKOSCOPE\.md|hooksPath|mergeManagedHookTrustStateToml/,
+        reason: 'setup/init harness writes run through setup-command or doctor-fix secret preservation guard',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/commands/doctor.ts',
+        pattern: /backupProjectConfigBeforeFix|writeTextAtomic|fsp\.writeFile|config_backup_path/,
+        reason: 'doctor --fix wraps runDoctor in secret preservation guard before project config repair',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/doctor/doctor-context7-repair.ts',
+        pattern: /backupConfig|writeTextAtomic|CONTEXT7_REMOTE_URL/,
+        reason: 'doctor Context7 repair writes a backup before replacing only the local stdio Context7 MCP block with the remote endpoint',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/doctor/doctor-codex-startup-repair.ts',
+        pattern: /backupConfig|writeTextAtomic|doctor-codex-startup-repair/,
+        reason: 'doctor startup repair writes backups before fixing stale Codex agent config_file paths and removing only missing-command MCP blocks',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/auto-review.ts',
+        pattern: /writeTextAtomic|writeProfileConfig|configPath/,
+        reason: 'auto-review profile migration rewrites bounded Codex profile tables while preserving non-profile config text',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/cli/context7-command.ts',
+        pattern: /writeTextAtomic|configPath/,
+        reason: 'explicit context7 setup appends non-secret MCP config and preserves existing secret lines',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/cli/xai-command.ts',
+        pattern: /writeTextAtomic|configPath/,
+        reason: 'explicit xAI setup appends MCP config and references env var names rather than raw secret values',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/cli/install-helpers.ts',
+        pattern: /writeTextAtomic|writeJsonAtomic|envPath|authPath|configPath|codexLbEnvPath|codexLbConfigPath|codexAuthPath/,
+        reason: 'postinstall/codex-lb setup callsites are covered by setup/update/doctor secret preservation guard fixtures',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/codex/codex-config-eperm-repair.ts',
+        pattern: /writeTextAtomic|configPath/,
+        reason: 'doctor config repair runs inside doctor-fix secret preservation guard',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/codex/agent-config-file-repair.ts',
+        pattern: /writeTextAtomic|configPath|missingAgentConfigFiles/,
+        reason: 'agent config_file repair rewrites only the project .codex/config.toml agent config_file paths and is covered by doctor/setup secret preservation fixtures',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/codex/codex-project-config-policy.ts',
+        pattern: /writeTextAtomic|configPath/,
+        reason: 'project config policy splitter preserves existing protected config content',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/codex-app/codex-app-fast-ui-repair.ts',
+        pattern: /writeTextAtomic|configPath/,
+        reason: 'Codex App fast UI repair is invoked from guarded doctor/setup flows',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/codex-control/codex-task-runner.ts',
+        pattern: /ensurePythonCodexLbConfig|CODEX_LB_API_KEY|config\.toml/,
+        reason: 'Python Codex task runner writes an isolated CODEX_HOME provider config referencing env_key only',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/codex-lb/codex-lb-setup.ts',
+        pattern: /installCodexLbShellProfileSnippet|upsertManagedBlock|envPath/,
+        reason: 'codex-lb shell profile setup writes a managed source block pointing at an env file, not the raw key',
+        expires: '3.2.0'
+    },
+    {
+        file: 'src/core/migration/migration-transaction-journal.ts',
+        pattern: /writeJsonAtomic|writeTextAtomic/,
+        reason: 'migration journal writes hashes and rollback metadata, not raw secret config values',
+        expires: '3.2.0'
+    }
+];
+const sources = listSourceFiles().map((file) => ({
+    file,
+    text: fs.readFileSync(path.join(root, file), 'utf8')
+}));
+const suspicious = findProtectedWriteCallsites(sources);
+const uncovered = suspicious.filter((callsite) => !allowFor(callsite));
+const negative = findProtectedWriteCallsites([{
+        file: 'fixture/unprotected-config-write.ts',
+        text: "await writeTextAtomic(path.join(root, '.codex', 'config.toml'), 'model = \"x\"\\n');\n"
+    }]);
+const report = {
+    schema: 'sks.config-managed-merge-callsite-coverage.v1',
+    ok: uncovered.length === 0 && negative.length === 1 && !allowFor(negative[0]),
+    scanned_dirs: SCAN_DIRS,
+    protected_write_callsites: suspicious.length,
+    allowlist_entries: ALLOWLIST.map((entry) => ({
+        file: entry.file,
+        pattern: String(entry.pattern),
+        reason: entry.reason,
+        expires: entry.expires
+    })),
+    uncovered,
+    negative_fixture_detected: negative.length === 1,
+    generated_at: new Date().toISOString()
+};
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'config-managed-merge-callsite-coverage.json'), `${JSON.stringify(report, null, 2)}\n`);
+assertGate(report.ok, 'managed config merge callsite coverage failed', report);
+emitGate('config:managed-merge-callsite-coverage', {
+    protected_write_callsites: suspicious.length,
+    allowlist_entries: ALLOWLIST.length
+});
+export function findProtectedWriteCallsites(files) {
+    const calls = [];
+    for (const sourceFile of files) {
+        const lines = sourceFile.text.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] || '';
+            if (!WRITE_CALL.test(line))
+                continue;
+            const window = lines.slice(Math.max(0, index - 3), Math.min(lines.length, index + 4)).join('\n');
+            const indicators = PROTECTED_INDICATORS.filter(([, pattern]) => pattern.test(window)).map(([name]) => name);
+            if (!indicators.length)
+                continue;
+            calls.push({
+                file: sourceFile.file,
+                line: index + 1,
+                source: line.trim(),
+                window,
+                indicators
+            });
+        }
+    }
+    return calls;
+}
+function allowFor(callsite) {
+    if (!callsite)
+        return null;
+    const text = `${callsite.source}\n${callsite.window}`;
+    return ALLOWLIST.find((entry) => entry.file === callsite.file && entry.pattern.test(text)) || null;
+}
+function listSourceFiles() {
+    const files = [];
+    for (const dir of SCAN_DIRS)
+        collectTsFiles(path.join(root, dir), files);
+    return files.sort();
+}
+function collectTsFiles(dir, out) {
+    const rows = fs.readdirSync(dir, { withFileTypes: true });
+    for (const row of rows) {
+        const abs = path.join(dir, row.name);
+        const rel = path.relative(root, abs);
+        if (row.isDirectory()) {
+            if (row.name === 'scripts' || row.name === 'node_modules' || row.name === 'dist')
+                continue;
+            collectTsFiles(abs, out);
+            continue;
+        }
+        if (row.isFile() && row.name.endsWith('.ts'))
+            out.push(rel);
+    }
+}
+//# sourceMappingURL=config-managed-merge-callsite-coverage-check.js.map

package/dist/scripts/context7-evidence-dedupe-check.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/pipeline-internals/runtime-core.js');
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-context7-evidence-'));
+const missionId = 'M-context7-dedupe';
+const missionDir = path.join(root, '.sneakoscope', 'missions', missionId);
+await fs.mkdir(missionDir, { recursive: true });
+const state = { mission_id: missionId };
+const falsePositive = await mod.recordContext7Evidence(root, state, {
+    tool_name: 'update_plan',
+    tool_response: 'This ordinary planning output mentions Context7 resolve-library-id and query-docs.'
+});
+assertGate(falsePositive === null, 'ordinary tool output must not be recorded as Context7 evidence', falsePositive);
+await mod.recordContext7Evidence(root, state, {
+    tool_name: 'resolve-library-id',
+    source: 'sks context7 evidence',
+    library: 'react',
+    library_id: '/react/react'
+});
+await mod.recordContext7Evidence(root, state, {
+    tool_name: 'resolve-library-id',
+    source: 'sks context7 evidence',
+    library: 'react',
+    library_id: '/react/react'
+});
+await mod.recordContext7Evidence(root, state, {
+    tool_name: 'query-docs',
+    source: 'sks context7 evidence',
+    library_id: '/react/react',
+    tool_input: { libraryId: '/react/react', query: 'hooks' }
+});
+await mod.recordContext7Evidence(root, state, {
+    tool_name: 'query-docs',
+    source: 'sks context7 evidence',
+    library_id: '/react/react',
+    tool_input: { libraryId: '/react/react', query: 'hooks' }
+});
+await mod.recordContext7Evidence(root, state, {
+    tool_name: 'query-docs',
+    source: 'sks context7 evidence',
+    library_id: '/react/react',
+    tool_input: { libraryId: '/react/react', query: 'server components' }
+});
+const evidenceFile = path.join(missionDir, 'context7-evidence.jsonl');
+const lines = (await fs.readFile(evidenceFile, 'utf8')).split(/\n/).filter(Boolean);
+const evidence = await mod.context7Evidence(root, state);
+assertGate(lines.length === 3, 'duplicate Context7 evidence records must be collapsed without merging distinct queries', { lines });
+assertGate(evidence.ok === true && evidence.resolve === true && evidence.docs === true && evidence.count === 3, 'deduped Context7 evidence must still satisfy docs gate', evidence);
+emitGate('context7:evidence-dedupe', { records: lines.length, evidence });
+//# sourceMappingURL=context7-evidence-dedupe-check.js.map