sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/doctor-transaction-engine-check.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { assertGate, emitGate, makeTempRoot } from './sks-3-1-8-check-lib.js';
+import { runDoctorFixTransaction } from '../core/doctor/doctor-transaction.js';
+import { doctorRepairPostcheck } from '../core/doctor/doctor-repair-postcheck.js';
+const root = await makeTempRoot('sks-doctor-tx-');
+let rollbackCalled = false;
+const tx = await runDoctorFixTransaction({
+    root,
+    phases: [
+        { id: 'preflight', run: async () => ({ id: 'preflight', ok: true }) },
+        {
+            id: 'optional_manual',
+            required_for_ready: false,
+            run: async () => ({ id: 'optional_manual', ok: false, manual_required: true, required_for_ready: false, blockers: ['operator_action_required'] })
+        },
+        {
+            id: 'rolled_back',
+            run: async () => ({ id: 'rolled_back', ok: false, blockers: ['fixture_failure'] }),
+            rollback: async () => {
+                rollbackCalled = true;
+            }
+        }
+    ],
+    reportPath: null
+});
+const postcheck = doctorRepairPostcheck(tx);
+assertGate(rollbackCalled && tx.rollback_performed === true, 'doctor transaction runner must execute rollback hooks for failed phases', tx);
+assertGate(tx.ok === false && postcheck.ok === false, 'required failed phase must block readiness', { tx, postcheck });
+assertGate(tx.phases.find((phase) => phase.id === 'optional_manual')?.required_for_ready === false, 'optional manual phase must be explicitly marked', tx);
+emitGate('doctor:transaction-engine', { phases: tx.phases.length });
+//# sourceMappingURL=doctor-transaction-engine-check.js.map

package/dist/scripts/doctor-zellij-fix-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('doctor:zellij-fix-blackbox');
+//# sourceMappingURL=doctor-zellij-fix-blackbox.js.map

package/dist/scripts/doctor-zellij-fix-output-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('doctor:zellij-fix-output');
+//# sourceMappingURL=doctor-zellij-fix-output-check.js.map

package/dist/scripts/doctor-zellij-no-homebrew-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('doctor:zellij-no-homebrew-blackbox');
+//# sourceMappingURL=doctor-zellij-no-homebrew-blackbox.js.map

package/dist/scripts/doctor-zellij-repair-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('doctor:zellij-repair');
+//# sourceMappingURL=doctor-zellij-repair-check.js.map

package/dist/scripts/doctor-zellij-upgrade-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('doctor:zellij-upgrade-blackbox');
+//# sourceMappingURL=doctor-zellij-upgrade-blackbox.js.map

