r2mcp 0.2.0

package/dist/tools/lint.js

@@ -0,0 +1,13 @@
+/**
+ * MCP tool handler for `lint()`.
+ *
+ * Lint is SQL-only — no LLM calls (C.R5) — so unlike `compile()` it runs
+ * directly in the MCP server process against the existing pgvector pool.
+ * No subprocess delegation needed.
+ */
+import { getPool } from '../db.js';
+import { runLint } from '../lint/run.js';
+export async function lint(input) {
+    const pool = getPool();
+    return runLint(input, pool);
+}

package/dist/tools/meditate.d.ts

@@ -0,0 +1,25 @@
+import type { LintFinding } from '../lint/types.js';
+export interface MeditateInput {
+    mode: 'full';
+    dry_run: boolean;
+    /**
+     * SPEC-044 C.R4 — opt-in lint integration. Default false for backward
+     * compatibility with existing direct callers (Slack bot, programmatic).
+     * When true, lint runs and findings are surfaced in `lint_findings`.
+     */
+    include_lint?: boolean;
+}
+export interface MeditateResult {
+    archived: number;
+    deduplicated: number;
+    cross_referenced: number;
+    clustered: number;
+    gaps_found: number;
+    total_changes: number;
+    /**
+     * Populated only when input.include_lint is true. Absent (undefined) for
+     * default callers — preserves the byte-identical default response shape.
+     */
+    lint_findings?: LintFinding[];
+}
+export declare function meditate(input: MeditateInput, projectRoot?: string): Promise<MeditateResult>;

package/dist/tools/meditate.js

