pi-mega-compact 0.4.28 → 0.5.1

package/dist/src/memory.test.js

@@ -0,0 +1,41 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { reviewConversation } from "./memory.js";
+test("reviewConversation: yields an ADD op for a stated decision", () => {
+    const msgs = [
+        { role: "user", text: "we use node:sqlite as the store" },
+        { role: "assistant", text: "got it, node:sqlite is the source of truth" },
+    ];
+    const ops = reviewConversation(msgs);
+    assert.ok(ops.some((o) => o.op === "add" && /sqlite|store/i.test(o.memory.content)), "adds a decision memory");
+});
+test("reviewConversation: REPLACE when a later message contradicts an earlier one", () => {
+    const msgs = [
+        { role: "user", text: "the threshold is 50k" },
+        { role: "assistant", text: "ok 50k threshold" },
+        { role: "user", text: "actually raise the threshold to 100k" },
+    ];
+    const ops = reviewConversation(msgs);
+    assert.ok(ops.some((o) => o.op === "replace"), "replaces the superseded value");
+});
+test("reviewConversation: no ops on pure smalltalk (no durable fact)", () => {
+    const msgs = [{ role: "user", text: "hi" }, { role: "assistant", text: "hey" }];
+    assert.equal(reviewConversation(msgs).length, 0);
+});
+test("reviewConversation: emits REMOVE when a user asks to drop an existing memory", () => {
+    const existing = [{ content: "we use node:sqlite as the store" }];
+    // Plain drop statement — no "switch to …" phrasing so we don't accidentally
+    // match DECISION_PATTERNS and route into the replace branch instead.
+    const msgs = [
+        { role: "user", text: "stop using node:sqlite for the store — drop it from memory" },
+        { role: "assistant", text: "ok dropped" },
+    ];
+    const ops = reviewConversation(msgs, existing);
+    assert.ok(ops.some((o) => o.op === "remove" && /sqlite/i.test(o.content)), "emits a remove op targeting the old memory");
+});
+test("reviewConversation: REMOVE requires topic overlap (no accidental drop)", () => {
+    const existing = [{ content: "the timezone is America/Los_Angeles" }];
+    const msgs = [{ role: "user", text: "drop it" }];
+    const ops = reviewConversation(msgs, existing);
+    assert.equal(ops.filter((o) => o.op === "remove").length, 0, "vague 'drop it' with no topic overlap does not remove anything");
+});

package/dist/src/memoryConsolidate.test.js

@@ -0,0 +1,38 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { consolidateMemories } from "./memory.js";
+import { addMemory, listMemories } from "./store/sqlite.js";
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-consolidate-"));
+test("consolidateMemories: merges near-duplicate memories (one kept, one removed)", async () => {
+    const dir = join(baseTmp, "merge");
+    // Two near-identical memories — same topic, minor wording drift.
+    addMemory({ content: "we use node:sqlite as the store", category: "decision" }, null, dir);
+    addMemory({ content: "we use node:sqlite for our store", category: "decision" }, null, dir);
+    const merged = await consolidateMemories(dir);
+    assert.equal(merged, 1, "one merge was performed");
+    const rows = listMemories(null, 50, dir);
+    // Exactly one of the two near-dupes survives.
+    assert.equal(rows.length, 1, "exactly one memory remains after merge");
+    assert.match(rows[0].content, /node:sqlite.*store/i, "survivor mentions node:sqlite + store");
+});
+test("consolidateMemories: leaves unrelated memories alone", async () => {
+    const dir = join(baseTmp, "noop");
+    addMemory({ content: "we use node:sqlite as the store", category: "decision" }, null, dir);
+    addMemory({ content: "the gpt-5 release is on hold pending benchmark results", category: "note" }, null, dir);
+    const merged = await consolidateMemories(dir);
+    assert.equal(merged, 0, "no merges on unrelated memories");
+    const rows = listMemories(null, 50, dir);
+    assert.equal(rows.length, 2, "both memories survive");
+});
+test("consolidateMemories: empty store returns 0 and changes nothing", async () => {
+    const dir = join(baseTmp, "empty");
+    const merged = await consolidateMemories(dir);
+    assert.equal(merged, 0, "no merges on empty store");
+    assert.equal(listMemories(null, 50, dir).length, 0, "store still empty");
+});
+test("cleanup memops", () => {
+    rmSync(baseTmp, { recursive: true, force: true });
+});

