sneakoscope 4.0.13 → 4.0.15

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,79 @@
+#!/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 fastRun = run(['--fast']);
+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,
+        preference_mode: defaultRun.fast_mode_policy?.preference_mode,
+        explicit_fast: defaultRun.fast_mode_policy?.explicit_fast,
+        explicit_service_tier: defaultRun.fast_mode_policy?.explicit_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
+    },
+    fast: {
+        mission_id: fastRun.mission_id,
+        fast_mode: fastRun.fast_mode_policy?.fast_mode,
+        service_tier: fastRun.fast_mode_policy?.service_tier,
+        worker_report_count: fastRun.fast_mode_propagation?.worker_process_report_count
+    },
+    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 agent run must pass', report);
+assertGate(defaultRun.fast_mode_policy?.explicit_fast === false && defaultRun.fast_mode_policy?.explicit_service_tier === null, 'default run must not use explicit fast/service-tier flags', report);
+if (defaultRun.fast_mode_policy?.preference_mode === 'fast') {
+    assertGate(defaultRun.fast_mode_policy?.fast_mode === true && defaultRun.fast_mode_policy?.service_tier === 'fast', 'default run must honor saved fast preference', report);
+}
+else {
+    assertGate(defaultRun.fast_mode_policy?.fast_mode === false && defaultRun.fast_mode_policy?.service_tier === 'standard', 'default run without saved fast preference must record service_tier standard', report);
+}
+assertGate(fastRun.fast_mode_policy?.fast_mode === true, '--fast must enable fast mode', report);
+assertGate(fastRun.fast_mode_policy?.service_tier === 'fast', '--fast must record service_tier fast', report);
+assertGate(fastRun.fast_mode_propagation?.worker_process_report_count >= 2, 'worker process reports must record explicit 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

@@ -0,0 +1,7 @@
+#!/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', extraArgs: ['--fast'], expectedFastMode: true });
+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

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

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

@@ -0,0 +1,29 @@
+#!/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);
+let totalArtifactBytes = 0;
+for (const file of ['agent-intelligent-work-graph.json', 'agent-test-ownership-map.json', 'agent-source-test-ownership-v2.json', 'agent-symbol-ownership-map.json', 'agent-critical-path.json', 'agent-integration-bottlenecks.json']) {
+    const stat = await fs.stat(path.join(out, file));
+    totalArtifactBytes += stat.size;
+    assertGate(stat.size < 2 * 1024 * 1024, 'intelligent work graph artifacts must stay bounded per file', { file, bytes: stat.size });
+}
+assertGate(totalArtifactBytes < 8 * 1024 * 1024, 'intelligent work graph artifacts must stay bounded as a set', { totalArtifactBytes });
+emitGate('agent:intelligent-work-graph', { score: graph.work_graph_quality_score, critical_path_length: graph.critical_path.length, total_artifact_bytes: totalArtifactBytes });
+//# sourceMappingURL=agent-intelligent-work-graph-check.js.map

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

@@ -0,0 +1,79 @@
+#!/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');
+const janitorSrc = read('src/core/agents/agent-janitor.ts');
+if (!janitorSrc.includes("error?.code === 'ENOENT'") || !janitorSrc.includes("error?.code === 'ENOTDIR'"))
+    issues.push('janitor_list_files_missing_disappearing_dir_guard');
+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

@@ -0,0 +1,11 @@
+#!/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-message-bus-reader-check.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { appendAgentMessage, readAgentMessageBus } from '../core/agents/agent-message-bus.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const missionId = 'M-agent-message-reader';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-agent-message-'));
+const agents = path.join(root, '.sneakoscope', 'missions', missionId, 'agents');
+await fs.mkdir(agents, { recursive: true });
+await appendAgentMessage(agents, { from: 'slot-001', session_id: 's1', type: 'worker_completed', body: 'patch candidate verified', artifact_paths: ['a.json'] });
+await appendAgentMessage(agents, { from: 'slot-002', session_id: 's2', type: 'worker_failed', body: 'blocker git_worktree_merge_conflict', artifact_paths: ['b.json'] });
+const rows = await readAgentMessageBus(root, missionId, { max: 20 });
+assertGate(rows.length === 2, 'message bus reader must read jsonl entries', rows);
+assertGate(rows[0].event_type === 'worker_completed' && rows[1].event_type === 'worker_failed', 'message bus reader must normalize event types', rows);
+assertGate(rows[1].level === 'error', 'worker_failed message must normalize to error level', rows[1]);
+emitGate('agent:message-bus-reader', { rows });
+//# sourceMappingURL=agent-message-bus-reader-check.js.map

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

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