sneakoscope 6.2.0 → 6.4.0

package/dist/scripts/agent-slot-pane-binding-proof-check.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const proof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-slot-pane-binding-proof.js')).href);
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-slot-pane-binding-'));
-const records = [1, 2, 3].map((index) => ({
-    session_id: `slot-001-gen-${index}`,
-    slot_id: 'slot-001',
-    generation_index: index,
-    pane_kind: index === 1 ? 'slot_status_renderer' : 'worker_codex_sdk',
-    zellij_pane_id: String(100 + index),
-    zellij_pane_id_source: index % 2 ? 'zellij_worker_new_pane_stdout' : 'zellij_worker_list_panes',
-    scaling_primitive: index === 1 ? 'native_cli_process_with_zellij_slot_renderer' : 'native_cli_process_in_zellij_worker_pane',
-    sdk_thread_id: `sdk-thread-${index}`,
-    sdk_run_id: `sdk-run-${index}`,
-    stream_event_count: 4,
-    structured_output_valid: true,
-    status: 'closed'
-}));
-await fs.writeFile(path.join(tmp, 'agent-native-cli-session-swarm.json'), `${JSON.stringify({
-    schema: 'sks.agent-native-cli-session-swarm.v1',
-    ok: true,
-    closed_worker_process_count: records.length,
-    zellij_pane_worker_sessions: records.length,
-    max_observed_worker_process_count: 1,
-    target_active_slots: 1,
-    records
-}, null, 2)}\n`);
-await fs.writeFile(path.join(tmp, 'agent-zellij-pane-launch-ledger.jsonl'), records.map((record) => JSON.stringify({
-    schema: 'sks.agent-zellij-pane-launch.v1',
-    pane_kind: record.pane_kind,
-    persistent_slot_lane: false,
-    scaling_primitive: record.scaling_primitive,
-    slot_id: record.slot_id,
-    generation_index: record.generation_index,
-    pane_id: record.zellij_pane_id,
-    pane_id_source: record.zellij_pane_id_source,
-    sdk_thread_id: record.sdk_thread_id,
-    sdk_run_id: record.sdk_run_id,
-    stream_event_count: record.stream_event_count,
-    structured_output_valid: record.structured_output_valid
-})).join('\n') + '\n');
-const report = await proof.writeAgentSlotPaneBindingProof(tmp, { requireZellij: true, reportPath: path.join(root, '.sneakoscope', 'reports', 'agent-slot-pane-binding-proof.json') });
-const badRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-slot-pane-binding-bad-'));
-await fs.writeFile(path.join(badRoot, 'agent-native-cli-session-swarm.json'), `${JSON.stringify({
-    closed_worker_process_count: 1,
-    zellij_pane_worker_sessions: 1,
-    records: [{ ...records[0], zellij_pane_id_source: 'synthetic_layout_pending_proof' }]
-})}\n`);
-await fs.writeFile(path.join(badRoot, 'agent-zellij-pane-launch-ledger.jsonl'), '');
-const bad = await proof.evaluateAgentSlotPaneBindingProof(badRoot, { requireZellij: true });
-const ok = report.ok && report.sdk_thread_count === records.length && bad.ok === false && bad.blockers.includes('slot_pane_binding_synthetic_or_missing_pane_id_source');
-emit({ schema: 'sks.agent-slot-pane-binding-proof-check.v1', ok, report, bad, blockers: ok ? [] : ['agent_slot_pane_binding_proof_check_failed'] });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.agent-slot-pane-binding-proof-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=agent-slot-pane-binding-proof-check.js.map

package/dist/scripts/agent-slot-telemetry-wiring-check.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
-const worker = readText('src/core/agents/native-cli-worker.ts');
-for (const token of ['slot_reserved', 'worker_spawned', 'heartbeat', 'task_progress', 'artifact_written', 'worker_completed', 'worker_failed']) {
-    assertGate(swarm.includes(token) || worker.includes(token), `missing telemetry lifecycle event ${token}`);
-}
-assertGate(swarm.includes('appendZellijSlotTelemetry') && worker.includes('appendZellijSlotTelemetry'), 'swarm and worker must append slot telemetry');
-assertGate(worker.includes('startWorkerProgressTelemetry'), 'native worker must pump progress telemetry while backend work is active');
-emitGate('agent:slot-telemetry-wiring', { lifecycle_events: 7, progress_pump: true });
-//# sourceMappingURL=agent-slot-telemetry-wiring-check.js.map

