@iamem/amem 0.1.0

package/dist/draft-quality.js

@@ -0,0 +1,85 @@
+import { listClaims } from "./db.js";
+import { kindRankBoost } from "./kinds.js";
+import { findClaimConflicts, parseProposalJson, } from "./proposal.js";
+export const REJECT_SCORE = 25;
+function labelFor(score) {
+    if (score < REJECT_SCORE)
+        return "reject";
+    if (score < 45)
+        return "low";
+    if (score < 60)
+        return "medium";
+    return "high";
+}
+/** Confidence 0–100 for a session-end / miss→learn proposal. */
+export function scoreProposal(proposal) {
+    const reasons = [];
+    let score = 10;
+    const claims = proposal.claims ?? [];
+    if (claims.length === 0) {
+        return { score: 0, label: "reject", reasons: ["empty proposal"], reject: true };
+    }
+    for (const claim of claims) {
+        const kind = (claim.kind || "session").toLowerCase();
+        const kindPts = Math.min(30, kindRankBoost(kind) * 2);
+        score += kindPts;
+        reasons.push(`${kind} +${kindPts}`);
+        const anchors = (claim.code_anchors ?? []).filter((a) => a && a !== "README.md");
+        const anchorPts = Math.min(20, anchors.length * 10);
+        score += anchorPts;
+        if (anchorPts)
+            reasons.push(`${anchors.length} file anchor${anchors.length === 1 ? "" : "s"} +${anchorPts}`);
+        else
+            reasons.push("no real file anchors");
+        const text = (claim.text || "").trim();
+        if (text.length >= 60) {
+            score += 15;
+            reasons.push("specific takeaway +15");
+        }
+        else if (text.length >= 40) {
+            score += 8;
+            reasons.push("short takeaway +8");
+        }
+        else {
+            score -= 10;
+            reasons.push("thin text −10");
+        }
+        if (/\b(must|never|always|gotcha|constraint|idempotent|before|entrypoint)\b/i.test(text)) {
+            score += 10;
+            reasons.push("durable language +10");
+        }
+        if (/\b(ok|thanks|sure|please)\b/i.test(text) && text.length < 50) {
+            score -= 15;
+            reasons.push("chat noise −15");
+        }
+        if (kind === "session" && anchors.length === 0) {
+            score -= 20;
+            reasons.push("session without anchors −20");
+        }
+    }
+    score = Math.max(0, Math.min(100, score));
+    const label = labelFor(score);
+    return { score, label, reasons, reject: label === "reject" };
+}
+export function parseDraftProposal(draft) {
+    try {
+        return parseProposalJson(draft.proposal_json);
+    }
+    catch {
+        return { claims: [] };
+    }
+}
+export function decorateDraft(draft, existingActive = listClaims(draft.repo_id)) {
+    const proposal = parseDraftProposal(draft);
+    const quality = scoreProposal(proposal);
+    const conflicts = findClaimConflicts(proposal, existingActive.filter((c) => (c.status ?? "active") === "active"));
+    return { ...draft, quality, conflicts };
+}
+export function decorateDrafts(drafts) {
+    const byRepo = new Map();
+    return drafts.map((d) => {
+        if (!byRepo.has(d.repo_id))
+            byRepo.set(d.repo_id, listClaims(d.repo_id));
+        return decorateDraft(d, byRepo.get(d.repo_id));
+    });
+}

package/dist/embed.d.ts

