sneakoscope 6.2.0 → 6.4.0

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-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: 4, total: 8 });
-const state = fixture.result.state;
-assertGate(fixture.result.ok === true, 'dynamic pool fixture must drain cleanly', state);
-assertGate(state.target_active_slots === 4, 'target active slots must be desktop-safe (4)', state);
-assertGate(state.max_observed_active_slots === 4, 'scheduler must observe at most 4 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-fixture.js

@@ -1,80 +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 { importDist } from './sks-1-18-gate-lib.js';
-export async function runDynamicPoolFixture(opts = {}) {
-    const target = opts.target || 4;
-    const total = opts.total || 8;
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-dynamic-pool-'));
-    const scheduler = await importDist('core/agents/agent-scheduler.js');
-    const roster = {
-        schema: 'sks.agent-roster.v1',
-        agent_count: target,
-        concurrency: target,
-        roster: Array.from({ length: target }, (_, index) => ({
-            id: `agent_${index + 1}`,
-            persona_id: `agent_${index + 1}`,
-            role: index % 2 === 0 ? 'verifier' : 'implementer',
-            write_policy: 'read-only',
-            index: index + 1
-        }))
-    };
-    const slices = Array.from({ length: total }, (_, index) => ({
-        id: `work-${String(index + 1).padStart(3, '0')}`,
-        role: 'verifier',
-        description: `fixture work ${index + 1}`,
-        delay_ms: index < 2 ? 10 : index < target ? 90 : 15,
-        write_paths: [],
-        readonly_paths: []
-    }));
-    const launched = [];
-    const result = await scheduler.runAgentScheduler({
-        root,
-        missionId: 'M-dynamic-pool',
-        rootHash: 'fixture-root',
-        roster,
-        partition: { slices },
-        prompt: 'dynamic pool fixture',
-        targetActiveSlots: target,
-        sourceIntelligenceRefs: { artifact: 'source-intelligence-evidence.json', ok: true, mode: 'offline_context7_only' },
-        goalModeRef: { artifact: 'goal-mode-applied.json', ok: true, mode: 'sks_goal_fallback' },
-        launchSession: async ({ agent, workItem, generation }) => {
-            launched.push({ session_id: generation.session_id, slot_id: agent.slot_id, generation_index: agent.generation_index, work_item_id: workItem.id, started_at: Date.now() });
-            await delay(Number(workItem.slice?.delay_ms || 1));
-            return {
-                schema: 'sks.agent-result.v1',
-                mission_id: 'M-dynamic-pool',
-                agent_id: agent.id,
-                session_id: generation.session_id,
-                persona_id: agent.persona_id,
-                task_slice_id: workItem.id,
-                status: 'done',
-                backend: 'fake',
-                summary: `completed ${workItem.id}`,
-                findings: [],
-                proposed_changes: [],
-                changed_files: [],
-                lease_compliance: { ok: true, violations: [] },
-                artifacts: [path.join(generation.artifact_dir, 'agent-result.json')],
-                blockers: [],
-                confidence: 'fixture',
-                handoff_notes: '',
-                unverified: [],
-                writes: [],
-                source_intelligence_refs: agent.source_intelligence_refs,
-                goal_mode_ref: agent.goal_mode_ref,
-                recursion_guard: { ok: true, violations: [] },
-                verification: { status: 'fixture', checks: ['dynamic-pool-fixture'] }
-            };
-        }
-    });
-    const eventsText = await fs.readFile(path.join(root, 'agent-scheduler-events.jsonl'), 'utf8');
-    const events = eventsText.trim().split(/\n+/).filter(Boolean).map((line) => JSON.parse(line));
-    return { root, result, launched, events };
-}
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//# sourceMappingURL=agent-dynamic-pool-fixture.js.map

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

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-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 = []) {
-    const fixtureRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-agent-fast-mode-fixture-'));
-    const fixtureHome = path.join(fixtureRoot, 'home');
-    try {
-        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: fixtureRoot,
-            encoding: 'utf8',
-            env: {
-                ...process.env,
-                HOME: fixtureHome,
-                CODEX_HOME: path.join(fixtureHome, '.codex'),
-                SKS_GLOBAL_ROOT: path.join(fixtureHome, '.sneakoscope-global'),
-                TMPDIR: fixtureRoot,
-                TMP: fixtureRoot,
-                TEMP: fixtureRoot,
-                PWD: fixtureRoot,
-                SKS_TEST_ISOLATION: '1',
-                SKS_UPDATE_MIGRATION_GATE_DISABLED: '1',
-                NODE_ENV: 'test',
-                CI: 'true'
-            },
-            maxBuffer: 32 * 1024 * 1024
-        }));
-    }
-    finally {
-        fs.rmSync(fixtureRoot, { recursive: true, force: true });
-    }
-}
-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,
-        default_fast_mode: defaultRun.fast_mode_policy?.default_fast_mode,
-        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);
-assertGate(defaultRun.fast_mode_policy?.default_fast_mode === true, 'built-in Fast default must be recorded', report);
-if (defaultRun.fast_mode_policy?.preference_mode === 'standard') {
-    assertGate(defaultRun.fast_mode_policy?.fast_mode === false && defaultRun.fast_mode_policy?.service_tier === 'standard', 'default run must honor saved standard preference', report);
-}
-else {
-    assertGate(defaultRun.fast_mode_policy?.fast_mode === true && defaultRun.fast_mode_policy?.service_tier === 'fast', 'default run without a saved standard preference must use Fast', 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

@@ -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', 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

@@ -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: 4, 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,29 +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);
-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

@@ -1,79 +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');
-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

@@ -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