memorix 1.7.2 → 1.8.0

package/src/multimodal/image-loader.ts

@@ -6,7 +6,11 @@
  */
 
 import { getLLMApiKey, getLLMBaseUrl, getLLMModel } from '../config.js';
-import { isLLMEnabled, getLLMConfig } from '../llm/provider.js';
+import {
+  isLLMEnabled,
+  getLLMConfig,
+  normalizeOpenAICompatibleBaseUrl,
+} from '../llm/provider.js';
 import { sanitizeCredentials } from '../memory/secret-filter.js';
 import {
   decodeBase64ImagePayload,
@@ -55,8 +59,7 @@ async function callVisionLLM(
     throw new Error('No LLM API key configured for image analysis.');
   }
 
-  let baseUrl = getLLMBaseUrl('https://api.openai.com/v1').replace(/\/+$/, '');
-  if (!baseUrl.endsWith('/v1')) baseUrl += '/v1';
+  const baseUrl = normalizeOpenAICompatibleBaseUrl(getLLMBaseUrl('https://api.openai.com/v1'));
   const model = getLLMModel('gpt-4o');
 
   const response = await fetch(`${baseUrl}/chat/completions`, {

package/src/rerank/http-provider.ts

@@ -0,0 +1,125 @@
+/**
+ * Optional HTTP rerank client.
+ *
+ * Posts a Cohere-compatible `{model, query, documents}` body to
+ * `{base_url}/rerank` (or an explicit `/rerank` path). Compatible with
+ * any `/rerank` endpoint that accepts that body. The model id is
+ * whatever the user configured — Memorix does not rewrite it.
+ */
+
+import { resolveRerankTimeoutMs } from './policy.js';
+
+export type NeuralRerankProviderName = 'http';
+
+export interface NeuralRerankRequestConfig {
+  provider: NeuralRerankProviderName;
+  model?: string;
+  baseUrl: string;
+  apiKey?: string;
+  timeoutMs?: number;
+  fetchImpl?: typeof fetch;
+}
+
+export interface RerankedDocument {
+  index: number;
+  score: number;
+}
+
+/**
+ * Join a provider base URL with `/rerank`, leaving an explicit path intact.
+ */
+export function buildRerankUrl(baseUrl: string): string {
+  const trimmed = baseUrl.trim().replace(/\/+$/, '');
+  if (trimmed.endsWith('/rerank')) return trimmed;
+  return `${trimmed}/rerank`;
+}
+
+/**
+ * Accept Cohere-compatible `{results:[{index,relevance_score}]}` and TEI `[{index,score}]`.
+ */
+export function parseRerankResponse(payload: unknown): RerankedDocument[] {
+  const rows = extractRows(payload);
+  if (rows.length === 0) {
+    throw new Error('Neural rerank response contained no ranked results');
+  }
+  return rows.sort((a, b) => b.score - a.score);
+}
+
+function extractRows(payload: unknown): RerankedDocument[] {
+  if (Array.isArray(payload)) {
+    return payload.map(rowFromUnknown).filter((row): row is RerankedDocument => row !== null);
+  }
+  if (payload && typeof payload === 'object' && 'results' in payload) {
+    const results = (payload as { results: unknown }).results;
+    if (Array.isArray(results)) {
+      return results.map(rowFromUnknown).filter((row): row is RerankedDocument => row !== null);
+    }
+  }
+  throw new Error('Neural rerank response was not Cohere or TEI shaped');
+}
+
+function rowFromUnknown(value: unknown): RerankedDocument | null {
+  if (!value || typeof value !== 'object') return null;
+  const row = value as { index?: unknown; relevance_score?: unknown; score?: unknown };
+  if (typeof row.index !== 'number' || !Number.isFinite(row.index)) return null;
+  const score = typeof row.relevance_score === 'number'
+    ? row.relevance_score
+    : typeof row.score === 'number'
+      ? row.score
+      : null;
+  if (score === null || !Number.isFinite(score)) return null;
+  return { index: row.index, score };
+}
+
+function buildRerankBody(query: string, documents: string[], model?: string): Record<string, unknown> {
+  const body: Record<string, unknown> = {
+    query,
+    documents,
+    top_n: documents.length,
+    return_documents: false,
+  };
+  const trimmed = model?.trim();
+  if (trimmed) body.model = trimmed;
+  return body;
+}
+
+/**
+ * POST query + documents to a compatible `/rerank` endpoint and return ranked indexes.
+ */
+export async function rerankViaHttp(
+  query: string,
+  documents: string[],
+  config: NeuralRerankRequestConfig,
+): Promise<RerankedDocument[]> {
+  if (documents.length === 0) return [];
+
+  const url = buildRerankUrl(config.baseUrl);
+  const headers: Record<string, string> = {
+    'content-type': 'application/json',
+  };
+  if (config.apiKey) {
+    headers.authorization = `Bearer ${config.apiKey}`;
+  }
+
+  const controller = new AbortController();
+  const timeoutMs = resolveRerankTimeoutMs(config.timeoutMs);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const fetchImpl = config.fetchImpl ?? fetch;
+    const response = await fetchImpl(url, {
+      method: 'POST',
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify(buildRerankBody(query, documents, config.model)),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Neural rerank HTTP ${response.status} from ${url}`);
+    }
+
+    return parseRerankResponse(await response.json());
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/rerank/index.ts

@@ -0,0 +1,81 @@
+/**
+ * Optional HTTP rerank lane. LLM rerank stays in quality.ts when HTTP is off.
+ */
+
+import { getResolvedRerankLane, type ResolvedLaneOptions } from '../config/resolved-config.js';
+import { rerankViaHttp } from './http-provider.js';
+import { resolveRerankTimeoutMs } from './policy.js';
+
+export {
+  DEFAULT_RERANK_TIMEOUT_MS,
+  MIN_RERANK_CANDIDATES,
+  parseRerankTimeoutMs,
+  resolveRerankTimeoutMs,
+  shouldAttemptHttpRerank,
+  shouldAttemptLlmRerank,
+} from './policy.js';
+
+/** Minimal search hit the HTTP reranker can reorder. */
+export interface NeuralRerankCandidate {
+  id: string;
+  title: string;
+  type: string;
+  score: number;
+  narrative?: string;
+}
+
+const MAX_RERANK = 10;
+
+/**
+ * True when an HTTP `/rerank` endpoint is configured.
+ */
+export function isNeuralRerankEnabled(options: ResolvedLaneOptions = {}): boolean {
+  const lane = getResolvedRerankLane(options);
+  return lane.provider === 'http' && Boolean(lane.baseUrl);
+}
+
+/**
+ * Reorder search candidates via the configured remote reranker.
+ * Returns null when the provider is off or the HTTP call cannot be used.
+ */
+export async function neuralRerankCandidates(
+  query: string,
+  candidates: NeuralRerankCandidate[],
+  options: ResolvedLaneOptions = {},
+): Promise<NeuralRerankCandidate[] | null> {
+  if (!isNeuralRerankEnabled(options) || candidates.length === 0) return null;
+
+  const lane = getResolvedRerankLane(options);
+  if (!lane.canSendRequest || !lane.baseUrl) return null;
+  const toRerank = candidates.slice(0, MAX_RERANK);
+  const rest = candidates.slice(MAX_RERANK);
+  const documents = toRerank.map((candidate) => candidateText(candidate));
+
+  const ranked = await rerankViaHttp(query, documents, {
+    provider: 'http',
+    model: lane.model,
+    baseUrl: lane.baseUrl!,
+    apiKey: lane.apiKey,
+    timeoutMs: resolveRerankTimeoutMs(),
+  });
+
+  const seen = new Set<number>();
+  const reranked: NeuralRerankCandidate[] = [];
+  for (const row of ranked) {
+    const candidate = toRerank[row.index];
+    if (!candidate || seen.has(row.index)) continue;
+    reranked.push(candidate);
+    seen.add(row.index);
+  }
+  for (const [index, candidate] of toRerank.entries()) {
+    if (!seen.has(index)) reranked.push(candidate);
+  }
+  reranked.push(...rest);
+  return reranked;
+}
+
+function candidateText(candidate: NeuralRerankCandidate): string {
+  const narrative = candidate.narrative?.trim();
+  if (narrative) return `${candidate.title} — ${narrative.slice(0, 200)}`;
+  return candidate.title;
+}

package/src/rerank/policy.ts

@@ -0,0 +1,88 @@
+/**
+ * Product rules for optional HTTP rerank and the existing LLM rerank path.
+ *
+ * HTTP rerank is opt-in. When it is configured, thorough search with enough
+ * candidates uses the HTTP lane only — a miss or timeout keeps the original
+ * order instead of falling through to LLM rerank.
+ */
+
+export const DEFAULT_RERANK_TIMEOUT_MS = 30_000;
+export const RERANK_TIMEOUT_MIN_MS = 1_000;
+export const RERANK_TIMEOUT_MAX_MS = 300_000;
+export const MIN_RERANK_CANDIDATES = 3;
+
+/**
+ * Parse and validate MEMORIX_RERANK_TIMEOUT_MS.
+ *
+ * @param raw - Environment value, or undefined when unset
+ * @returns Timeout in milliseconds (default 30000)
+ */
+export function parseRerankTimeoutMs(raw: string | undefined): number {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_RERANK_TIMEOUT_MS;
+
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || Number.isNaN(parsed)) {
+    console.warn(
+      `[memorix] MEMORIX_RERANK_TIMEOUT_MS="${raw}" is invalid (must be a positive integer between ${RERANK_TIMEOUT_MIN_MS}-${RERANK_TIMEOUT_MAX_MS}ms). Using default ${DEFAULT_RERANK_TIMEOUT_MS}ms.`,
+    );
+    return DEFAULT_RERANK_TIMEOUT_MS;
+  }
+
+  if (parsed < RERANK_TIMEOUT_MIN_MS) return RERANK_TIMEOUT_MIN_MS;
+  if (parsed > RERANK_TIMEOUT_MAX_MS) return RERANK_TIMEOUT_MAX_MS;
+  return parsed;
+}
+
+/**
+ * Resolve the rerank timeout from an explicit override or the environment.
+ *
+ * @param explicitTimeoutMs - Caller-supplied timeout, when present
+ * @returns Timeout in milliseconds
+ */
+export function resolveRerankTimeoutMs(explicitTimeoutMs?: number): number {
+  if (typeof explicitTimeoutMs === 'number' && Number.isFinite(explicitTimeoutMs) && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  return parseRerankTimeoutMs(process.env.MEMORIX_RERANK_TIMEOUT_MS);
+}
+
+/**
+ * True when thorough search has enough candidates for HTTP rerank.
+ *
+ * @param input - Retrieval quality, query presence, and hit count
+ * @returns Whether the HTTP rerank lane should run
+ */
+export function shouldAttemptHttpRerank(input: {
+  quality?: string;
+  hasQuery: boolean;
+  candidateCount: number;
+}): boolean {
+  return input.quality === 'thorough'
+    && input.hasQuery
+    && input.candidateCount >= MIN_RERANK_CANDIDATES;
+}
+
+/**
+ * True when the existing LLM rerank path should run.
+ *
+ * LLM rerank stays on the original thorough + heavy + close top-2 gate.
+ * It never runs when an HTTP rerank lane is configured.
+ *
+ * @param input - Search gate inputs plus whether HTTP rerank is configured
+ * @returns Whether LLM rerank should run
+ */
+export function shouldAttemptLlmRerank(input: {
+  quality?: string;
+  tier: string;
+  hasQuery: boolean;
+  candidateCount: number;
+  topScore: number;
+  secondScore: number;
+  httpRerankConfigured: boolean;
+}): boolean {
+  if (input.httpRerankConfigured) return false;
+  if (input.quality !== 'thorough' || input.tier !== 'heavy' || !input.hasQuery) return false;
+  if (input.candidateCount < MIN_RERANK_CANDIDATES) return false;
+  return input.topScore > 0 && input.secondScore / input.topScore > 0.7;
+}

package/src/server/mcp-binding-store.ts

@@ -0,0 +1,79 @@
+import { randomUUID } from 'node:crypto';
+import { getDatabase } from '../store/sqlite-db.js';
+
+export interface McpProjectBinding {
+  handleId: string;
+  projectId: string;
+  projectRoot: string;
+  dataDir: string;
+  createdAt: string;
+  lastUsedAt: string;
+  expiresAt?: string;
+}
+
+function rowToBinding(row: any): McpProjectBinding {
+  return {
+    handleId: String(row.handle_id),
+    projectId: String(row.project_id),
+    projectRoot: String(row.project_root),
+    dataDir: String(row.data_dir),
+    createdAt: String(row.created_at),
+    lastUsedAt: String(row.last_used_at),
+    ...(row.expires_at ? { expiresAt: String(row.expires_at) } : {}),
+  };
+}
+
+/** Durable project binding handles for stateless MCP requests. */
+export class McpBindingStore {
+  private db: any = null;
+
+  async init(dataDir: string): Promise<void> {
+    this.db = getDatabase(dataDir);
+  }
+
+  private requireDb(): any {
+    if (!this.db) throw new Error('McpBindingStore is not initialized.');
+    return this.db;
+  }
+
+  create(input: { projectId: string; projectRoot: string; dataDir: string; ttlMs?: number }): McpProjectBinding {
+    const now = new Date();
+    const binding: McpProjectBinding = {
+      handleId: `mxh_${randomUUID().replace(/-/g, '')}`,
+      projectId: input.projectId,
+      projectRoot: input.projectRoot,
+      dataDir: input.dataDir,
+      createdAt: now.toISOString(),
+      lastUsedAt: now.toISOString(),
+      ...(input.ttlMs && input.ttlMs > 0 ? { expiresAt: new Date(now.getTime() + input.ttlMs).toISOString() } : {}),
+    };
+    this.requireDb().prepare(`
+      INSERT INTO mcp_bindings (handle_id, project_id, project_root, data_dir, created_at, last_used_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(binding.handleId, binding.projectId, binding.projectRoot, binding.dataDir, binding.createdAt, binding.lastUsedAt, binding.expiresAt ?? null);
+    return binding;
+  }
+
+  get(handleId: string): McpProjectBinding | undefined {
+    const row = this.requireDb().prepare(`SELECT * FROM mcp_bindings WHERE handle_id = ?`).get(handleId);
+    if (!row) return undefined;
+    const binding = rowToBinding(row);
+    if (binding.expiresAt && Date.parse(binding.expiresAt) <= Date.now()) {
+      this.delete(handleId);
+      return undefined;
+    }
+    return binding;
+  }
+
+  touch(handleId: string): McpProjectBinding | undefined {
+    const binding = this.get(handleId);
+    if (!binding) return undefined;
+    const lastUsedAt = new Date().toISOString();
+    this.requireDb().prepare(`UPDATE mcp_bindings SET last_used_at = ? WHERE handle_id = ?`).run(lastUsedAt, handleId);
+    return { ...binding, lastUsedAt };
+  }
+
+  delete(handleId: string): void {
+    this.requireDb().prepare(`DELETE FROM mcp_bindings WHERE handle_id = ?`).run(handleId);
+  }
+}

package/src/server/mcp-diagnostics.ts

@@ -0,0 +1,40 @@
+/** MCP compatibility diagnostics shared by HTTP and CLI-facing checks. */
+
+export const CURRENT_MCP_PROTOCOL_VERSION = '2026-07-28';
+export const LEGACY_MCP_PROTOCOL_VERSION = '2024-11-05';
+export const MCP_SERVER_NAME = 'io.github.AVIDS2/memorix';
+
+export interface McpDiagnostics {
+  serverName: string;
+  protocol: {
+    current: string;
+    legacy: string;
+    statelessRequests: 'supported' | 'compatibility-only' | 'unsupported';
+    statefulStreamableHttp: 'supported';
+  };
+  capabilities: {
+    tasks: 'supported' | 'unsupported';
+    polling: 'supported' | 'unsupported';
+    listCache: 'supported';
+    explicitProjectHandle: 'supported';
+  };
+}
+
+/** The pinned SDK is stateful; do not present a fake durable task loop. */
+export function getMcpDiagnostics(): McpDiagnostics {
+  return {
+    serverName: MCP_SERVER_NAME,
+    protocol: {
+      current: CURRENT_MCP_PROTOCOL_VERSION,
+      legacy: LEGACY_MCP_PROTOCOL_VERSION,
+    statelessRequests: 'supported',
+      statefulStreamableHttp: 'supported',
+    },
+    capabilities: {
+      tasks: 'unsupported',
+      polling: 'unsupported',
+      listCache: 'supported',
+      explicitProjectHandle: 'supported',
+    },
+  };
+}

package/src/server/tool-profile.ts

@@ -40,6 +40,10 @@ export const TOOL_PROFILES: Record<string, ReadonlyArray<ToolProfile>> = Object.
   // multimodal support to one additional schema rather than enabling lite.
   memorix_session_start:      ['micro', 'lite', 'team', 'full'],
   memorix_media:              ['micro', 'lite', 'team', 'full'],
+  // Evidence and feedback are deliberate operator/context-control surfaces;
+  // keep the default micro profile at its nine-tool token budget.
+  memorix_evidence:           ['lite', 'team', 'full'],
+  memorix_feedback:           ['lite', 'team', 'full'],
 
   // ── lite: extended solo memory surface ────────────────────────────
   memorix_graph_context:      ['lite', 'team', 'full'],

package/src/server.ts

@@ -36,6 +36,8 @@ import { detectProject } from './project/detector.js';
 import { homeProjectRootError, isHomeDirectory, writeLastProjectRoot } from './project/launch-root.js';
 import { registerAlias, initAliasRegistry, resolveAliases, autoMergeByBaseName } from './project/aliases.js';
 import { getProjectDataDir } from './store/persistence.js';
+import { EvidenceCardStore } from './store/evidence-store.js';
+import { MemoryFeedbackStore } from './memory/feedback.js';
 import type { ObservationType, RuleSource, AgentTarget, MCPServerEntry, ObservationReader } from './types.js';
 import { RulesSyncer } from './rules/syncer.js';
 import { WorkspaceSyncEngine } from './workspace/engine.js';
@@ -4445,7 +4447,7 @@ export async function createMemorixServer(
           process.platform === 'win32' ? `start "" "${url}"` :
             process.platform === 'darwin' ? `open "${url}"` :
               `xdg-open "${url}"`;
-        execCmd(openCmd, () => { });
+        execCmd(openCmd, { windowsHide: true }, () => { });
 
         return {
           content: [{
@@ -4474,6 +4476,124 @@ export async function createMemorixServer(
   // Orchestration Coordination Tools (Multi-Agent) - SQLite-backed
   // ================================================================
 
+  server.registerTool(
+    'memorix_evidence',
+    {
+      title: 'Evidence Cards',
+      description:
+        'Inspect the bounded, project-scoped provenance cards behind Memorix context. ' +
+        'Use list for a compact index, get/events for one source, sync to repair the projection, ' +
+        'and stale when known source files changed. Cards expose sourceRef, locator, capturedHash, and freshness.',
+      inputSchema: {
+        action: z.enum(['list', 'get', 'sync', 'stale', 'events']).describe('Evidence operation'),
+        candidateKind: z.enum(['observation', 'code', 'git', 'test', 'document', 'workflow', 'graph']).optional().default('observation'),
+        candidateId: z.string().optional().describe('Candidate id, usually an observation id'),
+        query: z.string().optional().describe('Optional title/source query for list'),
+        paths: z.array(z.string()).max(200).optional().describe('Changed source paths for stale'),
+        reason: z.string().max(500).optional().describe('Why evidence became stale'),
+        limit: z.number().int().positive().max(100).optional().default(20),
+      },
+    },
+    async ({ action, candidateKind, candidateId, query, paths, reason, limit }) => {
+      const unresolved = requireResolvedProject('inspect evidence cards for the current project');
+      if (unresolved) return unresolved;
+      const cards = new EvidenceCardStore();
+      await cards.init(projectDir);
+      if (action === 'sync') {
+        const observations = await getObservationStore().loadByProject(project.id);
+        const synced = cards.syncObservations(observations);
+        return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, synced: synced.length, cards: synced.slice(0, limit ?? 20) }, null, 2) }] };
+      }
+      if (action === 'stale') {
+        const changed = cards.markStaleForPaths(project.id, paths ?? [], reason ?? 'source file changed');
+        return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, staleMarked: changed, paths: paths ?? [] }, null, 2) }] };
+      }
+      if (action === 'get') {
+        if (!candidateId?.trim()) return { content: [{ type: 'text' as const, text: 'candidateId is required for evidence get.' }], isError: true };
+        const card = cards.get(project.id, candidateKind ?? 'observation', candidateId.trim());
+        if (!card) return { content: [{ type: 'text' as const, text: 'Evidence card not found.' }], isError: true };
+        return { content: [{ type: 'text' as const, text: JSON.stringify({ card, events: cards.listEvents(card.id), projectId: project.id }, null, 2) }] };
+      }
+      if (action === 'events') {
+        if (!candidateId?.trim()) return { content: [{ type: 'text' as const, text: 'candidateId is required for evidence events.' }], isError: true };
+        const card = cards.get(project.id, candidateKind ?? 'observation', candidateId.trim());
+        if (!card) return { content: [{ type: 'text' as const, text: 'Evidence card not found.' }], isError: true };
+        return { content: [{ type: 'text' as const, text: JSON.stringify(cards.listEvents(card.id, limit), null, 2) }] };
+      }
+      const needle = query?.trim().toLowerCase();
+      const listed = cards.list(project.id, { limit: Math.max(limit ?? 20, 100) })
+        .filter((card) => !needle || [card.title, card.summary, card.sourceRef, card.locator ?? ''].join(' ').toLowerCase().includes(needle))
+        .slice(0, limit ?? 20);
+      return { content: [{ type: 'text' as const, text: JSON.stringify({ projectId: project.id, cards: listed }, null, 2) }] };
+    },
+  );
+
+  server.registerTool(
+    'memorix_feedback',
+    {
+      title: 'Memory Feedback',
+      description:
+        'Record or inspect auditable memory outcomes. Positive verification/use strengthens recall; correction, conflict, source change, or weaken lowers it. ' +
+        'Use revoke with targetEventId to undo one prior signal without deleting audit history.',
+      inputSchema: {
+        action: z.enum(['record', 'show', 'audit']).describe('Feedback operation'),
+        candidateKind: z.enum(['observation', 'claim', 'durable-memory', 'workflow']).optional().default('observation'),
+        candidateId: z.string().describe('Memory or knowledge candidate id'),
+        signal: z.enum(['user-correction', 'verification-success', 'verification-failure', 'code-change', 'used', 'not-used', 'code-conflict', 'strengthen', 'weaken', 'revoke']).optional(),
+        sourceRef: z.string().max(500).optional().describe('Source of this feedback, such as test:run-42 or user:chat'),
+        actor: z.string().max(200).optional(),
+        note: z.string().max(2_000).optional(),
+        targetEventId: z.string().optional().describe('Existing event id when action=record and signal=revoke'),
+        limit: z.number().int().positive().max(200).optional().default(100),
+      },
+    },
+    async ({ action, candidateKind, candidateId, signal, sourceRef, actor, note, targetEventId, limit }) => {
+      const unresolved = requireResolvedProject('record memory feedback for the current project');
+      if (unresolved) return unresolved;
+      const feedback = new MemoryFeedbackStore();
+      await feedback.init(projectDir);
+      const kind = candidateKind ?? 'observation';
+      if (action === 'show') {
+        return { content: [{ type: 'text' as const, text: JSON.stringify(feedback.getState(project.id, kind, candidateId), null, 2) }] };
+      }
+      if (action === 'audit') {
+        return { content: [{ type: 'text' as const, text: JSON.stringify(feedback.audit(project.id, kind, candidateId, limit), null, 2) }] };
+      }
+      if (!signal || !sourceRef?.trim()) {
+        return { content: [{ type: 'text' as const, text: 'record requires signal and sourceRef.' }], isError: true };
+      }
+      try {
+        const result = feedback.record({
+          projectId: project.id,
+          candidateKind: kind,
+          candidateId,
+          signal,
+          sourceRef,
+          ...(actor || currentAgentId ? { actor: actor ?? currentAgentId } : {}),
+          ...(note ? { note } : {}),
+          ...(targetEventId ? { targetEventId } : {}),
+        });
+        if (kind === 'observation') {
+          const cards = new EvidenceCardStore();
+          await cards.init(projectDir);
+          const card = cards.get(project.id, 'observation', candidateId);
+          if (card) {
+            const verification = signal === 'verification-success' || signal === 'strengthen' ? 'verified' : signal === 'user-correction' || signal === 'code-conflict' || signal === 'weaken' ? 'conflicted' : card.verification;
+            cards.recordEvent(project.id, card.id, `feedback:${signal}`, note);
+            if (verification !== card.verification) {
+              // Keep the card projection in sync with the feedback state while
+              // retaining the append-only feedback audit as the source of truth.
+              cards.setVerification(project.id, card.id, verification);
+            }
+          }
+        }
+        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+      } catch (error) {
+        return { content: [{ type: 'text' as const, text: error instanceof Error ? error.message : String(error) }], isError: true };
+      }
+    },
+  );
+
   // Use shared TeamStore (from HTTP server) or create new one (stdio mode).
   // All team state is canonical in SQLite — no JSON persistence, no sync/flush.
   if (teamFeaturesEnabled) {