sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/agent-ast-aware-work-graph-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, readJson } from './sks-1-18-gate-lib.js';
-const inventoryMod = await importDist('core/agents/work-partition/repo-inventory.js');
-const depsMod = await importDist('core/agents/work-partition/dependency-graph.js');
-const graphMod = await importDist('core/agents/intelligent-work-graph.js');
-const inventory = await inventoryMod.collectRepoInventory(root, { maxFiles: 2000 });
-const dependencyGraph = depsMod.buildDependencyGraph(inventory);
-const graph = await graphMod.buildIntelligentWorkGraph({ root, inventory, dependencyGraph, route: '$Team', prompt: '1.18.6 AST-aware work graph release gate' });
-const releaseVersion = readJson('package.json').version;
-assertGate(graph.schema === 'sks.intelligent-work-graph.v2', 'intelligent work graph schema must be v2', graph);
-assertGate(graph.ast_coverage > 0, 'AST-aware work graph must record AST coverage', graph);
-assertGate(Object.keys(graph.file_to_symbols).length > 0, 'AST-aware work graph must build file-to-symbol map', graph);
-assertGate(Object.keys(graph.symbol_to_files).length > 0, 'AST-aware work graph must build symbol-to-file map', graph);
-assertGate(Object.keys(graph.exported_symbols).length > 0, 'AST-aware work graph must build exported symbol map', graph);
-assertGate(Object.keys(graph.imported_symbols).length > 0, 'AST-aware work graph must build imported symbol map', graph);
-assertGate(Object.keys(graph.command_to_module_ownership).length > 0, 'AST-aware work graph must build command ownership map', graph);
-assertGate(graph.test_ownership_confidence >= 0, 'AST-aware work graph must record test ownership confidence', graph);
-assertGate(['proven', 'partial', 'blocked'].includes(graph.proof_level), 'AST-aware work graph must report an honest proof level', graph);
-fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', `agent-intelligent-work-graph-v2-${releaseVersion}.json`), `${JSON.stringify(graphMod.compactIntelligentWorkGraph(graph), null, 2)}\n`);
-emitGate('agent:ast-aware-work-graph', { score: graph.work_graph_quality_score, ast_coverage: graph.ast_coverage, proof_level: graph.proof_level });
-//# sourceMappingURL=agent-ast-aware-work-graph-check.js.map

package/dist/scripts/agent-backfill-replenishment-check.js

@@ -1,13 +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: 5, total: 8 });
-const backfills = fixture.events.filter((event) => event.event_type === 'backfill_event');
-const firstSlowCompletionIndex = fixture.events.findIndex((event) => event.event_type === 'session_completed' && /work-00[3-5]/.test(String(event.work_item_id || '')));
-const secondBackfillIndex = fixture.events.findIndex((event, index) => index > fixture.events.findIndex((row) => row.event_type === 'backfill_event') && event.event_type === 'backfill_event');
-assertGate(backfills.length >= 2, 'two early completions must create two backfill events', { backfills });
-assertGate(secondBackfillIndex >= 0 && (firstSlowCompletionIndex < 0 || secondBackfillIndex < firstSlowCompletionIndex), 'replacement sessions must launch before the remaining first wave drains', { firstSlowCompletionIndex, secondBackfillIndex });
-assertGate(fixture.result.state.backfill_count >= fixture.result.state.expected_backfill_count, 'backfill count must satisfy expected backfills', fixture.result.state);
-emitGate('agent:backfill-replenishment', { backfill_count: fixture.result.state.backfill_count, expected_backfill_count: fixture.result.state.expected_backfill_count });
-//# sourceMappingURL=agent-backfill-replenishment-check.js.map

package/dist/scripts/agent-backfill-route-blackbox.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runRouteBackfillBlackbox } from './agent-route-blackbox-lib.js';
-runRouteBackfillBlackbox('$Agent', 'agent:backfill-route-blackbox');
-//# sourceMappingURL=agent-backfill-route-blackbox.js.map

package/dist/scripts/agent-background-terminals-check.js

@@ -1,16 +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-agent-terminal-'));
-await fs.writeFile(path.join(root, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions: { agent_1: { agent_id: 'agent_1', session_id: 's1', status: 'closed' } } }, null, 2));
-const agent = { id: 'agent_1', session_id: 's1' };
-await mod.startAgentTerminalSession(root, agent, { backend: 'fake', real: false });
-await mod.closeAgentTerminalSession(root, agent, { exitCode: 0, status: 'done' });
-const closed = await mod.assertAgentTerminalSessionsClosed(root);
-assertGate(closed.ok === true, 'every agent terminal session must have close report', closed);
-emitGate('agent:background-terminals', { terminal_sessions: closed.total_sessions });
-//# sourceMappingURL=agent-background-terminals-check.js.map