@@ -0,0 +1,76 @@
+import type Database from "better-sqlite3";
+import type { ClaimRow } from "./db.js";
+export declare const HASH_DIM = 128;
+export declare const NGRAM_DIM = 256;
+/** @deprecated use HASH_DIM — kept so older tests keep compiling */
+export declare const EMBED_DIM = 128;
+export type EmbedBackend = "hash" | "ngram" | "external";
+export type EmbedStatus = {
+    backend: EmbedBackend;
+    requested: EmbedBackend;
+    dim: number;
+    licensed: boolean;
+    path: string;
+    command?: string;
+    args: string[];
+};
+export declare function requestedEmbedBackend(): EmbedBackend;
+export declare function activeEmbedBackend(): EmbedBackend;
+export declare function embedDim(backend?: EmbedBackend): number;
+export declare function embedCommand(): {
+    command?: string;
+    args: string[];
+};
+export declare function embedStatus(): EmbedStatus;
+export declare function setEmbedBackend(backend: EmbedBackend, extra?: {
+    command?: string;
+    args?: string[];
+    dim?: number;
+}): EmbedStatus;
+export declare function embedExternal(text: string): Float32Array;
+/** Local n-gram encoder: word tokens + char 3-grams + token pairs. No download. */
+export declare function embedNgram(text: string): Float32Array;
+export declare function embedText(text: string, backend?: EmbedBackend): Float32Array;
+export declare function cosine(a: Float32Array, b: Float32Array): number;
+export declare function vectorToBlob(vec: Float32Array): Buffer;
+export declare function blobToVector(buf: Buffer): Float32Array;
+export declare function ensureClaimsEmbed(db: Database.Database): void;
+export declare function upsertClaimEmbed(db: Database.Database, claim: ClaimRow): void;
+export declare function removeClaimEmbed(db: Database.Database, repoId: string, claimId: string): void;
+export declare function reindexRepoEmbeds(db: Database.Database, repoId: string): void;
+export declare function reindexAllEmbeds(db: Database.Database): {
+    repos: number;
+    claims: number;
+};
+export type EmbedIndexHealth = {
+    active: EmbedBackend;
+    dim: number;
+    total: number;
+    usable: number;
+    stale: number;
+    strandedBy: Array<{
+        backend: string;
+        dim: number;
+        count: number;
+    }>;
+};
+/**
+ * Stored vectors are only scored when their backend *and* dim match the active one, so a
+ * backend switch (usually a license change) silently drops facts out of semantic ranking
+ * without any error. This reports that drift so doctor/attest can tell the user to reindex.
+ */
+export declare function embedIndexHealth(db: Database.Database): EmbedIndexHealth;
+/** Human-readable warnings for doctor/attest. Empty when the index is consistent. */
+export declare function embedIndexIssues(db: Database.Database): string[];
+export type EmbedHit = {
+    id: string;
+    score: number;
+};
+export declare function searchClaimsEmbed(db: Database.Database, repoId: string, query: string, limit?: number): EmbedHit[];
+/**
+ * Live embed ranking for a forced backend (hash vs ngram showdown).
+ * Scores active claim texts against the query without requiring stored rows for that backend.
+ */
+export declare function searchClaimsEmbedLive(claims: ClaimRow[], query: string, backend: EmbedBackend, limit?: number): EmbedHit[];
+/** Convert cosine (0..1-ish) into a ranking boost comparable to FTS. */
+export declare function embedBoostFromScore(score: number): number;

package/dist/embed.js

