sneakoscope 4.0.13 → 4.0.14

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 || 5;
-    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-native-release-gate.js

@@ -1,274 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root, runSksJson } from './sks-1-11-gate-lib.js';
-const gate = process.argv[2] || path.basename(process.argv[1], '.mjs').replace(/-check$/, '');
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const runtimeFiles = [
-    'src/core/commands/team-command.ts',
-    'src/core/team-dag.ts',
-    'src/core/team-live.ts',
-    'src/core/research.ts',
-    'src/core/commands/research-command.ts',
-    'src/core/commands/qa-loop-command.ts',
-    'src/core/pipeline-internals/runtime-core.ts',
-    'src/core/pipeline-internals/runtime-gates.ts',
-    'src/core/proof/auto-finalize.ts',
-    'src/core/proof/route-finalizer.ts',
-    'src/core/proof/route-proof-gate.ts'
-];
-const agentFiles = [
-    'src/core/agents/agent-schema.ts',
-    'src/core/agents/agent-command-surface.ts',
-    'src/core/agents/agent-orchestrator.ts',
-    'src/core/agents/agent-worker-pipeline.ts',
-    'src/core/agents/agent-runner-codex-exec.ts',
-    'src/core/agents/agent-runner-process.ts',
-    'src/core/agents/agent-runner-fake.ts',
-    'src/core/agents/agent-runner-zellij.ts',
-    'src/core/agents/zellij-right-lane-cockpit.ts',
-    'src/core/agents/zellij-lane-supervisor.ts',
-    'src/core/agents/agent-persona.ts',
-    'src/core/agents/agent-roster.ts',
-    'src/core/agents/agent-effort-policy.ts',
-    'src/core/agents/route-collaboration-ledger.ts',
-    'src/core/agents/agent-task-slicer.ts',
-    'src/core/agents/agent-work-partition.ts',
-    'src/core/agents/agent-lease.ts',
-    'src/core/agents/agent-conflict-graph.ts',
-    'src/core/agents/agent-central-ledger.ts',
-    'src/core/agents/agent-ledger-schemas.ts',
-    'src/core/agents/agent-message-bus.ts',
-    'src/core/agents/agent-lifecycle.ts',
-    'src/core/agents/agent-heartbeat.ts',
-    'src/core/agents/agent-consensus.ts',
-    'src/core/agents/agent-proof-evidence.ts',
-    'src/core/agents/agent-recursion-guard.ts',
-    'src/core/agents/agent-output-validator.ts',
-    'src/core/agents/agent-cleanup.ts',
-    'src/core/agents/agent-trust-report.ts',
-    'src/core/agents/agent-wrongness.ts',
-    'src/core/commands/agent-command.ts'
-];
-const workPartitionFiles = [
-    'src/core/agents/work-partition/repo-inventory.ts',
-    'src/core/agents/work-partition/dependency-graph.ts',
-    'src/core/agents/work-partition/semantic-domain-graph.ts',
-    'src/core/agents/work-partition/task-slicer.ts',
-    'src/core/agents/work-partition/lease-planner.ts',
-    'src/core/agents/work-partition/conflict-detector.ts',
-    'src/core/agents/work-partition/no-overlap-proof.ts'
-];
-function text(rel) {
-    return fs.readFileSync(path.join(root, rel), 'utf8');
-}
-function exists(rel) {
-    return fs.existsSync(path.join(root, rel));
-}
-function assertFiles(files) {
-    for (const file of files)
-        assertGate(exists(file), `missing required file: ${file}`);
-}
-function assertLegacyMultiagentRemoved() {
-    const forbidden = [
-        /\brunFiveScoutIntake\b/,
-        /\bsks\s+scouts\s+run\b/,
-        /\bparallel_analysis_scouting\b/,
-        /\banalysis_scout(?:_\d+)?\b/
-    ];
-    for (const file of runtimeFiles) {
-        const body = text(file);
-        const hits = forbidden.filter((re) => re.test(body)).map(String);
-        assertGate(hits.length === 0, `legacy multi-agent runtime reference found in ${file}`, { hits });
-    }
-    for (const rel of ['src/core/scouts', 'src/core/commands/scouts-command.ts', 'src/commands/scouts.ts', 'schemas/codex/scout-result.schema.json']) {
-        assertGate(!exists(rel), `legacy multi-agent surface still present: ${rel}`);
-    }
-    const registry = text('src/cli/command-registry.ts');
-    assertGate(!/\bscouts?\s*:\s*entry\b/.test(registry), 'command registry must not expose legacy multi-agent commands');
-}
-function assertAgentSurface() {
-    assertFiles(agentFiles);
-    const registry = text('src/cli/command-registry.ts');
-    const zellij = text('src/core/agents/agent-runner-zellij.ts');
-    assertGate(/\bagent:\s+entry/.test(registry), 'command registry must expose sks agent');
-    assertGate(/'--agent': 'agent'/.test(registry), 'CLI parser must route --agent to agent command');
-    assertGate(zellij.includes('buildZellijAgentPanePlan') && zellij.includes('persistent_worker_slot') && zellij.includes('agent-zellij-report.json'), 'Zellij agent backend must declare lane plan and report policy');
-}
-function assertNonRecursive() {
-    const pipeline = text('src/core/agents/agent-worker-pipeline.ts');
-    const guard = text('src/core/agents/agent-recursion-guard.ts');
-    const docs = text('docs/agent-non-recursive-pipeline.md');
-    const orchestrator = text('src/core/agents/agent-orchestrator.ts');
-    const hooks = text('src/core/hooks-runtime.ts');
-    assertGate(exists('src/scripts/non-recursive-pipeline-check.ts'), 'missing non-recursive pipeline checker script');
-    assertGate(exists('schemas/codex/non-recursive-pipeline-report.schema.json'), 'missing non-recursive pipeline report schema');
-    for (const token of ['AGENT_WORKER_PIPELINE', 'SKS_AGENT_WORKER', 'SKS_PIPELINE_MODE', 'SKS_DISABLE_ROUTE_RECURSION', 'SKS_AGENT_SESSION_ID', 'SKS_AGENT_ID']) {
-        assertGate(pipeline.includes(token), `agent worker pipeline missing ${token}`);
-    }
-    for (const token of ['sks team', 'sks --agent', 'sks agent run', 'sks research run', 'sks autoresearch run', 'sks goal', '$Team', '$Research', '$AutoResearch', '$QA-LOOP', '$Goal']) {
-        assertGate(guard.includes(token), `agent recursion denylist missing ${token}`);
-    }
-    assertGate(guard.includes('agent-recursion-guard.json'), 'recursion guard report must be written');
-    for (const token of ['NON_RECURSIVE_PIPELINE_REPORT_SCHEMA', 'scanNonRecursivePipelinePolicy', 'wrongness_records', 'trust_report', 'evidence_router', 'next_action', 'local_only', 'secret_redaction_ok', 'performance_budget_ms']) {
-        assertGate(guard.includes(token), `non-recursive policy module missing ${token}`);
-    }
-    for (const token of ['env guard', 'command denylist', 'route denylist', 'worker mission creation block', 'current.json write block', 'stdout transcript scan', 'stderr transcript scan', 'agent result scan', 'wrongness record']) {
-        assertGate(guard.includes(token), `non-recursive policy contract missing ${token}`);
-    }
-    assertGate(docs.includes('Non-Recursive Pipeline Policy Report'), 'non-recursive policy docs section missing');
-    assertGate(orchestrator.includes('writeAgentRecursionGuardReport'), 'orchestrator must detect recursion attempts');
-    assertGate(hooks.includes('agentWorkerHookRecursionDecision') && hooks.includes('scanAgentTextForRecursion'), 'Codex PreToolUse hook must integrate agent recursion guard');
-}
-function assertCentralLedger() {
-    const ledger = text('src/core/agents/agent-central-ledger.ts');
-    const schemas = text('src/core/agents/agent-ledger-schemas.ts');
-    for (const token of ['agent-events.jsonl', 'agent-sessions.json', 'agent-roster.json', 'agent-task-board.json', 'agent-task-board.md', 'agent-messages.jsonl', 'agent-handoffs.jsonl', 'agent-leases.json', 'agent-conflict-graph.json', 'agent-consensus.json', 'agent-proof-evidence.json', 'current_hash', 'previous_hash']) {
-        assertGate(ledger.includes(token), `central ledger missing ${token}`);
-    }
-    for (const token of ['sks.agent-event.v1', 'sks.agent-message.v1', 'sks.agent-task-board.v1', 'sks.agent-session-record.v1', 'sks.agent-lease-ledger.v1', 'sks.agent-conflict-graph.v1', 'sks.agent-consensus.v1', 'sks.agent-proof-evidence.v1', 'sks.agent-cleanup.v1', 'sks.agent-non-recursive-pipeline.v1', 'additionalProperties: false', 'validateJsonSchemaRecursive']) {
-        assertGate(schemas.includes(token), `central ledger schema registry missing ${token}`);
-    }
-    for (const token of ['validateAgentLedgerWriteScope', 'agent_cannot_modify_other_session_record', 'agent_cannot_modify_orchestrator_only_file']) {
-        assertGate(ledger.includes(token), `central ledger write-scope policy missing ${token}`);
-    }
-    const lifecycle = text('src/core/agents/agent-lifecycle.ts');
-    for (const token of ['agent-lifecycle-policy.json', 'agent-lifecycle-aggregate.json', 'agent-timeout-kill-report.json', 'killTimedOutAgentSessions', 'agentHardTimeoutMs', 'SKS_AGENT_HARD_TIMEOUT_MS', 'sks.agent-session-record.v1']) {
-        assertGate(lifecycle.includes(token), `agent lifecycle missing ${token}`);
-    }
-}
-function assertWorkPartition() {
-    assertFiles(workPartitionFiles);
-    const partition = text('src/core/agents/agent-work-partition.ts');
-    for (const token of ['inventory', 'dependency', 'semantic', 'lease', 'conflict', 'no_overlap_proof']) {
-        assertGate(partition.includes(token), `work partition missing ${token}`);
-    }
-}
-function assertOutputSchema() {
-    const schema = JSON.parse(text('schemas/codex/agent-result.schema.json'));
-    assertGate(schema.additionalProperties === false, 'agent result schema must close additionalProperties');
-    for (const key of ['mission_id', 'agent_id', 'session_id', 'persona_id', 'task_slice_id', 'status', 'summary', 'findings', 'proposed_changes', 'changed_files', 'lease_compliance', 'recursion_guard', 'verification', 'blockers', 'confidence', 'handoff_notes']) {
-        assertGate(schema.required.includes(key), `agent result schema missing required ${key}`);
-    }
-    const validator = text('src/core/agents/agent-output-validator.ts');
-    const worker = text('src/core/agents/agent-worker-pipeline.ts');
-    assertGate(validator.includes('validateJsonSchemaRecursive'), 'agent output schema must use recursive validator');
-    assertGate(worker.includes('schema_invalid:'), 'agent output invalid result must block proof');
-}
-function assertProofAndTrustArtifacts() {
-    const proof = text('src/core/agents/agent-proof-evidence.ts');
-    const orchestrator = text('src/core/agents/agent-orchestrator.ts');
-    const writers = {
-        'agent-cleanup.json': 'writeAgentCleanupReport',
-        'agent-trust-report.json': 'writeAgentTrustReport',
-        'agent-wrongness-records.json': 'writeAgentWrongnessRecords',
-        'agent-output-tails.json': 'writeAgentOutputTailReport',
-        'agent-timeout-kill-report.json': 'killTimedOutAgentSessions'
-    };
-    for (const [token, writer] of Object.entries(writers)) {
-        assertGate(proof.includes(token), `agent proof missing ${token}`);
-        assertGate(orchestrator.includes(writer), `agent orchestrator does not write ${token}`);
-    }
-}
-function assertPersonaAndCaps() {
-    const persona = text('src/core/agents/agent-persona.ts');
-    const roster = text('src/core/agents/agent-roster.ts');
-    const schema = text('src/core/agents/agent-schema.ts');
-    for (const role of ['architect', 'implementer', 'verifier', 'safety', 'integrator']) {
-        assertGate(persona.includes(role), `default persona missing ${role}`);
-    }
-    assertGate(schema.includes('DEFAULT_AGENT_COUNT = 5'), 'default agent count must be 5');
-    assertGate(schema.includes('MAX_AGENT_COUNT = 20'), 'max agent count must be 20');
-    assertGate(roster.includes('validatePersonaUniqueness'), 'persona uniqueness must be validated');
-    assertGate(roster.includes('buildAgentEffortPolicy') && text('src/core/agents/agent-effort-policy.ts').includes('escalation_triggers'), 'agent effort policy must be dynamic and recorded');
-    assertGate(roster.includes('exceeds max'), 'agent max cap must block overflow');
-}
-function assertReleaseScripts() {
-    const required = [
-        'agent:non-recursive-pipeline',
-        'agent:non-recursive-pipeline-report',
-        'agent:legacy-multiagent-removed',
-        'agent:central-ledger',
-        'agent:work-partition',
-        'agent:no-overlap-proof',
-        'agent:persona-uniqueness',
-        'agent:max-cap',
-        'agent:fake-backend-blackbox',
-        'agent:lifecycle-close',
-        'agent:output-schema',
-        'agent:lease-conflicts',
-        'agent:proof-graph',
-        'team:native-agent-backend',
-        'research:native-agent-backend',
-        'qa:native-agent-backend'
-    ];
-    for (const name of required) {
-        assertGate(Boolean(pkg.scripts?.[name]), `package script missing ${name}`);
-    }
-    const releaseCheck = String(pkg.scripts?.['release:check'] || '');
-    const affectedReleaseCheck = String(pkg.scripts?.['release:check:affected'] || '');
-    const delegatesToParallel = releaseCheck.includes('release:check:parallel');
-    const delegatesToAffectedDag = releaseCheck.includes('release:check:affected')
-        && affectedReleaseCheck.includes('release-gate-dag-runner')
-        && /--preset\s+affected/.test(affectedReleaseCheck);
-    const delegatesDirectlyToDag = releaseCheck.includes('release-gate-dag-runner')
-        && /--preset\s+(?:release|affected)/.test(releaseCheck);
-    assertGate(delegatesToParallel || delegatesToAffectedDag || delegatesDirectlyToDag, 'release:check must delegate to the parallel P0 DAG or v2 affected/release DAG', { release_check: releaseCheck, release_check_affected: affectedReleaseCheck });
-}
-function assertRouteNativeBlackbox(routeName) {
-    const routeFixtureArgs = ['--agents', '5', '--work-items', '8', '--target-active-slots', '5', '--minimum-work-items', '5', '--max-queue-expansion', '10', '--mock', '--json'];
-    if (routeName === 'team') {
-        const result = runSksJson(['team', 'native backend fixture', ...routeFixtureArgs, '--no-open-zellij']);
-        assertGate(result.mock === true, 'Team mock blackbox did not execute', result);
-        assertGate(result.native_agent_run?.proof?.ok === true, 'Team blackbox missing native agent proof', result.native_agent_run?.proof);
-        assertGate(!JSON.stringify(result).includes('analysis_scout'), 'Team runtime artifact leaked legacy analysis_scout');
-    }
-    if (routeName === 'research') {
-        const prepared = runSksJson(['research', 'prepare', 'native backend fixture', '--json']);
-        const result = runSksJson(['research', 'run', prepared.mission_id, ...routeFixtureArgs, '--native-proof-only']);
-        assertGate(result.ok === true, 'Research mock blackbox did not pass', result);
-        assertGate(result.gate?.gate?.native_agent_proof === true || result.gate?.native_agent_proof === true || result.proof?.ok === true, 'Research proof missing native agent evidence artifact', result);
-        assertGate(!JSON.stringify(result).includes('scout-ledger'), 'Research runtime artifact leaked scout-ledger as SSOT');
-    }
-    if (routeName === 'qa') {
-        const prepared = runSksJson(['qa-loop', 'prepare', 'native backend API fixture', '--json']);
-        const result = runSksJson(['qa-loop', 'run', prepared.mission_id, ...routeFixtureArgs, '--native-proof-only']);
-        assertGate(result.ok === true, 'QA mock blackbox did not pass', result);
-        assertGate(result.gate?.gate?.native_agent_proof === true || result.gate?.native_agent_proof === true || result.proof?.ok === true, 'QA proof missing native agent evidence artifact', result);
-    }
-}
-function assertBlackboxAgent() {
-    const result = runSksJson(['agent', 'run', 'fixture', '--mock', '--json']);
-    assertGate(result.ok === true, 'fake agent blackbox run failed', result);
-    assertGate(result.proof?.fake_backend_disclaimer, 'fake backend disclaimer missing', result.proof);
-    assertGate(result.proof?.all_sessions_closed === true, 'agent lifecycle close proof missing', result.proof);
-    assertGate(result.proof?.no_overlap_ok === true, 'agent no-overlap proof missing', result.proof);
-    assertGate(result.proof?.ledger_hash_chain_ok === true, 'agent ledger hash proof missing', result.proof);
-}
-assertAgentSurface();
-assertReleaseScripts();
-if (gate.includes('legacy-multiagent') || gate === 'team-native-agent-backend' || gate === 'research-native-agent-backend' || gate === 'qa-native-agent-backend')
-    assertLegacyMultiagentRemoved();
-if (gate === 'team-native-agent-backend')
-    assertRouteNativeBlackbox('team');
-if (gate === 'research-native-agent-backend')
-    assertRouteNativeBlackbox('research');
-if (gate === 'qa-native-agent-backend')
-    assertRouteNativeBlackbox('qa');
-if (gate.includes('non-recursive'))
-    assertNonRecursive();
-if (gate.includes('central-ledger'))
-    assertCentralLedger();
-if (gate.includes('work-partition') || gate.includes('no-overlap') || gate.includes('lease-conflicts'))
-    assertWorkPartition();
-if (gate.includes('persona') || gate.includes('max-cap'))
-    assertPersonaAndCaps();
-if (gate.includes('output-schema'))
-    assertOutputSchema();
-if (gate.includes('proof-graph') || gate.includes('lifecycle-close') || gate.includes('lease-conflicts'))
-    assertProofAndTrustArtifacts();
-if (gate.includes('fake-backend') || gate.includes('lifecycle-close') || gate.includes('proof-graph') || gate.includes('no-overlap') || gate.includes('lease-conflicts'))
-    assertBlackboxAgent();
-emitGate(gate, { version: pkg.version, native_agent_kernel: true });
-//# sourceMappingURL=agent-native-release-gate.js.map

