local-agentic-ai-mem 0.1.0

package/dist/lib/compose.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Compose a memory body for an atom that has no `content` yet.
+ *
+ * Historical atoms predate the content field, and the server has no transcript
+ * for them — only the prompt, the tool calls, the files touched and whatever
+ * the old regex scraper put in `decisions`. This squeezes a usable memory out
+ * of that material, or reports that there isn't one.
+ *
+ * The important behaviour is the second case. The previous refresh pass kept
+ * every atom because its extractor unconditionally appended `task: <prompt>`
+ * for any prompt of 20 characters or more, so "decisions.length > 0" was
+ * always true and the archive branch was unreachable. Filler is filtered out
+ * here before the emptiness check, so archival can actually happen.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meaningfulDecisions = meaningfulDecisions;
+exports.isControlFlowPrompt = isControlFlowPrompt;
+exports.indexText = indexText;
+exports.composeAtomContent = composeAtomContent;
+/** Decision prefixes that restate inputs rather than record an outcome. */
+const FILLER = /^(task|at commit|areas|pattern|convention|summary):\s*/i;
+/** Prompts that moved a session along without containing anything to remember. */
+const CONTROL_FLOW = /^(ok|okay|yes|yep|y|k|go|next|continue|proceed|thanks?|ty|test again|try again|do it|lets? go|ok lets? go|yes lets? go|whats? next\s*\??|ok whats? next\s*\??|git add commit and push( everything)?\.?|push it|commit it|save|\/\w[\w-]*|<task-notification>|\[image #\d+\])\s*[.!?]*$/i;
+function parseToolCalls(raw) {
+    const arr = typeof raw === "string" ? safeParse(raw) : raw;
+    if (!Array.isArray(arr))
+        return [];
+    return arr
+        .filter((t) => t && typeof t.tool === "string")
+        .map((t) => ({ tool: String(t.tool), target: String(t.target ?? "") }));
+}
+function safeParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+/** Decisions that actually say something, in original order. */
+function meaningfulDecisions(decisions) {
+    if (!Array.isArray(decisions))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const d of decisions) {
+        const text = String(d || "").trim();
+        if (!text || FILLER.test(text))
+            continue;
+        if (text.length < 15)
+            continue;
+        const key = text.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(text);
+    }
+    return out;
+}
+/**
+ * Strip harness scaffolding before judging a prompt.
+ *
+ * Claude Code injects structured payloads — task notifications, image
+ * references, system reminders — as the user turn. The tag alone was matched,
+ * but a real `<task-notification>` carries an id and a summary inside it, so
+ * the multi-line form slipped through and reached the index as a "memory".
+ */
+function stripHarnessNoise(text) {
+    return (text || "")
+        .replace(/<task-notification>[\s\S]*?<\/task-notification>/gi, " ")
+        .replace(/<\/?(?:task-notification|task-id|summary|system-reminder|command-name|local-command-stdout)[^>]*>/gi, " ")
+        .replace(/\[Image #\d+\]/gi, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function isControlFlowPrompt(prompt) {
+    const p = stripHarnessNoise(prompt);
+    if (p.length < 12)
+        return true;
+    return CONTROL_FLOW.test(p);
+}
+/**
+ * The text that gets embedded.
+ *
+ * Both halves matter and for different reasons. The prompt carries how the
+ * user phrases things, and at recall time the query *is* a new user prompt —
+ * dropping it measurably hurt retrieval. The content carries what was
+ * actually learned, which is what makes the returned memory worth reading.
+ * Indexing only one of them loses either the match or the payload.
+ *
+ * This also brings the vector arm in line with the lexical arm, whose
+ * tsvector has always covered content, prompt, decisions and files together.
+ */
+const INDEX_TEXT_CAP = 1200;
+function indexText(prompt, content) {
+    const p = stripHarnessNoise(prompt || "").slice(0, 400);
+    const c = (content || "").trim();
+    const joined = [c, p].filter(Boolean).join("\n");
+    return joined.slice(0, INDEX_TEXT_CAP);
+}
+/**
+ * Returns null when the atom holds nothing durable — the caller should archive
+ * it rather than keep it competing for space in recall results.
+ */
+function composeAtomContent(atom) {
+    const meaningful = meaningfulDecisions(atom.decisions);
+    const tools = parseToolCalls(atom.tool_calls);
+    const files = Array.isArray(atom.files_touched) ? atom.files_touched : [];
+    if (meaningful.length > 0) {
+        const content = meaningful.slice(0, 3).join(" · ").slice(0, 500);
+        return { content, decisions: meaningful.slice(0, 15) };
+    }
+    // No usable prose. Fall back to a factual description of the work, but only
+    // when there was real work — a control-flow prompt with no files changed is
+    // not a memory no matter how many tool calls it made.
+    const wrote = tools.filter((t) => ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(t.tool));
+    if (files.length === 0 && wrote.length === 0)
+        return null;
+    if (isControlFlowPrompt(atom.prompt) && files.length === 0)
+        return null;
+    const changed = [...new Set(wrote.map((t) => t.target.split("/").pop()).filter(Boolean))];
+    const subject = changed.length ? changed.slice(0, 5).join(", ") : files.slice(0, 5).join(", ");
+    if (!subject)
+        return null;
+    const task = isControlFlowPrompt(atom.prompt) ? "" : `${atom.prompt.slice(0, 160).trim()} — `;
+    const commit = atom.git_commit ? ` (at ${atom.git_commit})` : "";
+    const content = `${task}changed ${subject}${commit}`.slice(0, 500);
+    return { content, decisions: meaningful };
+}

package/dist/lib/conventions.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Convention derivation — pure logic, no database.
+ *
+ * Kept free of DB imports so the tiering logic and the evaluation harness can
+ * use it without a connection. The persistence side lives in
+ * services/preferences.ts.
+ *
+ * Only records things that are checkable and that repeated. "Runs tests with
+ * vitest" comes from actually seeing `vitest run` N times; the store it
+ * replaced was filled by asking a model for "preferences observed" on every
+ * session, which always answered, and after five months held 101 rows saying
+ * things like "Clean and maintainable code structure".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.norm = exports.CONFIRM_THRESHOLD = void 0;
+exports.deriveObservations = deriveObservations;
+/** A signal must be seen this many times before it is treated as a convention. */
+exports.CONFIRM_THRESHOLD = 3;
+const norm = (s) => (s || "").toLowerCase().replace(/[.!?,;:]+$/g, "").replace(/\s+/g, " ").trim();
+exports.norm = norm;
+const COMMAND_SIGNALS = [
+    { match: /\bvitest\b/, category: "testing", preference: "Runs tests with vitest" },
+    { match: /\bjest\b/, category: "testing", preference: "Runs tests with jest" },
+    { match: /\bpytest\b/, category: "testing", preference: "Runs tests with pytest" },
+    { match: /\bpnpm\s/, category: "tooling", preference: "Uses pnpm as the package manager" },
+    { match: /\byarn\s/, category: "tooling", preference: "Uses yarn as the package manager" },
+    { match: /\bbun\s/, category: "tooling", preference: "Uses bun as the runtime/package manager" },
+    { match: /\bpm2\s/, category: "tooling", preference: "Deploys with pm2" },
+    { match: /\bdocker(?:-compose)?\s/, category: "tooling", preference: "Uses Docker for local services" },
+    { match: /\bturbo\s/, category: "architecture", preference: "Uses Turborepo to orchestrate workspace tasks" },
+    { match: /\btsc\b|\btype-?check\b/, category: "tooling", preference: "Type-checks with tsc before shipping" },
+];
+const FILE_SIGNALS = [
+    { match: /\/migrations?\/\d{3}_[\w-]+\.sql$/, category: "conventions", preference: "Numbered SQL migration files (NNN_name.sql)" },
+    { match: /__tests__\//, category: "testing", preference: "Tests live in __tests__/ directories" },
+    { match: /\.(test|spec)\.[tj]sx?$/, category: "testing", preference: "Tests colocated as *.test.ts alongside source" },
+    { match: /\/components?\/[A-Z][A-Za-z0-9]*\.tsx$/, category: "conventions", preference: "PascalCase component filenames" },
+];
+/**
+ * Derive candidate observations from one session's raw material. Returns one
+ * entry per distinct signal seen — the caller records them, and only signals
+ * that recur across sessions ever reach CONFIRM_THRESHOLD.
+ */
+function deriveObservations(input) {
+    const out = [];
+    const seen = new Set();
+    const add = (o) => {
+        const k = `${o.category}::${(0, exports.norm)(o.preference)}`;
+        if (seen.has(k))
+            return;
+        seen.add(k);
+        out.push(o);
+    };
+    for (const cmd of input.commands || []) {
+        for (const sig of COMMAND_SIGNALS) {
+            if (sig.match.test(cmd)) {
+                add({ category: sig.category, preference: sig.preference, evidence: cmd.slice(0, 200) });
+            }
+        }
+    }
+    for (const file of input.files || []) {
+        for (const sig of FILE_SIGNALS) {
+            if (sig.match.test(file)) {
+                add({ category: sig.category, preference: sig.preference, evidence: file });
+            }
+        }
+    }
+    const conventional = (input.commitMessages || []).filter((m) => /^(feat|fix|chore|refactor|docs|test|perf|style|build|ci)(\([^)]+\))?:/i.test(m));
+    if (conventional.length >= 2) {
+        add({
+            category: "conventions",
+            preference: "Conventional commit prefixes (feat/fix/chore)",
+            evidence: conventional.slice(0, 3).join(" | ").slice(0, 200),
+        });
+    }
+    return out;
+}

package/dist/lib/embed.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelCacheDir = modelCacheDir;
+exports.getEmbedder = getEmbedder;
+exports.embed = embed;
+exports.embedMany = embedMany;
+/**
+ * Local embeddings. bge-small-en-v1.5 via fastembed, on CPU.
+ *
+ * ~190ms per call warm, 417ms to load the model the first time. No API key,
+ * no network, no per-call cost — the text being embedded is often the user's
+ * own source code, and it never leaves the machine.
+ */
+const fastembed_1 = require("fastembed");
+const os_1 = require("os");
+const path_1 = require("path");
+let _embedder = null;
+function modelCacheDir() {
+    return process.env.AGENTIC_MEMORY_MODELS || (0, path_1.join)((0, os_1.homedir)(), ".agentic-memory", "models");
+}
+function getEmbedder() {
+    if (!_embedder) {
+        _embedder = fastembed_1.FlagEmbedding.init({
+            model: fastembed_1.EmbeddingModel.BGESmallENV15,
+            cacheDir: modelCacheDir(),
+        });
+    }
+    return _embedder;
+}
+async function embed(text) {
+    const e = await getEmbedder();
+    for await (const batch of e.embed([text], 1))
+        return Float32Array.from(batch[0]);
+    throw new Error("embedding produced no vector");
+}
+async function embedMany(texts, onProgress) {
+    if (texts.length === 0)
+        return [];
+    const e = await getEmbedder();
+    const out = [];
+    for await (const batch of e.embed(texts, 32)) {
+        for (const v of batch)
+            out.push(Float32Array.from(v));
+        onProgress?.(out.length);
+    }
+    return out;
+}

package/dist/lib/extract.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Transcript → memory, with no LLM and no network call.
+ *
+ * This replaces summarizeTranscript(), which sent transcript.slice(-8000) to
+ * gpt-4o-mini. Two things were wrong with that beyond the vendor dependency:
+ * it read the *tail* of a session (the sign-off, not the decisions), and when
+ * it failed it fell back to storing transcript.slice(-500) verbatim — raw
+ * tool_result JSON, cut mid-word — which then got injected into every
+ * subsequent SessionStart as a "memory".
+ *
+ * The approach here is extractive rather than generative: Claude already
+ * states what it did and why, in prose, inside the transcript. Mining those
+ * statements and ranking them produces better memories than a small model
+ * paraphrasing the last 8KB, costs nothing, adds no latency, and keeps the
+ * user's code on their own infrastructure.
+ *
+ * The other half of the design is that this returns `null` when it finds
+ * nothing worth keeping. A missing memory is strictly better than a poisoned
+ * one; there is no fallback that stores raw text.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMemory = extractMemory;
+// ── statement classification ─────────────────────────────────────────────────
+/** Claude narrating what it is about to do. Never a memory. */
+const NARRATION = /^(let me\b|i'?ll\b|i will\b|i'?m going to\b|now (?:let|i)\b|first,? (?:let|i)\b|reading\b|checking\b|looking\b|running\b|searching\b|scanning\b|here'?s\b|here are\b|okay\b|sure\b|got it\b|perfect\b|great\b)/i;
+/** Structural scaffolding from markdown output. */
+const SCAFFOLD = /^(\||[-=*_]{3,}|#{1,6}\s|\d+\.\s*$|```)/;
+/** Claude stating a completed outcome. */
+const OUTCOME = /^(done|fixed|added|created|removed|updated|refactored|migrated|implemented|configured|wired|built|set up|pushed|published|committed|installed|deployed|disabled|enabled|renamed|dropped|moved|merged|extracted|archived|cleaned|deleted|replaced|switched|reverted|bumped|patched)\b/i;
+/** Explanation of why something is the way it is. */
+const CAUSAL = /\b(root cause|because|the reason|turns? out|which is why|caused by|due to|the bug was|was failing because|the problem was)\b/i;
+/** A concrete before→after change. */
+const CHANGE = /\b(switched from .+ to |replaced .+ with |changed .+ (?:from .+ )?to |moved .+ (?:from .+ )?to |now uses?\b|instead of\b|no longer\b|renamed .+ to )/i;
+/** A durable rule that will still be true next session. */
+const CONSTRAINT = /\b(must (?:be|not|always|never)|cannot be|can'?t be|should (?:always|never)|always (?:use|run|keep)|never (?:use|run|commit)|requires? |only works? (?:if|when)|is required)\b/i;
+/** Looks like it names something real in the codebase. */
+const CODEISH = /(`[^`]+`|\b[\w.-]+\/[\w./-]+\b|\b\w+\.(?:ts|tsx|js|jsx|mjs|sql|json|css|py|go|rb|sh|ya?ml|toml|md)\b|\b[a-z][a-zA-Z0-9]*[A-Z]\w*\b|\b[A-Z_]{3,}\b|\b\w+\(\)|\$\d|\b\d+(?:\.\d+)+\b)/;
+/** Numbers, versions, measurements — specificity signal. */
+const QUANTIFIED = /\b\d+(?:\.\d+)?\s*(?:ms|s|kb|mb|gb|%|x|rows?|files?|px|dims?|tokens?)\b|\bv?\d+\.\d+/i;
+const MIN_LEN = 25;
+const MAX_LEN = 240;
+function scoreStatement(line) {
+    const s = line.trim();
+    if (s.length < MIN_LEN || s.length > MAX_LEN)
+        return -Infinity;
+    if (s.endsWith("?"))
+        return -Infinity;
+    if (SCAFFOLD.test(s))
+        return -Infinity;
+    if (NARRATION.test(s))
+        return -Infinity;
+    let score = 0;
+    if (OUTCOME.test(s))
+        score += 3;
+    if (CAUSAL.test(s))
+        score += 3;
+    if (CHANGE.test(s))
+        score += 2;
+    if (CONSTRAINT.test(s))
+        score += 2;
+    if (CODEISH.test(s))
+        score += 2;
+    if (QUANTIFIED.test(s))
+        score += 1;
+    // A sentence that matched nothing above is prose about nothing in particular.
+    if (score === 0)
+        return -Infinity;
+    // Prefer statements that are specific without being a wall of text.
+    if (s.length > 160)
+        score -= 1;
+    return score;
+}
+/**
+ * Handles both shapes we receive: Claude Code's JSONL transcript, and a plain
+ * concatenated string (what the older hooks posted). Anything unparseable is
+ * treated as prose rather than discarded.
+ */
+function parseTranscript(transcript) {
+    const assistantText = [];
+    const toolCalls = [];
+    let sawJson = false;
+    for (const line of transcript.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("{")) {
+            let row;
+            try {
+                row = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            sawJson = true;
+            const blocks = row?.message?.content;
+            if (row?.type !== "assistant" || !Array.isArray(blocks))
+                continue;
+            for (const b of blocks) {
+                if (b?.type === "text" && typeof b.text === "string") {
+                    assistantText.push(b.text);
+                }
+                else if (b?.type === "tool_use" && typeof b.name === "string") {
+                    const input = b.input || {};
+                    const target = input.file_path || input.path || input.command || input.pattern || "";
+                    toolCalls.push({ tool: b.name, target: String(target).slice(0, 300) });
+                }
+            }
+        }
+    }
+    // Plain-text transcript: keep it whole and let the scorer sort it out.
+    if (!sawJson)
+        assistantText.push(transcript);
+    return { assistantText, toolCalls };
+}
+// ── mining ───────────────────────────────────────────────────────────────────
+/**
+ * Claude's markdown output is line-oriented, but a plain-text transcript is
+ * not — a paragraph arrives as one long line that would blow past MAX_LEN and
+ * be discarded whole. Split on newlines first, then on sentence boundaries for
+ * anything still too long to score.
+ */
+function splitStatements(text) {
+    const lines = text
+        .split("\n")
+        .map((l) => l
+        .replace(/^[-•*]\s+/, "")
+        .replace(/^\d+\.\s+/, "")
+        .replace(/[*`#>]/g, "")
+        .trim())
+        .filter(Boolean);
+    const out = [];
+    for (const line of lines) {
+        if (line.length <= MAX_LEN) {
+            out.push(line);
+            continue;
+        }
+        for (const sentence of line.split(/(?<=[.!?])\s+/)) {
+            const trimmed = sentence.trim();
+            if (trimmed)
+                out.push(trimmed);
+        }
+    }
+    return out;
+}
+function normalizeKey(s) {
+    return s.toLowerCase().replace(/[^a-z0-9 ]/g, "").replace(/\s+/g, " ").trim();
+}
+/** Dependencies, commits and config changes are facts, not prose — read them
+ *  off the tool calls rather than hoping Claude mentioned them. */
+function factsFromTools(toolCalls) {
+    const facts = [];
+    const seen = new Set();
+    const push = (f) => {
+        const k = normalizeKey(f);
+        if (!seen.has(k)) {
+            seen.add(k);
+            facts.push(f);
+        }
+    };
+    for (const tc of toolCalls) {
+        if (tc.tool !== "Bash")
+            continue;
+        const cmd = tc.target;
+        const dep = cmd.match(/\b(?:npm|pnpm|yarn|bun)\s+(?:install|add)\s+(-{1,2}\S+\s+)*([^\s&|;]+)/);
+        if (dep?.[2] && !dep[2].startsWith("-"))
+            push(`dependency: added ${dep[2]}`);
+        const commit = cmd.match(/git commit[^"']*["']([^"']{6,120})["']/);
+        if (commit?.[1])
+            push(`commit: ${commit[1]}`);
+        if (/\b(psql|migrate|migration)\b/.test(cmd)) {
+            const mig = cmd.match(/(\d{3}_[\w-]+\.sql)/);
+            if (mig?.[1])
+                push(`migration: applied ${mig[1]}`);
+        }
+    }
+    for (const tc of toolCalls) {
+        if ((tc.tool === "Write" || tc.tool === "Edit") && /\.env/.test(tc.target)) {
+            push(`config: modified ${tc.target.split("/").pop()}`);
+        }
+    }
+    return facts;
+}
+function filesFromTools(toolCalls) {
+    const files = new Set();
+    for (const tc of toolCalls) {
+        if (!["Write", "Edit", "MultiEdit", "NotebookEdit", "Read"].includes(tc.tool))
+            continue;
+        const t = tc.target;
+        if (t && /\.\w{1,5}$/.test(t) && !t.includes(" "))
+            files.add(t);
+    }
+    return [...files].slice(0, 40);
+}
+// ── composition ──────────────────────────────────────────────────────────────
+/**
+ * The indexed memory body. Built from the highest-scoring statements rather
+ * than a positional slice, so it reflects what the session concluded instead
+ * of where it happened to stop.
+ */
+function composeContent(ranked, files) {
+    const parts = [];
+    let budget = 420;
+    for (const s of ranked) {
+        const clean = s.endsWith(".") ? s : `${s}.`;
+        if (clean.length > budget)
+            break;
+        parts.push(clean);
+        budget -= clean.length + 1;
+        if (parts.length >= 3)
+            break;
+    }
+    if (parts.length === 0)
+        return "";
+    const areas = summariseAreas(files);
+    return areas ? `${parts.join(" ")} (${areas})` : parts.join(" ");
+}
+function summariseAreas(files) {
+    const areas = new Set();
+    for (const f of files) {
+        if (/\/components?\//.test(f))
+            areas.add("components");
+        if (/\/routes?\//.test(f))
+            areas.add("API routes");
+        if (/\/hooks?\//.test(f))
+            areas.add("hooks");
+        if (/\/migrations?\//.test(f))
+            areas.add("migrations");
+        if (/\.(test|spec)\.|__tests__/.test(f))
+            areas.add("tests");
+        if (/\/lib\//.test(f))
+            areas.add("lib");
+    }
+    return [...areas].slice(0, 3).join(", ");
+}
+// ── entry point ──────────────────────────────────────────────────────────────
+/**
+ * Returns null when the transcript yields nothing durable. Callers must treat
+ * null as "do not save" — there is deliberately no raw-text fallback.
+ */
+function extractMemory(transcript) {
+    if (!transcript || transcript.trim().length < 100)
+        return null;
+    const { assistantText, toolCalls } = parseTranscript(transcript);
+    if (assistantText.length === 0 && toolCalls.length === 0)
+        return null;
+    // Rank every candidate statement across the whole transcript. Deliberately
+    // not restricted to the tail: the diagnosis and the tradeoff are usually
+    // made in the middle of a session, and the tail is the sign-off.
+    const scored = [];
+    const seen = new Set();
+    for (const text of assistantText) {
+        for (const stmt of splitStatements(text)) {
+            const score = scoreStatement(stmt);
+            if (score === -Infinity)
+                continue;
+            const key = normalizeKey(stmt);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            scored.push({ text: stmt, score });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const facts = factsFromTools(toolCalls);
+    const files = filesFromTools(toolCalls);
+    const ranked = scored.map((s) => s.text);
+    const content = composeContent(ranked, files);
+    // The bar for saving anything at all. Any one of these is durable evidence
+    // that something happened worth remembering:
+    //   - a statement that scored on substance
+    //   - a hard fact read off the tool calls (a dependency, a commit)
+    //   - files actually written or edited
+    // A turn with none of the three produced nothing to remember.
+    const strong = scored.filter((s) => s.score >= 3);
+    const wroteFiles = toolCalls.some((t) => ["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(t.tool));
+    if (strong.length === 0 && facts.length === 0 && !wroteFiles)
+        return null;
+    const decisions = [...facts, ...ranked.slice(0, 12)].slice(0, 15);
+    // Files changed but nobody said anything quotable — record that factually
+    // rather than dropping the turn.
+    const body = content ||
+        (facts.length ? facts.slice(0, 3).join(" · ") : "") ||
+        (files.length ? `changed ${[...new Set(files.map((f) => f.split("/").pop()))].slice(0, 5).join(", ")}` : "");
+    if (!body)
+        return null;
+    const problems = scored
+        .filter((s) => CAUSAL.test(s.text))
+        .slice(0, 5)
+        .map((s) => s.text);
+    return {
+        content: body,
+        decisions,
+        files_touched: files,
+        problems_solved: problems,
+    };
+}

package/dist/lib/maintain.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertProject = void 0;
+exports.maintain = maintain;
+/**
+ * Maintenance: supersede, tier, derive facts.
+ *
+ * On the hosted version this was a nightly cron. Locally there is nothing to
+ * schedule against, so it runs opportunistically — cheap enough to do on
+ * SessionStart when it has not run recently.
+ */
+const db_1 = require("../db");
+Object.defineProperty(exports, "upsertProject", { enumerable: true, get: function () { return db_1.upsertProject; } });
+const tiers_1 = require("./tiers");
+const MIN_INTERVAL_MS = 6 * 60 * 60 * 1000;
+function toTierAtom(r) {
+    const parse = (s) => {
+        try {
+            const v = JSON.parse(s);
+            return Array.isArray(v) ? v : [];
+        }
+        catch {
+            return [];
+        }
+    };
+    return {
+        id: String(r.id),
+        project_id: String(r.project_id),
+        prompt: r.prompt,
+        content: r.content,
+        decisions: parse(r.decisions),
+        files_touched: parse(r.files),
+        tool_calls: parse(r.tool_calls),
+        git_commit: r.git_commit,
+        started_at: r.started_at,
+        confidence: r.confidence,
+    };
+}
+function maintain(force = false) {
+    const last = Number((0, db_1.getMeta)("last_maintain") ?? 0);
+    if (!force && Date.now() - last < MIN_INTERVAL_MS)
+        return null;
+    const conn = (0, db_1.db)();
+    const rows = (0, db_1.liveMemories)().map(toTierAtom);
+    // Supersede first, then tier what survives, then derive tier 1 from the
+    // live set. Order matters: a superseded memory must not shape the facts.
+    const sup = (0, tiers_1.findSupersessions)(rows);
+    const supStmt = conn.prepare("UPDATE memories SET superseded_at = datetime('now'), superseded_by = ? WHERE id = ?");
+    conn.transaction(() => {
+        for (const s of sup)
+            supStmt.run(Number(s.by), Number(s.superseded));
+    })();
+    const supersededIds = new Set(sup.map((s) => s.superseded));
+    const live = rows.filter((r) => !supersededIds.has(r.id));
+    const tierStmt = conn.prepare("UPDATE memories SET tier = ? WHERE id = ?");
+    let tier2 = 0;
+    conn.transaction(() => {
+        for (const r of live) {
+            const t = (0, tiers_1.assignTier)(r);
+            if (t === 2)
+                tier2++;
+            tierStmt.run(t, Number(r.id));
+        }
+    })();
+    const byProject = new Map();
+    for (const r of live) {
+        const list = byProject.get(r.project_id);
+        if (list)
+            list.push(r);
+        else
+            byProject.set(r.project_id, [r]);
+    }
+    let facts = 0;
+    for (const [projectId, atoms] of byProject) {
+        const derived = (0, tiers_1.deriveProjectFacts)(atoms);
+        (0, db_1.replaceFacts)(Number(projectId), derived);
+        facts += derived.length;
+    }
+    (0, db_1.setMeta)("last_maintain", String(Date.now()));
+    return { superseded: sup.length, tier2, facts };
+}