sneakoscope 4.8.7 → 5.1.2

package/dist/scripts/release-gate-dag-runner.js

@@ -43,6 +43,20 @@ console.log(`SKS Release DAG
   critical_path: ${(result.critical_path_ms / 1000).toFixed(1)}s
   certificate: ${result.completion_certificate.confidence} sla=${(result.completion_certificate.sla_ms / 1000).toFixed(0)}s met=${result.completion_certificate.sla_met}
   report: ${result.report_dir}`);
+const gateResult = {
+    schema: 'sks.gate-result.v1',
+    ok: result.ok === true,
+    blockers: result.ok ? [] : result.failures.map((failure) => `release_gate_failed:${failure.id}`),
+    summary: {
+        total_gates: result.total_gates,
+        selected_gates: result.selected_gates,
+        cached: result.cached,
+        completed: result.completed,
+        failed: result.failed,
+        report_dir: result.report_dir
+    }
+};
+console.log(JSON.stringify(gateResult));
 if (!result.ok) {
     for (const failure of result.failures) {
         console.error(`[fail] ${failure.id} exit=${failure.exit_code}\n${failure.stderr_tail}`);

package/dist/scripts/release-gate-existence-audit.js

@@ -43,7 +43,8 @@ const releaseCheckTarget = releaseCheck.includes('release:check:affected')
     : releaseCheck;
 assertGate(releaseCheckTarget.includes('release-gate-dag-runner') && /--preset\s+(?:release|affected)/.test(releaseCheckTarget), 'release:check must use the v2 DAG release/affected preset', { release_check: scripts['release:check'], resolved_release_check: releaseCheckTarget });
 assertGate(releaseGates.length > 0 && releaseGates.length <= 200, 'release v2 manifest must include 1..200 release gates', { gate_count: releaseGates.length });
-assertGate(Object.keys(scripts).length <= 100, 'package script budget exceeded', { script_count: Object.keys(scripts).length });
+const PACKAGE_SCRIPT_BUDGET = 150;
+assertGate(Object.keys(scripts).length <= PACKAGE_SCRIPT_BUDGET, 'package script budget exceeded', { script_count: Object.keys(scripts).length, limit: PACKAGE_SCRIPT_BUDGET });
 for (const id of requiredRelease)
     assertGate(releaseIds.has(id), `critical release gate missing from release v2 manifest: ${id}`, { id });
 for (const id of requiredHarness)

package/dist/scripts/release-gate-planner.js

@@ -9,6 +9,7 @@ import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
 const { validateReleaseGateManifest } = await importDist('core/release/release-gate-node.js');
 const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
 const scripts = pkg.scripts || {};
+const PACKAGE_SCRIPT_BUDGET = 150;
 const release = readManifest('release-gates.v2.json');
 const harness = readManifest('infra-harness-gates.json');
 assertGate(!fs.existsSync(path.join(root, 'release-gates.json')), 'release-gates.json v1 must not be present');
@@ -27,7 +28,7 @@ const releasePresetLeaks = release.gates.filter((gate) => !Array.isArray(gate.pr
 const harnessPresetLeaks = harness.gates.filter((gate) => !Array.isArray(gate.preset) || !gate.preset.includes('harness') || gate.preset.includes('release')).map((gate) => gate.id);
 const npmRunGates = release.gates.concat(harness.gates).filter((gate) => /\bnpm\s+run\b/.test(String(gate.command))).map((gate) => gate.id);
 assertGate(release.gates.length <= 200, 'release preset gate budget exceeded', { release_gates: release.gates.length, limit: 200 });
-assertGate(Object.keys(scripts).length <= 100, 'package.json script budget exceeded', { scripts: Object.keys(scripts).length, limit: 100 });
+assertGate(Object.keys(scripts).length <= PACKAGE_SCRIPT_BUDGET, 'package.json script budget exceeded', { scripts: Object.keys(scripts).length, limit: PACKAGE_SCRIPT_BUDGET });
 assertGate(duplicateAcrossManifests.length === 0, 'gate appears in both release and harness manifests', { duplicateAcrossManifests });
 assertGate(releaseZellij.length === 0, 'zellij gates must live in infra-harness-gates.json, not release-gates.v2.json', { releaseZellij });
 assertGate(harnessNonZellij.length === 0, 'infra harness manifest must contain only zellij gates', { harnessNonZellij });

package/dist/scripts/release-gate-script-parity-check.js

@@ -38,7 +38,7 @@ export const REQUIRED_3110_RELEASE_IDS = [
     'config:managed-merge-callsite-coverage',
     'release:gate-script-parity',
     'release:wiring-3110-blackbox',
-    'sks:3110-all-feature-regression'
+    'sks:3112-all-feature-regression'
 ];
 if (isMain()) {
     main().catch((err) => {

package/dist/scripts/release-metadata-1-19-check.js

@@ -372,7 +372,8 @@ assertGate(releaseManifest?.schema === 'sks.release-gates.v2', 'release gate man
 assertGate(harnessManifest?.schema === 'sks.infra-harness-gates.v1', 'infra harness manifest schema mismatch', { schema: harnessManifest?.schema || null });
 assertGate(releaseGates.length > 0 && releaseGates.length <= 200, 'release v2 manifest must include 1..200 release gates', { release_gates: releaseGates.length });
 assertGate(harnessGates.length > 0, 'infra harness manifest must include harness gates', { harness_gates: harnessGates.length });
-assertGate(Object.keys(pkg.scripts || {}).length <= 100, 'package script budget exceeded', { script_count: Object.keys(pkg.scripts || {}).length });
+const PACKAGE_SCRIPT_BUDGET = 150;
+assertGate(Object.keys(pkg.scripts || {}).length <= PACKAGE_SCRIPT_BUDGET, 'package script budget exceeded', { script_count: Object.keys(pkg.scripts || {}).length, limit: PACKAGE_SCRIPT_BUDGET });
 for (const script of requiredPackageScripts)
     assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
 for (const id of requiredReleaseGates)

package/dist/scripts/seo-geo-feature-fixture-quality-check.js

@@ -9,7 +9,7 @@ for (const id of ['cli-seo-geo-optimizer', 'route-seo-geo-optimizer']) {
     assertGate(feature, `feature missing: ${id}`);
     assertGate(feature.fixture?.status === 'pass', `feature fixture must pass: ${id}`, feature);
     assertGate(feature.fixture?.quality !== 'static_contract', `SEO/GEO feature must not rely on static contract: ${id}`, feature.fixture);
-    assertGate(['runtime_verified', 'runtime_mock_verified'].includes(feature.fixture?.quality), `SEO/GEO fixture quality must be runtime-backed: ${id}`, feature.fixture);
+    assertGate(feature.fixture?.quality === 'runtime_verified', `SEO/GEO fixture quality must be runtime-backed by execution: ${id}`, feature.fixture);
 }
 const selftest = registryMod.buildAllFeaturesSelftest(registry, {});
 const runtimeCheck = selftest.checks.find((check) => check.id === 'runtime_routes_not_static_contract');

package/dist/scripts/sks-1-11-gate-lib.js

@@ -23,15 +23,17 @@ export function runSksJson(args) {
         timeout: Number(process.env.SKS_GATE_TIMEOUT_MS || 120_000),
         env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' }
     });
-    if (result.status !== 0) {
-        assertGate(false, 'sks command failed', { args, status: result.status, stdout: result.stdout, stderr: result.stderr });
-    }
+    let parsed = null;
     try {
-        return JSON.parse(result.stdout);
+        parsed = JSON.parse(result.stdout);
     }
     catch (err) {
         assertGate(false, 'sks command did not emit parseable JSON', { args, stdout: result.stdout, error: err.message });
     }
+    if (result.status !== 0 && !parsed?.mission_id) {
+        assertGate(false, 'sks command failed', { args, status: result.status, stdout: result.stdout, stderr: result.stderr });
+    }
+    return { ...parsed, _process_status: result.status, _stderr_tail: String(result.stderr || '').slice(-600) };
 }
 export function runPptReview(action = 'review') {
     const json = runSksJson(['ppt', 'fixture', '--mock', '--json']);
@@ -46,7 +48,7 @@ export function runPptReview(action = 'review') {
         },
         slideIssues: review.slide_issue_ledger || {}
     };
-    assertGate(json.ok === true, 'ppt imagegen review fixture blocked', json);
+    assertGate(Boolean(json.mission_id), 'ppt imagegen review fixture did not create a mission', json);
     assertGate(json.proof_evidence?.generated_slide_callout_images_count > 0, 'ppt callout image evidence missing', json.proof_evidence);
     assertGate(json.proof_evidence?.slide_issue_extraction_status === 'valid', 'ppt issue extraction missing', json.proof_evidence);
     return json;
@@ -60,7 +62,7 @@ export function runDfixFixture() {
 }
 export function runUxFixture() {
     const json = runSksJson(['image-ux-review', 'fixture', '--mock', '--json']);
-    assertGate(json.ok === true, 'image UX review fixture blocked', json);
+    assertGate(Boolean(json.mission_id), 'image UX review fixture did not create a mission', json);
     return json;
 }
 export function missionFile(missionId, file) {

package/dist/scripts/ux-review-real-loop-fixture-check.js

@@ -1,24 +1,29 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
-const root = process.cwd();
-const result = spawnSync(process.execPath, [path.join(root, 'dist/bin/sks.js'), 'image-ux-review', 'fixture', '--mock', '--json'], {
+const repoRoot = process.cwd();
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-ux-review-real-loop-fixture-'));
+const result = spawnSync(process.execPath, [path.join(repoRoot, 'dist/bin/sks.js'), 'image-ux-review', 'fixture', '--mock', '--json'], {
     cwd: root,
     encoding: 'utf8',
-    env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
+    env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_UPDATE_MIGRATION_GATE_DISABLED: '1', CI: 'true' },
     timeout: Number(process.env.SKS_UX_REVIEW_REAL_LOOP_FIXTURE_TIMEOUT_MS || 180_000)
 });
-assert.equal(result.status, 0, JSON.stringify({
+assert.ok([0, 1].includes(result.status), JSON.stringify({
     stderr: result.stderr,
     stdout: result.stdout,
     signal: result.signal,
     error: result.error?.message || null
 }, null, 2));
 const json = JSON.parse(result.stdout);
+assert.equal(json.ok, false);
 assert.equal(json.artifacts.gate.mock_fixture_cannot_claim_real, true);
 assert.equal(json.artifacts.generated_review_ledger.real_generated_count, 0);
 assert.equal(json.artifacts.generated_review_ledger.generated_count, 1);
+assert.equal(json.proof.status, 'mock_only');
 console.log(JSON.stringify({ schema: 'sks.ux-review-real-loop-fixture.v1', ok: true, mission_id: json.mission_id }, null, 2));
 //# sourceMappingURL=ux-review-real-loop-fixture-check.js.map

package/dist/scripts/ux-review-run-wires-imagegen-check.js

@@ -3,7 +3,11 @@
 import { emitGate, requireContains } from './sks-1-12-real-execution-check-lib.js';
 requireContains('ux-review:run-wires-imagegen', 'src/core/commands/image-ux-review-command.ts', [
     'const shouldGenerateCallouts = flag(args, \'--generate-callouts\') || flag(args, \'--fix\')',
+    'requireCodexImagegen',
     'generateGptImage2CalloutReview',
+    'evidence_class',
+    'output_sha256',
+    'imagegen_response_non_codex_api_fallback_not_full_evidence',
     'extractRealCallouts',
     'buildImageUxCalloutExtractionReport'
 ]);

package/docs/demo.tape

@@ -0,0 +1,28 @@
+Output docs/assets/sks-v5-demo.gif
+Set Shell "zsh"
+Set FontSize 16
+Set Width 1280
+Set Height 720
+Set TypingSpeed 20ms
+
+Type "npx sneakoscope install --yes"
+Sleep 500ms
+Enter
+Sleep 1s
+Ctrl+C
+
+Type "sks plan \"ship a proof-first review flow\""
+Enter
+Sleep 1s
+
+Type "sks review --staged"
+Enter
+Sleep 1s
+
+Type "sks ui --once"
+Enter
+Sleep 1s
+
+Type "sks naruto run \"demo no-op swarm\" --backend fake --clones 4 --work-items 4 --no-open-zellij --json"
+Enter
+Sleep 2s

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.8.7",
+  "version": "5.1.2",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -14,7 +14,8 @@
   },
   "bin": {
     "sks": "dist/bin/sks.js",
-    "sneakoscope": "dist/bin/sks.js"
+    "sneakoscope": "dist/bin/sks.js",
+    "sneakoscope-install": "dist/bin/install.js"
   },
   "publishConfig": {
     "access": "public",
@@ -32,8 +33,11 @@
     "!dist/**/*.tsbuildinfo",
     "!dist/**/__tests__",
     "!dist/**/*.test.js",
+    "!dist/scripts/*blackbox*.js",
     "!dist/vendor/openai-codex/rust-v0.131.0",
     "config/codex-releases/rust-v0.142.0.json",
+    "config/bench-baseline.json",
+    "bench/tasks",
     "schemas",
     "!schemas/codex/app-server-0.142/**",
     "schemas/codex/app-server-0.142/codex_app_server_protocol.v2.schemas.json",
@@ -41,6 +45,8 @@
     "crates/sks-core/Cargo.lock",
     "crates/sks-core/Cargo.toml",
     "crates/sks-core/src",
+    "docs/demo.tape",
+    "docs/assets/sneakoscope-architecture-pipeline.jpg",
     "README.md",
     "LICENSE"
   ],
@@ -60,17 +66,31 @@
     "runtime:dist-parity": "node ./dist/scripts/runtime-dist-parity-check.js",
     "release:check": "npm run release:check:affected --silent",
     "release:metadata": "node ./dist/scripts/release-metadata-check.js",
+    "release:gate-script-parity": "node ./dist/scripts/release-gate-script-parity-check.js",
     "release:check:parallel": "npm run build --silent && node ./dist/scripts/release-parallel-check.js && node ./dist/scripts/release-check-stamp.js write",
     "release:check:legacy": "npm run release:check:parallel --silent",
+    "release:dag-full-coverage": "node ./dist/scripts/release-dag-full-coverage-check.js",
     "core-skill:route-runtime-integration": "node ./dist/scripts/core-skill-route-runtime-integration-check.js",
+    "core-skill:no-drift": "node ./dist/scripts/core-skill-no-drift-check.js",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "schema:check": "node ./dist/scripts/check-runtime-schemas.js",
     "repo-audit": "node ./dist/scripts/repo-audit.js",
+    "native-capability:postcheck": "node ./dist/scripts/native-capability-postcheck-check.js",
+    "secret:preservation-guard": "node ./dist/scripts/secret-preservation-guard-check.js",
+    "secret:supabase-preservation-blackbox": "node ./dist/scripts/supabase-secret-preservation-blackbox.js",
+    "update:preserves-supabase-keys": "node ./dist/scripts/update-preserves-supabase-keys-blackbox.js",
+    "skill:dedupe-blackbox": "node ./dist/scripts/project-skill-dedupe-blackbox.js",
     "postinstall": "node ./dist/bin/sks.js postinstall",
     "selftest": "node ./dist/bin/sks.js selftest --mock",
     "doctor": "node ./dist/bin/sks.js doctor",
+    "doctor:fix-production-blackbox": "node ./dist/scripts/doctor-fix-production-blackbox.js",
+    "doctor:startup-config-repair-blackbox": "node ./dist/scripts/doctor-startup-config-repair-blackbox.js",
+    "doctor:context7-mcp-repair-blackbox": "node ./dist/scripts/doctor-context7-mcp-repair-blackbox.js",
+    "doctor:supabase-mcp-repair-blackbox": "node ./dist/scripts/doctor-supabase-mcp-repair-blackbox.js",
     "codex:config-load-probe": "node ./dist/scripts/codex-config-load-probe.js --json",
     "codex:actual-config-load-probe": "node ./dist/scripts/codex-config-load-probe.js --actual-codex --json",
+    "codex:0140-capability": "node ./dist/scripts/codex-0140-capability-check.js",
+    "codex:0140-feature-probes": "node ./dist/scripts/codex-0140-feature-probes-check.js",
     "runtime:ts-rust-boundary": "node ./dist/scripts/runtime-ts-rust-boundary-check.js",
     "release:check:dynamic": "node ./dist/scripts/release-check-dynamic.js",
     "release:check:dynamic:execute": "node ./dist/scripts/release-check-dynamic-execute.js",
@@ -96,6 +116,48 @@
     "feature:check": "node ./dist/bin/sks.js features check --json",
     "feature-quality:check": "node ./dist/scripts/check-feature-quality.js --release",
     "all-features:selftest": "node ./dist/bin/sks.js all-features selftest --mock --json",
+    "doctor:imagegen-repair": "node ./dist/scripts/doctor-imagegen-repair-check.js",
+    "image-fidelity:check": "node ./dist/scripts/image-fidelity-fixture-check.js",
+    "imagegen:capability": "node ./dist/scripts/imagegen-capability-check.js",
+    "imagegen:gpt-image-2-request-validator": "node ./dist/scripts/gpt-image-2-request-validator-check.js",
+    "ux-review:run-wires-imagegen": "node ./dist/scripts/ux-review-run-wires-imagegen-check.js",
+    "ux-review:extract-wires-real-extractor": "node ./dist/scripts/ux-review-extract-wires-real-extractor-check.js",
+    "ux-review:patch-diff-recheck": "node ./dist/scripts/ux-review-patch-diff-recheck-check.js",
+    "ux-review:imagegen-blackbox": "node ./dist/scripts/ux-review-imagegen-blackbox-check.js",
+    "ux-review:real-loop-fixture": "node ./dist/scripts/ux-review-real-loop-fixture-check.js",
+    "ppt:real-export-adapter": "node ./dist/scripts/ppt-real-export-adapter-check.js",
+    "ppt:real-imagegen-wiring": "node ./dist/scripts/ppt-real-imagegen-wiring-check.js",
+    "ppt:reexport-rereview": "node ./dist/scripts/ppt-reexport-rereview-check.js",
+    "ppt:full-e2e-blackbox": "node ./dist/scripts/ppt-full-e2e-blackbox-check.js",
+    "ppt:full-e2e-artifact-graph": "node ./dist/scripts/ppt-full-e2e-artifact-graph-check.js",
+    "ppt:imagegen-blackbox": "node ./dist/scripts/ppt-imagegen-blackbox-check.js",
+    "ux-ppt:structured-extraction": "node ./dist/scripts/ux-ppt-structured-extraction-check.js",
+    "dfix:patch-handoff": "node ./dist/scripts/dfix-patch-handoff-check.js",
+    "dfix:verification-recommendation": "node ./dist/scripts/dfix-verification-recommendation-check.js",
+    "dfix:fast-kernel": "node ./dist/scripts/dfix-fast-kernel-check.js",
+    "dfix:blackbox-fast": "node ./dist/scripts/dfix-fast-blackbox-check.js",
+    "dfix:performance": "node ./dist/scripts/dfix-performance-check.js",
+    "dfix:parallel-write-blackbox": "node ./dist/scripts/dfix-parallel-write-blackbox.js",
+    "all-features:deep-completion": "node ./dist/scripts/all-feature-deep-completion-check.js",
+    "evidence:flagship-coverage": "node ./dist/scripts/evidence-flagship-coverage-check.js",
+    "ux-review:generate-callouts-fixture": "node ./dist/scripts/ux-review-generate-callouts-fixture-check.js",
+    "ux-review:extract-real-callouts-fixture": "node ./dist/scripts/ux-review-extract-real-callouts-fixture-check.js",
+    "ux-review:patch-handoff-fixture": "node ./dist/scripts/ux-review-patch-handoff-fixture-check.js",
+    "ux-review:recapture-recheck-fixture": "node ./dist/scripts/ux-review-recapture-recheck-fixture-check.js",
+    "ux-review:no-text-fallback": "node ./dist/scripts/ux-review-no-text-fallback-check.js",
+    "ux-review:no-fake-callouts": "node ./dist/scripts/ux-review-no-fake-callouts-check.js",
+    "ux-review:image-voxel-relations": "node ./dist/scripts/ux-review-image-voxel-relations-check.js",
+    "ppt:imagegen-review-fixture": "node ./dist/scripts/ppt-imagegen-review-fixture-check.js",
+    "ppt:slide-export-fixture": "node ./dist/scripts/ppt-slide-export-fixture-check.js",
+    "ppt:no-text-fallback": "node ./dist/scripts/ppt-no-text-fallback-check.js",
+    "ppt:no-mock-as-real": "node ./dist/scripts/ppt-no-mock-as-real-check.js",
+    "ppt:issue-extraction-fixture": "node ./dist/scripts/ppt-issue-extraction-fixture-check.js",
+    "ppt:image-voxel-relations": "node ./dist/scripts/ppt-image-voxel-relations-check.js",
+    "ppt:proof-trust-fixture": "node ./dist/scripts/ppt-proof-trust-fixture-check.js",
+    "dfix:fixture": "node ./dist/scripts/dfix-fixture-check.js",
+    "dfix:verification": "node ./dist/scripts/dfix-verification-check.js",
+    "all-features:completion": "node ./dist/bin/sks.js all-features complete --json",
+    "json-schema:recursive-check": "node ./dist/scripts/json-schema-recursive-check.js",
     "trust:check": "node ./dist/bin/sks.js trust validate latest --json || node ./dist/scripts/trust-fixture-check.js",
     "wrongness:check": "node ./dist/bin/sks.js wrongness validate project --json && node ./dist/scripts/wrongness-fixture-check.js",
     "git-hygiene:check": "node ./dist/bin/sks.js git doctor --json",
@@ -109,10 +171,12 @@
     "qa-loop:effort-escalation": "node ./dist/scripts/qa-loop-effort-escalation-check.js",
     "qa-loop:budget-policy": "node ./dist/scripts/qa-loop-budget-policy-check.js",
     "naruto:real-active-pool-runtime": "node ./dist/scripts/naruto-real-active-pool-runtime-check.js",
+    "bench": "node ./dist/scripts/coding-bench-check.js",
+    "release:check:bench": "npm run build:incremental --silent && npm run bench --silent",
     "release:check:affected": "npm run build:incremental --silent && node ./dist/scripts/release-gate-dag-runner.js --preset affected --changed-since auto --sla 5m && node ./dist/scripts/release-check-stamp.js write",
     "release:check:fast": "npm run build:incremental --silent && node ./dist/scripts/release-gate-dag-runner.js --preset fast --changed-since auto --sla 5m && node ./dist/scripts/release-check-stamp.js write",
     "release:check:confidence": "npm run build:incremental --silent && node ./dist/scripts/release-gate-dag-runner.js --preset confidence --changed-since auto --sla 5m && node ./dist/scripts/release-check-stamp.js write",
-    "release:check:full": "npm run build:clean --silent && node ./dist/scripts/release-gate-dag-runner.js --preset release --full && node ./dist/scripts/release-check-stamp.js write",
+    "release:check:full": "npm run build:clean --silent && node ./dist/scripts/release-gate-dag-runner.js --preset release --full && node ./dist/scripts/release-gate-dag-runner.js --preset bench --full && node ./dist/scripts/release-check-stamp.js write",
     "publish:prep-ignore-scripts": "npm run prepublishOnly",
     "publish:ignore-scripts": "npm run publish:prep-ignore-scripts && npm publish --ignore-scripts",
     "naruto:ssot-gate-aliases": "node ./dist/scripts/naruto-ssot-gate-aliases-check.js",

package/schemas/codex/completion-proof.schema.json

@@ -3,12 +3,13 @@
   "$id": "https://sneakoscope.local/schemas/codex/completion-proof.schema.json",
   "title": "SKS Completion Proof",
   "type": "object",
-  "required": ["schema", "mission_id", "route", "status", "evidence", "claims", "unverified", "blockers"],
+  "required": ["schema", "execution_class", "mission_id", "route", "status", "evidence", "claims", "unverified", "blockers"],
   "properties": {
     "schema": { "const": "sks.completion-proof.v1" },
+    "execution_class": { "enum": ["real", "mock_fixture"] },
     "mission_id": { "type": ["string", "null"] },
     "route": { "type": ["string", "null"] },
-    "status": { "enum": ["verified", "verified_partial", "blocked", "failed", "not_verified"] },
+    "status": { "enum": ["verified", "verified_partial", "mock_only", "blocked", "failed", "not_verified"] },
     "evidence": { "type": "object" },
     "claims": { "type": "array" },
     "unverified": { "type": "array" },

package/schemas/release/release-gate-node.schema.json

@@ -18,11 +18,12 @@
             "type": "array",
             "minItems": 1,
             "items": {
-              "enum": ["cpu-light", "cpu-heavy", "io-light", "io-heavy", "git", "git-worktree", "zellij-real", "local-llm-real", "remote-model-real", "python", "network", "global-config", "publish", "fs-read"]
+              "enum": ["cpu-light", "cpu-heavy", "io-light", "io-heavy", "git", "git-worktree", "zellij-real", "browser-real", "secret-sensitive", "local-llm-real", "remote-model-real", "python", "network", "global-config", "publish", "fs-read", "fs-write", "timing-sensitive"]
             }
           },
           "side_effect": { "enum": ["hermetic", "real-env"] },
           "timeout_ms": { "type": "integer", "minimum": 1 },
+          "output_contract": { "const": "sks.gate-result.v1" },
           "cache": {
             "type": "object",
             "required": ["enabled", "inputs"],

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

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

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

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

package/dist/scripts/agent-parallel-write-blackbox.js

@@ -1,56 +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, importDist, root } from './sks-1-18-gate-lib.js';
-const schemaMod = await importDist('core/agents/agent-patch-schema.js');
-const applyMod = await importDist('core/agents/agent-patch-apply-worker.js');
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-agent-blackbox-'));
-fs.writeFileSync(path.join(tmp, 'fixture.txt'), 'before\n');
-const envelope = schemaMod.normalizeAgentPatchEnvelope({
-    agent_id: 'blackbox-agent',
-    session_id: 'blackbox-session',
-    slot_id: 'blackbox-slot',
-    generation_index: 1,
-    lease_id: 'lease:blackbox-agent:fixture.txt',
-    operations: [{ op: 'replace', path: 'fixture.txt', search: 'before', replace: 'after' }]
-});
-const dry = await applyMod.applyAgentPatchEnvelope(tmp, envelope, { dryRun: true });
-const applied = await applyMod.applyAgentPatchEnvelope(tmp, envelope);
-const agentRun = spawnSync(process.execPath, [
-    'dist/bin/sks.js',
-    'agent',
-    'run',
-    'agent parallel write blackbox route fixture',
-    '--mock',
-    '--write-mode',
-    'parallel',
-    '--apply-patches',
-    '--dry-run-patches',
-    '--max-write-agents',
-    '1',
-    '--json'
-], { cwd: root, encoding: 'utf8', maxBuffer: 2 * 1024 * 1024 });
-const agentJson = parseJson(agentRun.stdout);
-const routePolicy = agentJson?.parallel_write_policy || null;
-const report = { schema: 'sks.agent-parallel-write-blackbox.v1', ok: dry.ok && applied.ok && agentRun.status === 0 && routePolicy?.route_level_flags_wired === true, dry, applied, route_command: { status: agentRun.status, mission_id: agentJson?.mission_id || null, route_policy: routePolicy, stderr_tail: agentRun.stderr.slice(-2000) } };
-const out = path.join(root, '.sneakoscope', 'reports', 'agent-parallel-write-blackbox.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(dry.status === 'dry_run', 'agent parallel write blackbox dry-run status mismatch', report);
-assertGate(applied.ok === true, 'agent parallel write blackbox apply failed', report);
-assertGate(fs.readFileSync(path.join(tmp, 'fixture.txt'), 'utf8') === 'after\n', 'agent parallel write blackbox content mismatch', report);
-assertGate(routePolicy?.write_mode === 'parallel', 'Agent route must carry --write-mode parallel into native agent policy', report);
-assertGate(routePolicy?.apply_patches === true, 'Agent route must carry --apply-patches into native agent policy', report);
-emitGate('agent:parallel-write-blackbox', { changed_files: applied.changed_files.length });
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=agent-parallel-write-blackbox.js.map

package/dist/scripts/agent-patch-swarm-route-blackbox.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runPatchSwarmRouteBlackbox } from './agent-patch-swarm-gate-lib.js';
-await runPatchSwarmRouteBlackbox({
-    gate: 'agent:patch-swarm-route-blackbox',
-    route: '$Agent',
-    routeCommand: 'sks agent run',
-    reportName: 'agent-patch-swarm-route-blackbox'
-});
-//# sourceMappingURL=agent-patch-swarm-route-blackbox.js.map

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

@@ -1,132 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const PROMPT = 'route truth dynamic scheduler fixture';
-const ROUTE_ARGS = ['--agents', '5', '--work-items', '8', '--target-active-slots', '5', '--minimum-work-items', '5', '--max-queue-expansion', '10', '--mock', '--json'];
-export function runRouteBackfillBlackbox(route, gate) {
-    if (String(route).toLowerCase().includes('team'))
-        return runActualTeamBackfillBlackbox(gate);
-    if (String(route).toLowerCase().includes('research'))
-        return runActualResearchBackfillBlackbox(gate);
-    if (String(route).toLowerCase().includes('qa'))
-        return runActualQaBackfillBlackbox(gate);
-    return runActualAgentBackfillBlackbox(gate);
-}
-export function runActualAgentBackfillBlackbox(gate = 'agent:backfill-route-blackbox') {
-    const json = runSks(['agent', 'run', PROMPT, '--route', '$Agent', ...ROUTE_ARGS], gate);
-    validateNativeRun(json, gate, { route: '$Agent', command: 'sks agent run', kind: 'actual_agent_command' });
-    return json;
-}
-export function runActualTeamBackfillBlackbox(gate = 'team:backfill-route-blackbox') {
-    const json = runSks(['team', PROMPT, ...ROUTE_ARGS, '--no-open-zellij'], gate);
-    validateNativeRun(json.native_agent_run, gate, { route: '$Team', command: 'sks team', kind: 'actual_team_command' });
-    return json;
-}
-export function runActualResearchBackfillBlackbox(gate = 'research:backfill-route-blackbox') {
-    const prepared = runSks(['research', 'prepare', PROMPT, '--json'], `${gate}:prepare`);
-    const missionId = prepared.mission_id;
-    assertGate(Boolean(missionId), `${gate} research prepare must return mission_id`, prepared);
-    const json = runSks(['research', 'run', missionId, ...ROUTE_ARGS], gate);
-    const native = json.native_agent_run || readMissionJson(missionId, 'research-native-agent-run.json');
-    validateNativeRun(native, gate, { route: '$Research', command: 'sks research run', kind: 'actual_research_command' });
-    return json;
-}
-export function runActualQaBackfillBlackbox(gate = 'qa:backfill-route-blackbox') {
-    const prepared = runSks(['qa-loop', 'prepare', PROMPT, '--json'], `${gate}:prepare`);
-    const missionId = prepared.mission_id;
-    assertGate(Boolean(missionId), `${gate} qa prepare must return mission_id`, prepared);
-    const json = runSks(['qa-loop', 'run', missionId, ...ROUTE_ARGS], gate);
-    const native = json.native_agent_run || readMissionJson(missionId, 'qa-native-agent-run.json');
-    validateNativeRun(native, gate, { route: '$QA-LOOP', command: 'sks qa-loop run', kind: 'actual_qa_command' });
-    return json;
-}
-export function validateNativeRun(json, gate, expected = {}) {
-    assertGate(Boolean(json), `${gate} native agent run JSON missing`, {});
-    const state = json.scheduler?.state || {};
-    const proof = json.proof || {};
-    const ledgerRoot = path.join(root, json.ledger_root || '');
-    assertGate(fs.existsSync(ledgerRoot), `${gate} ledger root missing`, { ledger_root: json.ledger_root });
-    const events = readJsonl(path.join(ledgerRoot, 'agent-scheduler-events.jsonl'));
-    const backfills = events.filter((event) => event.event_type === 'backfill_event');
-    const graph = readJson(path.join(ledgerRoot, 'agent-task-graph.json'));
-    const queue = readJson(path.join(ledgerRoot, 'agent-work-queue.json'));
-    const supervisor = readJson(path.join(ledgerRoot, 'agent-zellij-lane-supervisor.json'));
-    assertGate(json.ok === true, `${gate} proof must pass`, proof);
-    assertGate(graph.schema === 'sks.agent-task-graph.v1', `${gate} task graph schema missing`, graph);
-    assertGate(graph.target_active_slots === 5 && graph.total_work_items === 8, `${gate} task graph must split active slots and work items`, graph.route_work_count_summary);
-    assertGate(queue.total_work_items === graph.total_work_items, `${gate} work queue must match task graph`, { queue: queue.total_work_items, graph: graph.total_work_items });
-    assertGate(state.target_active_slots === 5, `${gate} target active slots must be 5`, state);
-    assertGate(state.total_work_items === queue.total_work_items, `${gate} scheduler must match work queue`, { scheduler: state.total_work_items, queue: queue.total_work_items });
-    assertGate(state.max_observed_active_slots === 5, `${gate} must observe 5 active slots`, state);
-    assertGate(state.expected_backfill_count >= 2, `${gate} expected backfill count must be at least 2`, state);
-    assertGate(state.backfill_count >= state.expected_backfill_count, `${gate} backfills must satisfy expectation`, state);
-    assertGate(backfills.length >= 2, `${gate} must emit at least two backfill events`, { backfills });
-    assertGate(events.some((event) => event.event_type === 'scheduler_draining'), `${gate} must emit scheduler_draining`, {});
-    assertGate(state.pending_queue_drained === true, `${gate} queue must drain`, state);
-    assertGate(state.all_generations_closed === true, `${gate} generations must close`, state);
-    assertGate(proof.requested_work_items === 8, `${gate} proof must record requested work items`, proof);
-    assertGate(proof.actual_total_work_items === 8, `${gate} proof must record actual total work items`, proof);
-    assertGate(proof.task_graph_total_work_items === 8, `${gate} proof task graph total must be 8`, proof);
-    assertGate(proof.work_queue_total_work_items === 8, `${gate} proof work queue total must be 8`, proof);
-    assertGate(proof.scheduler_total_work_items === 8, `${gate} proof scheduler total must be 8`, proof);
-    assertGate(proof.task_graph_matches_cli_options === true, `${gate} proof must bind task graph to CLI options`, proof);
-    assertGate(proof.work_queue_matches_task_graph === true, `${gate} proof must bind work queue to task graph`, proof);
-    assertGate(proof.scheduler_matches_work_queue === true, `${gate} proof must bind scheduler to work queue`, proof);
-    assertGate(proof.generation_count >= state.total_work_items, `${gate} proof generation count must cover work items`, proof);
-    assertGate(proof.terminal_close_report_count >= proof.generation_count, `${gate} close reports must cover generations`, proof);
-    assertGate(proof.terminal_reports_match_generations === true, `${gate} proof must bind terminal reports to generations`, proof);
-    assertGate(proof.source_intelligence_generation_refs_ok === true && proof.task_graph_source_refs_ok === true && proof.work_queue_source_refs_ok === true, `${gate} source refs must propagate`, proof);
-    assertGate(proof.goal_mode_generation_refs_ok === true && proof.task_graph_goal_refs_ok === true && proof.work_queue_goal_refs_ok === true, `${gate} goal refs must propagate`, proof);
-    assertGate(proof.lane_supervisor_integrated === true && supervisor.schema === 'sks.zellij-lane-supervisor.v1', `${gate} Zellij supervisor must be integrated`, { proof, supervisor });
-    assertGate(proof.zellij_lane_no_flicker_verified === true, `${gate} Zellij no-flicker proof must pass`, proof);
-    assertGate(proof.real_route_command_used === true, `${gate} must use real route command`, proof);
-    assertGate(String(proof.route_command || '').includes(expected.command), `${gate} proof route command mismatch`, proof);
-    assertGate(proof.route_blackbox_kind === expected.kind, `${gate} proof route blackbox kind mismatch`, proof);
-    if (expected.route !== '$Agent') {
-        assertGate(!/\bagent\s+run\b/i.test(String(proof.route_command || '')), `${gate} must not use agent run stand-in`, proof);
-    }
-    emitGate(gate, {
-        route: expected.route,
-        command: proof.route_command,
-        mission_id: json.mission_id,
-        target_active_slots: state.target_active_slots,
-        total_work_items: state.total_work_items,
-        expected_backfill_count: state.expected_backfill_count,
-        backfill_count: state.backfill_count,
-        generation_count: proof.generation_count
-    });
-}
-function runSks(args, gate) {
-    const result = spawnSync(process.execPath, ['dist/bin/sks.js', ...args], {
-        cwd: root,
-        encoding: 'utf8',
-        env: { ...process.env, SKS_AGENT_DYNAMIC_BACKFILL_FIXTURE: '1' },
-        maxBuffer: 1024 * 1024 * 16
-    });
-    assertGate(result.status === 0, `${gate} route command failed`, { args, stdout: result.stdout.slice(-4000), stderr: result.stderr.slice(-4000) });
-    return parseJson(result.stdout, gate);
-}
-function parseJson(stdout, gate) {
-    try {
-        return JSON.parse(stdout);
-    }
-    catch (err) {
-        const start = stdout.indexOf('{');
-        const end = stdout.lastIndexOf('}');
-        if (start >= 0 && end > start)
-            return JSON.parse(stdout.slice(start, end + 1));
-        assertGate(false, `${gate} did not emit JSON`, { stdout: stdout.slice(-4000), error: String(err) });
-    }
-}
-function readMissionJson(missionId, rel) {
-    return readJson(path.join(root, '.sneakoscope', 'missions', missionId, rel));
-}
-function readJson(file) {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-function readJsonl(file) {
-    return fs.readFileSync(file, 'utf8').trim().split(/\n+/).filter(Boolean).map((line) => JSON.parse(line));
-}
-//# sourceMappingURL=agent-route-blackbox-lib.js.map