sneakoscope 4.8.6 → 5.1.2

package/dist/scripts/concurrent-session-collision-check.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { evaluateHookPayload } from '../core/hooks-runtime.js';
+import { loadStateForSession, listSessionStates, stateFile } from '../core/mission.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-concurrent-session-'));
+await fs.mkdir(path.join(root, '.sneakoscope', 'state'), { recursive: true });
+const aPrompt = await evaluateHookPayload('user-prompt-submit', {
+    cwd: root,
+    conversation_id: 'chat-a',
+    prompt: '$Naruto concurrent session A fixture'
+}, { root });
+const aState = await loadStateForSession(root, 'chat-a');
+const bPrompt = await evaluateHookPayload('user-prompt-submit', {
+    cwd: root,
+    conversation_id: 'chat-b',
+    prompt: '$QA-LOOP concurrent session B fixture'
+}, { root });
+const bState = await loadStateForSession(root, 'chat-b');
+const aReload = await loadStateForSession(root, 'chat-a');
+const stopA = await evaluateHookPayload('stop', {
+    cwd: root,
+    conversation_id: 'chat-a',
+    last_assistant_message: 'Done.'
+}, { root });
+const aAfterStop = await loadStateForSession(root, 'chat-a');
+await evaluateHookPayload('user-prompt-submit', {
+    cwd: root,
+    prompt: '$DFix fallback warning fixture A'
+}, { root });
+await evaluateHookPayload('stop', {
+    cwd: root,
+    last_assistant_message: 'DFix 완료 요약: fallback warning fixture.\nDFix 솔직모드: verified: warning path checked; not verified: none; remaining: none.'
+}, { root });
+const sessions = await listSessionStates(root);
+const legacy = JSON.parse(await fs.readFile(stateFile(root), 'utf8'));
+const warningPath = path.join(root, '.sneakoscope', 'state', 'session-id-fallback-warning.jsonl');
+const warningLines = (await fs.readFile(warningPath, 'utf8').catch(() => '')).trim().split(/\n/).filter(Boolean);
+const blockers = [
+    ...(aState.mission_id ? [] : ['session_a_mission_missing']),
+    ...(bState.mission_id ? [] : ['session_b_mission_missing']),
+    ...(aState.mission_id && bState.mission_id && aState.mission_id !== bState.mission_id ? [] : ['session_missions_not_distinct']),
+    ...(aReload.mission_id === aState.mission_id ? [] : ['session_a_reloaded_as_other_mission']),
+    ...(aAfterStop.mission_id === aState.mission_id ? [] : ['session_a_stop_state_contaminated']),
+    ...(legacy._session_key ? [] : ['legacy_current_missing_session_key']),
+    ...(sessions.length >= 2 ? [] : ['session_state_table_missing_rows']),
+    ...(warningLines.length >= 2 ? [] : ['missing_explicit_session_warning_log']),
+    ...(String(stopA?.reason || stopA?.systemMessage || '').includes(bState.mission_id || 'never-match') ? ['stop_a_mentions_session_b_mission'] : [])
+];
+const report = {
+    schema: 'sks.concurrent-session-collision-check.v1',
+    ok: blockers.length === 0,
+    a_prompt_continue: aPrompt?.continue === true,
+    b_prompt_continue: bPrompt?.continue === true,
+    session_a: { mission_id: aState.mission_id, phase: aState.phase, key: aState._session_key },
+    session_b: { mission_id: bState.mission_id, phase: bState.phase, key: bState._session_key },
+    legacy_current: { mission_id: legacy.mission_id, session_key: legacy._session_key },
+    sessions: sessions.map((row) => ({ session_key: row.session_key, mission_id: row.mission_id, phase: row.phase })),
+    fallback_warning_count: warningLines.length,
+    stop_a_decision: stopA?.decision || (stopA?.continue ? 'continue' : 'unknown'),
+    blockers
+};
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok)
+    process.exitCode = 1;
+//# sourceMappingURL=concurrent-session-collision-check.js.map