package/dist/src/memoryOps.js

@@ -0,0 +1,58 @@
+import { addMemory, listMemories, replaceMemory, removeMemory, } from "./store/sqlite.js";
+/** Find a memory row whose content exactly matches (case-insensitive). */
+function findByContent(memories, content) {
+    const norm = content.trim().toLowerCase();
+    return memories.find((m) => m.content.trim().toLowerCase() === norm);
+}
+/**
+ * Apply add/replace/remove ops to the memories table. Replaces are matched by
+ * existing content; removes by content. Idempotent: an add that already exists
+ * is a no-op, a replace of a missing memory degrades to an add.
+ */
+export async function applyMemoryOps(ops, stateDir) {
+    if (!ops.length)
+        return;
+    const repo = null; // memories are repo-scoped by stateDir, not by the repo arg here
+    const existing = listMemories(repo, 1000, stateDir);
+    for (const op of ops) {
+        if (op.op === "add") {
+            // Skip if an identical memory already exists.
+            if (findByContent(existing, op.memory.content))
+                continue;
+            addMemory({
+                kind: op.memory.category,
+                content: op.memory.content,
+                tags: [],
+                category: op.memory.category,
+                target: op.memory.target,
+                sourceTurn: op.memory.sourceTurn,
+            }, repo, stateDir);
+        }
+        else if (op.op === "replace") {
+            const match = findByContent(existing, op.targetContent);
+            if (match) {
+                replaceMemory(match.id, {
+                    kind: op.memory.category,
+                    content: op.memory.content,
+                    category: op.memory.category,
+                    sourceTurn: op.memory.sourceTurn,
+                }, stateDir);
+            }
+            else {
+                // Target missing (e.g. earlier in-conversation contradiction) → add.
+                addMemory({
+                    kind: op.memory.category,
+                    content: op.memory.content,
+                    tags: [],
+                    category: op.memory.category,
+                    sourceTurn: op.memory.sourceTurn,
+                }, repo, stateDir);
+            }
+        }
+        else {
+            const match = findByContent(existing, op.content);
+            if (match)
+                removeMemory(match.id, stateDir);
+        }
+    }
+}

package/dist/src/memoryOps.test.js

@@ -0,0 +1,41 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { applyMemoryOps } from "./memoryOps.js";
+import { addMemory, listMemories } from "./store/sqlite.js";
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-memops-"));
+test("applyMemoryOps: ADD inserts a new memory", async () => {
+    const dir = join(baseTmp, "add");
+    await applyMemoryOps([{ op: "add", memory: { content: "we use node:sqlite as the store", category: "decision", sourceTurn: 0 } }], dir);
+    const rows = listMemories(null, 50, dir);
+    assert.ok(rows.some((m) => /node:sqlite/.test(m.content)), "added memory present");
+    assert.equal(rows[0].category, "decision", "category persisted");
+});
+test("applyMemoryOps: ADD is idempotent (no duplicate)", async () => {
+    const dir = join(baseTmp, "dup");
+    const op = { op: "add", memory: { content: "threshold is 50k", category: "decision", sourceTurn: 0 } };
+    await applyMemoryOps([op], dir);
+    await applyMemoryOps([op], dir);
+    const rows = listMemories(null, 50, dir);
+    assert.equal(rows.filter((m) => /threshold is 50k/.test(m.content)).length, 1, "no duplicate");
+});
+test("applyMemoryOps: REPLACE updates the matching memory", async () => {
+    const dir = join(baseTmp, "replace");
+    addMemory({ content: "the threshold is 50k", category: "decision" }, null, dir);
+    await applyMemoryOps([{ op: "replace", targetContent: "the threshold is 50k", memory: { content: "the threshold is 100k", category: "decision", sourceTurn: 2 } }], dir);
+    const rows = listMemories(null, 50, dir);
+    assert.ok(rows.some((m) => /100k/.test(m.content)), "replaced content present");
+    assert.ok(!rows.some((m) => /50k/.test(m.content)), "old content gone");
+});
+test("applyMemoryOps: REMOVE deletes the matching memory", async () => {
+    const dir = join(baseTmp, "remove");
+    addMemory({ content: "obsolete note", category: "note" }, null, dir);
+    await applyMemoryOps([{ op: "remove", content: "obsolete note" }], dir);
+    const rows = listMemories(null, 50, dir);
+    assert.ok(!rows.some((m) => /obsolete note/.test(m.content)), "removed");
+});
+test("cleanup memops", () => {
+    rmSync(baseTmp, { recursive: true, force: true });
+});

