memorix 1.7.2 → 1.8.0

package/src/store/evidence-store.ts

@@ -0,0 +1,261 @@
+import { createHash, randomUUID } from 'node:crypto';
+import type { Observation } from '../types.js';
+import { getDatabase } from './sqlite-db.js';
+
+export type EvidenceCandidateKind = 'observation' | 'code' | 'git' | 'test' | 'document' | 'workflow' | 'graph';
+export type EvidenceVerification = 'unverified' | 'verified' | 'conflicted';
+export type EvidenceFreshness = 'current' | 'stale' | 'unknown';
+
+export interface EvidenceCardRecord {
+  id: string;
+  projectId: string;
+  candidateKind: EvidenceCandidateKind;
+  candidateId: string;
+  title: string;
+  summary: string;
+  entityName?: string;
+  sourceKind: string;
+  sourceRef: string;
+  locator?: string;
+  capturedHash?: string;
+  sessionId?: string;
+  status: string;
+  verification: EvidenceVerification;
+  freshness: EvidenceFreshness;
+  staleReason?: string;
+  files: string[];
+  relatedEntities: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface EvidenceCardEvent {
+  id: string;
+  projectId: string;
+  cardId: string;
+  kind: string;
+  detail?: string;
+  createdAt: string;
+}
+
+function safeJson<T>(value: unknown, fallback: T): T {
+  if (typeof value !== 'string' || value.length === 0) return fallback;
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+function rowToCard(row: any): EvidenceCardRecord {
+  return {
+    id: String(row.id),
+    projectId: String(row.project_id),
+    candidateKind: row.candidate_kind,
+    candidateId: String(row.candidate_id),
+    title: String(row.title),
+    summary: String(row.summary ?? ''),
+    ...(row.entity_name ? { entityName: String(row.entity_name) } : {}),
+    sourceKind: String(row.source_kind),
+    sourceRef: String(row.source_ref),
+    ...(row.locator ? { locator: String(row.locator) } : {}),
+    ...(row.captured_hash ? { capturedHash: String(row.captured_hash) } : {}),
+    ...(row.session_id ? { sessionId: String(row.session_id) } : {}),
+    status: String(row.status ?? 'active'),
+    verification: row.verification,
+    freshness: row.freshness,
+    ...(row.stale_reason ? { staleReason: String(row.stale_reason) } : {}),
+    files: safeJson(row.files_json, []),
+    relatedEntities: safeJson(row.related_entities_json, []),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+  };
+}
+
+function observationHash(observation: Observation): string {
+  return createHash('sha256')
+    .update(JSON.stringify({
+      projectId: observation.projectId,
+      id: observation.id,
+      title: observation.title,
+      narrative: observation.narrative,
+      facts: observation.facts,
+      files: observation.filesModified,
+      relatedEntities: observation.relatedEntities,
+    }))
+    .digest('hex');
+}
+
+function sourceKind(observation: Observation): string {
+  if (observation.source === 'git' || observation.sourceDetail === 'git-ingest') return 'git';
+  if (observation.sourceDetail === 'hook') return 'hook';
+  return observation.source ?? 'agent';
+}
+
+/** SQLite-backed provenance cards used by MCP, CLI, and Dashboard surfaces. */
+export class EvidenceCardStore {
+  private db: any = null;
+
+  async init(dataDir: string): Promise<void> {
+    this.db = getDatabase(dataDir);
+  }
+
+  private requireDb(): any {
+    if (!this.db) throw new Error('EvidenceCardStore is not initialized.');
+    return this.db;
+  }
+
+  upsertObservation(observation: Observation): EvidenceCardRecord {
+    const db = this.requireDb();
+    const now = new Date().toISOString();
+    const card: EvidenceCardRecord = {
+      id: `evidence:observation:${observation.projectId}:${observation.id}`,
+      projectId: observation.projectId,
+      candidateKind: 'observation',
+      candidateId: String(observation.id),
+      title: observation.title,
+      summary: observation.narrative.slice(0, 500),
+      entityName: observation.entityName,
+      sourceKind: sourceKind(observation),
+      sourceRef: `observation:${observation.id}`,
+      locator: observation.filesModified?.join(', ') || `observation:${observation.id}`,
+      capturedHash: observationHash(observation),
+      ...(observation.sessionId ? { sessionId: observation.sessionId } : {}),
+      status: observation.status ?? 'active',
+      verification: observation.status === 'resolved' ? 'verified' : 'unverified',
+      freshness: 'current',
+      files: observation.filesModified ?? [],
+      relatedEntities: observation.relatedEntities ?? [],
+      createdAt: observation.createdAt,
+      updatedAt: now,
+    };
+    db.prepare(`
+      INSERT INTO evidence_cards (
+        id, project_id, candidate_kind, candidate_id, title, summary, entity_name,
+        source_kind, source_ref, locator, captured_hash, session_id, status,
+        verification, freshness, stale_reason, files_json, related_entities_json,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)
+      ON CONFLICT(project_id, candidate_kind, candidate_id) DO UPDATE SET
+        title = excluded.title,
+        summary = excluded.summary,
+        entity_name = excluded.entity_name,
+        source_kind = excluded.source_kind,
+        source_ref = excluded.source_ref,
+        locator = excluded.locator,
+        captured_hash = excluded.captured_hash,
+        session_id = excluded.session_id,
+        status = excluded.status,
+        freshness = 'current',
+        stale_reason = NULL,
+        files_json = excluded.files_json,
+        related_entities_json = excluded.related_entities_json,
+        updated_at = excluded.updated_at
+    `).run(
+      card.id,
+      card.projectId,
+      card.candidateKind,
+      card.candidateId,
+      card.title,
+      card.summary,
+      card.entityName ?? null,
+      card.sourceKind,
+      card.sourceRef,
+      card.locator ?? null,
+      card.capturedHash ?? null,
+      card.sessionId ?? null,
+      card.status,
+      card.verification,
+      card.freshness,
+      JSON.stringify(card.files),
+      JSON.stringify(card.relatedEntities),
+      card.createdAt,
+      card.updatedAt,
+    );
+    return this.get(card.projectId, card.candidateKind, card.candidateId) ?? card;
+  }
+
+  get(projectId: string, candidateKind: EvidenceCandidateKind, candidateId: string): EvidenceCardRecord | undefined {
+    const row = this.requireDb().prepare(`
+      SELECT * FROM evidence_cards WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+    `).get(projectId, candidateKind, candidateId);
+    return row ? rowToCard(row) : undefined;
+  }
+
+  list(projectId: string, options: { limit?: number; freshness?: EvidenceFreshness; status?: string } = {}): EvidenceCardRecord[] {
+    const limit = Math.min(100, Math.max(1, Math.floor(options.limit ?? 20)));
+    const clauses = ['project_id = ?'];
+    const args: unknown[] = [projectId];
+    if (options.freshness) { clauses.push('freshness = ?'); args.push(options.freshness); }
+    if (options.status) { clauses.push('status = ?'); args.push(options.status); }
+    args.push(limit);
+    const rows = this.requireDb().prepare(`
+      SELECT * FROM evidence_cards WHERE ${clauses.join(' AND ')} ORDER BY updated_at DESC, id DESC LIMIT ?
+    `).all(...args);
+    return rows.map(rowToCard);
+  }
+
+  syncObservations(observations: Observation[]): EvidenceCardRecord[] {
+    return observations.map((observation) => this.upsertObservation(observation));
+  }
+
+  markStaleForPaths(projectId: string, paths: string[], reason = 'source file changed'): number {
+    const normalized = new Set(paths.map((value) => value.replace(/\\/g, '/').toLowerCase()));
+    if (normalized.size === 0) return 0;
+    const db = this.requireDb();
+    const rows = db.prepare(`SELECT * FROM evidence_cards WHERE project_id = ? AND freshness != 'stale'`).all(projectId);
+    const update = db.prepare(`
+      UPDATE evidence_cards SET freshness = 'stale', stale_reason = ?, updated_at = ?
+      WHERE id = ?
+    `);
+    let changed = 0;
+    const now = new Date().toISOString();
+    const run = db.transaction(() => {
+      for (const row of rows) {
+        const files = safeJson<string[]>(row.files_json, []);
+        if (!files.some((file) => normalized.has(file.replace(/\\/g, '/').toLowerCase()))) continue;
+        update.run(reason, now, row.id);
+        changed++;
+      }
+    });
+    run();
+    return changed;
+  }
+
+  setVerification(projectId: string, cardId: string, verification: EvidenceVerification): void {
+    this.requireDb().prepare(`
+      UPDATE evidence_cards SET verification = ?, updated_at = ? WHERE project_id = ? AND id = ?
+    `).run(verification, new Date().toISOString(), projectId, cardId);
+  }
+
+  recordEvent(projectId: string, cardId: string, kind: string, detail?: string): EvidenceCardEvent {
+    const event: EvidenceCardEvent = {
+      id: randomUUID(),
+      projectId,
+      cardId,
+      kind,
+      ...(detail ? { detail: detail.slice(0, 2_000) } : {}),
+      createdAt: new Date().toISOString(),
+    };
+    this.requireDb().prepare(`
+      INSERT INTO evidence_card_events (id, project_id, card_id, kind, detail, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(event.id, event.projectId, event.cardId, event.kind, event.detail ?? null, event.createdAt);
+    return event;
+  }
+
+  listEvents(cardId: string, limit = 50): EvidenceCardEvent[] {
+    const rows = this.requireDb().prepare(`
+      SELECT * FROM evidence_card_events WHERE card_id = ? ORDER BY created_at DESC LIMIT ?
+    `).all(cardId, Math.min(200, Math.max(1, Math.floor(limit))));
+    return rows.map((row: any) => ({
+      id: String(row.id), projectId: String(row.project_id), cardId: String(row.card_id),
+      kind: String(row.kind), ...(row.detail ? { detail: String(row.detail) } : {}),
+      createdAt: String(row.created_at),
+    }));
+  }
+}
+
+export function buildEvidenceCardId(projectId: string, candidateKind: EvidenceCandidateKind, candidateId: string): string {
+  return `evidence:${candidateKind}:${projectId}:${candidateId}`;
+}

package/src/store/orama-store.ts

@@ -23,6 +23,7 @@ import {
 import { calculateProjectAffinity, extractProjectKeywords, type AffinityContext, type MemoryContent } from './project-affinity.js';
 import { detectQueryIntent, applyIntentBoost } from '../search/intent-detector.js';
 import { maybeExpandSearchQuery } from '../search/query-expansion.js';
+import { parseRerankTimeoutMs, shouldAttemptHttpRerank, shouldAttemptLlmRerank } from '../rerank/policy.js';
 import { withTimeout, withTimeoutSignal } from '../timeout.js';
 
 let db: AnyOrama | null = null;
@@ -1054,62 +1055,87 @@ export async function searchObservations(options: SearchOptions): Promise<IndexE
     }
   }
 
-  // ── LLM Reranking (heavy-tier only) ────────────────────────────
-  // Only triggered for heavy-tier queries with ambiguous top results.
-  // Non-thorough profiles, fast, and standard tiers skip entirely.
-  // Ambiguity check: top-2 scores within 30% → results are uncertain.
-  const shouldRerank = quality === 'thorough'
-    && tier === 'heavy'
-    && hasQuery
-    && intermediate.length > 2
-    && (() => {
-      const top = intermediate[0]?.score ?? 0;
-      const second = intermediate[1]?.score ?? 0;
-      return top > 0 && second / top > 0.7; // top-2 within 30% = ambiguous
-    })();
-
-  if (shouldRerank) {
-    try {
-      const { rerankResults } = await import('../llm/quality.js');
-      const narrativeMap = new Map<string, string>();
-      for (const hit of results.hits) {
-        const doc = hit.document as unknown as MemorixDocument;
-        narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
+  // HTTP rerank: thorough search with enough candidates.
+  // LLM rerank: original thorough + heavy + close top-2 gate, and only when
+  // HTTP rerank is not configured. A configured HTTP miss keeps original order.
+  const httpGate = shouldAttemptHttpRerank({
+    quality,
+    hasQuery: Boolean(hasQuery),
+    candidateCount: intermediate.length,
+  });
+  const llmGateWithoutHttp = shouldAttemptLlmRerank({
+    quality,
+    tier,
+    hasQuery: Boolean(hasQuery),
+    candidateCount: intermediate.length,
+    topScore: intermediate[0]?.score ?? 0,
+    secondScore: intermediate[1]?.score ?? 0,
+    httpRerankConfigured: false,
+  });
+
+  if (httpGate || llmGateWithoutHttp) {
+    const narrativeMap = new Map<string, string>();
+    for (const hit of results.hits) {
+      const doc = hit.document as unknown as MemorixDocument;
+      narrativeMap.set(makeEntryKey(doc.projectId, doc.observationId), doc.narrative);
+    }
+    const RERANK_TOP_K = 5;
+    const toRerank = intermediate.slice(0, RERANK_TOP_K);
+    const candidates = toRerank.map((e, index) => ({
+      id: `r${index + 1}`,
+      title: e.title,
+      type: e.type,
+      score: e.score,
+      narrative: narrativeMap.get(makeEntryKey(e.projectId, e.id)),
+    }));
+    const RERANK_TIMEOUT_MS = parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+    const candidateMap = new Map(candidates.map((candidate, index) => [candidate.id, toRerank[index]]));
+    const { isNeuralRerankEnabled, neuralRerankCandidates } = await import('../rerank/index.js');
+    const httpConfigured = isNeuralRerankEnabled();
+
+    if (httpConfigured && httpGate) {
+      try {
+        const neural = await withTimeout(
+          neuralRerankCandidates(originalQuery!, candidates),
+          RERANK_TIMEOUT_MS,
+          'neural rerank',
+        );
+        if (neural && neural.length > 0) {
+          const rerankedTop = neural
+            .map((row) => candidateMap.get(row.id))
+            .filter((entry): entry is NonNullable<typeof entry> => entry != null);
+          if (rerankedTop.length > 0) {
+            intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+            lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? 'fulltext') + ' + neural rerank');
+            mark('rerank(usedNeural=true)');
+          }
+        }
+      } catch {
+        console.error('[memorix] neural rerank failed or timed out; keeping original order');
       }
-      // Rerank only top-5 (was 10) to save LLM tokens and latency
-      const RERANK_TOP_K = 5;
-      const toRerank = intermediate.slice(0, RERANK_TOP_K);
-      const candidates = toRerank.map((e, index) => ({
-        id: `r${index + 1}`,
-        title: e.title,
-        type: e.type,
-        score: e.score,
-        narrative: narrativeMap.get(makeEntryKey(e.projectId, e.id)),
-      }));
-      
-      // LLM rerank timeout: configurable via MEMORIX_RERANK_TIMEOUT_MS, default 5s
-      const _parsedRerank = parseInt(process.env.MEMORIX_RERANK_TIMEOUT_MS || '', 10);
-      const RERANK_TIMEOUT_MS = Number.isFinite(_parsedRerank) && _parsedRerank > 0 ? _parsedRerank : 5000;
-      const { reranked, usedLLM } = await withTimeout(
-        rerankResults(originalQuery!, candidates),
-        RERANK_TIMEOUT_MS,
-        'LLM rerank',
-      );
-      mark(`rerank(usedLLM=${usedLLM})`);
-      
-      if (usedLLM) {
-        lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? 'fulltext') + ' + LLM rerank');
-        const candidateMap = new Map(candidates.map((candidate, index) => [candidate.id, toRerank[index]]));
-        const rerankedTop = reranked
-          .map(r => candidateMap.get(r.id))
-          .filter((e): e is NonNullable<typeof e> => e != null);
-        if (rerankedTop.length > 0) {
-          intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+    } else if (!httpConfigured && llmGateWithoutHttp) {
+      try {
+        const { rerankResults } = await import('../llm/quality.js');
+        const { reranked, usedLLM } = await withTimeout(
+          rerankResults(originalQuery!, candidates),
+          RERANK_TIMEOUT_MS,
+          'LLM rerank',
+        );
+        mark(`rerank(usedLLM=${usedLLM})`);
+        if (usedLLM) {
+          lastSearchModeByProject.set(modeKey, (lastSearchModeByProject.get(modeKey) ?? 'fulltext') + ' + LLM rerank');
+          const rerankedTop = reranked
+            .map((row) => candidateMap.get(row.id))
+            .filter((entry): entry is NonNullable<typeof entry> => entry != null);
+          if (rerankedTop.length > 0) {
+            intermediate = [...rerankedTop, ...intermediate.slice(RERANK_TOP_K)];
+          }
         }
+      } catch {
+        console.error('[memorix] LLM rerank failed or timed out, using original order');
       }
-    } catch (error) {
-      // Reranking is best-effort: fall back to original order on timeout or error
-      console.error('[memorix] LLM rerank failed or timed out, using original order');
+    } else {
+      mark(`rerank(skipped,tier=${tier})`);
     }
   } else {
     mark(`rerank(skipped,tier=${tier})`);

package/src/store/sqlite-db.ts

@@ -742,6 +742,88 @@ CREATE TABLE IF NOT EXISTS compaction_checkpoints (
 );
 `;
 
+// 1.8 context-control plane: persisted provenance cards, feedback state, and
+// explicit stateless MCP project handles. These are append/update records in
+// the same SQLite database as observations so a process restart cannot lose
+// the context-control boundary.
+const CREATE_EVIDENCE_CARDS_TABLE = `
+CREATE TABLE IF NOT EXISTS evidence_cards (
+  id                 TEXT PRIMARY KEY,
+  project_id         TEXT NOT NULL,
+  candidate_kind     TEXT NOT NULL,
+  candidate_id       TEXT NOT NULL,
+  title              TEXT NOT NULL,
+  summary            TEXT NOT NULL DEFAULT '',
+  entity_name        TEXT,
+  source_kind        TEXT NOT NULL,
+  source_ref         TEXT NOT NULL,
+  locator            TEXT,
+  captured_hash      TEXT,
+  session_id         TEXT,
+  status             TEXT NOT NULL DEFAULT 'active',
+  verification       TEXT NOT NULL DEFAULT 'unverified',
+  freshness          TEXT NOT NULL DEFAULT 'current',
+  stale_reason       TEXT,
+  files_json         TEXT NOT NULL DEFAULT '[]',
+  related_entities_json TEXT NOT NULL DEFAULT '[]',
+  created_at         TEXT NOT NULL,
+  updated_at         TEXT NOT NULL,
+  UNIQUE(project_id, candidate_kind, candidate_id)
+);
+`;
+
+const CREATE_EVIDENCE_CARD_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS evidence_card_events (
+  id          TEXT PRIMARY KEY,
+  project_id  TEXT NOT NULL,
+  card_id     TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  detail      TEXT,
+  created_at  TEXT NOT NULL,
+  FOREIGN KEY (card_id) REFERENCES evidence_cards(id) ON DELETE CASCADE
+);
+`;
+
+const CREATE_MEMORY_FEEDBACK_STATES_TABLE = `
+CREATE TABLE IF NOT EXISTS memory_feedback_states (
+  project_id       TEXT NOT NULL,
+  candidate_kind   TEXT NOT NULL,
+  candidate_id     TEXT NOT NULL,
+  weight           REAL NOT NULL DEFAULT 1.0,
+  lifecycle_status TEXT NOT NULL DEFAULT 'active',
+  updated_at       TEXT NOT NULL,
+  PRIMARY KEY (project_id, candidate_kind, candidate_id)
+);
+`;
+
+const CREATE_MEMORY_FEEDBACK_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS memory_feedback_events (
+  id              TEXT PRIMARY KEY,
+  project_id      TEXT NOT NULL,
+  candidate_kind  TEXT NOT NULL,
+  candidate_id    TEXT NOT NULL,
+  signal          TEXT NOT NULL,
+  actor           TEXT,
+  note            TEXT,
+  source_ref      TEXT NOT NULL,
+  target_event_id TEXT,
+  delta           REAL NOT NULL DEFAULT 0,
+  observed_at     TEXT NOT NULL
+);
+`;
+
+const CREATE_MCP_BINDINGS_TABLE = `
+CREATE TABLE IF NOT EXISTS mcp_bindings (
+  handle_id    TEXT PRIMARY KEY,
+  project_id   TEXT NOT NULL,
+  project_root TEXT NOT NULL,
+  data_dir     TEXT NOT NULL,
+  created_at   TEXT NOT NULL,
+  last_used_at TEXT NOT NULL,
+  expires_at   TEXT
+);
+`;
+
 const CREATE_INDEXES = `
 CREATE INDEX IF NOT EXISTS idx_observations_projectId ON observations(projectId);
 CREATE INDEX IF NOT EXISTS idx_observations_topicKey ON observations(projectId, topicKey);
@@ -803,6 +885,12 @@ CREATE INDEX IF NOT EXISTS idx_maintenance_targets_updated ON maintenance_target
 CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_project_recent ON compaction_checkpoints(project_id, status, completed_at DESC, pre_captured_at DESC);
 CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_session_pending ON compaction_checkpoints(project_id, session_id, agent, phase, status, pre_captured_at DESC);
 CREATE INDEX IF NOT EXISTS idx_compaction_checkpoints_source ON compaction_checkpoints(project_id, source_key);
+CREATE INDEX IF NOT EXISTS idx_evidence_cards_project ON evidence_cards(project_id, status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_evidence_cards_candidate ON evidence_cards(project_id, candidate_kind, candidate_id);
+CREATE INDEX IF NOT EXISTS idx_evidence_card_events_card ON evidence_card_events(card_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC);
+CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC);
 CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   ON maintenance_jobs(project_id, kind, dedupe_key)
   WHERE status IN ('pending', 'running', 'retry');
@@ -967,6 +1055,22 @@ const SCHEMA_MIGRATIONS: SchemaMigration[] = [
       db.exec('CREATE INDEX IF NOT EXISTS idx_media_jobs_source_asset ON media_jobs(project_id, source_asset_id, status)');
     },
   },
+  {
+    id: '1.8-context-control-plane',
+    apply: (db) => {
+      db.exec(CREATE_EVIDENCE_CARDS_TABLE);
+      db.exec(CREATE_EVIDENCE_CARD_EVENTS_TABLE);
+      db.exec(CREATE_MEMORY_FEEDBACK_STATES_TABLE);
+      db.exec(CREATE_MEMORY_FEEDBACK_EVENTS_TABLE);
+      db.exec(CREATE_MCP_BINDINGS_TABLE);
+      db.exec('CREATE INDEX IF NOT EXISTS idx_evidence_cards_project ON evidence_cards(project_id, status, updated_at DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_evidence_cards_candidate ON evidence_cards(project_id, candidate_kind, candidate_id)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_evidence_card_events_card ON evidence_card_events(card_id, created_at)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_memory_feedback_states_project ON memory_feedback_states(project_id, candidate_kind, updated_at DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_memory_feedback_events_candidate ON memory_feedback_events(project_id, candidate_kind, candidate_id, observed_at DESC)');
+      db.exec('CREATE INDEX IF NOT EXISTS idx_mcp_bindings_project ON mcp_bindings(project_id, last_used_at DESC)');
+    },
+  },
 ];
 
 function applySchemaMigrations(db: any): void {

package/src/types.ts

@@ -280,6 +280,10 @@ export interface IndexEntry {
   documentType?: DocumentType;
   /** Knowledge layer for layer-aware ranking (Phase 3a) */
   knowledgeLayer?: KnowledgeLayer;
+  /** Feedback materialized weight used by the context-control plane. */
+  feedbackWeight?: number;
+  /** Feedback lifecycle projection used to avoid recalling conflicted records. */
+  feedbackStatus?: ObservationStatus;
 }
 
 /** Explicit reference to an observation, optionally scoped to a project. */
@@ -390,6 +394,10 @@ export interface MemorixDocument {
   documentType?: DocumentType;
   /** Knowledge layer for layer-aware ranking (Phase 3a) */
   knowledgeLayer?: KnowledgeLayer;
+  /** Feedback materialized weight used by context-control retrieval. */
+  feedbackWeight?: number;
+  /** Feedback lifecycle projection used by retention and retrieval. */
+  feedbackStatus?: ObservationStatus;
 }
 
 // ============================================================