@@ -0,0 +1,128 @@
+import { getPool } from '../db.js';
+import { triggerGraphRebuild } from '../graph-rebuild.js';
+import { runLint } from '../lint/run.js';
+export async function meditate(input, projectRoot) {
+    const pool = getPool();
+    // 1. Archive stale entries
+    const archived = await archiveStale(pool, input.dry_run);
+    // 2. Deduplicate (sanity check — fingerprints should be unique)
+    const deduplicated = await countDuplicateFingerprints(pool);
+    // 3. Cross-reference (find entries with 2+ shared topics)
+    const cross_referenced = await countCrossReferencePairs(pool);
+    // 4. Cluster by theme (count distinct topic clusters)
+    const clustered = await countTopicClusters(pool);
+    // 5. Surface gaps (topics in preferences but not project-context)
+    const gaps_found = await surfaceGaps(pool);
+    // Trigger graph rebuild after consolidation (only if not dry_run)
+    if (!input.dry_run && projectRoot) {
+        triggerGraphRebuild(projectRoot);
+    }
+    const result = {
+        archived,
+        deduplicated,
+        cross_referenced,
+        clustered,
+        gaps_found,
+        total_changes: archived + deduplicated,
+    };
+    if (input.include_lint) {
+        const lintResult = await runLint({}, pool);
+        result.lint_findings = lintResult.findings;
+    }
+    return result;
+}
+/**
+ * Archive stale entries:
+ * - conversations tier: older than 90 days
+ * - project-context tier: older than 180 days
+ * - preferences tier: never auto-archived
+ */
+async function archiveStale(pool, dryRun) {
+    // Count how many would be archived
+    const countResult = await pool.query(`
+    SELECT COUNT(*)::int AS count FROM memories
+    WHERE type != 'archived' AND (
+      (tier = 'conversations' AND created_at < NOW() - INTERVAL '90 days')
+      OR
+      (tier = 'project-context' AND created_at < NOW() - INTERVAL '180 days')
+    )
+  `);
+    const count = countResult.rows[0].count;
+    if (!dryRun && count > 0) {
+        await pool.query(`
+      UPDATE memories SET type = 'archived', updated_at = NOW()
+      WHERE type != 'archived' AND (
+        (tier = 'conversations' AND created_at < NOW() - INTERVAL '90 days')
+        OR
+        (tier = 'project-context' AND created_at < NOW() - INTERVAL '180 days')
+      )
+    `);
+    }
+    return count;
+}
+/**
+ * Count entries with duplicate fingerprints (sanity check).
+ * Shouldn't happen due to UNIQUE constraint, but counts them if they exist.
+ */
+async function countDuplicateFingerprints(pool) {
+    const result = await pool.query(`
+    SELECT COALESCE(SUM(dup_count - 1), 0)::int AS duplicates
+    FROM (
+      SELECT fingerprint, COUNT(*)::int AS dup_count
+      FROM memories
+      GROUP BY fingerprint
+      HAVING COUNT(*) > 1
+    ) sub
+  `);
+    return result.rows[0].duplicates;
+}
+/**
+ * Find entries with overlapping topics (2+ shared topics) that could be cross-referenced.
+ * Returns count of such pairs. Informational only for Phase 2.
+ */
+async function countCrossReferencePairs(pool) {
+    const result = await pool.query(`
+    SELECT COUNT(*)::int AS pair_count
+    FROM (
+      SELECT m1.id AS id1, m2.id AS id2
+      FROM memories m1
+      JOIN memories m2 ON m1.id < m2.id
+      WHERE (
+        SELECT COUNT(*)
+        FROM unnest(m1.topics) t1
+        WHERE t1 = ANY(m2.topics)
+      ) >= 2
+    ) sub
+  `);
+    return result.rows[0].pair_count;
+}
+/**
+ * Group entries by most common topic. Returns count of distinct topic clusters.
+ * Informational only for Phase 2.
+ */
+async function countTopicClusters(pool) {
+    const result = await pool.query(`
+    SELECT COUNT(DISTINCT topic)::int AS cluster_count
+    FROM memories, unnest(topics) AS topic
+  `);
+    return result.rows[0].cluster_count;
+}
+/**
+ * Surface gaps: topics that appear in preferences but not in project-context.
+ * These might indicate missing architectural documentation for decided preferences.
+ */
+async function surfaceGaps(pool) {
+    const result = await pool.query(`
+    SELECT COUNT(*)::int AS gap_count
+    FROM (
+      SELECT DISTINCT topic
+      FROM memories, unnest(topics) AS topic
+      WHERE tier = 'preferences'
+      EXCEPT
+      SELECT DISTINCT topic
+      FROM memories, unnest(topics) AS topic
+      WHERE tier = 'project-context'
+    ) sub
+  `);
+    return result.rows[0].gap_count;
+}

package/dist/tools/recall.d.ts

@@ -0,0 +1,66 @@
+import type { RecallSignal } from '../edges/types.js';
+import type { EntityType } from '../entities/types.js';
+export type Tier = 'preferences' | 'project-context' | 'conversations';
+export type MatchType = 'semantic' | 'fulltext' | 'hybrid';
+export type SearchMode = 'semantic' | 'fulltext_only';
+export interface EntityLink {
+    type: EntityType;
+    canonical_name: string;
+    confidence: number;
+}
+export interface RecallResult {
+    id: string;
+    tier: string;
+    content: string;
+    metadata: {
+        type: string;
+        topics: string[];
+        persons: string[];
+        created: string;
+        updated: string;
+    };
+    score: number;
+    match_type: MatchType;
+    /** SPEC-046: present only when recall() is called with an `entity` filter. */
+    entity_links?: EntityLink[];
+}
+export interface RecallResponse {
+    results: RecallResult[];
+    query: string;
+    total_results: number;
+    search_mode: SearchMode;
+    tiers_searched: string[];
+    tokens_used?: number;
+    early_stopped?: boolean;
+    /** Always present in v1.1+; optional for backward-compat with pre-edges client types. */
+    signals?: RecallSignal[];
+    /** SPEC-046: present only when recall() is called with an `entity` filter. */
+    entity_resolved?: boolean;
+    /** SPEC-046: present only when `entity_resolved` is true. */
+    entity_id?: string;
+    /** Present only when the search ran degraded, e.g. embeddings unavailable (claw-8cjf.2). */
+    warnings?: string[];
+}
+export interface RecallInput {
+    /** Free-text query. Optional only when `entity` is provided (SPEC-046 entity-only fast path). */
+    query?: string;
+    top_k?: number;
+    tier?: Tier;
+    max_tokens?: number;
+    min_score?: number;
+    diversity?: number;
+    progressive?: boolean;
+    confidence_threshold?: number;
+    /** SPEC-046: optional entity filter. Resolves via canonical_name or alias. */
+    entity?: string;
+}
+interface InternalResult extends RecallResult {
+    rawScore: number;
+    rawEmbedding?: number[];
+}
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function jaccardSimilarity(a: string, b: string): number;
+export declare function estimateTokens(text: string): number;
+export declare function applyMMR(candidates: InternalResult[], lambda: number, topK: number): InternalResult[];
+export declare function recall(input: RecallInput): Promise<RecallResponse>;
+export {};

