sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,172 @@
+#!/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 non-speed 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 init = await importDist('core/init.js');
+const context7 = await importDist('cli/context7-command.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 without forcing fast service tier ---
+{
+    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 topLevel = String(after).split(/\n\s*\[/)[0] || '';
+    const ok = res.status === 'updated' && /^model = "gpt-5\.5"/m.test(topLevel) && !/^service_tier = "fast"/m.test(topLevel) && /\[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 });
+}
+// --- Case 5: project Context7 setup preserves user API key args/env instead of resetting the block ---
+{
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-context7-project-'));
+    const cfg = path.join(dir, '.codex', 'config.toml');
+    await fs.mkdir(path.dirname(cfg), { recursive: true });
+    const userConfig = [
+        '[mcp_servers.context7]',
+        'command = "npx"',
+        'args = ["-y", "@upstash/context7-mcp@latest", "--api-key", "ctx7-user-key"]',
+        '',
+        '[mcp_servers.context7.env]',
+        'CONTEXT7_API_KEY = "ctx7-user-key"',
+        ''
+    ].join('\n');
+    await fs.writeFile(cfg, userConfig);
+    const changed = await helpers.ensureProjectContext7Config(dir, 'local');
+    const after = await fs.readFile(cfg, 'utf8');
+    const ok = changed === false && after === userConfig;
+    results.push({ case: 'context7_project_setup_preserves_existing_key_block', ok, changed });
+}
+// --- Case 6: setup/init regeneration preserves an existing Context7 block with custom credentials ---
+{
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-context7-init-'));
+    const cfg = path.join(dir, '.codex', 'config.toml');
+    await fs.mkdir(path.dirname(cfg), { recursive: true });
+    const customBlock = [
+        '[mcp_servers.context7]',
+        'url = "https://mcp.context7.com/mcp"',
+        'headers = { CONTEXT7_API_KEY = "ctx7-user-key" }',
+        ''
+    ].join('\n');
+    await fs.writeFile(cfg, customBlock);
+    await init.initProject(dir, { installScope: 'global' });
+    const after = await fs.readFile(cfg, 'utf8');
+    const ok = /\[mcp_servers\.context7\]\nurl = "https:\/\/mcp\.context7\.com\/mcp"\nheaders = \{ CONTEXT7_API_KEY = "ctx7-user-key" \}/.test(after)
+        && !/args = \["-y", "@upstash\/context7-mcp@latest"\]/.test(after);
+    results.push({ case: 'context7_init_preserves_existing_key_block', ok });
+}
+// --- Case 7: global Context7 setup skips `codex mcp add` when context7 already exists ---
+{
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-context7-global-'));
+    const binDir = path.join(dir, 'bin');
+    await fs.mkdir(binDir, { recursive: true });
+    const fakeCodex = path.join(binDir, process.platform === 'win32' ? 'codex.cmd' : 'codex');
+    const log = path.join(dir, 'codex.log');
+    await fs.writeFile(fakeCodex, [
+        '#!/bin/sh',
+        `printf '%s\\n' "$*" >> ${JSON.stringify(log)}`,
+        'if [ "$1" = "--version" ]; then echo "codex-cli 99.0.0"; exit 0; fi',
+        'if [ "$1" = "mcp" ] && [ "$2" = "list" ]; then echo "context7  configured"; exit 0; fi',
+        'if [ "$1" = "mcp" ] && [ "$2" = "add" ]; then echo "unexpected mcp add" >&2; exit 77; fi',
+        'echo "unexpected codex $*" >&2',
+        'exit 2',
+        ''
+    ].join('\n'));
+    await fs.chmod(fakeCodex, 0o755);
+    const previous = {
+        SKS_CODEX_BIN: process.env.SKS_CODEX_BIN,
+        CODEX_BIN: process.env.CODEX_BIN
+    };
+    process.env.SKS_CODEX_BIN = fakeCodex;
+    delete process.env.CODEX_BIN;
+    const previousConsoleLog = console.log;
+    try {
+        console.log = () => { };
+        await context7.context7Command('setup', ['--scope', 'global', '--json']);
+    }
+    finally {
+        console.log = previousConsoleLog;
+        if (previous.SKS_CODEX_BIN === undefined)
+            delete process.env.SKS_CODEX_BIN;
+        else
+            process.env.SKS_CODEX_BIN = previous.SKS_CODEX_BIN;
+        if (previous.CODEX_BIN === undefined)
+            delete process.env.CODEX_BIN;
+        else
+            process.env.CODEX_BIN = previous.CODEX_BIN;
+    }
+    const calls = await fs.readFile(log, 'utf8');
+    const ok = /--version/.test(calls) && /mcp list/.test(calls) && !/mcp add/.test(calls);
+    results.push({ case: 'context7_global_setup_preserves_existing_entry', ok, calls: calls.trim().split(/\n+/) });
+}
+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

@@ -0,0 +1,78 @@
+#!/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-gate-inventory-check.js

@@ -0,0 +1,49 @@
+import { assertGate, emitGate, readJson, readText } from './sks-1-18-gate-lib.js';
+const gates = (readJson('release-gates.v2.json').gates || []);
+const migration = readText('docs/sks-4-migration.md');
+const allowlist = parseAllowlist(migration);
+const legacy = gates
+    .filter((gate) => gate.preset?.includes('release'))
+    .filter((gate) => removableLegacy(gate.id, gate.command))
+    .filter((gate) => !isAllowed(gate.id, allowlist));
+assertGate(migration.includes('Removed runtime migration') && migration.includes('No silent legacy fallback'), 'migration doc must record legacy purge policy');
+assertGate(legacy.length === 0, 'removable legacy gates must be removed or documented with a non-expired structured allowlist', legacy.slice(0, 30));
+emitGate('legacy:gate-inventory', { legacy_candidates: legacy.length, allowlist: allowlist.length });
+function removableLegacy(id, command) {
+    const surface = `${id} ${command}`;
+    return /^team:/.test(id)
+        || /^legacy:upgrade-zero-break$/.test(id)
+        || /(^|:)tmux($|:|-)/.test(surface)
+        || /^codex:0\.135/.test(id)
+        || /^codex:0\.136/.test(id)
+        || /codex[:.-]?0139/.test(id)
+        || /codex-0139/.test(command);
+}
+function parseAllowlist(text) {
+    return [...text.matchAll(/<!--\s*sks-legacy-allowlist\s*([\s\S]*?)-->/g)].map((match) => {
+        const body = match[1] || '';
+        return {
+            id: field(body, 'id'),
+            reason: field(body, 'reason'),
+            owner: field(body, 'owner'),
+            expires: field(body, 'expires')
+        };
+    }).filter((row) => row.id && row.reason && row.owner && compareVersion(row.expires, '4.0.2') > 0);
+}
+function isAllowed(id, allowlist) {
+    return allowlist.some((row) => row.id.endsWith('*') ? id.startsWith(row.id.slice(0, -1)) : row.id === id);
+}
+function field(body, name) {
+    return body.match(new RegExp(`^${name}:\\s*(.+)$`, 'm'))?.[1]?.trim() || '';
+}
+function compareVersion(a, b) {
+    const left = a.split('.').map(Number);
+    const right = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+        const delta = (left[i] || 0) - (right[i] || 0);
+        if (delta !== 0)
+            return delta;
+    }
+    return 0;
+}
+//# sourceMappingURL=legacy-gate-inventory-check.js.map