package/dist/scripts/docs-truthfulness-check.js

@@ -21,7 +21,7 @@ const required = {
     'README.md': ['CHANGELOG.md', 'docs/release-readiness.md', 'gpt-image-2'],
     'CHANGELOG.md': ['1.14.0', 'DFix Extreme Speed Kernel', 'hook trust doctor', 'warning-zero'],
     'docs/computer-use-evidence.md': ['sks.computer-use-live-evidence.v1', 'probe_only', 'live_capture_blocked', 'local-only', 'Codex Chrome Extension'],
-    'docs/codex-lb.md': ['durable_env_file', 'durable_keychain', 'durable_launchctl', 'shell_profile', 'process_only_ephemeral'],
+    'docs/codex-lb.md': ['durable_env_file', 'durable_keychain', 'shell_profile', 'process_only_ephemeral', 'base URL only'],
     'docs/codex-0.136-compat.md': ['rust-v0.136.0', 'codex:0.136-compat', 'codex archive', 'codex app-server --stdio', 'CODEX_API_KEY', 'server tokens'],
     'docs/codex-0.135-compat.md': ['rust-v0.135.0', 'codex:0.135-compat', 'named permission profiles'],
     'docs/codex-cli-compat.md': ['rust-v0.136.0', 'session_archive_restore', 'profile_primary_selector', 'managed_network_proxy_env', 'goals_default_enabled', 'permission_profiles_requirements', 'SubagentStart', 'sks_zero_warning_disallowed', 'strict subset'],

package/dist/scripts/doctor-imagegen-repair-check.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { repairCodexImagegen } from '../core/doctor/imagegen-repair.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-doctor-imagegen-repair-'));
+const stateFile = path.join(root, 'imagegen-enabled');
+const reportPath = path.join(root, 'doctor-imagegen-repair.json');
+const codexBin = path.join(root, 'codex');
+await fs.writeFile(codexBin, `#!/usr/bin/env node
+const fs = require('fs');
+const stateFile = ${JSON.stringify(stateFile)};
+const args = process.argv.slice(2).join(' ');
+if (args === '--version') {
+  console.log('codex-cli 99.0.0');
+  process.exit(0);
+}
+if (args === 'features enable image_generation') {
+  fs.writeFileSync(stateFile, '1');
+  console.log('enabled image_generation');
+  process.exit(0);
+}
+if (args === 'features list --json') {
+  const enabled = fs.existsSync(stateFile);
+  console.log(JSON.stringify({ features: { image_generation: enabled } }));
+  process.exit(0);
+}
+if (args === 'features list') {
+  const enabled = fs.existsSync(stateFile) ? 'true' : 'false';
+  console.log('image_generation stable ' + enabled);
+  process.exit(0);
+}
+console.error('unexpected fake codex args: ' + args);
+process.exit(64);
+`, { mode: 0o755 });
+const report = await repairCodexImagegen({
+    root,
+    apply: true,
+    codexBin,
+    reportPath,
+    timeoutMs: 1000
+});
+const reportFile = JSON.parse(await fs.readFile(reportPath, 'utf8'));
+const ok = report.schema === 'sks.doctor-imagegen-repair.v1'
+    && report.attempted === true
+    && report.recovered === true
+    && report.after?.core_ready === true
+    && report.steps?.some((step) => step.id === 'image_generation_feature_enable' && step.ok === true)
+    && reportFile.recovered === true;
+console.log(JSON.stringify({
+    schema: 'sks.doctor-imagegen-repair-check.v1',
+    ok,
+    repair_schema: report.schema,
+    attempted: report.attempted,
+    recovered: report.recovered,
+    after_core_ready: report.after?.core_ready === true,
+    report_path: reportPath
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=doctor-imagegen-repair-check.js.map

package/dist/scripts/ensure-bin-executable.js

@@ -4,7 +4,15 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const bin = path.join(root, 'dist', 'bin', 'sks.js');
-await fsp.chmod(bin, 0o755);
-console.log(`bin executable: ${path.relative(root, bin)}`);
+const bins = [
+    path.join(root, 'dist', 'bin', 'sks.js'),
+    path.join(root, 'dist', 'bin', 'install.js')
+];
+for (const bin of bins) {
+    await fsp.chmod(bin, 0o755).catch((err) => {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    });
+    console.log(`bin executable: ${path.relative(root, bin)}`);
+}
 //# sourceMappingURL=ensure-bin-executable.js.map

package/dist/scripts/gate-policy-audit-check.js

@@ -3,6 +3,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { COMMANDS } from '../cli/command-registry.js';
 const root = process.cwd();
 const release = JSON.parse(fs.readFileSync(path.join(root, 'release-gates.v2.json'), 'utf8'));
 const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
@@ -21,6 +22,10 @@ const splitReviewLineCounts = splitReviewFiles.map((file) => ({
     file,
     lines: lineCount(path.join(root, file))
 }));
+const directCodexConfigWrites = scanDirectCodexConfigWrites();
+const commandGateContract = scanCommandGateContract();
+const directMkdtempCalls = scanDirectMkdtempCalls();
+const rustTempdirCalls = scanRustTempdirCalls();
 if (releaseGates.length > 200)
     blockers.push(`release_preset_gate_budget_exceeded:${releaseGates.length}`);
 if (gates.length > 200)
@@ -33,6 +38,14 @@ if (fs.existsSync(path.join(root, 'src/core/pipeline-runtime.ts')))
     blockers.push('pipeline_runtime_duplicate_facade_present');
 if (gitTracked('*sks-backup*').length)
     blockers.push('tracked_sks_backup_files_present');
+if (directCodexConfigWrites.length)
+    blockers.push(`direct_codex_config_write_callsite:${directCodexConfigWrites[0].file}:${directCodexConfigWrites[0].line}`);
+if (!commandGateContract.ok)
+    blockers.push(`command_gate_contract:${commandGateContract.issues[0]}`);
+if (directMkdtempCalls.length)
+    blockers.push(`direct_mkdtemp_callsite:${directMkdtempCalls[0].file}:${directMkdtempCalls[0].line}`);
+if (rustTempdirCalls.length)
+    blockers.push(`rust_tempdir_without_raii:${rustTempdirCalls[0].file}:${rustTempdirCalls[0].line}`);
 for (const row of splitReviewLineCounts) {
     if (row.lines > splitReviewBudget)
         blockers.push(`split_review_budget_exceeded:${row.file}:${row.lines}`);
@@ -45,6 +58,12 @@ const result = {
     package_script_count: Object.keys(pkg.scripts || {}).length,
     split_review_budget_lines: splitReviewBudget,
     split_review_line_counts: splitReviewLineCounts,
+    direct_codex_config_write_callsite_count: directCodexConfigWrites.length,
+    direct_codex_config_write_callsites: directCodexConfigWrites.slice(0, 20),
+    command_gate_contract: commandGateContract,
+    direct_mkdtemp_callsite_count: directMkdtempCalls.length,
+    direct_mkdtemp_callsites: directMkdtempCalls.slice(0, 20),
+    rust_tempdir_raii: { ok: rustTempdirCalls.length === 0, direct_tempdir_callsites: rustTempdirCalls.slice(0, 20) },
     blockers
 };
 console.log(JSON.stringify(result, null, 2));
@@ -59,6 +78,76 @@ function gitTracked(pattern) {
         return [];
     }
 }
+function scanCommandGateContract() {
+    const issues = [];
+    for (const [name, entry] of Object.entries(COMMANDS)) {
+        if (entry.readonly === true && entry.skipMigrationGate !== true)
+            issues.push(`${name}:readonly_without_skipMigrationGate`);
+        if (entry.diagnostic === true && entry.allowedDuringActiveRoute !== true)
+            issues.push(`${name}:diagnostic_without_active_route_allow`);
+        if (entry.ownsGates === true && entry.mutatesRouteState !== true)
+            issues.push(`${name}:ownsGates_without_mutatesRouteState`);
+        if (entry.mutatesRouteState === true && (!Array.isArray(entry.ownedGateFiles) || entry.ownedGateFiles.length === 0))
+            issues.push(`${name}:route_mutator_without_owned_gate_files`);
+        if (entry.allowedDuringActiveRoute === true && !entry.activeRoutePolicy)
+            issues.push(`${name}:missing_active_route_policy`);
+    }
+    for (const required of ['help', 'version', 'commands', 'status', 'root', 'stop-gate', 'route', 'doctor']) {
+        const entry = COMMANDS[required];
+        if (!entry?.skipMigrationGate)
+            issues.push(`${required}:missing_skipMigrationGate`);
+    }
+    for (const routeStarter of ['naruto', 'goal', 'dfix', 'team', 'agent', 'loop', 'qa-loop', 'research', 'autoresearch', 'mad-sks', 'mad-db', 'ppt', 'image-ux-review', 'computer-use']) {
+        const entry = COMMANDS[routeStarter];
+        if (entry?.mutatesRouteState !== true)
+            issues.push(`${routeStarter}:missing_route_state_mutator_contract`);
+    }
+    for (const migrationBypass of ['check', 'gates', 'task', 'release', 'triwiki', 'daemon', 'pipeline', 'wiki', 'stop-gate']) {
+        const entry = COMMANDS[migrationBypass];
+        if (entry?.skipMigrationGate !== true)
+            issues.push(`${migrationBypass}:missing_skip_migration_gate_contract`);
+    }
+    return { ok: issues.length === 0, issues };
+}
+function scanDirectMkdtempCalls() {
+    const files = [
+        ...walk(path.join(root, 'src', 'core')),
+        ...walk(path.join(root, 'src', 'cli')),
+        ...walk(path.join(root, 'src', 'commands')),
+        ...walk(path.join(root, 'src', 'scripts'))
+    ].filter((file) => file.endsWith('.ts'));
+    const out = [];
+    for (const file of files) {
+        const rel = path.relative(root, file);
+        if (rel === 'src/core/fsx.ts')
+            continue;
+        if (/(?:__tests__|fixture|fixtures|bench|blackbox|check|probe|smoke|selftest|feature-commands|feature-probes)/i.test(rel))
+            continue;
+        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] || '';
+            if (/\bmkdtemp(?:Sync)?\s*\(/.test(line))
+                out.push({ file: rel, line: index + 1, text: line.trim().slice(0, 220) });
+        }
+    }
+    return out;
+}
+function scanRustTempdirCalls() {
+    const crateRoot = path.join(root, 'crates');
+    const files = walk(crateRoot).filter((file) => file.endsWith('.rs'));
+    const out = [];
+    for (const file of files) {
+        const rel = path.relative(root, file);
+        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] || '';
+            if (/\b(?:std::env::temp_dir|tempfile::tempdir|TempDir::new|mktemp)\b/.test(line)) {
+                out.push({ file: rel, line: index + 1, text: line.trim().slice(0, 220) });
+            }
+        }
+    }
+    return out;
+}
 function lineCount(file) {
     if (!fs.existsSync(file))
         return 0;
@@ -67,4 +156,45 @@ function lineCount(file) {
         return 0;
     return text.split(/\r?\n/).length - (text.endsWith('\n') ? 1 : 0);
 }
+function scanDirectCodexConfigWrites() {
+    const files = [
+        ...walk(path.join(root, 'src', 'core')),
+        ...walk(path.join(root, 'src', 'cli')),
+        ...walk(path.join(root, 'src', 'commands'))
+    ].filter((file) => file.endsWith('.ts'));
+    const out = [];
+    for (const file of files) {
+        const rel = path.relative(root, file);
+        if (rel === 'src/core/codex/codex-config-guard.ts')
+            continue;
+        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+        let inInstallHelperSelftest = false;
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] || '';
+            if (rel === 'src/cli/install-helpers.ts' && /export\s+async\s+function\s+selftest/.test(line))
+                inInstallHelperSelftest = true;
+            if (inInstallHelperSelftest)
+                continue;
+            if (!/\bwriteTextAtomic\s*\(/.test(line))
+                continue;
+            if (!/(?:config\.toml|configPath|candidate\.path|config\.path|userConfigPath|codexHomeConfigPath)/.test(line))
+                continue;
+            out.push({ file: rel, line: index + 1, text: line.trim().slice(0, 220) });
+        }
+    }
+    return out;
+}
+function walk(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...walk(file));
+        else
+            out.push(file);
+    }
+    return out;
+}
 //# sourceMappingURL=gate-policy-audit-check.js.map