package/dist/scripts/agent-patch-swarm-gate-lib.js

@@ -1,113 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-export function writeReport(name, report) {
-    const out = path.join(root, '.sneakoscope', 'reports', `${name}.json`);
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-    return out;
-}
-export function readJson(file) {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-export function makeTempPatchProject(prefix = 'sks-patch-swarm-') {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    for (let index = 1; index <= 10; index += 1) {
-        fs.writeFileSync(path.join(dir, `file-${index}.txt`), `before-${index}\n`);
-    }
-    return dir;
-}
-export async function runPatchSwarmRouteBlackbox({ gate, route, routeCommand, reportName }) {
-    const tmp = makeTempPatchProject();
-    const files = Array.from({ length: 10 }, (_, index) => `file-${index + 1}.txt`);
-    const prompt = [
-        'Patch exactly these ten independent fixture files with one exclusive write lease per file.',
-        ...files.map((file) => `\`${file}\``)
-    ].join(' ');
-    const orchestrator = await importDist('core/agents/agent-orchestrator.js');
-    const result = await orchestrator.runNativeAgentOrchestrator({
-        root: tmp,
-        prompt,
-        route,
-        routeCommand,
-        routeBlackboxKind: `actual_${route.replace(/[^a-z0-9]+/gi, '_').replace(/^_+|_+$/g, '').toLowerCase()}_command`,
-        backend: 'fake',
-        mock: true,
-        agents: 5,
-        concurrency: 5,
-        targetActiveSlots: 5,
-        desiredWorkItemCount: 10,
-        minimumWorkItems: 10,
-        writeMode: 'parallel',
-        applyPatches: true,
-        dryRunPatches: false,
-        maxWriteAgents: 5,
-        json: true
-    });
-    const ledgerRoot = path.join(tmp, result.ledger_root);
-    const queue = readJson(path.join(ledgerRoot, 'agent-patch-queue.json'));
-    const merge = readJson(path.join(ledgerRoot, 'agent-merge-coordinator-report.json'));
-    const apply = readJson(path.join(ledgerRoot, 'agent-patch-apply-results.json'));
-    const verification = readJson(path.join(ledgerRoot, 'agent-patch-verification-results.json'));
-    const rollback = readJson(path.join(ledgerRoot, 'agent-patch-rollback-proof.json'));
-    const proof = readJson(path.join(ledgerRoot, 'agent-patch-proof.json'));
-    const changedFiles = [...new Set((apply.results || []).flatMap((row) => row.changed_files || []))];
-    const writeOwners = new Map();
-    for (const entry of queue.entries || []) {
-        for (const file of entry.write_paths || []) {
-            if (!writeOwners.has(file))
-                writeOwners.set(file, new Set());
-            writeOwners.get(file).add(entry.agent_id);
-        }
-    }
-    const firstParallelWave = Math.max(0, ...(merge.parallel_apply_groups || []).map((group) => (group.entry_ids || []).length));
-    const report = {
-        schema: 'sks.patch-swarm-route-blackbox.v1',
-        ok: result.ok === true && proof.ok === true,
-        gate,
-        route,
-        route_command: routeCommand,
-        fixture_root: tmp,
-        mission_id: result.mission_id,
-        requested_agents: 5,
-        requested_work_items: 10,
-        write_mode: result.parallel_write_policy?.write_mode,
-        apply_patches: result.parallel_write_policy?.apply_patches,
-        patch_envelopes_enqueued: queue.entries?.length || 0,
-        first_parallel_wave_entry_count: firstParallelWave,
-        changed_files: changedFiles,
-        duplicate_write_owners: [...writeOwners.entries()].filter(([, owners]) => owners.size > 1).map(([file, owners]) => ({ file, owners: [...owners] })),
-        rollback_digest_count: proof.rollback_digest_count,
-        verification_ok: verification.ok === true,
-        rollback_ok: rollback.ok === true,
-        patch_proof_ok: proof.ok === true,
-        route_final_proof_ok: result.proof?.ok === true,
-        policy_only: false,
-        artifacts: {
-            queue: path.join(result.ledger_root, 'agent-patch-queue.json'),
-            merge: path.join(result.ledger_root, 'agent-merge-coordinator-report.json'),
-            apply: path.join(result.ledger_root, 'agent-patch-apply-results.json'),
-            verification: path.join(result.ledger_root, 'agent-patch-verification-results.json'),
-            rollback: path.join(result.ledger_root, 'agent-patch-rollback-proof.json'),
-            proof: path.join(result.ledger_root, 'agent-patch-proof.json')
-        },
-        result
-    };
-    writeReport(reportName, report);
-    assertGate(result.ok === true, `${gate} route final proof must pass`, report);
-    assertGate(queue.entries?.length === 10, `${gate} must enqueue 10 patch envelopes`, report);
-    assertGate(firstParallelWave >= 5, `${gate} must prove at least five first-wave disjoint patches`, report);
-    assertGate(changedFiles.length >= 5, `${gate} must change at least five files`, report);
-    assertGate(report.duplicate_write_owners.length === 0, `${gate} must not let two agents own the same file`, report);
-    assertGate(proof.rollback_digest_count >= changedFiles.length, `${gate} must record rollback digests for changed files`, report);
-    assertGate(verification.ok === true && verification.results?.length === 10, `${gate} verification results must exist for patches`, report);
-    assertGate(rollback.ok === true, `${gate} rollback proof must pass`, report);
-    assertGate(proof.ok === true, `${gate} patch proof must pass`, report);
-    assertGate(result.proof?.ok === true, `${gate} route final proof must pass`, report);
-    emitGate(gate, { mission_id: result.mission_id, changed_files: changedFiles.length, first_parallel_wave: firstParallelWave });
-    return report;
-}
-//# sourceMappingURL=agent-patch-swarm-gate-lib.js.map

package/dist/scripts/agent-real-codex-patch-envelope-smoke.js

@@ -1,126 +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 { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const reportPath = path.join(root, '.sneakoscope', 'reports', 'agent-real-codex-patch-envelope-smoke.json');
-fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-const required = process.env.SKS_REQUIRE_REAL_CODEX_PATCHES === '1';
-if (process.env.SKS_TEST_REAL_CODEX_PATCHES !== '1') {
-    optionalOrBlocked('set SKS_TEST_REAL_CODEX_PATCHES=1 to run real Codex patch envelope smoke', 'real_codex_patch_smoke_not_requested');
-}
-const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-real-codex-patches-'));
-fs.mkdirSync(path.join(fixture, '.sneakoscope'), { recursive: true });
-for (const file of ['alpha.txt', 'beta.txt', 'gamma.txt'])
-    fs.writeFileSync(path.join(fixture, file), `${file}: before\n`);
-const prompt = [
-    'Real Codex patch envelope smoke.',
-    'Return valid JSON matching schemas/codex/agent-result.schema.json.',
-    'Populate patch_envelopes with schema sks.agent-patch-envelope.v1 for alpha.txt, beta.txt, and gamma.txt.',
-    'Use write operations only inside this temp project, include lease_proof strategy_task_id, verification_node_id, rollback_node_id, and rollback_hint.'
-].join(' ');
-const run = spawnSync(process.execPath, [
-    path.join(root, 'dist', 'bin', 'sks.js'),
-    'agent',
-    'run',
-    prompt,
-    '--route', '$Agent',
-    '--backend', 'codex-sdk',
-    '--real',
-    '--agents', '2',
-    '--target-active-slots', '2',
-    '--minimum-work-items', '2',
-    '--work-items', '3',
-    '--write-mode', 'parallel',
-    '--apply-patches',
-    '--max-write-agents', '2',
-    '--json'
-], { cwd: fixture, encoding: 'utf8', env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1' }, timeout: Number(process.env.SKS_REAL_CODEX_PATCH_TIMEOUT_MS || 10 * 60 * 1000), maxBuffer: 1024 * 1024 * 32 });
-assertGate(run.status === 0, 'real Codex patch smoke command failed', { stdout: run.stdout.slice(-4000), stderr: run.stderr.slice(-4000) });
-const json = parseJson(run.stdout);
-const ledgerRoot = path.join(fixture, json.ledger_root || '');
-const queue = readJson(path.join(ledgerRoot, 'agent-patch-queue.json'), null);
-const apply = readJson(path.join(ledgerRoot, 'agent-patch-apply-results.json'), null);
-const rollback = readJson(path.join(ledgerRoot, 'agent-patch-rollback-proof.json'), null);
-const verification = readJson(path.join(ledgerRoot, 'agent-patch-verification-results.json'), null);
-const processReports = listNamedFiles(path.join(ledgerRoot, 'sessions'), 'agent-process-report.json').map((file) => readJson(file, null)).filter(Boolean);
-const result = {
-    schema: 'sks.agent-real-codex-patch-envelope-smoke.v1',
-    ok: true,
-    status: 'passed',
-    proof_level: process.env.SKS_AGENT_DYNAMIC_BACKFILL_FIXTURE === '1' ? 'fixture_instrumented_real' : 'proven',
-    required,
-    fixture_root: fixture,
-    mission_id: json.mission_id,
-    patch_envelope_count: queue?.entries?.length || 0,
-    queue_enqueue_ok: (queue?.entries?.length || 0) >= 3,
-    patch_apply_ok: apply?.results?.every?.((row) => row.ok === true) === true,
-    rollback_ok: rollback?.ok === true,
-    verification_ok: verification?.ok === true,
-    protected_path_violations: (queue?.entries || []).some((entry) => {
-        const lease = entry.envelope?.lease_proof || {};
-        return lease.protected_path_check === 'blocked' || (entry.violations || []).some((violation) => String(violation).startsWith('protected_path:'));
-    }),
-    process_report_profiles: processReports.map((row) => ({ profile: row.profile || null, managed_proxy_env_keys: row.managed_proxy_env_keys || [] })),
-    blockers: []
-};
-result.blockers.push(...(result.queue_enqueue_ok ? [] : ['real_codex_patch_queue_enqueue_missing']));
-result.blockers.push(...(result.patch_apply_ok ? [] : ['real_codex_patch_apply_failed']));
-result.blockers.push(...(result.rollback_ok ? [] : ['real_codex_patch_rollback_proof_missing']));
-result.blockers.push(...(result.verification_ok ? [] : ['real_codex_patch_verification_missing']));
-result.blockers.push(...(!result.protected_path_violations ? [] : ['real_codex_patch_protected_path_violation']));
-result.ok = result.blockers.length === 0;
-result.status = result.ok ? 'passed' : 'blocked';
-result.proof_level = result.ok ? result.proof_level : 'blocked';
-writeReport(result);
-assertGate(result.ok === true, 'real Codex patch envelope smoke failed', result);
-emitGate('agent:real-codex-patch-envelope-smoke', { status: result.status, patch_envelope_count: result.patch_envelope_count });
-function optionalOrBlocked(reason, code, extra = {}) {
-    const report = {
-        schema: 'sks.agent-real-codex-patch-envelope-smoke.v1',
-        ok: !required,
-        status: required ? 'blocked' : 'integration_optional',
-        proof_level: required ? 'real_required_missing' : 'integration_optional',
-        required,
-        reason,
-        blockers: required ? [code] : [],
-        ...extra
-    };
-    writeReport(report);
-    emitGate('agent:real-codex-patch-envelope-smoke', { status: report.status, reason: code });
-    process.exit(required ? 1 : 0);
-}
-function writeReport(report) {
-    fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-}
-function parseJson(stdout) {
-    const start = stdout.indexOf('{');
-    const end = stdout.lastIndexOf('}');
-    return JSON.parse(stdout.slice(start, end + 1));
-}
-function readJson(file, fallback) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch (err) {
-        if (arguments.length > 1)
-            return fallback;
-        throw err;
-    }
-}
-function listNamedFiles(dir, name) {
-    const out = [];
-    if (!fs.existsSync(dir))
-        return out;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...listNamedFiles(file, name));
-        else if (entry.isFile() && entry.name === name)
-            out.push(file);
-    }
-    return out;
-}
-//# sourceMappingURL=agent-real-codex-patch-envelope-smoke.js.map