package/dist/src/memoryRecall.js

@@ -0,0 +1,60 @@
+/**
+ * memoryRecall.ts — semantic recall over the durable memories table (S21).
+ * Embeds a query with the same local embedder used by RAPTOR, ranks every
+ * memory in the current repo's SQLite by cosine similarity combined with a
+ * category-weighted + recency-boosted score, and returns the top-k. Side
+ * effect: marks returned memories as referenced (last_referenced) so drift
+ * can be measured. PREVENT-PI-004 — embedder is the same local one used
+ * everywhere else; no remote calls are introduced here.
+ * @module
+ */
+import { defaultEmbedder, cosineSimilarity } from "./embedder.js";
+import { listMemories, referenceMemory } from "./store/sqlite.js";
+/** Default category weights — `decision` wins ties on tied cosine. */
+export const DEFAULT_CATEGORY_WEIGHTS = {
+    decision: 1.10,
+    preference: 1.05,
+    fact: 1.0,
+};
+const DEFAULT_RECENCY_WEIGHT = 0.05;
+/**
+ * Rank memories by a blended score of cosine similarity, category weight, and
+ * recency of last_referenced (with createdAt as a fallback). Returns the
+ * top-k above minSimilarity, sorted by blended score descending. Empty on
+ * no matches.
+ */
+export async function recallMemories(query, stateDir, opts = {}) {
+    const topK = opts.topK ?? 10;
+    const minSimilarity = opts.minSimilarity ?? 0.2;
+    const markReferenced = opts.markReferenced ?? true;
+    const embedder = opts.embedder ?? defaultEmbedder();
+    const repo = opts.repo === undefined ? null : opts.repo;
+    const categoryWeights = { ...DEFAULT_CATEGORY_WEIGHTS, ...(opts.categoryWeights ?? {}) };
+    const recencyWeight = opts.recencyWeight ?? DEFAULT_RECENCY_WEIGHT;
+    const queryVec = embedder.embed(query);
+    const memories = listMemories(repo, 1000, stateDir);
+    if (!memories.length || !query.trim())
+        return [];
+    const nowSec = Math.floor(Date.now() / 1000);
+    const scored = [];
+    for (const mem of memories) {
+        const vec = embedder.embed(mem.content);
+        const sim = cosineSimilarity(queryVec, vec);
+        if (sim < minSimilarity)
+            continue;
+        const categoryW = categoryWeights[mem.category ?? "fact"] ?? 1.0;
+        const lastTouch = mem.lastReferenced ?? mem.createdAt ?? nowSec;
+        // log(1 + daysSince) grows slowly — half-life-style decay.
+        const daysSince = Math.max(0, (nowSec - lastTouch) / 86_400);
+        const recencyBoost = Math.log1p(daysSince) * recencyWeight;
+        const finalScore = sim * categoryW * (1 + recencyBoost);
+        scored.push({ memory: mem, score: finalScore });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, topK);
+    if (markReferenced) {
+        for (const hit of top)
+            referenceMemory(hit.memory.id, stateDir);
+    }
+    return top;
+}

package/dist/src/memoryRecall.test.js

