@dotdotgod/cli 0.2.14 → 0.2.17

package/src/impact/report.mjs

@@ -1,6 +1,8 @@
-import { DEFAULT_IMPACT_RANKING_POLICY, SEMANTIC_RELATIONS, cloneImpactRankingPolicy, defaultMemoryConfig } from '../memory/config.mjs';
+import { DEFAULT_IMPACT_RANKING_POLICY, SEMANTIC_RELATIONS, cloneImpactRankingPolicy, defaultMemoryConfig, traceabilityRelationWeights } from '../memory/config.mjs';
 import { retrievalMetadataForPath } from '../graph/metadata.mjs';
 import { buildPersonalizedPageRank, compareImpactItems, docsArea, hasCuratedImpactReason, isLowActionabilityImpactItem, isSemanticOnlyImpactItem, isTestPath, scoreImpactItem } from './scoring.mjs';
+import { normalizeChangedPath } from './vector-profile.mjs';
+import { MAX_VECTOR_EVIDENCE_CHUNK_ID_CHARS, MAX_VECTOR_EVIDENCE_HEADING_CHARS } from './vector-overlay.mjs';
 
 function addImpactItem(group, item, limit = 10) {
   if (group.items.some((existing) => existing.id === item.id)) return;
@@ -13,7 +15,7 @@ function addImpactItem(group, item, limit = 10) {
 
 function normalizeChangedPaths(changedPaths) {
   const values = Array.isArray(changedPaths) ? changedPaths : [changedPaths];
-  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+  return [...new Set(values.map(normalizeChangedPath).filter(Boolean))];
 }
 
 function selectImpactItems(sortedItems, maxRelated, seeds) {
@@ -48,9 +50,14 @@ function selectImpactItems(sortedItems, maxRelated, seeds) {
 }
 
 function buildCombinedImpactReport(index, changedPaths, limits = {}) {
-  const graph = index?.graph ?? { nodes: [], edges: [] };
+  const baseGraph = index?.graph ?? { nodes: [], edges: [] };
+  const overlay = limits.overlay ?? { status: 'disabled', edges: [] };
+  const graph = { nodes: baseGraph.nodes, edges: [...baseGraph.edges, ...(overlay.edges ?? [])] };
   const config = index?.memoryConfig ? { ...defaultMemoryConfig(), ...index.memoryConfig } : defaultMemoryConfig();
   const policy = cloneImpactRankingPolicy(config.impactRanking ?? DEFAULT_IMPACT_RANKING_POLICY);
+  const traceabilityWeights = traceabilityRelationWeights(config.traceability);
+  policy.relationWeights = { ...policy.relationWeights, ...traceabilityWeights };
+  const curatedRelations = new Set(Object.keys(traceabilityWeights));
   const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
   const seeds = changedPaths.map((path) => `file:${path}`);
   const seedSet = new Set(seeds);
@@ -58,6 +65,7 @@ function buildCombinedImpactReport(index, changedPaths, limits = {}) {
   const groups = { files: { items: [], omitted: 0 }, docs: { items: [], omitted: 0 }, contracts: { items: [], omitted: 0 }, tests: { items: [], omitted: 0 }, commands: { items: [], omitted: 0 }, events: { items: [], omitted: 0 }, packageResources: { items: [], omitted: 0 }, symbols: { items: [], omitted: 0 } };
   const relatedIds = new Set(seeds);
   const reasons = new Map(seeds.map((seed) => [seed, new Set(['changed-file'])]));
+  const vectorEvidence = new Map();
   const addReason = (id, reason) => {
     relatedIds.add(id);
     if (!reasons.has(id)) reasons.set(id, new Set());
@@ -65,25 +73,31 @@ function buildCombinedImpactReport(index, changedPaths, limits = {}) {
   };
 
   for (const edge of graph.edges) {
+    if (edge.relation === 'vector_similarity' && seedSet.has(edge.source)) vectorEvidence.set(edge.target, {
+      score: edge.score,
+      heading: typeof edge.heading === 'string' ? edge.heading.slice(0, MAX_VECTOR_EVIDENCE_HEADING_CHARS) : undefined,
+      chunkId: typeof edge.chunkId === 'string' ? edge.chunkId.slice(0, MAX_VECTOR_EVIDENCE_CHUNK_ID_CHARS) : undefined,
+      confidence: edge.confidence,
+    });
     if (seedSet.has(edge.source)) addReason(edge.target, edge.relation);
     if (seedSet.has(edge.target)) addReason(edge.source, `incoming:${edge.relation}`);
   }
-  const expansionRelations = new Set(['implemented_by', 'verified_by', 'related_doc', 'verification_command', ...SEMANTIC_RELATIONS]);
+  const expansionRelations = new Set([...curatedRelations, ...SEMANTIC_RELATIONS]);
   for (const edge of graph.edges) {
     if (!expansionRelations.has(edge.relation)) continue;
     if (relatedIds.has(edge.source) && !seedSet.has(edge.target)) addReason(edge.target, edge.relation);
   }
 
   const pprScores = buildPersonalizedPageRank(graph, seeds, policy);
-  const candidatePprMax = Math.max(0, ...[...relatedIds].filter((id) => !seedSet.has(id)).map((id) => pprScores.get(id) ?? 0));
   const relatedAll = [...relatedIds].map((id) => {
     const node = nodeById.get(id) ?? { id };
     const path = node.path ?? id.replace(/^file:/, '').replace(/^test:/, '');
     const reasonList = [...(reasons.get(id) ?? [])];
     const retrieval = node.retrieval ?? retrievalMetadataForPath(path);
     const reasonSignals = reasonList.map((reason) => `reason:${reason}`);
-    const scored = scoreImpactItem({ ...node, reasons: reasonList, retrieval }, seedSet, changedPaths, policy, pprScores, candidatePprMax);
-    return { ...node, reasons: reasonList, retrieval: { ...retrieval, signals: [...new Set([...(retrieval.signals ?? []), ...reasonSignals])] }, ...scored };
+    const hasCuratedEvidence = reasonList.some((reason) => curatedRelations.has(reason.replace(/^incoming:/, '')));
+    const scored = scoreImpactItem({ ...node, reasons: reasonList, retrieval }, seedSet, changedPaths, policy, pprScores);
+    return { ...node, reasons: reasonList, hasCuratedEvidence, ...(vectorEvidence.has(id) ? { vectorEvidence: vectorEvidence.get(id) } : {}), retrieval: { ...retrieval, signals: [...new Set([...(retrieval.signals ?? []), ...reasonSignals])] }, ...scored };
   }).sort(compareImpactItems(seeds));
   const related = selectImpactItems(relatedAll, maxRelated, seeds);
   for (const item of related) {
@@ -98,7 +112,7 @@ function buildCombinedImpactReport(index, changedPaths, limits = {}) {
     else if (item.type === 'event') addImpactItem(groups.events, item, limits.events ?? 10);
     else if (item.type === 'package_resource') addImpactItem(groups.packageResources, item, limits.packageResources ?? 10);
   }
-  return { changed: changedPaths[0], changedFiles: changedPaths, ranking: { method: policy.ppr.enabled === false ? 'policy-score' : 'personalized-pagerank+policy', preset: policy.preset, configSource: index?.memoryConfig?.source ?? 'default', weights: policy.weights, ppr: policy.ppr }, related, groups, omittedRelated: Math.max(0, relatedAll.length - related.length) };
+  return { changed: changedPaths[0], changedFiles: changedPaths, semantic: { status: overlay.status ?? 'disabled', ...(limits.verboseSemantic ? { diagnostics: overlay.diagnostics } : {}) }, ranking: { method: 'weighted-personalized-pagerank+memory', configSource: index?.memoryConfig?.source ?? 'default', connectionCap: policy.connectionCap, memoryCap: policy.memoryCap, pprReference: policy.ppr.reference }, related, groups, omittedRelated: Math.max(0, relatedAll.length - related.length) };
 }
 
 export function buildImpactReport(index, changedPaths, limits = {}) {
@@ -106,7 +120,9 @@ export function buildImpactReport(index, changedPaths, limits = {}) {
   const aggregate = buildCombinedImpactReport(index, normalized, limits);
   const perSeedLimit = limits.perSeed ?? 5;
   aggregate.perSeed = normalized.map((changed) => {
-    const report = buildCombinedImpactReport(index, [changed], { ...limits, related: Math.max(limits.related ?? 25, perSeedLimit + 1) });
+    const seedId = `file:${changed}`;
+    const seedOverlay = limits.overlay ? { ...limits.overlay, edges: (limits.overlay.edges ?? []).filter((edge) => edge.source === seedId) } : undefined;
+    const report = buildCombinedImpactReport(index, [changed], { ...limits, overlay: seedOverlay, related: Math.max(limits.related ?? 25, perSeedLimit + 1) });
     const related = report.related.filter((item) => item.id !== `file:${changed}`).slice(0, perSeedLimit);
     return { changed, related, omittedRelated: Math.max(0, report.related.length - 1 - related.length) + report.omittedRelated };
   });
@@ -121,7 +137,7 @@ function compactScoreBreakdown(scoreBreakdown = {}) {
 
 export function compactImpactItem(item) {
   const compact = { id: item.id, type: item.type, impactScore: item.impactScore, reasons: (item.reasons ?? []).slice(0, 6), scoreBreakdown: compactScoreBreakdown(item.scoreBreakdown) };
-  for (const key of ['path', 'area', 'name', 'command', 'target', 'kind', 'specifier', 'title', 'contractId', 'sections']) if (item[key] !== undefined) compact[key] = item[key];
+  for (const key of ['path', 'area', 'name', 'command', 'target', 'kind', 'specifier', 'title', 'contractId', 'sections', 'vectorEvidence']) if (item[key] !== undefined) compact[key] = item[key];
   if (item.retrieval) compact.retrieval = { area: item.retrieval.area, role: item.retrieval.role, priority: item.retrieval.priority, freshness: item.retrieval.freshness };
   return compact;
 }
@@ -141,5 +157,5 @@ export function buildCompactImpactReport(impact, limits = {}) {
   const groups = Object.fromEntries(groupNames.map((name) => [name, compactImpactGroup(impact.groups?.[name], groupLimit)]));
   const perSeed = (impact.perSeed ?? []).map((entry) => ({ changed: entry.changed, related: (entry.related ?? []).slice(0, limits.perSeed ?? 5).map(compactImpactItem), omittedRelated: entry.omittedRelated ?? 0 }));
   const top10 = (impact.related ?? []).filter((item) => !seedIds.has(item.id)).slice(0, 10);
-  return { changed: impact.changed, changedFiles, perSeed, compact: true, ranking: { method: impact.ranking?.method, preset: impact.ranking?.preset, configSource: impact.ranking?.configSource }, related, groups, omittedRelated: (impact.omittedRelated ?? 0) + Math.max(0, (impact.related?.length ?? 0) - related.length), quality: { rawRelated: impact.related?.length ?? 0, compactRelated: related.length, semanticOnlyTop10: top10.filter((item) => isSemanticOnlyImpactItem(item)).length, curatedTop10: top10.filter((item) => hasCuratedImpactReason(item)).length, lowActionabilityTop10: top10.filter((item) => isLowActionabilityImpactItem(item)).length } };
+  return { changed: impact.changed, changedFiles, perSeed, semantic: impact.semantic, compact: true, ranking: { method: impact.ranking?.method, configSource: impact.ranking?.configSource, connectionCap: impact.ranking?.connectionCap, memoryCap: impact.ranking?.memoryCap, pprReference: impact.ranking?.pprReference }, related, groups, omittedRelated: (impact.omittedRelated ?? 0) + Math.max(0, (impact.related?.length ?? 0) - related.length), quality: { rawRelated: impact.related?.length ?? 0, compactRelated: related.length, semanticOnlyTop10: top10.filter((item) => isSemanticOnlyImpactItem(item)).length, curatedTop10: top10.filter((item) => hasCuratedImpactReason(item)).length, lowActionabilityTop10: top10.filter((item) => isLowActionabilityImpactItem(item)).length } };
 }

package/src/impact/scoring.mjs

@@ -23,18 +23,11 @@ function roundScore(value) {
   return Math.round(value * 10) / 10;
 }
 
-function sumReasonBoosts(reasons, boosts) {
-  return reasons.reduce((sum, reason) => sum + (boosts[reason] ?? 0), 0);
-}
-
-function cappedTraceabilityScore(reasons, boosts, cap) {
-  const values = reasons.map((reason) => boosts[reason] ?? 0).filter((value) => value > 0);
-  if (values.length === 0) return 0;
-  return clamp(Math.max(...values) + Math.min(5, Math.max(0, values.length - 1) * 2), 0, cap);
+function roundProbability(value) {
+  return Math.round(value * 1000000) / 1000000;
 }
 
 export function buildPersonalizedPageRank(graph, seeds, policy) {
-  if (policy.ppr.enabled === false) return new Map();
   const seedList = Array.isArray(seeds) ? [...new Set(seeds)] : [seeds];
   const seedSet = new Set(seedList);
   const restart = seedList.length > 0 ? 1 / seedList.length : 0;
@@ -45,7 +38,7 @@ export function buildPersonalizedPageRank(graph, seeds, policy) {
   for (const seed of seedList) ids.add(seed);
   const adjacency = new Map([...ids].map((id) => [id, []]));
   for (const edge of graph.edges) {
-    const weight = policy.relationWeights[edge.relation] ?? relationWeight(edge.relation);
+    const weight = edge.weight ?? policy.relationWeights[edge.relation] ?? relationWeight(edge.relation);
     if (weight <= 0) continue;
     if (!adjacency.has(edge.source)) adjacency.set(edge.source, []);
     if (!adjacency.has(edge.target)) adjacency.set(edge.target, []);
@@ -68,29 +61,33 @@ export function buildPersonalizedPageRank(graph, seeds, policy) {
   return ranks;
 }
 
-export function scoreImpactItem(item, seeds, changedPaths, policy, pprScores, maxPpr) {
+export function scoreImpactItem(item, seeds, changedPaths, policy, pprScores) {
   const seedSet = seeds instanceof Set ? seeds : new Set(Array.isArray(seeds) ? seeds : [seeds]);
   const paths = Array.isArray(changedPaths) ? changedPaths : [changedPaths];
-  if (seedSet.has(item.id)) return { impactScore: 100, scoreBreakdown: { seed: 100, ppr: 40, traceability: 0, memoryPolicy: 0, verification: 0, proximity: 0, semantic: 0, freshness: 0, archivePenalty: 0 } };
-  const reasons = item.reasons ?? [];
+  const archiveSeeded = paths.some((path) => path.startsWith('docs/archive/'));
+  if (seedSet.has(item.id)) return { impactScore: 100, scoreBreakdown: { seed: 100, connection: { ppr: 80, reference: policy.ppr.reference }, memory: { priority: 20, policyAdjustments: 0 } } };
   const retrieval = item.retrieval ?? {};
-  const pprNormalized = maxPpr > 0 ? (pprScores.get(item.id) ?? 0) / maxPpr : 0;
-  const ppr = clamp(pprNormalized * (policy.weights.ppr ?? 40), 0, Math.abs(policy.weights.ppr ?? 40));
-  const traceability = cappedTraceabilityScore(reasons, policy.traceabilityBoosts, Math.abs(policy.weights.traceability ?? 30));
-  const memoryPolicy = clamp(((retrieval.priority ?? 30) / 100) * Math.abs(policy.weights.memoryPolicy ?? 10), 0, Math.abs(policy.weights.memoryPolicy ?? 10));
-  const verification = clamp(sumReasonBoosts(reasons, policy.verificationBoosts) + (item.type === 'test' || isTestPath(item.path ?? '') ? 10 : 0) + (item.type === 'verification_command' ? 12 : 0), 0, Math.abs(policy.weights.verification ?? 15));
-  const proximity = clamp(sumReasonBoosts(reasons, policy.proximityBoosts), 0, Math.abs(policy.weights.proximity ?? 10));
-  const semantic = clamp(sumReasonBoosts(reasons, policy.semanticBoosts), 0, Math.abs(policy.weights.semantic ?? 10));
-  const freshness = retrieval.freshness === 'fresh' ? Math.abs(policy.weights.freshness ?? 5) : retrieval.freshness === 'stale' ? -Math.abs(policy.weights.freshness ?? 5) : 0;
-  let archivePenalty = 0;
-  if (!paths.some((path) => path.startsWith('docs/archive/'))) {
-    if (retrieval.area === 'archive-body') archivePenalty -= Math.abs(policy.weights.archivePenalty ?? -25);
-    if (retrieval.includeBodiesByDefault === false) archivePenalty -= 10;
-    if (retrieval.freshness === 'stale' && retrieval.area !== 'archive-map') archivePenalty -= 5;
-  }
-  archivePenalty = clamp(archivePenalty, -Math.abs(policy.weights.archivePenalty ?? -25), 0);
-  const impactScore = clamp(ppr + traceability + memoryPolicy + verification + proximity + semantic + freshness + archivePenalty, 0, 100);
-  return { impactScore: roundScore(impactScore), scoreBreakdown: { ppr: roundScore(ppr), traceability: roundScore(traceability), memoryPolicy: roundScore(memoryPolicy), verification: roundScore(verification), proximity: roundScore(proximity), semantic: roundScore(semantic), freshness: roundScore(freshness), archivePenalty: roundScore(archivePenalty) } };
+  const probability = pprScores.get(item.id) ?? 0;
+  const connection = clamp((probability / policy.ppr.reference) * policy.connectionCap, 0, policy.connectionCap);
+  const priority = clamp(((retrieval.priority ?? 30) / 100) * 15, 0, 15);
+  let policyAdjustments = retrieval.freshness === 'fresh' ? 5 : retrieval.freshness === 'stale' ? -5 : 0;
+  if (retrieval.includeBodiesByDefault === false && !archiveSeeded) policyAdjustments -= 5;
+  const memory = clamp(priority + policyAdjustments, 0, policy.memoryCap);
+  const reasons = item.reasons ?? [];
+  const strongestReason = (values) => [...values].sort((a, b) => {
+    const weightDelta = (policy.relationWeights[baseImpactReason(b)] ?? relationWeight(baseImpactReason(b))) - (policy.relationWeights[baseImpactReason(a)] ?? relationWeight(baseImpactReason(a)));
+    return weightDelta || a.localeCompare(b);
+  })[0];
+  const strongestDirectRelation = strongestReason(reasons.filter((reason) => reason !== 'changed-file'));
+  const impactScore = clamp(connection + memory, 0, 100);
+  return {
+    impactScore: roundScore(impactScore),
+    scoreBreakdown: {
+      connection: { ppr: roundScore(connection), probability: roundProbability(probability), reference: policy.ppr.reference },
+      memory: { priority: roundScore(priority), policyAdjustments: roundScore(policyAdjustments) },
+      ...(strongestDirectRelation ? { strongestDirectRelation } : {}),
+    },
+  };
 }
 
 const CURATED_IMPACT_REASONS = new Set(['implemented_by', 'verified_by', 'related_doc', 'verification_command', 'links_to', 'routes_to', 'belongs_to_area']);
@@ -109,7 +106,7 @@ function isCuratedImpactReason(reason = '') {
 }
 
 export function hasCuratedImpactReason(item) {
-  return (item.reasons ?? []).some((reason) => isCuratedImpactReason(reason));
+  return item.hasCuratedEvidence === true || (item.reasons ?? []).some((reason) => isCuratedImpactReason(reason));
 }
 
 export function isSemanticOnlyImpactItem(item) {
@@ -121,15 +118,6 @@ export function isLowActionabilityImpactItem(item) {
   return LOW_ACTIONABILITY_IMPACT_TYPES.has(item.type);
 }
 
-function impactSelectionScore(item) {
-  let score = item.impactScore ?? 0;
-  if (hasCuratedImpactReason(item)) score += 4;
-  if (item.type === 'file' || item.type === 'test' || item.type === 'verification_command') score += 2;
-  if (isSemanticOnlyImpactItem(item)) score -= 12;
-  if (isLowActionabilityImpactItem(item)) score -= 15;
-  return score;
-}
-
 export function compareImpactItems(seeds) {
   const seedList = Array.isArray(seeds) ? seeds : [seeds];
   const seedOrder = new Map(seedList.map((seed, index) => [seed, index]));
@@ -141,6 +129,6 @@ export function compareImpactItems(seeds) {
       if (bSeed === undefined) return -1;
       return aSeed - bSeed;
     }
-    return impactSelectionScore(b) - impactSelectionScore(a) || (b.impactScore ?? 0) - (a.impactScore ?? 0) || a.id.localeCompare(b.id);
+    return (b.impactScore ?? 0) - (a.impactScore ?? 0) || a.id.localeCompare(b.id);
   };
 }

package/src/impact/vector-overlay.mjs

@@ -0,0 +1,49 @@
+import { buildVectorIndex, rankVectorFiles } from '../commands/query.mjs';
+import { embedTexts } from '../query/embedder.mjs';
+import { VECTOR_MODEL } from '../query/store.mjs';
+import { buildChangedFileProfile, canonicalizeChangedPath } from './vector-profile.mjs';
+
+export const VECTOR_RELATION_WEIGHT = 2;
+export const MAX_VECTOR_EVIDENCE_HEADING_CHARS = 160;
+export const MAX_VECTOR_EVIDENCE_CHUNK_ID_CHARS = 200;
+
+function boundedEvidence(value, limit) {
+  return typeof value === 'string' ? value.slice(0, limit) : undefined;
+}
+
+export async function buildVectorImpactOverlay(root, index, changedPaths, options = {}) {
+  const semantic = index?.memoryConfig?.impactRanking?.semantic ?? {};
+  if (semantic.enabled === false || semantic.topKPerFile === 0) return { status: 'disabled', edges: [], diagnostics: { enabled: false } };
+  const embed = options.embed ?? embedTexts;
+  const threshold = semantic.threshold ?? 0.5;
+  const topK = semantic.topKPerFile ?? 5;
+  try {
+    const vectorIndex = await (options.buildIndex ?? buildVectorIndex)(root, embed);
+    const edges = [];
+    const normalizedChangedPaths = [...new Set(changedPaths.map((path) => canonicalizeChangedPath(root, path)).filter(Boolean))];
+    for (const changed of normalizedChangedPaths) {
+      const profile = buildChangedFileProfile(root, changed, index?.graph);
+      if (!profile) continue;
+      const [queryVector] = await embed([`query: ${profile.text}`]);
+      if (!queryVector) throw new Error('Changed-file embedding was empty.');
+      const matches = rankVectorFiles(queryVector, vectorIndex)
+        .filter((match) => match.path !== changed && match.vectorScore >= threshold)
+        .slice(0, topK);
+      for (const match of matches) {
+        edges.push({
+          source: `file:${changed}`,
+          target: `file:${match.path}`,
+          relation: 'vector_similarity',
+          weight: VECTOR_RELATION_WEIGHT * match.vectorScore,
+          score: Number(match.vectorScore.toFixed(6)),
+          confidence: 'INFERRED_VECTOR_SEMANTIC',
+          heading: boundedEvidence(match.heading, MAX_VECTOR_EVIDENCE_HEADING_CHARS),
+          chunkId: boundedEvidence(match.id, MAX_VECTOR_EVIDENCE_CHUNK_ID_CHARS),
+        });
+      }
+    }
+    return { status: 'available', edges, diagnostics: { enabled: true, model: VECTOR_MODEL, corpusChunks: vectorIndex.chunks.length, threshold, topK, embedded: vectorIndex.manifest?.embedded, reused: vectorIndex.manifest?.reused } };
+  } catch (error) {
+    return { status: 'unavailable', edges: [], diagnostics: { enabled: true, reason: error instanceof Error ? error.message : String(error) } };
+  }
+}

package/src/impact/vector-profile.mjs

@@ -0,0 +1,87 @@
+import { lstatSync, readFileSync, realpathSync } from 'node:fs';
+import { extname, relative, resolve, sep } from 'node:path';
+import { isSecretLikePathPattern } from '../memory/config.mjs';
+
+export const MAX_VECTOR_PROFILE_FILE_BYTES = 64 * 1024;
+export const MAX_VECTOR_PROFILE_CHARS = 4000;
+export const MAX_VECTOR_PROFILE_METADATA_ITEMS = 20;
+
+const TEXT_EXTENSIONS = new Set(['.c', '.cc', '.cpp', '.css', '.go', '.h', '.hpp', '.html', '.java', '.js', '.json', '.jsx', '.md', '.mjs', '.py', '.rb', '.rs', '.sh', '.ts', '.tsx', '.txt', '.yaml', '.yml']);
+const GENERATED_SEGMENTS = new Set(['.dotdotgod', 'build', 'coverage', 'dist', 'node_modules']);
+
+function insideRoot(root, absolute) {
+  const normalizedRoot = resolve(root);
+  return absolute === normalizedRoot || absolute.startsWith(`${normalizedRoot}${sep}`);
+}
+
+export function normalizeChangedPath(path) {
+  const normalized = String(path ?? '').replaceAll('\\', '/').replace(/^\.\/+/, '');
+  if (!normalized || normalized === '.') return null;
+  return normalized;
+}
+
+export function canonicalizeChangedPath(root, path) {
+  const normalized = normalizeChangedPath(path);
+  if (!normalized) return null;
+  const rootAbsolute = resolve(root);
+  const absolute = resolve(rootAbsolute, normalized);
+  if (!insideRoot(rootAbsolute, absolute)) return normalized;
+  try {
+    const canonicalRoot = realpathSync(rootAbsolute);
+    const canonicalAbsolute = realpathSync(absolute);
+    if (!insideRoot(canonicalRoot, canonicalAbsolute)) return normalized;
+    const canonical = relative(canonicalRoot, canonicalAbsolute).replaceAll('\\', '/');
+    return canonical || normalized;
+  } catch {
+    return relative(rootAbsolute, absolute).replaceAll('\\', '/') || normalized;
+  }
+}
+
+function unsafeProfilePath(path) {
+  return isSecretLikePathPattern(path) || path.split('/').some((segment) => GENERATED_SEGMENTS.has(segment));
+}
+
+function graphMetadata(graph, seedId) {
+  const nodeById = new Map((graph.nodes ?? []).map((node) => [node.id, node]));
+  const values = [];
+  for (const edge of graph.edges ?? []) {
+    if (edge.source !== seedId) continue;
+    if (!['contains_heading', 'declares_package', 'declares_bin', 'includes_resource', 'depends_on'].includes(edge.relation)) continue;
+    const target = nodeById.get(edge.target);
+    const value = target?.title ?? target?.name ?? target?.target ?? target?.id;
+    if (value) values.push(`${edge.relation}: ${value}`);
+    if (values.length === MAX_VECTOR_PROFILE_METADATA_ITEMS) break;
+  }
+  return values;
+}
+
+function safeTextPrefix(root, path) {
+  if (unsafeProfilePath(path) || !TEXT_EXTENSIONS.has(extname(path).toLowerCase())) return '';
+  try {
+    const absolute = resolve(root, path);
+    if (!insideRoot(root, absolute)) return '';
+    const canonicalAbsolute = realpathSync(absolute);
+    if (!insideRoot(realpathSync(root), canonicalAbsolute)) return '';
+    const canonicalPath = relative(realpathSync(root), canonicalAbsolute).replaceAll('\\', '/');
+    if (canonicalPath !== path || unsafeProfilePath(canonicalPath) || !TEXT_EXTENSIONS.has(extname(canonicalPath).toLowerCase())) return '';
+    const stats = lstatSync(canonicalAbsolute);
+    if (!stats.isFile() || stats.isSymbolicLink() || stats.size > MAX_VECTOR_PROFILE_FILE_BYTES) return '';
+    const buffer = readFileSync(canonicalAbsolute);
+    if (buffer.includes(0)) return '';
+    const text = new TextDecoder('utf-8', { fatal: true }).decode(buffer);
+    return text.slice(0, MAX_VECTOR_PROFILE_CHARS);
+  } catch {
+    return '';
+  }
+}
+
+export function buildChangedFileProfile(root, path, graph = { nodes: [], edges: [] }) {
+  const normalized = canonicalizeChangedPath(root, path);
+  if (!normalized || normalized === '..' || normalized.startsWith('../') || normalized.includes('/../') || unsafeProfilePath(normalized)) return null;
+  const metadata = graphMetadata(graph, `file:${normalized}`);
+  const text = safeTextPrefix(root, normalized);
+  const sections = [`Path: ${normalized}`];
+  if (metadata.length) sections.push(`Graph metadata:\n${metadata.join('\n')}`);
+  if (text) sections.push(`Text:\n${text}`);
+  return { path: normalized, text: sections.join('\n\n').slice(0, MAX_VECTOR_PROFILE_CHARS), metadataItems: metadata.length, sourceTextIncluded: Boolean(text) };
+}

package/src/index/cache.mjs

@@ -7,7 +7,6 @@ import { addEdge, addNode, compactGraph, expandGraph, graphStats, jsonSize, shar
 import { cacheFile, collectIndexFiles, fingerprint } from './files.mjs';
 import { CACHE_VERSION } from './constants.mjs';
 import { buildGraph } from '../graph/extract.mjs';
-import { addDeterministicSemanticEdges } from '../graph/semantic.mjs';
 
 function collectFingerprints(root, config = readMemoryConfig(root)) {
   return collectIndexFiles(root, config).map((file) => {
@@ -45,7 +44,7 @@ export function buildIndex(root, previous = readIndex(root)) {
   const fullRebuild = !previous?.graph || previous.version !== CACHE_VERSION;
   const refreshReason = !previous ? 'missing' : previous.version !== CACHE_VERSION ? 'schema-mismatch' : removedPaths.length > 0 ? 'content-removed' : changedPaths.length > 0 ? 'content-changed' : 'fresh';
   const rawGraph = fullRebuild ? buildGraph(root, files.map((file) => join(root, file.path)), memoryConfig) : mergeIncrementalGraph(previous.graph, buildGraph(root, changedFiles, memoryConfig), changedPaths);
-  const graph = addDeterministicSemanticEdges(rawGraph, memoryConfig);
+  const graph = rawGraph;
   const archiveBodiesIncluded = (memoryConfig.areas ?? []).some((area) => area.id === 'archive-body' && area.includeBodiesByDefault !== false);
   return { version: CACHE_VERSION, schemaVersion: CACHE_VERSION, generatedAt: new Date().toISOString(), archiveBodiesIncluded, memoryConfig: memoryConfigSummary(memoryConfig), files, graph, stats: graphStats(graph), incremental: { enabled: true, fullRebuild, changedFiles: changedPaths.length, refreshReason, elapsedMs: Date.now() - startedAt } };
 }

package/src/index/constants.mjs

@@ -1,3 +1,3 @@
-export const CACHE_VERSION = 11;
+export const CACHE_VERSION = 13;
 export const CACHE_DIR = '.dotdotgod';
 export const MANIFEST_FILE = 'manifest.json';