package/dist/scripts/agent-source-intelligence-propagation-check.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
-const allResultsHaveRefs = fixture.result.results.every((result) => result.source_intelligence_refs?.artifact === 'source-intelligence-evidence.json');
-assertGate(allResultsHaveRefs, 'all dynamic generations must propagate source intelligence refs', fixture.result.results);
-emitGate('agent:source-intelligence-propagation', { result_count: fixture.result.results.length });
-//# sourceMappingURL=agent-source-intelligence-propagation-check.js.map

package/dist/scripts/agent-strategy-to-lease-wiring-check.js

@@ -1,32 +0,0 @@
-#!/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 strategy = await importDist('core/strategy/strategy-compiler.js');
-const rosterMod = await importDist('core/agents/agent-roster.js');
-const partitionMod = await importDist('core/agents/agent-work-partition.js');
-const tmp = makeTempPatchProject('sks-strategy-lease-');
-const files = Array.from({ length: 10 }, (_, index) => `file-${index + 1}.txt`);
-const prompt = files.map((file) => `\`${file}\``).join(' ');
-const compiled = strategy.compileStrategy({ prompt, route: '$Agent', agentCount: 5 });
-const roster = rosterMod.buildAgentRoster({ agents: 5, concurrency: 4, prompt });
-const partition = await partitionMod.buildAgentWorkPartition(tmp, roster, prompt, {
-    route: '$Agent',
-    targetActiveSlots: 4,
-    desiredWorkItemCount: 10,
-    minimumWorkItems: 10,
-    strategyOwnershipPlan: compiled.file_ownership_plan,
-    microWins: compiled.gate.micro_wins
-});
-const writeLeases = partition.leases.filter((lease) => lease.kind === 'write');
-const report = { schema: 'sks.agent-strategy-to-lease-wiring-check.v1', ok: partition.ok, tmp, compiled, writeLeases };
-writeReport('agent-strategy-to-lease-wiring', report);
-assertGate(compiled.file_ownership_plan.no_overlap === true, 'strategy file ownership plan must have no overlaps', report);
-assertGate(writeLeases.length >= 10, 'strategy write targets must become write leases', report);
-assertGate(writeLeases.every((lease) => lease.strategy_task_id && lease.micro_win_id && lease.owner_persona), 'leases must carry strategy task, micro-win, and persona metadata', report);
-assertGate(writeLeases.every((lease) => lease.verification_node_id && lease.rollback_node_id), 'leases must carry verification and rollback node ids', report);
-assertGate(fs.existsSync(path.join(tmp, 'file-1.txt')), 'fixture sanity check failed', report);
-emitGate('agent:strategy-to-lease-wiring', { write_lease_count: writeLeases.length });
-//# sourceMappingURL=agent-strategy-to-lease-wiring-check.js.map

package/dist/scripts/agent-strategy-to-patch-strict-check.js