@@ -0,0 +1,331 @@
+/**
+ * On-device embeddings. Default is feature hashing (no download).
+ * Pro can switch to a local n-gram encoder (still no cloud, no model fetch).
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { FEATURE_LOCAL_EMBED, hasFeature } from "./license.js";
+import { amemHome } from "./paths.js";
+import { tokenize } from "./search.js";
+export const HASH_DIM = 128;
+export const NGRAM_DIM = 256;
+/** @deprecated use HASH_DIM — kept so older tests keep compiling */
+export const EMBED_DIM = HASH_DIM;
+function embedSettingsPath() {
+    return join(amemHome(), "embed.json");
+}
+function readEmbedSettings() {
+    const path = embedSettingsPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function requestedEmbedBackend() {
+    const env = (process.env.AMEM_EMBED_BACKEND || "").trim().toLowerCase();
+    if (env === "hash" || env === "ngram" || env === "external")
+        return env;
+    const raw = readEmbedSettings().backend;
+    if (raw === "ngram" || raw === "external")
+        return raw;
+    return "hash";
+}
+export function activeEmbedBackend() {
+    const requested = requestedEmbedBackend();
+    if ((requested === "ngram" || requested === "external") && hasFeature(FEATURE_LOCAL_EMBED)) {
+        return requested;
+    }
+    return "hash";
+}
+export function embedDim(backend = activeEmbedBackend()) {
+    if (backend === "ngram")
+        return NGRAM_DIM;
+    if (backend === "external") {
+        const n = Number(process.env.AMEM_EMBED_DIM || readEmbedSettings().dim || 0);
+        return Number.isFinite(n) && n > 0 ? Math.floor(n) : HASH_DIM;
+    }
+    return HASH_DIM;
+}
+export function embedCommand() {
+    const settings = readEmbedSettings();
+    const command = (process.env.AMEM_EMBED_CMD || settings.command || "").trim() || undefined;
+    const args = Array.isArray(settings.args) ? settings.args.filter((a) => typeof a === "string") : [];
+    return { command, args };
+}
+export function embedStatus() {
+    const requested = requestedEmbedBackend();
+    const backend = activeEmbedBackend();
+    const { command, args } = embedCommand();
+    return {
+        backend,
+        requested,
+        dim: embedDim(backend),
+        licensed: hasFeature(FEATURE_LOCAL_EMBED),
+        path: embedSettingsPath(),
+        command,
+        args,
+    };
+}
+export function setEmbedBackend(backend, extra = {}) {
+    if ((backend === "ngram" || backend === "external") && !hasFeature(FEATURE_LOCAL_EMBED)) {
+        throw new Error("Local embeddings need an amem Pro or IT license. Buy at https://getamem.com then: amem license apply --file <amem-license.json>");
+    }
+    if (backend === "external" && !(extra.command || process.env.AMEM_EMBED_CMD || readEmbedSettings().command)) {
+        throw new Error("external embedder needs --cmd (stdin text → stdout JSON { vector: number[] })");
+    }
+    mkdirSync(amemHome(), { recursive: true, mode: 0o700 });
+    const prev = readEmbedSettings();
+    const next = {
+        backend,
+        command: extra.command ?? prev.command,
+        args: extra.args ?? prev.args,
+        dim: extra.dim ?? prev.dim,
+    };
+    writeFileSync(embedSettingsPath(), `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    return embedStatus();
+}
+function parseExternalVector(raw) {
+    const trimmed = raw.trim();
+    let values = [];
+    try {
+        const parsed = JSON.parse(trimmed);
+        const list = Array.isArray(parsed) ? parsed : parsed.vector;
+        if (Array.isArray(list))
+            values = list.map((n) => Number(n));
+    }
+    catch {
+        values = trimmed.split(/[\s,]+/).map((n) => Number(n));
+    }
+    const clean = values.filter((n) => Number.isFinite(n));
+    if (clean.length < 4)
+        throw new Error("external embedder returned no usable vector");
+    return normalize(Float32Array.from(clean));
+}
+export function embedExternal(text) {
+    const { command, args } = embedCommand();
+    if (!command)
+        throw new Error("No AMEM_EMBED_CMD / embed.json command configured");
+    const out = execFileSync(command, args, {
+        input: text,
+        encoding: "utf8",
+        timeout: 8000,
+        maxBuffer: 2_000_000,
+        windowsHide: true,
+    });
+    return parseExternalVector(out);
+}
+function hashToken(token, dim) {
+    let h = 2166136261;
+    for (let i = 0; i < token.length; i++) {
+        h ^= token.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return Math.abs(h) % dim;
+}
+function addToken(vec, token, dim) {
+    const i = hashToken(token, dim);
+    const sign = hashToken(`s:${token}`, dim) % 2 === 0 ? 1 : -1;
+    vec[i] += sign;
+}
+function normalize(vec) {
+    let norm = 0;
+    for (let i = 0; i < vec.length; i++)
+        norm += vec[i] * vec[i];
+    norm = Math.sqrt(norm) || 1;
+    for (let i = 0; i < vec.length; i++)
+        vec[i] = vec[i] / norm;
+    return vec;
+}
+function embedHash(text) {
+    const vec = new Float32Array(HASH_DIM);
+    const tokens = tokenize(text);
+    if (tokens.length === 0)
+        return vec;
+    for (const t of tokens)
+        addToken(vec, t, HASH_DIM);
+    return normalize(vec);
+}
+/** Local n-gram encoder: word tokens + char 3-grams + token pairs. No download. */
+export function embedNgram(text) {
+    const vec = new Float32Array(NGRAM_DIM);
+    const tokens = tokenize(text);
+    const chars = text.toLowerCase().replace(/\s+/g, " ");
+    for (const t of tokens)
+        addToken(vec, t, NGRAM_DIM);
+    for (let i = 0; i < tokens.length - 1; i++) {
+        addToken(vec, `${tokens[i]}_${tokens[i + 1]}`, NGRAM_DIM);
+    }
+    for (let i = 0; i < chars.length - 2; i++) {
+        addToken(vec, `c:${chars.slice(i, i + 3)}`, NGRAM_DIM);
+    }
+    return normalize(vec);
+}
+export function embedText(text, backend = activeEmbedBackend()) {
+    if (backend === "ngram")
+        return embedNgram(text);
+    if (backend === "external") {
+        try {
+            return embedExternal(text);
+        }
+        catch {
+            return embedHash(text);
+        }
+    }
+    return embedHash(text);
+}
+export function cosine(a, b) {
+    let s = 0;
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++)
+        s += a[i] * b[i];
+    return s;
+}
+export function vectorToBlob(vec) {
+    return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+export function blobToVector(buf) {
+    return new Float32Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 4));
+}
+export function ensureClaimsEmbed(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS claims_embed (
+      repo_id TEXT NOT NULL,
+      claim_id TEXT NOT NULL,
+      dim INTEGER NOT NULL,
+      vector BLOB NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (repo_id, claim_id)
+    );
+  `);
+    const cols = db.prepare(`PRAGMA table_info(claims_embed)`).all();
+    if (!cols.some((c) => c.name === "backend")) {
+        db.exec(`ALTER TABLE claims_embed ADD COLUMN backend TEXT NOT NULL DEFAULT 'hash'`);
+    }
+}
+export function upsertClaimEmbed(db, claim) {
+    ensureClaimsEmbed(db);
+    const backend = activeEmbedBackend();
+    const text = `${claim.id} ${claim.kind} ${claim.text} ${claim.code_anchors}`;
+    const vec = embedText(text, backend);
+    db.prepare(`INSERT INTO claims_embed (repo_id, claim_id, dim, vector, updated_at, backend)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo_id, claim_id) DO UPDATE SET
+       dim = excluded.dim,
+       vector = excluded.vector,
+       updated_at = excluded.updated_at,
+       backend = excluded.backend`).run(claim.repo_id, claim.id, vec.length, vectorToBlob(vec), claim.updated_at, backend);
+}
+export function removeClaimEmbed(db, repoId, claimId) {
+    ensureClaimsEmbed(db);
+    db.prepare(`DELETE FROM claims_embed WHERE repo_id = ? AND claim_id = ?`).run(repoId, claimId);
+}
+export function reindexRepoEmbeds(db, repoId) {
+    ensureClaimsEmbed(db);
+    db.prepare(`DELETE FROM claims_embed WHERE repo_id = ?`).run(repoId);
+    const claims = db
+        .prepare(`SELECT * FROM claims WHERE repo_id = ? AND COALESCE(status, 'active') = 'active'`)
+        .all(repoId);
+    for (const c of claims)
+        upsertClaimEmbed(db, c);
+}
+export function reindexAllEmbeds(db) {
+    ensureClaimsEmbed(db);
+    const repos = db.prepare(`SELECT DISTINCT repo_id AS id FROM claims`).all();
+    let claims = 0;
+    for (const repo of repos) {
+        reindexRepoEmbeds(db, repo.id);
+        claims += db
+            .prepare(`SELECT COUNT(*) AS n FROM claims_embed WHERE repo_id = ?`)
+            .get(repo.id).n;
+    }
+    return { repos: repos.length, claims };
+}
+/**
+ * Stored vectors are only scored when their backend *and* dim match the active one, so a
+ * backend switch (usually a license change) silently drops facts out of semantic ranking
+ * without any error. This reports that drift so doctor/attest can tell the user to reindex.
+ */
+export function embedIndexHealth(db) {
+    ensureClaimsEmbed(db);
+    const active = activeEmbedBackend();
+    const dim = embedDim(active);
+    const rows = db
+        .prepare(`SELECT COALESCE(backend, 'hash') AS backend, dim, COUNT(*) AS n
+       FROM claims_embed GROUP BY backend, dim`)
+        .all();
+    let total = 0;
+    let usable = 0;
+    const strandedBy = [];
+    for (const row of rows) {
+        total += row.n;
+        if (row.backend === active && row.dim === dim)
+            usable += row.n;
+        else
+            strandedBy.push({ backend: row.backend, dim: row.dim, count: row.n });
+    }
+    return { active, dim, total, usable, stale: total - usable, strandedBy };
+}
+/** Human-readable warnings for doctor/attest. Empty when the index is consistent. */
+export function embedIndexIssues(db) {
+    let health;
+    try {
+        health = embedIndexHealth(db);
+    }
+    catch {
+        return [];
+    }
+    if (health.stale === 0)
+        return [];
+    const from = health.strandedBy
+        .map((s) => `${s.backend}/${s.dim}`)
+        .join(", ");
+    return [
+        `${health.stale} of ${health.total} facts are indexed with ${from} but the active embed backend is ${health.active}/${health.dim} — semantic search skips them. Run: amem embed reindex`,
+    ];
+}
+export function searchClaimsEmbed(db, repoId, query, limit = 24) {
+    return searchClaimsEmbedBackend(db, repoId, query, activeEmbedBackend(), limit);
+}
+/**
+ * Live embed ranking for a forced backend (hash vs ngram showdown).
+ * Scores active claim texts against the query without requiring stored rows for that backend.
+ */
+export function searchClaimsEmbedLive(claims, query, backend, limit = 24) {
+    if (tokenize(query).length === 0)
+        return [];
+    const qv = embedText(query, backend);
+    const scored = claims
+        .map((c) => {
+        const text = `${c.id} ${c.kind} ${c.text} ${c.code_anchors}`;
+        return { id: c.id, score: cosine(qv, embedText(text, backend)) };
+    })
+        .filter((r) => r.score > 0.05)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return scored;
+}
+function searchClaimsEmbedBackend(db, repoId, query, backend, limit = 24) {
+    ensureClaimsEmbed(db);
+    const qv = embedText(query, backend);
+    if (tokenize(query).length === 0)
+        return [];
+    const rows = db
+        .prepare(`SELECT claim_id AS id, vector FROM claims_embed
+       WHERE repo_id = ? AND dim = ? AND COALESCE(backend, 'hash') = ?`)
+        .all(repoId, qv.length, backend);
+    const scored = rows
+        .map((r) => ({ id: r.id, score: cosine(qv, blobToVector(r.vector)) }))
+        .filter((r) => r.score > 0.05)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit);
+    return scored;
+}
+/** Convert cosine (0..1-ish) into a ranking boost comparable to FTS. */
+export function embedBoostFromScore(score) {
+    return Math.max(0, score) * 14;
+}

