sneakoscope 7.3.0 → 7.6.0

package/dist/core/triwiki/context-graph/graph-index.js

@@ -0,0 +1,143 @@
+import { contextGraphPathFromId } from './ids.js';
+function push(map, key, value) {
+    const bucket = map.get(key);
+    if (bucket)
+        bucket.push(value);
+    else
+        map.set(key, [value]);
+}
+function freeze(map) {
+    const out = new Map();
+    for (const [key, value] of map)
+        out.set(key, value.sort());
+    return out;
+}
+export function buildContextGraphIndex(snapshot) {
+    const nodesById = new Map();
+    const edgesById = new Map();
+    const outgoing = new Map();
+    const incoming = new Map();
+    const nodesByPath = new Map();
+    const nodesByLabel = new Map();
+    const cycleByNode = new Map();
+    for (const node of snapshot.nodes) {
+        nodesById.set(node.id, node);
+        const nodePath = node.path ?? contextGraphPathFromId(node.id);
+        if (nodePath)
+            push(nodesByPath, nodePath, node.id);
+        if (node.label)
+            push(nodesByLabel, node.label.toLowerCase(), node.id);
+    }
+    for (const edge of snapshot.edges) {
+        edgesById.set(edge.id, edge);
+        push(outgoing, edge.from, edge.id);
+        push(incoming, edge.to, edge.id);
+    }
+    for (const cycle of snapshot.cycles) {
+        for (const nodeId of cycle.nodes)
+            cycleByNode.set(nodeId, cycle.id);
+    }
+    return {
+        snapshot,
+        nodesById,
+        edgesById,
+        outgoing: freeze(outgoing),
+        incoming: freeze(incoming),
+        nodesByPath: freeze(nodesByPath),
+        nodesByLabel: freeze(nodesByLabel),
+        cycleByNode
+    };
+}
+export function outgoingEdges(index, nodeId) {
+    const ids = index.outgoing.get(nodeId) ?? [];
+    const out = [];
+    for (const id of ids) {
+        const edge = index.edgesById.get(id);
+        if (edge)
+            out.push(edge);
+    }
+    return out;
+}
+export function incomingEdges(index, nodeId) {
+    const ids = index.incoming.get(nodeId) ?? [];
+    const out = [];
+    for (const id of ids) {
+        const edge = index.edgesById.get(id);
+        if (edge)
+            out.push(edge);
+    }
+    return out;
+}
+export function nodesAtPath(index, relativePath) {
+    const ids = index.nodesByPath.get(relativePath) ?? [];
+    const out = [];
+    for (const id of ids) {
+        const node = index.nodesById.get(id);
+        if (node)
+            out.push(node);
+    }
+    return out;
+}
+export function computeStronglyConnectedComponents(nodeIds, outgoingOf) {
+    const indexOf = new Map();
+    const lowLink = new Map();
+    const onStack = new Set();
+    const stack = [];
+    const components = [];
+    let counter = 0;
+    for (const start of nodeIds) {
+        if (indexOf.has(start))
+            continue;
+        const work = [
+            { node: start, edgeIndex: 0, edges: outgoingOf(start) }
+        ];
+        indexOf.set(start, counter);
+        lowLink.set(start, counter);
+        counter += 1;
+        stack.push(start);
+        onStack.add(start);
+        while (work.length) {
+            const frame = work[work.length - 1];
+            if (!frame)
+                break;
+            if (frame.edgeIndex < frame.edges.length) {
+                const next = frame.edges[frame.edgeIndex]?.to;
+                frame.edgeIndex += 1;
+                if (!next)
+                    continue;
+                if (!indexOf.has(next)) {
+                    indexOf.set(next, counter);
+                    lowLink.set(next, counter);
+                    counter += 1;
+                    stack.push(next);
+                    onStack.add(next);
+                    work.push({ node: next, edgeIndex: 0, edges: outgoingOf(next) });
+                }
+                else if (onStack.has(next)) {
+                    lowLink.set(frame.node, Math.min(lowLink.get(frame.node) ?? 0, indexOf.get(next) ?? 0));
+                }
+                continue;
+            }
+            work.pop();
+            const parent = work[work.length - 1];
+            if (parent) {
+                lowLink.set(parent.node, Math.min(lowLink.get(parent.node) ?? 0, lowLink.get(frame.node) ?? 0));
+            }
+            if (lowLink.get(frame.node) === indexOf.get(frame.node)) {
+                const component = [];
+                for (;;) {
+                    const popped = stack.pop();
+                    if (popped === undefined)
+                        break;
+                    onStack.delete(popped);
+                    component.push(popped);
+                    if (popped === frame.node)
+                        break;
+                }
+                if (component.length > 1)
+                    components.push(component.sort());
+            }
+        }
+    }
+    return components.sort((left, right) => String(left[0]).localeCompare(String(right[0])));
+}

