sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/agent-patch-queue-runtime-check.js

@@ -1,36 +0,0 @@
-#!/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 } from './sks-1-18-gate-lib.js';
-import { readJson, writeReport } from './agent-patch-swarm-gate-lib.js';
-const storeMod = await importDist('core/agents/agent-patch-queue-store.js');
-const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-patch-queue-'));
-const store = new storeMod.PersistentAgentPatchQueueStore(dir);
-const entry = await store.enqueue({
-    schema: 'sks.agent-patch-envelope.v1',
-    agent_id: 'agent-a',
-    session_id: 'session-a',
-    slot_id: 'slot-a',
-    generation_index: 1,
-    lease_id: 'lease-a',
-    lease_proof: { lease_id: 'lease-a', allowed_paths: ['a.txt'], verification_node_id: 'verify-a', rollback_node_id: 'rollback-a' },
-    rollback_hint: { node_id: 'rollback-a' },
-    operations: [{ op: 'write', path: 'a.txt', content: 'a\n' }]
-}, { mission_id: 'mission-a', route: '$Agent' });
-await store.markApplying(entry.id);
-await store.markApplied(entry.id);
-await store.markVerified(entry.id);
-const queue = readJson(path.join(dir, 'agent-patch-queue.json'));
-const ownership = readJson(path.join(dir, 'agent-patch-ownership-ledger.json'));
-const events = fs.readFileSync(path.join(dir, 'agent-patch-queue-events.jsonl'), 'utf8').trim().split(/\n+/).filter(Boolean).map(JSON.parse);
-const report = { schema: 'sks.agent-patch-queue-runtime-check.v1', ok: true, artifact_dir: dir, queue, ownership, events };
-writeReport('agent-patch-queue-runtime', report);
-assertGate(queue.entries?.[0]?.mission_id === 'mission-a', 'queue entry must include mission id', report);
-assertGate(queue.entries?.[0]?.route === '$Agent', 'queue entry must include route', report);
-assertGate(queue.entries?.[0]?.status === 'verified', 'queue entry must reach verified state', report);
-assertGate(events.length >= 4, 'queue events must record append-only transitions', report);
-assertGate(ownership.entries?.[0]?.lease_id === 'lease-a', 'ownership ledger must bind lease id', report);
-emitGate('agent:patch-queue-runtime', { event_count: events.length });
-//# sourceMappingURL=agent-patch-queue-runtime-check.js.map

package/dist/scripts/agent-patch-rollback-check.js

@@ -1,38 +0,0 @@
-#!/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, root } from './sks-1-18-gate-lib.js';
-const applyMod = await importDist('core/agents/agent-patch-apply-worker.js');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-patch-rollback-'));
-const file = path.join(tmp, 'rollback.txt');
-const created = path.join(tmp, 'created.txt');
-fs.writeFileSync(file, 'before\n');
-const envelope = {
-    schema: 'sks.agent-patch-envelope.v1',
-    agent_id: 'rollback-agent',
-    session_id: 'rollback-session',
-    slot_id: 'rollback-slot',
-    generation_index: 1,
-    lease_id: 'lease:rollback-agent:rollback.txt',
-    rollback_hint: { node_id: 'rollback-fixture' },
-    operations: [
-        { op: 'replace', path: 'rollback.txt', search: 'before', replace: 'after' },
-        { op: 'write', path: 'created.txt', content: 'created\n' }
-    ]
-};
-const applied = await applyMod.applyAgentPatchEnvelope(tmp, envelope);
-const rolledBack = await applyMod.rollbackAgentPatchApply(tmp, applied);
-const restored = fs.readFileSync(file, 'utf8');
-const createdRemoved = !fs.existsSync(created);
-const report = { schema: 'sks.agent-patch-rollback-check.v1', ok: applied.ok && rolledBack.ok && restored === 'before\n' && createdRemoved, applied, rolledBack, restored, createdRemoved };
-const out = path.join(root, '.sneakoscope', 'reports', 'agent-patch-rollback.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(applied.ok === true, 'rollback check patch did not apply', report);
-assertGate(rolledBack.ok === true, 'rollback check did not execute rollback mechanism', report);
-assertGate(restored === 'before\n', 'rollback check did not restore original content', report);
-assertGate(createdRemoved === true, 'rollback check did not delete file created by patch', report);
-emitGate('agent:patch-rollback', { rollback_entries: applied.rollback.length, deleted_files: rolledBack.deleted_files.length });
-//# sourceMappingURL=agent-patch-rollback-check.js.map

package/dist/scripts/agent-patch-rollback-dag-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { writeReport } from './agent-patch-swarm-gate-lib.js';
-const strategy = await importDist('core/strategy/strategy-compiler.js');
-const compiled = strategy.compileStrategy({ prompt: '`file-1.txt` `file-2.txt`', route: '$Agent', agentCount: 2 });
-const rollbackNodes = compiled.verification_rollback_dag.nodes.filter((node) => node.kind === 'rollback');
-const report = { schema: 'sks.agent-patch-rollback-dag-check.v1', ok: compiled.verification_rollback_dag.rollback_ready, dag: compiled.verification_rollback_dag, rollbackNodes };
-writeReport('agent-patch-rollback-dag', report);
-assertGate(compiled.verification_rollback_dag.rollback_ready === true, 'rollback DAG must be ready', report);
-assertGate(rollbackNodes.length > 0, 'rollback DAG must include rollback nodes', report);
-assertGate(rollbackNodes.every((node) => node.proof_artifact), 'rollback DAG nodes must carry proof artifacts', report);
-emitGate('agent:patch-rollback-dag', { rollback_nodes: rollbackNodes.length });
-//# sourceMappingURL=agent-patch-rollback-dag-check.js.map

package/dist/scripts/agent-patch-swarm-route-blackbox.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runPatchSwarmRouteBlackbox } from './agent-patch-swarm-gate-lib.js';
-await runPatchSwarmRouteBlackbox({
-    gate: 'agent:patch-swarm-route-blackbox',
-    route: '$Agent',
-    routeCommand: 'sks agent run',
-    reportName: 'agent-patch-swarm-route-blackbox'
-});
-//# sourceMappingURL=agent-patch-swarm-route-blackbox.js.map

