sneakoscope 6.0.2 → 6.1.0

package/schemas/codex/codex-0139-real-probe-result.schema.json

@@ -1,30 +1,43 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneakoscope.local/schemas/codex/codex-0139-real-probe-result.schema.json",
-  "title": "SKS Codex 0.139 real probe result",
+  "title": "SKS Codex 0.144.1 core real probe result (0.139 contract lineage)",
   "type": "object",
   "required": [
     "schema",
+    "target_version",
+    "compatibility_origin",
+    "compatibility_authority",
     "generated_at",
     "codex_bin",
     "version_text",
     "parsed_version",
     "require_real",
+    "release_authorizing",
     "overall_ok",
     "probe_timeout_ms",
+    "requested_probes",
     "probes",
     "skipped",
+    "warnings",
+    "external_integration_status",
+    "temp_cleanup",
     "blockers"
   ],
   "properties": {
     "schema": { "const": "sks.codex-0139-real-probe-result.v1" },
+    "target_version": { "const": "0.144.1" },
+    "compatibility_origin": { "const": "codex-0139-real-probe-result-v1" },
+    "compatibility_authority": { "const": "deprecated_non_authoritative_lineage_only" },
     "generated_at": { "type": "string" },
     "codex_bin": { "type": ["string", "null"] },
     "version_text": { "type": ["string", "null"] },
     "parsed_version": { "type": ["string", "null"] },
     "require_real": { "type": "boolean" },
+    "release_authorizing": { "type": "boolean" },
     "overall_ok": { "type": "boolean" },
     "probe_timeout_ms": { "type": "integer", "minimum": 1 },
+    "requested_probes": { "type": "array", "items": { "type": "string" }, "uniqueItems": true },
     "probes": {
       "type": "object",
       "additionalProperties": false,
@@ -35,9 +48,9 @@
         "marketplace_source_json",
         "plugin_catalog_cache",
         "sandbox_profile_alias",
-        "interrupt_agent_event",
+        "collab_agent_tool_schema",
         "image_referenced_path",
-        "sandbox_proxy_preservation"
+        "sandbox_proxy_environment"
       ],
       "properties": {
         "code_mode_web_search": { "$ref": "#/$defs/singleProbe" },
@@ -46,12 +59,32 @@
         "marketplace_source_json": { "$ref": "#/$defs/singleProbe" },
         "plugin_catalog_cache": { "$ref": "#/$defs/singleProbe" },
         "sandbox_profile_alias": { "$ref": "#/$defs/singleProbe" },
-        "interrupt_agent_event": { "$ref": "#/$defs/singleProbe" },
+        "collab_agent_tool_schema": { "$ref": "#/$defs/singleProbe" },
         "image_referenced_path": { "$ref": "#/$defs/singleProbe" },
-        "sandbox_proxy_preservation": { "$ref": "#/$defs/singleProbe" }
+        "sandbox_proxy_environment": { "$ref": "#/$defs/singleProbe" }
       }
     },
     "skipped": { "type": "array", "items": { "type": "string" } },
+    "warnings": { "type": "array", "items": { "type": "string" } },
+    "external_integration_status": {
+      "type": "object",
+      "required": ["mcp_auth", "release_authorization_scope"],
+      "properties": {
+        "mcp_auth": { "enum": ["authentication_required", "not_observed"] },
+        "release_authorization_scope": { "const": "codex_core_compatibility_only" }
+      },
+      "additionalProperties": false
+    },
+    "temp_cleanup": {
+      "type": "object",
+      "required": ["root", "ok", "remaining_entries"],
+      "properties": {
+        "root": { "type": "string" },
+        "ok": { "type": "boolean" },
+        "remaining_entries": { "type": "array", "items": { "type": "string" } }
+      },
+      "additionalProperties": false
+    },
     "blockers": { "type": "array", "items": { "type": "string" } }
   },
   "$defs": {
@@ -76,6 +109,7 @@
         "stderr_tail": { "type": "string" },
         "artifact_paths": { "type": "array", "items": { "type": "string" } },
         "evidence": { "type": "object" },
+        "warnings": { "type": "array", "items": { "type": "string" } },
         "blockers": { "type": "array", "items": { "type": "string" } }
       },
       "additionalProperties": false

