muonroi-cli 1.3.4 → 1.4.1

package/dist/src/ee/__tests__/export-transcripts.test.js

@@ -0,0 +1,200 @@
+/**
+ * export-transcripts.test.ts
+ *
+ * Unit tests for exportTranscripts() — SQLite → JSONL transcript export.
+ *
+ * Strategy: redirect USERPROFILE (Windows) / HOME (POSIX) to a temp dir,
+ * create a real SQLite DB at `~/.muonroi-cli/muonroi.db`, and call the
+ * function.  Also creates `~/.experience/config.json` so the emit sidecar
+ * (transcript-emit) does not gate-return null.
+ */
+import { Database } from "bun:sqlite";
+// @ts-expect-error — bun:test is provided by the bun runtime; this file runs
+// via `bun test`, not vitest (vitest cannot resolve bun:sqlite's `db.run` API).
+// Excluded from vitest in vitest.config.ts.
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+let tmpHome = "";
+let origUserProfile;
+function cleanDb() {
+    if (tmpHome) {
+        try {
+            rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+        }
+        catch {
+            /* ok */
+        }
+    }
+}
+function bootstrapDb(sessions) {
+    const dbDir = join(tmpHome, ".muonroi-cli");
+    const dbPath = join(dbDir, "muonroi.db");
+    mkdirSync(dbDir, { recursive: true });
+    const db = new Database(dbPath, { create: true });
+    db.run("CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, updated_at TEXT NOT NULL, cwd_last TEXT DEFAULT NULL)");
+    db.run("CREATE TABLE IF NOT EXISTS messages (session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE, seq INTEGER NOT NULL, role TEXT NOT NULL, message_json TEXT NOT NULL, created_at TEXT DEFAULT NULL, status TEXT DEFAULT NULL)");
+    for (const s of sessions) {
+        db.run("INSERT INTO sessions (id, updated_at, cwd_last) VALUES (?, ?, ?)", [s.sessionId, s.updatedAt, s.cwdLast]);
+        for (const m of s.messages) {
+            db.run("INSERT INTO messages (session_id, seq, role, message_json) VALUES (?, ?, ?, ?)", [
+                s.sessionId,
+                m.seq,
+                m.role,
+                m.messageJson,
+            ]);
+        }
+    }
+    db.close();
+}
+beforeEach(() => {
+    tmpHome = join(tmpdir(), "muonroi-test-export-" + Date.now());
+    const muonroiDir = join(tmpHome, ".muonroi-cli");
+    const experienceDir = join(tmpHome, ".experience");
+    mkdirSync(muonroiDir, { recursive: true });
+    mkdirSync(experienceDir, { recursive: true });
+    // Create a minimal config so transcript-emit's isEnabled() returns true.
+    writeFileSync(join(experienceDir, "config.json"), JSON.stringify({}), "utf-8");
+    origUserProfile = process.env.USERPROFILE;
+    process.env.USERPROFILE = tmpHome;
+});
+afterEach(() => {
+    cleanDb();
+    if (origUserProfile !== undefined)
+        process.env.USERPROFILE = origUserProfile;
+    else
+        delete process.env.USERPROFILE;
+});
+// ── tests ────────────────────────────────────────────────────────────
+describe("exportTranscripts", () => {
+    it("no DB file → throws", async () => {
+        // No bootstrapDb call — DB doesn't exist.
+        const mod = await import("../export-transcripts.js");
+        await expect(mod.exportTranscripts()).rejects.toThrow();
+    });
+    it("dry-run with 0 sessions => empty result", async () => {
+        await bootstrapDb([]);
+        const mod = await import("../export-transcripts.js");
+        const res = await mod.exportTranscripts({ dryRun: true });
+        expect(res.totalSessions).toBe(0);
+        expect(res.written).toBe(0);
+        expect(res.skippedEmpty).toBe(0);
+        expect(res.skippedTooSmall).toBe(0);
+    });
+    it("dry-run emits sessions with >= 4 messages", async () => {
+        await bootstrapDb([
+            {
+                sessionId: "sess-1",
+                updatedAt: new Date().toISOString(),
+                cwdLast: null,
+                messages: [
+                    { seq: 1, role: "user", messageJson: JSON.stringify({ content: "hi" }) },
+                    { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "there" }) },
+                    { seq: 3, role: "user", messageJson: JSON.stringify({ content: "again" }) },
+                    { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "bye" }) },
+                ],
+            },
+        ]);
+        const mod = await import("../export-transcripts.js");
+        const res = await mod.exportTranscripts({ dryRun: true });
+        expect(res.totalSessions).toBe(1);
+        expect(res.written).toBe(1);
+        expect(res.skippedEmpty).toBe(0);
+        expect(res.skippedTooSmall).toBe(0);
+    });
+    it("wet-run writes JSONL files", async () => {
+        await bootstrapDb([
+            {
+                sessionId: "sess-1",
+                updatedAt: new Date().toISOString(),
+                cwdLast: null,
+                messages: [
+                    { seq: 1, role: "user", messageJson: JSON.stringify({ content: "hi" }) },
+                    { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "there" }) },
+                    { seq: 3, role: "user", messageJson: JSON.stringify({ content: "again" }) },
+                    { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "bye" }) },
+                ],
+            },
+        ]);
+        const mod = await import("../export-transcripts.js");
+        const res = await mod.exportTranscripts({ dryRun: false });
+        expect(res.totalSessions).toBe(1);
+        expect(res.written).toBe(1);
+        expect(res.skippedEmpty).toBe(0);
+        expect(res.skippedTooSmall).toBe(0);
+    });
+    it("skips sessions past maxAgeDays", async () => {
+        const old = new Date(Date.now() - 100 * 86400_000).toISOString();
+        await bootstrapDb([
+            {
+                sessionId: "sess-old",
+                updatedAt: old,
+                cwdLast: null,
+                messages: [
+                    { seq: 1, role: "user", messageJson: JSON.stringify({ content: "old1" }) },
+                    { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "old resp1" }) },
+                    { seq: 3, role: "user", messageJson: JSON.stringify({ content: "old2" }) },
+                    { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "old resp2" }) },
+                ],
+            },
+        ]);
+        const mod = await import("../export-transcripts.js");
+        const res = await mod.exportTranscripts({ dryRun: true, maxAgeDays: 7 });
+        expect(res.totalSessions).toBe(0);
+        expect(res.written).toBe(0);
+    });
+    it("skips sessions with too few messages", async () => {
+        await bootstrapDb([
+            {
+                sessionId: "sess-small",
+                updatedAt: new Date().toISOString(),
+                cwdLast: null,
+                messages: [{ seq: 1, role: "user", messageJson: JSON.stringify({ content: "only" }) }],
+            },
+        ]);
+        const mod = await import("../export-transcripts.js");
+        // Default minMessages = 4
+        const res = await mod.exportTranscripts({ dryRun: true });
+        expect(res.totalSessions).toBe(1);
+        expect(res.written).toBe(0);
+        expect(res.skippedTooSmall).toBe(1);
+    });
+    it("skippedEmpty when messages table returns nothing for a matched session", async () => {
+        await bootstrapDb([
+            {
+                sessionId: "sess-empty",
+                updatedAt: new Date().toISOString(),
+                cwdLast: null,
+                messages: [],
+            },
+        ]);
+        const mod = await import("../export-transcripts.js");
+        const res = await mod.exportTranscripts({ dryRun: true, maxAgeDays: 30 });
+        expect(res.totalSessions).toBe(1);
+        expect(res.written).toBe(0);
+        expect(res.skippedEmpty).toBe(1);
+    });
+    it("bad JSON in message_json row — throws by default", async () => {
+        await bootstrapDb([
+            {
+                sessionId: "sess-bad",
+                updatedAt: new Date().toISOString(),
+                cwdLast: null,
+                messages: [{ seq: 1, role: "user", messageJson: "NOT_VALID_JSON" }],
+            },
+        ]);
+        const mod = await import("../export-transcripts.js");
+        // The function's inner callback in .map() wraps JSON.parse in try/catch
+        // and returns null on failure. With null row messages.length<minMessages
+        // so it falls through to skippedTooSmall. This is intentional per source.
+        const res = await mod.exportTranscripts({ dryRun: true, minMessages: 1 });
+        // minMessages=1, but the single row's parse fails → messages.length=0
+        // -> skippedEmpty not skippedTooSmall
+        expect(res.totalSessions).toBe(1);
+        expect(res.written).toBe(0);
+        expect(res.skippedEmpty).toBe(1);
+        expect(res.skippedTooSmall).toBe(0);
+    });
+});
+//# sourceMappingURL=export-transcripts.test.js.map

