sneakoscope 7.1.0 → 7.3.0

package/dist/core/code-structure.js

@@ -1,8 +1,9 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
 import { spawnSync } from 'node:child_process';
-import { nowIso, writeJsonAtomic } from './fsx.js';
-import { LEAN_CHANGE_EVIDENCE_SCHEMA, leanPolicyReference, parseLeanSimplificationMarkerLine } from './lean-engineering-policy.js';
+import { nowIso, sha256, writeJsonAtomic } from './fsx.js';
+import { LEAN_CHANGE_EVIDENCE_SCHEMA, assessTestVolume, leanPolicyReference, parseLeanSimplificationMarkerLine } from './lean-engineering-policy.js';
+import { escapeRegExp } from './text/regex.js';
 export const CODE_STRUCTURE_THRESHOLDS = {
     warning: 1000,
     review: 2000,
@@ -15,8 +16,25 @@ const SOURCE_EXT_RE = /\.(js|ts|tsx|jsx|cjs|mjs|json|md|rs|toml)$/;
 const FALLBACK_RE = /\b(fallback|legacy|shim|compat|mock|catch-all|catch all|default provider)\b/i;
 const CONFIG_FLAG_RE = /\b(process\.env|SKS_[A-Z0-9_]+|CODEX_[A-Z0-9_]+|[A-Z][A-Z0-9_]{5,})\b/;
 const ABSTRACTION_RE = /\b(interface|abstract class|class|factory|provider|adapter|registry|orchestrator|manager)\b/;
+const N_PLUS_ONE_RE = /(?:(?:for\s*(?:await\s*)?\([^)]*\)|for\s+(?:await\s+)?(?:const|let|var)\s+\w+\s+of\s+[^{]+|\.forEach\s*\(\s*async\b|\.map\s*\(\s*async\b))[\s\S]{0,1200}\bawait\s+[\w.$]*(?:query|execute|findMany|findUnique|findFirst|select|insert|update|delete|save)\s*\(/i;
+const UNBOUNDED_LOOP_RE = /\bwhile\s*\(\s*true\s*\)|\bfor\s*\(\s*;\s*;\s*\)/i;
+const RENDER_LOOP_RE = /\buseEffect\s*\(\s*\(\s*\)\s*=>\s*\{[\s\S]{0,1200}\bset[A-Z]\w*\s*\([^)]*\)[\s\S]{0,400}\}\s*\)\s*;?/i;
+const VERIFICATION_BYPASS_RE = /\b(?:test|it|describe)\.(?:skip|only)\s*\(|\b(?:xit|xdescribe)\s*\(|@ts-ignore\b|eslint-disable(?:-next-line)?\b|\.catch\s*\(\s*\(\s*\)\s*=>\s*(?:undefined|\{\s*\})\s*\)|catch\s*\([^)]*\)\s*\{\s*\}/i;
+const DB_POOL_CONSTRUCTOR_RE = /\bnew\s+(?:Pool|PrismaClient|DataSource|Sequelize)\s*\(|\bcreatePool\s*\(|\bknex\s*\(/i;
+const SENSITIVE_DOMAIN_RE = /\b(payment|billing|invoice|charge|refund|ledger|balance|payout|settlement|wallet)\b|결제|청구|환불|원장|잔액|정산/i;
+const DB_WRITE_CALL_RE = /\b(?:insert|update|delete|upsert|save|create|execute|query)\s*\(/gi;
+const TRANSACTION_MARKER_RE = /\b(?:transaction|withTransaction|atomic|begin|commit|rollback|savepoint|\$transaction)\b/i;
+const ENGINEERING_SANITY_TAGS = new Set([
+    'solid',
+    'n-plus-one',
+    'unbounded-loop',
+    'verification-bypass',
+    'db-pool',
+    'transaction'
+]);
 export async function scanCodeStructure(root, opts = {}) {
     const changedScope = await collectChangedScope(root, opts);
+    const addedHunkScopes = await collectAddedHunkScopes(root, changedScope);
     const files = await resolveScanFiles(root, opts, changedScope);
     const touched = new Set((opts.touchedFiles || []).map((file) => normalizeRel(root, file)));
     const changedSet = new Set((changedScope.source_files || []).map((file) => normalizeSlashes(file)));
@@ -30,7 +48,12 @@ export async function scanCodeStructure(root, opts = {}) {
         const changedByDiff = changedSet.has(rel);
         if (status === 'ok' && !opts.includeOk && !changedByDiff)
             continue;
-        const signals = analyzeTextSignals(rel, text, changedByDiff);
+        const addedScope = addedHunkScopes.get(rel);
+        const signals = analyzeTextSignals(rel, text, changedByDiff, addedScope || {
+            scope: changedByDiff ? 'changed_file_without_added_hunks' : 'full_file_advisory',
+            text: changedByDiff ? '' : text,
+            line_ranges: []
+        });
         intentionalSimplifications.push(...signals.lean_markers);
         entries.push({
             path: rel,
@@ -115,18 +138,23 @@ async function resolveScanFiles(root, opts, changedScope) {
     const changedSourceFiles = (changedScope.source_files || [])
         .filter((file) => DEFAULT_INCLUDE.has(path.extname(file)))
         .map((file) => path.resolve(root, file));
-    if ((opts.changed || opts.changedSince || opts.changedFiles?.length) && changedSourceFiles.length)
+    if (opts.changed || opts.changedSince || opts.changedFiles?.length)
         return changedSourceFiles;
     return listSourceFiles(root);
 }
 async function collectChangedScope(root, opts) {
     if (opts.changedFiles?.length) {
         const changedFiles = Array.from(new Set(opts.changedFiles.map((file) => normalizeRel(root, file))));
+        const entries = [];
+        for (const file of changedFiles) {
+            const text = await fsp.readFile(path.join(root, file), 'utf8').catch(() => '');
+            entries.push({ path: file, status: 'M', lines_added: 0, lines_deleted: 0, source_sha256: isSourceLike(file) ? sha256(text) : null });
+        }
         return {
             ...emptyChangedScope('explicit', opts.changedSince || 'HEAD'),
             changed_files: changedFiles,
             source_files: changedFiles.filter(isSourceLike),
-            entries: changedFiles.map((file) => ({ path: file, status: 'M', lines_added: 0, lines_deleted: 0 }))
+            entries
         };
     }
     const shouldCollect = opts.changed || opts.changedSince;
@@ -169,11 +197,18 @@ async function collectChangedScope(root, opts) {
         entriesByPath.set(rel, {
             path: rel,
             status: 'A',
-            lines_added: text ? text.split(/\n/).length : 0,
-            lines_deleted: 0
+            lines_added: addedFileLines(text).length,
+            lines_deleted: 0,
+            source_sha256: isSourceLike(rel) ? sha256(text) : null
         });
     }
-    const entries = [...entriesByPath.values()].filter((entry) => entry.path);
+    const entries = [...entriesByPath.values()].filter((entry) => entry.path && isChangedScopePath(entry.path));
+    for (const entry of entries) {
+        if (!isSourceLike(entry.path) || entry.source_sha256)
+            continue;
+        const text = await fsp.readFile(path.join(root, entry.path), 'utf8').catch(() => '');
+        entry.source_sha256 = sha256(text);
+    }
     const changedFiles = entries.map((entry) => entry.path);
     const sourceFiles = changedFiles.filter(isSourceLike);
     const linesAdded = entries.reduce((sum, entry) => sum + Number(entry.lines_added || 0), 0);
@@ -258,8 +293,70 @@ async function collectAddedFallbackSites(root, changedScope) {
     }
     return sites;
 }
-function analyzeTextSignals(rel, text, changedByDiff) {
+async function collectAddedHunkScopes(root, changedScope) {
+    const scopes = new Map();
+    if (!changedScope?.source_files?.length)
+        return scopes;
+    if (changedScope.mode === 'explicit') {
+        for (const rel of changedScope.source_files) {
+            const text = await fsp.readFile(path.join(root, rel), 'utf8').catch(() => '');
+            const lineCount = text ? text.split(/\r?\n/).length : 0;
+            scopes.set(normalizeSlashes(rel), {
+                scope: 'explicit_changed_file',
+                text,
+                line_ranges: lineCount ? [{ start: 1, end: lineCount }] : []
+            });
+        }
+        return scopes;
+    }
+    if (changedScope.mode !== 'git-diff')
+        return scopes;
+    const diff = gitText(root, ['diff', '--unified=0', changedScope.base || 'HEAD', '--', ...changedScope.source_files]);
+    let currentFile = '';
+    let currentLine = 0;
+    const linesByFile = new Map();
+    for (const line of diff.split(/\r?\n/)) {
+        if (line.startsWith('+++ b/')) {
+            currentFile = normalizeSlashes(line.slice('+++ b/'.length));
+            continue;
+        }
+        const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+        if (hunk) {
+            currentLine = Number(hunk[1]) || 0;
+            continue;
+        }
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+            if (currentFile) {
+                const rows = linesByFile.get(currentFile) || [];
+                rows.push({ line: currentLine, text: line.slice(1) });
+                linesByFile.set(currentFile, rows);
+            }
+            currentLine += 1;
+            continue;
+        }
+        if (!line.startsWith('-'))
+            currentLine += 1;
+    }
+    for (const rel of changedScope.source_files) {
+        const normalized = normalizeSlashes(rel);
+        let rows = linesByFile.get(normalized) || [];
+        const entry = changedScope.entries?.find((candidate) => normalizeSlashes(candidate.path) === normalized);
+        if (!rows.length && String(entry?.status || '').startsWith('A')) {
+            const text = await fsp.readFile(path.join(root, normalized), 'utf8').catch(() => '');
+            rows = addedFileLines(text).map((value, index) => ({ line: index + 1, text: value }));
+        }
+        scopes.set(normalized, {
+            scope: 'added_hunks',
+            text: joinAddedHunkRows(rows),
+            line_ranges: contiguousLineRanges(rows.map((row) => row.line))
+        });
+    }
+    return scopes;
+}
+function analyzeTextSignals(rel, text, changedByDiff, sanityScope) {
     const lines = text.split(/\r?\n/);
+    const scopedText = String(sanityScope.text || '');
+    const scopedCode = stripNonCodeForSanity(scopedText);
     const imports = lines.filter((line) => /^\s*import\s/.test(line));
     const externalImports = imports
         .map((line) => /from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/.exec(line)?.[1] || /from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/.exec(line)?.[2] || '')
@@ -268,21 +365,64 @@ function analyzeTextSignals(rel, text, changedByDiff) {
         .map((line, index) => parseLeanSimplificationMarkerLine(line, rel, index + 1))
         .filter((marker) => Boolean(marker));
     const effectiveLines = lines.map((line) => line.trim()).filter(Boolean);
-    const forwardingOnly = effectiveLines.length > 0
+    const scopeCoversWholeFile = sanityScope.line_ranges.length === 1
+        && sanityScope.line_ranges[0]?.start === 1
+        && sanityScope.line_ranges[0]?.end >= lines.length;
+    const forwardingOnly = scopeCoversWholeFile
+        && effectiveLines.length > 0
         && effectiveLines.length <= 10
         && effectiveLines.every((line) => line.startsWith('import ') || line.startsWith('export ') || line.startsWith('//') || line.startsWith('/*') || line.startsWith('*'));
     return {
         import_count: imports.length,
         external_dependency_imports: Array.from(new Set(externalImports)).sort(),
-        ts_nocheck: /^\s*\/\/\s*@ts-nocheck\b/m.test(text),
+        ts_nocheck: /^\s*\/\/\s*@ts-nocheck\b/m.test(scopedText),
         changed_by_diff: changedByDiff,
         forwarding_only: forwardingOnly,
-        fallback_markers: countMatches(text, FALLBACK_RE),
-        config_flag_markers: countMatches(text, CONFIG_FLAG_RE),
-        abstraction_markers: countMatches(text, ABSTRACTION_RE),
+        fallback_markers: countMatches(scopedCode, FALLBACK_RE),
+        config_flag_markers: countMatches(scopedCode, CONFIG_FLAG_RE),
+        abstraction_markers: countMatches(scopedCode, ABSTRACTION_RE),
+        engineering_sanity: engineeringSanitySignals(scopedText, sanityScope),
         lean_markers: leanMarkers
     };
 }
+function engineeringSanitySignals(text, scope) {
+    const code = stripNonCodeForSanity(text);
+    const writeCalls = code.match(DB_WRITE_CALL_RE)?.length || 0;
+    return {
+        source_scope: scope.scope,
+        added_hunk_line_ranges: scope.line_ranges,
+        candidate_detection_only: true,
+        n_plus_one_candidates: countMatches(code, N_PLUS_ONE_RE),
+        unbounded_loop_candidates: countMatches(code, UNBOUNDED_LOOP_RE),
+        render_loop_candidates: countMatches(code, RENDER_LOOP_RE),
+        direct_recursion_candidates: countDirectRecursionCandidates(code),
+        verification_bypass_markers: countMatches(code, VERIFICATION_BYPASS_RE),
+        db_pool_constructor_markers: countMatches(code, DB_POOL_CONSTRUCTOR_RE),
+        sensitive_transaction_candidate: SENSITIVE_DOMAIN_RE.test(code)
+            && writeCalls >= 2
+            && !TRANSACTION_MARKER_RE.test(code),
+        db_write_call_markers: writeCalls
+    };
+}
+function stripNonCodeForSanity(text) {
+    return String(text || '')
+        .replace(/^\s*const\s+[A-Z0-9_]+_RE\s*=\s*\/.*\/[dgimsuvy]*;?\s*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//g, (value) => value.replace(/[^\n]/g, ' '))
+        .replace(/(^|[^:\\])\/\/.*$/gm, '$1')
+        .replace(/(['"`])(?:\\.|(?!\1)[\s\S])*?\1/g, (value) => value.replace(/[^\n]/g, ' '));
+}
+function countDirectRecursionCandidates(text) {
+    let count = 0;
+    const functions = /(?:function\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)|(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>)\s*\{([\s\S]{0,3000}?)\n?\}/g;
+    let match;
+    while ((match = functions.exec(text))) {
+        const name = match[1] || match[2];
+        const body = match[3] || '';
+        if (name && new RegExp(`\\b${escapeRegExp(name)}\\s*\\(`).test(body))
+            count += 1;
+    }
+    return count;
+}
 function collectRunnableChecks(changedScope) {
     return (changedScope.source_files || [])
         .filter((file) => /\b(test|tests|fixture|fixtures|spec|check|__tests__)\b/i.test(file))
@@ -290,6 +430,14 @@ function collectRunnableChecks(changedScope) {
 }
 function buildSemanticReview(input) {
     const findings = [];
+    const testVolume = assessTestVolume(input.changedScope?.entries || []);
+    if (testVolume.over_budget) {
+        findings.push({
+            tag: 'yagni',
+            severity: 'review',
+            summary: `change adds ${testVolume.added_test_lines} test lines for ${testVolume.added_source_lines} source lines (${testVolume.ratio?.toFixed(1)}x); keep the cases a real defect would produce and drop the rest — exhaustive cases are only owed on money-handling paths`
+        });
+    }
     for (const dep of input.dependencyDelta.added || []) {
         findings.push({
             tag: 'reuse',
@@ -340,12 +488,65 @@ function buildSemanticReview(input) {
                 summary: 'changed file is forwarding-only; confirm it replaces an older path instead of duplicating an SSOT'
             });
         }
+        const sanity = entry.lean_signals.engineering_sanity || {};
         if (entry.lean_signals.config_flag_markers > 6 || entry.lean_signals.abstraction_markers > 12) {
             findings.push({
-                tag: 'yagni',
+                tag: 'solid',
+                severity: 'review',
+                file: entry.path,
+                source_scope: sanity.source_scope,
+                added_hunk_line_ranges: sanity.added_hunk_line_ranges,
+                summary: 'changed file has dense config/abstraction markers; review single responsibility, dependency direction, and unrequested layers'
+            });
+        }
+        if (sanity.n_plus_one_candidates > 0) {
+            findings.push({
+                tag: 'n-plus-one',
+                severity: 'review',
+                file: entry.path,
+                source_scope: sanity.source_scope,
+                added_hunk_line_ranges: sanity.added_hunk_line_ranges,
+                summary: `${sanity.n_plus_one_candidates} loop-bound database or I/O call candidate(s) require batching, prefetching, or bounded-query review`
+            });
+        }
+        if (sanity.unbounded_loop_candidates > 0 || sanity.render_loop_candidates > 0 || sanity.direct_recursion_candidates > 0) {
+            findings.push({
+                tag: 'unbounded-loop',
+                severity: 'review',
+                file: entry.path,
+                source_scope: sanity.source_scope,
+                added_hunk_line_ranges: sanity.added_hunk_line_ranges,
+                summary: `control-flow review required: unbounded=${sanity.unbounded_loop_candidates || 0}, render=${sanity.render_loop_candidates || 0}, recursion=${sanity.direct_recursion_candidates || 0}`
+            });
+        }
+        if (sanity.verification_bypass_markers > 0) {
+            findings.push({
+                tag: 'verification-bypass',
                 severity: 'review',
                 file: entry.path,
-                summary: 'changed file has dense config/abstraction markers; review for unrequested knobs or layers'
+                source_scope: sanity.source_scope,
+                added_hunk_line_ranges: sanity.added_hunk_line_ranges,
+                summary: `${sanity.verification_bypass_markers} disabled-check or swallowed-failure marker(s) require explicit justification and equivalent verification`
+            });
+        }
+        if (sanity.db_pool_constructor_markers > 0) {
+            findings.push({
+                tag: 'db-pool',
+                severity: 'review',
+                file: entry.path,
+                source_scope: sanity.source_scope,
+                added_hunk_line_ranges: sanity.added_hunk_line_ranges,
+                summary: `${sanity.db_pool_constructor_markers} database client/pool construction marker(s) require canonical ownership, bounded acquire/release, shutdown, and exhaustion review`
+            });
+        }
+        if (sanity.sensitive_transaction_candidate) {
+            findings.push({
+                tag: 'transaction',
+                severity: 'review',
+                file: entry.path,
+                source_scope: sanity.source_scope,
+                added_hunk_line_ranges: sanity.added_hunk_line_ranges,
+                summary: 'sensitive or financial multi-write flow lacks an obvious transaction marker; verify atomic rollback, error propagation, idempotency, and post-commit invariants'
             });
         }
     }
@@ -360,12 +561,16 @@ function buildSemanticReview(input) {
             summary: `lean simplification marker is incomplete: ${marker.status}`
         });
     }
-    const status = findings.some((finding) => finding.severity === 'blocker')
+    const finalizedFindings = findings.map((finding) => ({
+        ...finding,
+        id: `eng-${sha256(`${finding.tag}:${finding.file || ''}:${finding.line || 0}:${finding.summary}`).slice(0, 16)}`
+    }));
+    const status = finalizedFindings.some((finding) => finding.severity === 'blocker')
         ? 'blocked'
-        : findings.some((finding) => finding.severity === 'review')
+        : finalizedFindings.some((finding) => finding.severity === 'review')
             ? 'needs-review'
             : 'pass';
-    return { status, findings };
+    return { status, findings: finalizedFindings };
 }
 function isLeanOwnedTypeSafetyPath(file) {
     return [
@@ -401,6 +606,21 @@ function buildLeanChangeEvidence(input) {
         fallback_sites_added: input.fallbackSites || [],
         intentional_simplifications: input.intentionalSimplifications || [],
         runnable_checks: input.runnableChecks || [],
+        engineering_sanity: {
+            status: (changedScope.source_files || []).length ? 'manual-review-required' : 'not-applicable',
+            automated_candidate_status: (input.semanticReview?.findings || []).some((finding) => ENGINEERING_SANITY_TAGS.has(finding.tag))
+                ? 'candidates-found'
+                : 'no-candidates-found',
+            required_checks: [
+                'solid_boundaries',
+                'n_plus_one_and_repeated_io',
+                'bounded_render_recursion_event_retry_polling',
+                'verification_bypass_absent',
+                'canonical_db_pool_lifecycle_when_applicable',
+                'transaction_integrity_when_sensitive_or_multi_step'
+            ],
+            findings: (input.semanticReview?.findings || []).filter((finding) => ENGINEERING_SANITY_TAGS.has(finding.tag))
+        },
         semantic_review: input.semanticReview || { status: 'needs-review', findings: [] }
     };
 }
@@ -444,6 +664,13 @@ function isSourceLike(file) {
     const rel = normalizeSlashes(file);
     return SOURCE_DIR_RE.test(rel) && SOURCE_EXT_RE.test(rel) && !isGeneratedOrVendor(rel);
 }
+function isChangedScopePath(file) {
+    const rel = normalizeSlashes(file);
+    const first = rel.split('/')[0] || '';
+    if (first.startsWith('.') && first !== '.agents')
+        return false;
+    return !isGeneratedOrVendor(rel);
+}
 function parseNumstat(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : 0;
@@ -456,6 +683,18 @@ function safeJson(text) {
         return {};
     }
 }
+function addedFileLines(text) {
+    if (!text)
+        return [];
+    const lines = text.split(/\r?\n/);
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
+export function resolveChangedScopeBase(root, fallback = 'HEAD') {
+    const sha = gitText(root, ['rev-parse', 'HEAD']).trim();
+    return /^[0-9a-f]{40}$/i.test(sha) ? sha : fallback;
+}
 function gitLines(root, args) {
     const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
     if (result.status !== 0)
@@ -488,3 +727,27 @@ function normalizeRel(root, file) {
 function normalizeSlashes(file) {
     return String(file || '').replace(/\\/g, '/');
 }
+function contiguousLineRanges(lines) {
+    const sorted = [...new Set(lines.filter((line) => Number.isInteger(line) && line > 0))].sort((a, b) => a - b);
+    const ranges = [];
+    for (const line of sorted) {
+        const last = ranges.at(-1);
+        if (last && line === last.end + 1)
+            last.end = line;
+        else
+            ranges.push({ start: line, end: line });
+    }
+    return ranges;
+}
+function joinAddedHunkRows(rows) {
+    const out = [];
+    let previousLine = 0;
+    for (const row of rows) {
+        if (previousLine > 0 && row.line > previousLine + 1) {
+            out.push(' '.repeat(1301));
+        }
+        out.push(row.text);
+        previousLine = row.line;
+    }
+    return out.join('\n');
+}

package/dist/core/codex/codex-config-guard.js

@@ -4,7 +4,20 @@ import { randomBytes } from 'node:crypto';
 import { appendJsonl, ensureDir, nowIso, readText, sha256, writeTextAtomic } from '../fsx.js';
 import { diffCodexAppUiSnapshots, snapshotCodexAppUiState } from '../codex-app/codex-app-ui-state-snapshot.js';
 import { cleanupCodexConfigBackups, validateCodexConfigRoundTrip } from './codex-config-toml.js';
-const FAST_FEATURE_KEYS = ['fast_mode'];
+import { escapeRegExp } from '../text/regex.js';
+const FAST_FEATURE_KEYS = [
+    'fast_mode',
+    'hooks',
+    'apps',
+    'computer_use',
+    'browser_use',
+    'browser_use_external',
+    'image_generation',
+    'in_app_browser',
+    'guardian_approval',
+    'tool_suggest',
+    'plugins'
+];
 export async function writeCodexConfigGuarded(input) {
     const configPath = path.resolve(input.configPath);
     const root = path.resolve(input.root || process.cwd());
@@ -513,6 +526,3 @@ async function recordCodexConfigGuard(root, reportPath, record) {
     }).catch(() => undefined);
     return file;
 }
-function escapeRegExp(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/core/codex/codex-config-toml.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { parse } from 'smol-toml';
+import { messageOf } from '../errors/message.js';
 export function parseCodexConfigToml(text = '') {
     return parse(String(text || ''));
 }
@@ -115,6 +116,3 @@ function ownedBackupTag(base, file) {
         return 'codex-app-ui-repair';
     return null;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-app/codex-agent-role-sync.js

@@ -4,6 +4,7 @@ import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { repairAgentRoleConfigs } from '../agents/agent-role-config.js';
 import { MANAGED_OFFICIAL_SUBAGENT_ROLES } from '../managed-assets/managed-assets-manifest.js';
 import { agentRolePayloadFor, probeCodexAgentTypeSupport } from './codex-agent-type-probe.js';
+import { messageOf } from '../errors/message.js';
 const OFFICIAL_ROLES = MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.codex_name);
 export async function syncCodexAgentRoles(input) {
     const root = path.resolve(input.root);
@@ -81,6 +82,3 @@ function stringList(value, key) {
         ? value[key].map(String).filter(Boolean)
         : [];
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-app/codex-app-fast-ui-repair.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { ensureDir, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { assertTestHomeWriteAllowed, ensureDir, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { codexHome, isSksOwnedGlobalUiLock, scanProjectLocalForbiddenKeys, snapshotCodexAppUiState } from './codex-app-ui-state-snapshot.js';
 import { assertCodexAppUiMutationAllowed } from './codex-app-ui-clobber-guard.js';
 import { codexProviderModelUiStatus } from '../codex-app.js';
@@ -11,6 +11,8 @@ const FAST_UI_LEGACY_TABLES = new Set(['user.fast_mode', 'profiles.sks-fast-high
 export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
     const resolvedRoot = path.resolve(root);
     const home = codexHome(input.codexHome === undefined ? {} : { codexHome: input.codexHome });
+    if (input.apply === true)
+        assertTestHomeWriteAllowed(path.join(home, 'config.toml'));
     const before = await snapshotCodexAppUiState(resolvedRoot, { codexHome: home });
     const candidates = [
         { scope: 'project', file: path.join(resolvedRoot, '.codex', 'config.toml'), mode: 'project_forbidden_keys' },
@@ -167,16 +169,27 @@ function stripProjectLocalForbiddenKeys(text) {
 function stripSksCausedHostOwnedLines(text) {
     const sourceLines = String(text || '').split(/\r?\n/);
     const preserveCodexLbSelection = hasActiveCodexLbProviderSelection(text);
+    const preserveOpenRouterSelection = hasActiveOpenRouterProviderSelection(text);
     const stripped = stripMatchingLines(text, (line, table, _previous, _next, index) => {
         const isLegacyFastTable = table ? FAST_UI_LEGACY_TABLES.has(table) : false;
         if (isLegacyFastTable)
             return true;
         if (!table && preserveCodexLbSelection && /^\s*model_provider\s*=\s*"codex-lb"\s*(?:#.*)?$/.test(line))
             return false;
+        if (!table && preserveOpenRouterSelection && /^\s*(?:model_provider\s*=\s*"openrouter"|model\s*=)/.test(line))
+            return false;
         return !table && FAST_UI_TOP_LEVEL_RE.test(line) && isSksOwnedGlobalUiLock(sourceLines, index);
     });
     return stripped;
 }
+function hasActiveOpenRouterProviderSelection(text) {
+    const source = String(text || '');
+    if (!/(?:^|\n)\s*model_provider\s*=\s*"openrouter"\s*(?:#.*)?(?=\n|$)/.test(source))
+        return false;
+    const body = source.match(/(?:^|\n)\[model_providers\.openrouter\]([^\n]*(?:\n(?!\s*\[)[^\n]*)*)/)?.[1] || '';
+    return /(?:^|\n)\s*base_url\s*=\s*"https:\/\/openrouter\.ai\/api\/v1"\s*(?:#.*)?(?=\n|$)/.test(body)
+        && /(?:^|\n)\s*wire_api\s*=\s*"responses"\s*(?:#.*)?(?=\n|$)/.test(body);
+}
 function hasActiveCodexLbProviderSelection(text) {
     const source = String(text || '');
     if (!/(?:^|\n)\s*model_provider\s*=\s*"codex-lb"\s*(?:#.*)?(?=\n|$)/.test(source))

package/dist/core/codex-app/codex-app-types.js

@@ -1,6 +1,5 @@
-export function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
+import { isRecord } from '../json/records.js';
+export { isRecord };
 export function stringList(value) {
     return Array.isArray(value) ? value.map((item) => String(item)).filter(Boolean) : [];
 }

package/dist/core/codex-app/codex-desktop-routing-ownership.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { isLoopbackHostname, resolveCatalogPath } from './multi-provider-router-support.js';
+import { defaultOpenCodexCatalogPath, readTopLevelTomlString } from './codex-model-catalog.js';
+const SKS_ROUTER_PROVIDER_ID = 'sks-router';
+const OPENROUTER_PROVIDER_ID = 'openrouter';
+export const OPENCODEX_INJECT_MARKER = 'Auto-injected by opencodex';
+export const OPENCODEX_DESIGN_B_FORCE_HINT = 'OpenCodex Design B currently owns openai_base_url loopback routing. Stop OpenCodex inject or re-run with --force-routing-override only if replacing that owner is intentional.';
+export function classifyCodexDesktopRouting(configText, input = {}) {
+    const text = String(configText || '');
+    const selectedProvider = readTopLevelTomlString(text, 'model_provider');
+    const selectedModel = readTopLevelTomlString(text, 'model');
+    const openaiBaseUrl = readTopLevelTomlString(text, 'openai_base_url');
+    const catalogPathRaw = readTopLevelTomlString(text, 'model_catalog_json');
+    const catalogResolved = catalogPathRaw
+        ? resolveCatalogPath(catalogPathRaw, input)
+        : null;
+    const defaultOpenCodexCatalog = path.resolve(defaultOpenCodexCatalogPath(input));
+    const catalogIsOpenCodexDefault = Boolean(catalogResolved && catalogResolved === defaultOpenCodexCatalog);
+    const markerPresent = text.includes(OPENCODEX_INJECT_MARKER);
+    const loopbackBase = openaiBaseUrl ? normalizeLoopbackOpenaiBaseUrl(openaiBaseUrl) : null;
+    const openaiBaseUrlLoopback = Boolean(loopbackBase);
+    const designB = Boolean(openaiBaseUrlLoopback
+        && (markerPresent || catalogIsOpenCodexDefault)
+        && (!selectedProvider || selectedProvider === 'openai'));
+    const blockers = [];
+    const warnings = [];
+    let classification = 'unconfigured';
+    if (selectedProvider === SKS_ROUTER_PROVIDER_ID)
+        classification = 'sks_router';
+    else if (selectedProvider === OPENROUTER_PROVIDER_ID)
+        classification = 'openrouter';
+    else if (selectedProvider === 'codex-lb')
+        classification = 'codex_lb';
+    else if (designB)
+        classification = 'opencodex_design_b';
+    else if (!selectedProvider || selectedProvider === 'openai')
+        classification = 'native_openai';
+    else
+        classification = 'external_conflict';
+    if (designB && selectedProvider && selectedProvider !== 'openai') {
+        classification = 'external_conflict';
+        blockers.push('opencodex_design_b_provider_conflict');
+    }
+    if (openaiBaseUrl && !openaiBaseUrlLoopback && selectedProvider === SKS_ROUTER_PROVIDER_ID) {
+        warnings.push('openai_base_url_present_with_sks_router');
+    }
+    if (designB) {
+        warnings.push('opencodex_design_b_routing_owner');
+    }
+    const sksRouterMayActivate = classification !== 'opencodex_design_b'
+        && classification !== 'external_conflict';
+    return {
+        schema: 'sks.codex-desktop-routing-ownership.v1',
+        classification,
+        selected_provider: selectedProvider,
+        selected_model: selectedModel,
+        openai_base_url: openaiBaseUrl,
+        openai_base_url_loopback: openaiBaseUrlLoopback,
+        opencodex_design_b: designB,
+        opencodex_marker_present: markerPresent,
+        catalog_path: catalogResolved,
+        catalog_is_opencodex_default: catalogIsOpenCodexDefault,
+        sks_router_may_activate: sksRouterMayActivate,
+        blockers,
+        warnings
+    };
+}
+export function opencodexDesignBBlocksRouterActivation(ownership, opts = {}) {
+    if (opts.forceRoutingOverride === true)
+        return null;
+    if (ownership.classification === 'opencodex_design_b' || ownership.opencodex_design_b) {
+        return 'opencodex_design_b_routing_owner';
+    }
+    return null;
+}
+function normalizeLoopbackOpenaiBaseUrl(value) {
+    try {
+        const parsed = new URL(String(value || '').trim());
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return null;
+        if (!isLoopbackHostname(parsed.hostname))
+            return null;
+        const normalizedPath = parsed.pathname.replace(/\/+$/, '') || '';
+        if (normalizedPath && normalizedPath !== '/v1')
+            return null;
+        return parsed.toString().replace(/\/$/, '');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/codex-app/codex-hook-approval-probe.js

@@ -3,6 +3,7 @@ import { findCodexBinary } from '../codex-adapter.js';
 import { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
 import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
 import { isRecord } from './codex-app-types.js';
+import { messageOf } from '../errors/message.js';
 export async function probeCodexHookApprovalState(root, input = {}) {
     const env = input.env || process.env;
     const sources = [];
@@ -182,6 +183,3 @@ async function persist(root, report, writeReport) {
         await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-hook-approval-probe.json'), report).catch(() => undefined);
     return report;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/core/codex-app/codex-hook-lifecycle.js

@@ -3,6 +3,7 @@ import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { readCodexHookActualState } from '../codex-hooks/codex-hook-actual-discovery.js';
 import { installManagedCodexHooks } from '../codex-hooks/codex-hook-managed-install.js';
 import { probeCodexHookApprovalState } from './codex-hook-approval-probe.js';
+import { messageOf } from '../errors/message.js';
 export async function buildCodexHookLifecycle(input = {}) {
     const root = path.resolve(input.root || process.cwd());
     const install = input.apply === true
@@ -58,6 +59,3 @@ export async function buildCodexHookLifecycle(input = {}) {
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'codex-hook-lifecycle.json'), report).catch(() => undefined);
     return report;
 }
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}