package/dist/scripts/agent-patch-swarm-runtime-check.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runPatchSwarmRouteBlackbox } from './agent-patch-swarm-gate-lib.js';
-await runPatchSwarmRouteBlackbox({
-    gate: 'agent:patch-swarm-runtime',
-    route: '$Agent',
-    routeCommand: 'sks agent run',
-    reportName: 'agent-patch-swarm-runtime'
-});
-//# sourceMappingURL=agent-patch-swarm-runtime-check.js.map

package/dist/scripts/agent-patch-swarm-runtime-truth-check.js

@@ -1,76 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-import { readJson, runPatchSwarmRouteBlackbox, writeReport } from './agent-patch-swarm-gate-lib.js';
-const routeReport = await runPatchSwarmRouteBlackbox({
-    gate: 'agent:patch-swarm-runtime-truth:route',
-    route: '$Agent',
-    routeCommand: 'sks agent run',
-    reportName: 'agent-patch-swarm-runtime-truth-route'
-});
-const ledgerRoot = path.join(routeReport.fixture_root, routeReport.result.ledger_root);
-const queue = readJson(path.join(ledgerRoot, 'agent-patch-queue.json'));
-const events = fs.readFileSync(path.join(ledgerRoot, 'agent-patch-queue-events.jsonl'), 'utf8').trim().split(/\n+/).filter(Boolean).map(JSON.parse);
-const merge = readJson(path.join(ledgerRoot, 'agent-merge-coordinator-report.json'));
-const apply = readJson(path.join(ledgerRoot, 'agent-patch-apply-results.json'));
-const verification = readJson(path.join(ledgerRoot, 'agent-patch-verification-results.json'));
-const rollback = readJson(path.join(ledgerRoot, 'agent-patch-rollback-proof.json'));
-const proof = readJson(path.join(ledgerRoot, 'agent-patch-proof.json'));
-const runtime = readJson(path.join(ledgerRoot, 'agent-patch-swarm-runtime.json'));
-const journal = readJson(path.join(ledgerRoot, 'agent-patch-transaction-journal-summary.json'));
-const strategyGateExists = fs.existsSync(path.join(ledgerRoot, 'strategy-gate.json')) || routeReport.result.strategy_gate;
-const strategyCompilerExists = fs.existsSync(path.join(ledgerRoot, 'strategy-compiler.json')) || routeReport.result.strategy_gate;
-const eventTypes = new Set(events.map((event) => event.event_type || event.status));
-const owners = new Map();
-for (const row of queue.ownership_ledger || []) {
-    for (const file of row.write_paths || []) {
-        if (!owners.has(file))
-            owners.set(file, []);
-        owners.get(file).push(row.agent_id);
-    }
-}
-const duplicateWriteOwners = [...owners.entries()].filter(([, rows]) => new Set(rows).size > 1).map(([file, rows]) => ({ file, owners: rows }));
-const report = {
-    schema: 'sks.agent-patch-swarm-runtime-truth-check.v1',
-    ok: true,
-    policy_only: false,
-    fixture_root: routeReport.fixture_root,
-    mission_id: routeReport.result.mission_id,
-    queue,
-    merge,
-    runtime,
-    proof,
-    journal,
-    changed_files: [...new Set((apply.results || []).flatMap((row) => row.changed_files || []))],
-    event_types: [...eventTypes],
-    duplicate_write_owners: duplicateWriteOwners,
-    strategy_gate_exists: Boolean(strategyGateExists),
-    strategy_compiler_exists: Boolean(strategyCompilerExists),
-    verification_ok: verification.ok === true,
-    rollback_ok: rollback.ok === true,
-    patch_proof_ok: proof.ok === true,
-    final_agent_proof_ok: routeReport.result.proof?.ok === true
-};
-report.ok = report.policy_only === false
-    && report.strategy_gate_exists
-    && report.strategy_compiler_exists
-    && queue.entries.length >= 10
-    && ['enqueue', 'applying', 'applied', 'verified'].every((kind) => eventTypes.has(kind))
-    && merge.parallel_apply_groups?.[0]?.entry_ids?.length >= 5
-    && report.changed_files.length >= 5
-    && duplicateWriteOwners.length === 0
-    && verification.ok === true
-    && rollback.ok === true
-    && proof.ok === true
-    && journal.ok === true
-    && routeReport.result.proof?.ok === true;
-writeReport('agent-patch-swarm-runtime-truth', report);
-assertGate(report.ok === true, 'patch swarm runtime truth umbrella gate failed', report);
-assertGate(report.policy_only === false, 'patch swarm runtime truth must not be policy-only', report);
-assertGate(queue.entries.length >= 10, 'truth gate must enqueue at least 10 patch entries', report);
-assertGate(['enqueue', 'applying', 'applied', 'verified'].every((kind) => eventTypes.has(kind)), 'truth gate must record queue lifecycle events', report);
-assertGate(journal.ok === true, 'truth gate must include transaction journal proof', report);
-emitGate('agent:patch-swarm-runtime-truth', { mission_id: report.mission_id, changed_files: report.changed_files.length });
-//# sourceMappingURL=agent-patch-swarm-runtime-truth-check.js.map

