memorix 1.1.8 → 1.1.10

package/docs/API_REFERENCE.md

@@ -103,6 +103,8 @@ MCP:
 
 `memorix context` defaults to `--refresh auto`, so first use can seed CodeGraph Memory without a separate manual `memorix codegraph refresh`. Its brief puts live package/changelog/Git facts before memory hints and flags old `progress.txt` / dev-log notes as historical when they predate the latest changelog, so agents should treat current facts as the source of truth when files disagree. Task lenses keep the packet shaped to the work: bugfix briefs prefer failing tests and repros, release briefs prefer metadata/changelog/package checks, and onboarding briefs prefer docs and entry points while hiding unrelated suspect details. Use `--refresh never` for read-only inspection and `--refresh always` when you want to force a fresh scan.
 
+Project-specific generated, vendored, or cache paths can be excluded from CodeGraph Memory with `[codegraph].exclude_patterns` in `memorix.toml` or `~/.memorix/config.toml` (`codegraph.excludePatterns` in legacy YAML). User patterns extend the built-in excludes and are applied to indexing, Project Context suggested reads, and Context Pack suggested reads.
+
 SessionStart hooks keep the default minimal hint lightweight. When memory behavior is configured with `sessionInject=full`, Memorix injects the compact Memory Autopilot brief at session start instead of only listing recent text memories.
 
 The intended loop for agents is: get the project brief when it helps, inspect the suggested current files, use stale or unbound memory only as a lead, store durable outcomes after the work changes the project, and resolve obsolete memories.

package/docs/CONFIGURATION.md

@@ -60,6 +60,9 @@ skip_merge_commits = true
 exclude_patterns = ["*.lock", "dist/**"]
 noise_keywords = ["format", "typo"]
 
+[codegraph]
+exclude_patterns = ["vendor/**", "third_party/**", "generated/**"]
+
 [server]
 transport = "stdio"
 dashboard = true
@@ -197,6 +200,21 @@ Project identity is still resolved from the real `.git` root. A project
 `memorix.toml` is an override file under that root; it does not create or rename
 the Memorix project ID.
 
+### `[codegraph]`
+
+CodeGraph Memory and Project Context path filtering.
+
+Common keys:
+
+- `exclude_patterns = ["vendor/**", "third_party/**", "generated/**"]`
+
+Legacy YAML uses `codegraph.excludePatterns` for the same setting.
+
+These patterns extend Memorix's built-in CodeGraph excludes (`node_modules`,
+build outputs, worktrees, and similar generated directories). Matching paths are
+skipped during CodeGraph indexing and hidden from Project Context / Context Pack
+suggested reads.
+
 ### `[server]`
 
 Server and dashboard behavior.

package/docs/dev-log/progress.txt

@@ -4,48 +4,35 @@
 > exist under subdirectories; prefer this file for repository-wide state.
 
 ## Current State
-- Phase: 1.1.8 release finalization
-- Branch: main
-- PR: #118 merged
-- Last updated: 2026-07-08
-- Goal: publish 1.1.8 after committing the final Claude local MCP repair and CodeGraph noise-control patch.
+- Phase: 1.1.10 emergency patch release
+- Branch: codex/issue-124-project-context-timeout
+- Issue: #124
+- Last updated: 2026-07-13
+- Goal: release the large-project `memorix_project_context` timeout fix and follow up with the reporter.
 
 ## Completed Recently
-- Merged PR #118: `fix(setup): make Memory Autopilot self-checking`.
-- Added `memorix doctor agents` and `memorix repair agents` so users can detect and repair stale agent MCP/rules setup.
-- Strengthened generated agent guidance so `memorix_project_context` is the default first step for non-trivial coding work.
-- Verified main at `8567f5e` after merge; GitHub CI passed before merge.
-- Confirmed local OpenRouter embedding lane resolves to `qwen/qwen3-embedding-8b` without printing secrets.
-- Fixed Claude Code 2.x local MCP repair: doctor/repair now inspect `~/.claude.json` project-private entries and rewrite stale worktree commands to `memorix serve` with `alwaysLoad: true`.
-- Fixed all-scope doctor noise: one healthy local, project, or global scope is enough in all-scope mode unless a stale actionable config is present.
-- Fixed CodeGraph Memory noise: `.tmp`, `.worktrees`, and `.claude/worktrees` are ignored by the lite scan and Autopilot suggested reads.
-- Bumped root and workspace package versions to `1.1.8` and updated lockfile/internal workspace dependencies.
+- Reproduced #124 with 3308 active memories and confirmed the old refresh path exceeded the MCP 60-second timeout.
+- Replaced broad per-observation symbol scans with indexed exact-name lookup and bulk existing-ref reads.
+- Changed first-use backfill to load one project graph snapshot, match all missing observations in memory, and persist refs in one transaction.
+- Reused one graph snapshot per project-context request and batched project refs/referenced symbols.
+- Prevented prose-only and ambiguous symbol mentions from creating large volumes of noisy code refs.
+- Preserved Ruby namespace and punctuated method names through Lite indexing and both binding paths.
+- Bumped root and workspace metadata to `1.1.10`.
 
 ## Current Follow-Up