package/dist/scripts/agent-cleanup-command-ux-check.js

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const surface = await importDist('core/agents/agent-command-surface.js');
-const parsed = surface.parseAgentCommandArgs('agent', ['cleanup', 'latest', '--apply', '--dry-run', '--drain', '--stale-ms', '1234', '--json']);
-assertGate(parsed.action === 'cleanup', 'agent command parser must parse cleanup action', parsed);
-assertGate(parsed.apply === true, 'agent command parser must support --apply', parsed);
-assertGate(parsed.dryRun === true, 'agent command parser must support --dry-run', parsed);
-assertGate(parsed.drain === true, 'agent command parser must support --drain', parsed);
-assertGate(parsed.staleMs === 1234, 'agent command parser must support --stale-ms', parsed);
-emitGate('agent:cleanup-command-ux', { action: parsed.action, stale_ms: parsed.staleMs });
-//# sourceMappingURL=agent-cleanup-command-ux-check.js.map

package/dist/scripts/agent-cleanup-executor-check.js

@@ -1,53 +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 cleanup = await importDist('core/agents/agent-cleanup-executor.js');
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cleanup-executor-'));
-const missionDir = path.join(root, '.sneakoscope', 'missions', 'M-cleanup-fixture');
-const agentRoot = path.join(missionDir, 'agents');
-const projectHash = 'cleanupfixturehash';
-const tempDir = path.join(os.tmpdir(), `sks-${projectHash}-orphan`);
-const lockDir = path.join(os.tmpdir(), `sks-${projectHash}-locks`);
-await fs.mkdir(path.join(agentRoot, 'sessions', 'slot-001', 'gen-1'), { recursive: true });
-await fs.mkdir(tempDir, { recursive: true });
-await fs.mkdir(lockDir, { recursive: true });
-const lockFile = path.join(lockDir, 'stale.lock');
-await fs.writeFile(lockFile, 'stale\n');
-const staleTime = new Date(Date.now() - 60 * 60 * 1000);
-await fs.utimes(lockFile, staleTime, staleTime);
-await fs.writeFile(path.join(missionDir, 'project-session-namespace.json'), JSON.stringify({
-    schema: 'sks.project-session-namespace.v1',
-    mission_id: 'M-cleanup-fixture',
-    root_hash: projectHash,
-    orphan_temp_dirs: [tempDir, path.join(os.tmpdir(), 'foreign-temp')],
-    lock_dir: lockDir
-}, null, 2));
-await fs.writeFile(path.join(agentRoot, 'agent-sessions.json'), JSON.stringify({
-    sessions: {
-        active: { session_id: 'active-session', status: 'running' },
-        closed: { session_id: 'closed-session', status: 'closed' }
-    }
-}, null, 2));
-await fs.writeFile(path.join(agentRoot, 'sessions', 'slot-001', 'gen-1', 'agent-terminal-session.json'), '{}\n');
-const dry = await cleanup.runAgentCleanupExecutor({ missionDir, missionId: 'M-cleanup-fixture', action: 'cleanup', dryRun: true, staleMs: 1 });
-assertGate(dry.dry_run === true && dry.orphan_temp_dirs_found.includes(tempDir), 'cleanup dry-run must find orphan temp dir without applying', dry);
-assertGate(await exists(tempDir), 'cleanup dry-run removed temp dir unexpectedly', { tempDir });
-const applied = await cleanup.runAgentCleanupExecutor({ missionDir, missionId: 'M-cleanup-fixture', action: 'cleanup', apply: true, staleMs: 1 });
-assertGate(applied.ok === true, 'cleanup apply proof must pass', applied);
-assertGate(!(await exists(tempDir)), 'cleanup apply must remove namespaced orphan temp dir', applied);
-assertGate(!(await exists(lockFile)), 'cleanup apply must remove stale lock file', applied);
-assertGate(applied.terminal_transcripts_preserved.length === 1, 'cleanup must preserve terminal transcripts', applied);
-emitGate('agent:cleanup-executor', { removed_temp_dirs: applied.orphan_temp_dirs_removed.length, removed_locks: applied.stale_locks_removed.length });
-async function exists(file) {
-    try {
-        await fs.access(file);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=agent-cleanup-executor-check.js.map

package/dist/scripts/agent-cleanup-executor-v2-check.js

@@ -1,39 +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 { spawn } from 'node:child_process';
-import { assertGate, emitGate, importDist, root as repoRoot, readJson } from './sks-1-18-gate-lib.js';
-const cleanup = await importDist('core/agents/agent-cleanup-executor.js');
-const releaseVersion = readJson('package.json').version;
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cleanup-v2-'));
-const missionDir = path.join(root, '.sneakoscope', 'missions', 'M-cleanup-v2');
-const agentRoot = path.join(missionDir, 'agents');
-await fs.mkdir(path.join(agentRoot, 'sessions', 'slot-001', 'gen-1'), { recursive: true });
-await fs.writeFile(path.join(missionDir, 'project-session-namespace.json'), JSON.stringify({ mission_id: 'M-cleanup-v2', root_hash: 'cleanupv2' }, null, 2));
-await fs.writeFile(path.join(agentRoot, 'agent-sessions.json'), JSON.stringify({ sessions: { stale: { session_id: 'stale-session', status: 'closed' } } }, null, 2));
-const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore' });
-await fs.writeFile(path.join(agentRoot, 'sessions', 'slot-001', 'gen-1', 'agent-process-report.json'), JSON.stringify({
-    session_id: 'stale-session',
-    pid: child.pid,
-    exit_code: 0,
-    project_hash: 'cleanupv2'
-}, null, 2));
-try {
-    const proof = await cleanup.runAgentCleanupExecutor({ missionDir, missionId: 'M-cleanup-v2', apply: true, staleMs: 1 });
-    assertGate(proof.schema === 'sks.agent-cleanup-proof.v2', 'cleanup proof schema must be v2', proof);
-    assertGate(proof.sigterm_sent.includes(String(child.pid)), 'cleanup must send SIGTERM before escalation', proof);
-    assertGate(proof.process_exit_verified.includes(String(child.pid)), 'cleanup must verify process exit', proof);
-    assertGate(proof.process_trees.some((row) => row.target === String(child.pid)), 'cleanup must record process tree', proof);
-    await fs.mkdir(path.join(repoRoot, '.sneakoscope', 'reports'), { recursive: true });
-    await fs.writeFile(path.join(repoRoot, '.sneakoscope', 'reports', `agent-cleanup-executor-v2-${releaseVersion}.json`), `${JSON.stringify(proof, null, 2)}\n`);
-    emitGate('agent:cleanup-executor-v2', { actions: proof.action_count, sigterm: proof.sigterm_sent.length, sigkill: proof.sigkill_escalations.length });
-}
-finally {
-    try {
-        process.kill(child.pid, 'SIGKILL');
-    }
-    catch { }
-}
-//# sourceMappingURL=agent-cleanup-executor-v2-check.js.map

package/dist/scripts/agent-cli-options-to-task-graph-check.js

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

package/dist/scripts/agent-codex-app-cockpit-check.js

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const issues = [];
-for (const rel of ['src/core/agents/agent-codex-cockpit.ts', 'src/core/agents/agent-orchestrator.ts']) {
-    if (!fs.existsSync(path.join(root, rel)))
-        issues.push(`missing:${rel}`);
-}
-const source = read('src/core/agents/agent-codex-cockpit.ts');
-for (const token of [
-    'agent-codex-dashboard.md',
-    'agent-codex-dashboard.json',
-    'agent-session-cards.md',
-    'agent-live-summary.json',
-    'agent-progress-timeline.md',
-    'NativeSessionStart',
-    'NativeSessionStop'
-]) {
-    if (!source.includes(token))
-        issues.push(`cockpit_missing:${token}`);
-}
-if (!read('src/core/agents/agent-orchestrator.ts').includes('writeAgentCodexCockpitArtifacts')) {
-    issues.push('orchestrator_not_writing_cockpit');
-}
-if (!read('src/core/agents/agent-orchestrator.ts').includes('appendAgentCodexCockpitHookEvent')) {
-    issues.push('orchestrator_not_writing_cockpit_events');
-}
-for (const token of ['dashboard', 'cockpit', 'codexApp', 'agent-codex-dashboard.md']) {
-    if (!read('src/core/commands/agent-command.ts').includes(token) && !read('src/core/agents/agent-command-surface.ts').includes(token)) {
-        issues.push(`agent_command_cockpit_missing:${token}`);
-    }
-}
-await runFixture();
-const result = { schema: 'sks.agent-codex-app-cockpit-check.v1', ok: issues.length === 0, issues };
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function read(rel) {
-    try {
-        return fs.readFileSync(path.join(root, rel), 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-async function runFixture() {
-    const built = path.join(root, 'dist', 'core', 'agents', 'agent-codex-cockpit.js');
-    if (!fs.existsSync(built)) {
-        issues.push('fixture_dist_cockpit_missing_run_build_first');
-        return;
-    }
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-cockpit-'));
-    const missionDir = path.join(tmp, '.sneakoscope', 'missions', 'M-cockpit');
-    const agentDir = path.join(missionDir, 'agents');
-    fs.mkdirSync(agentDir, { recursive: true });
-    fs.writeFileSync(path.join(missionDir, 'mission.json'), JSON.stringify({ id: 'M-cockpit', mode: 'agent', created_at: '2026-05-25T00:00:00.000Z' }));
-    fs.writeFileSync(path.join(agentDir, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions: { agent_1: { agent_id: 'agent_1', session_id: 'session_1', status: 'closed', heartbeat_at: '2026-05-25T00:00:00.000Z' } } }));
-    fs.writeFileSync(path.join(agentDir, 'agent-proof-evidence.json'), JSON.stringify({ schema: 'sks.agent-proof-evidence.v1', ok: true, status: 'passed', mission_id: 'M-cockpit', backend: 'fake', agent_count: 1, all_sessions_closed: true, blockers: [] }));
-    const mod = await import(pathToFileURL(built).href);
-    await mod.appendAgentCodexCockpitHookEvent(missionDir, { hook_event_name: 'NativeSessionStart', agent_id: 'agent_1', session_id: 'session_1', cwd: tmp });
-    await mod.appendAgentCodexCockpitHookEvent(missionDir, { hook_event_name: 'NativeSessionStop', agent_id: 'agent_1', session_id: 'session_1', cwd: tmp, last_assistant_message: 'done' });
-    await mod.writeAgentCodexCockpitArtifacts(missionDir, { missionId: 'M-cockpit', projectHash: 'fixture' });
-    for (const artifact of ['agent-codex-dashboard.md', 'agent-codex-dashboard.json', 'agent-session-cards.md', 'agent-live-summary.json', 'agent-progress-timeline.md', 'agent-codex-cockpit-events.jsonl']) {
-        if (!fs.existsSync(path.join(agentDir, artifact)))
-            issues.push(`fixture_missing:${artifact}`);
-    }
-    const dashboard = JSON.parse(fs.readFileSync(path.join(agentDir, 'agent-codex-dashboard.json'), 'utf8'));
-    if (!dashboard.agents?.[0] || dashboard.agents[0].heartbeat_age_ms === undefined)
-        issues.push('fixture_heartbeat_age_missing');
-    if (dashboard.agents?.[0]?.status !== 'closed')
-        issues.push('fixture_object_session_status_not_rendered');
-    const eventStream = fs.readFileSync(path.join(agentDir, 'agent-codex-cockpit-events.jsonl'), 'utf8');
-    if (!eventStream.includes('NativeSessionStart') || !eventStream.includes('NativeSessionStop'))
-        issues.push('fixture_cockpit_event_stream_missing_native_session_lifecycle');
-    const cli = spawnSync(process.execPath, [path.join(root, 'dist/bin/sks.js'), 'agent', 'cockpit', 'M-cockpit'], { cwd: tmp, encoding: 'utf8' });
-    if (cli.status !== 0 || !cli.stdout.includes('Agent Codex Dashboard'))
-        issues.push('fixture_agent_cockpit_cli_failed');
-    const broken = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-cockpit-broken-'));
-    const brokenMission = path.join(broken, '.sneakoscope', 'missions', 'M-cockpit-broken');
-    fs.mkdirSync(path.join(brokenMission, 'agents'), { recursive: true });
-    await mod.writeAgentCodexCockpitArtifacts(brokenMission, { missionId: 'M-cockpit-broken', projectHash: 'fixture' });
-    const brokenDashboard = JSON.parse(fs.readFileSync(path.join(brokenMission, 'agents', 'agent-codex-dashboard.json'), 'utf8'));
-    if (!brokenDashboard.blockers?.includes('agent_sessions_missing'))
-        issues.push('fixture_missing_sessions_not_reported');
-}
-//# sourceMappingURL=agent-codex-app-cockpit-check.js.map

package/dist/scripts/agent-codex-child-overlap-check.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { emitGate, root } from './sks-1-18-gate-lib.js';
-import { buildFixtureProof } from './lib/real-codex-parallel-proof-fixture.js';
-const proof = await buildFixtureProof({ workers: 5, required: false });
-const observedParallelism = Math.max(Number(proof.max_observed_codex_child_process_overlap || 0), Number(proof.max_observed_codex_sdk_parallelism || 0));
-if (!proof.ok || observedParallelism < 5) {
-    console.error(JSON.stringify({ ok: false, proof }, null, 2));
-    process.exit(1);
-}
-fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'agent-codex-child-overlap.json'), `${JSON.stringify({ ok: true, ...proof }, null, 2)}\n`);
-emitGate('agent:codex-child-overlap', {
-    overlap: proof.max_observed_codex_child_process_overlap,
-    sdk_parallelism: proof.max_observed_codex_sdk_parallelism,
-    observed_parallelism: observedParallelism,
-    codex_child_process_count: proof.codex_child_process_count
-});
-//# sourceMappingURL=agent-codex-child-overlap-check.js.map

package/dist/scripts/agent-dynamic-cockpit-check.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const orchestrator = await importDist('core/agents/agent-orchestrator.js');
-const run = await orchestrator.runNativeAgentOrchestrator({ prompt: 'dynamic cockpit fixture', agents: 2, concurrency: 2, mock: true, backend: 'fake' });
-assertGate(run.ok === true, 'fake orchestrator run must pass', run.proof);
-assertGate(run.proof.target_active_slots === 2, 'proof must expose target active slots', run.proof);
-assertGate(run.proof.session_generation_count === 2, 'proof must expose session generation count', run.proof);
-emitGate('agent:dynamic-cockpit', { target_active_slots: run.proof.target_active_slots, session_generation_count: run.proof.session_generation_count });
-//# sourceMappingURL=agent-dynamic-cockpit-check.js.map

package/dist/scripts/agent-dynamic-pool-check.js

@@ -1,13 +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: 5, total: 8 });
-const state = fixture.result.state;
-assertGate(fixture.result.ok === true, 'dynamic pool fixture must drain cleanly', state);
-assertGate(state.target_active_slots === 5, 'target active slots must be 5', state);
-assertGate(state.max_observed_active_slots === 5, 'scheduler must observe 5 active slots', state);
-assertGate(state.pending_queue_drained === true, 'pending queue must drain', state);
-assertGate(state.all_slots_closed_after_drain === true, 'all slots must close after drain', state);
-emitGate('agent:dynamic-pool', { target_active_slots: state.target_active_slots, max_observed_active_slots: state.max_observed_active_slots, total_work_items: state.total_work_items });
-//# sourceMappingURL=agent-dynamic-pool-check.js.map

