@ngockhoale/ukit 2.6.8 → 2.6.10

package/src/core/codeintel/retriever.js

@@ -5,6 +5,7 @@ import { getArtifactPath, INDEX_ARTIFACTS, INDEX_SCHEMA_VERSION, normalizeRelati
 import { loadRuntimeConfig } from '../runtimeConfig.js';
 import { createEdge, getSemanticProvider, IndexFileSyntaxProvider } from './providers.js';
 import { createSemanticProvider } from './semanticProvider.js';
+import { createEmbeddingProvider } from './vectorProvider.js';
 
 // Hybrid Retriever (SPEC §3): each lane produces a ranked list of file paths,
 // then lanes merge via Reciprocal Rank Fusion (k=60, per-lane weights from
@@ -15,8 +16,8 @@ import { createSemanticProvider } from './semanticProvider.js';
 const DEFAULT_LIMIT = 20;
 const DEFAULT_BM25 = { k1: 1.2, b: 0.75 };
 const DEFAULT_RRF_K = 60;
-const DEFAULT_WEIGHTS = { exact: 1.0, symbol: 1.2, bm25: 0.8, semantic: 1.0 };
-const LANE_ORDER = ['exact', 'symbol', 'bm25', 'semantic'];
+const DEFAULT_WEIGHTS = { exact: 1.0, symbol: 1.2, bm25: 0.8, vector: 0.6, semantic: 1.0 };
+const LANE_ORDER = ['exact', 'symbol', 'bm25', 'vector', 'semantic'];
 
 async function readArtifact(rootDir, name) {
   try {
@@ -56,6 +57,7 @@ function retrieverDefaults(config) {
       exact: weight('exact'),
       symbol: weight('symbol'),
       bm25: weight('bm25'),
+      vector: weight('vector'),
       semantic: weight('semantic'),
     },
   };
@@ -192,6 +194,39 @@ async function semanticLane(rootDir, normalizedQuery, config, fileSet, snapshotI
   return { lane, why: lane.length === 0 ? 'no-match' : null };
 }
 
+// Vector lane (SPEC §2/§3): dep-free hashed embedding provider; mirrors the
+// semantic lane. Edges' `to` carries "file:0" — reduce to a ranked file list.
+async function vectorLane(rootDir, normalizedQuery, config, fileSet, snapshotId) {
+  const provider = createEmbeddingProvider({ projectRoot: rootDir, config });
+  if (!provider || provider.name === 'null' || typeof provider.resolve !== 'function') {
+    return { lane: null, why: 'unavailable' };
+  }
+  let edges;
+  try {
+    edges = await provider.resolve(normalizedQuery, { limit: DEFAULT_LIMIT, snapshot: snapshotId });
+  } catch {
+    return { lane: null, why: 'provider-error' };
+  }
+  if (edges === null || edges === undefined) {
+    return { lane: null, why: 'unavailable' };
+  }
+  if (!Array.isArray(edges) || edges.length === 0) {
+    return { lane: [], why: 'no-match' };
+  }
+  const lane = [];
+  const seen = new Set();
+  for (const edge of edges) {
+    const target = typeof edge?.to === 'string' ? edge.to.split(':')[0] : null;
+    if (!target) continue;
+    const rel = path.isAbsolute(target) ? normalizeRelative(rootDir, target) : target;
+    if (seen.has(rel)) continue;
+    if (fileSet.size > 0 && !fileSet.has(rel)) continue;
+    seen.add(rel);
+    lane.push(laneEntry(rel, `vector ${edge.kind ?? 'match'} for "${normalizedQuery}"`));
+  }
+  return { lane, why: lane.length === 0 ? 'no-match' : null };
+}
+
 function rrfMerge(lanes, weights, rrfK) {
   const scores = new Map();
   const meta = new Map();
@@ -199,6 +234,7 @@ function rrfMerge(lanes, weights, rrfK) {
     const lane = lanes.get(laneName);
     if (!lane) continue;
     const w = weights[laneName] ?? 0;
+    if (w <= 0) continue;
     lane.forEach((entry, index) => {
       scores.set(entry.path, (scores.get(entry.path) ?? 0) + w / (rrfK + index + 1));
       if (!meta.has(entry.path)) meta.set(entry.path, entry);
@@ -312,7 +348,17 @@ export async function retrieve(projectRoot, query, { mode = 'search', limit, sna
     lanes.set('bm25', bm25.slice(0, Math.max(effectiveLimit, 100)));
   }
 
-  // Lane 4 — semantic provider (defensive; absent → skipped, never fatal).
+  // Lane 4 — dep-free hashed vector provider (index-bound; absent → omitted).
+  const vector = await vectorLane(rootDir, normalizedQuery, config, fileSet, snapshotId);
+  if (vector.lane === null) {
+    omitted.push({ what: 'vector-lane', why: vector.why });
+  } else if (vector.lane.length > 0) {
+    lanes.set('vector', vector.lane);
+  } else {
+    omitted.push({ what: 'vector-lane', why: vector.why });
+  }
+
+  // Lane 5 — semantic provider (defensive; absent → skipped, never fatal).
   const semantic = await semanticLane(rootDir, normalizedQuery, config, fileSet, snapshotId);
   if (semantic.lane === null) {
     omitted.push({ what: 'semantic-lane', why: semantic.why });

package/src/core/codeintel/summaries.js

@@ -0,0 +1,194 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { getSyntaxProvider } from './providers.js';
+import { resolveProjectRelativePath } from '../fileOps.js';
+
+// Deterministic extractive summaries (SPEC §7/§8, CI-304) — the L3 detail tier.
+// No model calls, no clock/random, no new deps. File reads are bounded to the
+// first MAX_READ_LINES lines; extraction is pure text scanning over docblocks,
+// declaration regexes, and the index-file symbol provider.
+
+const MAX_READ_LINES = 200;
+const DEFAULT_MAX_CHARS = 240;
+const DEFAULT_SYMBOL_MAX_CHARS = 160;
+const DEFAULT_MAX_SYMBOLS = 8;
+
+const DECL_RE = /^\s*(?:export\s+default\s+|export\s+)?(?:async\s+)?(?:function\*?|class|const|let|var)\s+([A-Za-z_$][\w$]*)/;
+
+async function readHead(rootDir, relPath) {
+  try {
+    const abs = resolveProjectRelativePath(rootDir, relPath);
+    if (!abs) return null;
+    const content = await fs.readFile(abs, 'utf8');
+    return { content, lines: content.split('\n').slice(0, MAX_READ_LINES), bytes: Buffer.byteLength(content, 'utf8') };
+  } catch {
+    return null;
+  }
+}
+
+// Extract the first sentence of a docblock: with `endIndex` omitted, reads the
+// leading file-level docblock at the top of `lines`; with `endIndex`, finds the
+// docblock ending right before a declaration line (lines above decl passed in).
+function docblockFirstSentence(lines, endIndex = lines.length) {
+  if (endIndex === lines.length) {
+    // File-level lane: the docblock must start at (or near) the top of file.
+    let start = 0;
+    while (start < lines.length && (lines[start].trim() === '' || lines[start].startsWith('#!'))) start += 1;
+    const first = (lines[start] ?? '').trim();
+    const isBlock = first.startsWith('/*');
+    const isLine = first.startsWith('//');
+    if (!isBlock && !isLine) return null;
+    const block = [];
+    if (isLine) {
+      for (let i = start; i < lines.length; i += 1) {
+        const t = lines[i].trim();
+        if (!t.startsWith('//')) break;
+        block.push(t.replace(/^\/\/+\s?/, ''));
+      }
+    } else {
+      for (let i = start; i < lines.length; i += 1) {
+        const t = lines[i].trim();
+        block.push(t.replace(/^\/\*\*?\s?/, '').replace(/\*\/\s?$/, '').replace(/^\*\s?/, ''));
+        if (t.endsWith('*/')) break;
+      }
+    }
+    const text = block.join(' ').replace(/\s+/g, ' ').trim();
+    if (!text) return null;
+    const m = text.match(/^.+?[.!?](?:\s|$)/);
+    return (m ? m[0] : text).trim();
+  }
+
+  // Find the last docblock ending at or before endIndex, scanning backwards
+  // for a '*/' terminator so decl-adjacent blocks are preferred.
+  let end = -1;
+  for (let i = Math.min(endIndex, lines.length) - 1; i >= 0; i -= 1) {
+    const t = lines[i].trim();
+    if (t === '' || t.startsWith('//') || t.startsWith('/*') || t.startsWith('*') || t.endsWith('*/')) {
+      if (t.endsWith('*/')) { end = i; break; }
+      if (t.startsWith('//')) { end = i; break; }
+      continue;
+    }
+    break;
+  }
+  if (end < 0) return null;
+
+  const block = [];
+  const tail = lines[end].trim();
+  if (tail.startsWith('//')) {
+    for (let i = end; i >= 0; i -= 1) {
+      const t = lines[i].trim();
+      if (!t.startsWith('//')) break;
+      block.unshift(t.replace(/^\/\/+\s?/, ''));
+    }
+  } else {
+    for (let i = end; i >= 0; i -= 1) {
+      const t = lines[i].trim();
+      const isBoundary = t.startsWith('/**') || t.startsWith('/*');
+      block.unshift(t.replace(/^\/\*\*?\s?/, '').replace(/\*\/\s?$/, '').replace(/^\*\s?/, ''));
+      if (isBoundary) break;
+    }
+  }
+
+  const text = block.join(' ').replace(/\s+/g, ' ').trim();
+  if (!text) return null;
+  const m = text.match(/^.+?[.!?](?:\s|$)/);
+  return (m ? m[0] : text).trim();
+}
+
+// Truncate on a word boundary — never mid-word.
+function truncateWords(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  const slice = text.slice(0, maxChars);
+  const lastSpace = slice.lastIndexOf(' ');
+  const cut = lastSpace > 0 ? slice.slice(0, lastSpace) : slice;
+  return cut.trimEnd();
+}
+
+// Regex fallback when the index symbols artifact is absent — bounded, dep-free.
+function scanDeclarations(lines, maxSymbols) {
+  const names = [];
+  for (const line of lines) {
+    const m = line.match(DECL_RE);
+    if (m && !names.includes(m[1])) names.push(m[1]);
+    if (names.length >= maxSymbols) break;
+  }
+  return names;
+}
+
+async function symbolNames(rootDir, relPath, lines, maxSymbols) {
+  try {
+    const provider = getSyntaxProvider(relPath);
+    if (provider) {
+      const syms = await provider.symbols(relPath);
+      if (Array.isArray(syms) && syms.length > 0) {
+        return syms.slice(0, maxSymbols).map((s) => s.name).filter(Boolean);
+      }
+    }
+  } catch {
+    // provider failure falls through to the regex lane — never throws
+  }
+  return scanDeclarations(lines, maxSymbols);
+}
+
+/**
+ * summarizeFile(rootDir, relPath, { maxSymbols=8, maxChars=240 })
+ *   → { path, summary, symbolCount, bytes } | null
+ *
+ * Extractive summary: leading docblock first sentence + top symbol names.
+ * Falls back to a path/size description for docblock-free files. Returns null
+ * only when the file cannot be read. Deterministic across calls.
+ */
+export async function summarizeFile(rootDir, relPath, opts = {}) {
+  if (!relPath || typeof relPath !== 'string') return null;
+  const maxChars = typeof opts.maxChars === 'number' ? opts.maxChars : DEFAULT_MAX_CHARS;
+  const maxSymbols = typeof opts.maxSymbols === 'number' ? opts.maxSymbols : DEFAULT_MAX_SYMBOLS;
+
+  const head = await readHead(rootDir, relPath);
+  if (!head) return null;
+
+  const parts = [];
+  const doc = docblockFirstSentence(head.lines);
+  if (doc) parts.push(doc);
+
+  const names = await symbolNames(rootDir, relPath, head.lines, maxSymbols);
+  if (names.length > 0) parts.push(`exports: ${names.join(', ')}`);
+
+  const summary = parts.length > 0
+    ? parts.join(' — ')
+    : `${relPath} (${head.bytes} bytes)`;
+
+  return {
+    path: relPath,
+    summary: truncateWords(summary, maxChars),
+    symbolCount: names.length,
+    bytes: head.bytes,
+  };
+}
+
+/**
+ * summarizeSymbol(rootDir, relPath, symbolName, { maxChars=160 })
+ *   → { path, symbol, summary } | null
+ *
+ * Docblock-above-decl + the declaration signature line. Null when the file is
+ * unreadable or the symbol is absent. Deterministic.
+ */
+export async function summarizeSymbol(rootDir, relPath, symbolName, opts = {}) {
+  if (!relPath || !symbolName) return null;
+  const maxChars = typeof opts.maxChars === 'number' ? opts.maxChars : DEFAULT_SYMBOL_MAX_CHARS;
+
+  const head = await readHead(rootDir, relPath);
+  if (!head) return null;
+
+  const declIndex = head.lines.findIndex((line) => {
+    const m = line.match(DECL_RE);
+    return m && m[1] === symbolName;
+  });
+  if (declIndex < 0) return null;
+
+  const signature = head.lines[declIndex].trim();
+  const doc = docblockFirstSentence(head.lines, declIndex);
+  const summary = doc ? `${doc} ${signature}` : signature;
+
+  return { path: relPath, symbol: symbolName, summary: truncateWords(summary, maxChars) };
+}

package/src/core/codeintel/vectorProvider.js

@@ -0,0 +1,213 @@
+import fs from 'node:fs/promises';
+
+import { getArtifactPath, INDEX_ARTIFACTS, INDEX_SCHEMA_VERSION } from '../../index/paths.js';
+import { createEdge } from './providers.js';
+
+// Dep-free embedding lane (SPEC §2): feature hashing (FNV-1a 32-bit) over word
+// tokens + word-boundary trigrams, L2-normalized, cosine-ranked against the
+// same doc text the BM25 lane uses (file paths + symbol names). No file reads,
+// no deps — real embeddings plug in later through the injectable `loader`
+// seam (config.codeIntel.embedding.provider === 'auto'), degrading to the
+// hashed provider on ANY failure. Never throws.
+
+const DEFAULT_DIMENSIONS = 256;
+const DEFAULT_LIMIT = 20;
+
+function fnv1a(str) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i += 1) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h >>> 0;
+}
+
+function wordTokens(text) {
+  return String(text ?? '')
+    .split(/[^A-Za-z0-9_$]+/)
+    .map((t) => t.toLowerCase())
+    .filter(Boolean);
+}
+
+function trigrams(token) {
+  const padded = `#${token}#`;
+  const grams = [];
+  for (let i = 0; i + 3 <= padded.length; i += 1) {
+    grams.push(padded.slice(i, i + 3));
+  }
+  return grams;
+}
+
+/**
+ * hashVectorize(text, { dimensions }) → number[] of length `dimensions`,
+ * L2-normalized (zero vector for empty/null input). Deterministic.
+ */
+export function hashVectorize(text, { dimensions = DEFAULT_DIMENSIONS } = {}) {
+  const dims = Number.isInteger(dimensions) && dimensions > 0 ? dimensions : DEFAULT_DIMENSIONS;
+  const vec = new Array(dims).fill(0);
+  const tokens = wordTokens(text);
+  for (const token of tokens) {
+    vec[fnv1a(`w:${token}`) % dims] += 1;
+    for (const gram of trigrams(token)) {
+      vec[fnv1a(`t:${gram}`) % dims] += 0.1;
+    }
+  }
+  const norm = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
+  if (norm > 0) {
+    for (let i = 0; i < dims; i += 1) vec[i] /= norm;
+  }
+  return vec;
+}
+
+/** cosineSimilarity(a, b) → number in [-1, 1]; 0 on dim mismatch/empty. */
+export function cosineSimilarity(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length === 0 || a.length !== b.length) {
+    return 0;
+  }
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+async function readArtifact(rootDir, name) {
+  try {
+    const raw = await fs.readFile(getArtifactPath(rootDir, name), 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed?.schemaVersion !== undefined && parsed.schemaVersion !== INDEX_SCHEMA_VERSION) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export class HashedEmbeddingProvider {
+  constructor({ projectRoot = process.cwd(), dimensions = DEFAULT_DIMENSIONS, embedFn = null } = {}) {
+    this.name = 'hashed-vector';
+    this.projectRoot = projectRoot;
+    this.dimensions = Number.isInteger(dimensions) && dimensions > 0 ? dimensions : DEFAULT_DIMENSIONS;
+    this._embedFn = typeof embedFn === 'function' ? embedFn : null;
+  }
+
+  async available() {
+    return true;
+  }
+
+  capabilities() {
+    return { embeddings: true, similarity: true };
+  }
+
+  async embed(text) {
+    if (this._embedFn) {
+      const vec = await this._embedFn(String(text ?? ''));
+      if (Array.isArray(vec)) return vec;
+    }
+    return hashVectorize(text, { dimensions: this.dimensions });
+  }
+
+  /**
+   * resolve(query, ctx { limit?, snapshot? }) → edge[] | null.
+   * Corpus: files.json paths + symbols.json names — index-bound, no file reads.
+   * Missing index → null (caller records 'unavailable'); empty index → [].
+   */
+  async resolve(query, ctx = {}) {
+    try {
+      const [filesArtifact, symbolsArtifact] = await Promise.all([
+        readArtifact(this.projectRoot, INDEX_ARTIFACTS.files),
+        readArtifact(this.projectRoot, INDEX_ARTIFACTS.symbols),
+      ]);
+      if (!filesArtifact && !symbolsArtifact) {
+        return null;
+      }
+      const limit = Number.isInteger(ctx?.limit) && ctx.limit > 0 ? ctx.limit : DEFAULT_LIMIT;
+      const queryVec = await this.embed(query);
+      const docs = new Map();
+      for (const item of filesArtifact?.items ?? []) {
+        if (!item?.filePath) continue;
+        docs.set(item.filePath, item.filePath);
+      }
+      for (const sym of symbolsArtifact?.items ?? []) {
+        if (!sym?.filePath || !sym?.name) continue;
+        docs.set(sym.filePath, `${docs.get(sym.filePath) ?? sym.filePath} ${sym.name}`);
+      }
+      const snapshot = ctx?.snapshot ?? null;
+      const scored = await Promise.all([...docs.entries()].map(async ([filePath, docText]) => ({
+        filePath,
+        score: cosineSimilarity(queryVec, await this.embed(docText)),
+      })));
+      return scored
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath))
+        .slice(0, limit)
+        .map((entry) => createEdge({
+          from: String(query ?? ''),
+          to: `${entry.filePath}:0`,
+          kind: 'vector',
+          confidence: entry.score,
+          provider: this.name,
+          evidence: 'hash-vectorizer',
+          snapshot,
+        }));
+    } catch {
+      return null;
+    }
+  }
+}
+
+export class NullEmbeddingProvider {
+  constructor() {
+    this.name = 'null';
+  }
+
+  async available() {
+    return false;
+  }
+
+  capabilities() {
+    return { embeddings: false, similarity: false };
+  }
+
+  async embed() {
+    return [];
+  }
+
+  async resolve() {
+    return null;
+  }
+}
+
+/**
+ * createEmbeddingProvider({ projectRoot, config, loader }) → provider.
+ * config.codeIntel.embedding.provider:
+ *   'hashed' (default) → HashedEmbeddingProvider
+ *   'auto'             → loader() module exposing embed(); ANY failure → Hashed
+ *   'null'             → NullEmbeddingProvider
+ */
+export function createEmbeddingProvider({ projectRoot = process.cwd(), config, loader } = {}) {
+  const embedding = config?.codeIntel?.embedding;
+  const setting = embedding?.provider ?? 'hashed';
+  const dimensions = embedding?.dimensions;
+  if (setting === 'null') {
+    return new NullEmbeddingProvider();
+  }
+  if (setting === 'auto' && typeof loader === 'function') {
+    try {
+      const mod = loader();
+      if (mod && typeof mod.embed === 'function') {
+        return new HashedEmbeddingProvider({ projectRoot, dimensions, embedFn: mod.embed });
+      }
+    } catch {
+      // fall through — degrade to hashed
+    }
+    return new HashedEmbeddingProvider({ projectRoot, dimensions });
+  }
+  return new HashedEmbeddingProvider({ projectRoot, dimensions });
+}

package/src/core/runtimeConfig.js

@@ -174,11 +174,17 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
         bm25: { k1: 1.2, b: 0.75 },
         merge: 'rrf',
         rrfK: 60,
-        weights: { exact: 1.0, symbol: 1.2, bm25: 0.8, semantic: 1.0 },
+        weights: { exact: 1.0, symbol: 1.2, bm25: 0.8, semantic: 1.0, vector: 0.6 },
       },
       impact: { defaultDepth: 2, maxDepth: 4, maxNodes: 200 },
       diagnostics: { enabled: true, timeoutMs: 8000 },
       providers: { semantic: 'null' },
+      // C30 additive blocks (SPEC §10 — TASK-222 single owner).
+      embedding: { provider: 'hashed', dimensions: 256 },
+      analogy: { enabled: true, limit: 5 },
+      cochange: { enabled: true, maxCommits: 500, minCount: 2, timeoutMs: 5000 },
+      summaries: { enabled: true, maxItems: 5 },
+      graph: { enabled: true, store: 'json' },
     },
     memoryV2: {
       enabled: true,
@@ -433,7 +439,7 @@ export function validateRuntimeConfig(config) {
       if (!isPlainObject(codeIntel.retriever.weights)) {
         errors.push('codeIntel.retriever.weights must be an object.');
       } else {
-        for (const lane of ['exact', 'symbol', 'bm25', 'semantic']) {
+        for (const lane of ['exact', 'symbol', 'bm25', 'semantic', 'vector']) {
           if (typeof codeIntel.retriever.weights[lane] !== 'number' || Number.isNaN(codeIntel.retriever.weights[lane])) {
             errors.push(`codeIntel.retriever.weights.${lane} must be a number.`);
           }
@@ -458,6 +464,48 @@ export function validateRuntimeConfig(config) {
     } else {
       pushNonEmptyStringError(errors, codeIntel.providers.semantic, 'codeIntel.providers.semantic');
     }
+    // C30 additive blocks (SPEC §10 — TASK-222).
+    if (!isPlainObject(codeIntel.embedding)) {
+      errors.push('codeIntel.embedding must be an object.');
+    } else {
+      const VALID_EMBEDDING_PROVIDERS = new Set(['hashed', 'auto', 'null']);
+      if (!VALID_EMBEDDING_PROVIDERS.has(codeIntel.embedding.provider)) {
+        errors.push(`codeIntel.embedding.provider must be one of: ${[...VALID_EMBEDDING_PROVIDERS].join(', ')}.`);
+      }
+      const dimensions = codeIntel.embedding.dimensions;
+      if (typeof dimensions !== 'number' || !Number.isInteger(dimensions) || dimensions <= 0 || dimensions > 4096) {
+        errors.push('codeIntel.embedding.dimensions must be a positive integer <= 4096.');
+      }
+    }
+    if (!isPlainObject(codeIntel.analogy)) {
+      errors.push('codeIntel.analogy must be an object.');
+    } else {
+      pushBooleanError(errors, codeIntel.analogy.enabled, 'codeIntel.analogy.enabled');
+      pushPositiveNumberError(errors, codeIntel.analogy.limit, 'codeIntel.analogy.limit');
+    }
+    if (!isPlainObject(codeIntel.cochange)) {
+      errors.push('codeIntel.cochange must be an object.');
+    } else {
+      pushBooleanError(errors, codeIntel.cochange.enabled, 'codeIntel.cochange.enabled');
+      pushPositiveNumberError(errors, codeIntel.cochange.maxCommits, 'codeIntel.cochange.maxCommits');
+      pushPositiveNumberError(errors, codeIntel.cochange.minCount, 'codeIntel.cochange.minCount');
+      pushPositiveNumberError(errors, codeIntel.cochange.timeoutMs, 'codeIntel.cochange.timeoutMs');
+    }
+    if (!isPlainObject(codeIntel.summaries)) {
+      errors.push('codeIntel.summaries must be an object.');
+    } else {
+      pushBooleanError(errors, codeIntel.summaries.enabled, 'codeIntel.summaries.enabled');
+      pushPositiveNumberError(errors, codeIntel.summaries.maxItems, 'codeIntel.summaries.maxItems');
+    }
+    if (!isPlainObject(codeIntel.graph)) {
+      errors.push('codeIntel.graph must be an object.');
+    } else {
+      pushBooleanError(errors, codeIntel.graph.enabled, 'codeIntel.graph.enabled');
+      const VALID_GRAPH_STORES = new Set(['json', 'scip', 'pdg', 'lsp', 'null']);
+      if (!VALID_GRAPH_STORES.has(codeIntel.graph.store)) {
+        errors.push(`codeIntel.graph.store must be one of: ${[...VALID_GRAPH_STORES].join(', ')}.`);
+      }
+    }
   }
 
   if (!isPlainObject(config.memoryV2)) {