@@ -1,54 +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 proofMod = await importDist('core/agents/agent-patch-proof.js');
-const cleanProof = proofMod.buildAgentPatchProof({
-    queue: {
-        queued_count: 0,
-        entries: [{
-                id: 'entry-strict',
-                status: 'verified',
-                violations: [],
-                lease_id: 'lease-strict',
-                envelope: {
-                    task_slice_id: 'slice-strict',
-                    lease_id: 'lease-strict',
-                    lease_proof: {
-                        lease_id: 'lease-strict',
-                        owner_agent: 'agent-strict',
-                        strategy_task_id: 'task-strict',
-                        micro_win_id: 'win-strict',
-                        verification_node_id: 'verify-strict',
-                        rollback_node_id: 'rollback-strict'
-                    }
-                }
-            }],
-        events: [{ entry_id: 'entry-strict', event_type: 'verified' }],
-        ownership_ledger: [{ entry_id: 'entry-strict', lease_id: 'lease-strict', write_paths: ['strict.txt'] }]
-    },
-    merge: { ok: true, blockers: [] },
-    applyResults: [{ entry_id: 'entry-strict', ok: true, changed_files: ['strict.txt'], rollback_digest: 'digest-strict', verification: { status: 'verified' } }],
-    transactionJournal: { ok: true, blockers: [], event_count: 8 },
-    conflictRebase: { ok: true, blockers: [] }
-});
-const missingProof = proofMod.buildAgentPatchProof({
-    queue: {
-        queued_count: 0,
-        entries: [{ id: 'entry-missing', status: 'verified', violations: [], envelope: { lease_proof: {} } }]
-    },
-    merge: { ok: true, blockers: [] },
-    applyResults: [{ entry_id: 'entry-missing', ok: true, changed_files: ['missing.txt'], rollback_digest: 'digest', verification: { status: 'verified' } }],
-    transactionJournal: { ok: true, blockers: [], event_count: 8 },
-    conflictRebase: { ok: true, blockers: [] }
-});
-const report = { schema: 'sks.agent-strategy-to-patch-strict-check.v1', ok: cleanProof.ok && missingProof.ok === false, cleanProof, missingProof };
-writeReport('agent-strategy-to-patch-strict', report);
-assertGate(cleanProof.strategy_to_patch_ok === true, 'strict strategy-to-patch clean fixture must pass', report);
-assertGate(cleanProof.verification_node_coverage['entry-strict'] === 'verify-strict', 'verification node coverage must be recorded', report);
-assertGate(cleanProof.rollback_node_coverage['entry-strict'] === 'rollback-strict', 'rollback node coverage must be recorded', report);
-assertGate(missingProof.blockers.some((row) => row.includes('strategy_reference_missing')), 'missing strategy reference must block proof', report);
-assertGate(missingProof.blockers.some((row) => row.includes('verification_node_missing')), 'missing verification node must block proof', report);
-assertGate(missingProof.blockers.some((row) => row.includes('rollback_node_missing')), 'missing rollback node must block proof', report);
-emitGate('agent:strategy-to-patch-strict', { clean: cleanProof.ok, missing_blockers: missingProof.blockers.length });
-//# sourceMappingURL=agent-strategy-to-patch-strict-check.js.map

package/dist/scripts/agent-task-graph-expansion-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/agents/agent-task-graph.js');
-for (const [target, total] of [[5, 8], [5, 25], [20, 40]]) {
-    const graph = mod.buildAgentTaskGraph({ routeType: '$Team', prompt: `fixture ${target}/${total}`, targetActiveSlots: target, desiredWorkItems: total, minimumWorkItems: total });
-    assertGate(graph.schema === 'sks.agent-task-graph.v1', 'task graph schema mismatch', graph);
-    assertGate(graph.target_active_slots === target, 'target active slots mismatch', graph.route_work_count_summary);
-    assertGate(graph.total_work_items === total, 'total work items mismatch', graph.route_work_count_summary);
-    assertGate(graph.total_work_items > graph.target_active_slots || total === target, 'work items must be independent from active slots', graph.route_work_count_summary);
-    assertGate(graph.work_items.every((item) => item.work_item_id && item.required_persona_category && Array.isArray(item.dependencies) && Array.isArray(item.lease_requirements)), 'work item shape incomplete', graph.work_items[0]);
-}
-emitGate('agent:task-graph-expansion', { fixtures: ['5/8', '5/25', '20/40'] });
-//# sourceMappingURL=agent-task-graph-expansion-check.js.map

package/dist/scripts/agent-terminal-generations-check.js

@@ -1,23 +0,0 @@
-#!/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/agents/agent-terminal-session.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-terminal-generations-'));
-await fs.mkdir(path.join(root, 'sessions'), { recursive: true });
-await fs.writeFile(path.join(root, 'agent-events.jsonl'), '');
-const sessions = {};
-for (const generationIndex of [1, 2]) {
-    const agent = { id: 'slot-001', slot_id: 'slot-001', generation_index: generationIndex, session_id: `agent_slot-001-gen_${generationIndex}`, session_artifact_dir: path.join('sessions', 'slot-001', `gen-${generationIndex}`) };
-    sessions[agent.session_id] = { agent_id: agent.id, slot_id: agent.slot_id, generation_index: generationIndex, session_id: agent.session_id, status: 'closed', session_artifact_dir: agent.session_artifact_dir };
-    await mod.startAgentTerminalSession(root, agent, { backend: 'fake', real: false });
-    await mod.closeAgentTerminalSession(root, agent, { exitCode: 0, status: 'done' });
-}
-await fs.writeFile(path.join(root, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions }, null, 2));
-const closed = await mod.assertAgentTerminalSessionsClosed(root);
-assertGate(closed.ok === true, 'terminal close reports must exist for every generation', closed);
-assertGate(closed.total_sessions === 2, 'terminal generation count must be 2', closed);
-emitGate('agent:terminal-generations', { terminal_generation_count: closed.total_sessions });
-//# sourceMappingURL=agent-terminal-generations-check.js.map