package/dist/scripts/agent-dynamic-pool-route-blackbox.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runRouteBackfillBlackbox } from './agent-route-blackbox-lib.js';
-runRouteBackfillBlackbox('$Agent', 'agent:dynamic-pool-route-blackbox');
-//# sourceMappingURL=agent-dynamic-pool-route-blackbox.js.map

package/dist/scripts/agent-fast-mode-default-check.js

@@ -1,62 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const distCli = path.join(root, 'dist', 'bin', 'sks.js');
-function run(extra = []) {
-    return JSON.parse(execFileSync(process.execPath, [
-        distCli,
-        'agent',
-        'run',
-        'fast mode default fixture',
-        '--mock',
-        '--agents',
-        '2',
-        '--concurrency',
-        '2',
-        '--work-items',
-        '2',
-        '--minimum-work-items',
-        '2',
-        '--json',
-        ...extra
-    ], { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 }));
-}
-const defaultRun = run();
-const noFastRun = run(['--no-fast']);
-const standardRun = run(['--service-tier', 'standard']);
-const report = {
-    schema: 'sks.agent-fast-mode-default-check.v1',
-    ok: true,
-    default: {
-        mission_id: defaultRun.mission_id,
-        fast_mode: defaultRun.fast_mode_policy?.fast_mode,
-        service_tier: defaultRun.fast_mode_policy?.service_tier,
-        worker_report_count: defaultRun.fast_mode_propagation?.worker_process_report_count
-    },
-    no_fast: {
-        mission_id: noFastRun.mission_id,
-        fast_mode: noFastRun.fast_mode_policy?.fast_mode,
-        service_tier: noFastRun.fast_mode_policy?.service_tier,
-        disabled_by: noFastRun.fast_mode_policy?.disabled_by
-    },
-    standard: {
-        mission_id: standardRun.mission_id,
-        fast_mode: standardRun.fast_mode_policy?.fast_mode,
-        service_tier: standardRun.fast_mode_policy?.service_tier,
-        disabled_by: standardRun.fast_mode_policy?.disabled_by
-    }
-};
-const out = path.join(root, '.sneakoscope', 'reports', 'agent-fast-mode-default.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(defaultRun.ok === true, 'default fast-mode agent run must pass', report);
-assertGate(defaultRun.fast_mode_policy?.fast_mode === true, 'default run must record fast_mode true', report);
-assertGate(defaultRun.fast_mode_policy?.service_tier === 'fast', 'default run must record service_tier fast', report);
-assertGate(defaultRun.fast_mode_propagation?.worker_process_report_count >= 2, 'worker process reports must record fast mode', report);
-assertGate(noFastRun.fast_mode_policy?.fast_mode === false && noFastRun.fast_mode_policy?.disabled_by === 'no-fast', '--no-fast must disable fast mode', report);
-assertGate(standardRun.fast_mode_policy?.service_tier === 'standard' && standardRun.fast_mode_policy?.fast_mode === false, '--service-tier standard must record standard tier', report);
-emitGate('agent:fast-mode-default', report.default);
-//# sourceMappingURL=agent-fast-mode-default-check.js.map

package/dist/scripts/agent-fast-mode-worker-propagation-check.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { emitGate } from './sks-1-18-gate-lib.js';
-import { runNativeCliSwarmCheck } from './lib/native-cli-session-swarm-check-lib.js';
-const report = runNativeCliSwarmCheck({ agents: 3, workItems: 3, reportName: 'agent-fast-mode-worker-propagation.json' });
-emitGate('agent:fast-mode-worker-propagation', { worker_process_report_count: report.fast_mode_propagation.worker_process_report_count });
-//# sourceMappingURL=agent-fast-mode-worker-propagation-check.js.map

package/dist/scripts/agent-follow-up-work-schema-check.js

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const validator = await importDist('core/agents/agent-worker-pipeline.js');
-const queueMod = await importDist('core/agents/agent-work-queue.js');
-const scheduler = await importDist('core/agents/agent-scheduler.js');
-const valid = {
-    id: 'follow-up-001',
-    title: 'Follow-up',
-    description: 'Validate a schema-bound generated work item.',
-    required_persona_category: 'verifier',
-    priority: 1,
-    dependencies: [],
-    lease_requirements: [],
-    max_attempts: 1,
-    reason: 'fixture'
-};
-const base = {
-    schema: 'sks.agent-result.v1',
-    mission_id: 'M-follow-up',
-    agent_id: 'agent_1',
-    session_id: 'session-1',
-    persona_id: 'agent_1',
-    task_slice_id: 'slice-01',
-    status: 'done',
-    backend: 'fake',
-    summary: 'ok',
-    findings: [],
-    proposed_changes: [],
-    changed_files: [],
-    lease_compliance: { ok: true, violations: [] },
-    artifacts: [],
-    blockers: [],
-    confidence: 'fixture',
-    handoff_notes: '',
-    unverified: [],
-    writes: [],
-    recursion_guard: { ok: true, violations: [] },
-    verification: { status: 'fixture', checks: [] }
-};
-const normalized = validator.validateAgentWorkerResult({ ...base, follow_up_work_items: [valid] });
-assertGate(normalized.status === 'done', 'valid follow_up_work_items must pass result validation', normalized);
-assertGate(normalized.follow_up_work_items?.length === 1, 'valid follow_up_work_items must survive normalization', normalized);
-const invalid = validator.validateAgentWorkerResult({ ...base, follow_up_work_items: [{ id: 'bad', title: 'bad' }] });
-assertGate(invalid.status === 'blocked', 'invalid follow_up_work_items must block result validation', invalid);
-const queue = queueMod.createAgentWorkQueue({ slices: [{ id: 'work-001', role: 'verifier', description: 'seed' }], maxQueueExpansion: 1 });
-const enqueue = queueMod.enqueueFollowUpWorkItems(queue, [valid, { ...valid, id: 'follow-up-002' }], { originSessionId: 'session-1' });
-assertGate(enqueue.accepted.length === 1, 'max_queue_expansion must cap accepted follow-up work', enqueue);
-assertGate(enqueue.blocked_count >= 1, 'follow-up overflow must be reported as blocked', enqueue);
-const result = await scheduler.runAgentScheduler({
-    root: await tempRoot(),
-    missionId: 'M-follow-up',
-    rootHash: 'fixture-root',
-    roster: { agent_count: 1, concurrency: 1, roster: [{ id: 'agent_1', persona_id: 'agent_1', role: 'verifier', write_policy: 'read-only', index: 1 }] },
-    partition: { slices: [{ id: 'work-001', role: 'verifier', description: 'seed' }] },
-    prompt: 'follow-up runtime fixture',
-    targetActiveSlots: 1,
-    sourceIntelligenceRefs: { ok: true, artifact: 'source-intelligence-evidence.json' },
-    goalModeRef: { ok: true, artifact: 'goal-mode-applied.json' },
-    maxQueueExpansion: 1,
-    launchSession: async ({ agent, workItem, generation }) => ({
-        ...base,
-        mission_id: 'M-follow-up',
-        agent_id: agent.id,
-        session_id: generation.session_id,
-        persona_id: agent.persona_id,
-        task_slice_id: workItem.id,
-        follow_up_work_items: workItem.id === 'work-001' ? [valid] : []
-    })
-});
-assertGate(result.state.generated_work_item_count === 1, 'scheduler must count generated follow-up work items', result.state);
-assertGate(result.state.total_work_items === 2, 'scheduler must enqueue generated follow-up work item', result.state);
-emitGate('agent:follow-up-work-schema', { generated_work_item_count: result.state.generated_work_item_count, total_work_items: result.state.total_work_items });
-async function tempRoot() {
-    const fs = await import('node:fs/promises');
-    const os = await import('node:os');
-    const path = await import('node:path');
-    return fs.mkdtemp(path.join(os.tmpdir(), 'sks-follow-up-work-'));
-}
-//# sourceMappingURL=agent-follow-up-work-schema-check.js.map

package/dist/scripts/agent-goal-mode-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: 5, total: 8 });
-const allResultsHaveRefs = fixture.result.results.every((result) => result.goal_mode_ref?.artifact === 'goal-mode-applied.json');
-assertGate(allResultsHaveRefs, 'all dynamic generations must propagate Goal mode refs', fixture.result.results);
-emitGate('agent:goal-mode-propagation', { result_count: fixture.result.results.length });
-//# sourceMappingURL=agent-goal-mode-propagation-check.js.map