-- The release patch is implemented and verified locally, but not committed or pushed yet.
-- Two unrelated local changes were temporarily stashed before final verification so they do not enter the release package: `packages/ai/src/models.generated.ts` and `packages/memcode/docs/images/exy.png`.
+- Commit, publish `memorix@1.1.10`, create the GitHub release, and reply to #124 with the upgrade path.
 
 ## Verification Snapshot
-- `git diff --check`
-- `npm test -- tests/cli/agent-doctor.test.ts tests/codegraph/lite-provider.test.ts tests/codegraph/project-context.test.ts tests/codegraph/context-pack.test.ts`
-- `npm run lint`
-- `npm run build`
-- `npm test`
-- `npm pack --dry-run --json` -> `memorix@1.1.8`, about 14.1 MB packed / 60.3 MB unpacked
-- `node dist/cli/index.js doctor agents --agent claude --scope local`
-- `node dist/cli/index.js doctor agents --agent claude --scope all`
-- `node dist/cli/index.js codegraph refresh --json`
-- `node dist/cli/index.js context --refresh never --task "准备发布 1.1.8：判断当前进度、风险和下一步"`
-- `claude mcp get memorix`
-- `claude mcp list`
-- Claude Code user-style smoke: a short print-mode handoff correctly blocked release because local changes were not committed yet; longer print-mode smoke can still time out.
+- TDD regression coverage passes for CodeGraph store, binder, project context, and auto context.
+- A copied real database with all refs removed improved from 57.9 seconds for 173 active memories to 12.4 seconds.
+- A scaled 3308-active first-use refresh completed in 13.3 seconds, including a forced code scan and full code-ref backfill.
+- Built stdio MCP smoke returned `memorix_project_context` successfully in 5.79 seconds.
+- Final release verification: `git diff --check`, `npm run lint`, `npm run build`, `npm test`, package dry-run, and clean-install npm smoke.
 
 ## Known UX Notes
-- Claude Code print-mode can be slow or fail to finish under budget during full user-style smoke. Use tool traces plus deterministic CLI/MCP smoke to distinguish product failures from model/runtime drift.
-- `memorix context --refresh never --task "<task>"` is fast and stable for first-contact context. `--refresh auto` can take longer on this repository.
+- Before 1.1.10, `refresh: "never"` is a temporary workaround for very large active-memory corpora.
 - Current code and release facts outrank stale handoff notes or older dev logs when they conflict.
 
 ## Next Steps
-- Commit and push the 1.1.8 release patch.
-- Publish `memorix@1.1.8` to npm, then tag and push `v1.1.8`.
-- Restore the temporary local stash after publishing if those local model/image changes are still needed.
+- Commit and push the 1.1.10 release patch.
+- Tag, publish the root package, create the GitHub release, and reply to #124.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,

package/src/cli/commands/codegraph.ts

@@ -3,6 +3,7 @@ import { CodeGraphStore } from '../../codegraph/store.js';
 import { indexProjectLite } from '../../codegraph/lite-provider.js';
 import { assembleContextPackForTask, buildContextPackPrompt } from '../../codegraph/context-pack.js';
 import { backfillMissingObservationCodeRefs } from '../../codegraph/binder.js';
+import { getResolvedConfig } from '../../config/resolved-config.js';
 import { getAllObservations } from '../../memory/observations.js';
 import { emitError, emitResult, getCliProjectContext, parsePositiveInt } from './operator-shared.js';
 