package/dist/scripts/harness-benchmark-check.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+import { ensureDir, nowIso, runProcess, writeJsonAtomic } from '../core/fsx.js';
+import { reviewCommand } from '../core/commands/review-command.js';
+import { collectUiState } from '../core/commands/ui-command.js';
+import { simulateNarutoActivePool } from '../core/naruto/naruto-active-pool.js';
+import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
+import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
+const reportPath = path.join(root, '.sneakoscope', 'reports', 'harness-benchmark.json');
+const metrics = [];
+metrics.push(await measure('install_entrypoint_readiness', 300000, async () => {
+    await assertFile('dist/bin/install.js');
+    await assertFile('plugins/sks/.codex-plugin/plugin.json');
+    return { mode: 'hermetic_readiness', command: 'npx sneakoscope install --yes' };
+}));
+metrics.push(await measure('stop_hook_light_budget', 25, async () => {
+    const started = performance.now();
+    await assertFile('dist/scripts/hook-latency-budget-check.js');
+    return { mode: 'script_presence_budget_proxy', measured_ms: performance.now() - started };
+}));
+metrics.push(await measure('swarm_14_worker_fixture', 20000, async () => {
+    const graph = buildNarutoWorkGraph({
+        requestedClones: 14,
+        totalWorkItems: 14,
+        honorExplicitTotalWorkItems: true,
+        readonly: true,
+        writeCapable: false,
+        maxActiveWorkers: 14
+    });
+    const governor = decideNarutoConcurrency({
+        requestedClones: 14,
+        totalWorkItems: 14,
+        pendingWorkQueueSize: 14,
+        backend: 'fake',
+        hardware: { remoteApiRateLimitBudget: 14, fileDescriptorLimit: 4096, freeMemoryBytes: 8 * 1024 * 1024 * 1024, totalMemoryBytes: 16 * 1024 * 1024 * 1024 }
+    });
+    const report = simulateNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 14 } });
+    return {
+        command: 'simulateNarutoActivePool --fake --clones 14',
+        ok: report.ok === true && report.completed_count >= 14 && report.max_observed_active_workers >= 7,
+        completed_count: report.completed_count,
+        max_observed_active_workers: report.max_observed_active_workers,
+        blockers: report.blockers
+    };
+}));
+metrics.push(await measure('review_10_file_diff', 120000, async () => {
+    const fixture = await makeReviewFixture();
+    const previousExitCode = process.exitCode;
+    const review = await reviewCommand(['--root', fixture]);
+    process.exitCode = previousExitCode;
+    return {
+        files: review?.files || 0,
+        machine_evidence: (review?.findings || []).filter((finding) => finding.evidence === 'machine').length,
+        verdict: review?.verdict || 'unknown'
+    };
+}));
+metrics.push(await measure('dashboard_first_state', 2000, async () => {
+    const state = await collectUiState(root, 'latest');
+    return { ok: state.ok === true, mission_id: state.mission_id || null, gates: Array.isArray(state.gates) ? state.gates.length : 0 };
+}));
+const report = {
+    schema: 'sks.harness-benchmark.v1',
+    generated_at: nowIso(),
+    ok: metrics.every((metric) => metric.ok),
+    metrics,
+    report_path: path.relative(root, reportPath)
+};
+await writeJsonAtomic(reportPath, report);
+assertGate(report.ok, 'harness benchmark check failed', report);
+emitGate('harness:benchmark', report);
+async function measure(id, budgetMs, fn) {
+    const started = performance.now();
+    try {
+        const detail = await fn();
+        const elapsed_ms = Math.round((performance.now() - started) * 100) / 100;
+        return { id, ok: elapsed_ms <= budgetMs && detail.ok !== false, budget_ms: budgetMs, elapsed_ms, detail };
+    }
+    catch (err) {
+        const elapsed_ms = Math.round((performance.now() - started) * 100) / 100;
+        return { id, ok: false, budget_ms: budgetMs, elapsed_ms, error: err?.message || String(err) };
+    }
+}
+async function assertFile(rel) {
+    await fs.access(path.join(root, rel));
+}
+async function makeReviewFixture() {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-review-bench-'));
+    await runProcess('git', ['init'], { cwd: dir, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
+    for (let i = 0; i < 10; i += 1) {
+        await ensureDir(path.join(dir, 'src'));
+        await fs.writeFile(path.join(dir, 'src', `file-${i}.txt`), `baseline ${i}\n`, 'utf8');
+    }
+    await runProcess('git', ['add', '.'], { cwd: dir, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
+    for (let i = 0; i < 10; i += 1) {
+        const content = i === 0 ? '<<<<<<< HEAD\nleft\n=======\nright\n>>>>>>> branch\n' : `changed ${i}\n`;
+        await fs.writeFile(path.join(dir, 'src', `file-${i}.txt`), content, 'utf8');
+    }
+    return dir;
+}
+//# sourceMappingURL=harness-benchmark-check.js.map

package/dist/scripts/hook-latency-budget-check.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const budgetMs = Number(process.env.SKS_HOOK_LATENCY_BUDGET_MS || 25);
+const readBudget = Number(process.env.SKS_HOOK_LATENCY_READ_BUDGET || 3);
+const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-hook-latency-'));
+await fsp.mkdir(path.join(root, '.sneakoscope', 'state'), { recursive: true });
+let readCount = 0;
+const originalReadFile = fsp.readFile.bind(fsp);
+fsp.readFile = async function patchedReadFile(file, ...rest) {
+    if (String(file).includes('.sneakoscope'))
+        readCount += 1;
+    return originalReadFile(file, ...rest);
+};
+try {
+    const { evaluateStop } = await importDist('core/pipeline-internals/runtime-gates.js');
+    const started = performance.now();
+    const decision = await evaluateStop(root, {
+        mission_id: 'M-light',
+        mode: 'ANSWER',
+        route: 'Answer',
+        route_command: '$Answer',
+        stop_gate: 'none',
+        reflection_required: false,
+        proof_required: false,
+        agents_required: false,
+        context7_required: false,
+        subagents_required: false
+    }, { message: 'done' });
+    const elapsed = performance.now() - started;
+    assertGate(decision === null, 'light stop route must early-exit without a block decision', { decision });
+    assertGate(elapsed <= budgetMs, 'light stop route exceeded latency budget', { elapsed_ms: elapsed, budget_ms: budgetMs, read_count: readCount });
+    assertGate(readCount <= readBudget, 'light stop route exceeded .sneakoscope read budget', { read_count: readCount, read_budget: readBudget, elapsed_ms: elapsed });
+    emitGate('hook:latency-budget', { elapsed_ms: Math.round(elapsed * 100) / 100, read_count: readCount, budget_ms: budgetMs, read_budget: readBudget });
+}
+finally {
+    fsp.readFile = originalReadFile;
+    fs.rmSync(root, { recursive: true, force: true });
+}
+//# sourceMappingURL=hook-latency-budget-check.js.map