package/dist/scripts/agent-patch-transaction-journal-check.js

@@ -1,57 +0,0 @@
-#!/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 } from './sks-1-18-gate-lib.js';
-import { writeReport } from './agent-patch-swarm-gate-lib.js';
-const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-patch-journal-'));
-fs.writeFileSync(path.join(dir, 'a.txt'), 'before\n');
-const storeMod = await importDist('core/agents/agent-patch-queue-store.js');
-const applyMod = await importDist('core/agents/agent-patch-apply-worker.js');
-const journalMod = await importDist('core/agents/agent-patch-transaction-journal.js');
-const store = new storeMod.PersistentAgentPatchQueueStore(dir);
-const entry = await store.enqueue({
-    schema: 'sks.agent-patch-envelope.v1',
-    agent_id: 'agent-journal',
-    session_id: 'session-journal',
-    slot_id: 'slot-journal',
-    generation_index: 1,
-    lease_id: 'lease-journal',
-    lease_proof: {
-        lease_id: 'lease-journal',
-        owner_agent: 'agent-journal',
-        owner_persona: 'fixture',
-        allowed_paths: ['a.txt'],
-        strategy_task_id: 'task-journal',
-        micro_win_id: 'win-journal',
-        verification_node_id: 'verify-journal',
-        rollback_node_id: 'rollback-journal',
-        protected_path_check: 'passed'
-    },
-    verification_hint: { node_id: 'verify-journal' },
-    rollback_hint: { node_id: 'rollback-journal' },
-    operations: [{ op: 'replace', path: 'a.txt', search: 'before', replace: 'after' }]
-}, { mission_id: 'M-journal', route: '$Agent' });
-await store.markApplying(entry.id);
-const applyResult = await applyMod.applyAgentPatchQueueEntry(dir, entry, { artifactsDir: dir });
-await store.markApplied(entry.id);
-await store.markVerified(entry.id);
-const journal = new journalMod.AgentPatchTransactionJournal(dir);
-await journal.append({ event_type: 'verification_started', entry_id: entry.id, agent_id: entry.agent_id, lease_id: entry.lease_id, status: 'started' });
-await journal.append({ event_type: 'verification_finished', entry_id: entry.id, agent_id: entry.agent_id, lease_id: entry.lease_id, status: 'verified', verification_status: applyResult.verification.status, changed_files: applyResult.changed_files, rollback_digest: applyResult.rollback_digest });
-await journal.append({ event_type: 'rollback_dry_run_started', entry_id: entry.id, agent_id: entry.agent_id, lease_id: entry.lease_id, status: 'started', rollback_digest: applyResult.rollback_digest });
-const rollbackDryRun = await applyMod.rollbackAgentPatchApply(dir, applyResult, { dryRun: true });
-await journal.append({ event_type: 'rollback_dry_run_finished', entry_id: entry.id, agent_id: entry.agent_id, lease_id: entry.lease_id, status: rollbackDryRun.status, rollback_digest: rollbackDryRun.rollback_digest, changed_files: applyResult.changed_files });
-const summary = await journal.writeSummary();
-const report = { schema: 'sks.agent-patch-transaction-journal-check.v1', ok: summary.ok, artifact_dir: dir, summary, applyResult, rollbackDryRun };
-writeReport('agent-patch-transaction-journal', report);
-assertGate(summary.ok === true, 'transaction journal summary must pass', report);
-assertGate(summary.event_types.includes('enqueue'), 'journal must record enqueue', report);
-assertGate(summary.event_types.includes('lock_acquired'), 'journal must record lock acquisition', report);
-assertGate(summary.event_types.includes('lock_released'), 'journal must record lock release', report);
-assertGate(summary.event_types.includes('apply_started') && summary.event_types.includes('apply_finished'), 'journal must record apply lifecycle', report);
-assertGate(summary.event_types.includes('verification_finished'), 'journal must record verification completion', report);
-assertGate(summary.event_types.includes('rollback_dry_run_finished'), 'journal must record rollback dry-run completion', report);
-emitGate('agent:patch-transaction-journal', { event_count: summary.event_count });
-//# sourceMappingURL=agent-patch-transaction-journal-check.js.map

