sneakoscope 6.2.0 → 6.5.1

package/dist/scripts/check-architecture.js

@@ -2,67 +2,233 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+const CURRENT_ROUTE_DOMAIN_IMPORT_SEGMENTS = Object.freeze([
+    'naruto',
+    'qa-loop',
+    'research',
+    'ppt',
+    'image-ux-review',
+    'db',
+    'gx',
+    'wiki'
+]);
 const root = process.cwd();
 const failures = [];
+const args = process.argv.slice(2);
+const strictAll = args.includes('--strict-all');
+const budgets = loadBudgetConfig();
 const waivers = loadWaivers();
-const changedFiles = changedFileSet();
+const baseRef = optionValue('--base-ref') || process.env.SKS_ARCH_BASE_REF || defaultBaseRef();
+const baseSha = mergeBaseSha(baseRef);
+const baseFiles = trackedFileSet(baseSha);
+const renamedPredecessors = renamedPredecessorMap(baseSha);
+const changedFiles = changedFileSet(baseSha);
+let scannedFiles = 0;
 runGate('pipeline-budget:check');
 runGate('pipeline-runtime:check');
 checkLargeFiles();
 checkTsImports();
 checkDistRuntime();
+const report = {
+    schema: 'sks.architecture-check.v2',
+    ok: failures.length === 0,
+    mode: strictAll ? 'strict-all' : 'merge-base-changed',
+    budget_config: 'config/architecture-budgets.v1.json',
+    base_ref: baseRef,
+    merge_base: baseSha,
+    changed_files: [...changedFiles].sort(),
+    scanned_files: scannedFiles,
+    waiver_policy: budgets.waiver_policy.mode,
+    failures
+};
+writeReport(report);
 if (failures.length) {
     console.error('Architecture check failed:');
     for (const failure of failures)
         console.error(`- ${failure}`);
     process.exit(1);
 }
-console.log('Architecture check passed');
+console.log(`Architecture check passed (${report.mode}, base ${baseSha || 'unavailable'})`);
 function runGate(script) {
+    const pkg = readJson(path.join(root, 'package.json'));
+    if (!pkg?.scripts?.[script]) {
+        failures.push(`${script}: package script missing`);
+        return;
+    }
     const result = spawnSync('npm', ['run', script], { cwd: root, encoding: 'utf8', stdio: 'pipe' });
     if (result.status !== 0)
         failures.push(`${script}: ${result.stderr || result.stdout}`.trim());
 }