package/dist/src/ee/__tests__/recall-format.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * formatRecallForAgent — compact, capped, inline-readable recall index.
+ *
+ * Locks the fix for the MCP/builtin ee_query overflow: the recallMode pipeline
+ * returns ~30k of ranked text, and the old `JSON.stringify(resp)` path blew the
+ * MCP per-result token cap (forcing a file spill) and JSON-escaped the index.
+ * This formatter returns the raw ranked text, capped on a line boundary, with a
+ * count + truncation footer and every `[id col]` handle in the kept region intact.
+ */
+export {};

package/dist/src/ee/__tests__/recall-format.test.js

@@ -0,0 +1,57 @@
+/**
+ * formatRecallForAgent — compact, capped, inline-readable recall index.
+ *
+ * Locks the fix for the MCP/builtin ee_query overflow: the recallMode pipeline
+ * returns ~30k of ranked text, and the old `JSON.stringify(resp)` path blew the
+ * MCP per-result token cap (forcing a file spill) and JSON-escaped the index.
+ * This formatter returns the raw ranked text, capped on a line boundary, with a
+ * count + truncation footer and every `[id col]` handle in the kept region intact.
+ */
+import { describe, expect, it } from "vitest";
+import { formatRecallForAgent } from "../search.js";
+function resp(text, count) {
+    return { text, count, entries: [] };
+}
+describe("formatRecallForAgent", () => {
+    it("returns the ranked index plus a count footer when it fits", () => {
+        const out = formatRecallForAgent(resp("- lesson one [id:abc col:experience-behavioral]", 1), { query: "redactor" });
+        expect(out).toContain("[id:abc col:experience-behavioral]");
+        expect(out).toContain('[recall: 1 entries for "redactor"]');
+        expect(out).not.toContain("\\n"); // raw text, not JSON-escaped
+    });
+    it("reports zero entries (and never dumps) when nothing matched", () => {
+        expect(formatRecallForAgent(resp(null, 0), { query: "nope" })).toBe('[recall: 0 entries for "nope" — the brain has nothing here; proceed without it.]');
+        expect(formatRecallForAgent(resp("ignored stale text", 0))).toContain("0 entries");
+    });
+    it("caps oversized text and marks it truncated", () => {
+        const big = `${"x".repeat(50_000)}`;
+        const out = formatRecallForAgent(resp(big, 99), { maxChars: 6000, query: "wide" });
+        expect(out.length).toBeLessThan(6500); // body cap + short footer
+        expect(out).toContain("truncated");
+        expect(out).toContain("/50000 chars");
+        expect(out).toContain("99 entries");
+    });
+    it("cuts on a line boundary so a [id col] handle is never split", () => {
+        // Padded so each line clears the 500-char clamp floor; budget lands inside
+        // line C → line C is dropped whole rather than split mid-handle.
+        const pad = "z".repeat(280);
+        const lineA = `${pad} [id:a col:x]`;
+        const lineB = `${pad} [id:b col:y]`;
+        const lineC = `${pad} [id:c col:z]`;
+        const text = [lineA, lineB, lineC].join("\n");
+        const cInner = text.indexOf("[id:c col:z]") + 4; // mid-line-C, after the last newline
+        const out = formatRecallForAgent(resp(text, 3), { maxChars: cInner });
+        expect(out).toContain("[id:a col:x]");
+        expect(out).toContain("[id:b col:y]");
+        expect(out).not.toContain("[id:c col:z]"); // dropped whole, not a dangling partial
+        expect(out).toContain("truncated");
+    });
+    it("clamps maxChars into [500, 20000]", () => {
+        const text = "y".repeat(30_000);
+        const tiny = formatRecallForAgent(resp(text, 1), { maxChars: 1 }); // clamped up to 500
+        const bodyLen = tiny.split("\n\n")[0].length;
+        expect(bodyLen).toBeGreaterThanOrEqual(500);
+        expect(bodyLen).toBeLessThanOrEqual(20_000);
+    });
+});
+//# sourceMappingURL=recall-format.test.js.map