package/dist/scripts/agent-intelligent-work-graph-check.js

@@ -1,25 +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 } from './sks-1-18-gate-lib.js';
-const inventoryMod = await importDist('core/agents/work-partition/repo-inventory.js');
-const depsMod = await importDist('core/agents/work-partition/dependency-graph.js');
-const graphMod = await importDist('core/agents/intelligent-work-graph.js');
-const inventory = await inventoryMod.collectRepoInventory(root, { maxFiles: 2000 });
-const dependencyGraph = depsMod.buildDependencyGraph(inventory);
-const graph = await graphMod.buildIntelligentWorkGraph({ root, inventory, dependencyGraph, route: '$Team', prompt: '1.18.6 intelligent work graph release gate' });
-const out = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-work-graph-'));
-await graphMod.writeIntelligentWorkGraphArtifacts(out, graph);
-assertGate(graph.schema === 'sks.intelligent-work-graph.v2', 'intelligent work graph schema mismatch', graph);
-assertGate(graph.source_inventory_count > 0, 'source inventory must be populated', graph);
-assertGate(graph.test_inventory_count > 0, 'test inventory must be populated', graph);
-assertGate(graph.critical_path.length > 0, 'critical path must be computed', graph.critical_path);
-assertGate(graph.parallelizable_groups.length > 0, 'parallelizable groups must be computed', graph);
-assertGate(graph.work_graph_quality_score >= 0.55, 'work graph quality score too low for release gate', graph);
-for (const file of ['agent-intelligent-work-graph.json', 'agent-test-ownership-map.json', 'agent-critical-path.json', 'agent-integration-bottlenecks.json']) {
-    await fs.access(path.join(out, file));
-}
-emitGate('agent:intelligent-work-graph', { score: graph.work_graph_quality_score, critical_path_length: graph.critical_path.length });
-//# sourceMappingURL=agent-intelligent-work-graph-check.js.map