package/dist/estimate.d.ts

@@ -0,0 +1,32 @@
+import type { ContextPacket } from "./context.js";
+/** Rough chars→tokens. */
+export declare function estimateTokensFromText(text: string): number;
+/**
+ * Proxy for exploration avoided:
+ * anchors_returned * 4000 + claims_returned * 200 - packet_tokens
+ */
+export declare function estimateTokensSaved(input: {
+    anchorsCount: number;
+    claimsCount: number;
+    packetTokens: number;
+}): number;
+/** Typical Cursor/Claude tool round-trip to read a file (~1.2s) plus a little per claim. */
+export declare const MS_PER_FILE_ROUNDTRIP = 1200;
+export declare const MS_PER_CLAIM = 80;
+export declare function estimateMsSaved(input: {
+    anchorsCount: number;
+    claimsCount: number;
+}): number;
+/** Mid-range frontier *input* $/1M tokens (Sonnet-class). Avoided exploration is input-side. Not a bill. */
+export declare const USD_PER_MILLION_INPUT_TOKENS = 3;
+export declare function estimateUsdSaved(tokens: number, usdPerMillion?: number): number;
+export declare function eventKind(claimsCount: number, notesCount?: number): "local_hit" | "server_trip";
+export declare function metricsFromPacket(packet: ContextPacket, markdown: string): {
+    claimIds: string[];
+    anchorsCount: number;
+    claimsCount: number;
+    packetTokens: number;
+    estimatedTokensSaved: number;
+    estimatedMsSaved: number;
+    kind: "local_hit" | "server_trip";
+};