package/dist/tools/recall.js

@@ -0,0 +1,409 @@
+import { getPool } from '../db.js';
+import { embedText, embeddingWarning } from '../embeddings.js';
+import pgvector from 'pgvector';
+import { getSignalsForMemoryIds } from '../edges/signals.js';
+import { findEntityByInput, getEntityLinksForMemories } from '../entities/db.js';
+const { toSql } = pgvector;
+const TIER_WEIGHTS = {
+    preferences: 1.3,
+    'project-context': 1.0,
+    conversations: 0.8,
+};
+const TIER_ORDER = ['preferences', 'project-context', 'conversations'];
+// Default to no floor to maintain backward compatibility with v1 callers.
+// Set min_score explicitly (e.g. 0.3 for hybrid, 0.1 for fulltext) to filter low-quality results.
+const DEFAULT_MIN_SCORE_HYBRID = 0.0;
+const DEFAULT_MIN_SCORE_FULLTEXT = 0.0;
+const DEFAULT_DIVERSITY = 0.7;
+const DEFAULT_CONFIDENCE_THRESHOLD = 0.82;
+// --- Utility functions ---
+export function cosineSimilarity(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+export function jaccardSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+    let intersection = 0;
+    for (const w of wordsA) {
+        if (wordsB.has(w))
+            intersection++;
+    }
+    const union = wordsA.size + wordsB.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+export function estimateTokens(text) {
+    const wordCount = text.split(/\s+/).filter(Boolean).length;
+    return Math.ceil(wordCount * 1.3);
+}
+function parseEmbedding(raw) {
+    if (!raw || typeof raw !== 'string')
+        return undefined;
+    try {
+        return raw.slice(1, -1).split(',').map(Number);
+    }
+    catch {
+        return undefined;
+    }
+}
+function docSimilarity(a, b) {
+    if (a.rawEmbedding && b.rawEmbedding) {
+        return cosineSimilarity(a.rawEmbedding, b.rawEmbedding);
+    }
+    return jaccardSimilarity(a.content, b.content);
+}
+function stripInternal(r) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { rawScore, rawEmbedding, ...rest } = r;
+    return rest;
+}
+function applyTierWeight(score, tier) {
+    return score * (TIER_WEIGHTS[tier] ?? 1.0);
+}
+// MMR: Maximum Marginal Relevance — balances relevance vs. diversity to eliminate redundant results.
+// lambda=1.0 = pure relevance (same as top-K), lambda=0.0 = pure diversity.
+export function applyMMR(candidates, lambda, topK) {
+    if (candidates.length === 0)
+        return [];
+    if (candidates.length <= 1)
+        return candidates.slice(0, topK);
+    const sorted = [...candidates].sort((a, b) => b.score - a.score);
+    const selected = [sorted[0]];
+    const remaining = sorted.slice(1);
+    while (selected.length < topK && remaining.length > 0) {
+        let bestIdx = -1;
+        let bestMMR = -Infinity;
+        for (let i = 0; i < remaining.length; i++) {
+            const relevance = remaining[i].score;
+            let maxSim = 0;
+            for (const sel of selected) {
+                const sim = docSimilarity(remaining[i], sel);
+                if (sim > maxSim)
+                    maxSim = sim;
+            }
+            const mmrScore = lambda * relevance - (1 - lambda) * maxSim;
+            if (mmrScore > bestMMR) {
+                bestMMR = mmrScore;
+                bestIdx = i;
+            }
+        }
+        selected.push(remaining.splice(bestIdx, 1)[0]);
+    }
+    return selected;
+}
+// --- DB search functions ---
+async function hybridSearchTier(pool, query, queryEmbedding, topK, tier, fetchEmbeddings = false, entityId) {
+    const embeddingSql = toSql(queryEmbedding);
+    const params = [embeddingSql, query];
+    let tierFilter = '';
+    if (tier) {
+        tierFilter = ` AND tier = $${params.length + 1}`;
+        params.push(tier);
+    }
+    // SPEC-046: narrow the candidate pool to memories linked to the resolved
+    // entity. Cheapest expression is a subquery in the WHERE clause — applied
+    // inside the CTE so ranking only ever runs over the entity-scoped pool.
+    let entityFilter = '';
+    if (entityId) {
+        entityFilter = ` AND id IN (SELECT memory_id FROM memory_entities WHERE entity_id = $${params.length + 1})`;
+        params.push(entityId);
+    }
+    const embeddingCol = fetchEmbeddings ? 'embedding::text AS raw_embedding,' : '';
+    const sql = `
+    WITH scored AS (
+      SELECT
+        id, content, tier, type, topics, people, created_at, updated_at,
+        ${embeddingCol}
+        (1 - (embedding <=> $1::vector)) AS semantic_score,
+        ts_rank(tsv, plainto_tsquery('english', $2)) AS fulltext_score,
+        CASE
+          WHEN embedding IS NOT NULL AND ts_rank(tsv, plainto_tsquery('english', $2)) > 0 THEN 'hybrid'
+          WHEN embedding IS NOT NULL THEN 'semantic'
+          ELSE 'fulltext'
+        END AS match_type
+      FROM memories
+      WHERE type NOT IN ('rejection', 'archived')
+      AND (
+        embedding IS NOT NULL
+        OR tsv @@ plainto_tsquery('english', $2)
+      )${tierFilter}${entityFilter}
+    )
+    SELECT *,
+      CASE match_type
+        WHEN 'hybrid' THEN (0.7 * semantic_score + 0.3 * fulltext_score)
+        WHEN 'semantic' THEN semantic_score
+        ELSE fulltext_score
+      END AS combined_score
+    FROM scored
+    ORDER BY combined_score DESC
+    LIMIT ${topK}
+  `;
+    const { rows } = await pool.query(sql, params);
+    return rows
+        .map((row) => {
+        const rawScore = row.combined_score;
+        return {
+            id: row.id,
+            tier: row.tier,
+            content: row.content,
+            metadata: {
+                type: row.type,
+                topics: row.topics || [],
+                persons: row.people || [],
+                created: row.created_at.toISOString(),
+                updated: row.updated_at.toISOString(),
+            },
+            score: applyTierWeight(rawScore, row.tier),
+            match_type: row.match_type,
+            rawScore,
+            rawEmbedding: fetchEmbeddings ? parseEmbedding(row.raw_embedding) : undefined,
+        };
+    })
+        .sort((a, b) => b.score - a.score);
+}
+async function fulltextSearchTier(pool, query, topK, tier, entityId) {
+    const params = [query];
+    let tierFilter = '';
+    if (tier) {
+        tierFilter = ` AND tier = $${params.length + 1}`;
+        params.push(tier);
+    }
+    let entityFilter = '';
+    if (entityId) {
+        entityFilter = ` AND id IN (SELECT memory_id FROM memory_entities WHERE entity_id = $${params.length + 1})`;
+        params.push(entityId);
+    }
+    const sql = `
+    SELECT
+      id, content, tier, type, topics, people, created_at, updated_at,
+      ts_rank(tsv, plainto_tsquery('english', $1)) AS fulltext_score
+    FROM memories
+    WHERE type NOT IN ('rejection', 'archived')
+    AND tsv @@ plainto_tsquery('english', $1)${tierFilter}${entityFilter}
+    ORDER BY fulltext_score DESC
+    LIMIT ${topK}
+  `;
+    const { rows } = await pool.query(sql, params);
+    return rows
+        .map((row) => {
+        const rawScore = row.fulltext_score;
+        return {
+            id: row.id,
+            tier: row.tier,
+            content: row.content,
+            metadata: {
+                type: row.type,
+                topics: row.topics || [],
+                persons: row.people || [],
+                created: row.created_at.toISOString(),
+                updated: row.updated_at.toISOString(),
+            },
+            score: applyTierWeight(rawScore, row.tier),
+            match_type: 'fulltext',
+            rawScore,
+        };
+    })
+        .sort((a, b) => b.score - a.score);
+}
+// Progressive tier search: searches tier by tier, top-down, stopping early when a high-confidence
+// result is found. This avoids searching lower-signal tiers when the top tier already answers the query.
+async function progressiveHybridSearch(pool, query, queryEmbedding, topK, confidenceThreshold, entityId) {
+    const tiersSearched = [];
+    const allResults = [];
+    let earlyStopped = false;
+    for (const tier of TIER_ORDER) {
+        tiersSearched.push(tier);
+        const tierResults = await hybridSearchTier(pool, query, queryEmbedding, topK, tier, true, entityId);
+        // Merge without duplicates
+        for (const r of tierResults) {
+            if (!allResults.some((existing) => existing.id === r.id)) {
+                allResults.push(r);
+            }
+        }
+        // Early stop: if best raw score exceeds confidence threshold, no need to dig deeper
+        if (allResults.length > 0) {
+            const topRawScore = Math.max(...allResults.map((r) => r.rawScore));
+            if (topRawScore >= confidenceThreshold) {
+                earlyStopped = true;
+                break;
+            }
+        }
+    }
+    return { results: allResults, tiersSearched, earlyStopped };
+}
+// --- Entity-only fast path ---
+// When an entity filter is set but the caller provides no query (or an empty
+// one), we skip semantic/fulltext ranking entirely — there's nothing to rank
+// against. Return all memories linked to the entity, ordered by recency, so
+// the entity_links attachment downstream still has a stable result set.
+async function entityOnlySearch(pool, entityId, topK, tier) {
+    const params = [entityId];
+    let tierFilter = '';
+    if (tier) {
+        tierFilter = ` AND m.tier = $${params.length + 1}`;
+        params.push(tier);
+    }
+    const sql = `
+    SELECT m.id, m.content, m.tier, m.type, m.topics, m.people, m.created_at, m.updated_at
+    FROM memories m
+    WHERE m.type NOT IN ('rejection', 'archived')
+    AND m.id IN (SELECT memory_id FROM memory_entities WHERE entity_id = $1)${tierFilter}
+    ORDER BY m.updated_at DESC
+    LIMIT ${topK}
+  `;
+    const { rows } = await pool.query(sql, params);
+    return rows.map((row) => ({
+        id: row.id,
+        tier: row.tier,
+        content: row.content,
+        metadata: {
+            type: row.type,
+            topics: row.topics || [],
+            persons: row.people || [],
+            created: row.created_at.toISOString(),
+            updated: row.updated_at.toISOString(),
+        },
+        score: 1.0,
+        match_type: 'fulltext',
+        rawScore: 1.0,
+    }));
+}
+// --- Main recall function ---
+export async function recall(input) {
+    const { 
+    // SPEC-046: query is optional when `entity` is set (entity-only recall).
+    // Normalize undefined → '' so downstream code keeps the same string contract.
+    query = '', top_k = 10, tier, max_tokens, min_score, diversity = DEFAULT_DIVERSITY, progressive = true, confidence_threshold = DEFAULT_CONFIDENCE_THRESHOLD, entity, } = input;
+    const pool = getPool();
+    // SPEC-046: resolve entity BEFORE retrieval. The resolution is the cheapest
+    // possible signal — a single indexed lookup on entities.normalized_name.
+    // When it fails, short-circuit with an empty result + entity_resolved=false
+    // (no error, per AC3b).
+    const entityFilterActive = entity !== undefined && entity !== '';
+    let resolvedEntity = null;
+    if (entityFilterActive) {
+        resolvedEntity = await findEntityByInput(pool, entity);
+        if (!resolvedEntity) {
+            return {
+                results: [],
+                query: query ?? '',
+                total_results: 0,
+                search_mode: 'semantic',
+                tiers_searched: [],
+                entity_resolved: false,
+            };
+        }
+    }
+    // Skip embedText entirely on the entity-only fast path: an empty query
+    // would either burn an embedding round-trip for nothing or break ranking.
+    const skipRanking = entityFilterActive && (!query || query === '');
+    const queryEmbedding = skipRanking ? null : await embedText(query);
+    // Only warn when an embedding was actually attempted (claw-8cjf.2).
+    const degradedWarning = skipRanking ? null : embeddingWarning(queryEmbedding);
+    let hasDbEmbeddings = false;
+    if (queryEmbedding) {
+        const embCheck = await pool.query('SELECT EXISTS(SELECT 1 FROM memories WHERE embedding IS NOT NULL) AS has_embeddings');
+        hasDbEmbeddings = embCheck.rows[0].has_embeddings;
+    }
+    const useHybrid = queryEmbedding !== null && hasDbEmbeddings;
+    const searchMode = useHybrid ? 'semantic' : 'fulltext_only';
+    const effectiveMinScore = min_score ?? (useHybrid ? DEFAULT_MIN_SCORE_HYBRID : DEFAULT_MIN_SCORE_FULLTEXT);
+    // Fetch a larger candidate pool so MMR has room to diversify
+    const candidateLimit = Math.max(top_k * 3, 30);
+    let rawResults;
+    let tiersSearched;
+    let earlyStopped = false;
+    const entityId = resolvedEntity?.id;
+    if (skipRanking && entityId) {
+        // SPEC-046: entity-only fast path. No query → no ranking signal; just
+        // return entity-linked memories ordered by recency.
+        rawResults = await entityOnlySearch(pool, entityId, candidateLimit, tier);
+        tiersSearched = tier ? [tier] : TIER_ORDER;
+    }
+    else if (useHybrid && progressive && !tier) {
+        // Phase 3: progressive tier search — most valuable in semantic mode
+        const r = await progressiveHybridSearch(pool, query, queryEmbedding, candidateLimit, confidence_threshold, entityId);
+        rawResults = r.results;
+        tiersSearched = r.tiersSearched;
+        earlyStopped = r.earlyStopped;
+    }
+    else if (useHybrid) {
+        // Flat hybrid search: tier explicitly set or progressive disabled
+        rawResults = await hybridSearchTier(pool, query, queryEmbedding, candidateLimit, tier, true, entityId);
+        tiersSearched = tier ? [tier] : TIER_ORDER;
+    }
+    else {
+        // Fulltext-only fallback: no embeddings available
+        rawResults = await fulltextSearchTier(pool, query, candidateLimit, tier, entityId);
+        tiersSearched = tier ? [tier] : TIER_ORDER;
+    }
+    // Phase 1a: relevance floor — drop results below minimum quality threshold
+    const floorPassed = rawResults.filter((r) => r.rawScore >= effectiveMinScore);
+    // Phase 1b: MMR diversity — re-rank to eliminate near-duplicate results
+    const diverse = applyMMR(floorPassed, diversity, max_tokens ? candidateLimit : top_k);
+    // Phase 2: context budgeting — fit within token budget, or apply top_k
+    let finalResults;
+    let tokensUsed;
+    if (max_tokens !== undefined) {
+        finalResults = [];
+        let tokenCount = 0;
+        for (const r of diverse) {
+            if (finalResults.length >= top_k)
+                break; // top_k is always an upper bound
+            const tokens = estimateTokens(r.content);
+            if (tokenCount + tokens > max_tokens)
+                break;
+            finalResults.push(r);
+            tokenCount += tokens;
+        }
+        tokensUsed = finalResults.reduce((sum, r) => sum + estimateTokens(r.content), 0);
+    }
+    else {
+        finalResults = diverse.slice(0, top_k);
+        tokensUsed = finalResults.reduce((sum, r) => sum + estimateTokens(r.content), 0);
+    }
+    const ids = finalResults.map((r) => r.id);
+    const signals = await getSignalsForMemoryIds(pool, ids);
+    // SPEC-046: when the entity filter is active, attach per-memory entity_links
+    // (the FULL link set for each memory, not just the filter entity — callers
+    // can see the wider entity graph for these results) and set top-level
+    // entity_resolved + entity_id. When the filter is OFF, response shape must
+    // be byte-identical to SPEC-037 — no new keys, not even undefined ones.
+    const strippedResults = finalResults.map(stripInternal);
+    if (entityFilterActive && resolvedEntity) {
+        const linkMap = await getEntityLinksForMemories(pool, ids);
+        for (const r of strippedResults) {
+            r.entity_links = linkMap.get(r.id) ?? [];
+        }
+        return {
+            results: strippedResults,
+            query,
+            total_results: finalResults.length,
+            search_mode: searchMode,
+            tiers_searched: tiersSearched,
+            tokens_used: tokensUsed,
+            early_stopped: earlyStopped,
+            signals,
+            entity_resolved: true,
+            entity_id: resolvedEntity.id,
+            ...(degradedWarning ? { warnings: [degradedWarning] } : {}),
+        };
+    }
+    return {
+        results: strippedResults,
+        query,
+        total_results: finalResults.length,
+        search_mode: searchMode,
+        tiers_searched: tiersSearched,
+        tokens_used: tokensUsed,
+        early_stopped: earlyStopped,
+        signals,
+        ...(degradedWarning ? { warnings: [degradedWarning] } : {}),
+    };
+}

