memorix 1.1.9 → 1.1.10

package/docs/dev-log/progress.txt

@@ -4,32 +4,35 @@
 > exist under subdirectories; prefer this file for repository-wide state.
 
 ## Current State
-- Phase: 1.1.9 release finalization
-- Branch: main
-- PR: #120, #121, and #123 merged
-- Last updated: 2026-07-12
-- Goal: publish 1.1.9 after accepting the latest contributor fixes and closing local release hygiene gaps.
+- 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 #120: configurable CodeGraph exclude patterns for indexing, Project Context, context packs, diagnostics, and docs.
-- Merged PR #121: `memorix config get` accepts TOML-style snake_case dotted keys against resolved camelCase config.
-- Merged PR #123: Orama search access tracking preserves vector-backed documents, public/detail cache results strip embeddings, and hydration reconciles exact observation IDs even when mini-skills already populate the shared index.
-- Cleaned the unrelated local model catalog refresh and deleted memcode image from the main working tree before release prep.
-- Bumped root and workspace package versions to `1.1.9` 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
-- Publish `1.1.9`, create the GitHub release, and confirm npm resolves the new root package version.
+- Commit, publish `memorix@1.1.10`, create the GitHub release, and reply to #124 with the upgrade path.
 
 ## Verification Snapshot
-- Latest main CI for `cd3f024` passed on Ubuntu and Windows before release prep.
-- Targeted Orama/config/CodeGraph checks passed during PR review for #120, #121, and #123.
-- Final 1.1.9 release verification is run from the release commit before publishing: `git diff --check`, `npm run lint`, `npm run build`, `npm test`, and package dry-runs.
+- 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.9 release patch.
-- Tag and publish `memorix@1.1.9` plus workspaces in dependency order.
+- 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.9",
+  "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/codegraph/auto-context.ts

@@ -7,7 +7,6 @@ import { collectCurrentProjectFacts, type CurrentProjectFacts } from './current-
 import { indexProjectLite } from './lite-provider.js';
 import {
   buildProjectContextExplain,
-  buildProjectContextOverview,
   type ProjectContextExplain,
   type ProjectContextObservation,
   type ProjectContextOverview,
@@ -147,18 +146,13 @@ export async function buildAutoProjectContext(input: {
     }
   }
 
-  const overview = buildProjectContextOverview({
-    project: input.project,
-    store,
-    observations: input.observations,
-    exclude,
-  });
   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/lite-provider.ts

@@ -141,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],
   },

package/src/codegraph/project-context.ts