package/dist/estimate.js

@@ -0,0 +1,69 @@
+/** Rough chars→tokens. */
+export function estimateTokensFromText(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+}
+/**
+ * Proxy for exploration avoided:
+ * anchors_returned * 4000 + claims_returned * 200 - packet_tokens
+ */
+export function estimateTokensSaved(input) {
+    return Math.max(0, input.anchorsCount * 4000 + input.claimsCount * 200 - input.packetTokens);
+}
+/** Typical Cursor/Claude tool round-trip to read a file (~1.2s) plus a little per claim. */
+export const MS_PER_FILE_ROUNDTRIP = 1200;
+export const MS_PER_CLAIM = 80;
+export function estimateMsSaved(input) {
+    return Math.max(0, input.anchorsCount * MS_PER_FILE_ROUNDTRIP + input.claimsCount * MS_PER_CLAIM);
+}
+/** Mid-range frontier *input* $/1M tokens (Sonnet-class). Avoided exploration is input-side. Not a bill. */
+export const USD_PER_MILLION_INPUT_TOKENS = 3;
+export function estimateUsdSaved(tokens, usdPerMillion = USD_PER_MILLION_INPUT_TOKENS) {
+    return Math.max(0, (Number(tokens) / 1_000_000) * usdPerMillion);
+}
+export function eventKind(claimsCount, notesCount = 0) {
+    return claimsCount > 0 || notesCount > 0 ? "local_hit" : "server_trip";
+}
+export function metricsFromPacket(packet, markdown) {
+    const matchedClaims = packet.claims.filter((c) => c.score > 0);
+    const matchedNotes = packet.notes.filter((n) => n.score > 0);
+    const kind = matchedClaims.length > 0 || matchedNotes.length > 0 ? "local_hit" : "server_trip";
+    const scored = kind === "local_hit" ? matchedClaims : [];
+    const claimIds = packet.claims.map((c) => c.id);
+    const anchorSet = new Set();
+    for (const claim of scored) {
+        try {
+            const anchors = JSON.parse(claim.code_anchors);
+            for (const a of anchors)
+                anchorSet.add(a);
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (kind === "local_hit") {
+        for (const component of packet.components) {
+            if (component.code_anchor)
+                anchorSet.add(component.code_anchor);
+        }
+    }
+    const anchorsCount = anchorSet.size;
+    const claimsCount = scored.length;
+    const packetTokens = estimateTokensFromText(markdown);
+    const estimatedTokensSaved = kind === "local_hit"
+        ? estimateTokensSaved({
+            anchorsCount,
+            claimsCount,
+            packetTokens,
+        })
+        : 0;
+    const estimatedMsSaved = kind === "local_hit" ? estimateMsSaved({ anchorsCount, claimsCount }) : 0;
+    return {
+        claimIds,
+        anchorsCount,
+        claimsCount,
+        packetTokens,
+        estimatedTokensSaved,
+        estimatedMsSaved,
+        kind,
+    };
+}

package/dist/freshness.d.ts

@@ -0,0 +1,15 @@
+import type { ClaimRow } from "./db.js";
+export type FreshnessStatus = "fresh" | "stale" | "missing_anchor" | "unanchored" | "unknown";
+export type ClaimFreshness = {
+    status: FreshnessStatus;
+    staleAnchors: string[];
+    missingAnchors: string[];
+};
+export declare function parseAnchors(codeAnchorsJson: string): string[];
+/**
+ * Compare claim.updated_at to filesystem mtimes of code_anchors.
+ * Missing paths → missing_anchor; any newer file → stale.
+ */
+export declare function assessClaimFreshness(rootPath: string | undefined, claim: ClaimRow): ClaimFreshness;
+/** Multiplier applied to retrieval score (1 = full trust). */
+export declare function freshnessScoreMultiplier(status: FreshnessStatus): number;