package/dist/scripts/agent-patch-verification-dag-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-import { writeReport } from './agent-patch-swarm-gate-lib.js';
-const strategy = await importDist('core/strategy/strategy-compiler.js');
-const compiled = strategy.compileStrategy({ prompt: '`file-1.txt` `file-2.txt`', route: '$Agent', agentCount: 2 });
-const verificationNodes = compiled.verification_rollback_dag.nodes.filter((node) => node.kind === 'verification');
-const report = { schema: 'sks.agent-patch-verification-dag-check.v1', ok: verificationNodes.length > 0, dag: compiled.verification_rollback_dag, verificationNodes };
-writeReport('agent-patch-verification-dag', report);
-assertGate(compiled.verification_rollback_dag.schema === 'sks.verification-rollback-dag.v1', 'verification rollback DAG schema must exist', report);
-assertGate(verificationNodes.length > 0, 'verification DAG must include verification nodes', report);
-assertGate(verificationNodes.every((node) => node.proof_artifact), 'verification DAG nodes must carry proof artifacts', report);
-emitGate('agent:patch-verification-dag', { verification_nodes: verificationNodes.length });
-//# sourceMappingURL=agent-patch-verification-dag-check.js.map

package/dist/scripts/agent-proof-contract-reconciled-check.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runActualAgentBackfillBlackbox } from './agent-route-blackbox-lib.js';
-runActualAgentBackfillBlackbox('agent:proof-contract-reconciled');
-//# sourceMappingURL=agent-proof-contract-reconciled-check.js.map

package/dist/scripts/agent-real-codex-dynamic-smoke-check.js

