@dotdotgod/cli 0.2.15 → 0.2.18

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';

package/src/memory/config.mjs

@@ -6,9 +6,16 @@ import { isKebabCase } from '../docs/markdown.mjs';
 const MEMORY_CONFIG_FILE = 'dotdotgod.config.json';
 const MEMORY_SCOPES = new Set(['shared', 'local']);
 const MEMORY_FRESHNESS = new Set(['fresh', 'stale']);
+export const DEFAULT_TRACEABILITY_KEYS = [
+  { key: 'implementedBy', label: 'Implemented by', description: 'Files that implement the behavior.', target: 'path', relation: 'implemented_by', weight: 4 },
+  { key: 'verifiedBy', label: 'Verified by', description: 'Tests or maintained verification documents.', target: 'path', relation: 'verified_by', weight: 4 },
+  { key: 'relatedDocs', label: 'Related docs', description: 'Documents needed to interpret the behavior.', target: 'path', relation: 'related_doc', weight: 3 },
+  { key: 'verificationCommands', label: 'Verification commands', description: 'Project-local verification commands.', target: 'command', relation: 'verification_command', weight: 3 },
+];
 export const DEFAULT_TRACEABILITY_POLICY = {
   required: ['docs/spec/**'],
   exclude: ['**/README.md'],
+  keys: DEFAULT_TRACEABILITY_KEYS,
 };
 export const DEFAULT_VALIDATION_POLICY = {
   markdown: {
@@ -32,37 +39,27 @@ export const DEFAULT_PLAN_MODE_POLICY = {
   writablePaths: ['docs/plan/**', 'docs/archive/**'],
 };
 export const DEFAULT_IMPACT_RANKING_POLICY = {
-  preset: 'balanced',
-  weights: { ppr: 40, traceability: 30, memoryPolicy: 10, verification: 15, proximity: 10, semantic: 10, freshness: 5, archivePenalty: -25 },
-  ppr: { enabled: true, damping: 0.85, iterations: 20, tolerance: 0.000001 },
+  connectionCap: 80,
+  memoryCap: 20,
+  ppr: { damping: 0.85, iterations: 20, tolerance: 0.000001, reference: 0.4 },
   relationWeights: {
-    implemented_by: 4,
-    verified_by: 4,
-    related_doc: 3,
-    verification_command: 3,
     links_to: 2,
+    routes_to: 2,
     belongs_to_area: 2,
-    semantic_similarity: 2,
-    mentions_package: 1,
+    vector_similarity: 2,
+    includes_resource: 1,
+    defines_contract: 2,
   },
-  traceabilityBoosts: { implemented_by: 30, 'incoming:implemented_by': 30, verified_by: 25, 'incoming:verified_by': 25, verification_command: 15, 'incoming:verification_command': 15, related_doc: 12, 'incoming:related_doc': 12 },
-  verificationBoosts: { verified_by: 15, 'incoming:verified_by': 15, verification_command: 12, 'incoming:verification_command': 12 },
-  semanticBoosts: { semantic_similarity: 8, 'incoming:semantic_similarity': 8, mentions_package: 4, 'incoming:mentions_package': 4 },
-  proximityBoosts: { links_to: 6, 'incoming:links_to': 6, routes_to: 5, 'incoming:routes_to': 5 },
-  semantic: { enabled: true, threshold: 0.5, topKPerFile: 5, includeArchiveBodies: false, signals: ['path', 'filename', 'heading', 'package'] },
-};
-const IMPACT_RANKING_PRESETS = {
-  balanced: {},
-  'docs-first': { weights: { ppr: 35, traceability: 35, memoryPolicy: 15, verification: 15, proximity: 5, semantic: 8, freshness: 5, archivePenalty: -30 } },
-  'code-proximity': { weights: { ppr: 45, traceability: 20, memoryPolicy: 8, verification: 12, proximity: 20, semantic: 8, freshness: 3, archivePenalty: -25 } },
-  'test-focused': { weights: { ppr: 35, traceability: 25, memoryPolicy: 8, verification: 25, proximity: 10, semantic: 7, freshness: 5, archivePenalty: -25 } },
-  'archive-aware': { weights: { ppr: 35, traceability: 25, memoryPolicy: 10, verification: 15, proximity: 10, semantic: 8, freshness: 3, archivePenalty: -10 } },
+  semantic: { enabled: true, threshold: 0.5, topKPerFile: 5 },
 };
-export const SEMANTIC_RELATIONS = new Set(['semantic_similarity', 'mentions_package']);
-const IMPACT_RANKING_WEIGHT_KEYS = new Set(['ppr', 'traceability', 'memoryPolicy', 'verification', 'proximity', 'semantic', 'freshness', 'archivePenalty']);
-const IMPACT_RANKING_RELATION_KEYS = new Set(['implemented_by', 'verified_by', 'related_doc', 'verification_command', 'links_to', 'belongs_to_area', 'semantic_similarity', 'mentions_package']);
-const IMPACT_RANKING_REASON_KEYS = new Set(['implemented_by', 'incoming:implemented_by', 'verified_by', 'incoming:verified_by', 'verification_command', 'incoming:verification_command', 'related_doc', 'incoming:related_doc', 'semantic_similarity', 'incoming:semantic_similarity', 'mentions_package', 'incoming:mentions_package', 'links_to', 'incoming:links_to', 'routes_to', 'incoming:routes_to']);
-const SEMANTIC_SIGNAL_KEYS = new Set(['path', 'filename', 'heading', 'package']);
+export const SEMANTIC_RELATIONS = new Set(['vector_similarity']);
+const TRACEABILITY_TARGETS = new Set(['path', 'command']);
+const TRACEABILITY_RESERVED_KEYS = new Set(['kind', 'contracts', 'id', 'title', 'sections']);
+export const BUILT_IN_GRAPH_RELATIONS = new Set([
+  'belongs_to_area', 'includes_resource', 'defines_contract', 'contains_heading', 'links_to', 'routes_to',
+  'declares_package', 'declares_script', 'declares_bin', 'depends_on', 'vector_similarity',
+]);
+const TRACEABILITY_RESERVED_RELATIONS = BUILT_IN_GRAPH_RELATIONS;
 const DEFAULT_FUZZY_LOW_SIGNAL_TERMS = [
   'a', 'an', 'and', 'are', 'as', 'by', 'docs', 'document', 'for', 'from', 'it', 'of', 'on', 'plan', 'test', 'the', 'to', 'update', 'version', 'with',
   '계획', '문서', '수정', '업데이트', '버전', '정보', '확인', '테스트',
@@ -109,13 +106,22 @@ function cloneArea(area) {
   }, area);
 }
 
+function cloneTraceabilityKey(definition) {
+  return { key: definition.key, label: definition.label, description: definition.description, target: definition.target, relation: definition.relation, weight: definition.weight };
+}
+
 export function cloneTraceabilityPolicy(policy = DEFAULT_TRACEABILITY_POLICY) {
   return {
     required: [...(policy.required ?? [])],
     exclude: [...(policy.exclude ?? [])],
+    keys: (policy.keys ?? DEFAULT_TRACEABILITY_KEYS).map(cloneTraceabilityKey),
   };
 }
 
+export function traceabilityRelationWeights(policy = DEFAULT_TRACEABILITY_POLICY) {
+  return Object.fromEntries((policy.keys ?? DEFAULT_TRACEABILITY_KEYS).map((definition) => [definition.relation, definition.weight]));
+}
+
 export function cloneValidationPolicy(policy = DEFAULT_VALIDATION_POLICY) {
   const filename = policy.markdown?.filename;
   return {
@@ -132,15 +138,11 @@ export function cloneValidationPolicy(policy = DEFAULT_VALIDATION_POLICY) {
 
 export function cloneImpactRankingPolicy(policy = DEFAULT_IMPACT_RANKING_POLICY) {
   return {
-    preset: policy.preset ?? 'balanced',
-    weights: { ...DEFAULT_IMPACT_RANKING_POLICY.weights, ...(policy.weights ?? {}) },
-    ppr: { ...DEFAULT_IMPACT_RANKING_POLICY.ppr, ...(policy.ppr ?? {}) },
-    relationWeights: { ...DEFAULT_IMPACT_RANKING_POLICY.relationWeights, ...(policy.relationWeights ?? {}) },
-    traceabilityBoosts: { ...DEFAULT_IMPACT_RANKING_POLICY.traceabilityBoosts, ...(policy.traceabilityBoosts ?? {}) },
-    verificationBoosts: { ...DEFAULT_IMPACT_RANKING_POLICY.verificationBoosts, ...(policy.verificationBoosts ?? {}) },
-    semanticBoosts: { ...DEFAULT_IMPACT_RANKING_POLICY.semanticBoosts, ...(policy.semanticBoosts ?? {}) },
-    proximityBoosts: { ...DEFAULT_IMPACT_RANKING_POLICY.proximityBoosts, ...(policy.proximityBoosts ?? {}) },
-    semantic: { ...DEFAULT_IMPACT_RANKING_POLICY.semantic, ...(policy.semantic ?? {}), signals: [...(policy.semantic?.signals ?? DEFAULT_IMPACT_RANKING_POLICY.semantic.signals)] },
+    connectionCap: DEFAULT_IMPACT_RANKING_POLICY.connectionCap,
+    memoryCap: DEFAULT_IMPACT_RANKING_POLICY.memoryCap,
+    ppr: { ...DEFAULT_IMPACT_RANKING_POLICY.ppr },
+    relationWeights: { ...DEFAULT_IMPACT_RANKING_POLICY.relationWeights },
+    semantic: { ...DEFAULT_IMPACT_RANKING_POLICY.semantic, ...(policy.semantic ?? {}) },
   };
 }
 
@@ -169,9 +171,16 @@ function normalizeReferenceExpansionPolicy(raw) {
 }
 
 function normalizeImpactRankingPolicy(raw) {
-  const presetName = typeof raw?.preset === 'string' ? raw.preset : 'balanced';
-  const preset = IMPACT_RANKING_PRESETS[presetName] ?? IMPACT_RANKING_PRESETS.balanced;
-  return cloneImpactRankingPolicy({ ...preset, ...raw, preset: presetName, weights: { ...(preset.weights ?? {}), ...(raw?.weights ?? {}) }, ppr: { ...(preset.ppr ?? {}), ...(raw?.ppr ?? {}) }, semantic: { ...(preset.semantic ?? {}), ...(raw?.semantic ?? {}) } });
+  const candidate = raw && typeof raw === 'object' && !Array.isArray(raw)
+    && raw.semantic && typeof raw.semantic === 'object' && !Array.isArray(raw.semantic)
+    ? raw.semantic
+    : {};
+  const semantic = {
+    ...(typeof candidate.enabled === 'boolean' ? { enabled: candidate.enabled } : {}),
+    ...(isFiniteNumberInRange(candidate.threshold, 0, 1) ? { threshold: candidate.threshold } : {}),
+    ...(Number.isInteger(candidate.topKPerFile) && candidate.topKPerFile >= 0 && candidate.topKPerFile <= 20 ? { topKPerFile: candidate.topKPerFile } : {}),
+  };
+  return cloneImpactRankingPolicy({ semantic });
 }
 
 export function cloneLoadPolicy(policy = DEFAULT_LOAD_POLICY) {
@@ -237,6 +246,7 @@ function normalizeTraceabilityPolicy(raw) {
   return {
     required: Array.isArray(raw.required) ? raw.required.map(normalizePathPattern) : [],
     exclude: Array.isArray(raw.exclude) ? raw.exclude.map(normalizePathPattern) : [],
+    keys: (raw.keys === undefined ? DEFAULT_TRACEABILITY_KEYS : raw.keys).map(cloneTraceabilityKey),
   };
 }
 
@@ -274,8 +284,8 @@ function normalizeLoadPolicy(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return cloneLoadPolicy();
   const normalize = (values) => (Array.isArray(values) ? [...new Set(values.map(normalizePathPattern))] : []);
   return cloneLoadPolicy({
-    pinnedPaths: normalize(raw.pinnedPaths),
-    pinnedBodies: normalize(raw.pinnedBodies),
+    pinnedPaths: [],
+    pinnedBodies: [],
     documentationSummary: {
       exclude: raw.documentationSummary?.exclude === undefined
         ? DEFAULT_LOAD_POLICY.documentationSummary.exclude
@@ -314,10 +324,6 @@ function isFiniteNumberInRange(value, min, max) {
   return typeof value === 'number' && Number.isFinite(value) && value >= min && value <= max;
 }
 
-function validateNumberMap(map, keys, min, max) {
-  return map && typeof map === 'object' && !Array.isArray(map) && Object.entries(map).every(([key, value]) => keys.has(key) && isFiniteNumberInRange(value, min, max));
-}
-
 export function validateMemoryConfigData(data, root = '.', file = 'dotdotgod.config.json') {
   const errors = [];
   const add = (code, field, message, fix = null) => errors.push({
@@ -338,6 +344,26 @@ export function validateMemoryConfigData(data, root = '.', file = 'dotdotgod.con
       else if (traceability.required.some((value) => !isValidPathPattern(value))) add('TRACEABILITY_CONFIG_INVALID_REQUIRED', 'traceability.required', 'Expected path strings using exact paths, /** subtree patterns, or **/suffix patterns.');
       if (traceability.exclude !== undefined && !Array.isArray(traceability.exclude)) add('TRACEABILITY_CONFIG_INVALID_EXCLUDE', 'traceability.exclude', 'Expected an array of path strings.');
       else if (Array.isArray(traceability.exclude) && traceability.exclude.some((value) => !isValidPathPattern(value))) add('TRACEABILITY_CONFIG_INVALID_EXCLUDE', 'traceability.exclude', 'Expected path strings using exact paths, /** subtree patterns, or **/suffix patterns.');
+      if (traceability.keys !== undefined && !Array.isArray(traceability.keys)) add('TRACEABILITY_CONFIG_INVALID_KEYS', 'traceability.keys', 'Expected an array of traceability key definitions.');
+      else if (Array.isArray(traceability.keys)) {
+        const keys = new Set();
+        const labels = new Set();
+        const relations = new Set();
+        for (const [index, definition] of traceability.keys.entries()) {
+          const prefix = `traceability.keys[${index}]`;
+          if (!definition || typeof definition !== 'object' || Array.isArray(definition)) { add('TRACEABILITY_CONFIG_INVALID_KEY', prefix, 'Expected an object.'); continue; }
+          const allowed = new Set(['key', 'label', 'description', 'target', 'relation', 'weight']);
+          if (Object.keys(definition).some((key) => !allowed.has(key))) add('TRACEABILITY_CONFIG_INVALID_KEY', prefix, 'Contains unsupported fields.');
+          if (typeof definition.key !== 'string' || !/^[A-Za-z][A-Za-z0-9]*$/.test(definition.key) || TRACEABILITY_RESERVED_KEYS.has(definition.key) || keys.has(definition.key)) add('TRACEABILITY_CONFIG_INVALID_KEY', `${prefix}.key`, 'Expected a unique non-reserved identifier.'); else keys.add(definition.key);
+          const trimmedLabel = typeof definition.label === 'string' ? definition.label.trim() : '';
+          const normalizedLabel = trimmedLabel.toLocaleLowerCase();
+          if (!normalizedLabel || /[\u0000-\u001f\u007f]/.test(trimmedLabel) || labels.has(normalizedLabel)) add('TRACEABILITY_CONFIG_INVALID_LABEL', `${prefix}.label`, 'Expected a unique single-line non-empty label after trimming and case normalization.'); else labels.add(normalizedLabel);
+          if (typeof definition.description !== 'string' || !definition.description.trim()) add('TRACEABILITY_CONFIG_INVALID_DESCRIPTION', `${prefix}.description`, 'Expected a non-empty description.');
+          if (!TRACEABILITY_TARGETS.has(definition.target)) add('TRACEABILITY_CONFIG_INVALID_TARGET', `${prefix}.target`, 'Expected "path" or "command".');
+          if (typeof definition.relation !== 'string' || !/^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/.test(definition.relation) || TRACEABILITY_RESERVED_RELATIONS.has(definition.relation) || relations.has(definition.relation)) add('TRACEABILITY_CONFIG_INVALID_RELATION', `${prefix}.relation`, 'Expected a unique canonical snake_case relation not reserved by the graph.'); else relations.add(definition.relation);
+          if (!isFiniteNumberInRange(definition.weight, 0, 20)) add('TRACEABILITY_CONFIG_INVALID_WEIGHT', `${prefix}.weight`, 'Expected a finite number from 0 to 20.');
+        }
+      }
     }
   }
   const validation = data.validation;
@@ -371,15 +397,6 @@ export function validateMemoryConfigData(data, root = '.', file = 'dotdotgod.con
     if (!load || typeof load !== 'object' || Array.isArray(load)) {
       add('LOAD_CONFIG_INVALID', 'load', 'Expected an object.');
     } else {
-      for (const [key, code] of [['pinnedPaths', 'LOAD_CONFIG_INVALID_PINNED_PATHS'], ['pinnedBodies', 'LOAD_CONFIG_INVALID_PINNED_BODIES']]) {
-        const values = load[key];
-        if (values === undefined) continue;
-        if (!Array.isArray(values)) add(code, `load.${key}`, 'Expected an array of path strings.');
-        else {
-          if (values.some((value) => !isValidPathPattern(value) || (typeof value === 'string' && value.trim().startsWith('/')))) add(code, `load.${key}`, 'Expected repository-relative path strings using exact paths, /** subtree patterns, or **/suffix patterns.');
-          if (values.some((value) => typeof value === 'string' && isSecretLikePathPattern(value))) add('LOAD_CONFIG_SECRET_PINNED_PATH', `load.${key}`, 'Pinned load paths must not target secrets, credentials, environment files, or private keys.');
-        }
-      }
       if (load.documentationSummary !== undefined) {
         const summary = load.documentationSummary;
         if (!summary || typeof summary !== 'object' || Array.isArray(summary)) {
@@ -421,40 +438,6 @@ export function validateMemoryConfigData(data, root = '.', file = 'dotdotgod.con
       }
     }
   }
-  const impactRanking = data.impactRanking;
-  if (impactRanking !== undefined) {
-    if (!impactRanking || typeof impactRanking !== 'object' || Array.isArray(impactRanking)) {
-      add('IMPACT_RANKING_CONFIG_INVALID', 'impactRanking', 'Expected an object.');
-    } else {
-      if (impactRanking.preset !== undefined && !Object.hasOwn(IMPACT_RANKING_PRESETS, impactRanking.preset)) add('IMPACT_RANKING_CONFIG_INVALID_PRESET', 'impactRanking.preset', 'Expected one of balanced, docs-first, code-proximity, test-focused, or archive-aware.');
-      if (impactRanking.weights !== undefined && !validateNumberMap(impactRanking.weights, IMPACT_RANKING_WEIGHT_KEYS, -100, 100)) add('IMPACT_RANKING_CONFIG_INVALID_WEIGHTS', 'impactRanking.weights', 'Expected known numeric weight keys with finite values from -100 to 100.');
-      if (impactRanking.relationWeights !== undefined && !validateNumberMap(impactRanking.relationWeights, IMPACT_RANKING_RELATION_KEYS, 0, 20)) add('IMPACT_RANKING_CONFIG_INVALID_RELATION_WEIGHTS', 'impactRanking.relationWeights', 'Expected known relation keys with finite values from 0 to 20.');
-      for (const key of ['traceabilityBoosts', 'verificationBoosts', 'semanticBoosts', 'proximityBoosts']) {
-        if (impactRanking[key] !== undefined && !validateNumberMap(impactRanking[key], IMPACT_RANKING_REASON_KEYS, 0, 100)) add('IMPACT_RANKING_CONFIG_INVALID_BOOSTS', `impactRanking.${key}`, 'Expected known reason keys with finite values from 0 to 100.');
-      }
-      if (impactRanking.ppr !== undefined) {
-        const ppr = impactRanking.ppr;
-        if (!ppr || typeof ppr !== 'object' || Array.isArray(ppr)) add('IMPACT_RANKING_CONFIG_INVALID_PPR', 'impactRanking.ppr', 'Expected an object.');
-        else {
-          if (ppr.enabled !== undefined && typeof ppr.enabled !== 'boolean') add('IMPACT_RANKING_CONFIG_INVALID_PPR', 'impactRanking.ppr.enabled', 'Expected a boolean.');
-          if (ppr.damping !== undefined && !isFiniteNumberInRange(ppr.damping, 0.01, 0.99)) add('IMPACT_RANKING_CONFIG_INVALID_PPR', 'impactRanking.ppr.damping', 'Expected a number greater than 0 and less than 1.');
-          if (ppr.iterations !== undefined && (!Number.isInteger(ppr.iterations) || ppr.iterations < 1 || ppr.iterations > 100)) add('IMPACT_RANKING_CONFIG_INVALID_PPR', 'impactRanking.ppr.iterations', 'Expected an integer from 1 to 100.');
-          if (ppr.tolerance !== undefined && !isFiniteNumberInRange(ppr.tolerance, 0, 1)) add('IMPACT_RANKING_CONFIG_INVALID_PPR', 'impactRanking.ppr.tolerance', 'Expected a number from 0 to 1.');
-        }
-      }
-      if (impactRanking.semantic !== undefined) {
-        const semantic = impactRanking.semantic;
-        if (!semantic || typeof semantic !== 'object' || Array.isArray(semantic)) add('IMPACT_RANKING_CONFIG_INVALID_SEMANTIC', 'impactRanking.semantic', 'Expected an object.');
-        else {
-          if (semantic.enabled !== undefined && typeof semantic.enabled !== 'boolean') add('IMPACT_RANKING_CONFIG_INVALID_SEMANTIC', 'impactRanking.semantic.enabled', 'Expected a boolean.');
-          if (semantic.threshold !== undefined && !isFiniteNumberInRange(semantic.threshold, 0, 1)) add('IMPACT_RANKING_CONFIG_INVALID_SEMANTIC', 'impactRanking.semantic.threshold', 'Expected a number from 0 to 1.');
-          if (semantic.topKPerFile !== undefined && (!Number.isInteger(semantic.topKPerFile) || semantic.topKPerFile < 0 || semantic.topKPerFile > 20)) add('IMPACT_RANKING_CONFIG_INVALID_SEMANTIC', 'impactRanking.semantic.topKPerFile', 'Expected an integer from 0 to 20.');
-          if (semantic.includeArchiveBodies !== undefined && typeof semantic.includeArchiveBodies !== 'boolean') add('IMPACT_RANKING_CONFIG_INVALID_SEMANTIC', 'impactRanking.semantic.includeArchiveBodies', 'Expected a boolean.');
-          if (semantic.signals !== undefined && (!Array.isArray(semantic.signals) || semantic.signals.some((value) => !SEMANTIC_SIGNAL_KEYS.has(value)))) add('IMPACT_RANKING_CONFIG_INVALID_SEMANTIC', 'impactRanking.semantic.signals', 'Expected an array of known deterministic signal names.');
-        }
-      }
-    }
-  }
   const areas = data.memory?.areas;
   if (areas === undefined) return errors;
   if (!Array.isArray(areas)) {
@@ -540,7 +523,7 @@ export function defaultDotdotgodConfigData() {
     },
     traceability: cloneTraceabilityPolicy(config.traceability),
     validation: cloneValidationPolicy(config.validation),
-    impactRanking: cloneImpactRankingPolicy(config.impactRanking),
+    impactRanking: { semantic: { ...config.impactRanking.semantic } },
     referenceExpansion: { fuzzy: { lowSignal: { add: [], remove: [] } } },
     load: cloneLoadPolicy(config.load),
     planMode: clonePlanModePolicy(config.planMode),
@@ -567,7 +550,15 @@ export function memoryConfigSummary(config) {
     }, area)),
     traceability: cloneTraceabilityPolicy(config.traceability ?? DEFAULT_TRACEABILITY_POLICY),
     validation: cloneValidationPolicy(config.validation ?? DEFAULT_VALIDATION_POLICY),
-    impactRanking: cloneImpactRankingPolicy(config.impactRanking ?? DEFAULT_IMPACT_RANKING_POLICY),
+    impactRanking: {
+      fixed: {
+        connectionCap: DEFAULT_IMPACT_RANKING_POLICY.connectionCap,
+        memoryCap: DEFAULT_IMPACT_RANKING_POLICY.memoryCap,
+        ppr: { ...DEFAULT_IMPACT_RANKING_POLICY.ppr },
+        relationWeights: { ...DEFAULT_IMPACT_RANKING_POLICY.relationWeights },
+      },
+      semantic: { ...cloneImpactRankingPolicy(config.impactRanking ?? DEFAULT_IMPACT_RANKING_POLICY).semantic },
+    },
     referenceExpansion: cloneReferenceExpansionPolicy(config.referenceExpansion),
     load: cloneLoadPolicy(config.load),
     planMode: clonePlanModePolicy(config.planMode),