peaks-loop 4.1.1 → 4.1.2

package/dist/services/codegraph/codegraph-backend-advice.js

@@ -0,0 +1,166 @@
+// src/services/codegraph/codegraph-backend-advice.ts
+//
+// Localizes the SQLite-backend advice the upstream `codegraph` binary prints.
+//
+// It lives in the service layer, not the CLI, because two kinds of consumer
+// need it: the CLI echo paths (re-exported from `codegraph-command-runtime.ts`)
+// and the failure-note builders in `codegraph-autorefresh.ts` and
+// `codegraph-preflight-service.ts`, which may not import from `src/cli`.
+//
+// What is being localized, and why it is wrong here:
+//
+//   1. a status line — `Backend:   wasm - slower fallback; run
+//      `npm rebuild better-sqlite3``;
+//   2. a runtime block on stderr, framed by 72-box-drawing rules, opening
+//      `[CodeGraph] WASM SQLite fallback active (better-sqlite3 unavailable)`
+//      and then telling the reader to install C build tools, rebuild the
+//      binding, or add the package as a hard dependency, followed by the native
+//      loader's absolute search paths.
+//
+// Both were true while `better-sqlite3` was a dependency. This project removed
+// it on purpose — a native addon means a C++ toolchain on every machine that
+// installs the CLI — and put its own stores on Node's built-in `node:sqlite`,
+// so upstream's wasm fallback is permanent and intended, and the advice cannot
+// be followed.
+//
+// Two exports, because the two consumers need different things:
+//
+//   - `rewriteSqliteBackendAdvice` for output the reader sees: the block
+//     becomes one note saying no action is needed.
+//   - `dropSqliteBackendAdvice` for a line being QUOTED as a failure cause:
+//     substituting our note there would put filler where the cause belongs, so
+//     the block is removed and the next real line surfaces.
+/**
+ * The control character that opens an SGR sequence, as a string constant:
+ * `no-control-regex` refuses one inside a PATTERN literal, and an SGR sequence
+ * begins with it by construction — so escape runs are found by scanning.
+ */
+// eslint-disable-next-line no-magic-numbers -- 27 is the ESC control character
+const escChar = String.fromCharCode(27);
+function sgrRunLength(text, from) {
+    if (text[from] !== escChar || text[from + 1] !== '[') {
+        return 0;
+    }
+    let index = from + 2;
+    while (index < text.length && /[0-9;]/.test(text[index] ?? '')) {
+        index += 1;
+    }
+    return (text[index] ?? '') === 'm' ? index + 1 - from : 0;
+}
+/** The text a terminal would actually show for this line. */
+function withoutSgr(text) {
+    let out = '';
+    for (let index = 0; index < text.length; index += 1) {
+        const run = sgrRunLength(text, index);
+        if (run > 0) {
+            index += run - 1;
+            continue;
+        }
+        out += text[index];
+    }
+    return out;
+}
+/** The 72-box-drawing rule upstream frames its blocks with. */
+const RULE_LINE_PATTERN = /^─{20,}$/;
+/** Opens the runtime SQLite-backend block. */
+const BLOCK_INTRO_PATTERN = /^\[CodeGraph\]\s+WASM SQLite fallback active\b/i;
+/** `Backend:   wasm …`, judged on the visible line. */
+const BACKEND_WASM_PATTERN = /^(\s*Backend:\s*)wasm\b/i;
+const WASM_STATUS_TEXT = 'wasm (slower fallback — by design: peaks-loop ships no native SQLite addon)';
+/**
+ * The line the runtime block collapses to. The yellow the status line was
+ * wrapped in goes away with the warning it was coloring: this fallback is not
+ * a warning here.
+ */
+const WASM_BACKEND_NOTE = 'note: codegraph is on its wasm SQLite backend (5-10x slower than native). ' +
+    "This is intentional: peaks-loop ships no native addon and uses Node's built-in node:sqlite. " +
+    'No action needed.';
+/** One line of the block, judged on the text the terminal shows. */
+function isBackendAdvice(raw) {
+    const text = withoutSgr(raw).trim();
+    if (text.length === 0) {
+        return true;
+    }
+    if (text.includes('better-sqlite3')) {
+        return true;
+    }
+    // The native loader's search paths, and the wrapped command lines.
+    if (text.startsWith('→') || text.startsWith('npm ') || text.startsWith('sudo ')) {
+        return true;
+    }
+    return /xcode-select|build-essential|apt install|yum groupinstall|^Indexing and sync will be |^Fix on (?:macOS|Linux):|^Or force-include as a hard dependency|^Verify after fix:|^Native load error:/i.test(text);
+}
+/**
+ * True when the line is one of the 72-dash frames upstream draws around its
+ * blocks.
+ *
+ * Exported for the failure-note builders, because a frame is never a cause and
+ * the block removal alone does not get rid of every one: the frame's CLOSING
+ * rule survives whenever the cause line follows it with no blank line between
+ * (measured 2026-10-06 against the real binary — `files` on an unreadable store
+ * leaves `────…` and then `[ERR] Failed to list files: file is not a database`,
+ * and the note quoted the rule).
+ */
+export function isBackendRuleLine(raw) {
+    return RULE_LINE_PATTERN.test(withoutSgr(raw).trim());
+}
+function isRuleLine(raw) {
+    return raw !== undefined && isBackendRuleLine(raw);
+}
+/** The index of the last line the block owns, starting after its intro. A
+ * rule belongs to the block only when block content follows it; otherwise it
+ * frames something else and stays exactly where it was. */
+function blockBodyEnd(lines, introIndex) {
+    let index = introIndex + 1;
+    while (index < lines.length) {
+        const raw = lines[index] ?? '';
+        if (isBackendAdvice(raw) || (isRuleLine(raw) && isBackendAdvice(lines[index + 1] ?? ''))) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return index - 1;
+}
+function collapseBackendAdvice(text, replacement) {
+    const lines = text.split('\n');
+    const out = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        const visible = withoutSgr(line);
+        const statusMatch = BACKEND_WASM_PATTERN.exec(visible);
+        if (statusMatch !== null) {
+            out.push(`${statusMatch[1]}${WASM_STATUS_TEXT}`);
+            continue;
+        }
+        if (!BLOCK_INTRO_PATTERN.test(visible)) {
+            out.push(line);
+            continue;
+        }
+        // The framing rule the block opens with was already emitted: take it back.
+        if (isRuleLine(out[out.length - 1])) {
+            out.pop();
+        }
+        out.push(replacement);
+        index = blockBodyEnd(lines, index);
+    }
+    return out.join('\n');
+}
+/**
+ * Rewrites the `Backend:   wasm` status line and collapses the
+ * `WASM SQLite fallback active` block to one note. The match is anchored — a
+ * run of block lines ends at the first line that is not a block shape. Output
+ * with no wasm advice (notably a `Backend:   native` index) passes through
+ * byte-for-byte, and the transform is idempotent.
+ */
+export function rewriteSqliteBackendAdvice(text) {
+    return collapseBackendAdvice(text, WASM_BACKEND_NOTE);
+}
+/**
+ * Removes the block instead of replacing it, for callers that quote one line
+ * of upstream output as a failure cause. The status line is still rewritten,
+ * so no deleted-package name survives either way.
+ */
+export function dropSqliteBackendAdvice(text) {
+    return collapseBackendAdvice(text, '');
+}

