sneakoscope 7.3.0 → 7.6.0

package/dist/core/triwiki/context-graph/extractors/topology/commands.js

@@ -0,0 +1,207 @@
+import { COMMAND_ALIASES_LITE, COMMAND_MANIFEST_LITE, LEGACY_COMMAND_ALIASES_LITE } from '../../../../../cli/command-manifest-lite.js';
+import { contextGraphNodeId } from '../../ids.js';
+import { addEdge, addNode, asRecord, ensureFileNode, estimateTokenCost, isCanonicalId, mapIdentifierLines, readStringField, readWorkspaceText, recordSkip, topologyLintError } from './shared.js';
+export const TOPOLOGY_COMMAND_MANIFEST_PATH = 'src/cli/command-manifest-lite.ts';
+export const TOPOLOGY_RUNTIME_SCRIPTS_PATH = 'runtime-required-scripts.json';
+const RUNTIME_SCRIPTS_SCHEMA = 'sks.runtime-required-scripts.v1';
+const COMMAND_NAME_LINE = /\{\s*name:\s*'([^']+)'/;
+const EMPTY_RUNTIME_MANIFEST = {
+    present: false,
+    path: TOPOLOGY_RUNTIME_SCRIPTS_PATH,
+    hash: '',
+    sources: new Set()
+};
+export function collectRuntimeManifest(ctx) {
+    const read = readWorkspaceText(ctx, TOPOLOGY_RUNTIME_SCRIPTS_PATH);
+    if (!read)
+        return EMPTY_RUNTIME_MANIFEST;
+    let parsed;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        topologyLintError(ctx, 'invalid_node_field', `${TOPOLOGY_RUNTIME_SCRIPTS_PATH} is not valid JSON`, {
+            path: TOPOLOGY_RUNTIME_SCRIPTS_PATH
+        });
+        return EMPTY_RUNTIME_MANIFEST;
+    }
+    const root = asRecord(parsed);
+    if (!root || readStringField(root, 'schema') !== RUNTIME_SCRIPTS_SCHEMA) {
+        topologyLintError(ctx, 'invalid_node_field', `${TOPOLOGY_RUNTIME_SCRIPTS_PATH} does not declare ${RUNTIME_SCRIPTS_SCHEMA}`, { path: TOPOLOGY_RUNTIME_SCRIPTS_PATH });
+        return EMPTY_RUNTIME_MANIFEST;
+    }
+    const sources = new Set();
+    const scripts = Array.isArray(root.scripts) ? root.scripts : [];
+    for (const raw of scripts) {
+        const entry = asRecord(raw);
+        if (!entry)
+            continue;
+        const mapped = mapDistPathToSource(readStringField(entry, 'path'));
+        if (!mapped || !ctx.files.set.has(mapped))
+            continue;
+        ctx.fileClassification.set(mapped, readStringField(entry, 'category') || 'installed_runtime');
+        sources.add(mapped);
+    }
+    const policies = Array.isArray(root.reference_source_policies) ? root.reference_source_policies : [];
+    for (const raw of policies) {
+        const entry = asRecord(raw);
+        if (!entry)
+            continue;
+        const source = readStringField(entry, 'source').split('#')[0] ?? '';
+        if (!source || source.includes('*') || source.startsWith('dist/'))
+            continue;
+        if (!ctx.files.set.has(source))
+            continue;
+        ctx.fileClassification.set(source, readStringField(entry, 'classification') || 'unclassified');
+        sources.add(source);
+    }
+    return { present: true, path: TOPOLOGY_RUNTIME_SCRIPTS_PATH, hash: read.hash, sources };
+}
+function mapDistPathToSource(value) {
+    if (!value.startsWith('dist/') || value.includes('..'))
+        return null;
+    return `src/${value.slice('dist/'.length).replace(/\.(js|mjs|cjs)$/, '.ts')}`;
+}
+export function commandHandlerCandidates(name) {
+    return [
+        `src/commands/${name}.ts`,
+        `src/core/commands/${name}-command.ts`,
+        `src/cli/${name}-command.ts`,
+        `src/cli/${name}.ts`
+    ];
+}
+const RISK_BY_LEVEL = { R0: 'low', R1: 'medium', R2: 'medium', R3: 'high' };
+export function commandNodeIdFor(name) {
+    return contextGraphNodeId({ kind: 'command', name });
+}
+function commandAliasMap() {
+    return {
+        ...LEGACY_COMMAND_ALIASES_LITE,
+        ...COMMAND_ALIASES_LITE
+    };
+}
+export function canonicalCommandName(candidate) {
+    const raw = String(candidate ?? '').trim();
+    if (!raw)
+        return null;
+    const resolved = commandAliasMap()[raw] ?? raw;
+    return COMMAND_MANIFEST_LITE.some((entry) => entry.name === resolved) ? resolved : null;
+}
+export function buildCommandGraph(ctx, runtime, presets) {
+    const read = readWorkspaceText(ctx, TOPOLOGY_COMMAND_MANIFEST_PATH);
+    if (!read)
+        return { present: false, path: TOPOLOGY_COMMAND_MANIFEST_PATH, hash: '' };
+    const lines = mapIdentifierLines(read.text, COMMAND_NAME_LINE);
+    const aliasesByCommand = groupAliases();
+    for (const entry of COMMAND_MANIFEST_LITE) {
+        const nodeId = commandNodeIdFor(entry.name);
+        if (!isCanonicalId('command', entry.name, nodeId)) {
+            topologyLintError(ctx, 'invalid_node_field', `command "${entry.name}" is not a canonical command id`, {
+                path: TOPOLOGY_COMMAND_MANIFEST_PATH
+            });
+            continue;
+        }
+        const line = lines.get(entry.name);
+        const metadata = {
+            source: 'command-manifest-lite',
+            commandName: entry.name,
+            summary: entry.summary,
+            maturity: entry.maturity,
+            riskLevel: entry.risk,
+            latency: entry.latency,
+            inputProfile: entry.inputProfile,
+            supportsJson: entry.supportsJson,
+            remoteAllowed: entry.remoteAllowed,
+            telegramAllowed: entry.telegramAllowed,
+            readonlyCommand: entry.readonly === true,
+            diagnostic: entry.diagnostic === true,
+            deprecated: entry.deprecated === true,
+            hidden: entry.hidden === true,
+            mutatesRouteState: entry.mutatesRouteState === true,
+            requiredCapabilities: [...entry.requiredCapabilities],
+            aliases: aliasesByCommand.get(entry.name) ?? []
+        };
+        addNode(ctx, {
+            id: nodeId,
+            kind: 'command',
+            label: entry.name,
+            path: TOPOLOGY_COMMAND_MANIFEST_PATH,
+            line,
+            contentHash: read.hash,
+            trust: 0.95,
+            risk: RISK_BY_LEVEL[entry.risk] ?? 'medium',
+            tokenCost: estimateTokenCost([entry.name, entry.summary]),
+            metadata,
+            sourcePath: TOPOLOGY_COMMAND_MANIFEST_PATH
+        });
+        let handlers = 0;
+        for (const candidate of commandHandlerCandidates(entry.name)) {
+            if (!ctx.files.set.has(candidate))
+                continue;
+            const fileId = ensureFileNode(ctx, candidate, 'command_handler', TOPOLOGY_COMMAND_MANIFEST_PATH);
+            if (!fileId)
+                continue;
+            const declared = runtime.present && runtime.sources.has(candidate);
+            const confidence = declared ? 'manifest' : 'derived';
+            const added = addEdge(ctx, {
+                from: nodeId,
+                to: fileId,
+                type: 'routes_to',
+                confidence,
+                path: declared ? runtime.path : TOPOLOGY_COMMAND_MANIFEST_PATH,
+                hash: declared ? runtime.hash : read.hash,
+                ...(declared ? {} : { line })
+            });
+            if (added)
+                handlers += 1;
+            if (declared) {
+                addEdge(ctx, {
+                    from: nodeId,
+                    to: fileId,
+                    type: 'owns',
+                    confidence: 'manifest',
+                    path: runtime.path,
+                    hash: runtime.hash
+                });
+            }
+        }
+        if (!handlers) {
+            recordSkip(ctx, TOPOLOGY_COMMAND_MANIFEST_PATH, 'excluded', `command ${entry.name} has no conventional handler file in this workspace`);
+        }
+    }
+    linkCommandsToPresetPipelines(ctx, presets);
+    return { present: true, path: TOPOLOGY_COMMAND_MANIFEST_PATH, hash: read.hash };
+}
+function groupAliases() {
+    const out = new Map();
+    const aliases = commandAliasMap();
+    for (const alias of Object.keys(aliases).sort()) {
+        const target = aliases[alias];
+        if (!target)
+            continue;
+        const bucket = out.get(target);
+        if (bucket)
+            bucket.push(alias);
+        else
+            out.set(target, [alias]);
+    }
+    return out;
+}
+function linkCommandsToPresetPipelines(ctx, presets) {
+    for (const preset of presets) {
+        const name = canonicalCommandName(preset.preset);
+        if (!name)
+            continue;
+        const commandId = commandNodeIdFor(name);
+        if (!ctx.nodes.has(commandId))
+            continue;
+        addEdge(ctx, {
+            from: commandId,
+            to: preset.pipelineId,
+            type: 'routes_to',
+            confidence: 'derived',
+            path: preset.manifestPath,
+            hash: preset.manifestHash
+        });
+    }
+}