package/dist/src/ee/__tests__/recall-ledger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/ee/__tests__/recall-ledger.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { createRecallLedger } from "../recall-ledger.js";
+describe("recall-ledger", () => {
+    it("records entries as pending and counts them", () => {
+        const l = createRecallLedger();
+        l.record([
+            { id: "a", collection: "c1" },
+            { id: "b", collection: null },
+        ], "q1");
+        expect(l.pendingCount()).toBe(2);
+        const pending = l.pending();
+        expect(pending.map((p) => p.id)).toEqual(["a", "b"]);
+        expect(pending[0].query).toBe("q1");
+    });
+    it("first sighting wins — re-recording an unrated id keeps the original query", () => {
+        const l = createRecallLedger();
+        l.record([{ id: "a", collection: "c1" }], "first");
+        l.record([{ id: "a", collection: "c1" }], "second");
+        expect(l.pendingCount()).toBe(1);
+        expect(l.pending()[0].query).toBe("first");
+    });
+    it("clear() removes a rated id and reports whether it was pending", () => {
+        const l = createRecallLedger();
+        l.record([{ id: "a", collection: "c1" }], "q");
+        expect(l.clear("a")).toBe(true);
+        expect(l.clear("a")).toBe(false); // already gone
+        expect(l.pendingCount()).toBe(0);
+    });
+    it("ignores entries with empty/missing ids and non-array input", () => {
+        const l = createRecallLedger();
+        l.record([
+            { id: "", collection: "c" },
+            { id: "  ", collection: "c" },
+        ], "q");
+        l.record(undefined, "q");
+        expect(l.pendingCount()).toBe(0);
+    });
+    it("reset() empties the ledger", () => {
+        const l = createRecallLedger();
+        l.record([{ id: "a", collection: "c" }], "q");
+        l.reset();
+        expect(l.pendingCount()).toBe(0);
+    });
+});
+//# sourceMappingURL=recall-ledger.test.js.map