package/dist/scripts/agent-visual-consistency-check.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const cockpit = readText('src/core/agents/agent-codex-cockpit.ts');
-for (const token of ['source_intelligence_status', 'super_search_status', 'codex_web_search_status', 'goal_mode_status', 'terminal_session_status', 'zellij_attach_command']) {
-    assertGate(cockpit.includes(token), `Codex App cockpit missing ${token}`);
-}
-emitGate('agent:visual-consistency', { dashboard_fields: 6 });
-//# sourceMappingURL=agent-visual-consistency-check.js.map

package/dist/scripts/agent-wiki-context-proof-check.js

@@ -1,76 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Gate: agent:wiki-context-proof
-// Proves the native agent kernel consults the TriWiki context pack (read-only) and
-// references it in proof: (1) the read-only pack loader behaves correctly with and
-// without a pack, (2) the orchestrator wires loadTriWikiRuntimeContext + writes the
-// artifact + passes it to proof, (3) agent-proof-evidence records the wiki proof fields.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, readText, root } from './sks-1-18-gate-lib.js';
-const triwiki = await importDist('core/triwiki-runtime.js');
-const coordinates = await importDist('core/wiki-coordinate.js');
-const { loadTriWikiRuntimeContext, triWikiProofRecord, writeTriWikiContextArtifact } = triwiki;
-// 1) Absent pack -> graceful fallback (present:false, warning, not consulted).
-const emptyRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-triwiki-empty-'));
-const emptyCtx = await loadTriWikiRuntimeContext(emptyRoot);
-assertGate(emptyCtx.present === false, 'absent pack must yield present:false', { ctx: emptyCtx });
-assertGate(typeof emptyCtx.warning === 'string' && emptyCtx.warning.length > 0, 'absent pack must carry a warning');
-assertGate(emptyCtx.context_pack_hash === null && emptyCtx.use_first.length === 0, 'absent pack must have null hash + no use_first');
-assertGate(triWikiProofRecord(emptyCtx).triwiki_context_consulted === false, 'absent pack proof must report not consulted');
-// 2) Present pack -> consulted with hash + attention rows.
-const packRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-triwiki-pack-'));
-const packDir = path.join(packRoot, '.sneakoscope', 'wiki');
-fs.mkdirSync(packDir, { recursive: true });
-const wiki = coordinates.compactWikiCoordinateIndex(coordinates.buildWikiCoordinateIndex({
-    mission: { id: 'project-wiki', coord: { rgba: [48, 132, 212, 240] } },
-    claims: [
-        { id: 'claim-a', text: 'claim a', status: 'supported', freshness: 'fresh', risk: 'low', trust_score: 0.95 },
-        { id: 'claim-b', text: 'claim b', status: 'weak', freshness: 'unknown', risk: 'high', trust_score: 0.5 }
-    ],
-    maxAnchors: 2
-}));
-const anchorById = new Map(wiki.a.map((row) => [row[0], row]));
-const pack = {
-    mission: 'project-wiki',
-    attention: {
-        mode: 'aggressive_triwiki_active_recall',
-        use_first: [['claim-a', anchorById.get('claim-a')?.[1], anchorById.get('claim-a')?.[7]]],
-        hydrate_first: [['claim-b', 'risk:high']]
-    },
-    wiki,
-    claims: [{ id: 'claim-a' }, { id: 'claim-b' }],
-    trust_summary: { avg: 0.71 }
-};
-fs.writeFileSync(path.join(packDir, 'context-pack.json'), `${JSON.stringify(pack, null, 2)}\n`);
-const ctx = await loadTriWikiRuntimeContext(packRoot);
-assertGate(ctx.present === true, 'present pack must yield present:true', { ctx });
-assertGate(typeof ctx.context_pack_hash === 'string' && /^[0-9a-f]{64}$/.test(ctx.context_pack_hash), 'present pack must carry a sha256 hash', { hash: ctx.context_pack_hash });
-assertGate(ctx.mission === 'project-wiki', 'pack mission must be read', { mission: ctx.mission });
-assertGate(ctx.use_first.length === 1 && ctx.hydrate_first.length === 1, 'attention rows must be surfaced', { use: ctx.use_first.length, hyd: ctx.hydrate_first.length });
-assertGate(ctx.claim_count === 2 && ctx.anchor_count === 2, 'claim/anchor counts must be read', { claims: ctx.claim_count, anchors: ctx.anchor_count });
-const proof = triWikiProofRecord(ctx);
-assertGate(proof.triwiki_context_consulted === true && proof.context_pack_hash === ctx.context_pack_hash, 'present pack proof must report consulted + hash');
-// 3) Artifact write.
-const ledger = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-triwiki-ledger-'));
-const artifactPath = await writeTriWikiContextArtifact(ledger, ctx);
-assertGate(fs.existsSync(artifactPath), 'context artifact must be written');
-const artifact = JSON.parse(fs.readFileSync(artifactPath, 'utf8'));
-assertGate(artifact.proof?.triwiki_context_consulted === true, 'artifact must embed proof record');
-// 4) Kernel + proof wiring (source-level so the consult cannot be silently removed).
-const orchestrator = readText('src/core/agents/agent-orchestrator.ts');
-assertGate(orchestrator.includes('loadTriWikiRuntimeContext') && orchestrator.includes('writeTriWikiContextArtifact') && orchestrator.includes('triwikiContext'), 'orchestrator must consult TriWiki + write artifact + pass to proof');
-const proofSrc = readText('src/core/agents/agent-proof-evidence.ts');
-assertGate(proofSrc.includes('triwiki_context_consulted') && proofSrc.includes('context_pack_hash') && proofSrc.includes("triwiki_context: 'agent-triwiki-context.json'"), 'agent-proof-evidence must record the TriWiki proof fields');
-for (const dir of [emptyRoot, packRoot, ledger]) {
-    try {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    catch { /* best-effort */ }
-}
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-fs.mkdirSync(reportDir, { recursive: true });
-fs.writeFileSync(path.join(reportDir, 'agent-wiki-context-proof.json'), `${JSON.stringify({ schema: 'sks.agent-wiki-context-proof.v1', ok: true, present_pack_hash: ctx.context_pack_hash, use_first: ctx.use_first.length, hydrate_first: ctx.hydrate_first.length }, null, 2)}\n`);
-emitGate('agent:wiki-context-proof', { kernel_consults_triwiki: true, proof_records_hash: true });
-//# sourceMappingURL=agent-wiki-context-proof-check.js.map

package/dist/scripts/agent-worker-backend-router-check.js

@@ -1,63 +0,0 @@
-#!/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, root as repoRoot } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/agents/native-cli-worker.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-worker-router-'));
-const old = snapshotEnv();
-process.env.SKS_DISABLE_ROUTE_RECURSION = '1';
-process.env.SKS_AGENT_WORKER = '1';
-process.env.SKS_FAST_MODE = '1';
-process.env.SKS_SERVICE_TIER = 'fast';
-try {
-    const result = await mod.runNativeCliWorker({
-        intakeJson: {
-            mission_id: 'M-router-check',
-            parent_mission_id: 'M-router-check',
-            route: '$Agent',
-            backend: 'process',
-            agent_root: root,
-            agent: { id: 'router-agent', session_id: 'router-session', slot_id: 'slot-001', generation_index: 1, persona_id: 'executor' },
-            slice: { id: 'router-task', write_paths: ['router-output.txt'], description: 'exercise real process child backend' },
-            worker_artifact_dir: 'sessions/slot-001/gen-1/worker',
-            result_path: 'sessions/slot-001/gen-1/worker/worker-result.json',
-            heartbeat_path: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
-            patch_envelope_path: 'sessions/slot-001/gen-1/worker/worker-patch-envelope.json',
-            fast_mode: true,
-            service_tier: 'fast'
-        }
-    });
-    const workerDir = path.join(root, 'sessions', 'slot-001', 'gen-1', 'worker');
-    const router = JSON.parse(await fs.readFile(path.join(workerDir, 'worker-backend-router-report.json'), 'utf8'));
-    const patch = JSON.parse(await fs.readFile(path.join(workerDir, 'worker-patch-envelope.json'), 'utf8'));
-    assertGate(result.status === 'done', 'process backend worker result must be done', result);
-    assertGate(router.selected_backend === 'process', 'router selected backend mismatch', router);
-    assertGate(router.child_process_ids.length === 1, 'router must record child process id', router);
-    assertGate(patch.envelopes[0].source === 'process_generated', 'process backend patch envelope source missing', patch);
-    assertGate(result.backend_router_report?.proof_level === 'process_child_proven', 'router proof level must show process child', result.backend_router_report);
-    await fs.mkdir(path.join(repoRoot, '.sneakoscope', 'reports'), { recursive: true });
-    await fs.writeFile(path.join(repoRoot, '.sneakoscope', 'reports', 'agent-worker-backend-router.json'), `${JSON.stringify({ ok: true, router, patch_source: patch.envelopes[0].source }, null, 2)}\n`);
-    emitGate('agent:worker-backend-router', { backend: router.selected_backend, child_process_ids: router.child_process_ids.length, patch_source: patch.envelopes[0].source });
-}
-finally {
-    restoreEnv(old);
-}
-function snapshotEnv() {
-    return {
-        SKS_DISABLE_ROUTE_RECURSION: process.env.SKS_DISABLE_ROUTE_RECURSION,
-        SKS_AGENT_WORKER: process.env.SKS_AGENT_WORKER,
-        SKS_FAST_MODE: process.env.SKS_FAST_MODE,
-        SKS_SERVICE_TIER: process.env.SKS_SERVICE_TIER
-    };
-}
-function restoreEnv(old) {
-    for (const [key, value] of Object.entries(old)) {
-        if (value === undefined)
-            delete process.env[key];
-        else
-            process.env[key] = value;
-    }
-}
-//# sourceMappingURL=agent-worker-backend-router-check.js.map

package/dist/scripts/agent-worker-scout-limited-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/agents/scout-policy.js');
-const local = mod.validateWorkerScoutEvidence(path.join(root, '.sneakoscope/missions/fixture/agents'), {
-    agent_id: 'agent_1',
-    artifact_path: 'sessions/agent_1/worker-scout/evidence.json'
-});
-const global = mod.validateWorkerScoutEvidence(path.join(root, '.sneakoscope/missions/fixture/agents'), {
-    agent_id: 'agent_1',
-    artifact_path: '../scout-ledger.json'
-});
-assertGate(local.ok === true && local.central_proof_ssot === false, 'worker Scout local evidence must be accepted only as local evidence', local);
-assertGate(global.ok === false, 'worker Scout global artifact must be blocked', global);
-emitGate('agent:worker-scout-limited', { local_ok: local.ok, global_ok: global.ok });
-//# sourceMappingURL=agent-worker-scout-limited-check.js.map

package/dist/scripts/agent-zellij-dynamic-backfill-panes-check.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const proof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-slot-pane-binding-proof.js')).href);
-const targetActiveSlots = 4;
-const workItems = 10;
-const records = Array.from({ length: workItems }, (_, index) => {
-    const slotIndex = (index % targetActiveSlots) + 1;
-    const generationIndex = Math.floor(index / targetActiveSlots) + 1;
-    const slotId = `slot-${String(slotIndex).padStart(3, '0')}`;
-    return {
-        slot_id: slotId,
-        generation_index: generationIndex,
-        pane_name: `${slotId}/gen-${generationIndex}`,
-        active_at_once: targetActiveSlots
-    };
-});
-const report = proof.evaluateWorkerPaneBackfillProof(records, targetActiveSlots, workItems);
-const bad = proof.evaluateWorkerPaneBackfillProof(records.slice(0, 5), targetActiveSlots, workItems);
-const ok = report.ok
-    && report.generation_record_count >= 10
-    && report.distinct_pane_count >= 10
-    && bad.ok === false
-    && bad.blockers.includes('dynamic_backfill_generation_records_missing');
-emit({ schema: 'sks.agent-zellij-dynamic-backfill-panes-check.v1', ok, report, bad, blockers: ok ? [] : ['agent_zellij_dynamic_backfill_panes_check_failed'] });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.agent-zellij-dynamic-backfill-panes-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=agent-zellij-dynamic-backfill-panes-check.js.map

package/dist/scripts/agent-zellij-runtime-check.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const supervisor = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'zellij-lane-supervisor.js')).href);
-const runner = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-runner-zellij.js')).href);
-const nativeSwarm = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'native-cli-session-swarm.js')).href);
-const manager = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-worker-pane-manager.js')).href);
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-agent-zellij-'));
-await supervisor.initializeZellijLaneSupervisorEmpty(tmp, { missionId: 'M-agent-zellij', sessionName: 'sks-M-agent-zellij' });
-const supervisorState = JSON.parse(await fs.readFile(path.join(tmp, 'agent-zellij-lane-supervisor.json'), 'utf8'));
-const runtimeManifest = JSON.parse(await fs.readFile(path.join(tmp, 'zellij-lane-runtime.json'), 'utf8'));
-const agent = { id: 'agent_1', session_id: 'session_1', persona_id: 'agent_1', slot_id: 'slot-001', generation_index: 1 };
-const result = await runner.runZellijAgent(agent, { id: 'work-001' }, { agentRoot: tmp, missionId: 'M-agent-zellij' });
-const supervisorOk = supervisorState.lane_count === 0
-    && supervisorState.lanes.length === 0
-    && supervisorState.all_lanes_closed_after_drain === true
-    && runtimeManifest.lanes.length === 0;
-const paneWorkerCommand = nativeSwarm.buildPaneWorkerCommand({
-    args: ['/tmp/sks.js', '--agent', 'worker', '--intake', '/tmp/worker-intake.json', '--json'],
-    stdoutPath: '/tmp/worker.stdout.log',
-    stderrPath: '/tmp/worker.stderr.log',
-    heartbeatPath: '/tmp/worker-heartbeat.jsonl',
-    env: {
-        SKS_AGENT_WORKER: '1',
-        SKS_PARENT_MISSION_ID: 'M-agent-zellij',
-        SKS_AGENT_SLOT_ID: 'slot-001',
-        SKS_ZELLIJ_WORKER_PANE: '1'
-    }
-});
-const paneArtifact = manager.buildWorkerPaneArtifact({
-    root: tmp,
-    missionId: 'M-agent-zellij',
-    sessionName: 'sks-M-agent-zellij',
-    slotId: 'slot-001',
-    generationIndex: 1,
-    sessionId: 'slot-001-gen-1',
-    workerArtifactDir: 'sessions/slot-001/gen-1/worker',
-    resultPath: 'sessions/slot-001/gen-1/worker/worker-result.json',
-    heartbeatPath: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
-    patchEnvelopePath: 'sessions/slot-001/gen-1/worker/worker-patch-envelope.json',
-    stdoutLog: 'sessions/slot-001/gen-1/worker/worker.stdout.log',
-    stderrLog: 'sessions/slot-001/gen-1/worker/worker.stderr.log',
-    paneId: '1',
-    paneIdSource: 'zellij_worker_new_pane_stdout',
-    status: 'running',
-    blockers: []
-});
-const expectedPanePrefix = 'slot-001/gen-1';
-const paneTitle = String(paneArtifact.pane_title || paneArtifact.pane_name || '');
-const providerContext = paneArtifact.provider_context || {};
-const paneWorkerOk = paneWorkerCommand.includes('SKS_ZELLIJ_WORKER_PANE=')
-    && paneWorkerCommand.includes('--agent')
-    && paneWorkerCommand.includes('worker')
-    && paneWorkerCommand.includes('worker.stdout.log')
-    && paneWorkerCommand.includes('worker-heartbeat.jsonl')
-    && paneWorkerCommand.includes('2>&1 | tee -a')
-    && paneWorkerCommand.includes('code=$(cat')
-    && paneWorkerCommand.includes('worker-heartbeat.jsonl.exit')
-    && paneArtifact.pane_name === paneTitle
-    && paneTitle.startsWith(expectedPanePrefix)
-    && paneTitle.includes('codex-sdk')
-    && paneTitle.includes('tier-unknown')
-    && paneTitle.includes('provider-unknown')
-    && paneArtifact.provider === 'unknown'
-    && paneArtifact.service_tier === 'unknown'
-    && providerContext.schema === 'sks.provider-context.v1'
-    && providerContext.provider === 'unknown'
-    && providerContext.service_tier === 'unknown'
-    && paneArtifact.scaling_primitive === 'native_cli_process_in_zellij_worker_pane';
-const ok = result.status === 'done' && result.backend === 'zellij' && supervisorOk && paneWorkerOk;
-const report = { schema: 'sks.agent-zellij-runtime-check.v1', ok, result, supervisor_ok: supervisorOk, pane_worker_ok: paneWorkerOk, pane_worker_command: paneWorkerCommand, pane_artifact: paneArtifact, supervisor: supervisorState, runtime_manifest: runtimeManifest, blockers: ok ? [] : ['agent_zellij_runtime_check_failed'] };
-await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'agent-zellij-runtime.json'), `${JSON.stringify(report, null, 2)}\n`);
-emit(report);
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.agent-zellij-runtime-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=agent-zellij-runtime-check.js.map

