sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/hooks-latest-schema-check.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { codexSchemaSnapshotReport } from '../core/codex-compat/codex-schema-snapshot.js';
-const report = await codexSchemaSnapshotReport();
-const ok = report.ok
-    && report.supported_events_count === 10
-    && report.schema_files_count === 20
-    && report.metadata?.tag === 'latest'
-    && report.supported_events.includes('SubagentStart')
-    && report.supported_events.includes('SubagentStop');
-console.log(JSON.stringify({
-    schema: 'sks.hooks-latest-schema-check.v1',
-    ok,
-    supported_events_count: report.supported_events_count,
-    schema_files_count: report.schema_files_count,
-    release_blockers: ok ? [] : report.release_blockers
-}, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-latest-schema-check.js.map

package/dist/scripts/hooks-managed-install-fixture-check.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { installManagedCodexHooks } from '../core/codex-hooks/codex-hook-managed-install.js';
-import { readCodexHookActualState } from '../core/codex-hooks/codex-hook-actual-discovery.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-hooks-managed-install-'));
-const install = await installManagedCodexHooks(root);
-const actual = await readCodexHookActualState(root);
-const requirements = fs.readFileSync(path.join(root, '.codex', 'requirements.toml'), 'utf8');
-const ok = install.ok
-    && requirements.includes('allow_managed_hooks_only = true')
-    && requirements.includes('[hooks]')
-    && actual.entries.filter((entry) => entry.trust_status === 'Managed').length >= 10
-    && actual.unsupported_handlers.length === 0
-    && actual.dual_representation.length === 0;
-console.log(JSON.stringify({ schema: 'sks.hooks-managed-install-fixture-check.v1', ok, install, actual_summary: { entries: actual.entries.length, unsupported_handlers: actual.unsupported_handlers.length, dual_representation: actual.dual_representation.length } }, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-managed-install-fixture-check.js.map

package/dist/scripts/hooks-official-hash-oracle-check.js

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { installManagedCodexHooks } from '../core/codex-hooks/codex-hook-managed-install.js';
-import { codexHookOfficialParityReport } from '../core/codex-hooks/codex-hook-official-parity.js';
-import { resolveCodexHookHashOracle } from '../core/codex-hooks/codex-hook-official-hash-oracle.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-hooks-oracle-'));
-await installManagedCodexHooks(root);
-const oracle = await resolveCodexHookHashOracle(root, {
-    event: 'PreToolUse',
-    matcher: 'Read',
-    command: 'sks hook pre-tool',
-    timeout: 600,
-    async: false
-});
-const parity = await codexHookOfficialParityReport(root);
-const ok = parity.ok
-    && parity.schema === 'sks.codex-hook-official-parity.v2'
-    && parity.policy.sks_trusted_hash_fallback_allowed === false
-    && (oracle.schema === 'sks.codex-hook-hash-oracle.v1');
-const result = {
-    schema: 'sks.hooks-official-hash-oracle-check.v1',
-    ok,
-    oracle,
-    parity_status: parity.status,
-    official_hash_available: parity.official_hash_available,
-    unmanaged_trusted_hash_writer_enabled: parity.unmanaged_trusted_hash_writer_enabled,
-    managed_policy_used: parity.managed_policy_used
-};
-console.log(JSON.stringify(result, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-official-hash-oracle-check.js.map

package/dist/scripts/hooks-official-hash-parity-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { installManagedCodexHooks } from '../core/codex-hooks/codex-hook-managed-install.js';
-import { codexHookOfficialParityReport } from '../core/codex-hooks/codex-hook-official-parity.js';
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-hooks-official-hash-'));
-await installManagedCodexHooks(root);
-const report = await codexHookOfficialParityReport(root);
-const ok = report.ok
-    && report.fixture_parity.ok === true
-    && report.policy.sks_trusted_hash_fallback_allowed === false;
-console.log(JSON.stringify({ schema: 'sks.hooks-official-hash-parity-check.v1', ok, status: report.status, fixture_parity: report.fixture_parity, policy: report.policy }, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-official-hash-parity-check.js.map

package/dist/scripts/hooks-subagent-events-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { CODEX_HOOK_EVENTS } from '../core/codex-compat/codex-schema-snapshot.js';
-import { validateCodexFixtureOutputs } from '../core/codex-compat/codex-hook-schema.js';
-const fixtures = await validateCodexFixtureOutputs(process.cwd());
-const subagentEvents = ['SubagentStart', 'SubagentStop'];
-const ok = subagentEvents.every((event) => CODEX_HOOK_EVENTS.includes(event))
-    && subagentEvents.every((event) => fixtures.outputs.some((row) => row.event === event && row.ok));
-console.log(JSON.stringify({
-    schema: 'sks.hooks-subagent-events-check.v1',
-    ok,
-    subagent_events: subagentEvents,
-    fixture_counts: Object.fromEntries(subagentEvents.map((event) => [event, fixtures.outputs.filter((row) => row.event === event).length]))
-}, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-subagent-events-check.js.map

package/dist/scripts/hooks-trust-state-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { codexHookTrustDoctor } from '../core/codex-hooks/codex-hook-trust-doctor.js';
-const report = await codexHookTrustDoctor(process.cwd(), { managed: true });
-console.log(JSON.stringify({
-    schema: 'sks.hooks-trust-state-check.v1',
-    ok: report.ok,
-    current_hash_count: report.current_hash_count,
-    trust: report.trust,
-    warnings: report.warnings
-}, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-//# sourceMappingURL=hooks-trust-state-check.js.map

package/dist/scripts/image-fidelity-fixture-check.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-const root = process.cwd();
-const mod = await import(pathToFileURL(path.join(root, 'dist/core/image-ux-review.js')));
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-image-fidelity-'));
-const pngPath = path.join(tmp, 'one-by-one.png');
-await fs.writeFile(pngPath, Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/axX7V8AAAAASUVORK5CYII=', 'base64'));
-const contract = {
-    prompt: 'image fidelity fixture',
-    answers: { IMAGE_UX_REVIEW_SOURCE_IMAGES: [pngPath] }
-};
-const inventory = await mod.hydrateImageUxScreenInventory(root, mod.buildImageUxScreenInventory(contract));
-const screen = inventory.source_screens[0];
-assert.equal(screen.width, 1);
-assert.equal(screen.height, 1);
-assert.match(screen.sha256, /^[a-f0-9]{64}$/);
-assert.equal(screen.original_resolution.preserved, true);
-console.log(JSON.stringify({ schema: 'sks.image-fidelity-fixture.v1', ok: true, screen }, null, 2));
-//# sourceMappingURL=image-fidelity-fixture-check.js.map

package/dist/scripts/imagegen-capability-check.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { detectImagegenCapability } from '../core/imagegen/imagegen-capability.js';
-const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
-const report = await detectImagegenCapability();
-const out = path.join(process.cwd(), '.sneakoscope', 'reports', `imagegen-capability-${pkg.version}.json`);
-const stableOut = path.join(process.cwd(), '.sneakoscope', 'reports', 'imagegen-capability.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-fs.writeFileSync(stableOut, `${JSON.stringify(report, null, 2)}\n`);
-const ok = report.ok
-    && report.core_feature === true
-    && report.core_ready === true
-    && report.codex_app?.available === true
-    && report.codex_app_builtin_output_required === true
-    && report.capability_detection_is_not_output_proof === true
-    && report.real_generation_available === true
-    && report.model === 'gpt-image-2'
-    && report.openai_images_api?.official_codex_app_substitute === false
-    && report.api_fallback_satisfies_codex_app_evidence === false
-    && report.input_fidelity_must_be_omitted === true
-    && report.gpt_image_2_input_fidelity_automatic === true
-    && Array.isArray(report.core_blockers)
-    && report.core_blockers.length === 0;
-console.log(JSON.stringify({ ...report, ok, path: out, stable_path: stableOut }, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=imagegen-capability-check.js.map

package/dist/scripts/imagegen-real-smoke-check.js

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { osTempPngFixtureArg } from './lib/valid-png-fixture.js';
-const enabled = process.env.SKS_TEST_REAL_IMAGEGEN === '1' || process.env.SKS_REAL_IMAGEGEN === '1';
-const reportDir = path.join(process.cwd(), '.sneakoscope', 'reports');
-const out = path.join(reportDir, 'real-imagegen-smoke-1.14.1.json');
-const stableOut = path.join(reportDir, 'real-imagegen-smoke.json');
-fs.mkdirSync(reportDir, { recursive: true });
-function writeReport(report) {
-    const text = `${JSON.stringify(report, null, 2)}\n`;
-    fs.writeFileSync(out, text);
-    fs.writeFileSync(stableOut, text);
-}
-function parseUxReviewJson(stdout) {
-    const text = String(stdout || '').trim();
-    if (!text)
-        return null;
-    try {
-        return JSON.parse(text);
-    }
-    catch { }
-    const first = text.indexOf('{');
-    const last = text.lastIndexOf('}');
-    if (first >= 0 && last > first) {
-        try {
-            return JSON.parse(text.slice(first, last + 1));
-        }
-        catch { }
-    }
-    return null;
-}
-function missionIdFromRun(stdout, parsed) {
-    const direct = parsed?.mission_id || parsed?.mission?.mission_id || parsed?.mission?.id || parsed?.contract?.mission_id || null;
-    if (direct)
-        return String(direct);
-    const matches = String(stdout || '').match(/M-\d{8}-\d{6}-[a-f0-9]+/g);
-    return matches?.length ? matches[matches.length - 1] : null;
-}
-function readJsonIfExists(file) {
-    try {
-        if (!file || !fs.existsSync(file))
-            return null;
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function imagegenRequestEvidence(missionId) {
-    if (!missionId)
-        return { request_artifact: null, response_artifact: null, request: null, response: null };
-    const missionRoot = path.join(process.cwd(), '.sneakoscope', 'missions', missionId);
-    const requestCandidates = [
-        path.join(missionRoot, 'generated-callouts', 'image-ux-gpt-image-2-request.json'),
-        path.join(missionRoot, 'image-ux-gpt-image-2-request.json')
-    ];
-    const requestArtifact = requestCandidates.find((candidate) => fs.existsSync(candidate)) || null;
-    const responseArtifact = requestArtifact
-        ? requestArtifact.replace(/request\.json$/, 'response.json')
-        : null;
-    return {
-        request_artifact: requestArtifact,
-        response_artifact: responseArtifact && fs.existsSync(responseArtifact) ? responseArtifact : null,
-        request: readJsonIfExists(requestArtifact),
-        response: readJsonIfExists(responseArtifact)
-    };
-}
-function verifiedGeneratedOutput(response) {
-    const outputPath = response?.output_image_path ? path.resolve(String(response.output_image_path)) : null;
-    const exists = Boolean(outputPath && fs.existsSync(outputPath));
-    const fake = response?.fake_adapter === true || response?.mock === true || response?.provider === 'fake_imagegen_adapter';
-    return {
-        output_image_path: outputPath,
-        output_image_exists: exists,
-        output_image_sha256: response?.output_image_sha256 || null,
-        output_dimensions: response?.dimensions || null,
-        provider: response?.provider || null,
-        response_ok: response?.ok === true,
-        response_status: response?.status || null,
-        fake_adapter: fake,
-        real_generated_output_verified: response?.ok === true && response?.status === 'generated' && exists && !fake
-    };
-}
-if (!enabled) {
-    const skipped = {
-        schema: 'sks.imagegen-real-smoke.v1',
-        ok: true,
-        status: 'skipped',
-        reason: 'Set SKS_TEST_REAL_IMAGEGEN=1 with OPENAI_API_KEY or Codex App imagegen output to run live smoke.',
-        compatibility_env_alias: 'SKS_REAL_IMAGEGEN=1',
-        release_gate: 'release:real-check_only',
-        request_validator_checked: false,
-        input_fidelity_present: false,
-        local_only_artifact_policy: true
-    };
-    writeReport(skipped);
-    console.log(JSON.stringify(skipped, null, 2));
-    process.exit(0);
-}
-const started = Date.now();
-const sourceImage = osTempPngFixtureArg('imagegen-real-smoke-source.png');
-const run = spawnSync(process.execPath, ['./dist/bin/sks.js', 'ux-review', 'run', '--image', sourceImage, '--generate-callouts', '--fix', '--json'], {
-    cwd: process.cwd(),
-    env: process.env,
-    encoding: 'utf8',
-    timeout: Number(process.env.SKS_IMAGEGEN_SMOKE_TIMEOUT_MS || 180000),
-    maxBuffer: 8 * 1024 * 1024
-});
-const parsed = parseUxReviewJson(run.stdout);
-const missionId = missionIdFromRun(run.stdout, parsed);
-const evidence = imagegenRequestEvidence(missionId);
-const inputFidelityPresent = evidence.request?.validation?.params_checked?.input_fidelity_present === true;
-const generatedOutput = verifiedGeneratedOutput(evidence.response);
-const report = {
-    schema: 'sks.imagegen-real-smoke.v1',
-    ok: run.status === 0 && generatedOutput.real_generated_output_verified === true,
-    status: run.status === 0 && generatedOutput.real_generated_output_verified === true ? 'passed' : 'blocked',
-    env_flag: 'SKS_TEST_REAL_IMAGEGEN',
-    mission_id: missionId,
-    latency_ms: Date.now() - started,
-    cost: 'not_reported_by_adapter',
-    source_image: sourceImage,
-    request_validator_checked: Boolean(evidence.request?.validation),
-    request_artifact: evidence.request_artifact,
-    response_artifact: evidence.response_artifact,
-    imagegen_provider: evidence.request?.provider || evidence.response?.provider || null,
-    imagegen_blocker: evidence.response?.blocker || null,
-    generated_output: generatedOutput,
-    process_error: run.error?.message || null,
-    process_signal: run.signal || null,
-    input_fidelity_present: inputFidelityPresent,
-    local_only_artifact_policy: true,
-    stdout_tail: run.stdout.slice(-4000),
-    stderr_tail: run.stderr.slice(-4000)
-};
-if (run.status === 0 && !generatedOutput.real_generated_output_verified) {
-    report.blocker = generatedOutput.fake_adapter
-        ? 'fake_imagegen_output_not_real_smoke'
-        : generatedOutput.output_image_exists
-            ? 'generated_output_not_marked_real'
-            : 'generated_output_file_missing';
-}
-if (report.input_fidelity_present) {
-    report.ok = false;
-    report.status = 'blocked';
-    report.blocker = 'input_fidelity_must_not_be_sent_for_gpt_image_2';
-}
-writeReport(report);
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-//# sourceMappingURL=imagegen-real-smoke-check.js.map

package/dist/scripts/install-update-preserves-config-check.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Production regression for the chronic "npm i -g wipes ~/.codex/config.toml" bug.
-// Proves ensureGlobalCodexFastModeDuringInstall:
-//   1. PRESERVES user-set top-level model/service_tier/model_reasoning_effort on update,
-//   2. backs up the prior config before mutating,
-//   3. still seeds SKS defaults for a fresh (empty) config,
-//   4. NEVER blind-overwrites an unparseable config (backs up + preserves),
-//   5. is idempotent (second run is a no-op 'present').
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const helpers = await importDist('cli/install-helpers.js');
-const results = [];
-// --- Case 1: customized config preserved + backed up on update ---
-{
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cfg-preserve-'));
-    const codexDir = path.join(dir, '.codex');
-    await fs.mkdir(codexDir, { recursive: true });
-    const cfg = path.join(codexDir, 'config.toml');
-    const userConfig = [
-        '# my hand-tuned Codex config',
-        'model = "gpt-5.1-codex"',
-        'service_tier = "standard"',
-        'model_reasoning_effort = "high"',
-        '',
-        '[mcp_servers.custom]',
-        'command = "npx"',
-        ''
-    ].join('\n');
-    await fs.writeFile(cfg, userConfig);
-    const res = await helpers.ensureGlobalCodexFastModeDuringInstall({ home: dir, configPath: cfg });
-    const after = await fs.readFile(cfg, 'utf8');
-    const backups = (await fs.readdir(codexDir)).filter((f) => f.startsWith('config.toml.sks-'));
-    const ok = res.status === 'updated' &&
-        /^model = "gpt-5\.1-codex"/m.test(after) && // user model preserved
-        /^service_tier = "standard"/m.test(after) && // user tier preserved
-        /^model_reasoning_effort = "high"/m.test(after) && // user effort NOT stripped
-        /# my hand-tuned Codex config/.test(after) && // user comment preserved
-        /\[mcp_servers\.custom\]/.test(after) && // user table preserved
-        /\[profiles\.sks-fast-high\]/.test(after) && // SKS-managed table added
-        backups.length >= 1 && // backup created
-        Boolean(res.backup_path);
-    results.push({ case: 'preserves_user_config', ok, status: res.status, backups, model_preserved: /gpt-5\.1-codex/.test(after) });
-}
-// --- Case 2: fresh/empty config gets SKS defaults ---
-{
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cfg-fresh-'));
-    const cfg = path.join(dir, '.codex', 'config.toml');
-    await fs.mkdir(path.dirname(cfg), { recursive: true });
-    const res = await helpers.ensureGlobalCodexFastModeDuringInstall({ home: dir, configPath: cfg });
-    const after = await fs.readFile(cfg, 'utf8');
-    const ok = res.status === 'updated' && /^model = "gpt-5\.5"/m.test(after) && /^service_tier = "fast"/m.test(after) && /\[features\]/.test(after);
-    results.push({ case: 'fresh_config_seeds_defaults', ok, status: res.status });
-}
-// --- Case 3: unparseable config is preserved + backed up, NOT overwritten ---
-{
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cfg-broken-'));
-    const codexDir = path.join(dir, '.codex');
-    await fs.mkdir(codexDir, { recursive: true });
-    const cfg = path.join(codexDir, 'config.toml');
-    const broken = 'model = "gpt-5.5"\n[features\nhooks = true\n'; // malformed table header
-    await fs.writeFile(cfg, broken);
-    const res = await helpers.ensureGlobalCodexFastModeDuringInstall({ home: dir, configPath: cfg });
-    const after = await fs.readFile(cfg, 'utf8');
-    const backups = (await fs.readdir(codexDir)).filter((f) => f.includes('.sks-unparseable-'));
-    const ok = res.status === 'unparseable_config_preserved' && after === broken && backups.length >= 1 && Boolean(res.backup_path);
-    results.push({ case: 'unparseable_preserved_not_clobbered', ok, status: res.status, untouched: after === broken });
-}
-// --- Case 4: idempotent — second run on a healthy config is a no-op ---
-{
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-cfg-idem-'));
-    const cfg = path.join(dir, '.codex', 'config.toml');
-    await fs.mkdir(path.dirname(cfg), { recursive: true });
-    await helpers.ensureGlobalCodexFastModeDuringInstall({ home: dir, configPath: cfg });
-    const second = await helpers.ensureGlobalCodexFastModeDuringInstall({ home: dir, configPath: cfg });
-    const ok = second.status === 'present';
-    results.push({ case: 'idempotent_second_run_noop', ok, status: second.status });
-}
-const ok = results.every((r) => r.ok);
-if (!ok) {
-    console.error(JSON.stringify({ ok: false, message: 'install config-preservation regression failed', results }, null, 2));
-    process.exit(1);
-}
-emitGate('install:update-preserves-config', { cases: results.map((r) => r.case) });
-//# sourceMappingURL=install-update-preserves-config-check.js.map

package/dist/scripts/json-schema-recursive-check.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { validateJsonSchema, validateJsonSchemaRecursive } from '../core/json-schema-validator.js';
-import { assertGate, emitGate } from './sks-1-11-gate-lib.js';
-const schema = {
-    type: 'object',
-    required: ['name', 'items'],
-    additionalProperties: false,
-    properties: {
-        name: { type: 'string', minLength: 2 },
-        items: {
-            type: 'array',
-            minItems: 1,
-            items: {
-                type: 'object',
-                required: ['kind', 'score'],
-                additionalProperties: false,
-                properties: {
-                    kind: { enum: ['alpha', 'beta'] },
-                    score: { type: 'integer', minimum: 1 }
-                }
-            }
-        }
-    }
-};
-const pass = validateJsonSchema({ name: 'ok', items: [{ kind: 'alpha', score: 2 }] }, schema);
-const fail = validateJsonSchema({ name: 'x', items: [{ kind: 'omega', score: 0, extra: true }] }, schema);
-assertGate(pass.ok === true, 'recursive JSON schema validator rejected a valid nested object', pass);
-assertGate(fail.ok === false && fail.issues.length >= 3, 'recursive JSON schema validator failed to detect nested issues', fail);
-const oneOfPass = validateJsonSchema('a', { oneOf: [{ const: 'a' }, { const: 'b' }] });
-const oneOfFail = validateJsonSchema('a', { oneOf: [{ type: 'string' }, { const: 'a' }] });
-const anyOfPass = validateJsonSchema(3, { anyOf: [{ type: 'string' }, { type: 'integer' }] });
-assertGate(oneOfPass.ok === true && oneOfFail.ok === false && anyOfPass.ok === true, 'oneOf/anyOf behavior regression', { oneOfPass, oneOfFail, anyOfPass });
-const localRefSchema = {
-    type: 'object',
-    required: ['box'],
-    properties: {
-        box: { '$ref': '#/$defs/box' }
-    },
-    '$defs': {
-        box: {
-            type: 'array',
-            minItems: 4,
-            maxItems: 4,
-            items: { type: 'number' }
-        }
-    }
-};
-const localRef = validateJsonSchemaRecursive({ box: [0, 0, 1, 1] }, localRefSchema);
-assertGate(localRef.ok === true, '$ref local resolution regression', localRef);
-const externalRef = validateJsonSchema({ box: [0, 0, 1, 1] }, { '$ref': 'https://example.invalid/schema.json' });
-assertGate(externalRef.ok === false && externalRef.unsupported.some((issue) => issue.code === 'ref_unsupported'), 'external $ref unsupported blocker missing', externalRef);
-const targetSchemas = [
-    'schemas/codex/image-ux-issue-ledger.schema.json',
-    'schemas/codex/image-ux-callout-extraction-report.schema.json',
-    'schemas/codex/ppt-slide-issue-ledger.schema.json',
-    'schemas/codex/ppt-slide-extraction-report.schema.json',
-    'schemas/codex/dfix-diagnosis.schema.json',
-    'schemas/codex/dfix-patch-plan.schema.json',
-    'schemas/codex/dfix-patch-result.schema.json',
-    'schemas/codex/dfix-verification-suggestion.schema.json',
-    'schemas/codex/dfix-verification.schema.json',
-    'schemas/codex/completion-proof.schema.json',
-    'schemas/codex/wrongness-record.schema.json',
-    'schemas/codex/agent-result.schema.json',
-    'schemas/codex/all-feature-completion.schema.json'
-];
-const missing = targetSchemas.filter((rel) => !fs.existsSync(path.join(process.cwd(), rel)));
-assertGate(missing.length === 0, 'recursive schema target missing', { missing });
-emitGate('json-schema:recursive-check', {
-    valid_issues: pass.issues.length,
-    invalid_issues: fail.issues.length,
-    checked_schemas: targetSchemas.length,
-    local_ref: localRef.ok
-});
-//# sourceMappingURL=json-schema-recursive-check.js.map

package/dist/scripts/legacy-multiagent-removal-check.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const pkg = readJson('package.json');
-const removedPaths = [
-    'archive/legacy/legacy-main.0.9.13.mjs',
-    'archive/legacy/maintenance-commands.0.9.13.mjs',
-    'docs/goals/sks-1.14.1-scout-multisession-official-syntax-addendum.md',
-    'src/core/scouts',
-    'src/core/commands/scouts-command.ts',
-    'src/core/commands/scouts-command.mjs',
-    'src/commands/scouts.ts',
-    'src/commands/scouts.mjs',
-    'schemas/codex/scout-result.schema.json',
-    'schemas/codex/no-scout-policy-report.schema.json',
-    'src/core/agents/no-scout-policy.ts',
-    'src/core/agents/no-scout-policy.mjs',
-    'dist/scripts/no-scout-policy-check.js'
-];
-const sourceFiles = [
-    'src/cli/command-registry.ts',
-    'src/cli/command-registry.mjs',
-    'src/core/routes.ts',
-    'src/core/routes.mjs',
-    'src/core/proof/route-finalizer.ts',
-    'src/core/proof/route-finalizer.mjs',
-    'src/core/trust-kernel/route-contract.ts',
-    'src/core/trust-kernel/route-contract.mjs',
-    'src/core/trust-kernel/completion-contract.ts',
-    'src/core/trust-kernel/completion-contract.mjs',
-    'src/core/commands/status-command.ts',
-    'src/core/commands/status-command.mjs',
-    'README.md',
-    'docs/native-agent-kernel.md',
-    'docs/team-mode.md',
-    'docs/research-mode.md',
-    'docs/legacy-free-architecture.md',
-    'docs/feature-fixtures.md',
-    'docs/feature-inventory.md',
-    'docs/completion-proof.md'
-];
-const forbidden = [
-    { id: 'scouts_cli_command', re: /\bscouts?\s*:\s*entry\b|\bsks\s+scouts?\b|['"]--force-scouts['"]|['"]--legacy-scout['"]/i },
-    { id: 'scout_runtime_import', re: /\brunFiveScoutIntake\b|\.\.\/scouts\/|\.\.\/core\/scouts\/|\bscout-proof-evidence\b|\bscout-gate\b/i },
-    { id: 'scout_evidence_contract', re: /\bevidence\.scouts\b|\brequired\.scouts\b|\bscout_status\b|\bscouts_required\b/i },
-    { id: 'manual_diagnostics_fallback', re: /manual (?:diagnostics|forensics)|legacy artifact comparison|legacy Scout/i }
-];
-const issues = [];
-for (const rel of removedPaths) {
-    if (fs.existsSync(path.join(root, rel)))
-        issues.push({ type: 'path_present', path: rel });
-}
-for (const key of Object.keys(pkg.scripts || {})) {
-    const value = String(pkg.scripts[key] || '');
-    if (/^scouts?:|scouts?:/.test(key) || /\bsks(?:\.js)?\s+scouts?\b|\bnpm run scouts?:/.test(value)) {
-        issues.push({ type: 'package_script_legacy_surface', script: key, value });
-    }
-}
-for (const rel of sourceFiles) {
-    const full = path.join(root, rel);
-    if (!fs.existsSync(full))
-        continue;
-    const text = fs.readFileSync(full, 'utf8');
-    for (const rule of forbidden) {
-        if (rule.re.test(text))
-            issues.push({ type: 'forbidden_reference', rule: rule.id, path: rel });
-    }
-}
-const result = {
-    schema: 'sks.legacy-multiagent-removal.v1',
-    ok: issues.length === 0,
-    removed_paths_checked: removedPaths.length,
-    source_files_checked: sourceFiles.filter((rel) => fs.existsSync(path.join(root, rel))).length,
-    issues
-};
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function readJson(rel) {
-    return JSON.parse(fs.readFileSync(path.join(root, rel), 'utf8'));
-}
-//# sourceMappingURL=legacy-multiagent-removal-check.js.map