package/dist/scripts/legacy-gate-purge-check.js

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const registry = readText('src/cli/command-registry.ts');
+assertGate(!registry.includes("auth: '") && !registry.includes("dollars: '"), 'legacy compatibility aliases must be purged from command registry');
+assertGate(registry.includes('tmux') && registry.includes('removed-runtime migration notice'), 'tmux command must be explicit removed-runtime notice only');
+emitGate('legacy:gate-purge');
+//# sourceMappingURL=legacy-gate-purge-check.js.map

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

@@ -0,0 +1,85 @@
+#!/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

package/dist/scripts/legacy-purge-final-check.js

@@ -0,0 +1,5 @@
+import './legacy-gate-inventory-check.js';
+import './legacy-strong-inventory-check.js';
+import { emitGate } from './sks-1-18-gate-lib.js';
+emitGate('legacy:purge-final');
+//# sourceMappingURL=legacy-purge-final-check.js.map

package/dist/scripts/legacy-strong-inventory-check.js

@@ -0,0 +1,43 @@
+import { assertGate, emitGate, importDist, readJson, readText, root } from './sks-1-18-gate-lib.js';
+const impactMod = await importDist('core/triwiki/triwiki-gate-impact-map.js');
+const map = impactMod.buildTriWikiGateImpactMap(root);
+const migration = readText('docs/sks-4-migration.md');
+const allowlist = parseAllowlist(migration);
+const gates = (readJson('release-gates.v2.json').gates || []);
+const legacyOrphans = map.impacts.filter((impact) => impact.orphan && removableLegacy(impact.gate_id, ''));
+const legacyPresent = gates.filter((gate) => gate.preset?.includes('release') && removableLegacy(gate.id, gate.command) && !isAllowed(gate.id, allowlist));
+assertGate(legacyOrphans.length === 0 && legacyPresent.length === 0, 'removable legacy gates must not remain unless covered by a non-expired structured allowlist', { legacyOrphans, legacyPresent: legacyPresent.slice(0, 30), allowlist });
+emitGate('legacy:strong-inventory', { legacy_orphans: legacyOrphans.length, legacy_present: legacyPresent.length, allowlist: allowlist.length });
+function removableLegacy(id, command) {
+    const surface = `${id} ${command}`;
+    return /^team:/.test(id)
+        || /^legacy:upgrade-zero-break$/.test(id)
+        || /(^|:)tmux($|:|-)/.test(surface)
+        || /^codex:0\.135/.test(id)
+        || /^codex:0\.136/.test(id)
+        || /codex[:.-]?0139/.test(id)
+        || /codex-0139/.test(command);
+}
+function parseAllowlist(text) {
+    return [...text.matchAll(/<!--\s*sks-legacy-allowlist\s*([\s\S]*?)-->/g)].map((match) => {
+        const body = match[1] || '';
+        return { id: field(body, 'id'), reason: field(body, 'reason'), owner: field(body, 'owner'), expires: field(body, 'expires') };
+    }).filter((row) => row.id && row.reason && row.owner && compareVersion(row.expires, '4.0.2') > 0);
+}
+function isAllowed(id, allowlist) {
+    return allowlist.some((row) => row.id.endsWith('*') ? id.startsWith(row.id.slice(0, -1)) : row.id === id);
+}
+function field(body, name) {
+    return body.match(new RegExp(`^${name}:\\s*(.+)$`, 'm'))?.[1]?.trim() || '';
+}
+function compareVersion(a, b) {
+    const left = a.split('.').map(Number);
+    const right = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+        const delta = (left[i] || 0) - (right[i] || 0);
+        if (delta !== 0)
+            return delta;
+    }
+    return 0;
+}
+//# sourceMappingURL=legacy-strong-inventory-check.js.map