@@ -0,0 +1,92 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { recallMemories } from "./memoryRecall.js";
+import { addMemory, getMemory } from "./store/sqlite.js";
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-memrec-"));
+function biGramEmbedder() {
+    // Deterministic test embedder — bigger dim + binary encoding so two semantically
+    // related strings have higher cosine than unrelated ones.
+    const dim = 64;
+    return {
+        dim,
+        embed(text) {
+            const v = new Array(dim).fill(0);
+            const norm = text.toLowerCase().replace(/[^a-z0-9 ]/g, "").trim();
+            for (let i = 0; i < norm.length - 1; i++) {
+                const idx = ((norm.charCodeAt(i) * 31 + norm.charCodeAt(i + 1)) >>> 0) % dim;
+                v[idx] = 1;
+            }
+            return v;
+        },
+    };
+}
+test("recallMemories: ranks relevant memory above unrelated", async () => {
+    const dir = join(baseTmp, "rank");
+    addMemory({ content: "we use sqlite for the durable store", category: "decision" }, null, dir);
+    addMemory({ content: "the threshold is 100 thousand tokens", category: "decision" }, null, dir);
+    addMemory({ content: "katz says hi", category: "note" }, null, dir);
+    const hits = await recallMemories("what store do we use?", dir, {
+        embedder: biGramEmbedder(),
+        topK: 3,
+        minSimilarity: 0.0,
+    });
+    assert.ok(hits.length >= 2, "finds relevant");
+    assert.ok(/sqlite/.test(hits[0].memory.content), "top hit is sqlite one");
+    assert.ok(!/katz/.test(hits[0].memory.content), "unrelated not on top");
+});
+test("recallMemories: marks referenced hits (last_referenced updated)", async () => {
+    const dir = join(baseTmp, "ref");
+    addMemory({ content: "policy is local-only", category: "rule" }, null, dir);
+    const hits = await recallMemories("local-only policy", dir, { embedder: biGramEmbedder() });
+    assert.ok(hits.length >= 1);
+    const fresh = getMemory(hits[0].memory.id, dir);
+    assert.ok(fresh && fresh.lastReferenced && fresh.lastReferenced > 0, "lastReferenced set");
+});
+test("recallMemories: empty store returns []", async () => {
+    const dir = join(baseTmp, "empty");
+    const hits = await recallMemories("anything", dir, { embedder: biGramEmbedder() });
+    assert.deepEqual(hits, []);
+});
+test("recallMemories: decision category beats fact category at equal similarity", async () => {
+    const dir = join(baseTmp, "category");
+    // Two memories that share many bigrams with the query — both will have very
+    // similar cosine. The decision category should win because of categoryWeight.
+    addMemory({ content: "we use redis for cache" }, null, dir);
+    const aId = addMemory({ content: "we use redis as primary cache key", category: "fact" }, null, dir);
+    const dId = addMemory({ content: "we use redis as primary cache layer", category: "decision" }, null, dir);
+    const hits = await recallMemories("redis cache layer", dir, {
+        embedder: biGramEmbedder(),
+        topK: 3,
+        minSimilarity: 0.0,
+    });
+    assert.ok(hits.length >= 2);
+    assert.equal(hits[0].memory.id, dId, "decision-tagged memory outranks fact-tagged");
+    assert.notEqual(hits[0].memory.id, aId, "top is the decision row, not the unknown-category row");
+});
+test("recallMemories: fresher reference beats older at equal similarity", async () => {
+    const dir = join(baseTmp, "recency");
+    const aId = addMemory({ content: "we use redis for cache", category: "fact" }, null, dir);
+    const bId = addMemory({ content: "we use redis for cache layer", category: "fact" }, null, dir);
+    // Backdate aId so its last_referenced is older; bId stays fresh.
+    const { openStore, closeStore } = await import("./store/sqlite.js");
+    const db = openStore(dir);
+    const longAgo = Math.floor(Date.now() / 1000) - 30 * 86_400; // 30d
+    db.prepare("UPDATE memories SET last_referenced = ? WHERE id = ?").run(longAgo, aId);
+    // closeStore evicts the cached handle — calling db.close() directly would
+    // leave a stale closed DB in the openStore cache and break subsequent
+    // callers (the "database is not open" failure under parallel runs).
+    closeStore(dir);
+    const hits = await recallMemories("redis cache layer", dir, {
+        embedder: biGramEmbedder(),
+        topK: 3,
+        minSimilarity: 0.0,
+    });
+    assert.ok(hits.length >= 2);
+    assert.equal(hits[0].memory.id, bId, "freshly-referenced memory outranks 30-day-old one");
+});
+test("cleanup memrec", () => {
+    rmSync(baseTmp, { recursive: true, force: true });
+});

package/dist/src/recall.js