@@ -1,166 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const releaseVersion = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version;
-const reportPath = path.join(root, '.sneakoscope', 'reports', `agent-real-codex-dynamic-smoke-${releaseVersion}.json`);
-fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-const required = process.env.SKS_REQUIRE_REAL_DYNAMIC_AGENTS === '1';
-if (process.env.SKS_TEST_REAL_DYNAMIC_AGENTS !== '1') {
-    optionalOrBlocked('set SKS_TEST_REAL_DYNAMIC_AGENTS=1 to run real Codex SDK dynamic smoke', 'real_dynamic_agents_not_requested');
-}
-const full = process.argv.includes('--full');
-const activeSlots = full ? 3 : 2;
-const workItems = full ? 5 : 3;
-const childEnv = { ...process.env };
-const run = spawnSync(process.execPath, [
-    'dist/bin/sks.js',
-    'agent',
-    'run',
-    'real codex dynamic backfill read-only smoke: inspect package metadata and report no file changes',
-    '--route', '$Agent',
-    '--backend', 'codex-sdk',
-    '--real',
-    '--readonly',
-    '--json',
-    '--agents', String(activeSlots),
-    '--target-active-slots', String(activeSlots),
-    '--minimum-work-items', String(activeSlots),
-    '--work-items', String(workItems),
-    '--max-queue-expansion', '10'
-], {
-    cwd: root,
-    encoding: 'utf8',
-    env: childEnv,
-    maxBuffer: 1024 * 1024 * 32,
-    timeout: Number(process.env.SKS_REAL_SMOKE_TIMEOUT_MS || 10 * 60 * 1000)
-});
-assertGate(run.status === 0, 'real codex dynamic smoke command failed', { stdout: run.stdout.slice(-4000), stderr: run.stderr.slice(-4000) });
-const json = parseJson(run.stdout);
-const ledgerRoot = path.join(root, json.ledger_root || '');
-const proof = readJson(path.join(ledgerRoot, 'agent-proof-evidence.json'));
-const scheduler = json.scheduler?.state || {};
-const reports = listNamedFiles(path.join(ledgerRoot, 'sessions'), 'agent-process-report.json').map(readJson);
-const changedFiles = (json.results || []).flatMap((row) => row.changed_files || []);
-const terminal = readJson(path.join(ledgerRoot, 'agent-terminal-close-aggregate.json'), null);
-const outputSchemaReports = reports.filter((row) => row.output_schema_used === true && row.output_last_message_path);
-const resultFiles = reports.map((row) => resolveReportPath(ledgerRoot, row.result_file || row.output_last_message_path)).filter(Boolean);
-const parsedResultFiles = resultFiles.map((file) => ({ file, exists: fs.existsSync(file), json: readJson(file, null) }));
-const processCleanupOk = reports.every((row) => !row.pid || row.exit_code !== null || !processAlive(Number(row.pid)));
-const fixtureInstrumented = childEnv.SKS_AGENT_DYNAMIC_BACKFILL_FIXTURE === '1';
-const result = {
-    ok: true,
-    status: fixtureInstrumented ? 'fixture_instrumented_real' : 'passed',
-    proof_level: fixtureInstrumented ? 'fixture_instrumented_real' : 'proven',
-    schema: 'sks.real-codex-dynamic-smoke.v2',
-    proof_contract: 'sks.real-codex-dynamic-smoke.v3',
-    generated_at: new Date().toISOString(),
-    release_version: releaseVersion,
-    mission_id: json.mission_id,
-    active_slots: activeSlots,
-    work_items: workItems,
-    default_bounded_smoke: !full,
-    required,
-    fixture_instrumented_real: fixtureInstrumented,
-    scheduler_state: scheduler,
-    proof_status: proof.status,
-    output_schema_used: outputSchemaReports.length === reports.length && reports.length > 0,
-    output_last_message_paths: outputSchemaReports.map((row) => row.output_last_message_path),
-    result_files: parsedResultFiles.map((row) => ({ file: row.file, exists: row.exists, json_ok: Boolean(row.json) })),
-    all_result_files_exist: parsedResultFiles.length === reports.length && parsedResultFiles.every((row) => row.exists),
-    all_output_last_message_json_valid: parsedResultFiles.length === reports.length && parsedResultFiles.every((row) => row.json),
-    all_agent_result_schemas_valid: (json.results || []).every((row) => !Array.isArray(row.blockers) || !row.blockers.some((blocker) => String(blocker).startsWith('schema_invalid:'))),
-    process_report_count: reports.length,
-    terminal_close_report: terminal ? 'agent-terminal-close-aggregate.json' : proof.terminal_close_report,
-    terminal_close_reports_ok: Boolean(terminal) || proof.terminal_sessions_closed === true,
-    process_cleanup_ok: processCleanupOk,
-    changed_files: changedFiles,
-    source_refs_ok: proof.source_intelligence_generation_refs_ok === true && proof.task_graph_source_refs_ok === true,
-    goal_refs_ok: proof.goal_mode_generation_refs_ok === true && proof.task_graph_goal_refs_ok === true,
-    backfill_count: scheduler.backfill_count || 0,
-    expected_backfill_count: scheduler.expected_backfill_count || 0,
-    blockers: []
-};
-result.blockers.push(...(result.output_schema_used ? [] : ['output_schema_not_used_by_all_workers']));
-result.blockers.push(...(result.all_result_files_exist ? [] : ['worker_result_file_missing']));
-result.blockers.push(...(result.all_output_last_message_json_valid ? [] : ['output_last_message_json_parse_failed']));
-result.blockers.push(...(result.all_agent_result_schemas_valid ? [] : ['agent_result_schema_invalid']));
-result.blockers.push(...(scheduler.backfill_count >= scheduler.expected_backfill_count ? [] : ['backfill_count_below_expected']));
-result.blockers.push(...(result.terminal_close_reports_ok ? [] : ['terminal_close_reports_missing']));
-result.blockers.push(...(result.process_cleanup_ok ? [] : ['worker_process_cleanup_failed']));
-result.blockers.push(...(changedFiles.length === 0 ? [] : ['real_smoke_changed_files_not_empty']));
-result.blockers.push(...(result.source_refs_ok ? [] : ['source_intelligence_refs_missing']));
-result.blockers.push(...(result.goal_refs_ok ? [] : ['goal_mode_refs_missing']));
-result.ok = result.blockers.length === 0;
-result.status = result.ok ? (fixtureInstrumented ? 'fixture_instrumented_real' : 'passed') : 'blocked';
-result.proof_level = result.ok ? (fixtureInstrumented ? 'fixture_instrumented_real' : 'proven') : 'blocked';
-writeReport(result);
-assertGate(result.ok, 'real codex dynamic smoke proof failed', result);
-emitGate('agent:real-codex-dynamic-smoke', { status: result.status, mission_id: result.mission_id, backfill_count: result.backfill_count });
-function optionalOrBlocked(reason, code, extra = {}) {
-    const report = {
-        ok: !required,
-        status: required ? 'blocked' : 'integration_optional',
-        proof_level: required ? 'real_required_missing' : 'integration_optional',
-        schema: 'sks.real-codex-dynamic-smoke.v2',
-        proof_contract: 'sks.real-codex-dynamic-smoke.v3',
-        release_version: releaseVersion,
-        required,
-        reason,
-        blockers: required ? [code] : [],
-        ...extra
-    };
-    writeReport(report);
-    emitGate('agent:real-codex-dynamic-smoke', { status: report.status, reason: code });
-    process.exit(required ? 1 : 0);
-}
-function writeReport(report) {
-    fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-}
-function parseJson(stdout) {
-    const start = stdout.indexOf('{');
-    const end = stdout.lastIndexOf('}');
-    return JSON.parse(stdout.slice(start, end + 1));
-}
-function readJson(file, fallback) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch (err) {
-        if (arguments.length > 1)
-            return fallback;
-        throw err;
-    }
-}
-function resolveReportPath(ledgerRoot, file) {
-    if (!file)
-        return '';
-    return path.isAbsolute(file) ? file : path.join(ledgerRoot, file);
-}
-function processAlive(pid) {
-    if (!pid)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function listNamedFiles(dir, name) {
-    const out = [];
-    if (!fs.existsSync(dir))
-        return out;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...listNamedFiles(file, name));
-        else if (entry.isFile() && entry.name === name)
-            out.push(file);
-    }
-    return out;
-}
-//# sourceMappingURL=agent-real-codex-dynamic-smoke-check.js.map

package/dist/scripts/agent-real-codex-dynamic-smoke-v2-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const run = spawnSync(process.execPath, ['dist/scripts/agent-real-codex-dynamic-smoke-check.js'], {
-    cwd: root,
-    encoding: 'utf8',
-    env: { ...process.env },
-    maxBuffer: 1024 * 1024 * 8,
-    timeout: Number(process.env.SKS_REAL_SMOKE_TIMEOUT_MS || 10 * 60 * 1000)
-});
-assertGate(run.status === 0, 'real codex dynamic smoke v2 wrapper failed', { stdout: run.stdout.slice(-2000), stderr: run.stderr.slice(-2000), status: run.status });
-emitGate('agent:real-codex-dynamic-smoke-v2', { status: 'delegated_to_v2_report' });
-//# sourceMappingURL=agent-real-codex-dynamic-smoke-v2-check.js.map