memorix 1.1.8 → 1.1.9

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,41 +4,26 @@
 > exist under subdirectories; prefer this file for repository-wide state.
 
 ## Current State
-- Phase: 1.1.8 release finalization
+- Phase: 1.1.9 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.
+- 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.
 
 ## 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.
+- 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.
 
 ## 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`.
+- Publish `1.1.9`, create the GitHub release, and confirm npm resolves the new root package version.
 
 ## 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.
+- 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.
 
 ## 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.
@@ -46,6 +31,5 @@
 - 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.9 release patch.
+- Tag and publish `memorix@1.1.9` plus workspaces in dependency order.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "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,5 +1,6 @@
 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';
@@ -100,11 +101,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 +129,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(
@@ -147,11 +151,13 @@ export async function buildAutoProjectContext(input: {
     project: input.project,
     store,
     observations: input.observations,
+    exclude,
   });
   const explain = buildProjectContextExplain({
     project: input.project,
     store,
     observations: input.observations,
+    exclude,
   });
 
   return {

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;
@@ -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);

package/src/codegraph/project-context.ts

@@ -2,6 +2,7 @@ import type { ProjectInfo } from '../types.js';
 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 ProjectContextObservation {
   id: number;
@@ -77,29 +78,17 @@ function countLanguages(files: CodeFile[]): LanguageSummary[] {
     .sort((a, b) => a.language.localeCompare(b.language));
 }
 
-function normalizePath(path: string): string {
-  return path.replace(/\\/g, '/');
-}
-
-function isGeneratedPath(path: string): boolean {
-  const normalized = normalizePath(path);
-  return (
-    /(^|\/)(dist|build|coverage|\.next|\.turbo|node_modules|\.git|\.tmp|\.worktrees)(\/|$)/i.test(normalized) ||
-    /(^|\/)\.claude\/worktrees(\/|$)/i.test(normalized)
-  );
-}
-
 function suggestedReadRank(path: string): number {
-  const normalized = normalizePath(path);
+  const normalized = path.replace(/\\/g, '/');
   if (normalized.startsWith('src/')) return 0;
   if (normalized.startsWith('tests/') || normalized.startsWith('test/')) return 0;
   if (normalized.startsWith('packages/') && normalized.includes('/src/')) return 2;
   return 3;
 }
 
-function compactSuggestedReads(paths: string[], limit = 8): string[] {
+function compactSuggestedReads(paths: string[], limit = 8, exclude?: string[]): string[] {
   return uniq(paths)
-    .filter(path => !isGeneratedPath(path))
+    .filter(path => !isCodeGraphExcludedPath(path, exclude))
     .sort((a, b) => suggestedReadRank(a) - suggestedReadRank(b))
     .slice(0, limit);
 }
@@ -108,6 +97,7 @@ function collectGraph(
   store: CodeGraphStore,
   projectId: string,
   observations: ProjectContextObservation[],
+  exclude?: string[],
 ): {
   files: CodeFile[];
   symbols: CodeSymbol[];
@@ -139,7 +129,9 @@ function collectGraph(
 
     const observation = observationsById.get(ref.observationId);
     if (!observation) continue;
-    if (result.status === 'current' && file) suggestedReads.push(file.path);
+    const excluded = file ? isCodeGraphExcludedPath(file.path, exclude) : false;
+    if (result.status === 'current' && file && !excluded) suggestedReads.push(file.path);
+    if (excluded) continue;
     sources.push({
       observationId: observation.id,
       title: observation.title,
@@ -157,7 +149,7 @@ function collectGraph(
     refs,
     freshness,
     sources,
-    suggestedReads: compactSuggestedReads(suggestedReads),
+    suggestedReads: compactSuggestedReads(suggestedReads, 8, exclude),
   };
 }
 
@@ -165,9 +157,10 @@ 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);
+  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
   const status = input.store.status(input.project.id);
 
   return {
@@ -194,10 +187,11 @@ 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);
+  const graph = collectGraph(input.store, input.project.id, active, input.exclude);
   return {
     project: input.project,
     sources: graph.sources.sort((a, b) => a.observationId - b.observationId || (a.path ?? '').localeCompare(b.path ?? '')),

package/src/config/resolved-config.ts

@@ -51,6 +51,9 @@ export interface ResolvedMemorixConfig {
     excludePatterns?: string[];
     noiseKeywords?: string[];
   };
+  codegraph: {
+    excludePatterns?: string[];
+  };
   server: {
     transport?: 'stdio' | 'http';
     dashboard?: boolean;
@@ -147,6 +150,9 @@ export function getResolvedConfig(options: ResolvedLaneOptions = {}): ResolvedMe
       excludePatterns: firstArray(toml.git?.exclude_patterns, yaml.git?.excludePatterns),
       noiseKeywords: firstArray(toml.git?.noise_keywords, yaml.git?.noiseKeywords),
     },
+    codegraph: {
+      excludePatterns: firstArray(toml.codegraph?.exclude_patterns, yaml.codegraph?.excludePatterns),
+    },
     server: {
       transport: first(toml.server?.transport, yaml.server?.transport),
       dashboard: firstBool(toml.server?.dashboard, yaml.server?.dashboard),

package/src/config/toml-loader.ts

@@ -39,6 +39,9 @@ export interface MemorixTomlConfig {
     exclude_patterns?: string[];
     noise_keywords?: string[];
   };
+  codegraph?: {
+    exclude_patterns?: string[];
+  };
   server?: {
     transport?: 'stdio' | 'http';
     dashboard?: boolean;
@@ -91,6 +94,7 @@ function mergeTomlConfig(base: MemorixTomlConfig, override: MemorixTomlConfig):
     embedding: { ...base.embedding, ...override.embedding },
     hooks: { ...base.hooks, ...override.hooks },
     git: { ...base.git, ...override.git },
+    codegraph: { ...base.codegraph, ...override.codegraph },
     server: { ...base.server, ...override.server },
   };
 }

package/src/config/yaml-loader.ts

@@ -64,6 +64,12 @@ export interface MemorixYamlConfig {
     noiseKeywords?: string[];
   };
 
+  /** CodeGraph / Project Context configuration */
+  codegraph?: {
+    /** File patterns to exclude from CodeGraph indexing and context suggestions */
+    excludePatterns?: string[];
+  };
+
   /** Behavior settings */
   behavior?: {
     /** Session start injection mode */
@@ -184,6 +190,7 @@ export function loadYamlConfig(projectRoot?: string | null): MemorixYamlConfig {
     agent: { ...userConfig.agent, ...projectConfig.agent },
     embedding: { ...userConfig.embedding, ...projectConfig.embedding },
     git: { ...userConfig.git, ...projectConfig.git },
+    codegraph: { ...userConfig.codegraph, ...projectConfig.codegraph },
     behavior: { ...userConfig.behavior, ...projectConfig.behavior },
     server: { ...userConfig.server, ...projectConfig.server },
     team: { ...userConfig.team, ...projectConfig.team },

package/src/server.ts

@@ -1295,8 +1295,10 @@ export async function createMemorixServer(
       return withFreshIndex(async () => {
         const { CodeGraphStore } = await import('./codegraph/store.js');
         const { assembleContextPackForTask, buildContextPackPrompt } = await import('./codegraph/context-pack.js');
+        const { getResolvedConfig } = await import('./config/resolved-config.js');
         const store = new CodeGraphStore();
         await store.init(projectDir);
+        const exclude = getResolvedConfig({ projectRoot: project.rootPath }).codegraph.excludePatterns;
 
         const observations = getAllObservations()
           .filter(obs => obs.projectId === project.id && (obs.status ?? 'active') === 'active')
@@ -1307,6 +1309,7 @@ export async function createMemorixServer(
           task,
           observations,
           limit: typeof limit === 'number' ? limit : 20,
+          exclude,
         });
         const text = buildContextPackPrompt(pack);
 

package/src/store/orama-store.ts

@@ -8,7 +8,7 @@
  * Vector search (embeddings) will be added in P1 phase.
  */
 
-import { create, insert, search, remove, update, count, type AnyOrama } from '@orama/orama';
+import { create, insert, search, remove, update, count, getByID, type AnyOrama } from '@orama/orama';
 import type { MemorixDocument, SearchOptions, IndexEntry, KnowledgeLayer } from '../types.js';
 import { OBSERVATION_ICONS, type ObservationType } from '../types.js';
 import { resolveKnowledgeLayer } from '../skills/mini-skills.js';
@@ -52,9 +52,13 @@ function makeEntryKey(projectId: string | undefined, observationId: number): str
   return `${projectId ?? ''}::${observationId}`;
 }
 
-function rememberObservationDoc(doc: MemorixDocument): void {
-  if (!doc.projectId || typeof doc.observationId !== 'number') return;
-  docByObservationKey.set(makeEntryKey(doc.projectId, doc.observationId), doc);
+function rememberObservationDoc(doc: MemorixDocument): MemorixDocument {
+  const publicDoc = { ...doc };
+  delete publicDoc.embedding;
+  if (doc.projectId && typeof doc.observationId === 'number') {
+    docByObservationKey.set(makeEntryKey(doc.projectId, doc.observationId), publicDoc);
+  }
+  return publicDoc;
 }
 
 function isCommandLikeQuery(query: string): boolean {
@@ -243,15 +247,15 @@ export async function batchGenerateEmbeddings(texts: string[]): Promise<(number[
  */
 export async function hydrateIndex(observations: any[]): Promise<number> {
   const database = await getDb();
-  const currentCount = await count(database);
-  if (currentCount > 0) return 0; // already hydrated
 
   let inserted = 0;
   for (const obs of observations) {
     if (!obs || !obs.id || !obs.projectId) continue;
     try {
+      const id = makeOramaObservationId(obs.projectId, obs.id);
+      if (getByID(database, id)) continue;
       const doc: MemorixDocument = {
-        id: makeOramaObservationId(obs.projectId, obs.id),
+        id,
         observationId: obs.id,
         entityName: obs.entityName || '',
         type: obs.type || 'discovery',
@@ -376,6 +380,7 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
   let searchParams: Record<string, unknown> = {
     term: originalQuery,
     limit: requestLimit,
+    includeVectors: true,
     ...(Object.keys(filters).length > 0 ? { where: filters } : {}),
     // Search specific fields (not tokens, accessCount, etc.)
     properties: ['title', 'entityName', 'narrative', 'facts', 'concepts', 'filesModified'],
@@ -458,6 +463,7 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
       const vectorOnlyParams: Record<string, unknown> = {
         term: '',
         limit: requestLimit,
+        includeVectors: true,
         ...(Object.keys(filters).length > 0 ? { where: filters } : {}),
         mode: 'vector',
         vector: {
@@ -887,6 +893,7 @@ export async function getObservationsByIds(
 
     const searchResult = await search(database, {
       term: '',
+      includeVectors: true,
       where: {
         observationId: { eq: id },
         ...(projectId ? { projectId } : {}),
@@ -895,7 +902,7 @@ export async function getObservationsByIds(
     });
 
     if (searchResult.hits.length > 0) {
-      results.push(searchResult.hits[0].document as unknown as MemorixDocument);
+      results.push(rememberObservationDoc(searchResult.hits[0].document as unknown as MemorixDocument));
     }
   }