package/dist/services/codegraph/codegraph-config-repair-writer.d.ts

@@ -22,45 +22,21 @@ export declare function repairCodegraphExclude(input: {
     readonly exclude: readonly string[];
     readonly rulesToRemove: readonly string[];
 }): CodegraphExcludeRepairPlan;
-/**
- * Pure: given the current `include` list and the patterns to append, return
- * the new list. The mirror of `repairCodegraphExclude`, in the other
- * direction — a SUPERSET operation instead of a subset one.
- *
- * A pattern already present is not appended twice: the include reconciler
- * already guarantees that, but this function is the writer's own last line
- * of defence, and a duplicated glob in a third-party config would be a
- * visible defect even though it changes no matching behaviour.
- */
-export declare function repairCodegraphInclude(input: {
-    readonly include: readonly string[];
-    readonly patternsToAdd: readonly string[];
-}): {
-    readonly changed: boolean;
-    readonly include: readonly string[];
-    readonly addedPatterns: readonly string[];
-};
 export type CodegraphConfigRepairPlan = {
     /** Rules from the exclude reconciler to drop. */
     readonly rulesToRemove: readonly string[];
-    /** Patterns from the include reconciler to append. */
-    readonly includePatternsToAdd: readonly string[];
 };
 export type CodegraphConfigRepairOutcome = {
     readonly applied: false;
     readonly reason: 'nothing-to-repair';
     readonly removedRules: readonly string[];
-    readonly addedIncludePatterns: readonly string[];
 } | {
     readonly applied: true;
     readonly configPath: string;
     readonly backupPath: string;
     readonly removedRules: readonly string[];
-    readonly addedIncludePatterns: readonly string[];
     readonly excludeCountBefore: number;
     readonly excludeCountAfter: number;
-    readonly includeCountBefore: number;
-    readonly includeCountAfter: number;
 };
 /**
  * Apply BOTH config repairs to `<projectRoot>/.codegraph/config.json` in one

package/dist/services/codegraph/codegraph-config-repair-writer.js

@@ -1,28 +1,38 @@
 // src/services/codegraph/codegraph-config-repair-writer.ts
 //
-// The pure repair plans (`repairCodegraphExclude` for the exclude axis,
-// `repairCodegraphInclude` for the include axis) and the writer that applies
-// them to `<projectRoot>/.codegraph/config.json` in ONE atomic rewrite, plus
-// the byte-exact `config.json.bak` copy it keeps for rollback and
+// The pure exclude repair plan (`repairCodegraphExclude`) and the writer that
+// applies it to this project's codegraph config in ONE atomic rewrite, plus
+// the byte-exact `<config>.bak` copy it keeps for rollback and
 // `rollbackCodegraphConfig`, that copy's reader (slice A1 of
 // `2026-09-17-session-607ead`: the reverse write, so the rollback the `.bak`
 // has always promised is reachable).
 //
+// WHICH FILE that is comes from `codegraph-project-config.ts` — upstream reads
+// `<root>/codegraph.json` from 1.6.x and `<root>/.codegraph/config.json`
+// before it. The read and the write go through that ONE resolver, so a repair
+// cannot report success against a file upstream never consults.
+//
+// The include axis used to have a plan here too (`repairCodegraphInclude`).
+// It is gone: it existed to append the extensions upstream's own `include`
+// TEMPLATE omitted, and 1.6.x ships no template — while `include` itself came
+// to mean "force INTO the index even when `.gitignore` drops it", so appending
+// every supported extension would have told upstream to index gitignored
+// source. See `codegraph-exclude-repair.ts` for the disposition.
+//
 // Extracted verbatim from `codegraph-exclude-repair.ts` (rid
-// 2026-09-17-oversize-followup, G1 — the 800-line file-size cap). Every moved
 // line is byte-identical and no behaviour changed; `codegraph-exclude-repair.ts`
 // re-exports this module's public surface, so every existing import site
 // (`applyCodegraphConfigRepair`, `repairCodegraphExclude`,
-// `repairCodegraphInclude`, `CODEGRAPH_CONFIG_BACKUP_SUFFIX`, and the three
-// plan/outcome types) keeps working unchanged.
+// `CODEGRAPH_CONFIG_BACKUP_SUFFIX`, and the two plan/outcome types) keeps
+// working unchanged.
 //
 // The dependency edge is ONE-WAY and must stay that way: this module must not
 // import `codegraph-exclude-repair.ts`, which imports this one.
 import { randomBytes } from 'node:crypto';
 import { chmodSync, lstatSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { assertStringArray, CODEGRAPH_CONFIG_FILENAME } from './codegraph-exclude-reconciler.js';
-import { assertCodegraphDirContained, CODEGRAPH_DIR_NAME } from './codegraph-service.js';
+import { assertStringArray } from './codegraph-exclude-reconciler.js';
+import { resolveCodegraphConfigSource } from './codegraph-project-config.js';
+import { assertCodegraphDirContained } from './codegraph-service.js';
 /** Suffix of the byte-exact pre-repair copy kept next to the config. */
 export const CODEGRAPH_CONFIG_BACKUP_SUFFIX = '.bak';
 /**
@@ -50,24 +60,6 @@ export function repairCodegraphExclude(input) {
         removedRules
     };
 }
-/**
- * Pure: given the current `include` list and the patterns to append, return
- * the new list. The mirror of `repairCodegraphExclude`, in the other
- * direction — a SUPERSET operation instead of a subset one.
- *
- * A pattern already present is not appended twice: the include reconciler
- * already guarantees that, but this function is the writer's own last line
- * of defence, and a duplicated glob in a third-party config would be a
- * visible defect even though it changes no matching behaviour.
- */
-export function repairCodegraphInclude(input) {
-    const existing = new Set(input.include);
-    const additions = input.patternsToAdd.filter((pattern) => !existing.has(pattern));
-    if (additions.length === 0) {
-        return { changed: false, include: input.include, addedPatterns: [] };
-    }
-    return { changed: true, include: [...input.include, ...additions], addedPatterns: additions };
-}
 /**
  * Detect the indentation the config already uses so the rewrite keeps
  * the file's shape instead of reformatting a third-party tool's file.
@@ -125,7 +117,6 @@ function writeConfigAtomic(filePath, content, mode) {
             // process umask instead of the original's mode.
             chmodSync(tempPath, mode);
             // Windows cannot REPLACE a read-only destination: `renameSync` over
-            // one throws EPERM (measured, `2026-09-17-codegraph-msg-and-refresh`).
             // The only destination this branch ever sees read-only is this
             // writer's own previous `.bak`, which under A4 carries the original
             // config's mode — so a read-only config would make the SECOND repair
@@ -223,7 +214,6 @@ function linkOrDirectoryAt(path) {
  * succeeded, so a refusal leaves the config BYTES UNTOUCHED — the throw
  * propagates out of `applyCodegraphConfigRepair` before the rewrite.
  *
- * A4 (`2026-09-17-codegraph-msg-and-refresh`, the L1 half left over from
  * slice-002's S1): the copy carries the ORIGINAL CONFIG'S MODE, because the
  * mode is part of what a rollback restores. The `.bak` exists so an operator
  * can put the previous config back with a `mv`, and a restore that hands
@@ -280,13 +270,8 @@ function writeConfigBackup(configPath, originalText) {
  * anything is written, so a throw can never half-apply.
  */
 export function applyCodegraphConfigRepair(projectRoot, repair) {
-    if (repair.rulesToRemove.length === 0 && repair.includePatternsToAdd.length === 0) {
-        return {
-            applied: false,
-            reason: 'nothing-to-repair',
-            removedRules: [],
-            addedIncludePatterns: []
-        };
+    if (repair.rulesToRemove.length === 0) {
+        return { applied: false, reason: 'nothing-to-repair', removedRules: [] };
     }
     // Containment FIRST — before even reading (S12 / security R1). The `.bak`
     // guard below protects a FILE path; this protects the DIRECTORY it lives
@@ -295,7 +280,9 @@ export function applyCodegraphConfigRepair(projectRoot, repair) {
     // write target stays derived from the caller's `projectRoot`, so this
     // verb's canonicalization remains where L2/S5 put it, at the CLI edge.
     assertCodegraphDirContained(projectRoot);
-    const configPath = join(projectRoot, CODEGRAPH_DIR_NAME, CODEGRAPH_CONFIG_FILENAME);
+    // The file WRITTEN is the file READ — both come from the one resolver, so a
+    // repair can never report success against a file upstream does not consult.
+    const configPath = resolveCodegraphConfigSource(projectRoot).configPath;
     const originalText = readFileSync(configPath, 'utf8');
     const parsed = JSON.parse(originalText);
     if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
@@ -303,52 +290,24 @@ export function applyCodegraphConfigRepair(projectRoot, repair) {
     }
     const record = parsed;
     const exclude = assertStringArray(record.exclude, 'exclude', configPath);
-    // An ABSENT `include` key is tolerated, and is NOT the same as a malformed
-    // one: this writer predates the include axis and callers exist whose
-    // config carries only `exclude` (a hand-written minimal file; the S2
-    // hardening fixtures are exactly that). Throwing here would make the
-    // whole repair fail — including the exclude half that used to succeed —
-    // so the include axis simply has nothing to extend, and the key is never
-    // invented. A key that is PRESENT but is not an array of strings is still
-    // an error: that is a genuinely malformed config, and silently ignoring it
-    // is how a wrong `include` would survive a repair that reported success.
-    const include = record.include === undefined ? [] : assertStringArray(record.include, 'include', configPath);
     const excludePlan = repairCodegraphExclude({ exclude, rulesToRemove: repair.rulesToRemove });
-    const includePlan = repairCodegraphInclude({
-        include,
-        patternsToAdd: repair.includePatternsToAdd
-    });
-    if (!excludePlan.changed && !includePlan.changed) {
-        return {
-            applied: false,
-            reason: 'nothing-to-repair',
-            removedRules: [],
-            addedIncludePatterns: []
-        };
+    if (!excludePlan.changed) {
+        return { applied: false, reason: 'nothing-to-repair', removedRules: [] };
     }
     const backupPath = writeConfigBackup(configPath, originalText);
-    // Spread first, then replace the keys that changed — every other key keeps
-    // its original value AND its original position in the serialized object.
-    // `include` is only written back when it actually changed, so a config
-    // without that key does not gain one from a repair that did not touch it.
+    // Spread first, then replace the key that changed — every other key keeps
+    // its original value AND its original position in the serialized object, so
+    // a key this repair does not own (`extensions`, `include`, anything a newer
+    // upstream adds) survives byte-for-byte.
     const nextRecord = { ...record, exclude: excludePlan.exclude };
-    if (includePlan.changed) {
-        nextRecord.include = includePlan.include;
-    }
     writeConfigAtomic(configPath, serializeConfig(nextRecord, originalText));
     return {
         applied: true,
         configPath,
         backupPath,
         removedRules: excludePlan.removedRules,
-        // The patterns that ACTUALLY landed (a caller-supplied pattern that was
-        // already present is not an addition), so the report cannot overstate
-        // what changed on disk.
-        addedIncludePatterns: includePlan.addedPatterns,
         excludeCountBefore: exclude.length,
-        excludeCountAfter: excludePlan.exclude.length,
-        includeCountBefore: include.length,
-        includeCountAfter: includePlan.include.length
+        excludeCountAfter: excludePlan.exclude.length
     };
 }
 // ─────────────────────────────────────────────────────────────────────

package/dist/services/codegraph/codegraph-exclude-integrity.d.ts

@@ -14,7 +14,7 @@ export type CodegraphExcludeRuleImpact = {
     readonly blockedCount: number;
 };
 export type CodegraphExcludeIntegrityReport = {
-    /** Absolute path of the reconciled `.codegraph/config.json`. */
+    /** Absolute path of the reconciled config file — see `codegraph-project-config.ts`. */
     readonly configPath: string;
     /** True when at least one tracked source file is blocked. */
     readonly gap: boolean;
@@ -30,15 +30,23 @@ export type CodegraphExcludeIntegrityReport = {
     readonly ruleImpacts: readonly CodegraphExcludeRuleImpact[];
 };
 /**
- * True when `<projectRoot>/.codegraph/config.json` exists, i.e. when an
+ * True when the project's codegraph config file exists, i.e. when an
  * exclude list is actually in play here. Both consumers use this to
- * stay SILENT on a project that never ran `peaks codegraph init`: there
- * is no exclusion to report, and a missing config is not a finding.
+ * stay SILENT on a project that never configured one: there is no
+ * exclusion to report, and a missing config is not a finding.
+ *
+ * WHICH file that is comes from `codegraph-project-config.ts`, because it
+ * is a property of the installed upstream rather than of this module: it is
+ * `<projectRoot>/codegraph.json` under 1.6.x and
+ * `<projectRoot>/.codegraph/config.json` under 0.7.x. Asking about the old
+ * path only would answer `false` on every 1.6.x project, which reads as
+ * "nothing is excluded" when the truth is "the exclusion list was never
+ * looked at".
  *
  * Note the difference from `isCodegraphInitialized` in
  * `codegraph-service.ts`, which probes `codegraph.db` (upstream's own
- * definition of "initialized"). The exclude list is written by upstream
- * init, so its presence is the narrower question this module asks.
+ * definition of "initialized"). The config is what carries `exclude`, so
+ * its presence is the narrower question this module asks.
  */
 export declare function isCodegraphExcludeConfigPresent(projectRoot: string): boolean;
 /**

package/dist/services/codegraph/codegraph-exclude-integrity.js

@@ -1,6 +1,5 @@
 // src/services/codegraph/codegraph-exclude-integrity.ts
 //
-// Slice S2 of `2026-09-12-codegraph-exclude-integrity` — the READ-ONLY
 // integrity report shared by `peaks codegraph status` and the
 // `capability:codegraph-exclude-integrity` doctor check.
 //
@@ -9,14 +8,13 @@
 // that both consumers can render and gate on, so neither of them has
 // to re-derive "is there a gap, how big, and which rules cause it".
 //
-// It NEVER writes `.codegraph/config.json`. The only write path is
+// It NEVER writes the project's codegraph config. The only write path is
 // `codegraph-exclude-repair.ts`, reachable from `peaks codegraph init`
 // (fresh-initialization self-heal) and the explicit
 // `peaks codegraph repair-exclude` command. Read stays read.
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { CODEGRAPH_CONFIG_FILENAME, resolveSharedConfig, resolveSharedTrackedFiles, reconcileCodegraphExclude } from './codegraph-exclude-reconciler.js';
-import { CODEGRAPH_DIR_NAME } from './codegraph-service.js';
+import { resolveSharedConfig, resolveSharedTrackedFiles, reconcileCodegraphExclude } from './codegraph-exclude-reconciler.js';
+import { upstreamSupportsPath } from './codegraph-index-integrity.js';
+import { resolveCodegraphConfigSource } from './codegraph-project-config.js';
 /**
  * Exit code `peaks codegraph status` uses when the index is
  * demonstrably incomplete. Distinct from the upstream pass-through
@@ -29,18 +27,26 @@ export const CODEGRAPH_INTEGRITY_EXIT_CODE = 74;
 const MAX_REPORTED_RULES = 10;
 const MAX_REPORTED_FILES = 10;
 /**
- * True when `<projectRoot>/.codegraph/config.json` exists, i.e. when an
+ * True when the project's codegraph config file exists, i.e. when an
  * exclude list is actually in play here. Both consumers use this to
- * stay SILENT on a project that never ran `peaks codegraph init`: there
- * is no exclusion to report, and a missing config is not a finding.
+ * stay SILENT on a project that never configured one: there is no
+ * exclusion to report, and a missing config is not a finding.
+ *
+ * WHICH file that is comes from `codegraph-project-config.ts`, because it
+ * is a property of the installed upstream rather than of this module: it is
+ * `<projectRoot>/codegraph.json` under 1.6.x and
+ * `<projectRoot>/.codegraph/config.json` under 0.7.x. Asking about the old
+ * path only would answer `false` on every 1.6.x project, which reads as
+ * "nothing is excluded" when the truth is "the exclusion list was never
+ * looked at".
  *
  * Note the difference from `isCodegraphInitialized` in
  * `codegraph-service.ts`, which probes `codegraph.db` (upstream's own
- * definition of "initialized"). The exclude list is written by upstream
- * init, so its presence is the narrower question this module asks.
+ * definition of "initialized"). The config is what carries `exclude`, so
+ * its presence is the narrower question this module asks.
  */
 export function isCodegraphExcludeConfigPresent(projectRoot) {
-    return existsSync(join(projectRoot, CODEGRAPH_DIR_NAME, CODEGRAPH_CONFIG_FILENAME));
+    return resolveCodegraphConfigSource(projectRoot).present;
 }
 /**
  * Read the project's git-tracked files + `.codegraph/config.json` and
@@ -71,14 +77,18 @@ export function inspectCodegraphExcludeIntegrity(projectRoot, inputs = {}) {
     const result = reconcileCodegraphExclude({
         trackedFiles,
         include: config.include,
-        exclude: config.exclude
+        exclude: config.exclude,
+        admissionModel: config.model,
+        // The same oracle the index axis uses, so "would upstream ingest this
+        // file" cannot be answered two ways across the two gates.
+        supportsPath: upstreamSupportsPath
     });
     const blockedCounts = new Map();
     for (const violation of result.violations) {
         blockedCounts.set(violation.matchedRule, (blockedCounts.get(violation.matchedRule) ?? 0) + 1);
     }
     return {
-        configPath: join(projectRoot, CODEGRAPH_DIR_NAME, CODEGRAPH_CONFIG_FILENAME),
+        configPath: config.configPath,
         gap: result.excludedTrackedCount > 0,
         trackedSourceCount: result.trackedSourceCount,
         excludedTrackedCount: result.excludedTrackedCount,

package/dist/services/codegraph/codegraph-exclude-reconciler.d.ts

@@ -1,3 +1,4 @@
+import { type CodegraphConfigModel } from './codegraph-project-config.js';
 export declare function matchesCodegraphGlob(filePath: string, pattern: string): boolean;
 export type CompiledCodegraphGlobs = {
     readonly matchesAny: (filePath: string) => boolean;
@@ -7,6 +8,8 @@ export type CodegraphExcludeReconcileInput = {
     readonly trackedFiles: readonly string[];
     readonly include: readonly string[];
     readonly exclude: readonly string[];
+    readonly admissionModel: CodegraphConfigModel;
+    readonly supportsPath?: ((filePath: string) => boolean) | undefined;
 };
 export type CodegraphExcludeViolation = {
     readonly path: string;
@@ -20,8 +23,10 @@ export type CodegraphExcludeReconcileResult = {
 };
 export declare function filterAdmittedTrackedFiles(trackedFiles: readonly string[], include: readonly string[]): readonly string[];
 export declare function reconcileCodegraphExclude(input: CodegraphExcludeReconcileInput): CodegraphExcludeReconcileResult;
-export declare const CODEGRAPH_CONFIG_FILENAME = "config.json";
 export type CodegraphExcludeConfig = {
+    readonly configPath: string;
+    readonly present: boolean;
+    readonly model: CodegraphConfigModel;
     readonly include: readonly string[];
     readonly exclude: readonly string[];
 };
@@ -35,7 +40,9 @@ export type ReadTrackedFiles = readonly string[] & ReadProvenance;
 export type ReadCodegraphExcludeConfig = CodegraphExcludeConfig & ReadProvenance;
 export declare function readTrackedFiles(projectRoot: string): ReadTrackedFiles;
 export declare function assertStringArray(value: unknown, field: string, configPath: string): readonly string[];
+export declare function optionalStringArray(value: unknown, field: string, configPath: string): readonly string[];
 export declare function readCodegraphExcludeConfig(projectRoot: string): ReadCodegraphExcludeConfig;
+export declare function readCodegraphConfigFrom(projectRoot: string, model: CodegraphConfigModel): ReadCodegraphExcludeConfig;
 export type CodegraphProjectInputs = {
     readonly trackedFiles: ReadTrackedFiles;
     readonly config: ReadCodegraphExcludeConfig;
@@ -43,5 +50,5 @@ export type CodegraphProjectInputs = {
 export declare function readCodegraphProjectInputs(projectRoot: string): CodegraphProjectInputs;
 export declare function resolveSharedTrackedFiles(supplied: ReadTrackedFiles | undefined, projectRoot: string): ReadTrackedFiles;
 export declare function resolveSharedConfig(supplied: ReadCodegraphExcludeConfig | undefined, projectRoot: string): ReadCodegraphExcludeConfig;
-export declare function reconcileCodegraphExcludeFromProject(projectRoot: string): CodegraphExcludeReconcileResult;
+export declare function reconcileCodegraphExcludeFromProject(projectRoot: string, supportsPath?: (filePath: string) => boolean): CodegraphExcludeReconcileResult;
 export {};