package/dist/core/triwiki/context-graph/lint/rules.js

@@ -0,0 +1,232 @@
+import { lintError, validateContextGraphSnapshot } from '../contracts.js';
+import { computeStronglyConnectedComponents } from '../graph-index.js';
+import { isWorkspaceRelativePosixPath, isSymlinkEscape } from '../paths.js';
+import { containsPlaintextSecret } from '../../../secret-redaction.js';
+import { computeContextGraphSnapshotHash, orderedEdge, orderedNode, sortContextGraphEdges, sortContextGraphNodes } from '../compiler/serialize.js';
+const SHA256_RE = /^[a-f0-9]{64}$/;
+const MIN_ENV_VALUE_LENGTH = 12;
+const SOURCE_RELATION_KINDS = new Set([
+    'file',
+    'config',
+    'schema',
+    'test',
+    'proof',
+    'source',
+    'module',
+    'symbol',
+    'pipeline',
+    'command',
+    'route'
+]);
+export function structuralIssues(snapshot) {
+    return validateContextGraphSnapshot(snapshot).issues;
+}
+export function pathSafetyIssues(root, snapshot) {
+    const issues = [];
+    const checked = new Set();
+    const check = (value, label, extra) => {
+        if (!isWorkspaceRelativePosixPath(value)) {
+            issues.push(lintError('absolute_or_escaping_path', `${label} is not a workspace-relative POSIX path`, {
+                ...extra,
+                path: value
+            }));
+            return;
+        }
+        if (checked.has(value))
+            return;
+        checked.add(value);
+        if (isSymlinkEscape(root, value)) {
+            issues.push(lintError('symlink_escape', `${label} resolves outside the workspace through a symlink`, {
+                ...extra,
+                path: value
+            }));
+        }
+    };
+    for (const node of snapshot.nodes) {
+        if (node.path !== undefined)
+            check(node.path, `node ${node.id} path`, { nodeId: node.id });
+    }
+    for (const edge of snapshot.edges) {
+        const provenancePath = edge.provenance?.path;
+        if (typeof provenancePath === 'string' && provenancePath) {
+            check(provenancePath, `edge ${edge.id} provenance path`, {
+                edgeId: edge.id,
+                extractor: edge.provenance.extractor
+            });
+        }
+    }
+    return issues;
+}
+function nodeValues(node) {
+    const parts = [node.label ?? '', node.path ?? ''];
+    for (const [key, value] of Object.entries(node.metadata ?? {})) {
+        if (typeof value === 'string')
+            parts.push(`${key}=${value}`);
+        else if (Array.isArray(value))
+            for (const item of value)
+                parts.push(`${key}=${item}`);
+    }
+    return parts.filter(Boolean);
+}
+function edgeValues(edge) {
+    return [edge.provenance?.path ?? '', edge.provenance?.extractor ?? '', edge.provenance?.hash ?? ''].filter(Boolean);
+}
+const HIGH_ENTROPY_RUN_RE = /[A-Za-z0-9_+/=~-]{20,}/g;
+function looksHighEntropy(token) {
+    if (/^[a-f0-9]{8,64}$/.test(token))
+        return false;
+    if (token.length >= 32)
+        return true;
+    return /[A-Z]/.test(token) && /[a-z]/.test(token) && /[0-9]/.test(token);
+}
+function isStructuralValue(value) {
+    if (value.length > 512)
+        return false;
+    for (const run of value.match(HIGH_ENTROPY_RUN_RE) ?? []) {
+        if (looksHighEntropy(run))
+            return false;
+    }
+    return true;
+}
+function environmentValues(env) {
+    const out = [];
+    for (const value of Object.values(env)) {
+        if (typeof value === 'string' && value.length >= MIN_ENV_VALUE_LENGTH)
+            out.push(value);
+    }
+    return out;
+}
+export function secretIssues(snapshot, env = process.env) {
+    const issues = [];
+    const envValues = environmentValues(env);
+    const scan = (values, where, label) => {
+        for (const text of values) {
+            if (!isStructuralValue(text) && containsPlaintextSecret(text, env)) {
+                issues.push(lintError('secret_like_value', `${label} carries a secret-like value`, where));
+                return;
+            }
+            for (const value of envValues) {
+                if (text.includes(value)) {
+                    issues.push(lintError('secret_like_value', `${label} carries a raw environment value`, where));
+                    return;
+                }
+            }
+        }
+    };
+    for (const node of snapshot.nodes)
+        scan(nodeValues(node), { nodeId: node.id }, `node ${node.id}`);
+    for (const edge of snapshot.edges) {
+        scan(edgeValues(edge), { edgeId: edge.id, extractor: edge.provenance?.extractor }, `edge ${edge.id}`);
+    }
+    return issues;
+}
+export function determinismIssues(snapshot) {
+    const issues = [];
+    const canonicalNodes = JSON.stringify(sortContextGraphNodes(snapshot.nodes).map(orderedNode));
+    if (JSON.stringify(snapshot.nodes.map(orderedNode)) !== canonicalNodes) {
+        issues.push(lintError('non_deterministic_serialization', 'nodes are not in canonical order'));
+    }
+    if (JSON.stringify(snapshot.nodes) !== canonicalNodes) {
+        issues.push(lintError('non_deterministic_serialization', 'node objects do not use the canonical key order'));
+    }
+    const canonicalEdges = JSON.stringify(sortContextGraphEdges(snapshot.edges).map((edge) => orderedEdge(edge)));
+    if (JSON.stringify(snapshot.edges.map((edge) => orderedEdge(edge))) !== canonicalEdges) {
+        issues.push(lintError('non_deterministic_serialization', 'edges are not in canonical order'));
+    }
+    if (JSON.stringify(snapshot.edges) !== canonicalEdges) {
+        issues.push(lintError('non_deterministic_serialization', 'edge objects do not use the canonical key order'));
+    }
+    return issues;
+}
+export function hashIssues(snapshot, meta) {
+    const issues = [];
+    const recomputed = computeContextGraphSnapshotHash(snapshot);
+    if (recomputed !== snapshot.snapshotHash) {
+        issues.push(lintError('hash_mismatch', 'snapshotHash does not match the canonical serialization'));
+    }
+    for (const node of snapshot.nodes) {
+        if (node.contentHash !== undefined && !SHA256_RE.test(node.contentHash)) {
+            issues.push(lintError('hash_mismatch', `node ${node.id} contentHash is not a sha256 digest`, { nodeId: node.id }));
+        }
+    }
+    for (const edge of snapshot.edges) {
+        const hash = edge.provenance?.hash;
+        if (typeof hash !== 'string' || !SHA256_RE.test(hash)) {
+            issues.push(lintError('hash_mismatch', `edge ${edge.id} provenance hash is not a sha256 digest`, { edgeId: edge.id }));
+        }
+        if (typeof edge.provenance?.extractor !== 'string' || !edge.provenance.extractor) {
+            issues.push(lintError('edge_without_provenance', `edge ${edge.id} provenance names no extractor`, { edgeId: edge.id }));
+        }
+    }
+    if (!meta)
+        return issues;
+    if (meta.snapshotHash !== snapshot.snapshotHash) {
+        issues.push(lintError('snapshot_meta_mismatch', 'meta snapshotHash does not match the snapshot'));
+    }
+    if (meta.nodeCount !== snapshot.nodeCount || meta.edgeCount !== snapshot.edgeCount) {
+        issues.push(lintError('snapshot_meta_mismatch', 'meta counts do not match the snapshot'));
+    }
+    return issues;
+}
+export function protectedGateIssues(index) {
+    const issues = [];
+    for (const node of index.snapshot.nodes) {
+        if (node.kind !== 'gate' || node.risk !== 'protected')
+            continue;
+        const incident = [...(index.outgoing.get(node.id) ?? []), ...(index.incoming.get(node.id) ?? [])];
+        const grounded = incident.some((edgeId) => {
+            const edge = index.edgesById.get(edgeId);
+            if (!edge)
+                return false;
+            const otherId = edge.from === node.id ? edge.to : edge.from;
+            const other = index.nodesById.get(otherId);
+            return Boolean(other && SOURCE_RELATION_KINDS.has(other.kind));
+        });
+        if (!grounded) {
+            issues.push(lintError('protected_gate_without_source_relation', `protected gate ${node.id} has no relation to a repository source`, {
+                nodeId: node.id
+            }));
+        }
+    }
+    return issues;
+}
+export function manifestCycleIssues(snapshot) {
+    const manifest = new Map();
+    for (const edge of snapshot.edges) {
+        if (edge.confidence !== 'manifest')
+            continue;
+        const bucket = manifest.get(edge.from);
+        if (bucket)
+            bucket.push({ to: edge.to });
+        else
+            manifest.set(edge.from, [{ to: edge.to }]);
+    }
+    if (manifest.size === 0)
+        return [];
+    const nodeIds = snapshot.nodes.map((node) => node.id);
+    const components = computeStronglyConnectedComponents(nodeIds, (nodeId) => manifest.get(nodeId) ?? []);
+    return components.map((component) => lintError('manifest_dag_cycle', `manifest relations form a cycle across ${component.length} nodes`, {
+        nodeId: component[0] ?? ''
+    }));
+}
+export function freshnessClaimIssues(snapshot, sourceHashes) {
+    if (!sourceHashes)
+        return [];
+    const issues = [];
+    for (const node of snapshot.nodes) {
+        if (node.freshness !== 'fresh' || node.path === undefined)
+            continue;
+        const current = sourceHashes[node.path];
+        if (current === undefined)
+            continue;
+        if (node.contentHash === undefined || node.contentHash === '')
+            continue;
+        if (current !== node.contentHash) {
+            issues.push(lintError('freshness_claim_mismatch', `node ${node.id} claims fresh but its source hash changed`, {
+                nodeId: node.id,
+                path: node.path
+            }));
+        }
+    }
+    return issues;
+}