package/dist/tools/reject.d.ts

@@ -0,0 +1,10 @@
+export interface RejectInput {
+    id: string;
+    reason: string;
+}
+export interface RejectResult {
+    rejected_id: string;
+    reason_id: string;
+    message: string;
+}
+export declare function reject(input: RejectInput): Promise<RejectResult>;

package/dist/tools/reject.js

@@ -0,0 +1,24 @@
+import { getPool } from '../db.js';
+import { fingerprint } from '../fingerprint.js';
+export async function reject(input) {
+    const pool = getPool();
+    const { id, reason } = input;
+    // Mark the original memory's type as 'rejection' (matching schema CHECK constraint)
+    const updateResult = await pool.query(`UPDATE memories SET type = 'rejection', updated_at = NOW()
+     WHERE id = $1
+     RETURNING id, tier, topics, people`, [id]);
+    if (updateResult.rows.length === 0) {
+        throw new Error(`No memory found with id ${id}`);
+    }
+    const original = updateResult.rows[0];
+    // Store the rejection reason as a new memory entry
+    const fp = fingerprint(reason);
+    const reasonResult = await pool.query(`INSERT INTO memories (content, tier, type, section, topics, people, fingerprint)
+     VALUES ($1, $2, 'rejection', $3, $4, $5, $6)
+     RETURNING id`, [reason, original.tier, `rejection-of:${id}`, original.topics || [], original.people || [], fp]);
+    return {
+        rejected_id: id,
+        reason_id: reasonResult.rows[0].id,
+        message: `Memory ${id} marked as rejected. Reason stored as ${reasonResult.rows[0].id}.`,
+    };
+}