package/dist/core/triwiki/context-graph/extractors/topology/gate-edges.js

@@ -0,0 +1,201 @@
+import { computeStronglyConnectedComponents } from '../../graph-index.js';
+import { contextGraphNodeId } from '../../ids.js';
+import { gateCheckCandidates, gateDependentIds, isProtectedGate } from './gates.js';
+import { expandGlob, isGlobPattern } from './globs.js';
+import { TOPOLOGY_GATE_AFFECTED_CAP, TOPOLOGY_GATE_VERIFIED_CAP, TOPOLOGY_GLOB_MATCH_CAP, addEdge, addNode, ensureFileNode, estimateTokenCost, recordSkip, topologyLintError } from './shared.js';
+export function buildGateDependencyEdges(ctx, gates) {
+    const byId = new Map(gates.map((gate) => [gate.id, gate]));
+    const adjacency = new Map();
+    for (const gate of gates) {
+        const resolved = [];
+        for (const dep of [...gate.deps].sort()) {
+            if (dep === gate.id) {
+                topologyLintError(ctx, 'manifest_dag_cycle', `gate ${gate.id} depends on itself`, {
+                    nodeId: gate.nodeId,
+                    path: gate.manifestPath
+                });
+                continue;
+            }
+            const target = byId.get(dep);
+            if (!target) {
+                topologyLintError(ctx, 'dangling_edge', `gate ${gate.id} depends on unknown gate ${dep}`, {
+                    nodeId: gate.nodeId,
+                    path: gate.manifestPath
+                });
+                continue;
+            }
+            const added = addEdge(ctx, {
+                from: gate.nodeId,
+                to: target.nodeId,
+                type: 'depends_on',
+                confidence: 'manifest',
+                path: gate.manifestPath,
+                hash: gate.manifestHash,
+                line: gate.line
+            });
+            if (added)
+                resolved.push({ to: target.nodeId });
+        }
+        adjacency.set(gate.nodeId, resolved);
+    }
+    const components = computeStronglyConnectedComponents(gates.map((gate) => gate.nodeId), (nodeId) => adjacency.get(nodeId) ?? []);
+    for (const component of components) {
+        topologyLintError(ctx, 'manifest_dag_cycle', `gate dependency cycle: ${component.join(' -> ')}`, {
+            nodeId: component[0] ?? '',
+            path: gates[0]?.manifestPath ?? ''
+        });
+    }
+}
+export function buildGateVerificationEdges(ctx, gates) {
+    const verified = new Set();
+    for (const gate of gates) {
+        let emitted = 0;
+        for (const candidate of gateCheckCandidates(gate.command)) {
+            if (emitted >= TOPOLOGY_GATE_VERIFIED_CAP)
+                break;
+            const expansion = expandGlob(ctx.files, candidate, TOPOLOGY_GLOB_MATCH_CAP);
+            if (expansion.capped) {
+                recordSkip(ctx, gate.manifestPath, 'cap_reached', `check pattern ${candidate} matched ${expansion.total} files`);
+                continue;
+            }
+            if (!expansion.matches.length) {
+                recordSkip(ctx, gate.manifestPath, 'excluded', `check implementation ${candidate} is not in this workspace`);
+                continue;
+            }
+            const confidence = isGlobPattern(candidate) ? 'derived' : 'manifest';
+            for (const match of expansion.matches) {
+                if (emitted >= TOPOLOGY_GATE_VERIFIED_CAP)
+                    break;
+                const fileId = ensureFileNode(ctx, match, 'gate_check', gate.manifestPath);
+                if (!fileId)
+                    continue;
+                const added = addEdge(ctx, {
+                    from: gate.nodeId,
+                    to: fileId,
+                    type: 'verified_by',
+                    confidence,
+                    path: gate.manifestPath,
+                    hash: gate.manifestHash,
+                    line: gate.line
+                });
+                if (added) {
+                    emitted += 1;
+                    verified.add(gate.id);
+                }
+            }
+        }
+    }
+    return verified;
+}
+export function buildGateAffectedEdges(ctx, gates) {
+    const affected = new Set();
+    for (const gate of gates) {
+        let emitted = 0;
+        const seen = new Set();
+        for (const input of gate.cacheInputs) {
+            if (emitted >= TOPOLOGY_GATE_AFFECTED_CAP)
+                break;
+            const expansion = expandGlob(ctx.files, input, TOPOLOGY_GLOB_MATCH_CAP);
+            if (expansion.capped) {
+                recordSkip(ctx, gate.manifestPath, 'cap_reached', `cache input ${input} matched ${expansion.total} files`);
+                continue;
+            }
+            for (const match of expansion.matches) {
+                if (emitted >= TOPOLOGY_GATE_AFFECTED_CAP)
+                    break;
+                if (seen.has(match))
+                    continue;
+                seen.add(match);
+                const fileId = ensureFileNode(ctx, match, 'gate_cache_input', gate.manifestPath);
+                if (!fileId)
+                    continue;
+                const added = addEdge(ctx, {
+                    from: gate.nodeId,
+                    to: fileId,
+                    type: 'affected_by',
+                    confidence: 'derived',
+                    path: gate.manifestPath,
+                    hash: gate.manifestHash,
+                    line: gate.line
+                });
+                if (added) {
+                    emitted += 1;
+                    affected.add(gate.id);
+                }
+            }
+        }
+    }
+    return affected;
+}
+export function reportUnbackedProtectedGates(ctx, gates, verified, affected) {
+    const dependedOn = gateDependentIds(gates);
+    for (const gate of gates) {
+        if (!isProtectedGate(gate.id, dependedOn))
+            continue;
+        if (verified.has(gate.id) || affected.has(gate.id))
+            continue;
+        topologyLintError(ctx, 'protected_gate_without_source_relation', `protected gate ${gate.id} has no check implementation and no cache input inside this workspace`, { nodeId: gate.nodeId, path: gate.manifestPath });
+    }
+}
+export function buildGatePresetPipelines(ctx, gates) {
+    const byPreset = new Map();
+    for (const gate of gates) {
+        for (const preset of gate.presets) {
+            const bucket = byPreset.get(preset);
+            if (bucket)
+                bucket.push(gate);
+            else
+                byPreset.set(preset, [gate]);
+        }
+    }
+    const dependedOn = gateDependentIds(gates);
+    const pipelines = [];
+    for (const preset of [...byPreset.keys()].sort()) {
+        const members = byPreset.get(preset) ?? [];
+        const first = members[0];
+        if (!first)
+            continue;
+        const pipelineId = contextGraphNodeId({ kind: 'pipeline', pipelineId: `gates:${preset}` });
+        const metadata = {
+            source: 'gate-manifest',
+            pipelineKind: 'gate_preset',
+            preset,
+            manifest: first.manifestPath,
+            gateCount: members.length,
+            protectedGateCount: members.filter((gate) => isProtectedGate(gate.id, dependedOn)).length
+        };
+        const added = addNode(ctx, {
+            id: pipelineId,
+            kind: 'pipeline',
+            label: `gates:${preset}`,
+            path: first.manifestPath,
+            contentHash: first.manifestHash,
+            trust: 0.95,
+            risk: preset === 'release' ? 'protected' : 'high',
+            tokenCost: estimateTokenCost([preset, String(members.length)]),
+            metadata,
+            sourcePath: first.manifestPath
+        });
+        if (!added)
+            continue;
+        for (const gate of members) {
+            addEdge(ctx, {
+                from: pipelineId,
+                to: gate.nodeId,
+                type: 'gated_by',
+                confidence: 'manifest',
+                path: gate.manifestPath,
+                hash: gate.manifestHash,
+                line: gate.line
+            });
+        }
+        pipelines.push({
+            preset,
+            pipelineId,
+            manifestPath: first.manifestPath,
+            manifestHash: first.manifestHash,
+            gateCount: members.length
+        });
+    }
+    return pipelines;
+}

