sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeTempPatchProject, writeReport } from './agent-patch-swarm-gate-lib.js';
+const queueMod = await importDist('core/agents/agent-patch-queue.js');
+const mergeMod = await importDist('core/agents/agent-merge-coordinator.js');
+const applyMod = await importDist('core/agents/agent-patch-apply-worker.js');
+const proofMod = await importDist('core/agents/agent-patch-proof.js');
+const tmp = makeTempPatchProject('sks-patch-proof-');
+const queue = new queueMod.InMemoryAgentPatchQueue();
+for (let index = 1; index <= 5; index += 1) {
+    queue.enqueue({
+        schema: 'sks.agent-patch-envelope.v1',
+        agent_id: `agent-${index}`,
+        session_id: `session-${index}`,
+        slot_id: `slot-${index}`,
+        generation_index: 1,
+        lease_id: `lease-${index}`,
+        lease_proof: { lease_id: `lease-${index}`, allowed_paths: [`file-${index}.txt`], strategy_task_id: `task-${index}`, owner_agent: `agent-${index}`, verification_node_id: `verify-${index}`, rollback_node_id: `rollback-${index}` },
+        rollback_hint: { node_id: `rollback-${index}` },
+        operations: [{ op: 'write', path: `file-${index}.txt`, content: `after-${index}\n` }]
+    });
+}
+const merge = mergeMod.coordinateAgentPatchMerge(queue.queued());
+const applyResults = [];
+for (const entry of queue.queued()) {
+    const applied = await applyMod.applyAgentPatchEnvelope(tmp, entry.envelope, { entryId: entry.id });
+    applyResults.push(applied);
+    if (applied.ok)
+        queue.markApplied(entry.id);
+}
+for (const entry of queue.entries)
+    queue.markVerified(entry.id);
+const verificationRollbackDag = {
+    nodes: queue.entries.flatMap((entry, index) => [
+        { id: `verify-${index + 1}`, kind: 'verification' },
+        { id: `rollback-${index + 1}`, kind: 'rollback' }
+    ])
+};
+const fileOwnershipPlan = {
+    owners: queue.entries.flatMap((entry, index) => (entry.write_paths || []).map((file) => ({ path: file, access: 'write', owner_agent: `agent-${index + 1}` })))
+};
+const proof = proofMod.buildAgentPatchProof({
+    queue: queue.toJSON(),
+    merge,
+    applyResults,
+    verification: applyResults.map((row) => row.verification.status),
+    parallelWritePolicy: { write_mode: 'parallel' },
+    verificationRollbackDag,
+    fileOwnershipPlan,
+    transactionJournal: { ok: true, blockers: [], event_count: 25 },
+    conflictRebase: { ok: true, blockers: [] }
+});
+const report = { schema: 'sks.agent-patch-proof-runtime-check.v1', ok: proof.ok, tmp, queue: queue.toJSON(), merge, applyResults, proof };
+writeReport('agent-patch-proof-runtime', report);
+assertGate(proof.ok === true, 'patch proof runtime must pass for verified disjoint patches', report);
+assertGate(proof.patch_queue_ok === true && proof.patch_apply_ok === true && proof.patch_verification_ok === true && proof.patch_rollback_ok === true, 'patch proof booleans must all pass', report);
+assertGate(proof.parallel_patch_apply_verified === true, 'patch proof must record parallel apply group evidence', report);
+assertGate(fs.readFileSync(path.join(tmp, 'file-1.txt'), 'utf8') === 'after-1\n', 'patch must be applied to fixture file', report);
+emitGate('agent:patch-proof-runtime', { changed_files: proof.changed_files.length });
+//# sourceMappingURL=agent-patch-proof-runtime-check.js.map

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

@@ -0,0 +1,36 @@
+#!/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

@@ -0,0 +1,38 @@
+#!/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

@@ -0,0 +1,14 @@
+#!/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

@@ -0,0 +1,10 @@
+#!/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

@@ -0,0 +1,10 @@
+#!/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

@@ -0,0 +1,76 @@
+#!/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

@@ -0,0 +1,57 @@
+#!/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

@@ -0,0 +1,14 @@
+#!/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

@@ -0,0 +1,5 @@
+#!/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

@@ -0,0 +1,166 @@
+#!/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

@@ -0,0 +1,14 @@
+#!/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