package/dist/scripts/agent-janitor-check.js

@@ -1,76 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const issues = [];
-for (const rel of ['src/core/agents/agent-janitor.ts', 'src/core/agents/agent-orchestrator.ts', 'src/core/agents/agent-proof-evidence.ts']) {
-    if (!fs.existsSync(path.join(root, rel)))
-        issues.push(`missing:${rel}`);
-}
-if (!read('src/core/agents/agent-orchestrator.ts').includes('runAgentJanitor'))
-    issues.push('orchestrator_not_running_janitor');
-if (!read('src/core/agents/agent-orchestrator.ts').includes('periodic_janitor_blocked'))
-    issues.push('orchestrator_not_running_periodic_janitor');
-if (!read('src/core/agents/agent-proof-evidence.ts').includes('janitor_ok'))
-    issues.push('proof_missing_janitor_ok');
-await runFixture();
-const result = { schema: 'sks.agent-janitor-check.v1', ok: issues.length === 0, issues };
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function read(rel) {
-    try {
-        return fs.readFileSync(path.join(root, rel), 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-async function runFixture() {
-    const built = path.join(root, 'dist', 'core', 'agents', 'agent-janitor.js');
-    if (!fs.existsSync(built))
-        return;
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-janitor-'));
-    const missionDir = path.join(tmp, '.sneakoscope', 'missions', 'M-janitor');
-    const agentDir = path.join(missionDir, 'agents');
-    fs.mkdirSync(agentDir, { recursive: true });
-    fs.writeFileSync(path.join(agentDir, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions: { agent_1: { agent_id: 'agent_1', session_id: 's1', status: 'closed', heartbeat_at: '2026-05-25T00:00:00.000Z' } } }));
-    const mod = await import(pathToFileURL(built).href);
-    const report = await mod.runAgentJanitor({ missionDir, missionId: 'M-janitor', projectHash: 'fixture', staleMs: 1 });
-    if (!report.ok)
-        issues.push('fixture_closed_session_marked_stale');
-    if (!fs.existsSync(path.join(agentDir, 'agent-janitor-report.json')))
-        issues.push('fixture_janitor_report_missing');
-    const negative = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-janitor-negative-'));
-    const negativeMission = path.join(negative, '.sneakoscope', 'missions', 'M-janitor-negative');
-    const negativeAgentDir = path.join(negativeMission, 'agents');
-    const negativeSessionDir = path.join(negativeAgentDir, 'sessions', 'agent_1');
-    const lockDir = path.join(negative, '.sneakoscope', 'locks', 'fixture');
-    fs.mkdirSync(negativeSessionDir, { recursive: true });
-    fs.mkdirSync(lockDir, { recursive: true });
-    const activeTemp = path.join(os.tmpdir(), 'sks-fixture-active');
-    fs.mkdirSync(activeTemp, { recursive: true });
-    fs.writeFileSync(path.join(negativeMission, 'project-session-namespace.json'), JSON.stringify({ mission_id: 'M-janitor-negative', root_hash: 'fixture', lock_dir: lockDir, temp_dir: activeTemp }));
-    fs.writeFileSync(path.join(negativeAgentDir, 'agent-sessions.json'), JSON.stringify({ schema: 'sks.agent-sessions.v1', sessions: { agent_1: { agent_id: 'agent_1', session_id: 's1', status: 'running', heartbeat_at: '2026-05-25T00:00:00.000Z' } } }));
-    fs.writeFileSync(path.join(negativeSessionDir, 'agent-process-report.json'), JSON.stringify({ schema: 'sks.agent-process-report.v1', agent_id: 'agent_1', session_id: 's1', pid: 999999999, exit_code: null }));
-    fs.writeFileSync(path.join(negativeSessionDir, 'agent-zellij-report.json'), JSON.stringify({ schema: 'sks.agent-zellij-report.v1', agent_id: 'agent_1', session_id: 's1', launch_mode: 'launched' }));
-    const lockFile = path.join(lockDir, 'agent.lock');
-    fs.writeFileSync(lockFile, 'lock');
-    const old = new Date(Date.now() - 60_000);
-    fs.utimesSync(lockFile, old, old);
-    fs.utimesSync(path.join(negativeSessionDir, 'agent-zellij-report.json'), old, old);
-    const blocked = await mod.runAgentJanitor({ missionDir: negativeMission, missionId: 'M-janitor-negative', projectHash: 'fixture', staleMs: 1 });
-    for (const token of ['stale_heartbeat:s1', 'zombie_process:s1', 'stale_zellij:s1']) {
-        if (!blocked.blockers.includes(token))
-            issues.push(`fixture_janitor_missing:${token}`);
-    }
-    if (!blocked.blockers.some((entry) => entry.startsWith('stale_lock:')))
-        issues.push('fixture_janitor_missing_stale_lock');
-    await mod.runAgentJanitor({ missionDir: negativeMission, missionId: 'M-janitor-negative', projectHash: 'fixture', staleMs: 1, cleanup: true });
-    if (!fs.existsSync(activeTemp))
-        issues.push('fixture_janitor_deleted_active_temp_dir');
-}
-//# sourceMappingURL=agent-janitor-check.js.map

package/dist/scripts/agent-main-no-scout-check.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertFiles, assertGate, emitGate, importDist, AGENT_118_FILES } from './sks-1-18-gate-lib.js';
-assertFiles(AGENT_118_FILES);
-const mod = await importDist('core/agents/scout-policy.js');
-const ok = mod.detectMainScoutCall('native agent orchestrator creates workers');
-const bad = mod.detectMainScoutCall('main orchestrator runs sks scouts run now');
-assertGate(ok.ok === true, 'ordinary main text must pass no-Scout detector');
-assertGate(bad.ok === false, 'main Scout call must be blocked');
-emitGate('agent:main-no-scout', { violations_detected: bad.violations.length });
-//# sourceMappingURL=agent-main-no-scout-check.js.map

package/dist/scripts/agent-model-authored-patch-envelope-check.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { emitGate, root } from './sks-1-18-gate-lib.js';
-import { buildFixtureProof } from './lib/real-codex-parallel-proof-fixture.js';
-const proof = await buildFixtureProof({ workers: 3, required: false });
-if (!proof.ok || proof.model_authored_patch_envelope_count < 3 || proof.fixture_patch_envelope_count !== 0) {
-    console.error(JSON.stringify({ ok: false, proof }, null, 2));
-    process.exit(1);
-}
-fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'agent-model-authored-patch-envelope.json'), `${JSON.stringify({ ok: true, ...proof }, null, 2)}\n`);
-emitGate('agent:model-authored-patch-envelope', { model_authored_patch_envelope_count: proof.model_authored_patch_envelope_count });
-//# sourceMappingURL=agent-model-authored-patch-envelope-check.js.map