package/dist/core/triwiki/context-graph/extractors/topology/gates.js

@@ -0,0 +1,182 @@
+import { ALWAYS_ON_GATES, FORBIDDEN_RECURSIVE_GATES, REQUIRED_FOR_PUBLISH } from '../../../../release/gate-manifest.js';
+import { contextGraphNodeId } from '../../ids.js';
+import { addNode, asRecord, estimateTokenCost, isCanonicalId, mapIdentifierLines, readNumberField, readStringArrayField, readStringField, readWorkspaceText, recordSkip, topologyLintError } from './shared.js';
+export const TOPOLOGY_GATE_MANIFESTS = [
+    { path: 'release-gates.v2.json', schemas: ['sks.release-gates.v2'] },
+    { path: 'infra-harness-gates.json', schemas: ['sks.infra-harness-gates.v1'] }
+];
+export const TOPOLOGY_PROTECTED_NAMESPACES = new Set([
+    'release',
+    'publish',
+    'security',
+    'secret',
+    'prepublish'
+]);
+const GATE_ID_LINE = /"id"\s*:\s*"([^"]+)"/;
+export function collectTopologyGates(ctx) {
+    const gates = [];
+    const seen = new Map();
+    for (const manifest of TOPOLOGY_GATE_MANIFESTS) {
+        const read = readWorkspaceText(ctx, manifest.path);
+        if (!read)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(read.text);
+        }
+        catch {
+            topologyLintError(ctx, 'invalid_node_field', `${manifest.path} is not valid JSON`, { path: manifest.path });
+            continue;
+        }
+        const root = asRecord(parsed);
+        if (!root) {
+            topologyLintError(ctx, 'invalid_node_field', `${manifest.path} is not a gate manifest object`, { path: manifest.path });
+            continue;
+        }
+        const schema = readStringField(root, 'schema');
+        if (!manifest.schemas.includes(schema)) {
+            topologyLintError(ctx, 'invalid_node_field', `${manifest.path} declares schema "${schema}" instead of ${manifest.schemas.join(' | ')}`, { path: manifest.path });
+            continue;
+        }
+        const rawGates = root.gates;
+        if (!Array.isArray(rawGates)) {
+            topologyLintError(ctx, 'invalid_node_field', `${manifest.path} has no gates array`, { path: manifest.path });
+            continue;
+        }
+        const lines = mapIdentifierLines(read.text, GATE_ID_LINE);
+        for (const [index, rawGate] of rawGates.entries()) {
+            const entry = asRecord(rawGate);
+            if (!entry) {
+                topologyLintError(ctx, 'invalid_node_field', `${manifest.path} gate[${index}] is not an object`, { path: manifest.path });
+                continue;
+            }
+            const id = readStringField(entry, 'id').trim();
+            if (!id) {
+                topologyLintError(ctx, 'invalid_node_field', `${manifest.path} gate[${index}] has no id`, { path: manifest.path });
+                continue;
+            }
+            const nodeId = contextGraphNodeId({ kind: 'gate', gateId: id });
+            if (!isCanonicalId('gate', id, nodeId)) {
+                topologyLintError(ctx, 'invalid_node_field', `${manifest.path} gate id "${id}" is not a canonical gate id`, {
+                    path: manifest.path
+                });
+                continue;
+            }
+            const previous = seen.get(id);
+            if (previous) {
+                topologyLintError(ctx, 'duplicate_node_conflict', `gate ${id} is declared in both ${previous} and ${manifest.path}`, {
+                    nodeId,
+                    path: manifest.path
+                });
+                continue;
+            }
+            seen.set(id, manifest.path);
+            const cache = asRecord(entry.cache);
+            gates.push({
+                id,
+                nodeId,
+                manifestPath: manifest.path,
+                manifestHash: read.hash,
+                line: lines.get(id),
+                command: readStringField(entry, 'command'),
+                deps: readStringArrayField(entry, 'deps'),
+                cacheInputs: cache ? readStringArrayField(cache, 'inputs') : [],
+                cacheEnabled: cache ? cache.enabled === true : false,
+                presets: readStringArrayField(entry, 'preset'),
+                sideEffect: readStringField(entry, 'side_effect'),
+                resource: readStringArrayField(entry, 'resource'),
+                timeoutMs: readNumberField(entry, 'timeout_ms'),
+                outputContract: readStringField(entry, 'output_contract'),
+                declaredProtected: entry.protected === true
+            });
+        }
+    }
+    gates.sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+    return gates;
+}
+export function gateDependentIds(gates) {
+    const dependedOn = new Set();
+    for (const gate of gates)
+        for (const dep of gate.deps)
+            dependedOn.add(dep);
+    return dependedOn;
+}
+export function isProtectedGate(id, dependedOn, declaredProtected = false) {
+    if (declaredProtected)
+        return true;
+    if (REQUIRED_FOR_PUBLISH.has(id) || ALWAYS_ON_GATES.has(id) || FORBIDDEN_RECURSIVE_GATES.has(id))
+        return true;
+    if (dependedOn.has(id))
+        return true;
+    return TOPOLOGY_PROTECTED_NAMESPACES.has(id.split(':')[0] ?? '');
+}
+function gateRisk(gate, dependedOn) {
+    if (isProtectedGate(gate.id, dependedOn, gate.declaredProtected))
+        return 'protected';
+    return gate.sideEffect === 'hermetic' ? 'medium' : 'high';
+}
+export function gateCheckCandidates(command) {
+    const out = [];
+    for (const token of String(command ?? '').split(/\s+/)) {
+        const cleaned = token.replace(/^['"]|['"]$/g, '').replace(/^\.\//, '');
+        if (!/\.(js|mjs|cjs)$/.test(cleaned))
+            continue;
+        if (cleaned.startsWith('node_modules/'))
+            continue;
+        if (cleaned.startsWith('/') || cleaned.startsWith('~') || /^[A-Za-z]:/.test(cleaned))
+            continue;
+        if (cleaned.includes('..'))
+            continue;
+        const mapped = cleaned.startsWith('dist/')
+            ? `src/${cleaned.slice('dist/'.length).replace(/\.(js|mjs|cjs)$/, '.ts')}`
+            : cleaned;
+        if (!out.includes(mapped))
+            out.push(mapped);
+    }
+    return out;
+}
+export function buildGateNodes(ctx, gates) {
+    const dependedOn = gateDependentIds(gates);
+    for (const gate of gates) {
+        const metadata = {
+            source: 'gate-manifest',
+            manifest: gate.manifestPath,
+            gateId: gate.id,
+            namespace: gate.id.split(':')[0] ?? '',
+            deps: [...gate.deps],
+            presets: [...gate.presets],
+            resource: [...gate.resource],
+            sideEffect: gate.sideEffect,
+            timeoutMs: gate.timeoutMs,
+            cacheEnabled: gate.cacheEnabled,
+            cacheInputs: [...gate.cacheInputs],
+            checkScripts: gateCheckCandidates(gate.command),
+            outputContract: gate.outputContract,
+            requiredForPublish: REQUIRED_FOR_PUBLISH.has(gate.id),
+            alwaysOnRelease: ALWAYS_ON_GATES.has(gate.id),
+            nonRecursive: FORBIDDEN_RECURSIVE_GATES.has(gate.id),
+            hasDependents: dependedOn.has(gate.id),
+            declaredProtected: gate.declaredProtected
+        };
+        addNode(ctx, {
+            id: gate.nodeId,
+            kind: 'gate',
+            label: gate.id,
+            path: gate.manifestPath,
+            line: gate.line,
+            contentHash: gate.manifestHash,
+            trust: 0.95,
+            risk: gateRisk(gate, dependedOn),
+            tokenCost: estimateTokenCost([gate.id, gate.sideEffect, gate.cacheInputs.join(' ')]),
+            metadata,
+            sourcePath: gate.manifestPath
+        });
+    }
+    if (!gates.length) {
+        for (const manifest of TOPOLOGY_GATE_MANIFESTS) {
+            if (ctx.inputHashes[manifest.path] === undefined)
+                continue;
+            recordSkip(ctx, manifest.path, 'excluded', 'manifest declared no usable gates');
+        }
+    }
+}