package/dist/core/triwiki/context-graph/lint/warnings.js

@@ -0,0 +1,93 @@
+import { lintWarning } from '../contracts.js';
+import { incomingEdges, outgoingEdges } from '../graph-index.js';
+import { CONTEXT_GRAPH_QUERY_PROFILES } from '../profiles.js';
+const CITATION_EDGE_TYPES = new Set([
+    'cites',
+    'derived_from',
+    'supports'
+]);
+const VERIFICATION_EDGE_TYPES = new Set([
+    'tests',
+    'verified_by',
+    'gated_by'
+]);
+const HIGH_FAN_IN = 8;
+const LOW_TRUST = 0.5;
+const PER_RULE_LIMIT = 50;
+function traversableEdgeTypes() {
+    const out = new Set();
+    for (const profile of Object.values(CONTEXT_GRAPH_QUERY_PROFILES)) {
+        for (const edge of profile.edges)
+            out.add(edge);
+    }
+    return out;
+}
+function capped(issues, limit = PER_RULE_LIMIT) {
+    if (issues.length <= limit)
+        return [...issues];
+    const head = issues.slice(0, limit);
+    const first = issues[0];
+    if (first) {
+        head.push({
+            code: first.code,
+            severity: 'warning',
+            message: `${issues.length - limit} further ${first.code} warnings were omitted from this snapshot`
+        });
+    }
+    return head;
+}
+export function warningIssues(input) {
+    const { index } = input;
+    const traversable = traversableEdgeTypes();
+    const orphanClaims = [];
+    const lowTrust = [];
+    const unknownFreshness = [];
+    const highFanIn = [];
+    const unreachable = [];
+    for (const node of index.snapshot.nodes) {
+        const outgoing = outgoingEdges(index, node.id);
+        const incoming = incomingEdges(index, node.id);
+        if (node.kind === 'wiki_claim') {
+            const citations = outgoing.filter((edge) => CITATION_EDGE_TYPES.has(edge.type));
+            if (citations.length === 0) {
+                orphanClaims.push(lintWarning('orphan_wiki_claim', `wiki claim ${node.id} cites no source`, { nodeId: node.id }));
+            }
+            else if (citations.length === 1 && node.trust < LOW_TRUST) {
+                lowTrust.push(lintWarning('single_source_low_trust_synthesis', `wiki claim ${node.id} rests on one low-trust source`, {
+                    nodeId: node.id
+                }));
+            }
+        }
+        if (node.freshness === 'unknown') {
+            unknownFreshness.push(lintWarning('unknown_freshness', `node ${node.id} has unknown freshness`, { nodeId: node.id }));
+        }
+        if (incoming.length >= HIGH_FAN_IN) {
+            const verified = [...incoming, ...outgoing].some((edge) => VERIFICATION_EDGE_TYPES.has(edge.type));
+            if (!verified) {
+                highFanIn.push(lintWarning('high_fan_in_without_verification', `node ${node.id} has ${incoming.length} dependents and no test or gate relation`, { nodeId: node.id }));
+            }
+        }
+        const reachable = [...incoming, ...outgoing].some((edge) => traversable.has(edge.type));
+        if (!reachable) {
+            unreachable.push(lintWarning('unreachable_in_profile', `node ${node.id} is not reachable by any query profile`, {
+                nodeId: node.id
+            }));
+        }
+    }
+    return [
+        ...capped(orphanClaims),
+        ...capped(lowTrust),
+        ...capped(unknownFreshness),
+        ...capped(highFanIn),
+        ...capped(unreachable),
+        ...summarizeSkips(input.skipped ?? [])
+    ];
+}
+export function summarizeSkips(skipped) {
+    const counts = new Map();
+    for (const skip of skipped)
+        counts.set(skip.reason, (counts.get(skip.reason) ?? 0) + 1);
+    return [...counts.entries()]
+        .sort((left, right) => (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0))
+        .map(([reason, count]) => lintWarning('extractor_skipped_input', `${count} input(s) were skipped: ${reason}`));
+}