-function checkFacade(relPath, maxLines) {
-    const file = path.join(root, relPath);
-    if (!fs.existsSync(file))
-        return failures.push(`${relPath}: missing`);
-    const text = fs.readFileSync(file, 'utf8');
-    const lines = text.split(/\r?\n/).length;
-    if (lines > maxLines)
-        failures.push(`${relPath}: line count ${lines} > ${maxLines}`);
-    if (/from ['"].*\b(team|qa|research|ppt|image-ux-review|db|gx)\b/i.test(text))
-        failures.push(`${relPath}: imports route implementation domains directly`);
-}
 function checkLargeFiles() {
     const files = [];
-    walk(path.join(root, 'src'), files);
+    for (const scanRoot of budgets.scan_roots) {
+        const absolute = path.join(root, scanRoot);
+        if (fs.existsSync(absolute))
+            walk(absolute, files);
+    }
     for (const file of files) {
-        const relPath = path.relative(root, file).split(path.sep).join('/');
-        const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/).length;
-        if (isWaivedGenerated(relPath))
+        const relPath = normalize(path.relative(root, file));
+        if (!budgets.source_extensions.includes(path.extname(file)))
+            continue;
+        if (isGeneratedPath(relPath))
+            continue;
+        scannedFiles += 1;
+        const lines = lineCount(fs.readFileSync(file, 'utf8'));
+        const rule = budgetRule(relPath);
+        const basePath = basePathFor(relPath);
+        const existedAtBase = basePath !== null;
+        const changed = changedFiles.has(relPath);
+        if (!strictAll && !changed)
             continue;
-        const max = architectureLineLimit(relPath);
-        const baselineLines = changedFiles.has(relPath) ? baseLineCount(relPath) : lines;
-        if (lines >= 3000)
-            failures.push(`${relPath}: handwritten file ${lines} lines >= 3000 split-review risk`);
-        if (baselineLines === null && lines > 400)
-            failures.push(`${relPath}: new source file ${lines} lines > 400`);
-        if (changedFiles.has(relPath) && lines > max && (baselineLines === null || lines - baselineLines > 80)) {
-            failures.push(`${relPath}: changed file grew to ${lines} lines > ${max} architecture gate`);
+        if (lines >= budgets.split_review_lines) {
+            const baseLines = basePath ? baseLineCount(basePath, baseSha) : null;
+            const waiverFailure = waiverFailureFor(relPath, lines, baseLines);
+            if (waiverFailure)
+                failures.push(`${relPath}: handwritten file ${lines} lines >= ${budgets.split_review_lines} split-review gate (${waiverFailure})`);
+            continue;
+        }
+        const maxLines = existedAtBase
+            ? rule.max_lines
+            : Math.min(rule.max_lines, rule.new_file_max_lines ?? budgets.default_new_file_max_lines);
+        if (lines > maxLines) {
+            const baseLines = basePath ? baseLineCount(basePath, baseSha) : null;
+            const waiverFailure = waiverFailureFor(relPath, lines, baseLines);
+            if (waiverFailure)
+                failures.push(`${relPath}: ${lines} lines > ${maxLines} ${rule.id} budget (${waiverFailure})`);
+        }
+        if ((strictAll || changed) && !isRouteDomainAggregator(relPath) && importsUnrelatedRouteDomains(file)) {
+            failures.push(`${relPath}: imports 5+ unrelated route domains`);
         }
-        if (changedFiles.has(relPath) && !isRouteDomainAggregator(relPath) && importsUnrelatedRouteDomains(file))
-            failures.push(`${relPath}: changed file imports 5+ unrelated route domains`);
     }
 }
-function architectureLineLimit(relPath) {
-    if (/^src\/core\/(?:pipeline|trust-kernel|evidence|proof)\//.test(relPath))
-        return 1200;
-    if (/^src\/core\/(?:pipeline|trust-kernel|evidence|proof)/.test(relPath))
-        return 1200;
-    if (/^src\/commands\//.test(relPath) || /^src\/core\/commands\//.test(relPath))
-        return 900;
-    return 1800;
+function budgetRule(relPath) {
+    for (const rule of budgets.budgets) {
+        if (new RegExp(rule.match).test(relPath))
+            return rule;
+    }
+    throw new Error(`architecture budget missing for ${relPath}`);
+}
+function waiverFailureFor(relPath, lines, baseLines) {
+    const waiver = waivers.find((candidate) => candidate.file === relPath);
+    if (!waiver)
+        return 'no shrink-only waiver';
+    if (waiver.policy !== budgets.waiver_policy.mode)
+        return `waiver policy ${String(waiver.policy || 'missing')} is not shrink-only`;
+    if (!Number.isInteger(waiver.baseline_lines) || waiver.baseline_lines < 1)
+        return 'waiver baseline_lines missing';
+    if (!waiver.reason || !waiver.expires_version)
+        return 'waiver reason/expiry missing';
+    if (baseLines === null)
+        return 'new files cannot use architecture waivers';
+    const ceiling = Math.min(baseLines, waiver.baseline_lines);
+    return lines <= ceiling ? null : `shrink-only ceiling ${ceiling} exceeded`;
+}
+function checkTsImports() {
+    const files = [];
+    const src = path.join(root, 'src');
+    if (!fs.existsSync(src))
+        return;
+    walk(src, files);
+    for (const file of files.filter((item) => item.endsWith('.ts'))) {
+        const relPath = normalize(path.relative(root, file));
+        const text = fs.readFileSync(file, 'utf8');
+        if (/from\s+['"][^'"]+\.mjs['"]|import\(\s*['"][^'"]+\.mjs['"]\s*\)/.test(text)) {
+            failures.push(`${relPath}: TypeScript imports .mjs runtime`);
+        }
+    }
+}
+function checkDistRuntime() {
+    const dist = path.join(root, 'dist');
+    if (!fs.existsSync(dist))
+        return;
+    const files = [];
+    walk(dist, files);
+    for (const file of files) {
+        const relPath = normalize(path.relative(root, file));
+        if (relPath.endsWith('.mjs'))
+            failures.push(`${relPath}: dist .mjs runtime forbidden`);
+    }
+}
+function loadBudgetConfig() {
+    const file = path.join(root, 'config', 'architecture-budgets.v1.json');
+    const parsed = readJson(file);
+    if (parsed?.schema !== 'sks.architecture-budgets.v1' || !Array.isArray(parsed?.budgets)) {
+        throw new Error('config/architecture-budgets.v1.json is missing or invalid');
+    }
+    if (parsed?.waiver_policy?.mode !== 'shrink-only')
+        throw new Error('architecture waiver policy must be shrink-only');
+    return parsed;
+}
+function loadWaivers() {
+    const file = path.join(root, 'src', 'generated', 'architecture-waivers.json');
+    const parsed = readJson(file);
+    return Array.isArray(parsed?.waivers) ? parsed.waivers : [];
+}
+function changedFileSet(base) {
+    const out = new Set();
+    if (base) {
+        for (const line of gitLines(['diff', '--name-only', '--diff-filter=ACMR', `${base}...HEAD`, '--']))
+            out.add(normalize(line));
+    }
+    for (const line of gitLines(['diff', '--name-only', '--diff-filter=ACMR', '--']))
+        out.add(normalize(line));
+    for (const line of gitLines(['diff', '--cached', '--name-only', '--diff-filter=ACMR', '--']))
+        out.add(normalize(line));
+    for (const line of gitLines(['ls-files', '--others', '--exclude-standard']))
+        out.add(normalize(line));
+    return out;
+}
+function trackedFileSet(base) {
+    if (!base)
+        return new Set();
+    return new Set(gitLines(['ls-tree', '-r', '--name-only', base]));
+}
+function renamedPredecessorMap(base) {
+    const predecessors = new Map();
+    if (!base)
+        return predecessors;
+    for (const line of gitLines(['diff', '--name-status', '--find-renames', base, '--'])) {
+        const [status, predecessor, current] = line.split('\t');
+        if (!/^R\d*$/.test(status || '') || !predecessor || !current)
+            continue;
+        predecessors.set(normalize(current), normalize(predecessor));
+    }
+    return predecessors;
+}
+function basePathFor(relPath) {
+    if (baseFiles.has(relPath))
+        return relPath;
+    const predecessor = renamedPredecessors.get(relPath);
+    return predecessor && baseFiles.has(predecessor) ? predecessor : null;
+}
+function baseLineCount(relPath, base) {
+    if (!base)
+        return null;
+    const result = spawnSync('git', ['show', `${base}:${relPath}`], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (result.status !== 0)
+        return null;
+    return lineCount(String(result.stdout || ''));
+}
+function defaultBaseRef() {
+    for (const candidate of ['origin/main', 'main']) {
+        if (gitOk(['rev-parse', '--verify', candidate]))
+            return candidate;
+    }
+    return 'HEAD';
+}
+function mergeBaseSha(ref) {
+    const result = spawnSync('git', ['merge-base', 'HEAD', ref], { cwd: root, encoding: 'utf8' });
+    if (result.status === 0 && String(result.stdout || '').trim())
+        return String(result.stdout).trim();
+    const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' });
+    return head.status === 0 ? String(head.stdout || '').trim() || null : null;
+}
+function optionValue(name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? String(args[index + 1] || '').trim() : '';
+}
+function isGeneratedPath(relPath) {
+    return /^src\/generated\//.test(relPath);
 }
 function isRouteDomainAggregator(relPath) {
     return [
@@ -74,7 +240,7 @@ function importsUnrelatedRouteDomains(file) {
     const text = fs.readFileSync(file, 'utf8');
     const domains = new Set();
     const imports = importSpecs(text);
-    for (const domain of ['team', 'qa-loop', 'research', 'ppt', 'image-ux-review', 'db', 'gx', 'wiki']) {
+    for (const domain of CURRENT_ROUTE_DOMAIN_IMPORT_SEGMENTS) {
         if (imports.some((spec) => new RegExp(`(^|[/_-])${domain}([/_-]|\\.|$)`, 'i').test(spec)))
             domains.add(domain);
     }
@@ -85,9 +251,8 @@ function importSpecs(text) {
     const re = /^\s*import\s+(?:[^'"]*?\s+from\s+)?['"]([^'"]+)['"]/gm;
     let match;
     while ((match = re.exec(text))) {
-        const spec = match[1];
-        if (spec)
-            specs.push(spec);
+        if (match[1])
+            specs.push(match[1]);
     }
     return specs;
 }
@@ -96,72 +261,35 @@ function walk(dir, out) {
         const file = path.join(dir, entry.name);
         if (entry.isDirectory())
             walk(file, out);
-        else if (entry.isFile() && /\.(mjs|js|ts)$/.test(entry.name))
+        else if (entry.isFile())
             out.push(file);
     }
 }
-function checkTsImports() {
-    const files = [];
-    walk(path.join(root, 'src'), files);
-    for (const file of files.filter((item) => item.endsWith('.ts'))) {
-        const relPath = path.relative(root, file).split(path.sep).join('/');
-        const text = fs.readFileSync(file, 'utf8');
-        if (/from\s+['"][^'"]+\.mjs['"]|import\(\s*['"][^'"]+\.mjs['"]\s*\)/.test(text)) {
-            failures.push(`${relPath}: TypeScript imports .mjs runtime`);
-        }
-    }
-}
-function checkDistRuntime() {
-    const dist = path.join(root, 'dist');
-    if (!fs.existsSync(dist))
-        return;
-    const files = [];
-    walk(dist, files);
-    for (const file of files) {
-        const relPath = path.relative(root, file).split(path.sep).join('/');
-        if (relPath.endsWith('.mjs'))
-            failures.push(`${relPath}: dist .mjs runtime forbidden`);
-    }
+function lineCount(text) {
+    return text ? text.split(/\r?\n/).length : 0;
 }
-function loadWaivers() {
-    const file = path.join(root, 'src', 'generated', 'architecture-waivers.json');
+function readJson(file) {
     try {
-        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-        return Array.isArray(parsed.waivers) ? parsed.waivers : [];
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
     }
     catch {
-        return [];
-    }
-}
-function isWaivedGenerated(relPath) {
-    return /^src\/generated\//.test(relPath)
-        || waivers.some((waiver) => waiver?.schema === 'sks.architecture-waiver.v1'
-            && waiver.file === relPath
-            && waiver.reason === 'generated'
-            && waiver.expires_version);
-}
-function changedFileSet() {
-    const out = new Set();
-    for (const line of gitLines(['diff', '--name-only', 'HEAD', '--']))
-        out.add(normalize(line));
-    for (const line of gitLines(['ls-files', '--others', '--exclude-standard']))
-        out.add(normalize(line));
-    return out;
-}
-function baseLineCount(relPath) {
-    const result = spawnSync('git', ['show', `HEAD:${relPath}`], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-    if (result.status !== 0)
         return null;
-    const text = String(result.stdout || '');
-    return text ? text.split(/\r?\n/).length : 0;
+    }
 }
-function gitLines(args) {
-    const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+function gitLines(gitArgs) {
+    const result = spawnSync('git', gitArgs, { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
     if (result.status !== 0)
         return [];
     return String(result.stdout || '').split(/\r?\n/).map(normalize).filter(Boolean);
 }
+function gitOk(gitArgs) {
+    return spawnSync('git', gitArgs, { cwd: root, stdio: 'ignore' }).status === 0;
+}
+function writeReport(value) {
+    const dir = path.join(root, '.sneakoscope', 'reports');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'architecture-check.json'), `${JSON.stringify(value, null, 2)}\n`);
+}
 function normalize(file) {
     return String(file || '').replace(/\\/g, '/');
 }
-//# sourceMappingURL=check-architecture.js.map

package/dist/scripts/check-cli-entrypoint.js

@@ -40,4 +40,3 @@ if (issues.length) {
 else {
     console.log('CLI entrypoint check passed');
 }
-//# sourceMappingURL=check-cli-entrypoint.js.map

package/dist/scripts/check-command-module-budget.js

@@ -82,4 +82,3 @@ function rel(file) {
 function normalize(file) {
     return String(file || '').replace(/\\/g, '/');
 }
-//# sourceMappingURL=check-command-module-budget.js.map

package/dist/scripts/check-feature-quality.js

@@ -50,4 +50,3 @@ function releaseQualityBlockers(counts = {}) {
         blockers.push(`missing_above_release_target:${counts.missing || 0}`);
     return blockers;
 }
-//# sourceMappingURL=check-feature-quality.js.map

package/dist/scripts/check-legacy-free.js

@@ -63,4 +63,3 @@ async function listFiles(dir) {
 function rel(file) {
     return path.relative(root, file).split(path.sep).join('/');
 }
-//# sourceMappingURL=check-legacy-free.js.map

package/dist/scripts/check-pipeline-budget.js

@@ -47,4 +47,3 @@ console.log('Pipeline budget check passed');
 function lineCount(file) {
     return fs.readFileSync(file, 'utf8').split(/\r?\n/).length;
 }
-//# sourceMappingURL=check-pipeline-budget.js.map

package/dist/scripts/check-pipeline-runtime.js

@@ -15,4 +15,3 @@ if (failures.length) {
     process.exit(1);
 }
 console.log('Pipeline runtime check passed');
-//# sourceMappingURL=check-pipeline-runtime.js.map

package/dist/scripts/check-publish-tag.js

@@ -54,4 +54,3 @@ function readRootNpmrcTag() {
     }
     return '';
 }
-//# sourceMappingURL=check-publish-tag.js.map

package/dist/scripts/check-route-modularity.js

@@ -19,9 +19,9 @@ for (const relModule of registeredCommandModules()) {
         failures.push(`registered command module missing: ${relModule}`);
 }
 const disallowedImports = {
-    'qa-loop-command.ts': ['research-command', 'ppt-command', 'team-command', 'gx-command'],
-    'research-command.ts': ['qa-loop-command', 'ppt-command', 'team-command', 'gx-command'],
-    'wiki-command.ts': ['team-command', 'research-command', 'qa-loop-command', 'ppt-command']
+    'qa-loop-command.ts': ['research-command', 'ppt-command', 'gx-command'],
+    'research-command.ts': ['qa-loop-command', 'ppt-command', 'gx-command'],
+    'wiki-command.ts': ['research-command', 'qa-loop-command', 'ppt-command']
 };
 for (const [name, needles] of Object.entries(disallowedImports)) {
     const file = commandModulePath(name);
@@ -70,4 +70,3 @@ function commandModulePath(name) {
     const ts = path.join(base, name.replace(/\.mjs$/, '.ts'));
     return fs.existsSync(mjs) ? mjs : ts;
 }
-//# sourceMappingURL=check-route-modularity.js.map

package/dist/scripts/check-runtime-schemas.js

@@ -4,6 +4,7 @@ import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import fs from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
 const root = process.cwd();
 const tsc = spawnSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['tsc', '-p', 'tsconfig.json', '--noEmit'], {
     cwd: root,
@@ -21,7 +22,7 @@ try {
     validatorsOk = proof.isCompletionProof({
         schema: 'sks.completion-proof.v1',
         mission_id: null,
-        route: '$Team',
+        route: '$Naruto',
         status: 'verified_partial',
         evidence: {},
         claims: [],
@@ -80,6 +81,23 @@ for (const file of [
         issues.push(`codex_schema_invalid_json:${file}:${err.message}`);
     }
 }
+try {
+    const external = JSON.parse(fs.readFileSync(path.join(codexSchemaDir, 'agent-result.schema.json'), 'utf8'));
+    const runtime = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-output-validator.js')));
+    const { $schema, $id, title, ...externalRuntimeShape } = external;
+    if ($schema !== 'https://json-schema.org/draft/2020-12/schema')
+        issues.push('agent_result_schema_draft_mismatch');
+    if ($id !== 'https://sneakoscope.dev/schemas/codex/agent-result.schema.json')
+        issues.push('agent_result_schema_id_mismatch');
+    if (title !== 'SKS Native Agent Result')
+        issues.push('agent_result_schema_title_mismatch');
+    if (!isDeepStrictEqual(externalRuntimeShape, runtime.AGENT_RESULT_RUNTIME_SCHEMA)) {
+        issues.push('agent_result_runtime_schema_parity_mismatch');
+    }
+}
+catch (err) {
+    issues.push(`agent_result_runtime_schema_parity_error:${err.message}`);
+}
 const searchVisibilitySchemaDir = path.join(root, 'schemas', 'search-visibility');
 for (const file of [
     'site-inventory.schema.json',
@@ -106,4 +124,3 @@ const result = { schema: 'sks.runtime-schema-check.v1', ok: issues.length === 0,
 console.log(JSON.stringify(result, null, 2));
 if (!result.ok)
     process.exitCode = 1;
-//# sourceMappingURL=check-runtime-schemas.js.map

package/dist/scripts/cli-output-consistency-check.js

@@ -4,7 +4,6 @@ import { spawnSync } from 'node:child_process';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
 import { PACKAGE_VERSION } from '../core/version.js';
 const executed = [
-    ['ui', '--once'],
     ['review'],
     ['fast-mode', 'status'],
     ['menubar', 'status'],
@@ -16,7 +15,6 @@ const staticFiles = [
     'src/core/commands/basic-cli.ts',
     'src/core/commands/naruto-command.ts',
     'src/core/commands/review-command.ts',
-    'src/core/commands/ui-command.ts',
     'src/core/commands/fast-mode-command.ts',
     'src/core/commands/menubar-command.ts',
     'src/core/commands/uninstall-command.ts'
@@ -54,4 +52,3 @@ function run(args) {
         stderr: stderr.slice(0, 1000)
     };
 }
-//# sourceMappingURL=cli-output-consistency-check.js.map

package/dist/scripts/codex-0-134-runner-truth-check.js

@@ -63,4 +63,3 @@ fs.mkdirSync(path.dirname(out), { recursive: true });
 fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
 assertGate(report.ok === true, 'Codex 0.134 runner truth has blockers', report);
 emitGate('codex:0.134-runner-truth', { profile: processReport.profile, history_results: historyReport.results.length });
-//# sourceMappingURL=codex-0-134-runner-truth-check.js.map

package/dist/scripts/codex-0-137-compat-check.js

@@ -24,4 +24,3 @@ emit(report);
 function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
     process.exitCode = 1; }
 function fail(blocker, detail) { emit({ schema: 'sks.codex-0.137-compat-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=codex-0-137-compat-check.js.map

package/dist/scripts/codex-0138-capability-artifact-check.js

@@ -12,4 +12,3 @@ const rootArtifact = JSON.parse(await fs.readFile(result.root_artifact, 'utf8'))
 const missionArtifact = JSON.parse(await fs.readFile(result.mission_artifact, 'utf8'));
 assertGate(rootArtifact.schema === 'sks.codex-0138-capability.v1' && missionArtifact.ok === true, 'capability artifacts must be written at root and mission scope', result);
 emitGate('codex:0138-capability-artifact', { root_artifact: path.basename(result.root_artifact), mission_artifact: path.basename(result.mission_artifact) });
-//# sourceMappingURL=codex-0138-capability-artifact-check.js.map

package/dist/scripts/codex-0138-capability-check.js

@@ -8,4 +8,3 @@ const cap = await mod.detectCodex0138Capability({ codexBin: 'codex' });
 assertGate(cap.ok === true, 'Codex 0.138 capability detector must accept 0.138.0', cap);
 assertGate(cap.supports_app_handoff && cap.supports_plugin_json && cap.supports_image_path_exposure && cap.supports_model_defined_efforts && cap.supports_app_server_token_usage && cap.supports_oauth_mcp_prerefresh, '0.138 feature flags missing', cap);
 emitGate('codex:0138-capability', { parsed_version: cap.parsed_version });
-//# sourceMappingURL=codex-0138-capability-check.js.map

package/dist/scripts/codex-0138-doctor-check.js

@@ -12,4 +12,3 @@ await writeTextAtomic(path.join(root, 'AGENTS.md'), '# fixture\n');
 const report = await mod.runCodex0138Doctor(root, { fix: true });
 assertGate(report.schema === 'sks.codex-0138-doctor.v1' && report.ok === true && report.checks.oauth_mcp_prerefresh.supported === true, 'Codex 0.138 doctor must check startup resilience and OAuth MCP pre-refresh support', report);
 emitGate('codex:0138-doctor', { fixed: report.fixed });
-//# sourceMappingURL=codex-0138-doctor-check.js.map

package/dist/scripts/codex-0138-feature-probes-check.js

@@ -9,4 +9,3 @@ const mod = await importDist('core/codex-control/codex-0138-capability.js');
 const cap = await mod.detectCodex0138Capability({ codexBin: 'codex' });
 assertGate(cap.ok === false && cap.probe_mode === 'feature-probe' && cap.supports_plugin_json === false && cap.blockers.includes('codex_plugin_json_probe_failed'), '0.138 feature probes must override coarse version-only plugin JSON support and mark failed probes not ok');
 emitGate('codex:0138-feature-probes', { probe_mode: cap.probe_mode, plugin_json: cap.feature_probe_results.plugin_json });
-//# sourceMappingURL=codex-0138-feature-probes-check.js.map

package/dist/scripts/codex-0140-capability-check.js

@@ -12,4 +12,3 @@ process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.139.0';
 const old = await detectCodex0140Capability({ codexBin: 'codex' });
 assertGate(old.ok === false && old.blockers.includes('codex_0_140_required_for_0140_features'), 'Codex 0.139 must not satisfy 0.140 capability', old);
 emitGate('codex:0140-capability', { features: Object.keys(cap.features).length });
-//# sourceMappingURL=codex-0140-capability-check.js.map

package/dist/scripts/codex-0140-feature-probes-check.js

@@ -21,4 +21,3 @@ function clearFailureEnv() {
             delete process.env[key];
     }
 }
-//# sourceMappingURL=codex-0140-feature-probes-check.js.map

package/dist/scripts/codex-0144-app-server-v2-check.js

@@ -10,10 +10,10 @@ assertGate(clientSource.includes('currentTime/read'), 'app-server-v2 client must
 assertGate(clientSource.includes("request('thread/list'"), 'app-server-v2 client must wrap native thread/list');
 assertGate(clientSource.includes("request('thread/read'"), 'app-server-v2 client must wrap native thread/read');
 assertGate(clientSource.includes('searchThreads'), 'app-server-v2 client must expose search over native thread list searchTerm');
-assertGate(schema.includes('"thread/list"'), 'generated 0.144.1 schema must contain thread/list');
-assertGate(schema.includes('"thread/read"'), 'generated 0.144.1 schema must contain thread/read');
-assertGate(schema.includes('"searchTerm"'), 'generated 0.144.1 schema must contain ThreadListParams.searchTerm');
-assertGate(schema.includes('"ThreadSearchResult"'), 'generated 0.144.1 schema must contain ThreadSearchResult');
+assertGate(schema.includes('"thread/list"'), 'generated 0.144.5 schema must contain thread/list');
+assertGate(schema.includes('"thread/read"'), 'generated 0.144.5 schema must contain thread/read');
+assertGate(schema.includes('"searchTerm"'), 'generated 0.144.5 schema must contain ThreadListParams.searchTerm');
+assertGate(schema.includes('"ThreadSearchResult"'), 'generated 0.144.5 schema must contain ThreadSearchResult');
 const deterministic = currentTimeResponse(new Date('2026-06-23T00:00:00.000Z'));
 assertGate(deterministic.utcIso === '2026-06-23T00:00:00.000Z', 'currentTime/read UTC ISO must be deterministic');
 assertGate(deterministic.unixTimeSeconds === 1782172800, 'currentTime/read seconds must be Unix UTC seconds');
@@ -44,4 +44,3 @@ emitGate('codex:0144:app-server-v2', {
     thread_search_via_list_search_term: true,
     real_probe: realProbe
 });
-//# sourceMappingURL=codex-0144-app-server-v2-check.js.map

package/dist/scripts/codex-0144-binary-identity-check.js

@@ -14,4 +14,3 @@ emitGate('codex:0144:binary-identity', {
     sha256: identity.sha256,
     source: identity.source
 });
-//# sourceMappingURL=codex-0144-binary-identity-check.js.map

package/dist/scripts/codex-0144-capability-check.js

@@ -5,12 +5,12 @@ const requireReal = process.argv.includes('--require-real') || process.env.SKS_R
 if (!requireReal)
     process.env.SKS_CODEX_0144_FAKE = '1';
 const cap = await detectCodex0144Capability({ requireReal });
-assertGate(cap.ok === true, 'Codex 0.144.1 capability probe must pass', cap);
-assertGate(Object.keys(cap.feature_states).length === CODEX_0144_FEATURE_KEYS.length, 'Codex 0.144.1 feature count mismatch', cap);
-assertGate(Object.values(cap.feature_states).every((state) => String(state.certainty) !== 'assumed_by_version'), 'Codex 0.144.1 capability must not use assumed_by_version evidence', cap);
+assertGate(cap.ok === true, 'Codex 0.144.5 capability probe must pass', cap);
+assertGate(Object.keys(cap.feature_states).length === CODEX_0144_FEATURE_KEYS.length, 'Codex 0.144.5 feature count mismatch', cap);
+assertGate(Object.values(cap.feature_states).every((state) => String(state.certainty) !== 'assumed_by_version'), 'Codex 0.144.5 capability must not use assumed_by_version evidence', cap);
 if (requireReal) {
-    assertGate(cap.probe_mode === 'real-schema', 'Codex 0.144.1 require-real must use generated schema evidence', cap);
-    assertGate(cap.release_authorizing === true, 'Codex 0.144.1 require-real must be release-authorizing', cap);
+    assertGate(cap.probe_mode === 'real-schema', 'Codex 0.144.5 require-real must use generated schema evidence', cap);
+    assertGate(cap.release_authorizing === true, 'Codex 0.144.5 require-real must be release-authorizing', cap);
     await writeCodex0144CapabilityArtifacts(process.cwd(), { requireReal: true });
 }
 emitGate('codex:0144:capability', {
@@ -18,4 +18,3 @@ emitGate('codex:0144:capability', {
     probe_mode: cap.probe_mode,
     release_authorizing: cap.release_authorizing
 });
-//# sourceMappingURL=codex-0144-capability-check.js.map

package/dist/scripts/codex-0144-core-real-probes-check.js

@@ -48,4 +48,3 @@ function readRepeated(name) {
             out.push(args[i + 1]);
     return out;
 }
-//# sourceMappingURL=codex-0144-core-real-probes-check.js.map

package/dist/scripts/codex-0144-manifest-check.js

@@ -27,4 +27,3 @@ emitGate('codex:0144:manifest', {
     sdk_version: manifest.sdkVersion,
     generated_schema_sha256: shippedCapability.generated_schema_sha256
 });
-//# sourceMappingURL=codex-0144-manifest-check.js.map

package/dist/scripts/codex-0144-policy-check.js

@@ -29,4 +29,3 @@ emitGate('codex:0144:policy', {
     network: policy.network,
     approval: policy.approval
 });
-//# sourceMappingURL=codex-0144-policy-check.js.map

package/dist/scripts/codex-0144-thread-store-check.js

@@ -51,4 +51,3 @@ async function exists(file) {
         return false;
     }
 }
-//# sourceMappingURL=codex-0144-thread-store-check.js.map

package/dist/scripts/codex-agent-role-rich-content-check.js

@@ -1,4 +1,3 @@
 #!/usr/bin/env node
 import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
 await runDirective315Gate('codex-app:agent-role-rich-content');
-//# sourceMappingURL=codex-agent-role-rich-content-check.js.map

package/dist/scripts/codex-agent-role-sync-check.js

@@ -1,4 +1,3 @@
 #!/usr/bin/env node
 import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
 await runDirective314Gate('codex-app:agent-role-sync');
-//# sourceMappingURL=codex-agent-role-sync-check.js.map