memorix 1.7.2 → 1.8.0

package/src/dashboard/static/index.html

@@ -92,6 +92,15 @@
         </svg>
         <span class="nav-label">Observations</span>
       </button>
+      <button class="nav-btn" data-page="evidence" title="Evidence" aria-label="Evidence">
+        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+          <polyline points="14 2 14 8 20 8"/>
+          <line x1="8" y1="13" x2="16" y2="13"/>
+          <line x1="8" y1="17" x2="14" y2="17"/>
+        </svg>
+        <span class="nav-label">Evidence</span>
+      </button>
     </div>
     <div class="sidebar-section-label" data-section="health">HEALTH</div>
     <div class="sidebar-nav">
@@ -175,6 +184,7 @@
     <div id="page-knowledge" class="page"></div>
     <div id="page-graph" class="page"></div>
     <div id="page-observations" class="page"></div>
+    <div id="page-evidence" class="page"></div>
     <div id="page-retention" class="page"></div>
     <div id="page-config" class="page"></div>
     <div id="page-identity" class="page"></div>

package/src/dashboard/static/style.css

@@ -64,6 +64,92 @@
   --transition-emphasized: 500ms cubic-bezier(0.2, 0, 0, 1);
 }
 
+/* Evidence Console: provenance is readable at a glance and stays bounded on
+   narrow screens; long paths and generated titles never widen the viewport. */
+.evidence-console {
+  display: grid;
+  gap: 12px;
+  min-width: 0;
+}
+
+.evidence-card {
+  border: 1px solid var(--border-color, rgba(148, 163, 184, .18));
+  border-radius: 8px;
+  background: var(--surface, rgba(15, 23, 42, .45));
+  padding: 16px;
+  min-width: 0;
+}
+
+.evidence-card-header {
+  display: flex;
+  gap: 12px;
+  align-items: flex-start;
+  justify-content: space-between;
+  min-width: 0;
+}
+
+.evidence-card-heading {
+  min-width: 0;
+}
+
+.evidence-card-heading h2 {
+  margin: 4px 0 0;
+  font-size: 16px;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+}
+
+.evidence-card-kind {
+  color: var(--text-muted);
+  font-size: 11px;
+  text-transform: uppercase;
+}
+
+.evidence-card-state {
+  display: flex;
+  gap: 6px;
+  flex: 0 0 auto;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.evidence-state {
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  padding: 3px 7px;
+  font-size: 11px;
+  white-space: nowrap;
+}
+
+.evidence-current, .evidence-verified { color: #4ade80; }
+.evidence-stale, .evidence-conflicted { color: #fb923c; }
+.evidence-unverified { color: var(--text-muted); }
+
+.evidence-card-summary {
+  margin: 12px 0;
+  color: var(--text-secondary, var(--text-muted));
+  line-height: 1.55;
+  overflow-wrap: anywhere;
+}
+
+.evidence-card-meta {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 10px;
+  margin: 0;
+}
+
+.evidence-card-meta div { min-width: 0; }
+.evidence-card-meta dt { color: var(--text-muted); font-size: 11px; margin-bottom: 3px; }
+.evidence-card-meta dd { margin: 0; font-size: 12px; overflow-wrap: anywhere; }
+.evidence-card-warning { margin-top: 10px; color: #fb923c; font-size: 12px; overflow-wrap: anywhere; }
+
+@media (max-width: 600px) {
+  .evidence-card-header { display: block; }
+  .evidence-card-state { justify-content: flex-start; margin-top: 10px; }
+  .evidence-card-meta { grid-template-columns: 1fr; }
+}
+
 /* Light Theme - MD3 */
 [data-theme="light"] {
   --bg-base: #FFFBFE;

package/src/hooks/installers/index.ts

@@ -1259,7 +1259,7 @@ function getAgentRulesContent(agent?: AgentName, scope: 'project' | 'global' = '
     '',
     `Default first step for non-trivial coding work: call \x60memorix_project_context\x60 with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). When the task is continuing prior work, the same brief also includes a bounded prior-work projection. Treat its "Start here" files as the first ${contextNoun} files to inspect.`,
     '',
-    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select \x60memorix_project_context\x60 first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: \x60memorix resume "<task>" --brief-json\x60. For a new task, use \x60memorix context "<task>" --brief-json\x60 instead. The absence of \x60.memorix\x60 or visible memory files never proves project memory is empty. Use \x60--json\x60 only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
+    'If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select \x60memorix_project_context\x60 first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user\'s real task before inspecting files, Git history, progress notes, or guessing: \x60memorix resume "<task>" --fallback --brief-json\x60. For a new task, use \x60memorix context "<task>" --fallback --brief-json\x60 instead. The absence of \x60.memorix\x60 or visible memory files never proves project memory is empty. Use \x60--json\x60 only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax.',
     '',
     'After a successful \x60memorix_project_context\x60 result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use \x60memorix_context_pack\x60, \x60memorix_search\x60, or \x60memorix_detail\x60 only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in \x60purpose\x60 when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.',
     'If the user asks for read-only work or says not to modify files, do not call \x60memorix_store\x60 just to record an assessment. Store only when the user explicitly asks to preserve it.',

package/src/hooks/official-skills.ts

@@ -31,8 +31,8 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '| Situation | Prefer | CLI fallback |',
       '|---|---|---|',
-      '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --brief-json` |',
-      '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --brief-json` |',
+      '| Starting a coding task and needing the best task-lensed project map | `memorix_project_context` with the user\'s task | `memorix context "<task>" --fallback --brief-json` |',
+      '| Continuing prior project work | `memorix_project_context` with the user\'s task | `memorix resume "<task>" --fallback --brief-json` |',
       '| Need structured refs/freshness for code-bound memories | `memorix_context_pack` | `memorix codegraph context-pack --task "<topic>"` |',
       '| Explicit memory graph question | `memorix_graph_context` | `memorix memory graph-context --query "<topic>"` |',
       '| Specific past decision, bug, file, or change | `memorix_search` | `memorix memory search --query "<topic>"` |',
@@ -45,7 +45,7 @@ export const OFFICIAL_MEMORIX_SKILLS: OfficialMemorixSkill[] = [
       '',
       '- Default first step for non-trivial coding work: call `memorix_project_context` before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Pass the user\'s actual task so Memorix can choose a bugfix, feature, release, onboarding, refactor, docs, test, or general brief. Start by reading its suggested files.',
       '- In Claude Code headless/print-mode, an initial MCP `pending` status is not a failure by itself. Prefer MCP first: use the client\'s tool discovery/dynamic loading to find `memorix_project_context` when it is not in the first visible tool list.',
-      '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --brief-json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
+      '- Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run `memorix resume "<task>" --fallback --brief-json` exactly once before inspecting files, Git history, progress notes, or guessing. The absence of `.memorix` or visible memory files never proves project memory is empty. For a new task, use `memorix context "<task>" --fallback --brief-json` instead. Use `--json` only when a diagnostic needs the detailed legacy payload. If that one command fails, report it and proceed normally; do not probe help, enumerate commands, or chain broad searches.',
       '- After a successful `memorix_project_context`, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use Context Pack, search, or detail only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.',
       '- If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.',
       '- Use `memorix_search` for a specific decision, bug, file, or prior change that the project context did not answer. Fetch detail only for a result you still need after the brief.',

package/src/hooks/rules/memorix-agent-rules.md

@@ -7,7 +7,7 @@ You have access to Memorix memory tools. Follow these rules to maintain persiste
 At the beginning of non-trivial coding work, use Memorix Memory Autopilot before local progress notes or broad file exploration. A session bind is not required for every conversation.
 
 1. Default first step for non-trivial coding work: call `memorix_project_context` with the user's actual task before progress files, dev-log reads, ad-hoc file reads, or git archaeology. Memorix will choose a task-lensed brief (bugfix, feature, release, onboarding, refactor, docs, test, or general). Treat its "Start here" files as the first code or docs to inspect.
-2. If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user's real task before inspecting files, Git history, progress notes, or guessing: use `memorix resume "<task>" --brief-json`. For a new task, use `memorix context "<task>" --brief-json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax. Use `--json` only when a diagnostic needs the detailed legacy payload.
+2. If the MCP tool is not visible yet but the client supports tool discovery or dynamic loading, search/select `memorix_project_context` first. Continuation fallback is mandatory: when the user asks to continue, resume, take over, or explain prior work and MCP cannot be called in this turn, run exactly one CLI brief with the user's real task before inspecting files, Git history, progress notes, or guessing: use `memorix resume "<task>" --fallback --brief-json`. For a new task, use `memorix context "<task>" --fallback --brief-json` instead. The absence of `.memorix` or visible memory files never proves project memory is empty. If that one command fails, report it and proceed normally. Do not probe help, enumerate commands, chain broad searches, wait indefinitely on MCP startup, or hand-write tool-call syntax. Use `--json` only when a diagnostic needs the detailed legacy payload.
 3. After a successful `memorix_project_context` result, the brief is the default retrieval boundary. Do not call more Memorix retrieval tools after a complete brief. Use `memorix_context_pack`, `memorix_search`, or `memorix_detail` only when the brief lacks a specific reference, freshness field, or fact needed for the task, or when the user explicitly asks for deeper history. In MCP, name that missing fact in `purpose` when intentionally expanding beyond the brief. Do not retrieve the same decision twice just to confirm an already-complete brief.
    If the user asks for read-only work or says not to modify files, do not call `memorix_store` just to record an assessment. Store only when the user explicitly asks to preserve it.
 4. Use `memorix_context_pack` when you need structured refs and freshness for code-bound memories.

package/src/llm/provider.ts

@@ -31,6 +31,36 @@ const LLM_TIMEOUT_MIN_MS = 1_000;
 const LLM_TIMEOUT_MAX_MS = 300_000;
 const MAX_LLM_RESPONSE_BYTES = 2 * 1024 * 1024;
 
+const OPENAI_API_VERSION_SEGMENT = /^v\d+(?:[a-z][a-z0-9-]*)?$/i;
+
+/**
+ * Normalize an OpenAI-compatible API root without rewriting an explicit
+ * provider version such as `/api/v3` or `/v1beta`.
+ *
+ * Bare hosts keep the historical convenience of receiving `/v1`. Once a
+ * caller supplies a versioned path, that path is authoritative.
+ */
+export function normalizeOpenAICompatibleBaseUrl(baseUrl: string): string {
+  const base = baseUrl.trim().replace(/\/+$/, '');
+  if (!base) return base;
+
+  let pathname = '';
+  try {
+    pathname = new URL(base).pathname.replace(/\/+$/, '');
+  } catch {
+    pathname = base.split(/[?#]/, 1)[0].replace(/\/+$/, '');
+  }
+
+  const lastSegment = pathname.split('/').filter(Boolean).at(-1);
+  if (lastSegment && OPENAI_API_VERSION_SEGMENT.test(lastSegment)) {
+    return base;
+  }
+
+  const queryOrHash = base.match(/[?#].*$/)?.[0] ?? '';
+  const pathWithoutQuery = base.slice(0, base.length - queryOrHash.length).replace(/\/+$/, '');
+  return `${pathWithoutQuery}/v1${queryOrHash}`;
+}
+
 /**
  * Parse and validate MEMORIX_LLM_TIMEOUT_MS environment variable.
  * - Must be a valid integer in the range 1000–300000ms.
@@ -259,9 +289,7 @@ async function callOpenAICompatible(
   signal?: AbortSignal,
 ): Promise<LLMResponse> {
   const config = currentConfig!;
-  // Auto-fix: append /v1 if baseUrl doesn't end with it (common user mistake)
-  let base = config.baseUrl!.replace(/\/+$/, '');
-  if (!base.endsWith('/v1')) base += '/v1';
+  const base = normalizeOpenAICompatibleBaseUrl(config.baseUrl!);
   const url = `${base}/chat/completions`;
 
   const fetchSignal = signal
@@ -387,8 +415,7 @@ async function callOpenAIWithTools(
   signal?: AbortSignal,
 ): Promise<LLMToolResponse> {
   const config = currentConfig!;
-  let base = config.baseUrl!.replace(/\/+$/, '');
-  if (!base.endsWith('/v1')) base += '/v1';
+  const base = normalizeOpenAICompatibleBaseUrl(config.baseUrl!);
   const url = `${base}/chat/completions`;
 
   // Convert ChatMessage[] to OpenAI format
@@ -603,8 +630,7 @@ async function* callOpenAIWithToolsStream(
   tools: ToolDefinition[],
 ): AsyncGenerator<LLMStreamEvent, void, undefined> {
   const config = currentConfig!;
-  let base = config.baseUrl!.replace(/\/+$/, '');
-  if (!base.endsWith('/v1')) base += '/v1';
+  const base = normalizeOpenAICompatibleBaseUrl(config.baseUrl!);
   const url = `${base}/chat/completions`;
 
   const openaiMessages: Array<Record<string, unknown>> = messages.map((msg) => {

package/src/memory/feedback-model.ts

@@ -0,0 +1,4 @@
+/** Pure feedback math shared by retrieval/retention without opening SQLite. */
+export function feedbackWeightMultiplier(weight: number): number {
+  return Math.max(0.35, Math.min(1.4, 0.35 + Math.max(0, Math.min(2, weight)) * 0.525));
+}

package/src/memory/feedback.ts

@@ -0,0 +1,220 @@
+import { randomUUID } from 'node:crypto';
+import type { ObservationStatus } from '../types.js';
+import { getDatabase } from '../store/sqlite-db.js';
+export { feedbackWeightMultiplier } from './feedback-model.js';
+
+export type MemoryFeedbackSignal =
+  | 'user-correction'
+  | 'verification-success'
+  | 'verification-failure'
+  | 'code-change'
+  | 'used'
+  | 'not-used'
+  | 'code-conflict'
+  | 'strengthen'
+  | 'weaken'
+  | 'revoke';
+
+export interface MemoryFeedbackEvent {
+  signal: MemoryFeedbackSignal;
+  at: string;
+  actor?: string;
+  note?: string;
+  sourceRef?: string;
+  targetEventId?: string;
+}
+
+export interface FeedbackState {
+  weight: number;
+  status: ObservationStatus;
+  audit: MemoryFeedbackEvent[];
+}
+
+export type FeedbackCandidateKind = 'observation' | 'claim' | 'durable-memory' | 'workflow';
+
+export interface PersistedFeedbackEvent extends MemoryFeedbackEvent {
+  id: string;
+  projectId: string;
+  candidateKind: FeedbackCandidateKind;
+  candidateId: string;
+  delta: number;
+}
+
+export const FEEDBACK_DELTAS: Record<Exclude<MemoryFeedbackSignal, 'revoke'>, number> = {
+  'user-correction': -0.35,
+  'verification-success': 0.25,
+  'verification-failure': -0.25,
+  'code-change': -0.15,
+  used: 0.1,
+  'not-used': -0.05,
+  'code-conflict': -0.4,
+  strengthen: 0.2,
+  weaken: -0.2,
+};
+
+/** Deterministic feedback reducer used by MCP/CLI adapters and tests. */
+export function applyMemoryFeedback(
+  current: FeedbackState,
+  event: MemoryFeedbackEvent,
+): FeedbackState {
+  const delta = event.signal === 'revoke' ? 0 : FEEDBACK_DELTAS[event.signal];
+  const weight = Math.max(0, Math.min(2, current.weight + delta));
+  const status: ObservationStatus = (event.signal === 'code-conflict' || event.signal === 'user-correction' || event.signal === 'weaken') && weight < 0.5
+    ? 'archived'
+    : current.status;
+  return { weight, status, audit: [...current.audit, { ...event }] };
+}
+
+function rowToEvent(row: any): PersistedFeedbackEvent {
+  return {
+    id: String(row.id),
+    projectId: String(row.project_id),
+    candidateKind: row.candidate_kind,
+    candidateId: String(row.candidate_id),
+    signal: row.signal,
+    ...(row.observed_at ? { at: String(row.observed_at) } : { at: new Date().toISOString() }),
+    ...(row.actor ? { actor: String(row.actor) } : {}),
+    ...(row.note ? { note: String(row.note) } : {}),
+    ...(row.source_ref ? { sourceRef: String(row.source_ref) } : {}),
+    ...(row.target_event_id ? { targetEventId: String(row.target_event_id) } : {}),
+    delta: Number(row.delta ?? 0),
+  };
+}
+
+function candidateKey(projectId: string, candidateKind: FeedbackCandidateKind, candidateId: string): string {
+  return `${projectId}\u0000${candidateKind}\u0000${candidateId}`;
+}
+
+/**
+ * Durable feedback loop. Events are append-only; the state row is a materialized
+ * projection rebuilt from non-revoked events, so undo never destroys audit truth.
+ */
+export class MemoryFeedbackStore {
+  private db: any = null;
+
+  async init(dataDir: string): Promise<void> {
+    this.db = getDatabase(dataDir);
+  }
+
+  private requireDb(): any {
+    if (!this.db) throw new Error('MemoryFeedbackStore is not initialized.');
+    return this.db;
+  }
+
+  private loadEvents(projectId: string, candidateKind: FeedbackCandidateKind, candidateId: string): PersistedFeedbackEvent[] {
+    return this.requireDb().prepare(`
+      SELECT * FROM memory_feedback_events
+      WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+      ORDER BY observed_at ASC, rowid ASC
+    `).all(projectId, candidateKind, candidateId).map(rowToEvent);
+  }
+
+  private rebuild(projectId: string, candidateKind: FeedbackCandidateKind, candidateId: string): FeedbackState {
+    const events = this.loadEvents(projectId, candidateKind, candidateId);
+    const revoked = new Set(events.filter((event) => event.signal === 'revoke' && event.targetEventId).map((event) => event.targetEventId!));
+    let state: FeedbackState = { weight: 1, status: 'active', audit: [] };
+    for (const event of events) {
+      if (event.signal === 'revoke' || revoked.has(event.id)) {
+        state.audit.push(event);
+        continue;
+      }
+      state = applyMemoryFeedback(state, event);
+    }
+    this.requireDb().prepare(`
+      INSERT INTO memory_feedback_states (project_id, candidate_kind, candidate_id, weight, lifecycle_status, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id, candidate_kind, candidate_id) DO UPDATE SET
+        weight = excluded.weight, lifecycle_status = excluded.lifecycle_status, updated_at = excluded.updated_at
+    `).run(projectId, candidateKind, candidateId, state.weight, state.status, new Date().toISOString());
+    return state;
+  }
+
+  getState(projectId: string, candidateKind: FeedbackCandidateKind, candidateId: string): FeedbackState {
+    const row = this.requireDb().prepare(`
+      SELECT weight, lifecycle_status FROM memory_feedback_states
+      WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+    `).get(projectId, candidateKind, candidateId);
+    if (!row) return { weight: 1, status: 'active', audit: [] };
+    return {
+      weight: Number(row.weight ?? 1),
+      status: row.lifecycle_status ?? 'active',
+      audit: this.loadEvents(projectId, candidateKind, candidateId),
+    };
+  }
+
+  listStates(projectId: string, candidateKind: FeedbackCandidateKind = 'observation'): Array<{ candidateId: string; weight: number; status: ObservationStatus; updatedAt: string }> {
+    return this.requireDb().prepare(`
+      SELECT candidate_id, weight, lifecycle_status, updated_at
+      FROM memory_feedback_states WHERE project_id = ? AND candidate_kind = ?
+      ORDER BY updated_at DESC
+    `).all(projectId, candidateKind).map((row: any) => ({
+      candidateId: String(row.candidate_id),
+      weight: Number(row.weight),
+      status: row.lifecycle_status,
+      updatedAt: String(row.updated_at),
+    }));
+  }
+
+  weights(projectId: string, candidateKind: FeedbackCandidateKind = 'observation'): Map<string, FeedbackState> {
+    const states = new Map<string, FeedbackState>();
+    for (const row of this.listStates(projectId, candidateKind)) {
+      states.set(row.candidateId, this.getState(projectId, candidateKind, row.candidateId));
+    }
+    return states;
+  }
+
+  record(input: {
+    projectId: string;
+    candidateKind: FeedbackCandidateKind;
+    candidateId: string;
+    signal: MemoryFeedbackSignal;
+    sourceRef: string;
+    actor?: string;
+    note?: string;
+    targetEventId?: string;
+    at?: string;
+  }): { event: PersistedFeedbackEvent; state: FeedbackState } {
+    if (input.signal === 'revoke' && !input.targetEventId) {
+      throw new Error('A revoke feedback event requires targetEventId.');
+    }
+    if (input.signal === 'revoke') {
+      const target = this.requireDb().prepare(`
+        SELECT 1 FROM memory_feedback_events
+        WHERE id = ? AND project_id = ? AND candidate_kind = ? AND candidate_id = ?
+      `).get(input.targetEventId, input.projectId, input.candidateKind, input.candidateId);
+      if (!target) throw new Error('The feedback event to revoke was not found in the same candidate scope.');
+    }
+    const event: PersistedFeedbackEvent = {
+      id: randomUUID(),
+      projectId: input.projectId,
+      candidateKind: input.candidateKind,
+      candidateId: input.candidateId,
+      signal: input.signal,
+      sourceRef: input.sourceRef,
+      ...(input.actor ? { actor: input.actor } : {}),
+      ...(input.note ? { note: input.note.slice(0, 2_000) } : {}),
+      ...(input.targetEventId ? { targetEventId: input.targetEventId } : {}),
+      at: input.at ?? new Date().toISOString(),
+      delta: input.signal === 'revoke' ? 0 : FEEDBACK_DELTAS[input.signal],
+    };
+    this.requireDb().prepare(`
+      INSERT INTO memory_feedback_events (
+        id, project_id, candidate_kind, candidate_id, signal, actor, note,
+        source_ref, target_event_id, delta, observed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      event.id, event.projectId, event.candidateKind, event.candidateId, event.signal,
+      event.actor ?? null, event.note ?? null, event.sourceRef, event.targetEventId ?? null,
+      event.delta, event.at,
+    );
+    return { event, state: this.rebuild(input.projectId, input.candidateKind, input.candidateId) };
+  }
+
+  audit(projectId: string, candidateKind: FeedbackCandidateKind, candidateId: string, limit = 100): PersistedFeedbackEvent[] {
+    return this.requireDb().prepare(`
+      SELECT * FROM memory_feedback_events
+      WHERE project_id = ? AND candidate_kind = ? AND candidate_id = ?
+      ORDER BY observed_at DESC, rowid DESC LIMIT ?
+    `).all(projectId, candidateKind, candidateId, Math.min(200, Math.max(1, Math.floor(limit)))).map(rowToEvent);
+  }
+}

package/src/memory/observations.ts

@@ -44,6 +44,7 @@ import { getEmbeddingProvider, isEmbeddingExplicitlyDisabled, validateEmbeddingI
 import { sanitizeCredentials } from './secret-filter.js';
 import { enqueueClaimDerivation, enqueueObservationQualification } from '../runtime/lifecycle.js';
 import { canManageObservation, resolveObservationVisibility } from './visibility.js';
+import { EvidenceCardStore } from '../store/evidence-store.js';
 
 /** In-memory observation list (loaded from persistence on init) */
 let observations: Observation[] = [];
@@ -186,6 +187,20 @@ async function bindObservationCodeRefsBestEffort(observation: Observation): Prom
   }
 }
 
+async function persistEvidenceCard(observation: Observation): Promise<void> {
+  if (!projectDir) return;
+  try {
+    const evidence = new EvidenceCardStore();
+    await evidence.init(projectDir);
+    evidence.upsertObservation(observation);
+  } catch (error) {
+    // Evidence is a derived control-plane projection. A failed projection must
+    // never roll back the canonical observation, but it must be visible for a
+    // later repair/sync pass.
+    console.error(`[memorix] Evidence card projection failed for obs-${observation.id}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 function queueClaimDerivation(observation: Observation): void {
   const dataDir = projectDir;
   const isExplicit = observation.sourceDetail === 'explicit';
@@ -692,6 +707,7 @@ export async function storeObservation(input: {
   if (!persistedCallbackInvoked) await input.onPersisted?.(observation);
 
   await bindObservationCodeRefsBestEffort(observation);
+  await persistEvidenceCard(observation);
   queueObservationQualification(observation);
   if (resolveObservationVisibility(observation) === 'project') {
     queueClaimDerivation(observation);
@@ -828,6 +844,7 @@ async function upsertObservation(
   }
 
   await bindObservationCodeRefsBestEffort(existing);
+  await persistEvidenceCard(existing);
   queueObservationQualification(existing);
   if (resolveObservationVisibility(existing) === 'project') {
     queueClaimDerivation(existing);
@@ -1002,6 +1019,8 @@ export async function resolveObservations(
     });
   }
 
+  for (const observation of changed) await persistEvidenceCard(observation);
+
   return { resolved, notFound };
 }
 

package/src/memory/retention.ts

@@ -15,9 +15,10 @@
  * retention period but are no longer permanently immune — they decay normally.
  */
 
-import type { MemorixDocument, Observation, ObservationReader } from '../types.js';
+import type { MemorixDocument, Observation, ObservationReader, ObservationStatus } from '../types.js';
 import { getObservationStore } from '../store/obs-store.js';
 import { canManageObservation } from './visibility.js';
+import { feedbackWeightMultiplier } from './feedback-model.js';
 
 // ── Importance → Retention Period mapping ────────────────────────────
 
@@ -113,6 +114,7 @@ export function getEffectiveRetentionDays(doc: MemorixDocument): number {
 export function isImmune(doc: MemorixDocument): boolean {
   // Probe observations are operational heartbeats -- never immune, regardless of valueCategory or access.
   if (doc.type === 'probe') return false;
+  if (doc.feedbackStatus === 'archived') return false;
 
   // A candidate has not earned durable status. Never let an automatic core
   // classification turn unqualified capture into permanently retained memory.
@@ -164,6 +166,7 @@ export interface RelevanceScore {
   accessBoost: number;
   ageDays: number;
   isImmune: boolean;
+  feedbackMultiplier: number;
 }
 
 /**
@@ -202,7 +205,12 @@ export function calculateRelevance(
   const accessCount = doc.accessCount ?? 0;
   const accessBoost = Math.min(2.0, 1 + 0.1 * accessCount);
 
-  let totalScore = base * decayFactor * accessBoost;
+  // Legacy memories have no feedback row. Preserve their historical score
+  // exactly; only an explicit feedback projection changes relevance.
+  const feedbackMultiplier = doc.feedbackWeight === undefined
+    ? 1
+    : feedbackWeightMultiplier(doc.feedbackWeight);
+  let totalScore = base * decayFactor * accessBoost * feedbackMultiplier;
 
   // Immune observations get minimum 0.5 relevance
   const immune = isImmune(doc);
@@ -218,6 +226,7 @@ export function calculateRelevance(
     accessBoost,
     ageDays,
     isImmune: immune,
+    feedbackMultiplier,
   };
 }
 
@@ -248,6 +257,7 @@ export type RetentionZone = 'active' | 'stale' | 'archive-candidate';
  */
 export function getRetentionZone(doc: MemorixDocument, referenceTime?: Date): RetentionZone {
   const now = referenceTime ?? new Date();
+  if (doc.feedbackStatus === 'archived') return 'archive-candidate';
   const importance = getImportanceLevel(doc);
   const retention = getEffectiveRetentionDays(doc);
 
@@ -344,6 +354,7 @@ export interface RetentionProjection extends RetentionExplanation {
 export interface ObservationRetentionProjectionOptions {
   referenceTime?: Date;
   accessMap?: ObservationAccessMap;
+  feedback?: { weight: number; status: ObservationStatus };
 }
 
 export interface RetentionProjectionSummary {
@@ -415,6 +426,7 @@ export function explainRetention(
 export function toRetentionDocument(
   obs: Observation,
   accessMap?: ObservationAccessMap,
+  feedback?: { weight: number; status: ObservationStatus },
 ): MemorixDocument {
   const access = accessMap?.get(obs.id);
   return {
@@ -438,6 +450,7 @@ export function toRetentionDocument(
     valueCategory: obs.valueCategory ?? '',
     admissionState: obs.admissionState ?? '',
     admissionReason: obs.admissionReason ?? '',
+    ...(feedback ? { feedbackWeight: feedback.weight, feedbackStatus: feedback.status } : {}),
   };
 }
 
@@ -446,7 +459,7 @@ export function projectObservationRetention(
   observation: Observation,
   options: ObservationRetentionProjectionOptions = {},
 ): RetentionProjection {
-  const document = toRetentionDocument(observation, options.accessMap);
+  const document = toRetentionDocument(observation, options.accessMap, options.feedback);
   const relevance = calculateRelevance(document, options.referenceTime);
   const explanation = explainRetention(document, options.referenceTime);
 
@@ -497,12 +510,25 @@ export interface ArchiveExpiredBatchResult {
   nextCursor?: number;
 }
 
+async function loadFeedbackStore(dataDir: string): Promise<import('./feedback.js').MemoryFeedbackStore | undefined> {
+  try {
+    const { MemoryFeedbackStore } = await import('./feedback.js');
+    const store = new MemoryFeedbackStore();
+    await store.init(dataDir);
+    return store;
+  } catch {
+    // Pre-1.8 databases or degraded SQLite installations keep the legacy
+    // retention behavior until the feedback projection is available.
+    return undefined;
+  }
+}
+
 /**
  * Archive one bounded page of a project's active memories. The caller owns the
  * cursor, which makes the operation safe to run from a durable maintenance job.
  */
 export async function archiveExpiredBatch(
-  _projectDir: string,
+  projectDir: string,
   options: ArchiveExpiredBatchOptions,
 ): Promise<ArchiveExpiredBatchResult> {
   const store = getObservationStore();
@@ -513,6 +539,7 @@ export async function archiveExpiredBatch(
     afterId,
     limit: limit + 1,
   });
+  const feedback = await loadFeedbackStore(projectDir);
   const hasMore = page.length > limit;
   const scanned = hasMore ? page.slice(0, limit) : page;
   const candidateIds = scanned
@@ -520,6 +547,7 @@ export async function archiveExpiredBatch(
     .filter((observation) => projectObservationRetention(observation, {
       accessMap: options.accessMap,
       referenceTime: options.referenceTime,
+      ...(feedback ? { feedback: feedback.getState(options.projectId, 'observation', String(observation.id)) } : {}),
     }).zone === 'archive-candidate')
     .map((observation) => observation.id);
 
@@ -580,6 +608,7 @@ export async function archiveExpired(
     return { archived, remaining };
   }
 
+  const feedback = await loadFeedbackStore(projectDir);
   return await store.atomic(async (tx) => {
     const allObs = await tx.loadAll();
 
@@ -591,7 +620,11 @@ export async function archiveExpired(
     const archivedIds: number[] = [];
 
     for (const obs of activeObs) {
-      const retention = projectObservationRetention(obs, { accessMap, referenceTime });
+      const retention = projectObservationRetention(obs, {
+        accessMap,
+        referenceTime,
+        ...(feedback ? { feedback: feedback.getState(obs.projectId, 'observation', String(obs.id)) } : {}),
+      });
       if (retention.zone === 'archive-candidate') {
         archivedIds.push(obs.id);
       }