@@ -22,7 +22,11 @@ export function formatRecallBlock(hits) {
         return "";
     const parts = hits.map((h, i) => {
         const score = (h.score * 100).toFixed(0);
-        return (`### Recalled context [${i + 1}] (relevance ${score}%)\n` +
+        // S17: label a cross-repo hit with its source repo (the repoId doubles as
+        // that repo's stateDir, so the last path segment is the repo's display
+        // name). Same-repo hits (no repoId) stay unlabeled.
+        const repoName = h.repoId ? ` (from repo ${h.repoId.split("/").filter(Boolean).pop() ?? h.repoId})` : "";
+        return (`### Recalled context [${i + 1}] (relevance ${score}%)${repoName}\n` +
             `${h.checkpoint.summary.trim()}\n` +
             (h.checkpoint.filesModified.length
                 ? `Key files: ${h.checkpoint.filesModified.join(", ")}.\n`
@@ -84,6 +88,47 @@ export function recallAndInline(opts, store) {
         empty: toInject.length === 0,
     };
 }
+/** Format one memory hit for the recall block. Category + score for traceability. */
+export function formatMemoryRecallBlock(hits) {
+    if (hits.length === 0)
+        return "";
+    const parts = hits.map((h, i) => {
+        const pct = (h.score * 100).toFixed(0);
+        const cat = h.category ? `[${h.category}] ` : "";
+        return `### Recalled memory [${i + 1}] (relevance ${pct}%)\n${cat}${h.content.trim()}`;
+    });
+    return ("The following facts about this project were saved from earlier turns " +
+        "and are relevant to the current request. Treat them as established:\n\n" +
+        parts.join("\n"));
+}
+/** Recall top-k durable memories, format into a token-capped block. */
+export async function recallMemoriesAndInline(opts) {
+    const limit = opts.limit ?? 5;
+    const maxTokens = opts.recallMaxTokens ?? 0;
+    const { recallMemories } = await import("./memoryRecall.js");
+    const hits = await recallMemories(opts.query, opts.stateDir, {
+        topK: limit,
+        minSimilarity: opts.minSimilarity ?? 0.2,
+    });
+    if (hits.length === 0)
+        return { empty: true, block: "", report: [] };
+    // Same incremental token cap pattern as checkpoint recall.
+    const parts = [];
+    const report = [];
+    let blockTokens = 0;
+    for (const h of hits) {
+        const part = formatMemoryRecallBlock([
+            { content: h.memory.content, category: h.memory.category, score: h.score },
+        ]);
+        const partTokens = estimateBlockTokens(part);
+        if (maxTokens > 0 && blockTokens + partTokens > maxTokens)
+            break;
+        parts.push(part);
+        report.push(`  • memory#${h.memory.id} (${(h.score * 100).toFixed(0)}%): ${h.memory.content.slice(0, 60).replace(/\n/g, " ")}…`);
+        blockTokens += partTokens;
+    }
+    return { empty: parts.length === 0, block: parts.join("\n"), report };
+}
 /**
  * Slice 2 async cross-repo recall. Same dedup/bound/inline contract as
  * `recallAndInline`, but backed by `VectorStore.searchAsync` so it can recall
@@ -121,6 +166,19 @@ export async function recallAndInlineAsync(opts, store) {
     for (const h of hits) {
         if (skip && store.wasInjected(opts.sessionId, h.checkpoint.checkpointId))
             continue;
+        // S18: machine-wide injected-set — a foreign checkpoint already injected
+        // (in any session) is never re-injected. Only applies to cross-repo hits
+        // (same-repo hits have no repoId and are handled by the per-session set).
+        if (opts.globalIndexDir && h.repoId) {
+            try {
+                const { wasInjectedGlobal } = await import("./store/sqlite.js");
+                if (wasInjectedGlobal(h.checkpoint.checkpointId, opts.sessionId, opts.globalIndexDir))
+                    continue;
+            }
+            catch {
+                /* non-fatal: degrade to per-session injected-set only */
+            }
+        }
         if (doWindowDedupe && liveEmbeddings.length > 0) {
             const hitVec = defaultEmbedder().embed(h.checkpoint.summary);
             if (liveEmbeddings.some((v) => cosineSimilarity(v, hitVec) >= dedupSim))
@@ -134,6 +192,17 @@ export async function recallAndInlineAsync(opts, store) {
         toInject.push(h);
         blockTokens += partTokens;
         store.markInjected(opts.sessionId, h.checkpoint.checkpointId);
+        // S18: record the cross-repo injection machine-wide so it's not re-injected
+        // by a later recall (same or different session).
+        if (opts.globalIndexDir && h.repoId) {
+            try {
+                const { markInjectedGlobal } = await import("./store/sqlite.js");
+                markInjectedGlobal(h.checkpoint.checkpointId, h.repoId, opts.sessionId, opts.globalIndexDir);
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
     }
     const block = parts.join("\n");
     const report = toInject.map((h) => `  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`);

package/dist/src/recall.test.js

@@ -5,7 +5,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { VectorStore } from "./vectorStore.js";
 import { compactSession } from "./engine.js";
-import { recallAndInline, formatRecallBlock } from "./recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "./recall.js";
+import { markInjectedGlobal, wasInjectedGlobal, closeIndexStore } from "./store/sqlite.js";
 const baseTmp = mkdtempSync(join(tmpdir(), "mc-recall-"));
 let counter = 0;
 function store() {
@@ -39,6 +40,24 @@ test("recallAndInline skipInjected=false re-returns hits", () => {
 test("formatRecallBlock is empty for no hits", () => {
     assert.equal(formatRecallBlock([]), "");
 });
+test("formatRecallBlock (S17): labels a cross-repo hit with its source repo", () => {
+    const hit = {
+        checkpoint: { checkpointId: "chkpt_x", summary: "did thing Y", filesModified: ["a.ts"] },
+        score: 0.91,
+        repoId: "/home/u/rad-gateway",
+    };
+    const block = formatRecallBlock([hit]);
+    assert.ok(block.includes("from repo"), "labels cross-repo source");
+    assert.ok(block.includes("rad-gateway"), "includes the repo display name");
+});
+test("formatRecallBlock (S17): omits the label for same-repo hits (no repoId)", () => {
+    const hit = {
+        checkpoint: { checkpointId: "c1", summary: "s", filesModified: [] },
+        score: 0.9,
+    };
+    const block = formatRecallBlock([hit]);
+    assert.ok(!block.includes("from repo"), "no source label for same-repo hits");
+});
 test("recallAndInline empty when store has nothing for query", () => {
     const s = store();
     const r = recallAndInline({ sessionId: SESS, query: "no such topic exists here", limit: 5, source: "command" }, s);
@@ -73,6 +92,55 @@ test("Fix C: inline dedupe drops a hit already resident in the live window", ()
     assert.ok(rDedup.toInject.length <= rNoDedup.toInject.length, "dedupe never adds hits");
     assert.ok(rDedup.toInject.length < rNoDedup.toInject.length, "inline dedupe dropped a resident hit");
 });
+test("S18: global injected-set skips a foreign checkpoint already injected machine-wide", async () => {
+    const indexDir = mkdtempSync(join(tmpdir(), "mc-gi-"));
+    try {
+        const sess = "sess_cross";
+        // A foreign checkpoint already marked injected globally (in this session).
+        markInjectedGlobal("chkpt_foreign", "/repo/other", sess, indexDir);
+        assert.equal(wasInjectedGlobal("chkpt_foreign", sess, indexDir), true);
+        // searchAsync returns the foreign hit; recallAndInlineAsync must skip it
+        // (globally injected) → toInject is empty.
+        const mockStore = {
+            searchAsync: async () => [{
+                    checkpoint: { checkpointId: "chkpt_foreign", summary: "foreign work", filesModified: [], dedupStatus: "active" },
+                    score: 0.92,
+                    repoId: "/repo/other",
+                }],
+            wasInjected: () => false,
+            markInjected: () => { },
+        };
+        const r = await recallAndInlineAsync({ sessionId: sess, query: "foreign", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir }, mockStore);
+        assert.equal(r.toInject.length, 0, "globally-injected foreign checkpoint skipped");
+    }
+    finally {
+        closeIndexStore();
+        rmSync(indexDir, { recursive: true, force: true });
+    }
+});
+test("S18: a fresh foreign checkpoint is injected AND recorded globally", async () => {
+    const indexDir = mkdtempSync(join(tmpdir(), "mc-gi2-"));
+    try {
+        const sess = "sess_fresh";
+        assert.equal(wasInjectedGlobal("chkpt_new", sess, indexDir), false);
+        const mockStore = {
+            searchAsync: async () => [{
+                    checkpoint: { checkpointId: "chkpt_new", summary: "brand new foreign work", filesModified: [], dedupStatus: "active" },
+                    score: 0.93,
+                    repoId: "/repo/alpha",
+                }],
+            wasInjected: () => false,
+            markInjected: () => { },
+        };
+        const r = await recallAndInlineAsync({ sessionId: sess, query: "foreign", limit: 3, source: "command", crossRepo: true, globalIndexDir: indexDir }, mockStore);
+        assert.equal(r.toInject.length, 1, "fresh foreign checkpoint injected");
+        assert.equal(wasInjectedGlobal("chkpt_new", sess, indexDir), true, "recorded machine-wide");
+    }
+    finally {
+        closeIndexStore();
+        rmSync(indexDir, { recursive: true, force: true });
+    }
+});
 test("cleanup", () => {
     rmSync(baseTmp, { recursive: true, force: true });
 });