package/dist/src/ee/auth.test.js

@@ -9,7 +9,7 @@ describe("loadEEAuthToken", () => {
         tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "ee-auth-test-"));
     });
     afterEach(async () => {
-        await fs.rm(tmpHome, { recursive: true, force: true }).catch(() => { });
+        await fs.rm(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
     });
     it("returns token when ~/.experience/config.json exists", async () => {
         const dir = path.join(tmpHome, ".experience");
@@ -42,7 +42,7 @@ describe("refreshAuthToken", () => {
         tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "ee-auth-ref-"));
     });
     afterEach(async () => {
-        await fs.rm(tmpHome, { recursive: true, force: true }).catch(() => { });
+        await fs.rm(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
     });
     it("re-reads config.json and updates the cached value", async () => {
         const dir = path.join(tmpHome, ".experience");

package/dist/src/ee/client.js

@@ -170,6 +170,11 @@ export function createEEClient(opts = {}) {
     const baseUrl = opts.baseUrl ?? DEFAULT_BASE;
     const authToken = opts.authToken;
     const interceptTimeoutMs = opts.timeoutMs ?? defaultTimeoutForBase(baseUrl);
+    // posttool is AWAITED by the PostToolUse hook (src/hooks/index.ts) on the hot
+    // path, yet is semantically fire-and-forget telemetry. Bound it on the same
+    // per-base budget as intercept so a reachable-but-wedged server (accepts TCP,
+    // never responds) can never hang the hook / stall the orchestrator.
+    const postToolTimeoutMs = defaultTimeoutForBase(baseUrl);
     const f = opts.fetchImpl ?? fetch;
     function headers() {
         const h = { "Content-Type": "application/json" };
@@ -230,6 +235,7 @@ export function createEEClient(opts = {}) {
                 method: "POST",
                 headers: headers(),
                 body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(postToolTimeoutMs),
             }).catch((err) => {
                 logEeFailure("client.posttool", classifyEeError(err), err);
                 /* fire-and-forget error swallowed */
@@ -287,6 +293,23 @@ export function createEEClient(opts = {}) {
                 void enqueue({ endpoint: "/api/feedback", body: payload, enqueuedAt: Date.now() });
             });
         },
+        /**
+         * User-driven noise feedback — matches the `exp-feedback` helper payload
+         * shape (pointId + collection + verdict='IRRELEVANT' + reason). Surfaces
+         * the EE scope-narrowing path (wrong_language / wrong_repo / wrong_task /
+         * stale_rule). Fire-and-forget; queued offline like standard feedback.
+         */
+        noiseFeedback(payload) {
+            const body = { ...payload, verdict: "IRRELEVANT" };
+            f(`${baseUrl}/api/feedback`, {
+                method: "POST",
+                headers: headers(),
+                body: JSON.stringify(body),
+            }).catch((err) => {
+                logEeFailure("client.noiseFeedback", classifyEeError(err), err);
+                void enqueue({ endpoint: "/api/feedback", body, enqueuedAt: Date.now() });
+            });
+        },
         touch(principle_uuid, tenantId) {
             f(`${baseUrl}/api/principle/touch?id=${encodeURIComponent(principle_uuid)}`, {
                 method: "POST",
@@ -494,6 +517,42 @@ export function createEEClient(opts = {}) {
                 return null;
             }
         },
+        // ─── Active recall (recallMode) ───────────────────────────────────────────
+        // Hits /api/recall (handleRecall), NOT /api/search. This is the fixed
+        // semantic-recall pipeline: 3 collections merged by raw cosine, integrity
+        // gates kept, records a surface so the returned `[id col]` handles can be
+        // reinforced via exp-feedback. Same path exp-recall.js uses. Returns null on
+        // any error/timeout — matches this client's documented circuit-breaker
+        // contract (callers map null → "EE unavailable"; the tool layer surfaces it).
+        async recall(query, opts = {}) {
+            const body = { query };
+            if (opts.cwd)
+                body.cwd = opts.cwd;
+            if (opts.project)
+                body.project_slug = opts.project;
+            if (opts.sourceSession)
+                body.sourceSession = opts.sourceSession;
+            // Server bounds the recall pipeline at ~8s internally (handleRecall's
+            // AbortSignal.timeout(8000)); embedding + 3-leg search + network push real
+            // wall-time past that (measured ~9.3s on a warm VPS). An 8s client ceiling
+            // races the server and loses → spurious ee_unavailable. 15s gives margin
+            // so a slow-but-valid recall still lands rather than being dropped.
+            const timeoutMs = opts.timeoutMs ?? 15000;
+            try {
+                const resp = await f(`${baseUrl}/api/recall`, {
+                    method: "POST",
+                    headers: headers(),
+                    body: JSON.stringify(body),
+                    signal: opts.signal ?? AbortSignal.timeout(timeoutMs),
+                });
+                if (!resp.ok)
+                    return null;
+                return (await resp.json());
+            }
+            catch {
+                return null;
+            }
+        },
         // ─── User identity ──────────────────────────────────────────────────────
         async user() {
             try {

package/dist/src/ee/client.test.js

@@ -106,6 +106,36 @@ describe("EEClient - posttool", () => {
         // Must not throw even when awaited
         await expect(ee.posttool(mockPayload)).resolves.toBeUndefined();
     });
+    it("Test 9: posttool does not hang on a wedged server — bounded by an abort signal", async () => {
+        // PostToolUse hook (src/hooks/index.ts) AWAITS posttool on the hot path.
+        // A reachable-but-wedged EE server (accepts TCP, never responds) must NOT
+        // hang the hook — posttool must carry a timeout abort signal like every
+        // other client method, honouring the "never block orchestrator" intent.
+        vi.useFakeTimers();
+        try {
+            const mockFetch = vi.fn().mockImplementation((_url, opts) => {
+                return new Promise((_resolve, reject) => {
+                    const signal = opts?.signal;
+                    // Wedged server: only ever settles if the client aborts it.
+                    signal?.addEventListener("abort", () => {
+                        reject(new DOMException("The operation was aborted.", "AbortError"));
+                    });
+                });
+            });
+            const ee = createEEClient({ fetchImpl: mockFetch });
+            const p = ee.posttool(mockPayload);
+            // Structural: the call must be bounded by an AbortSignal (deterministic).
+            const opts = mockFetch.mock.calls[0][1];
+            expect(opts.signal).toBeInstanceOf(AbortSignal);
+            // Behavioral: once the timeout fires, the wedged call is aborted and the
+            // fire-and-forget catch resolves posttool to undefined (never throws).
+            await vi.advanceTimersByTimeAsync(15_000);
+            await expect(p).resolves.toBeUndefined();
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
 });
 describe("EEClient - auth", () => {
     beforeEach(() => {

package/dist/src/ee/council-bridge.js

@@ -36,7 +36,7 @@ export async function queryExperience(topic, domain, signal) {
             text: extractText(p),
             id: String(p.id),
             score: p.score ?? 0,
-            collection: p.payload?.["collection"] ?? "experience-behavioral",
+            collection: p.payload?.collection ?? "experience-behavioral",
         }));
         return { warnings };
     }
@@ -46,11 +46,11 @@ export async function queryExperience(topic, domain, signal) {
 }
 function extractText(p) {
     const payload = p.payload ?? {};
-    const direct = payload["text"];
+    const direct = payload.text;
     if (direct)
         return direct;
     try {
-        const parsed = JSON.parse(payload["json"] || "{}");
+        const parsed = JSON.parse(payload.json || "{}");
         return parsed.solution ?? parsed.principle ?? parsed.judgment ?? "";
     }
     catch {

package/dist/src/ee/export-transcripts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * One-shot SQLite → JSONL transcript exporter.
+ *
+ * Walks `~/.muonroi-cli/muonroi.db` `messages` table grouped by session_id,
+ * normalizes each row's `message_json` (ai SDK ModelMessage shape) via the
+ * same emitTranscriptToDisk encoder used at runtime, and writes one JSONL
+ * file per session under `~/.experience/muonroi-cli-sessions/`.
+ *
+ * This is the backfill counterpart to runtime emit — exists so the user can
+ * recover lessons from sessions that pre-date the transcript-emit feature.
+ * Idempotent: re-running overwrites the same per-session JSONL.
+ */
+export interface ExportOptions {
+    maxAgeDays?: number;
+    dryRun?: boolean;
+    /** Minimum messages per session to bother emitting (default 4 — skip noise). */
+    minMessages?: number;
+}
+export interface ExportResult {
+    totalSessions: number;
+    written: number;
+    skippedEmpty: number;
+    skippedTooSmall: number;
+    outputRoot: string;
+}
+export declare function exportTranscripts(opts?: ExportOptions): Promise<ExportResult>;

package/dist/src/ee/export-transcripts.js

@@ -0,0 +1,115 @@
+/**
+ * One-shot SQLite → JSONL transcript exporter.
+ *
+ * Walks `~/.muonroi-cli/muonroi.db` `messages` table grouped by session_id,
+ * normalizes each row's `message_json` (ai SDK ModelMessage shape) via the
+ * same emitTranscriptToDisk encoder used at runtime, and writes one JSONL
+ * file per session under `~/.experience/muonroi-cli-sessions/`.
+ *
+ * This is the backfill counterpart to runtime emit — exists so the user can
+ * recover lessons from sessions that pre-date the transcript-emit feature.
+ * Idempotent: re-running overwrites the same per-session JSONL.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { emitTranscriptToDisk, getEmitRoot } from "./transcript-emit.js";
+async function openDb(dbPath) {
+    // Prefer better-sqlite3 (sync), fall back to bun:sqlite when running under Bun.
+    // better-sqlite3 is an OPTIONAL runtime dep — its native build often fails on
+    // Windows without VS Build Tools, so the module may be missing from
+    // node_modules even when listed in package.json. The try/catch below handles
+    // the runtime ENOENT; the ts-ignore keeps the build unblocked.
+    try {
+        // optional dep, may not be installed
+        const mod = await import("better-sqlite3");
+        const Better = mod.default ?? mod;
+        const db = new Better(dbPath, { readonly: true });
+        return {
+            all: (sql) => db.prepare(sql).all(),
+            close: () => db.close(),
+        };
+    }
+    catch {
+        /* fall through */
+    }
+    try {
+        const bun = await import("bun:sqlite").catch(() => null);
+        if (!bun)
+            throw new Error("no sqlite driver");
+        const Database = bun.Database;
+        const db = new Database(dbPath, { readonly: true });
+        return {
+            all: (sql) => db.query(sql).all(),
+            close: () => db.close(),
+        };
+    }
+    catch (e) {
+        throw new Error(`No SQLite driver available (tried better-sqlite3, bun:sqlite). Install better-sqlite3 or run under Bun. Cause: ${e.message}`);
+    }
+}
+export async function exportTranscripts(opts = {}) {
+    const maxAgeDays = opts.maxAgeDays ?? 30;
+    const minMessages = opts.minMessages ?? 4;
+    const dryRun = opts.dryRun ?? false;
+    const dbPath = path.join(os.homedir(), ".muonroi-cli", "muonroi.db");
+    if (!fs.existsSync(dbPath)) {
+        throw new Error(`muonroi.db not found at ${dbPath}`);
+    }
+    const db = await openDb(dbPath);
+    try {
+        const cutoff = Date.now() - maxAgeDays * 86400_000;
+        const cutoffIso = new Date(cutoff).toISOString();
+        // Pull sessions touched in window. cwd_last is the cwd at session-end —
+        // critical for EE scope detection so framework/lang resolve correctly.
+        const sessions = db.all(`SELECT id, updated_at, cwd_last FROM sessions WHERE updated_at >= '${cutoffIso}' ORDER BY updated_at DESC`);
+        const out = {
+            totalSessions: sessions.length,
+            written: 0,
+            skippedEmpty: 0,
+            skippedTooSmall: 0,
+            outputRoot: getEmitRoot(),
+        };
+        for (const s of sessions) {
+            const rows = db.all(`SELECT session_id, seq, role, message_json FROM messages WHERE session_id = '${s.id.replace(/'/g, "''")}' ORDER BY seq ASC`);
+            if (rows.length === 0) {
+                out.skippedEmpty++;
+                continue;
+            }
+            if (rows.length < minMessages) {
+                out.skippedTooSmall++;
+                continue;
+            }
+            const messages = rows
+                .map((r) => {
+                try {
+                    return JSON.parse(r.message_json);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((m) => m !== null);
+            if (messages.length === 0) {
+                out.skippedEmpty++;
+                continue;
+            }
+            if (dryRun) {
+                console.log(`[dry-run] would emit ${s.id} (${messages.length} msgs)`);
+                out.written++;
+                continue;
+            }
+            // Re-use runtime emitter so format matches stop-extractor parser exactly.
+            // Cast to ModelMessage[]: the on-disk shape and ModelMessage are wire-compatible
+            // — emitTranscriptToDisk only inspects role + content blocks.
+            const target = emitTranscriptToDisk(messages, s.id, "cli-exit", s.cwd_last ?? null);
+            if (target)
+                out.written++;
+        }
+        return out;
+    }
+    finally {
+        db.close();
+    }
+}
+//# sourceMappingURL=export-transcripts.js.map

package/dist/src/ee/intercept.d.ts

@@ -1,6 +1,15 @@
 import type { CreateEEClientOpts } from "./client.js";
 import { createEEClient } from "./client.js";
 import type { InterceptRequest, InterceptResponse } from "./types.js";
+export declare function getLastSurfacedMatches(): Array<{
+    principleUuid: string;
+    collection: string;
+}>;
+export declare function setLastSurfacedMatches(matches: Array<{
+    principleUuid: string;
+    collection: string;
+}>): void;
+export declare function clearLastSurfacedMatches(): void;
 /**
  * Returns the last surfaced suggestion IDs and timestamp from the most recent
  * intercept call that returned matches. Used by prompt-stale reconciliation