package/dist/scripts/appshots-capability-check.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/codex/appshots-detector.js');
-const notRequired = mod.detectAppshotsCapability({ prompt: 'nonvisual release metadata' });
-const visualWithOperator = mod.detectAppshotsCapability({ prompt: 'verify UI with Appshots', operatorActionRecorded: true });
-const visualMissing = mod.detectAppshotsCapability({ prompt: 'verify UI with Appshots' });
-const report = { schema: 'sks.appshots-capability-check.v1', ok: notRequired.ok && visualWithOperator.ok && !visualMissing.ok, notRequired, visualWithOperator, visualMissing };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-capability.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(notRequired.status === 'not_required', 'nonvisual prompts must not require Appshots', report);
-assertGate(visualWithOperator.ok === true, 'operator-recorded visual Appshots must pass', report);
-assertGate(visualMissing.ok === false, 'missing visual Appshots operator action must block', report);
-emitGate('appshots:capability', { visual_required: visualWithOperator.visual_required });
-//# sourceMappingURL=appshots-capability-check.js.map

package/dist/scripts/appshots-evidence-check.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const mod = await importDist('core/source-intelligence/appshots-evidence.js');
-const fixture = writeAppshotFixture('evidence');
-const evidence = mod.buildAppshotsEvidence({
-    root,
-    prompt: 'visual Appshots proof',
-    sourcePaths: [fixture.rel],
-    sourceMetadata: [fixture.metadata],
-    operatorActionRecorded: true
-});
-const report = { schema: 'sks.appshots-evidence-check.v1', ok: evidence.ok, evidence };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-evidence.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(evidence.ok === true, 'Appshots evidence must pass with source path', report);
-assertGate(evidence.status === 'recorded', 'Appshots evidence must mark recorded visual source', report);
-assertGate(evidence.proof_level === 'fixture_instrumented_real', 'Appshots fixture evidence must not be promoted to proven', report);
-assertGate(evidence.source_verification.every((row) => row.accepted === true), 'Appshots evidence must verify source metadata', report);
-emitGate('appshots:evidence', { source_count: evidence.source_count });
-function writeAppshotFixture(name) {
-    const dir = path.join(root, '.sneakoscope', 'reports', 'appshots-fixtures');
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, `${name}.redacted-appshot.json`);
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    const rel = path.relative(root, file).split(path.sep).join('/');
-    return {
-        rel,
-        metadata: {
-            path: rel,
-            source_type: 'codex_appshot',
-            origin: 'fixture',
-            operator_attached: true,
-            frontmost_window: true,
-            redacted: true,
-            local_only: true,
-            fixture: true,
-            thread_id: 'thread-fixture-evidence',
-            attachment_id: 'attachment-fixture-evidence',
-            source_app: 'Codex',
-            source_window: 'Fixture Appshot'
-        }
-    };
-}
-//# sourceMappingURL=appshots-evidence-check.js.map

