@renzrollon/interlock 1.4.1 → 1.5.0

package/lib/graph/cli.mjs

@@ -13,7 +13,16 @@ import {
   writeDocsIndex,
 } from './retrieve/docs-index.mjs';
 import { formatDocsResult, retrieveMarkdownSections } from './retrieve/markdown.mjs';
-import { graphPath, reportPath, resolveRoot } from './paths.mjs';
+import {
+  createSkips,
+  formatSkip,
+  graphPath,
+  loadJson,
+  manifestPath,
+  PARTIAL_MARKER,
+  reportPath,
+  resolveRoot,
+} from './paths.mjs';
 import { resolveStateHome } from '../state-home.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -78,6 +87,51 @@ function graphRootFor(root) {
   return root;
 }
 
+/**
+ * The root a query command reads its graph from, having said — once, on stderr —
+ * when that graph was built past paths it could not read (graph/unreadable-paths).
+ *
+ * The build named each skipped path when it skipped it. A query runs later, often
+ * in another session, and "no consumers" from a graph that never read the file is
+ * not evidence the file is unused. The count comes from the manifest beside the
+ * graph that is actually loaded, so a query served from the main checkout reports
+ * that graph's skips. A graph built with none, by a version that recorded none, or
+ * beside a manifest that cannot be read prints nothing: the query answers as it
+ * always did, and stdout and the exit code never move.
+ */
+function queryGraphRoot(root) {
+  const from = graphRootFor(root);
+  let recorded;
+  try {
+    recorded = loadJson(manifestPath(from), null)?.skipped;
+  } catch {
+    recorded = null;
+  }
+  if (Array.isArray(recorded) && recorded.length > 0) {
+    process.stderr.write(
+      `${PARTIAL_MARKER}: ${recorded.length} path(s) were unreadable when this graph was built and ` +
+        `are not in it (GRAPH_REPORT.md lists them under "Not indexed") — no result for one of ` +
+        `them is not evidence it is unused; interlock-graph update re-reads them\n`,
+    );
+  }
+  return from;
+}
+
+/**
+ * Name every path the command could not read, one line each on stderr, after
+ * the command's stdout (graph/unreadable-paths). A reader never prints; the
+ * command does, here, so a skip is said once and the exit code does not move.
+ */
+function speakSkips(skips) {
+  for (const entry of skips.list()) process.stderr.write(`${formatSkip(entry)}\n`);
+}
+
+/** ` skipped=<n>` for a summary line, and nothing at all on a clean tree. */
+function skippedField(skips) {
+  const n = skips.list().length;
+  return n > 0 ? ` skipped=${n}` : '';
+}
+
 function parseArgs(argv) {
   const args = {
     _: [],
@@ -142,19 +196,27 @@ function main() {
         break;
       }
       case 'build': {
-        const result = buildGraph(root);
+        const skips = createSkips(root);
+        const result = buildGraph(root, { skips });
         const written = writeGraphArtifacts(root, result);
         process.stdout.write(
           `Built graph → ${written.graphPath}\nReport → ${written.reportPath}\n` +
-            `files=${result.stats.files} nodes=${result.stats.nodes} edges=${result.stats.edges} extractor=${result.stats.extractor}\n`,
+            `files=${result.stats.files} nodes=${result.stats.nodes} edges=${result.stats.edges} extractor=${result.stats.extractor}${skippedField(skips)}\n`,
         );
         // An empty graph is a legitimate outcome — this repo is written in a
         // language the walker does not structurally index. Saying so is the
-        // difference between "unsupported" and "broken".
-        if (result.stats.files === 0) {
+        // difference between "unsupported" and "broken". An empty graph beside
+        // skipped paths is a third thing: blaming the language there would
+        // misname a permissions problem.
+        if (result.stats.files === 0 && skips.list().length > 0) {
+          process.stdout.write(
+            '\nNo source files were indexed: nothing indexable under the root could be read ' +
+              '(each skipped path is named on stderr).\n',
+          );
+        } else if (result.stats.files === 0) {
           process.stdout.write(
             '\nNo source files were indexed. Structural indexing covers ' +
-              '.ts .tsx .js .jsx .mjs .cjs .py .pyi .sh .bash\n' +
+              '.ts .tsx .js .jsx .mjs .cjs .py .pyi .sh .bash .cs .csproj .bicep\n' +
               'plus curated config JSON. Other languages (Go, Rust, Java, Ruby) ' +
               'are not structurally indexed yet:\n' +
               'docs, OpenSpec specs and spec→file links still work, but there ' +
@@ -163,18 +225,22 @@ function main() {
               'prose retrieval on this repo.\n',
           );
         }
+        speakSkips(skips);
         break;
       }
       case 'update': {
-        const result = updateGraph(root);
+        const skips = createSkips(root);
+        const result = updateGraph(root, { skips });
         if (!result.updated) {
-          process.stdout.write(`Graph up to date (${result.reason})\n`);
+          process.stdout.write(`Graph up to date (${result.reason})${skippedField(skips)}\n`);
         } else {
           process.stdout.write(
             `Updated graph (${result.reason})\n` +
-              `files=${result.stats.files} nodes=${result.stats.nodes} edges=${result.stats.edges}\n`,
+              `files=${result.stats.files} nodes=${result.stats.nodes} edges=${result.stats.edges}${skippedField(skips)}\n`,
           );
         }
+        // Said whether or not it rebuilt: a path still unreadable is still not indexed.
+        speakSkips(skips);
         break;
       }
       case 'report': {
@@ -187,7 +253,10 @@ function main() {
           modules: graph.nodes.filter((n) => n.type === 'module').length,
           extractor: graph.graph?.extractor,
         };
-        const report = writeReport(root, graph, stats);
+        // Regenerated from the graph, which holds no skips: the manifest is
+        // their record, so the section survives a re-render.
+        const recorded = loadJson(manifestPath(root), null)?.skipped;
+        const report = writeReport(root, graph, stats, Array.isArray(recorded) ? recorded : []);
         fs.writeFileSync(reportPath(root), report);
         process.stdout.write(report);
         break;
@@ -195,7 +264,7 @@ function main() {
       case 'query': {
         const q = args._.slice(1).join(' ');
         if (!q) throw new Error('query requires a search string');
-        const from = graphRootFor(root);
+        const from = queryGraphRoot(root);
         const graph = loadGraph(from);
         const seeds = findSeedNodes(graph, q);
         if (!seeds.length) {
@@ -214,32 +283,35 @@ function main() {
       case 'consumers': {
         const target = args._.slice(1).join(' ');
         if (!target) throw new Error('consumers requires a symbol or file');
-        process.stdout.write(consumers(loadGraph(graphRootFor(root)), target));
+        process.stdout.write(consumers(loadGraph(queryGraphRoot(root)), target));
         break;
       }
       case 'path': {
         const a = args._[1];
         const b = args._[2];
         if (!a || !b) throw new Error('path requires two endpoints');
-        process.stdout.write(shortestPath(loadGraph(graphRootFor(root)), a, b));
+        process.stdout.write(shortestPath(loadGraph(queryGraphRoot(root)), a, b));
         break;
       }
       case 'explain': {
         const q = args._.slice(1).join(' ');
         if (!q) throw new Error('explain requires a node query');
-        process.stdout.write(explain(loadGraph(graphRootFor(root)), q));
+        process.stdout.write(explain(loadGraph(queryGraphRoot(root)), q));
         break;
       }
       case 'docs': {
         const q = args._.slice(1).join(' ');
         if (!q && args.changed.length === 0) throw new Error('docs requires a query or --changed paths');
+        const skips = createSkips(root);
         const result = retrieveMarkdownSections(root, {
           query: q,
           changedFiles: args.changed,
           dirs: args.dirs ?? undefined,
           budget: defaultBudget('docs', args),
+          skips,
         });
         process.stdout.write(formatDocsResult(result));
+        speakSkips(skips);
         if (result.empty) process.exit(1);
         break;
       }
@@ -248,8 +320,10 @@ function main() {
         if (!q && args.changed.length === 0 && !args.commitSubject) {
           throw new Error('context requires a query, --changed paths, or --commit-subject');
         }
+        const skips = createSkips(root);
         const result = retrieveContext(root, {
-          graphRoot: graphRootFor(root),
+          skips,
+          graphRoot: queryGraphRoot(root),
           query: q,
           changedFiles: args.changed,
           commitSubject: args.commitSubject,
@@ -259,13 +333,16 @@ function main() {
           docsDirs: args.dirs ?? undefined,
         });
         process.stdout.write(formatContextResult(result));
+        speakSkips(skips);
         if (result.empty) process.exit(1);
         break;
       }
       case 'docs-index': {
         const write = args.write !== false;
+        const skips = createSkips(root);
         const { index, path: outPath, written } = writeDocsIndex(root, {
           write,
+          skips,
           // Omit rather than defaulting, so buildDocsIndex can probe for the
           // docs root this repo actually uses (doc/, site/, root README, …).
           dirs: args.dirs ?? undefined,
@@ -274,6 +351,7 @@ function main() {
         if (!written) {
           process.stdout.write(`${JSON.stringify(index, null, 2)}\n`);
         }
+        speakSkips(skips);
         break;
       }
       default:

package/lib/graph/extract/bicep.mjs

@@ -0,0 +1,67 @@
+/**
+ * Regex-based Bicep extractor: module imports, param/var/resource/output
+ * declarations, and `<module>.outputs.<x>` references.
+ */
+
+const MODULE_RE = /^[ \t]*module[ \t]+([A-Za-z_]\w*)[ \t]+'([^'\n]+)'[ \t]*=/;
+const DECL_RE = /^[ \t]*(param|var|resource|output)[ \t]+([A-Za-z_]\w*)\b/;
+const COMMENT_LINE_RE = /^[ \t]*(?:\/\/|\/\*|\*)/;
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractBicep(filePath, source) {
+  const imports = [];
+  const exports = [];
+  const lines = source.split(/\r?\n/);
+  const modules = new Map(); // module symbolic name -> target as written
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const text = lines[i];
+    if (COMMENT_LINE_RE.test(text)) continue;
+    const line = i + 1;
+    let m = MODULE_RE.exec(text);
+    if (m) {
+      modules.set(m[1], m[2]);
+      imports.push({
+        from: m[2],
+        imported: null,
+        local: m[1],
+        line,
+        confidence: 'EXTRACTED',
+      });
+      continue;
+    }
+    m = DECL_RE.exec(text);
+    if (m) {
+      exports.push({ name: m[2], kind: m[1], line, confidence: 'EXTRACTED' });
+    }
+  }
+
+  if (modules.size > 0) {
+    const seen = new Set();
+    for (let i = 0; i < lines.length; i += 1) {
+      const text = lines[i];
+      if (COMMENT_LINE_RE.test(text)) continue;
+      for (const [name, target] of modules) {
+        const re = new RegExp(`(?<![\\w.])${name}(?:\\[[^\\]]*\\])?\\??\\.outputs\\.([A-Za-z_]\\w*)`, 'g');
+        let m;
+        while ((m = re.exec(text))) {
+          const key = `${name}\0${m[1]}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          imports.push({
+            from: target,
+            imported: m[1],
+            local: null,
+            line: i + 1,
+            confidence: 'INFERRED',
+          });
+        }
+      }
+    }
+  }
+
+  return { filePath, imports, exports, references: [] };
+}

package/lib/graph/extract/create-extractor.mjs

@@ -3,6 +3,9 @@ import { createJsExtractor } from './typescript.mjs';
 import { extractPython } from './python.mjs';
 import { extractShell } from './shell.mjs';
 import { extractConfigJson } from './config-json.mjs';
+import { extractCsproj } from './csproj.mjs';
+import { extractCsharp } from './csharp.mjs';
+import { extractBicep } from './bicep.mjs';
 
 /**
  * Language-dispatching extractor. JS/TS uses typescript AST when available.
@@ -29,6 +32,18 @@ export function createExtractor(root) {
         modes.add('json');
         return extractConfigJson(filePath, source);
       }
+      if (ext === '.csproj') {
+        modes.add('csproj');
+        return extractCsproj(filePath, source);
+      }
+      if (ext === '.cs') {
+        modes.add('csharp');
+        return extractCsharp(filePath, source);
+      }
+      if (ext === '.bicep') {
+        modes.add('bicep');
+        return extractBicep(filePath, source);
+      }
       return js.extract(filePath, source);
     },
   };

package/lib/graph/extract/csharp.mjs

@@ -0,0 +1,206 @@
+/**
+ * Regex-based C# extractor. Line-oriented, no parser: type declarations as
+ * exports, plus a `csharp` record (namespaces, using directives, types,
+ * identifiers, tests) that `graph/link-csharp.mjs` links across files.
+ *
+ * Known limits: nesting is not tracked, and a declaration-shaped line inside a
+ * verbatim or raw string literal reads as a declaration.
+ */
+
+const COMMENT_LINE_RE = /^[ \t]*(?:\/\/|\*|\/\*)/;
+const NAMESPACE_RE = /^[ \t]*namespace[ \t]+([A-Za-z_][\w.]*)/;
+const USING_RE =
+  /^[ \t]*(?:global[ \t]+)?using[ \t]+(?:static[ \t]+)?(?:[A-Za-z_]\w*[ \t]*=[ \t]*)?(?:global::)?([A-Za-z_][\w.]*)(?:<[^;]*>)?[ \t]*;/;
+const MODIFIERS =
+  '(?:(?:public|private|protected|internal|static|sealed|abstract|partial|readonly|unsafe|new|file|ref|required|virtual)[ \\t]+)*';
+const TYPE_RE = new RegExp(
+  `^[ \\t]*(?:\\[[^\\]\\n]*\\][ \\t]*)*${MODIFIERS}(class|record(?:[ \\t]+(?:class|struct))?|struct|interface|enum)[ \\t]+@?([A-Za-z_]\\w*)`,
+);
+const IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/g;
+const TEST_ATTRIBUTES = new Set(['Fact', 'Theory', 'Test', 'TestCase', 'TestMethod', 'DataTestMethod']);
+const MAX_GROUP_CHARS = 4000;
+
+/** Index of the end of a string or char literal starting at `i`, inclusive. */
+function skipLiteral(text, i) {
+  const quote = text[i];
+  const verbatim = quote === '"' && text[i - 1] === '@';
+  for (let j = i + 1; j < text.length; j += 1) {
+    const c = text[j];
+    if (verbatim) {
+      if (c === '"') {
+        if (text[j + 1] === '"') j += 1;
+        else return j;
+      }
+    } else if (c === '\\') {
+      j += 1;
+    } else if (c === quote || c === '\n') {
+      return j;
+    }
+  }
+  return text.length - 1;
+}
+
+/**
+ * Read the `[...]` group opening at `pos`. Returns the index of its closing
+ * bracket and the names of the attributes at its top level, or null when it
+ * does not close within a plausible span.
+ */
+function scanGroup(text, pos) {
+  let depth = 0;
+  const names = [];
+  let segmentStart = pos + 1;
+  const flush = (end) => {
+    const seg = text.slice(segmentStart, end).trim();
+    const m = /^(?:[A-Za-z_]\w*[ \t]*:(?!:)[ \t]*)?([A-Za-z_][\w.]*)/.exec(seg);
+    if (!m) return;
+    let name = m[1].split('.').pop();
+    if (name.endsWith('Attribute') && name.length > 'Attribute'.length) name = name.slice(0, -'Attribute'.length);
+    names.push(name);
+  };
+  for (let i = pos; i < text.length && i - pos < MAX_GROUP_CHARS; i += 1) {
+    const c = text[i];
+    if (c === '"' || c === "'") {
+      i = skipLiteral(text, i);
+    } else if (c === '[' || c === '(' || c === '{') {
+      depth += 1;
+    } else if (c === ']' || c === ')' || c === '}') {
+      depth -= 1;
+      if (depth === 0 && c === ']') {
+        flush(i);
+        return { end: i, names };
+      }
+      if (depth <= 0) return null;
+    } else if (c === ',' && depth === 1) {
+      flush(i);
+      segmentStart = i + 1;
+    }
+  }
+  return null;
+}
+
+function lastLineOf(source, lines) {
+  return source.endsWith('\n') ? lines.length - 1 : lines.length;
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractCsharp(filePath, source) {
+  const exports = [];
+  const namespaces = [];
+  const usings = [];
+  const types = [];
+  const identifierLines = new Map();
+
+  const lines = source.split(/\r?\n/);
+  const lineStarts = [];
+  {
+    let off = 0;
+    for (const raw of source.split('\n')) {
+      lineStarts.push(off);
+      off += raw.length + 1;
+    }
+  }
+  const lineAt = (offset) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+
+  const isComment = lines.map((l) => COMMENT_LINE_RE.test(l));
+
+  for (let i = 0; i < lines.length; i += 1) {
+    if (isComment[i]) continue;
+    const text = lines[i];
+    const line = i + 1;
+
+    let m = NAMESPACE_RE.exec(text);
+    if (m) {
+      namespaces.push({ name: m[1], line });
+    } else if ((m = USING_RE.exec(text))) {
+      usings.push({ name: m[1], line });
+    } else if ((m = TYPE_RE.exec(text))) {
+      const name = m[2];
+      const kind = m[1].split(/\s+/)[0];
+      exports.push({ name, kind, line, confidence: 'EXTRACTED' });
+      let ns = '';
+      for (const n of namespaces) if (n.line <= line) ns = n.name;
+      types.push({ name, line, namespace: ns });
+    }
+
+    IDENT_RE.lastIndex = 0;
+    let im;
+    while ((im = IDENT_RE.exec(text))) {
+      const seen = identifierLines.get(im[0]);
+      if (!seen) identifierLines.set(im[0], [line]);
+      else if (seen[seen.length - 1] !== line) seen.push(line);
+    }
+  }
+  const identifiers = Object.fromEntries(identifierLines);
+
+  // Tests: an attribute stack whose top-level names include a test attribute,
+  // followed by a method signature.
+  const found = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (isComment[i] || !/^[ \t]*\[/.test(lines[i])) continue;
+    let p = lineStarts[i] + lines[i].search(/\S/);
+    let testLine = 0;
+    let groups = 0;
+    for (;;) {
+      while (p < source.length && /\s/.test(source[p])) p += 1;
+      if (source.startsWith('//', p)) {
+        const nl = source.indexOf('\n', p);
+        p = nl === -1 ? source.length : nl;
+        continue;
+      }
+      if (source[p] !== '[') break;
+      const g = scanGroup(source, p);
+      if (!g) break;
+      groups += 1;
+      if (!testLine && g.names.some((n) => TEST_ATTRIBUTES.has(n))) testLine = lineAt(p);
+      p = g.end + 1;
+    }
+    if (groups === 0) continue;
+    const sigLine = lineAt(Math.min(p, source.length - 1));
+    i = Math.max(i, sigLine - 1);
+    if (!testLine) continue;
+
+    const head = source.slice(p, p + 300);
+    const paren = head.indexOf('(');
+    if (paren === -1) continue;
+    const before = head.slice(0, paren);
+    if (/[;{}=]/.test(before) || /\b(?:class|struct|interface|enum|record|namespace)\b/.test(before)) continue;
+    const nm = /([A-Za-z_]\w*)$/.exec(before.replace(/<[^<>()]*(?:<[^<>()]*>[^<>()]*)*>\s*$/, '').trimEnd());
+    if (!nm) continue;
+    found.push({ name: nm[1], line: sigLine, start: testLine });
+  }
+
+  found.sort((a, b) => a.start - b.start);
+  const lastLine = lastLineOf(source, lines);
+  const tests = found.map((t, idx) => {
+    let type = '';
+    for (const ty of types) if (ty.line < t.start) type = ty.name;
+    const next = found[idx + 1];
+    return {
+      type,
+      name: t.name,
+      line: t.line,
+      start: t.start,
+      end: next ? next.start - 1 : lastLine,
+    };
+  });
+
+  return {
+    filePath,
+    imports: [],
+    exports,
+    references: [],
+    csharp: { namespaces, usings, types, identifiers, tests },
+  };
+}

package/lib/graph/extract/csproj.mjs

@@ -0,0 +1,42 @@
+/**
+ * Regex-based .csproj extractor: one `imports` entry per <ProjectReference Include>.
+ * The Include value is emitted as written (separators, `$(...)` and all);
+ * `resolveImport` normalizes it to a project identity.
+ */
+
+const PROJECT_REFERENCE_RE =
+  /<ProjectReference\b[^>]*?\bInclude\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+
+/** Blank out XML comments, keeping every newline so line numbers hold. */
+function blankComments(source) {
+  return source.replace(/<!--[\s\S]*?-->/g, (m) => m.replace(/[^\n]/g, ' '));
+}
+
+function lineOf(text, index) {
+  let line = 1;
+  for (let i = text.indexOf('\n'); i !== -1 && i < index; i = text.indexOf('\n', i + 1)) line += 1;
+  return line;
+}
+
+/**
+ * @param {string} filePath relative posix path
+ * @param {string} source
+ */
+export function extractCsproj(filePath, source) {
+  const imports = [];
+  const text = blankComments(source);
+  PROJECT_REFERENCE_RE.lastIndex = 0;
+  let m;
+  while ((m = PROJECT_REFERENCE_RE.exec(text))) {
+    const from = (m[1] ?? m[2] ?? '').trim();
+    if (!from) continue;
+    imports.push({
+      from,
+      imported: null,
+      local: null,
+      line: lineOf(text, m.index),
+      confidence: 'EXTRACTED',
+    });
+  }
+  return { filePath, imports, exports: [], references: [] };
+}

package/lib/graph/extract/memory.mjs

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { rel } from '../paths.mjs';
+import { readIndexed, rel } from '../paths.mjs';
 import { walkMarkdown } from './walk.mjs';
 
 const COUPLE_RE =
@@ -12,11 +12,11 @@ const FILE_PAIR_RE =
 /**
  * Extract memory nodes and coupling edges.
  */
-export function extractMemory(root, knownFiles = new Set()) {
+export function extractMemory(root, knownFiles = new Set(), { skips } = {}) {
   const candidates = [];
   const memRoot = path.join(root, '.claude', 'memory');
   if (fs.existsSync(memRoot)) {
-    candidates.push(...walkMarkdown(root, ['.claude/memory']));
+    candidates.push(...walkMarkdown(root, ['.claude/memory'], { skips }));
   }
   const legacy = path.join(root, '.claude', 'memory.md');
   if (fs.existsSync(legacy)) candidates.push(legacy);
@@ -27,7 +27,12 @@ export function extractMemory(root, knownFiles = new Set()) {
 
   for (const absPath of candidates) {
     const filePath = rel(root, absPath);
-    const text = fs.readFileSync(absPath, 'utf8');
+    const read = readIndexed(absPath);
+    if (!read.ok) {
+      if (skips) skips.add(absPath, read.code);
+      continue;
+    }
+    const text = read.text;
     const id = `memory:${filePath}`;
     if (!seenNodes.has(id)) {
       seenNodes.add(id);

package/lib/graph/extract/openspec.mjs

@@ -1,6 +1,5 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { rel } from '../paths.mjs';
+import { readIndexed, rel } from '../paths.mjs';
 import { walkMarkdown } from './walk.mjs';
 
 // Any repo-relative path with an extension. Deliberately NOT restricted to a
@@ -16,14 +15,19 @@ const SYMBOL_RE = /`([A-Z][A-Za-z0-9_]{2,})`|\b([A-Z][A-Za-z0-9_]{2,}(?:Service|
 /**
  * Extract OpenSpec artifact nodes and inferred links to code paths/symbols.
  */
-export function extractOpenspec(root, knownSymbols = new Set(), knownFiles = new Set()) {
-  const files = walkMarkdown(root, ['openspec']);
+export function extractOpenspec(root, knownSymbols = new Set(), knownFiles = new Set(), { skips } = {}) {
+  const files = walkMarkdown(root, ['openspec'], { skips });
   const nodes = [];
   const edges = [];
 
   for (const absPath of files) {
     const filePath = rel(root, absPath);
-    const text = fs.readFileSync(absPath, 'utf8');
+    const read = readIndexed(absPath);
+    if (!read.ok) {
+      if (skips) skips.add(absPath, read.code);
+      continue;
+    }
+    const text = read.text;
     const id = `openspec:${filePath}`;
     nodes.push({
       id,