package/dist/scripts/evidence-fixture-check.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { writeEvidenceIndexForProof } from '../core/evidence/evidence-router.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-evidence-fixture-'));
+const mission = path.join(root, '.sneakoscope', 'missions', 'M-evidence');
+await fs.mkdir(mission, { recursive: true });
+await fs.writeFile(path.join(mission, 'completion-proof.json'), '{}\n');
+await fs.writeFile(path.join(mission, 'route-gate.json'), '{}\n');
+const index = await writeEvidenceIndexForProof(root, {
+    schema: 'sks.completion-proof.v1',
+    mission_id: 'M-evidence',
+    route: '$Team',
+    status: 'verified_partial',
+    evidence: { artifacts: ['route-gate.json'] },
+    claims: [],
+    unverified: ['fixture evidence'],
+    blockers: []
+});
+const ok = index.status === 'verified_partial' && index.records.every((record) => record.source !== 'mock' || record.trust !== 'high');
+console.log(JSON.stringify({ schema: 'sks.evidence-fixture-check.v1', ok, status: index.status, records: index.records.length, issues: index.issues }, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=evidence-fixture-check.js.map

package/dist/scripts/evidence-flagship-coverage-check.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { emitGate, requireContains, root } from './sks-1-12-real-execution-check-lib.js';
+requireContains('evidence:flagship-coverage', 'src/core/commands/image-ux-review-command.ts', [
+    'visualEvidence: { image_ux_review',
+    'IMAGE_UX_REVIEW_CALLOUT_EXTRACTION_REPORT_ARTIFACT'
+]);
+requireContains('evidence:flagship-coverage', 'src/core/commands/ppt-command.ts', [
+    'visualEvidence: { ppt_review',
+    'PPT_REVIEW_ARTIFACT_PATHS'
+]);
+requireContains('evidence:flagship-coverage', 'src/core/dfix.ts', [
+    'visualEvidence: { dfix',
+    'DFIX_VERIFICATION_SUGGESTION_ARTIFACT'
+]);
+requireContains('evidence:flagship-coverage', 'src/scripts/release-readiness-report.ts', [
+    'all_features_completion',
+    'image_ux_review',
+    'ppt_imagegen_review',
+    'dfix'
+]);
+requireContains('evidence:flagship-coverage', 'src/core/proof/route-finalizer.ts', [
+    'wrongnessProofEvidence',
+    'writeRouteCompletionProof'
+]);
+requireContains('evidence:flagship-coverage', 'src/core/trust-kernel/trust-report.ts', [
+    'buildTrustReport',
+    'evaluateWrongnessTrust'
+]);
+requireContains('evidence:flagship-coverage', 'src/core/evidence/flagship-proof-graph-validator.ts', [
+    'completionProofStatusOk',
+    'trustStatusOk'
+]);
+const report = {
+    schema: 'sks.evidence-flagship-coverage.v1',
+    ok: true,
+    gate: 'evidence:flagship-coverage',
+    flagship_routes: ['UX-Review', 'PPT Imagegen Review', 'DFix', 'All-feature completion'],
+    evidence_index_linked: true,
+    completion_proof_linked: true,
+    trust_linked: true,
+    wrongness_behavior_defined: true,
+    completion_proof_link_source: 'static_source_contract_and_status_validator',
+    trust_link_source: 'static_source_contract_and_status_validator',
+    wrongness_link_source: 'static_source_contract',
+    mock_real_cap_checked: true,
+    local_only_policy_checked: true
+};
+const out = path.join(root, '.sneakoscope', 'reports', 'evidence-flagship-coverage.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+emitGate('evidence:flagship-coverage', report);
+//# sourceMappingURL=evidence-flagship-coverage-check.js.map

package/dist/scripts/fake-real-proof-policy-v2-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/proof/fake-real-proof-policy.js');
+const fixtureReal = mod.evaluateFakeRealProofPolicy({
+    backend: 'codex-sdk',
+    real_parallel_claim: true,
+    output_schema_used: true,
+    output_last_message_path: 'result.json',
+    fixture_instrumented_real: true,
+    work_graph_quality_score: 0.8,
+    cleanup_proof: { ok: true }
+});
+const requiredMissing = mod.evaluateFakeRealProofPolicy({
+    backend: 'codex-sdk',
+    real_parallel_claim: true,
+    integration_optional: true,
+    require_real_dynamic_agents: true
+});
+const zellij = mod.evaluateFakeRealProofPolicy({ backend: 'zellij', zellij_pane_verified: true, work_graph_quality_score: 0.8, cleanup_proof: { ok: true } });
+assertGate(fixtureReal.proof_level === 'fixture_instrumented_real', 'fixture-instrumented real smoke must not be plain proven', fixtureReal);
+assertGate(requiredMissing.proof_level === 'real_required_missing' && requiredMissing.ok === false, 'required missing real runtime must block', requiredMissing);
+assertGate(zellij.subsystem_levels.zellij_pane === 'proven', 'real Zellij pane proof must be subsystem-proven', zellij);
+assertGate(zellij.subsystem_levels.cleanup === 'proven', 'cleanup proof level must be included', zellij);
+assertGate(zellij.subsystem_levels.work_graph === 'proven', 'work graph proof level must be included', zellij);
+emitGate('proof:fake-real-policy-v2', { fixture_real: fixtureReal.proof_level, required_missing: requiredMissing.proof_level });
+//# sourceMappingURL=fake-real-proof-policy-v2-check.js.map

package/dist/scripts/fake-vs-real-proof-policy-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/proof/fake-real-proof-policy.js');
+const fake = mod.evaluateFakeRealProofPolicy({ backend: 'fake', real_parallel_claim: false });
+assertGate(fake.ok === true && fake.proof_level === 'fixture_only', 'fake backend must be fixture_only', fake);
+const badFake = mod.evaluateFakeRealProofPolicy({ backend: 'fake', real_parallel_claim: true });
+assertGate(badFake.ok === false && badFake.blockers.includes('fake_backend_claimed_real_parallel'), 'fake backend cannot claim real parallel', badFake);
+const zellij = mod.evaluateFakeRealProofPolicy({ backend: 'zellij', zellij_pane_verified: true });
+assertGate(zellij.ok === true && zellij.proof_level === 'proven', 'real Zellij with pane evidence must be proven', zellij);
+const optional = mod.evaluateFakeRealProofPolicy({ backend: 'codex-sdk', real_parallel_claim: true, integration_optional: true });
+assertGate(optional.ok === true && optional.proof_level === 'integration_optional', 'unavailable real smoke must be integration_optional', optional);
+emitGate('proof:fake-vs-real-policy', { fake: fake.proof_level, zellij: zellij.proof_level, optional: optional.proof_level });
+//# sourceMappingURL=fake-vs-real-proof-policy-check.js.map

package/dist/scripts/fast-codex-service-tier-proof-check.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const syntax = await import(pathToFileURL(path.join(root, 'dist', 'core', 'codex', 'codex-cli-syntax-builder.js')).href);
+const fastMode = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'fast-mode-policy.js')).href);
+const args = syntax.buildCodexExecArgs({ prompt: 'fixture', sandbox: 'workspace-write', serviceTier: 'fast' });
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-fast-tier-proof-'));
+const reportDir = path.join(temp, 'sessions', 'agent');
+fs.mkdirSync(reportDir, { recursive: true });
+fs.writeFileSync(path.join(reportDir, 'agent-process-report.json'), `${JSON.stringify({
+    schema: 'sks.agent-process-report.v1',
+    backend: 'codex-sdk',
+    fast_mode: true,
+    service_tier: 'fast',
+    sdk_config_service_tier: 'fast'
+})}\n`);
+fs.writeFileSync(path.join(reportDir, 'worker-fast-mode.json'), `${JSON.stringify({
+    schema: 'sks.native-cli-worker-fast-mode.v1',
+    fast_mode: true,
+    service_tier: 'fast'
+})}\n`);
+const proof = await fastMode.writeFastModePropagationProof(temp, { policy: fastMode.resolveFastModePolicy({ fastMode: true }) });
+const ok = args.includes('-c')
+    && args.includes('service_tier=fast')
+    && !args.includes('--full-auto')
+    && !args.includes('--dangerously-bypass-approvals-and-sandbox')
+    && proof.ok === true;
+console.log(JSON.stringify({ schema: 'sks.fast-codex-service-tier-proof-check.v1', ok, args, proof }, null, 2));
+if (!ok)
+    process.exitCode = 1;
+function fail(blocker, detail) {
+    console.log(JSON.stringify({ schema: 'sks.fast-codex-service-tier-proof-check.v1', ok: false, blocker, detail }, null, 2));
+    process.exit(1);
+}
+//# sourceMappingURL=fast-codex-service-tier-proof-check.js.map