package/dist/scripts/appshots-operator-policy-check.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const detector = await importDist('core/codex/appshots-detector.js');
-const policyMod = await importDist('core/codex/appshots-operator-policy.js');
-const fixture = writeAppshotFixture('operator-policy');
-const capability = detector.detectAppshotsCapability({ prompt: 'visual Appshots check', operatorActionRecorded: true });
-const policy = policyMod.buildAppshotsOperatorPolicy(capability, { operatorActionRecorded: true, sourcePaths: [fixture.rel] });
-const report = { schema: 'sks.appshots-operator-policy-check.v1', ok: policy.ok, policy };
-const out = path.join(root, '.sneakoscope', 'reports', 'appshots-operator-policy.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(policy.ok === true, 'Appshots operator policy must pass when action is recorded', report);
-assertGate(policy.privacy_safety.no_background_screen_capture === true, 'Appshots policy must prevent background capture', report);
-emitGate('appshots:operator-policy', { mode: policy.mode });
-function writeAppshotFixture(name) {
-    const dir = path.join(root, '.sneakoscope', 'reports', 'appshots-fixtures');
-    fs.mkdirSync(dir, { recursive: true });
-    const file = path.join(dir, `${name}.redacted-appshot.json`);
-    fs.writeFileSync(file, `${JSON.stringify({ fixture: true, redacted: true, text: '[redacted appshot fixture]' })}\n`);
-    return { rel: path.relative(root, file).split(path.sep).join('/') };
-}
-//# sourceMappingURL=appshots-operator-policy-check.js.map