package/dist/core/triwiki/context-graph/paths.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const CONTEXT_GRAPH_DIR_SEGMENTS = ['.sneakoscope', 'wiki'];
+export class ContextGraphPathError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ContextGraphPathError';
+        this.code = code;
+    }
+}
+function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+export function normalizeGraphPath(root, candidate) {
+    const raw = String(candidate ?? '').trim();
+    if (!raw)
+        throw new ContextGraphPathError('empty_path', 'graph path is empty');
+    const absoluteRoot = path.resolve(root);
+    const absolute = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(absoluteRoot, raw);
+    const relative = path.relative(absoluteRoot, absolute);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new ContextGraphPathError('absolute_or_escaping_path', `path escapes the workspace: ${toPosix(raw)}`);
+    }
+    return toPosix(relative);
+}
+export function tryNormalizeGraphPath(root, candidate) {
+    try {
+        return normalizeGraphPath(root, candidate);
+    }
+    catch {
+        return null;
+    }
+}
+export function isWorkspaceRelativePosixPath(value) {
+    if (typeof value !== 'string' || !value)
+        return false;
+    if (value.includes('\\'))
+        return false;
+    if (path.posix.isAbsolute(value))
+        return false;
+    if (/^[A-Za-z]:\//.test(value))
+        return false;
+    if (value === '..' || value.startsWith('../') || value.includes('/../') || value.endsWith('/..'))
+        return false;
+    if (value.startsWith('~'))
+        return false;
+    return true;
+}
+export function resolveInsideWorkspace(root, relative) {
+    const absoluteRoot = safeRealpath(path.resolve(root));
+    const absolute = path.resolve(absoluteRoot, relative);
+    if (!fs.existsSync(absolute))
+        return null;
+    const real = safeRealpath(absolute);
+    const rel = path.relative(absoluteRoot, real);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+        throw new ContextGraphPathError('symlink_escape', `symlink leaves the workspace: ${toPosix(relative)}`);
+    }
+    return real;
+}
+export function isSymlinkEscape(root, relative) {
+    try {
+        resolveInsideWorkspace(root, relative);
+        return false;
+    }
+    catch (error) {
+        return error instanceof ContextGraphPathError && error.code === 'symlink_escape';
+    }
+}
+function safeRealpath(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch {
+        return target;
+    }
+}
+export function contextGraphDir(root) {
+    return path.join(root, ...CONTEXT_GRAPH_DIR_SEGMENTS);
+}
+export function contextGraphSnapshotPath(root) {
+    return path.join(contextGraphDir(root), 'context-graph.json');
+}
+export function contextGraphMetaPath(root) {
+    return path.join(contextGraphDir(root), 'context-graph.meta.json');
+}
+export function contextGraphPrevSnapshotPath(root) {
+    return path.join(contextGraphDir(root), 'context-graph.prev.json');
+}
+export function contextGraphEventLogPath(root) {
+    return path.join(contextGraphDir(root), 'context-graph-events.jsonl');
+}
+export function contextGraphFragmentCacheDir(root) {
+    return path.join(root, '.sneakoscope', 'cache', 'context-graph', 'fragments');
+}
+export function contextGraphLockPath(root) {
+    return path.join(root, '.sneakoscope', 'cache', 'context-graph', 'compile.lock');
+}
+export function contextGraphBenchmarkReportPath(root) {
+    return path.join(root, '.sneakoscope', 'reports', 'context-graph-benchmark.json');
+}
+export function contextGraphExperimentLogPath(root) {
+    return path.join(root, '.sneakoscope', 'reports', 'context-graph-experiments.jsonl');
+}
+export function contextPackPath(root) {
+    return path.join(contextGraphDir(root), 'context-pack.json');
+}
+export function contextGraphArtifactPaths(root) {
+    return [
+        contextGraphSnapshotPath(root),
+        contextGraphMetaPath(root),
+        contextGraphPrevSnapshotPath(root),
+        contextGraphEventLogPath(root)
+    ];
+}

