memwarden 0.0.1

package/dist/functions/conflicts.js

@@ -0,0 +1,328 @@
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "by",
+    "for",
+    "from",
+    "in",
+    "is",
+    "it",
+    "of",
+    "on",
+    "or",
+    "the",
+    "this",
+    "to",
+    "with",
+]);
+// Tokens that negate the claim they sit in. Clause-local: a negation only
+// flips polarity when it appears in the SAME clause as the matched
+// subject/relation (see extractClaims), so a subordinate "…which is not
+// deprecated" can't flip the polarity of the main claim.
+const NEGATION_RE = /\b(no longer|not|never|without|doesn't|does not|do not|isn't|is not|aren't|are not|disabled)\b/i;
+// Generic "container" subjects that legitimately hold many independent facts
+// ("the project uses zod" AND "the project uses vitest" are both true). For
+// these, two different positive values are NOT treated as a contradiction
+// unless they share a qualifier (the same attribute, e.g. "…for passwords").
+// A SPECIFIC subject (auth, cache, runtime, …) is single-valued, so two
+// different values for it DO contradict.
+const CONTAINER_SUBJECTS = new Set([
+    "project",
+    "repo",
+    "repository",
+    "codebase",
+    "code base",
+    "app",
+    "application",
+    "system",
+    "service",
+    "server",
+    "stack",
+    "we",
+    "they",
+    "it",
+]);
+const CLAIM_PATTERNS = [
+    {
+        relation: "uses",
+        re: /\b(.{2,80}?)\b(?:does not use|doesn't use|do not use|no longer uses|no longer use|never uses|never use|uses|use)\b\s+(.{2,100})/i,
+    },
+    {
+        relation: "is",
+        re: /\b(.{2,80}?)\b(?:is not|isn't|are not|aren't|is|are|was|were|becomes|became)\b\s+(.{2,100})/i,
+    },
+    {
+        relation: "configured",
+        re: /\b(.{2,80}?)\b(?:defaults to|default is|configured to|set to|runs on|stores in|writes to)\b\s+(.{2,100})/i,
+    },
+];
+function normalize(raw) {
+    return raw
+        .toLowerCase()
+        .replace(/["'`{}[\](),;:]/g, " ")
+        .replace(/[_/\\|=]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function words(raw) {
+    return normalize(raw)
+        .split(" ")
+        .map((w) => w.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, ""))
+        .filter((w) => w.length > 1 && !STOP_WORDS.has(w));
+}
+function subjectKey(raw) {
+    const ws = words(raw);
+    return ws.slice(-5).join(" ");
+}
+function valueWords(raw) {
+    const firstClause = raw.split(/[.!?\n|]/)[0] ?? raw;
+    return words(firstClause)
+        .filter((w) => !["now", "currently", "instead", "rather", "than"].includes(w))
+        .slice(0, 8);
+}
+function valueKey(raw) {
+    return valueWords(raw).join(" ");
+}
+// Split into clauses so negation can be scoped clause-locally. Clause
+// boundaries are sentence terminators AND coordinating/subordinating breaks
+// (commas, "which", "but", "although", "while", "however") so that a "not"
+// living in a subordinate clause does not reach the main claim's clause.
+function clausesOf(sentence) {
+    return sentence
+        .split(/,|\bwhich\b|\bwho\b|\bwhere\b|\bbut\b|\balthough\b|\bwhile\b|\bhowever\b|\bwhereas\b|\bthough\b/i)
+        .map((c) => c.trim())
+        .filter((c) => c.length > 0);
+}
+function splitClaimsText(obs) {
+    const text = [obs.title, obs.subtitle, ...obs.facts, obs.narrative]
+        .filter((s) => typeof s === "string" && s.trim().length > 0)
+        .join(" | ");
+    return text
+        .split(/[.!?\n|]+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length >= 8 && s.length <= 240);
+}
+function extractClaims(obs) {
+    const claims = [];
+    for (const sentence of splitClaimsText(obs)) {
+        for (const pattern of CLAIM_PATTERNS) {
+            const match = pattern.re.exec(sentence);
+            if (!match)
+                continue;
+            const subject = subjectKey(match[1] ?? "");
+            const value = valueKey(match[2] ?? "");
+            if (!subject || !value)
+                continue;
+            // Clause-local negation: only the clause that actually contains the
+            // matched subject+value can flip polarity. A "not"/"never"/"disabled"
+            // anywhere else in the sentence (e.g. a subordinate clause) is ignored.
+            const matchedText = normalize(match[0] ?? sentence);
+            const owningClause = clausesOf(sentence).find((c) => {
+                const n = normalize(c);
+                return n.length > 0 && (matchedText.includes(n) || n.includes(value));
+            }) ?? sentence;
+            claims.push({
+                subject,
+                relation: pattern.relation,
+                value,
+                valueTokens: valueWords(match[2] ?? ""),
+                polarity: NEGATION_RE.test(owningClause) ? "negative" : "positive",
+                text: normalize(sentence),
+                obs,
+            });
+            break;
+        }
+    }
+    return claims;
+}
+function jaccard(a, b) {
+    const left = new Set(a);
+    const right = new Set(b);
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let shared = 0;
+    for (const w of left)
+        if (right.has(w))
+            shared++;
+    return shared / (left.size + right.size - shared);
+}
+// True when the two phrases are an abbreviation/acronym pair, e.g.
+// "jwts" <-> "json web tokens", "k8s"-style initialisms aside. We compare the
+// initials of the multi-word phrase against the (de-pluralized) short token.
+function acronymMatch(a, b) {
+    const tryPair = (acr, phrase) => {
+        if (acr.length !== 1 || phrase.length < 2)
+            return false;
+        const token = acr[0].replace(/s$/, "");
+        if (token.length < 2)
+            return false;
+        const initials = phrase.map((w) => w[0] ?? "").join("");
+        return token === initials;
+    };
+    return tryPair(a, b) || tryPair(b, a);
+}
+// "Same fact, reworded" — the two values are NOT in genuine value-conflict.
+// Equal, one contains the other, an acronym/abbreviation pair, or high
+// token-overlap (>= 0.5) all count as the same fact.
+function valuesCompatible(a, b) {
+    if (a.value === b.value)
+        return true;
+    if (a.value.includes(b.value) || b.value.includes(a.value))
+        return true;
+    if (acronymMatch(a.valueTokens, b.valueTokens))
+        return true;
+    return jaccard(a.valueTokens, b.valueTokens) >= 0.5;
+}
+// On/off state words that carry the polarity themselves rather than naming a
+// distinct value: "cache is enabled" vs "cache is disabled" is the SAME
+// attribute toggled, not two different values. Stripped before the
+// polarity-conflict comparison so the residual values line up.
+const STATE_WORDS = new Set([
+    "enabled",
+    "disabled",
+    "on",
+    "off",
+    "active",
+    "inactive",
+    "present",
+    "absent",
+]);
+function stripStateTokens(tokens) {
+    return tokens.filter((t) => !STATE_WORDS.has(t));
+}
+// Are the two claims about the SAME thing such that opposite polarity is a
+// real contradiction? True when the residual values (state words removed)
+// line up — including the common "enabled"/"disabled" case where both reduce
+// to nothing and the subject IS the toggled thing.
+function samePolarityTarget(a, b) {
+    if (valuesCompatible(a, b))
+        return true;
+    const ra = stripStateTokens(a.valueTokens);
+    const rb = stripStateTokens(b.valueTokens);
+    if (ra.length === 0 && rb.length === 0)
+        return true; // pure state toggle
+    if (ra.length === 0 || rb.length === 0) {
+        // One side is a pure state word ("disabled"); the other carries the same
+        // residual the toggle applies to.
+        return jaccard(ra, rb) > 0 || ra.join(" ") === rb.join(" ");
+    }
+    return jaccard(ra, rb) >= 0.5;
+}
+// Do the two values share a qualifier token (the same attribute)? e.g.
+// "bcrypt for passwords" vs "md5 for passwords" share "passwords". Used to
+// turn a generic-container subject's differing values into a real conflict.
+function shareQualifier(a, b) {
+    const right = new Set(b.valueTokens);
+    return a.valueTokens.some((t) => right.has(t));
+}
+function isContainerSubject(subject) {
+    if (CONTAINER_SUBJECTS.has(subject))
+        return true;
+    // Multi-word subjects ending in a container head ("the api server") still
+    // count as a container.
+    const last = subject.split(" ").pop() ?? subject;
+    return CONTAINER_SUBJECTS.has(last);
+}
+function compareByTime(a, b) {
+    const left = Date.parse(a.timestamp);
+    const right = Date.parse(b.timestamp);
+    if (Number.isFinite(left) && Number.isFinite(right) && left !== right) {
+        return left - right;
+    }
+    return a.id.localeCompare(b.id);
+}
+function conflictBetween(a, b) {
+    if (a.obs.id === b.obs.id)
+        return null;
+    if (a.subject !== b.subject || a.relation !== b.relation)
+        return null;
+    const compatible = valuesCompatible(a, b);
+    // Polarity conflict: the SAME thing asserted both ways (positive vs negative)
+    // — e.g. "cache is enabled" vs "cache is disabled", or "uses X" vs "does not
+    // use X". State words ("enabled"/"disabled") carry the polarity themselves,
+    // so we compare the residual target rather than the raw value strings.
+    const polarityConflict = a.polarity !== b.polarity && samePolarityTarget(a, b);
+    // Value conflict: two POSITIVE claims with genuinely different values for the
+    // same subject+relation. Only a real contradiction when:
+    //   - the values aren't the same fact reworded (compatible == false), AND
+    //   - they aren't two different attributes of one subject. For the
+    //     "configured" relation (runs on / set to / defaults to …) values with
+    //     no shared token are different attributes (port vs host), not a clash.
+    //   - for a generic CONTAINER subject (project/repo/app/…) two unrelated
+    //     values are independent facts unless they share a qualifier (the same
+    //     attribute). A SPECIFIC subject is single-valued, so any differing
+    //     value contradicts.
+    let valueConflict = false;
+    if (!compatible && a.polarity === "positive" && b.polarity === "positive") {
+        const shared = shareQualifier(a, b);
+        if (a.relation === "configured" && !shared) {
+            valueConflict = false; // different attributes of the same subject
+        }
+        else if (isContainerSubject(a.subject) && !shared) {
+            valueConflict = false; // independent facts about a container
+        }
+        else {
+            valueConflict = true;
+        }
+    }
+    if (!polarityConflict && !valueConflict)
+        return null;
+    const [older, newer] = compareByTime(a.obs, b.obs) <= 0 ? [a, b] : [b, a];
+    return {
+        olderId: older.obs.id,
+        olderTitle: older.obs.title,
+        newerId: newer.obs.id,
+        newerTitle: newer.obs.title,
+        subject: older.subject,
+        olderClaim: older.text,
+        newerClaim: newer.text,
+        reason: polarityConflict
+            ? `same subject "${older.subject}" changed polarity`
+            : `same subject "${older.subject}" has incompatible values`,
+    };
+}
+/**
+ * Advisory contradiction report for mem::doctor. Deliberately conservative:
+ * simple subject/relation/value claims, clause-local negation, and a high bar
+ * for value conflicts so reworded facts, abbreviations, and different
+ * attributes of one subject don't fire. NEVER used to drop memory from recall
+ * — recall only firewalls STALE memory.
+ */
+export function detectConflicts(observations, limit = 20) {
+    const groups = new Map();
+    for (const obs of observations) {
+        for (const claim of extractClaims(obs)) {
+            const key = `${claim.relation}:${claim.subject}`;
+            const group = groups.get(key);
+            if (group)
+                group.push(claim);
+            else
+                groups.set(key, [claim]);
+        }
+    }
+    const conflicts = [];
+    const seen = new Set();
+    for (const group of groups.values()) {
+        const sorted = group.sort((a, b) => compareByTime(a.obs, b.obs));
+        for (let i = 0; i < sorted.length; i++) {
+            for (let j = i + 1; j < sorted.length; j++) {
+                const conflict = conflictBetween(sorted[i], sorted[j]);
+                if (!conflict)
+                    continue;
+                const key = `${conflict.olderId}:${conflict.newerId}:${conflict.subject}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                conflicts.push(conflict);
+                if (conflicts.length >= limit)
+                    return conflicts;
+            }
+        }
+    }
+    return conflicts;
+}

package/dist/functions/context.d.ts

@@ -0,0 +1,3 @@
+import type { ISdk } from "../kernel/index.js";
+import type { StateKV } from "../state/kv.js";
+export declare function registerContextFunction(sdk: ISdk, kv: StateKV, tokenBudget: number): void;

package/dist/functions/context.js

@@ -0,0 +1,155 @@
+//
+// Recency-packed context assembly (mem::context). Gathers pinned slots, the
+// project profile, ranked lessons, and recent same-project sessions (rendered
+// from their summary, or from important observations when there is none),
+// sorts the blocks newest-first, and greedily packs them under a token budget
+// inside a <memwarden-context project="..."> wrapper. Returns
+// {context, blocks, tokens}.
+//
+// Memory slots are an optional, off-by-default feature; when disabled the
+// pinned-slots block is empty.
+import { KV } from "../state/schema.js";
+import { recordAccessBatch } from "./access-tracker.js";
+import { isSlotsEnabled } from "./config.js";
+import { logger } from "./logger.js";
+import { metrics, estimateTokens } from "../observability/metrics.js";
+function escapeXmlAttr(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function block(type, content, recency, sourceIds) {
+    const b = { type, content, tokens: estimateTokens(content), recency };
+    if (sourceIds && sourceIds.length > 0)
+        b.sourceIds = sourceIds;
+    return b;
+}
+// Slots feature is not part of the core path; no pinned content when disabled.
+async function renderPinnedSlots(_kv) {
+    return isSlotsEnabled() ? "" : "";
+}
+function profileBlock(profile) {
+    if (!profile)
+        return null;
+    const parts = [];
+    if (profile.topConcepts.length > 0) {
+        parts.push(`Concepts: ${profile.topConcepts.slice(0, 8).map((c) => c.concept).join(", ")}`);
+    }
+    if (profile.topFiles.length > 0) {
+        parts.push(`Key files: ${profile.topFiles.slice(0, 5).map((f) => f.file).join(", ")}`);
+    }
+    if (profile.conventions.length > 0) {
+        parts.push(`Conventions: ${profile.conventions.join("; ")}`);
+    }
+    if (profile.commonErrors.length > 0) {
+        parts.push(`Common errors: ${profile.commonErrors.slice(0, 3).join("; ")}`);
+    }
+    if (parts.length === 0)
+        return null;
+    return block("memory", `## Project Profile\n${parts.join("\n")}`, new Date(profile.updatedAt).getTime());
+}
+function lessonsBlock(lessons, project) {
+    const relevant = lessons
+        .filter((l) => !l.deleted && (!l.project || l.project === project))
+        .sort((a, b) => {
+        const sa = (a.project === project ? 1.5 : 1) * a.confidence;
+        const sb = (b.project === project ? 1.5 : 1) * b.confidence;
+        return sb - sa;
+    })
+        .slice(0, 10);
+    if (relevant.length === 0)
+        return null;
+    const items = relevant
+        .map((l) => `- (${l.confidence.toFixed(2)}) ${l.content}${l.context ? ` — ${l.context}` : ""}`)
+        .join("\n");
+    const recency = relevant.reduce((acc, l) => {
+        const t = new Date(l.lastReinforcedAt || l.updatedAt).getTime();
+        return t > acc ? t : acc;
+    }, 0);
+    return block("memory", `## Lessons Learned\n${items}`, recency, relevant.map((l) => l.id));
+}
+export function registerContextFunction(sdk, kv, tokenBudget) {
+    sdk.registerFunction("mem::context", async (data) => {
+        const startedAt = performance.now();
+        const budget = data.budget || tokenBudget;
+        const blocks = [];
+        const [slotContent, profile, lessons] = await Promise.all([
+            renderPinnedSlots(kv).catch(() => ""),
+            kv.get(KV.profiles, data.project).catch(() => null),
+            kv.list(KV.lessons).catch(() => []),
+        ]);
+        if (slotContent)
+            blocks.push(block("memory", slotContent, Date.now()));
+        const pb = profileBlock(profile);
+        if (pb)
+            blocks.push(pb);
+        const lb = lessonsBlock(lessons, data.project);
+        if (lb)
+            blocks.push(lb);
+        // Recent sessions in the same project (excluding the current one).
+        const sessions = (await kv.list(KV.sessions))
+            .filter((s) => s.project === data.project && s.id !== data.sessionId)
+            .sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime())
+            .slice(0, 10);
+        const summaries = await Promise.all(sessions.map((s) => kv.get(KV.summaries, s.id).catch(() => null)));
+        // A session renders from its summary, or falls back to its important
+        // observations when no summary exists.
+        const needObs = [];
+        sessions.forEach((_, i) => {
+            const summary = summaries[i];
+            if (summary) {
+                const content = `## ${summary.title}\n${summary.narrative}\nDecisions: ${summary.keyDecisions.join("; ")}\nFiles: ${summary.filesModified.join(", ")}`;
+                blocks.push(block("summary", content, new Date(summary.createdAt).getTime()));
+            }
+            else {
+                needObs.push(i);
+            }
+        });
+        const obsLists = await Promise.all(needObs.map((i) => kv
+            .list(KV.observations(sessions[i].id))
+            .catch(() => [])));
+        needObs.forEach((sessionIdx, j) => {
+            const session = sessions[sessionIdx];
+            const important = (obsLists[j] ?? []).filter((o) => o.title && o.importance >= 5);
+            if (important.length === 0)
+                return;
+            const top = important.sort((a, b) => b.importance - a.importance).slice(0, 5);
+            const items = top.map((o) => `- [${o.type}] ${o.title}: ${o.narrative}`).join("\n");
+            const content = `## Session ${session.id.slice(0, 8)} (${session.startedAt})\n${items}`;
+            blocks.push(block("observation", content, new Date(session.startedAt).getTime(), top.map((o) => o.id)));
+        });
+        // Newest first, then greedily pack under the budget.
+        blocks.sort((a, b) => b.recency - a.recency);
+        const candidateTokens = blocks.reduce((sum, b) => sum + b.tokens, 0);
+        const header = `<memwarden-context project="${escapeXmlAttr(data.project)}">`;
+        const footer = `</memwarden-context>`;
+        let usedTokens = estimateTokens(header) + estimateTokens(footer);
+        const selected = [];
+        const accessedIds = [];
+        for (const b of blocks) {
+            if (usedTokens + b.tokens > budget)
+                continue;
+            selected.push(b.content);
+            usedTokens += b.tokens;
+            if (b.sourceIds)
+                accessedIds.push(...b.sourceIds);
+        }
+        if (accessedIds.length > 0)
+            void recordAccessBatch(kv, accessedIds);
+        const elapsed = performance.now() - startedAt;
+        if (selected.length === 0) {
+            metrics.recordContext(candidateTokens, 0, elapsed);
+            logger.info("No context available", { project: data.project });
+            return { context: "", blocks: 0, tokens: 0 };
+        }
+        metrics.recordContext(candidateTokens, usedTokens, elapsed);
+        logger.info("Context generated", { blocks: selected.length, tokens: usedTokens });
+        return {
+            context: `${header}\n${selected.join("\n\n")}\n${footer}`,
+            blocks: selected.length,
+            tokens: usedTokens,
+        };
+    });
+}

package/dist/functions/dedup.d.ts

@@ -0,0 +1,11 @@
+export declare class DedupMap {
+    private seen;
+    private sweep;
+    constructor();
+    computeHash(sessionId: string, toolName: string, toolInput: unknown): string;
+    isDuplicate(hash: string): boolean;
+    record(hash: string): void;
+    stop(): void;
+    get size(): number;
+    private evictExpired;
+}

package/dist/functions/dedup.js

@@ -0,0 +1,51 @@
+//
+// A short-lived dedup set for the observe write path. Identical tool calls
+// (same session + tool + input) seen again within a 5-minute window are
+// suppressed, so a retried or replayed event is not stored twice. A periodic
+// sweep clears expired keys; its timer is unref'd so it never holds the
+// process open.
+import { createHash } from "node:crypto";
+const WINDOW_MS = 5 * 60 * 1000;
+const SWEEP_MS = 60_000;
+const MAX_INPUT = 500;
+export class DedupMap {
+    // hash -> expiry (epoch ms)
+    seen = new Map();
+    sweep;
+    constructor() {
+        this.sweep = setInterval(() => this.evictExpired(), SWEEP_MS);
+        this.sweep.unref();
+    }
+    computeHash(sessionId, toolName, toolInput) {
+        const raw = typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput ?? "");
+        return createHash("sha256")
+            .update(`${sessionId}:${toolName}:${raw.slice(0, MAX_INPUT)}`)
+            .digest("hex");
+    }
+    isDuplicate(hash) {
+        const expiry = this.seen.get(hash);
+        if (expiry === undefined)
+            return false;
+        if (Date.now() > expiry) {
+            this.seen.delete(hash);
+            return false;
+        }
+        return true;
+    }
+    record(hash) {
+        this.seen.set(hash, Date.now() + WINDOW_MS);
+    }
+    stop() {
+        clearInterval(this.sweep);
+    }
+    get size() {
+        return this.seen.size;
+    }
+    evictExpired() {
+        const now = Date.now();
+        for (const [hash, expiry] of this.seen) {
+            if (now > expiry)
+                this.seen.delete(hash);
+        }
+    }
+}

package/dist/functions/dejafix.d.ts

@@ -0,0 +1,96 @@
+import type { ISdk } from "../kernel/index.js";
+import type { StateKV } from "../state/kv.js";
+import type { Provenance } from "./types.js";
+export declare const DEJAFIX_SCOPE = "mem:dejafix";
+/** A captured {error signature -> root cause + fix} record. */
+export interface FixMemory {
+    /** Stable signature of the error this fix resolves. */
+    signature: string;
+    /** Id of the observation/record this fix was captured from. */
+    observationId: string;
+    /** Optional one-line root cause. */
+    rootCause?: string;
+    /** Short narrative of the fix that resolved the error. */
+    fix: string;
+    /** Evidence trail (files + fileHashes) reused by Verified Recall. */
+    provenance: Provenance;
+    /** Which agent recorded it (claude, codex, cursor, …). */
+    tool?: string;
+    /** Session it was recorded in. */
+    sessionId?: string;
+    /** Capture-time working directory (project scope). */
+    cwd: string;
+    /** ISO timestamp the fix was recorded. */
+    timestamp: string;
+}
+/** A FixMemory surfaced by lookup, annotated with a freshness badge. */
+export interface VerifiedFix {
+    signature: string;
+    observationId: string;
+    rootCause?: string;
+    fix: string;
+    tool?: string;
+    sessionId?: string;
+    cwd: string;
+    timestamp: string;
+    /** "verified current" when all referenced files still hash-match; else
+     *  "sourced, unverified". Stale fixes are never returned at all. */
+    badge: "verified current" | "sourced, unverified";
+    /** The underlying classifier status (verified | sourced_unverified). */
+    status: "verified" | "sourced_unverified";
+}
+/**
+ * Extract a STABLE signature from an error message, stack trace, or failing
+ * test output. Returns null when nothing recognizable as an error is present.
+ *
+ * The signature normalizes away volatile parts (absolute paths -> basename,
+ * line/column numbers, hex addresses, timestamps, UUIDs, ports, durations) and
+ * keeps the stable core: the error/exception class, the failing test name, and
+ * the key message tokens. Deterministic: same logical error -> same signature.
+ */
+export declare function errorSignature(text: string): string | null;
+/** True when `text` contains both an error AND resolution language — the
+ *  shape that observe.ts treats as a recorded fix worth signature-tagging. */
+export declare function looksLikeResolvedFix(text: string): boolean;
+export interface RecordFixInput {
+    /** Error text (or its signature) the fix resolves. */
+    errorText?: string;
+    /** Precomputed signature (overrides errorText if both given). */
+    signature?: string;
+    observationId?: string;
+    rootCause?: string;
+    fix: string;
+    /** Files the fix touched/relied on; hashed under cwd for drift checks. */
+    files?: string[];
+    /** A fully-formed provenance (overrides files-based one if given). */
+    provenance?: Provenance;
+    tool?: string;
+    sessionId?: string;
+    cwd: string;
+    timestamp?: string;
+}
+/**
+ * Store a FixMemory under its signature. Returns the stored record, or null
+ * when no signature can be derived (nothing to key on). Hashes the referenced
+ * files at capture time so later recall can detect drift — exactly like
+ * observe.ts does for synthetic observations.
+ */
+export declare function recordFix(kv: StateKV, input: RecordFixInput): Promise<FixMemory | null>;
+/**
+ * Look up verified fixes for an error. Computes the signature, fetches the
+ * candidate FixMemories scoped to the caller's project (canonicalized cwd),
+ * runs each through classifyProvenance, and returns ONLY verified /
+ * sourced_unverified ones — never stale, never if referenced files vanished.
+ * Each is annotated with a freshness badge. Newest first.
+ */
+export declare function lookupFix(kv: StateKV, errorText: string, cwd: string): Promise<VerifiedFix[]>;
+/**
+ * Register the two Déjà Fix kernel functions:
+ *   mem::dejafix_record  — store a fix (input: errorText|signature, fix, …)
+ *   mem::dejafix_lookup  — surface verified fixes for an error (input:
+ *                          errorText, cwd)
+ *
+ * Both are thin, dependency-free, and go through the same StateKV chokepoint
+ * every other mem:: function uses, so they share the one persistence layer.
+ */
+export declare function registerDejaFixFunctions(sdk: ISdk, kv: StateKV): void;