package/schemas/codex/ppt-slide-issue-ledger.schema.json

@@ -3,13 +3,14 @@
   "$id": "https://sneakoscope.local/schemas/ppt-slide-issue-ledger.schema.json",
   "title": "SKS PPT Slide Issue Ledger",
   "type": "object",
-  "required": ["schema", "schema_version", "created_at", "issues", "issue_count", "blockers", "validation", "passed"],
+  "required": ["schema", "schema_version", "created_at", "issues", "issue_count", "blocking_issue_count", "blockers", "validation", "passed"],
   "additionalProperties": false,
   "properties": {
     "schema": { "const": "sks.ppt-slide-issue-ledger.v1" },
     "schema_version": { "const": 1 },
     "created_at": { "type": "string" },
     "issue_count": { "type": "integer", "minimum": 0 },
+    "blocking_issue_count": { "type": "integer", "minimum": 0 },
     "blockers": { "type": "array", "items": { "type": "string" } },
     "passed": { "type": "boolean" },
     "extraction_source": { "type": "string" },

package/dist/core/codex-control/codex-0139-multi-agent-real-probe.js

@@ -1,107 +0,0 @@
-import path from 'node:path';
-import { findCodexBinary } from '../codex-adapter.js';
-import { ensureDir, runProcess, writeJsonAtomic } from '../fsx.js';
-import { codex0139ProbeTail, skippedCodex0139Probe } from './codex-0139-real-probes.js';
-export function normalizeCodex0139InterruptAgentEvent(event) {
-    const name = String(event?.tool || event?.item?.tool || event?.type || event?.event || event?.name || '');
-    return name === 'interrupt_agent' || name === 'close_agent' ? { ...event, canonical: 'subagent_result', stage: 'result' } : event;
-}
-export async function runCodex0139InterruptAgentRealProbe(input = {}) {
-    const started = Date.now();
-    if (process.env.SKS_CODEX_0139_ALLOW_CAPTURED_EVENT_FIXTURE === '1') {
-        const event = normalizeCodex0139InterruptAgentEvent({ type: 'interrupt_agent', agent_id: 'captured-real-doc-sample' });
-        return {
-            ok: event.stage === 'result',
-            mode: 'captured-real-fixture',
-            duration_ms: Date.now() - started,
-            artifact_paths: [],
-            evidence: {
-                saw_interrupt_agent_event: true,
-                normalized_stage: event.stage,
-                fixture_allowed_by_env: true
-            },
-            blockers: event.stage === 'result' ? [] : ['codex_interrupt_agent_normalization_failed']
-        };
-    }
-    const codexBin = input.codexBin || await findCodexBinary();
-    if (!codexBin)
-        return skippedCodex0139Probe('codex_cli_missing');
-    const root = input.root || process.cwd();
-    const tempDir = path.join(root, '.sneakoscope', 'tmp', 'codex-0139-real-probes', `interrupt-agent-${Date.now()}`);
-    await ensureDir(tempDir);
-    const prompt = 'No file edits. Spawn one tiny subagent named interrupt_probe that only says ready. Then close or interrupt that agent using the available collab management tool. Final answer exactly: interrupt probe done.';
-    const args = ['exec', '--json', '--skip-git-repo-check', '--ephemeral', '--ignore-rules', '--disable', 'hooks', '-s', 'read-only', '-C', tempDir, prompt];
-    const result = await runProcess(codexBin, args, {
-        cwd: tempDir,
-        timeoutMs: input.timeoutMs || 120000,
-        maxOutputBytes: 1024 * 1024
-    }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
-    const events = parseJsonlEvents(`${result.stdout || ''}\n${result.stderr || ''}`);
-    const tools = events
-        .map((event) => String(event?.item?.tool || event?.tool || ''))
-        .filter(Boolean);
-    const sawSpawn = tools.includes('spawn_agent');
-    const sawInterrupt = tools.includes('interrupt_agent');
-    const sawClose = tools.includes('close_agent');
-    const closeOrInterruptEvent = events.find((event) => ['interrupt_agent', 'close_agent'].includes(String(event?.item?.tool || event?.tool || '')));
-    const normalized = normalizeCodex0139InterruptAgentEvent(closeOrInterruptEvent?.item || closeOrInterruptEvent || {});
-    const finalText = events.map((event) => String(event?.item?.text || '')).find((text) => /interrupt probe done/i.test(text)) || '';
-    const ok = result.code === 0 && sawSpawn && (sawInterrupt || sawClose) && normalized.stage === 'result';
-    const artifact = path.join(root, '.sneakoscope', 'codex-0139-interrupt-agent-real.json');
-    await writeJsonAtomic(artifact, {
-        schema: 'sks.codex-0139-interrupt-agent-real.v1',
-        ok,
-        generated_at: new Date().toISOString(),
-        command_line: [codexBin, ...args],
-        event_count: events.length,
-        tools,
-        saw_spawn_agent_event: sawSpawn,
-        saw_interrupt_agent_event: sawInterrupt,
-        saw_close_agent_event: sawClose,
-        normalized_stage: normalized.stage || null,
-        final_text_seen: Boolean(finalText),
-        stdout_tail: codex0139ProbeTail(result.stdout),
-        stderr_tail: codex0139ProbeTail(result.stderr)
-    });
-    return {
-        ok,
-        mode: 'actual-cli',
-        command_line: [codexBin, ...args],
-        duration_ms: Date.now() - started,
-        stdout_tail: codex0139ProbeTail(result.stdout),
-        stderr_tail: codex0139ProbeTail(result.stderr),
-        artifact_paths: [artifact, tempDir],
-        evidence: {
-            event_count: events.length,
-            collab_tools_seen: [...new Set(tools)],
-            saw_spawn_agent_event: sawSpawn,
-            saw_interrupt_agent_event: sawInterrupt,
-            saw_close_agent_event: sawClose,
-            close_agent_used_as_actual_interrupt_surface: sawClose && !sawInterrupt,
-            normalized_stage: normalized.stage || null,
-            final_text_seen: Boolean(finalText)
-        },
-        blockers: ok ? [] : [
-            ...(result.code === 0 ? [] : ['codex_interrupt_agent_exec_failed']),
-            ...(sawSpawn ? [] : ['codex_interrupt_agent_spawn_event_missing']),
-            ...(sawInterrupt || sawClose ? [] : ['codex_interrupt_agent_or_close_event_missing']),
-            ...(normalized.stage === 'result' ? [] : ['codex_interrupt_agent_normalization_failed'])
-        ]
-    };
-}
-function parseJsonlEvents(text) {
-    return String(text || '')
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.startsWith('{') && line.endsWith('}'))
-        .map((line) => {
-        try {
-            return JSON.parse(line);
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter(Boolean);
-}
-//# sourceMappingURL=codex-0139-multi-agent-real-probe.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/codex-0142-capability-check.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { CODEX_0142_FEATURE_KEYS, detectCodex0142Capability, writeCodex0142CapabilityArtifacts } from '../core/codex-control/codex-0142-capability.js';
-const requireReal = process.argv.includes('--require-real') || process.env.SKS_REQUIRE_CODEX_0142 === '1';
-if (!requireReal)
-    process.env.SKS_CODEX_0142_FAKE = '1';
-const cap = await detectCodex0142Capability({ requireReal });
-assertGate(cap.ok === true, 'Codex 0.142 capability probe must pass', cap);
-assertGate(Object.keys(cap.feature_states).length === CODEX_0142_FEATURE_KEYS.length, 'Codex 0.142 feature count mismatch', cap);
-assertGate(Object.values(cap.feature_states).every((state) => String(state.certainty) !== 'assumed_by_version'), 'Codex 0.142 capability must not use assumed_by_version evidence', cap);
-if (requireReal) {
-    assertGate(cap.probe_mode === 'real-schema', 'Codex 0.142 require-real must use generated schema evidence', cap);
-    assertGate(cap.release_authorizing === true, 'Codex 0.142 require-real must be release-authorizing', cap);
-    await writeCodex0142CapabilityArtifacts(process.cwd(), { requireReal: true });
-}
-emitGate('codex:0142-capability', {
-    features: CODEX_0142_FEATURE_KEYS.length,
-    probe_mode: cap.probe_mode,
-    release_authorizing: cap.release_authorizing
-});
-//# sourceMappingURL=codex-0142-capability-check.js.map