package/dist/core/triwiki/context-graph/profiles.js

@@ -0,0 +1,78 @@
+export const CONTEXT_GRAPH_QUERY_PROFILE_NAMES = ['implementation', 'review', 'planning', 'answer'];
+export const CONTEXT_GRAPH_TRAVERSAL_CAPS = {
+    maxVisitedNodes: 4000,
+    maxVisitedEdges: 20000,
+    maxSeeds: 24,
+    maxSelectedNodes: 64,
+    defaultTokenBudget: 6000,
+    queryTimeoutMs: 1500
+};
+function weights(entries) {
+    const edges = [];
+    const edgeWeights = {};
+    for (const [edge, weight] of entries) {
+        edges.push(edge);
+        edgeWeights[edge] = weight;
+    }
+    return { edges, edgeWeights };
+}
+const IMPLEMENTATION = weights([
+    ['defines', 3.0],
+    ['contains', 2.2],
+    ['imports', 2.0],
+    ['routes_to', 2.0],
+    ['reexports', 1.8],
+    ['references', 1.6],
+    ['calls', 1.6],
+    ['tests', 1.4],
+    ['verified_by', 1.2]
+]);
+const REVIEW = weights([
+    ['affected_by', 3.0],
+    ['tests', 2.4],
+    ['gated_by', 2.4],
+    ['verified_by', 2.0],
+    ['invalidates', 1.8],
+    ['conflicts_with', 1.6],
+    ['routes_to', 1.4],
+    ['contains', 1.2],
+    ['defines', 1.0]
+]);
+const PLANNING = weights([
+    ['depends_on', 2.8],
+    ['owns', 2.2],
+    ['affected_by', 2.0],
+    ['conflicts_with', 1.8],
+    ['routes_to', 1.6],
+    ['cochanged_with', 1.4],
+    ['gated_by', 1.4],
+    ['contains', 1.0],
+    ['imports', 1.0]
+]);
+const ANSWER = weights([
+    ['derived_from', 2.8],
+    ['cites', 2.6],
+    ['supports', 2.0],
+    ['contradicts', 1.8],
+    ['supersedes', 1.6],
+    ['contains', 0.8]
+]);
+export const CONTEXT_GRAPH_QUERY_PROFILES = {
+    implementation: { name: 'implementation', ...IMPLEMENTATION, maxDepth: 2, maxDepthHighRisk: 3 },
+    review: { name: 'review', ...REVIEW, maxDepth: 2, maxDepthHighRisk: 3 },
+    planning: { name: 'planning', ...PLANNING, maxDepth: 2, maxDepthHighRisk: 3 },
+    answer: { name: 'answer', ...ANSWER, maxDepth: 2, maxDepthHighRisk: 3 }
+};
+export const DEFAULT_CONTEXT_GRAPH_QUERY_PROFILE = 'implementation';
+export function isContextGraphQueryProfileName(value) {
+    return typeof value === 'string' && CONTEXT_GRAPH_QUERY_PROFILE_NAMES.includes(value);
+}
+export function contextGraphQueryProfile(name) {
+    return CONTEXT_GRAPH_QUERY_PROFILES[isContextGraphQueryProfileName(name) ? name : DEFAULT_CONTEXT_GRAPH_QUERY_PROFILE];
+}
+export function profileEdgeWeight(profile, edge) {
+    return profile.edgeWeights[edge] ?? 0;
+}
+export function profileTraversesEdge(profile, edge) {
+    return profileEdgeWeight(profile, edge) > 0;
+}