@@ -107,11 +107,13 @@ function collectGraph(
   suggestedReads: string[];
 } {
   const files = store.listFiles(projectId);
-  const symbols = files.flatMap(file => store.listSymbolsForFile(file.id));
+  const symbols = store.listReferencedSymbols(projectId);
   const filesById = new Map(files.map(file => [file.id, file]));
   const symbolsById = new Map(symbols.map(symbol => [symbol.id, symbol]));
   const observationsById = new Map(observations.map(obs => [obs.id, obs]));
-  const refs = observations.flatMap(obs => store.listObservationRefs(projectId, obs.id));
+  const activeObservationIds = new Set(observations.map(obs => obs.id));
+  const refs = store.listProjectObservationRefs(projectId)
+    .filter(ref => activeObservationIds.has(ref.observationId));
   const freshness: ProjectContextOverview['freshness'] = {
     current: 0,
     suspect: 0,
@@ -153,16 +155,14 @@ function collectGraph(
   };
 }
 
-export function buildProjectContextOverview(input: {
+function overviewFromGraph(input: {
   project: Pick<ProjectInfo, 'id' | 'name' | 'rootPath'>;
   store: CodeGraphStore;
   observations: ProjectContextObservation[];
-  exclude?: string[];
+  active: ProjectContextObservation[];
+  graph: ReturnType<typeof collectGraph>;
 }): ProjectContextOverview {
-  const active = activeObservations(input.observations, input.project.id);
-  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
   const status = input.store.status(input.project.id);
-
   return {
     project: input.project,
     code: {
@@ -172,26 +172,49 @@ export function buildProjectContextOverview(input: {
       edges: status.edges,
       refs: status.refs,
       ...(status.indexedAt ? { indexedAt: status.indexedAt } : {}),
-      languages: countLanguages(graph.files),
+      languages: countLanguages(input.graph.files),
     },
     memory: {
       total: input.observations.filter(obs => obs.projectId === input.project.id).length,
-      active: active.length,
+      active: input.active.length,
     },
-    freshness: graph.freshness,
-    suggestedReads: graph.suggestedReads,
+    freshness: input.graph.freshness,
+    suggestedReads: input.graph.suggestedReads,
   };
 }
 
+export function buildProjectContextOverview(input: {
+  project: Pick<ProjectInfo, 'id' | 'name' | 'rootPath'>;
+  store: CodeGraphStore;
+  observations: ProjectContextObservation[];
+  exclude?: string[];
+}): ProjectContextOverview {
+  const active = activeObservations(input.observations, input.project.id);
+  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
+  return overviewFromGraph({
+    project: input.project,
+    store: input.store,
+    observations: input.observations,
+    active,
+    graph,
+  });
+}
+
 export function buildProjectContextExplain(input: {
   project: Pick<ProjectInfo, 'id' | 'name' | 'rootPath'>;
   store: CodeGraphStore;
   observations: ProjectContextObservation[];
   exclude?: string[];
 }): ProjectContextExplain {
-  const overview = buildProjectContextOverview(input);
   const active = activeObservations(input.observations, input.project.id);
   const graph = collectGraph(input.store, input.project.id, active, input.exclude);
+  const overview = overviewFromGraph({
+    project: input.project,
+    store: input.store,
+    observations: input.observations,
+    active,
+    graph,
+  });
   return {
     project: input.project,
     sources: graph.sources.sort((a, b) => a.observationId - b.observationId || (a.path ?? '').localeCompare(b.path ?? '')),

package/src/codegraph/store.ts

@@ -316,6 +316,47 @@ export class CodeGraphStore {
     `).all(projectId, like, like, like, limit).map(rowToSymbol);
   }
 
+  listSymbols(projectId: string): CodeSymbol[] {
+    return this.db.prepare(`
+      SELECT * FROM code_symbols
+      WHERE projectId = ? AND stale = 0
+      ORDER BY path, startLine
+    `).all(projectId).map(rowToSymbol);
+  }
+
+  findSymbolsByNames(projectId: string, names: string[], fileIds: string[] = []): CodeSymbol[] {
+    const candidates = [...new Set(names.map(name => name.trim()).filter(Boolean))];
+    if (candidates.length === 0) return [];
+    const candidateJson = JSON.stringify(candidates);
+    const hintedFiles = [...new Set(fileIds.map(fileId => fileId.trim()).filter(Boolean))];
+    if (hintedFiles.length > 0) {
+      return this.db.prepare(`
+        SELECT * FROM code_symbols
+        WHERE projectId = ?
+          AND stale = 0
+          AND name IN (SELECT value FROM json_each(?))
+          AND fileId IN (SELECT value FROM json_each(?))
+        ORDER BY path, startLine
+      `).all(projectId, candidateJson, JSON.stringify(hintedFiles)).map(rowToSymbol);
+    }
+
+    return this.db.prepare(`
+      SELECT symbols.*
+      FROM code_symbols AS symbols
+      INNER JOIN (
+        SELECT name
+        FROM code_symbols
+        WHERE projectId = ?
+          AND stale = 0
+          AND name IN (SELECT value FROM json_each(?))
+        GROUP BY name
+        HAVING COUNT(*) = 1
+      ) AS unambiguous ON unambiguous.name = symbols.name
+      WHERE symbols.projectId = ? AND symbols.stale = 0
+      ORDER BY symbols.path, symbols.startLine
+    `).all(projectId, candidateJson, projectId).map(rowToSymbol);
+  }
+
   listSymbolsForFile(fileId: string): CodeSymbol[] {
     return this.db.prepare(`SELECT * FROM code_symbols WHERE fileId = ? AND stale = 0 ORDER BY startLine`).all(fileId).map(rowToSymbol);
   }
@@ -332,6 +373,24 @@ export class CodeGraphStore {
     `).all(projectId, observationId).map(rowToRef);
   }
 
+  listProjectObservationRefs(projectId: string): ObservationCodeRef[] {
+    return this.db.prepare(`
+      SELECT * FROM observation_code_refs
+      WHERE projectId = ?
+      ORDER BY observationId, status, id
+    `).all(projectId).map(rowToRef);
+  }
+
+  listReferencedSymbols(projectId: string): CodeSymbol[] {
+    return this.db.prepare(`
+      SELECT DISTINCT symbols.*
+      FROM code_symbols AS symbols
+      INNER JOIN observation_code_refs AS refs ON refs.symbolId = symbols.id
+      WHERE refs.projectId = ? AND symbols.projectId = ? AND symbols.stale = 0
+      ORDER BY symbols.path, symbols.startLine
+    `).all(projectId, projectId).map(rowToSymbol);
+  }
+
   status(projectId: string): CodeGraphStatus {
     const files = this.db.prepare(`SELECT COUNT(*) AS count FROM code_files WHERE projectId = ?`).get(projectId).count;
     const symbols = this.db.prepare(`SELECT COUNT(*) AS count FROM code_symbols WHERE projectId = ? AND stale = 0`).get(projectId).count;