package/dist/scripts/flagship-proof-graph-v2-check.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { writeCodexHookOfficialParityReport } from '../core/codex-hooks/codex-hook-official-parity.js';
+import { validateFlagshipProofGraph } from '../core/evidence/flagship-proof-graph-validator.js';
+const root = process.cwd();
+await refreshDependencyReports(root);
+const report = await validateFlagshipProofGraph(process.cwd());
+const out = path.join(process.cwd(), '.sneakoscope', 'reports', 'flagship-proof-graph-v2.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok)
+    process.exitCode = 1;
+async function refreshDependencyReports(root) {
+    await writeCodexHookOfficialParityReport(root, {
+        outputPath: path.join(root, '.sneakoscope', 'reports', 'codex-hook-parity-1.14.1.json')
+    });
+    for (const script of [
+        './dist/scripts/imagegen-real-smoke-check.js',
+        './dist/scripts/ppt-full-e2e-blackbox-check.js',
+        './dist/scripts/evidence-flagship-coverage-check.js'
+    ]) {
+        const run = spawnSync(process.execPath, [script], {
+            cwd: root,
+            env: process.env,
+            encoding: 'utf8',
+            maxBuffer: 8 * 1024 * 1024
+        });
+        if (run.status !== 0) {
+            const report = {
+                schema: 'sks.flagship-proof-graph.v2',
+                ok: false,
+                blocker: `dependency_report_failed:${script}`,
+                stdout_tail: run.stdout.slice(-2000),
+                stderr_tail: run.stderr.slice(-2000)
+            };
+            const out = path.join(root, '.sneakoscope', 'reports', 'flagship-proof-graph-v2.json');
+            fs.mkdirSync(path.dirname(out), { recursive: true });
+            fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+            console.log(JSON.stringify(report, null, 2));
+            process.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=flagship-proof-graph-v2-check.js.map

package/dist/scripts/flagship-proof-graph-v3-check.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const reportDir = path.join(root, '.sneakoscope', 'reports');
+fs.mkdirSync(reportDir, { recursive: true });
+const initialFreshness = ensureDistFresh({ rebuild: true });
+if (!initialFreshness.ok) {
+    const report = { schema: 'sks.flagship-proof-graph.v3', ok: false, blocker: 'dist_not_fresh_before_dependencies', freshness: initialFreshness };
+    fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
+    console.log(JSON.stringify(report, null, 2));
+    process.exit(1);
+}
+const dependencies = [
+    ['flagship-proof-graph-v2.json', './dist/scripts/flagship-proof-graph-v2-check.js'],
+    ['mad-sks-permission-model.json', './dist/scripts/mad-sks-permission-model-check.js'],
+    ['mad-sks-immutable-harness.json', './dist/scripts/mad-sks-immutable-harness-check.js'],
+    ['mad-sks-write-guard.json', './dist/scripts/mad-sks-write-guard-check.js'],
+    ['mad-sks-audit-proof.json', './dist/scripts/mad-sks-audit-proof-check.js'],
+    ['mad-sks-no-harness-modification.json', './dist/scripts/mad-sks-no-harness-modification-check.js'],
+    ['legacy-multiagent-removal.json', './dist/scripts/legacy-multiagent-removal-check.js'],
+    ['release-native-agent-fixture-check.json', './dist/scripts/release-native-agent-fixture-check.js'],
+    ['codex-exec-output-schema-actual-syntax.json', './dist/scripts/codex-exec-output-schema-actual-syntax-check.js'],
+    ['release-dist-freshness.json', './dist/scripts/release-dist-freshness-check.js']
+];
+for (const [name, script] of dependencies) {
+    const run = spawnSync(process.execPath, [script], { cwd: root, encoding: 'utf8', env: process.env, maxBuffer: 20 * 1024 * 1024 });
+    const parsed = parseLastJson(run.stdout);
+    if (parsed)
+        fs.writeFileSync(path.join(reportDir, name), `${JSON.stringify(parsed, null, 2)}\n`);
+    if (run.status !== 0) {
+        const report = { schema: 'sks.flagship-proof-graph.v3', ok: false, blocker: `dependency_failed:${script}`, stdout_tail: run.stdout.slice(-3000), stderr_tail: run.stderr.slice(-3000) };
+        fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
+        console.log(JSON.stringify(report, null, 2));
+        process.exit(1);
+    }
+}
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok) {
+    const report = { schema: 'sks.flagship-proof-graph.v3', ok: false, blocker: 'dist_not_fresh', freshness };
+    fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
+    console.log(JSON.stringify(report, null, 2));
+    process.exit(1);
+}
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'evidence', 'flagship-proof-graph-validator.js')).href);
+const report = await mod.validateFlagshipProofGraphV3(root);
+fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v3.json'), `${JSON.stringify(report, null, 2)}\n`);
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok)
+    process.exitCode = 1;
+function parseLastJson(text) {
+    const raw = String(text || '').trim();
+    if (!raw)
+        return null;
+    const start = raw.lastIndexOf('\n{');
+    const jsonText = start >= 0 ? raw.slice(start + 1) : raw;
+    try {
+        return JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=flagship-proof-graph-v3-check.js.map

package/dist/scripts/flagship-proof-graph-v4-check.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const reportDir = path.join(root, '.sneakoscope', 'reports');
+fs.mkdirSync(reportDir, { recursive: true });
+const initialFreshness = ensureDistFresh({ rebuild: true });
+if (!initialFreshness.ok)
+    fail('dist_not_fresh_before_dependencies', { freshness: initialFreshness });
+const dependencies = [
+    ['flagship-proof-graph-v3.json', './dist/scripts/flagship-proof-graph-v3-check.js'],
+    ['mad-sks-actual-executor-blackbox.json', './dist/scripts/mad-sks-actual-executor-blackbox.js'],
+    ['mad-sks-file-write-executor.json', './dist/scripts/mad-sks-file-write-executor-check.js'],
+    ['mad-sks-shell-executor.json', './dist/scripts/mad-sks-shell-executor-check.js'],
+    ['mad-sks-package-executor.json', './dist/scripts/mad-sks-package-executor-check.js'],
+    ['mad-sks-service-executor.json', './dist/scripts/mad-sks-service-executor-check.js'],
+    ['mad-sks-db-executor.json', './dist/scripts/mad-sks-db-executor-check.js'],
+    ['mad-sks-rollback-apply.json', './dist/scripts/mad-sks-rollback-apply-check.js'],
+    ['mad-sks-live-protected-core-smoke.json', './dist/scripts/mad-sks-live-protected-core-smoke.js'],
+    ['mad-sks-executor-proof-graph.json', './dist/scripts/mad-sks-executor-proof-graph-check.js']
+];
+for (const [name, script] of dependencies) {
+    const run = spawnSync(process.execPath, [script], { cwd: root, encoding: 'utf8', env: process.env, maxBuffer: 20 * 1024 * 1024 });
+    const parsed = parseLastJson(run.stdout);
+    if (parsed)
+        fs.writeFileSync(path.join(reportDir, name), `${JSON.stringify(parsed, null, 2)}\n`);
+    if (run.status !== 0)
+        fail(`dependency_failed:${script}`, { stdout_tail: run.stdout.slice(-3000), stderr_tail: run.stderr.slice(-3000) });
+}
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'evidence', 'flagship-proof-graph-validator.js')).href);
+const report = await mod.validateFlagshipProofGraphV4(root);
+fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v4.json'), `${JSON.stringify(report, null, 2)}\n`);
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok)
+    process.exitCode = 1;
+function fail(blocker, extra = {}) {
+    const report = { schema: 'sks.flagship-proof-graph.v4', ok: false, blocker, ...extra };
+    fs.writeFileSync(path.join(reportDir, 'flagship-proof-graph-v4.json'), `${JSON.stringify(report, null, 2)}\n`);
+    console.log(JSON.stringify(report, null, 2));
+    process.exit(1);
+}
+function parseLastJson(text) {
+    const raw = String(text || '').trim();
+    if (!raw)
+        return null;
+    const start = raw.lastIndexOf('\n{');
+    const jsonText = start >= 0 ? raw.slice(start + 1) : raw;
+    try {
+        return JSON.parse(jsonText);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=flagship-proof-graph-v4-check.js.map

package/dist/scripts/gate-pack-fixture-cache-check.js

@@ -0,0 +1,9 @@
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/release/gate-pack-fixture-cache.js');
+const packId = `fixture-check-${process.pid}-${Date.now()}`;
+const first = await mod.prepareGatePackFixture({ root, packId, fixtureVersion: 'sks-4.0.1' });
+const second = await mod.prepareGatePackFixture({ root, packId, fixtureVersion: 'sks-4.0.1' });
+assertGate(first.schema === 'sks.gate-pack-fixture.v1', 'fixture schema mismatch', first);
+assertGate(first.setup_count === 1 && second.reused_base === true, 'fixture base must be created once and reused', { first, second });
+emitGate('gate-pack:fixture-cache', { pack_id: packId, setup_count: first.setup_count, reused_base: second.reused_base });
+//# sourceMappingURL=gate-pack-fixture-cache-check.js.map

package/dist/scripts/gate-pack-manifest-check.js

@@ -0,0 +1,9 @@
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/release/gate-pack-manifest.js');
+const manifest = mod.buildGatePackManifest(root);
+const ids = manifest.packs.map((pack) => pack.id);
+for (const id of mod.REQUIRED_GATE_PACK_IDS)
+    assertGate(ids.includes(id), `gate pack missing: ${id}`, ids);
+emitGate('gate-pack:manifest', { packs: ids });
+//# sourceMappingURL=gate-pack-manifest-check.js.map

package/dist/scripts/gate-pack-runner-blackbox.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { assertGate, emitGate, makeTempRoot } from './sks-3-1-8-check-lib.js';
+import { importDist } from './sks-1-18-gate-lib.js';
+const tmp = await makeTempRoot('sks-gate-pack-');
+await fs.writeFile(path.join(tmp, 'package.json'), JSON.stringify({ version: '4.0.0', scripts: { 'triwiki:proof-card': 'node -e "process.exit(0)"' } }, null, 2));
+await fs.writeFile(path.join(tmp, 'package-lock.json'), JSON.stringify({ lockfileVersion: 3 }));
+await fs.writeFile(path.join(tmp, 'release-gates.v2.json'), JSON.stringify({
+    schema: 'sks.release-gates.v2',
+    gates: [{
+            id: 'triwiki:proof-card',
+            command: 'npm run triwiki:proof-card --silent',
+            deps: [],
+            resource: ['cpu-light'],
+            side_effect: 'hermetic',
+            timeout_ms: 1000,
+            cache: { enabled: true, inputs: ['package.json'] },
+            isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
+            preset: ['release']
+        }]
+}, null, 2));
+const runner = await importDist('core/release/gate-pack-runner.js');
+const report = await runner.executeGatePack({ root: tmp, packId: 'triwiki', mode: 'execute' });
+assertGate(report.ok === true && report.executed === 1 && report.proof_paths.length >= 2, 'gate pack blackbox must execute and write gate plus pack proof', report);
+emitGate('gate-pack:runner-blackbox', { executed: report.executed, proofs: report.proof_paths.length });
+//# sourceMappingURL=gate-pack-runner-blackbox.js.map

package/dist/scripts/gate-pack-runner-check.js

@@ -0,0 +1,6 @@
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/release/gate-pack-runner.js');
+const report = await mod.executeGatePack({ root, packId: 'triwiki', mode: 'plan' });
+assertGate(report.schema === 'sks.gate-pack-runner.v1' && report.mode === 'plan' && report.ok === true, 'gate pack runner plan must pass', report);
+emitGate('gate-pack:runner', { pack: report.pack_id, reused: report.reused, executed: report.executed });
+//# sourceMappingURL=gate-pack-runner-check.js.map

package/dist/scripts/gate-pack-v2-blackbox.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
+import { importDist } from './sks-1-18-gate-lib.js';
+const tmp = await makeTempRoot('sks-gate-pack-v2-');
+await writeText(path.join(tmp, 'package.json'), JSON.stringify({ version: '4.0.2', scripts: { 'triwiki:proof-card': 'node -e "if(!process.env.SKS_GATE_PACK_ARTIFACT) process.exit(2)"' } }, null, 2));
+await writeText(path.join(tmp, 'package-lock.json'), JSON.stringify({ lockfileVersion: 3 }, null, 2));
+await writeText(path.join(tmp, 'release-gates.v2.json'), JSON.stringify({ schema: 'sks.release-gates.v2', gates: [gate('triwiki:proof-card')] }, null, 2));
+await fs.mkdir(path.join(tmp, 'src/core/triwiki'), { recursive: true });
+const runner = await importDist('core/release/gate-pack-runner.js');
+const report = await runner.executeGatePack({ root: tmp, packId: 'triwiki', mode: 'execute' });
+assertGate(report.ok === true && report.executed === 1, 'gate pack v2 must execute through async runner', report);
+assertGate(report.proof_paths.length >= 2, 'gate pack v2 must write gate and pack proofs', report);
+emitGate('gate-pack:v2-blackbox', { executed: report.executed, proofs: report.proof_paths.length });
+function gate(id) {
+    return { id, command: `npm run ${id} --silent`, deps: [], resource: ['cpu-light'], side_effect: 'hermetic', timeout_ms: 5000, cache: { enabled: false, inputs: ['package.json'] }, isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' }, preset: ['release'] };
+}
+//# sourceMappingURL=gate-pack-v2-blackbox.js.map

package/dist/scripts/git-precommit-fixture-check.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import { runProcess } from '../core/fsx.js';
+const bin = path.join(process.cwd(), 'dist', 'bin', 'sks.js');
+const runtimeRoot = await fixtureRoot('runtime');
+await runProcess('git', ['init'], { cwd: runtimeRoot });
+await runSks(runtimeRoot, ['git', 'install', '--json']);
+await fs.mkdir(path.join(runtimeRoot, '.sneakoscope', 'missions'), { recursive: true });
+await fs.writeFile(path.join(runtimeRoot, '.sneakoscope', 'missions', 'runtime.json'), '{}\n');
+await runProcess('git', ['add', '-f', '.sneakoscope/missions/runtime.json'], { cwd: runtimeRoot });
+const blocked = await runProcess(process.execPath, [bin, 'git', 'precommit', '--json'], { cwd: runtimeRoot });
+assert.equal(blocked.code, 1, blocked.stdout || blocked.stderr);
+assert.match(blocked.stdout, /runtime_noise_not_staged/);
+const sharedRoot = await fixtureRoot('shared');
+await runProcess('git', ['init'], { cwd: sharedRoot });
+await runSks(sharedRoot, ['git', 'install', '--json']);
+await fs.mkdir(path.join(sharedRoot, '.sneakoscope', 'wiki', 'records', 'claims'), { recursive: true });
+await fs.writeFile(path.join(sharedRoot, '.sneakoscope', 'wiki', 'records', 'claims', 'ok.json'), JSON.stringify({
+    schema: 'sks.triwiki-claim-record.v1',
+    id: 'ok',
+    status: 'supported',
+    claim: { text: 'Valid shared claim.' }
+}, null, 2));
+await runProcess('git', ['add', '.sneakoscope/wiki/records/claims/ok.json'], { cwd: sharedRoot });
+const allowed = await runProcess(process.execPath, [bin, 'git', 'precommit', '--json'], { cwd: sharedRoot });
+assert.equal(allowed.code, 0, allowed.stdout || allowed.stderr);
+console.log(JSON.stringify({ ok: true, schema: 'sks.git-precommit-fixture.v1' }, null, 2));
+async function fixtureRoot(name) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), `sks-precommit-fixture-${name}-`));
+    await fs.writeFile(path.join(root, 'package.json'), '{"name":"fixture","private":true}\n');
+    return root;
+}
+async function runSks(root, args) {
+    const result = await runProcess(process.execPath, [bin, ...args], { cwd: root, env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' } });
+    assert.equal(result.code, 0, result.stdout || result.stderr);
+    return JSON.parse(result.stdout);
+}
+//# sourceMappingURL=git-precommit-fixture-check.js.map

package/dist/scripts/git-worktree-batch-allocation-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const manager = readText('src/core/git/git-worktree-manager.ts');
+const pool = readText('src/core/git/git-worktree-pool.ts');
+assertGate(manager.includes('allocateWorkerWorktreesBatch') && manager.includes('Promise.all(workers)'), 'batch worktree allocation API/pool missing');
+assertGate(manager.includes('worktree_allocation_started') && manager.includes('worktree_allocation_completed'), 'worktree allocation proof events missing');
+assertGate(pool.includes('allocateWorkerWorktreesBatch'), 'worktree pool must export batch allocation');
+emitGate('git:worktree-batch-allocation');
+//# sourceMappingURL=git-worktree-batch-allocation-check.js.map

package/dist/scripts/git-worktree-cache-performance-check.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const policyMod = await importDist('core/git/git-worktree-cache-policy.js');
+const now = Date.now();
+const entries = Array.from({ length: 1000 }, (_, index) => ({
+    path: `/tmp/wt-${index}`,
+    updated_at_ms: now - index * 60000,
+    bytes: 1024 * (index + 1),
+    dirty: index % 137 === 0
+}));
+const start = Date.now();
+const plan = policyMod.planGitWorktreeCachePolicy({ entries, nowMs: now, maxEntries: 120, maxBytes: 40 * 1024 * 1024, ttlMs: 2 * 60 * 60 * 1000 });
+const elapsed = Date.now() - start;
+assertGate(plan.ok === true, 'cache policy plan must pass', plan);
+assertGate(plan.keep.length <= 120 || plan.dirty_retained.length > 0, 'cache policy must bound retained clean entries', plan);
+assertGate(plan.dirty_retained.length > 0, 'dirty entries must be retained by cache policy', plan);
+assertGate(elapsed < 250, 'cache policy must stay fast on 1000 entries', { elapsed });
+emitGate('git:worktree-cache-performance', {
+    elapsed_ms: elapsed,
+    keep: plan.keep.length,
+    prune: plan.prune.length,
+    dirty_retained: plan.dirty_retained.length
+});
+//# sourceMappingURL=git-worktree-cache-performance-check.js.map

package/dist/scripts/git-worktree-capability-check.js

@@ -0,0 +1,27 @@
+#!/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 } from './sks-1-18-gate-lib.js';
+import { makeGitFixture, makeNonGitFixture } from './lib/git-worktree-fixture.js';
+const capabilityMod = await importDist('core/git/git-worktree-capability.js');
+const nonGit = makeNonGitFixture('worktree-capability-non-git');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-capability-'));
+delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
+const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-non-git' });
+assertGate(nonGitCapability.mode === 'patch-envelope-only', 'non-Git projects must degrade to patch-envelope-only', nonGitCapability);
+assertGate(nonGitCapability.worktree_probe_attempted === false, 'non-Git projects must not probe git worktree', nonGitCapability);
+const repo = makeGitFixture('worktree-capability-git');
+const gitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-git' });
+assertGate(gitCapability.ok === true && gitCapability.mode === 'git-worktree', 'Git fixture must support worktree mode', gitCapability);
+assertGate(gitCapability.root_resolution?.in_repo === false, 'default worktree root must be outside main repo', gitCapability.root_resolution);
+process.env.SKS_WORKTREE_ROOT = path.join(repo, '.sneakoscope', 'worktrees');
+const blocked = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-in-repo' });
+assertGate(blocked.ok === false && blocked.blockers.includes('git_worktree_root_inside_repo_blocked'), 'in-repo worktree root must be blocked by default', blocked);
+emitGate('git:worktree-capability', {
+    non_git_mode: nonGitCapability.mode,
+    git_mode: gitCapability.mode,
+    in_repo_blocked: true
+});
+//# sourceMappingURL=git-worktree-capability-check.js.map

package/dist/scripts/git-worktree-checkpoint-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { checkpointWorkerWorktree } from '../core/git/git-worktree-checkpoint.js';
+import { runGitCommand } from '../core/git/git-worktree-runner.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-checkpoint-'));
+await runGitCommand(root, ['init']);
+await runGitCommand(root, ['config', 'user.email', 'sks@example.test']);
+await runGitCommand(root, ['config', 'user.name', 'SKS Test']);
+fs.writeFileSync(path.join(root, 'a.txt'), 'a\n');
+await runGitCommand(root, ['add', 'a.txt']);
+await runGitCommand(root, ['commit', '-m', 'base']);
+fs.writeFileSync(path.join(root, 'a.txt'), 'a2\n');
+fs.writeFileSync(path.join(root, 'b.txt'), 'b\n');
+const report = await checkpointWorkerWorktree({ worktreePath: root, repoRoot: root, workerId: 'W1', taskId: 'T1', mode: 'auto' });
+assertGate(report.ok && report.mode_applied === 'checkpoint-commit' && Boolean(report.commit_hash), 'Git worktree checkpoint must create checkpoint commits for multi-file changes', report);
+emitGate('git:worktree-checkpoint', report);
+//# sourceMappingURL=git-worktree-checkpoint-check.js.map