@@ -49,6 +50,7 @@ export default defineCommand({
       const store = new CodeGraphStore();
       await store.init(dataDir);
       const explicitAction = Boolean(positional[0] || (args.action as string | undefined));
+      const exclude = getResolvedConfig({ projectRoot: project.rootPath }).codegraph.excludePatterns;
 
       switch (action) {
         case 'status': {
@@ -64,6 +66,7 @@ export default defineCommand({
           const indexed = await indexProjectLite({
             projectId: project.id,
             projectRoot: project.rootPath,
+            exclude,
           });
           store.replaceProjectIndex(project.id, indexed);
           const activeObservations = getAllObservations()
@@ -99,6 +102,7 @@ export default defineCommand({
             task,
             observations,
             limit,
+            exclude,
           });
           emitResult({ project, pack }, buildContextPackPrompt(pack), asJson);
           return;

package/src/cli/commands/config-get.ts

@@ -29,12 +29,19 @@ export default defineCommand({
 function readDotted(source: Record<string, unknown>, key: string): unknown {
   let cursor: unknown = source;
   for (const part of key.split('.')) {
-    if (!cursor || typeof cursor !== 'object' || !(part in cursor)) return undefined;
-    cursor = (cursor as Record<string, unknown>)[part];
+    if (!cursor || typeof cursor !== 'object') return undefined;
+    const record = cursor as Record<string, unknown>;
+    const normalizedPart = part in record ? part : snakeToCamel(part);
+    if (!(normalizedPart in record)) return undefined;
+    cursor = record[normalizedPart];
   }
   return cursor;
 }
 
+function snakeToCamel(value: string): string {
+  return value.replace(/_([a-z])/g, (_, char: string) => char.toUpperCase());
+}
+
 function formatValue(value: unknown, key: string): string {
   if (typeof value === 'string') return shouldRedactKey(key) ? '<redacted>' : value;
   if (typeof value === 'number' || typeof value === 'boolean') return String(value);

package/src/cli/commands/doctor.ts

@@ -318,8 +318,10 @@ export default defineCommand({
       try {
         const { CodeGraphStore } = await import('../../codegraph/store.js');
         const { buildProjectContextOverview } = await import('../../codegraph/project-context.js');
+        const { getResolvedConfig } = await import('../../config/resolved-config.js');
         const codeStore = new CodeGraphStore();
         await codeStore.init(dataDir);
+        const exclude = getResolvedConfig({ projectRoot: projectRoot || process.cwd() }).codegraph.excludePatterns;
         const overview = buildProjectContextOverview({
           project: {
             id: projectId,
@@ -328,6 +330,7 @@ export default defineCommand({
           },
           store: codeStore,
           observations: projectObservations,
+          exclude,
         });
         const languageText = overview.code.languages.length > 0
           ? overview.code.languages.map((item: any) => `${item.language} ${item.files}`).join(', ')

package/src/codegraph/auto-context.ts

@@ -1,12 +1,12 @@
 import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { getResolvedConfig } from '../config/resolved-config.js';
 import type { ProjectInfo } from '../types.js';
 import { backfillMissingObservationCodeRefs, type CodeRefBackfillResult } from './binder.js';
 import { collectCurrentProjectFacts, type CurrentProjectFacts } from './current-facts.js';
 import { indexProjectLite } from './lite-provider.js';
 import {
   buildProjectContextExplain,
-  buildProjectContextOverview,
   type ProjectContextExplain,
   type ProjectContextObservation,
   type ProjectContextOverview,
@@ -100,11 +100,13 @@ export async function buildAutoProjectContext(input: {
   refresh?: AutoContextRefreshMode;
   maxAgeMs?: number;
   now?: Date;
+  exclude?: string[];
 }): Promise<AutoProjectContext> {
   const refreshMode = input.refresh ?? 'auto';
   const now = input.now ?? new Date();
   const task = input.task?.trim();
   const lens = resolveTaskLens(task);
+  const exclude = input.exclude ?? getResolvedConfig({ projectRoot: input.project.rootPath }).codegraph.excludePatterns;
   const store = new CodeGraphStore();
   await store.init(input.dataDir);
 
@@ -126,6 +128,7 @@ export async function buildAutoProjectContext(input: {
       const indexed = await indexProjectLite({
         projectId: input.project.id,
         projectRoot: input.project.rootPath,
+        exclude,
       });
       store.replaceProjectIndex(input.project.id, indexed);
       const backfill = await backfillMissingObservationCodeRefs(
@@ -143,16 +146,13 @@ export async function buildAutoProjectContext(input: {
     }
   }
 
-  const overview = buildProjectContextOverview({
-    project: input.project,
-    store,
-    observations: input.observations,
-  });
   const explain = buildProjectContextExplain({
     project: input.project,
     store,
     observations: input.observations,
+    exclude,
   });
+  const overview = explain.overview;
 
   return {
     project: input.project,

package/src/codegraph/binder.ts

@@ -27,6 +27,24 @@ function mentionsSymbol(text: string, symbol: CodeSymbol): boolean {
   return new RegExp(`(^|[^\\w$])${name}([^\\w$]|$)`).test(text);
 }
 
+function identifierCandidates(text: string): string[] {
+  return [...new Set(text.match(/[A-Za-z_$][\w$]*(?:::[A-Za-z_$][\w$]*)*[!?=]?/g) ?? [])];
+}
+
+function codeIdentifierCandidates(text: string): string[] {
+  const explicit = new Set<string>();
+  for (const match of text.matchAll(/`([A-Za-z_$][\w$]*(?:::[A-Za-z_$][\w$]*)*[!?=]?)`/g)) explicit.add(match[1]);
+  for (const match of text.matchAll(/\b([A-Za-z_$][\w$]*(?:::[A-Za-z_$][\w$]*)*[!?=]?)\s*\(/g)) explicit.add(match[1]);
+  return identifierCandidates(text).filter(candidate =>
+    explicit.has(candidate) ||
+    candidate.includes('::') ||
+    /[!?=]$/.test(candidate) ||
+    /^[A-Z]/.test(candidate) ||
+    /[_$]/.test(candidate) ||
+    /[a-z0-9][A-Z]/.test(candidate) ||
+    /[A-Z]{2}/.test(candidate));
+}
+
 function fileRef(projectId: string, obs: BindableObservation, file: CodeFile): ObservationCodeRef {
   return {
     id: makeObservationCodeRefId(projectId, obs.id, file.id),
@@ -55,35 +73,89 @@ function symbolRef(projectId: string, obs: BindableObservation, file: CodeFile,
   };
 }
 
-export async function bindObservationToCode(
-  store: CodeGraphStore,
+interface CodeBindingLookup {
+  findFile(path: string): CodeFile | undefined;
+  findSymbols(names: string[], hintedFileIds: string[]): CodeSymbol[];
+}
+
+function resolveObservationCodeRefs(
   obs: BindableObservation,
-): Promise<ObservationCodeRef[]> {
+  lookup: CodeBindingLookup,
+): ObservationCodeRef[] {
   const refs = new Map<string, ObservationCodeRef>();
   const text = observationText(obs);
   const candidateFiles = new Map<string, CodeFile>();
 
   for (const rawPath of obs.filesModified ?? []) {
-    const file = store.getFile(obs.projectId, normalizeCodePath(rawPath));
+    const file = lookup.findFile(normalizeCodePath(rawPath));
     if (!file) continue;
     candidateFiles.set(file.id, file);
     const ref = fileRef(obs.projectId, obs, file);
     refs.set(ref.id, ref);
   }
 
-  const symbols = store.findSymbols(obs.projectId, '', 500);
+  const hintedFileIds = new Set(candidateFiles.keys());
+  const symbolNames = hintedFileIds.size > 0 ? identifierCandidates(text) : codeIdentifierCandidates(text);
+  const symbols = lookup.findSymbols(symbolNames, [...hintedFileIds]);
+  const symbolsByName = new Map<string, CodeSymbol[]>();
   for (const symbol of symbols) {
-    if (!mentionsSymbol(text, symbol)) continue;
-    const file = candidateFiles.get(symbol.fileId) ?? store.getFile(obs.projectId, symbol.path);
-    if (!file) continue;
-    candidateFiles.set(file.id, file);
-    const ref = symbolRef(obs.projectId, obs, file, symbol);
-    refs.set(ref.id, ref);
+    const group = symbolsByName.get(symbol.name) ?? [];
+    group.push(symbol);
+    symbolsByName.set(symbol.name, group);
+  }
+
+  for (const group of symbolsByName.values()) {
+    const candidates = group.length === 1 ? group : [];
+    for (const symbol of candidates) {
+      if (!mentionsSymbol(text, symbol)) continue;
+      const file = candidateFiles.get(symbol.fileId) ?? lookup.findFile(symbol.path);
+      if (!file) continue;
+      candidateFiles.set(file.id, file);
+      const ref = symbolRef(obs.projectId, obs, file, symbol);
+      refs.set(ref.id, ref);
+    }
   }
 
-  const result = [...refs.values()];
-  store.replaceObservationRefs(obs.projectId, obs.id, result);
-  return result;
+  return [...refs.values()];
+}
+
+function createStoreLookup(store: CodeGraphStore, projectId: string): CodeBindingLookup {
+  return {
+    findFile: path => store.getFile(projectId, path) ?? undefined,
+    findSymbols: (names, hintedFileIds) => store.findSymbolsByNames(projectId, names, hintedFileIds),
+  };
+}
+
+function createSnapshotLookup(files: CodeFile[], symbols: CodeSymbol[]): CodeBindingLookup {
+  const filesByPath = new Map(files.map(file => [normalizeCodePath(file.path), file]));
+  const symbolsByName = new Map<string, CodeSymbol[]>();
+  for (const symbol of symbols) {
+    const group = symbolsByName.get(symbol.name) ?? [];
+    group.push(symbol);
+    symbolsByName.set(symbol.name, group);
+  }
+
+  return {
+    findFile: path => filesByPath.get(normalizeCodePath(path)),
+    findSymbols: (names, hintedFileIds) => {
+      const hinted = new Set(hintedFileIds);
+      const found: CodeSymbol[] = [];
+      for (const name of names) {
+        const candidates = symbolsByName.get(name) ?? [];
+        found.push(...(hinted.size > 0 ? candidates.filter(symbol => hinted.has(symbol.fileId)) : candidates));
+      }
+      return found;
+    },
+  };
+}
+
+export async function bindObservationToCode(
+  store: CodeGraphStore,
+  obs: BindableObservation,
+): Promise<ObservationCodeRef[]> {
+  const refs = resolveObservationCodeRefs(obs, createStoreLookup(store, obs.projectId));
+  store.replaceObservationRefs(obs.projectId, obs.id, refs);
+  return refs;
 }
 
 export async function backfillMissingObservationCodeRefs(
@@ -92,14 +164,35 @@ export async function backfillMissingObservationCodeRefs(
 ): Promise<CodeRefBackfillResult> {
   let observationsBackfilled = 0;
   let refsBackfilled = 0;
+  const boundObservationIdsByProject = new Map<string, Set<number>>();
+  const lookupByProject = new Map<string, CodeBindingLookup>();
+
+  for (const projectId of new Set(observations.map(observation => observation.projectId))) {
+    boundObservationIdsByProject.set(
+      projectId,
+      new Set(store.listProjectObservationRefs(projectId).map(ref => ref.observationId)),
+    );
+    lookupByProject.set(
+      projectId,
+      createSnapshotLookup(store.listFiles(projectId), store.listSymbols(projectId)),
+    );
+  }
 
+  const refsToInsert: ObservationCodeRef[] = [];
   for (const observation of observations) {
-    if (store.listObservationRefs(observation.projectId, observation.id).length > 0) continue;
-    const refs = await bindObservationToCode(store, observation);
+    if (boundObservationIdsByProject.get(observation.projectId)?.has(observation.id)) continue;
+    if ((observation.filesModified?.length ?? 0) === 0 && codeIdentifierCandidates(observationText(observation)).length === 0) {
+      continue;
+    }
+    const lookup = lookupByProject.get(observation.projectId);
+    if (!lookup) continue;
+    const refs = resolveObservationCodeRefs(observation, lookup);
     if (refs.length === 0) continue;
     observationsBackfilled += 1;
     refsBackfilled += refs.length;
+    refsToInsert.push(...refs);
   }
+  store.upsertObservationRefs(refsToInsert);
 
   return {
     observationsScanned: observations.length,

package/src/codegraph/context-pack.ts

@@ -1,6 +1,7 @@
 import { evaluateCodeRefFreshness } from './freshness.js';
 import type { CodeFile, CodeRefStatus, CodeSymbol, ObservationCodeRef } from './types.js';
 import type { CodeGraphStore } from './store.js';
+import { isCodeGraphExcludedPath } from './exclude.js';
 
 export interface ContextPackMemory {
   id: number;
@@ -52,6 +53,7 @@ export interface AssembleContextPackInput {
   files: CodeFile[];
   symbols: CodeSymbol[];
   suggestedVerification?: string[];
+  exclude?: string[];
 }
 
 function uniq<T>(items: T[]): T[] {
@@ -68,14 +70,6 @@ function timestampOf(observation: ContextPackObservation): number {
   return Date.parse(observation.updatedAt ?? observation.createdAt ?? '') || 0;
 }
 
-function isGeneratedPath(path: string): boolean {
-  const normalized = path.replace(/\\/g, '/');
-  return (
-    /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules|\.git|\.tmp|\.worktrees)(\/|$)/i.test(normalized) ||
-    /(^|\/)\.claude\/worktrees(\/|$)/i.test(normalized)
-  );
-}
-
 function relevanceScore(observation: ContextPackObservation, taskTokens: string[]): number {
   if (taskTokens.length === 0) return 0;
   const title = observation.title.toLowerCase();
@@ -137,6 +131,7 @@ export function assembleContextPackForTask(input: {
   observations: ContextPackObservation[];
   limit?: number;
   suggestedVerification?: string[];
+  exclude?: string[];
 }): ContextPack {
   const selected = selectRelevantObservations(input.observations, input.task, input.limit ?? 20);
   const refs = selected.flatMap(obs => input.store.listObservationRefs(input.projectId, obs.id));
@@ -151,6 +146,7 @@ export function assembleContextPackForTask(input: {
     files,
     symbols,
     suggestedVerification: input.suggestedVerification,
+    exclude: input.exclude,
   });
 }
 
@@ -172,6 +168,7 @@ export function assembleContextPack(input: AssembleContextPackInput): ContextPac
 
     const file = ref.fileId ? files.get(ref.fileId) : undefined;
     const symbol = ref.symbolId ? symbols.get(ref.symbolId) : undefined;
+    if (file && isCodeGraphExcludedPath(file.path, input.exclude)) continue;
     const freshness = evaluateCodeRefFreshness(ref, file, symbol);
 
     if (freshness.status === 'current') {
@@ -247,8 +244,8 @@ export function buildContextPackPrompt(pack: ContextPack): string {
   const reliableMemories = pack.memories.filter(memory => memory.status === 'current');
   const unboundMemories = pack.memories.filter(memory => memory.status === 'unbound');
   const lines: string[] = ['## Task', pack.task, '', '## Reliable Memories'];
-  const visibleCodeFacts = pack.codeFacts.filter(fact => !isGeneratedPath(fact.path)).slice(0, 5);
-  const visibleSuggestedReads = pack.suggestedReads.filter(path => !isGeneratedPath(path)).slice(0, 5);
+  const visibleCodeFacts = pack.codeFacts.filter(fact => !isCodeGraphExcludedPath(fact.path)).slice(0, 5);
+  const visibleSuggestedReads = pack.suggestedReads.filter(path => !isCodeGraphExcludedPath(path)).slice(0, 5);
 
   if (reliableMemories.length === 0) lines.push('- none');
   for (const memory of reliableMemories) {

package/src/codegraph/exclude.ts

@@ -0,0 +1,47 @@
+export const DEFAULT_CODEGRAPH_EXCLUDES = [
+  'node_modules/**',
+  'dist/**',
+  'build/**',
+  'coverage/**',
+  '.next/**',
+  '.turbo/**',
+  '.git/**',
+  '.tmp/**',
+  '.worktrees/**',
+  '.claude/worktrees/**',
+];
+
+export function normalizeCodeGraphExcludePatterns(exclude?: string[]): string[] {
+  return [...new Set([
+    ...DEFAULT_CODEGRAPH_EXCLUDES,
+    ...(exclude ?? []).map(pattern => pattern.trim()).filter(Boolean),
+  ])];
+}
+
+export function isCodeGraphExcludedPath(path: string, exclude?: string[]): boolean {
+  const normalized = normalizeCodePath(path);
+  return normalizeCodeGraphExcludePatterns(exclude).some((pattern) => matchesPattern(normalized, normalizeCodePath(pattern)));
+}
+
+function normalizeCodePath(path: string): string {
+  return path.replace(/\\/g, '/').replace(/^\.\/+/, '');
+}
+
+function matchesPattern(path: string, pattern: string): boolean {
+  if (pattern.endsWith('/**')) {
+    const base = pattern.slice(0, -3);
+    if (base.startsWith('**/')) {
+      const suffix = base.slice(3);
+      return path === suffix || path.endsWith(`/${suffix}`) || path.includes(`/${suffix}/`);
+    }
+    if (!base.includes('/')) {
+      return path === base || path.startsWith(`${base}/`) || path.includes(`/${base}/`);
+    }
+    return path === base || path.startsWith(`${base}/`);
+  }
+  if (pattern.startsWith('**/')) {
+    const suffix = pattern.slice(3);
+    return path === suffix || path.endsWith(`/${suffix}`);
+  }
+  return path === pattern || path.startsWith(`${pattern}/`);
+}

package/src/codegraph/lite-provider.ts

@@ -3,6 +3,7 @@ import { readdirSync, readFileSync, statSync, type Dirent } from 'node:fs';
 import { join, relative } from 'node:path';
 import type { CodeEdge, CodeFile, CodeSymbol } from './types.js';
 import { makeCodeEdgeId, makeCodeFileId, makeCodeSymbolId, normalizeCodePath } from './ids.js';
+import { isCodeGraphExcludedPath, normalizeCodeGraphExcludePatterns } from './exclude.js';
 
 export interface LiteIndexOptions {
   projectId: string;
@@ -140,8 +141,8 @@ const languageProfiles: Record<string, LanguageProfile> = {
   },
   ruby: {
     symbols: [
-      { kind: 'class', re: /^class\s+([A-Za-z_][\w:]*?)\b/gm },
-      { kind: 'function', re: /^def\s+([A-Za-z_][\w!?=]*)\b/gm },
+      { kind: 'class', re: /^class\s+([A-Za-z_][\w]*(?:::[A-Za-z_][\w]*)*)/gm },
+      { kind: 'function', re: /^def\s+([A-Za-z_][\w]*[!?=]?)/gm },
     ],
     imports: [/require\s+['"]([^'"]+)['"]/g],
   },
@@ -169,19 +170,6 @@ function languageForPath(path: string): string {
   return LANGUAGE_BY_EXTENSION.get(ext) ?? 'unknown';
 }
 
-function isExcluded(path: string, exclude: string[]): boolean {
-  const normalized = normalizeCodePath(path);
-  return exclude.some((pattern) => {
-    const p = normalizeCodePath(pattern);
-    if (p.endsWith('/**')) {
-      const base = p.slice(0, -3);
-      return normalized === base || normalized.startsWith(`${base}/`);
-    }
-    if (p.startsWith('**/')) return normalized.endsWith(p.slice(3));
-    return normalized === p || normalized.startsWith(`${p}/`);
-  });
-}
-
 function walk(root: string, exclude: string[], maxFiles: number): string[] {
   const out: string[] = [];
   const visit = (dir: string) => {
@@ -196,7 +184,7 @@ function walk(root: string, exclude: string[], maxFiles: number): string[] {
     for (const entry of entries) {
       const abs = join(dir, entry.name);
       const rel = normalizeCodePath(relative(root, abs));
-      if (isExcluded(rel, exclude)) continue;
+      if (isCodeGraphExcludedPath(rel, exclude)) continue;
       if (entry.isDirectory()) {
         if (entry.name === '.git' || entry.name === '.worktrees' || entry.name === '.tmp' || entry.name === 'node_modules') continue;
         if (rel === '.claude/worktrees' || rel.startsWith('.claude/worktrees/')) continue;
@@ -290,18 +278,7 @@ function extractImportEdges(projectId: string, file: CodeFile, text: string, ind
 }
 
 export async function indexProjectLite(options: LiteIndexOptions): Promise<LiteIndexResult> {
-  const exclude = options.exclude ?? [
-    'node_modules/**',
-    'dist/**',
-    'build/**',
-    'coverage/**',
-    '.next/**',
-    '.turbo/**',
-    '.git/**',
-    '.tmp/**',
-    '.worktrees/**',
-    '.claude/worktrees/**',
-  ];
+  const exclude = normalizeCodeGraphExcludePatterns(options.exclude);
   const maxFiles = options.maxFiles ?? 5000;
   const indexedAt = new Date().toISOString();
   const paths = walk(options.projectRoot, exclude, maxFiles);