muonroi-cli 1.3.4 → 1.4.1

package/dist/src/ee/intercept.js

@@ -6,6 +6,19 @@ import { getTenantId } from "./tenant.js";
 // ─── Surfaced-state tracking for prompt-stale reconciliation ─────────────────
 let _lastSurfacedIds = [];
 let _lastSurfacedTimestamp = null;
+// Most-recent match batch with collection info — drives Ctrl+N user feedback.
+// Separate from _lastSurfacedIds (which may include IDs from PIL Layer 3
+// injection where we don't have the collection).
+let _lastSurfacedMatches = [];
+export function getLastSurfacedMatches() {
+    return _lastSurfacedMatches.map((m) => ({ ...m }));
+}
+export function setLastSurfacedMatches(matches) {
+    _lastSurfacedMatches = matches.filter((m) => m.principleUuid && m.collection).map((m) => ({ ...m }));
+}
+export function clearLastSurfacedMatches() {
+    _lastSurfacedMatches = [];
+}
 /**
  * Returns the last surfaced suggestion IDs and timestamp from the most recent
  * intercept call that returned matches. Used by prompt-stale reconciliation
@@ -87,6 +100,12 @@ export async function intercept(req, opts) {
         _lastSurfacedIds = resp.matches.map((m) => m.principle_uuid);
         _lastSurfacedTimestamp = new Date().toISOString();
     }
+    // Track matches with collection for user feedback (Ctrl+N noise).
+    if (resp.matches && resp.matches.length > 0) {
+        setLastSurfacedMatches(resp.matches
+            .filter((m) => m.collection)
+            .map((m) => ({ principleUuid: m.principle_uuid, collection: m.collection })));
+    }
     return resp;
 }
 /**

package/dist/src/ee/offline-queue.test.js

@@ -30,7 +30,7 @@ beforeEach(async () => {
     await mkdir(tmpDir, { recursive: true });
 });
 afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true });
+    await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
 });
 /**
  * Helper: get the ee-offline-queue dir inside tmpDir.
@@ -150,10 +150,10 @@ describe("drainQueueAsync()", () => {
     // ─── Test 6: drainQueue() stops on failure, leaves remaining ──────────────
     it("stops on 2nd entry failure and leaves 2nd + 3rd entries on disk", async () => {
         await populateQueue(3, 1000);
-        let callCount = 0;
+        let _callCount = 0;
         const stub = await startStubEEServer({
             feedback: () => {
-                callCount++;
+                _callCount++;
             },
         });
         // Override the server to return 500 on 2nd call

package/dist/src/ee/phase-tracker.js

@@ -65,7 +65,7 @@ export function recordIntercept(refs) {
         return;
     _state.toolCount++;
     for (const ref of refs) {
-        if (!ref || !ref.pointId || !ref.collection)
+        if (!ref?.pointId || !ref.collection)
             continue;
         if (_state.seenPrincipleIds.has(ref.pointId))
             continue;

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

@@ -0,0 +1,32 @@
+/**
+ * src/ee/recall-ledger.ts
+ *
+ * In-memory, session-scoped ledger of recalled `[id col]` handles that have NOT
+ * yet been rated via the ee_feedback MCP tool. The muonroi-tools MCP server is one
+ * process per agent session, so a module-level singleton IS the session: every
+ * ee_query adds its returned entries as PENDING debt; every ee_feedback clears one;
+ * ee_query then surfaces (soft mode) or refuses on (hard mode) accumulated unrated
+ * debt. This is what forces a verdict on useful recalls — the only signal that lets
+ * the brain keep the good entries and prune the rest, because recall surfaces are
+ * deliberately excluded from the implicit-precision reconcile path.
+ */
+import type { EERecallEntry } from "./types.js";
+export interface PendingRecall {
+    id: string;
+    collection: string | null;
+    query: string;
+    ts: number;
+}
+export interface RecallLedger {
+    /** Stamp the entries returned by a recall as pending debt (first sighting wins). */
+    record(entries: EERecallEntry[] | undefined, query: string): void;
+    /** Clear one id once it has been rated. Returns true if it was actually pending. */
+    clear(id: string): boolean;
+    /** Oldest-first list of still-unrated recalls. */
+    pending(): PendingRecall[];
+    pendingCount(): number;
+    reset(): void;
+}
+export declare function createRecallLedger(): RecallLedger;
+/** Process-scoped singleton = the current MCP session's unrated-recall debt. */
+export declare const sessionRecallLedger: RecallLedger;

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

@@ -0,0 +1,52 @@
+/**
+ * src/ee/recall-ledger.ts
+ *
+ * In-memory, session-scoped ledger of recalled `[id col]` handles that have NOT
+ * yet been rated via the ee_feedback MCP tool. The muonroi-tools MCP server is one
+ * process per agent session, so a module-level singleton IS the session: every
+ * ee_query adds its returned entries as PENDING debt; every ee_feedback clears one;
+ * ee_query then surfaces (soft mode) or refuses on (hard mode) accumulated unrated
+ * debt. This is what forces a verdict on useful recalls — the only signal that lets
+ * the brain keep the good entries and prune the rest, because recall surfaces are
+ * deliberately excluded from the implicit-precision reconcile path.
+ */
+export function createRecallLedger() {
+    const map = new Map();
+    return {
+        record(entries, query) {
+            if (!Array.isArray(entries))
+                return;
+            const now = Date.now();
+            for (const e of entries) {
+                const id = e && e.id != null ? String(e.id).trim() : "";
+                if (!id)
+                    continue;
+                // First sighting keeps the original ts + query so age-based reporting is
+                // honest; re-recalling an already-pending id must not reset its clock.
+                if (!map.has(id)) {
+                    map.set(id, {
+                        id,
+                        collection: e.collection ?? null,
+                        query: String(query || "").slice(0, 120),
+                        ts: now,
+                    });
+                }
+            }
+        },
+        clear(id) {
+            return map.delete(String(id ?? "").trim());
+        },
+        pending() {
+            return [...map.values()].sort((a, b) => a.ts - b.ts);
+        },
+        pendingCount() {
+            return map.size;
+        },
+        reset() {
+            map.clear();
+        },
+    };
+}
+/** Process-scoped singleton = the current MCP session's unrated-recall debt. */
+export const sessionRecallLedger = createRecallLedger();
+//# sourceMappingURL=recall-ledger.js.map

package/dist/src/ee/recall-mirror.test.d.ts

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

package/dist/src/ee/recall-mirror.test.js

@@ -0,0 +1,65 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mirrorRecallLocally } from "./search.js";
+/**
+ * mirrorRecallLocally writes an op:'recall' row matching the EE buildRecallEvent
+ * shape into the client-local activity.jsonl, so the session-end runbook-candidate
+ * nudge sees MCP/builtin recalls (not just exp-recall.js CLI recalls).
+ */
+describe("mirrorRecallLocally", () => {
+    let dir;
+    let logPath;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "recall-mirror-"));
+        logPath = join(dir, "activity.jsonl");
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("appends an op:recall row with surfacedIds derived from entries", async () => {
+        await mirrorRecallLocally("post donor enrich", {
+            sourceSession: "sess-1",
+            project: "storyflow",
+            entries: [
+                { id: "4c81b5ca", collection: "experience-selfqa" },
+                { id: "1e5f095f", collection: "experience-behavioral" },
+            ],
+        }, logPath);
+        const rows = readFileSync(logPath, "utf8")
+            .trim()
+            .split("\n")
+            .map((l) => JSON.parse(l));
+        expect(rows).toHaveLength(1);
+        expect(rows[0].op).toBe("recall");
+        expect(rows[0].query).toBe("post donor enrich");
+        expect(rows[0].sourceSession).toBe("sess-1");
+        expect(rows[0].project_slug).toBe("storyflow");
+        expect(rows[0].surfacedIds).toEqual(["4c81b5ca", "1e5f095f"]);
+        expect(rows[0].count).toBe(2);
+        expect(typeof rows[0].ts).toBe("string");
+    });
+    it("writes count 0 with empty entries (still observable, never throws)", async () => {
+        await mirrorRecallLocally("nothing matched", { sourceSession: null, project: null, entries: [] }, logPath);
+        const rows = readFileSync(logPath, "utf8")
+            .trim()
+            .split("\n")
+            .map((l) => JSON.parse(l));
+        expect(rows[0].count).toBe(0);
+        expect(rows[0].surfacedIds).toEqual([]);
+        expect(rows[0].sourceSession).toBeNull();
+    });
+    it("truncates an over-long query to 200 chars (matches buildRecallEvent)", async () => {
+        const long = "x".repeat(500);
+        await mirrorRecallLocally(long, { entries: [{ id: "a", collection: "c" }] }, logPath);
+        const row = JSON.parse(readFileSync(logPath, "utf8").trim());
+        expect(row.query.length).toBe(200);
+    });
+    it("never throws when the target path is unwritable (best-effort)", async () => {
+        // A path under a non-existent directory → appendFile rejects → swallowed.
+        const bad = join(dir, "nope", "deep", "activity.jsonl");
+        await expect(mirrorRecallLocally("q", { entries: [{ id: "a", collection: "c" }] }, bad)).resolves.toBeUndefined();
+    });
+});
+//# sourceMappingURL=recall-mirror.test.js.map

package/dist/src/ee/scope.js

@@ -58,7 +58,7 @@ export async function buildScope(opts) {
     // Ecosystem detection — check if remote matches any configured pattern
     if (remote) {
         const eco = loadUserSettings().ecosystem;
-        if (eco && eco.patterns.some((p) => remote.includes(p))) {
+        if (eco?.patterns.some((p) => remote.includes(p))) {
             cached = { kind: "ecosystem", name: eco.name };
             cachedFor = opts.cwd;
             return cached;

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

@@ -11,7 +11,7 @@ describe("buildScope", () => {
         tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "scope-test-"));
     });
     afterEach(async () => {
-        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+        await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
     });
     it("returns { kind: 'global' } for a directory without .git", async () => {
         const scope = await buildScope({ cwd: tmpDir });

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

@@ -0,0 +1,99 @@
+/**
+ * src/ee/search.ts
+ *
+ * Shared Experience Engine (EE) search/health helpers used by BOTH:
+ *   - the MCP `ee.query` / `ee.health` tools (src/mcp/ee-tools.ts), for
+ *     external agents driving the CLI over MCP, and
+ *   - the in-CLI agent's builtin `ee_query` tool (src/tools/registry.ts), so
+ *     the anti-mù protocol's "Use ee_query tool with 'tool-artifact id=XXX'"
+ *     instruction is actually executable from inside the agent loop.
+ *
+ * The EE client returns null on any error/timeout (graceful, circuit-breaker)
+ * so callers map null → an "EE unavailable" outcome rather than throwing.
+ */
+import type { EERecallEntry, EERecallResponse, EESearchResponse } from "./types.js";
+/**
+ * Render an {@link EERecallResponse} into the compact, inline-readable index the
+ * agent actually consumes — the same ranked `[id col]` text the exp-recall.js
+ * CLI prints, NOT a JSON dump of the whole response.
+ *
+ * Why this exists: the recallMode pipeline casts a wide net (recallBudgetChars
+ * sums to ~30k across the 3 collections), so `resp.text` is routinely ~31k. The
+ * MCP `ee.query` tool used to return `JSON.stringify(resp)` verbatim, which
+ * (a) blew past the MCP per-result token cap → the client spilled it to a file,
+ * and (b) JSON-escaped every newline, making the index unreadable. This caps the
+ * text on a line boundary (recall text is cosine-ranked strongest-first, so the
+ * tail is the safe thing to drop), preserves every `[id col]` handle in the kept
+ * region, and appends a one-line footer with the true count + truncation notice.
+ */
+export declare function formatRecallForAgent(resp: EERecallResponse, opts?: {
+    query?: string;
+    maxChars?: number;
+}): string;
+/**
+ * Mirror an agent-initiated recall as a LOCAL `op:'recall'` activity row, matching
+ * the EE-side buildRecallEvent shape. The server logs recalls into the VPS's
+ * activity.jsonl, but the runbook-candidate nudge (stop-extractor) reads the
+ * CLIENT-local one — so without this, MCP/builtin recalls (which POST straight to
+ * /api/recall) are invisible to the stitch signal, exactly as exp-recall.js was
+ * before its own local-log fix. Best-effort: a failed write must never break recall.
+ *
+ * Exported for unit testing (pass `logPath` to redirect off the real ~/.experience).
+ */
+export declare function mirrorRecallLocally(query: string, meta: {
+    sourceSession?: string | null;
+    project?: string | null;
+    entries?: EERecallEntry[];
+}, logPath?: string): Promise<void>;
+/**
+ * Semantic search over the EE brain. Token + base URL are resolved lazily from
+ * ~/.experience/config.json (works on thin clients). Returns null on
+ * unavailability/timeout — never throws for transport errors.
+ */
+export declare function searchEE(query: string, opts?: {
+    limit?: number;
+    collections?: string[];
+}): Promise<EESearchResponse | null>;
+/**
+ * Active recall over the EE brain via /api/recall (recallMode) — the fixed
+ * pipeline (3 collections merged by raw cosine, integrity gates, records a
+ * surface) that returns the `[id col]` index. This is the recall path the MCP
+ * `ee.query` tool and the in-CLI builtin `ee_query` route through, so the
+ * agent's tool-driven recall is on par with exp-recall.js. Returns null on
+ * unavailability/timeout — never throws for transport errors.
+ */
+export declare function recallEE(query: string, opts?: {
+    project?: string;
+    cwd?: string;
+    sourceSession?: string;
+    timeoutMs?: number;
+}): Promise<EERecallResponse | null>;
+export type FeedbackVerdict = "followed" | "ignored" | "noise";
+export type NoiseReason = "wrong_repo" | "wrong_language" | "wrong_task" | "stale_rule";
+export interface FeedbackResult {
+    ok: boolean;
+    resolvedId?: string;
+    verdict?: string;
+    reason?: string;
+    error?: string;
+}
+/**
+ * Record an agent verdict on a recalled `[id col]` entry, byte-for-byte matching
+ * the exp-feedback.js wire shape the server already accepts
+ * (`{pointId, collection, verdict: FOLLOWED|IGNORED|IRRELEVANT, reason?}`). The
+ * server resolves a short pointId prefix and returns the full `resolvedId`. Never
+ * throws (graceful, logged) — returns `{ok:false, error}` on transport failure so
+ * the caller can keep the entry as unrated debt instead of clearing it.
+ */
+export declare function feedbackEE(pointId: string, collection: string, verdict: FeedbackVerdict, reason?: NoiseReason): Promise<FeedbackResult>;
+/**
+ * Mirror a feedback verdict as a LOCAL `op:'feedback'` activity row (parity with
+ * mirrorRecallLocally's `op:'recall'`). Lets the session-end nudge + forensics
+ * compute unrated-recall debt as recalled ids minus fed-back ids. Best-effort.
+ */
+export declare function mirrorFeedbackLocally(pointId: string, collection: string, verdict: string, reason?: string | null, logPath?: string): Promise<void>;
+/** Reachability probe for the EE server. */
+export declare function healthEE(): Promise<{
+    ok: boolean;
+    status: number;
+}>;

package/dist/src/ee/search.js

@@ -0,0 +1,220 @@
+/**
+ * src/ee/search.ts
+ *
+ * Shared Experience Engine (EE) search/health helpers used by BOTH:
+ *   - the MCP `ee.query` / `ee.health` tools (src/mcp/ee-tools.ts), for
+ *     external agents driving the CLI over MCP, and
+ *   - the in-CLI agent's builtin `ee_query` tool (src/tools/registry.ts), so
+ *     the anti-mù protocol's "Use ee_query tool with 'tool-artifact id=XXX'"
+ *     instruction is actually executable from inside the agent loop.
+ *
+ * The EE client returns null on any error/timeout (graceful, circuit-breaker)
+ * so callers map null → an "EE unavailable" outcome rather than throwing.
+ */
+/** Char-budget bounds for the agent-facing recall index. */
+const RECALL_FORMAT_MIN_CHARS = 500;
+const RECALL_FORMAT_MAX_CHARS = 20_000;
+const RECALL_FORMAT_DEFAULT_CHARS = 6_000;
+function clampRecallChars(n) {
+    if (typeof n !== "number" || !Number.isFinite(n))
+        return RECALL_FORMAT_DEFAULT_CHARS;
+    return Math.min(RECALL_FORMAT_MAX_CHARS, Math.max(RECALL_FORMAT_MIN_CHARS, Math.floor(n)));
+}
+/**
+ * Render an {@link EERecallResponse} into the compact, inline-readable index the
+ * agent actually consumes — the same ranked `[id col]` text the exp-recall.js
+ * CLI prints, NOT a JSON dump of the whole response.
+ *
+ * Why this exists: the recallMode pipeline casts a wide net (recallBudgetChars
+ * sums to ~30k across the 3 collections), so `resp.text` is routinely ~31k. The
+ * MCP `ee.query` tool used to return `JSON.stringify(resp)` verbatim, which
+ * (a) blew past the MCP per-result token cap → the client spilled it to a file,
+ * and (b) JSON-escaped every newline, making the index unreadable. This caps the
+ * text on a line boundary (recall text is cosine-ranked strongest-first, so the
+ * tail is the safe thing to drop), preserves every `[id col]` handle in the kept
+ * region, and appends a one-line footer with the true count + truncation notice.
+ */
+export function formatRecallForAgent(resp, opts = {}) {
+    const maxChars = clampRecallChars(opts.maxChars);
+    const q = opts.query ? ` for "${String(opts.query).slice(0, 80)}"` : "";
+    if (!resp.text || resp.count === 0) {
+        return `[recall: 0 entries${q} — the brain has nothing here; proceed without it.]`;
+    }
+    const full = resp.text.length;
+    let body = resp.text;
+    let truncated = false;
+    if (full > maxChars) {
+        truncated = true;
+        const slice = resp.text.slice(0, maxChars);
+        const lastNl = slice.lastIndexOf("\n");
+        // Cut on the last newline so a `[id col]` handle is never split — unless that
+        // would discard more than half the budget, in which case keep the hard slice.
+        body = lastNl > maxChars * 0.5 ? slice.slice(0, lastNl) : slice;
+    }
+    const footer = truncated
+        ? `[recall: ${resp.count} entries${q} · truncated ${body.length}/${full} chars — narrow the query or raise maxChars; entries are cosine-ranked, strongest first]`
+        : `[recall: ${resp.count} entries${q}]`;
+    return `${body}\n\n${footer}`;
+}
+/**
+ * Mirror an agent-initiated recall as a LOCAL `op:'recall'` activity row, matching
+ * the EE-side buildRecallEvent shape. The server logs recalls into the VPS's
+ * activity.jsonl, but the runbook-candidate nudge (stop-extractor) reads the
+ * CLIENT-local one — so without this, MCP/builtin recalls (which POST straight to
+ * /api/recall) are invisible to the stitch signal, exactly as exp-recall.js was
+ * before its own local-log fix. Best-effort: a failed write must never break recall.
+ *
+ * Exported for unit testing (pass `logPath` to redirect off the real ~/.experience).
+ */
+export async function mirrorRecallLocally(query, meta, logPath) {
+    try {
+        const fs = await import("node:fs");
+        const os = await import("node:os");
+        const path = await import("node:path");
+        const ids = Array.isArray(meta.entries)
+            ? meta.entries.map((e) => (e && e.id != null ? String(e.id) : "")).filter(Boolean)
+            : [];
+        const row = {
+            ts: new Date().toISOString(),
+            op: "recall",
+            query: String(query || "").slice(0, 200),
+            sourceSession: meta.sourceSession ?? null,
+            project_slug: meta.project ?? null,
+            surfacedIds: ids,
+            count: ids.length,
+        };
+        const target = logPath ?? process.env.EXPERIENCE_ACTIVITY_LOG ?? path.join(os.homedir(), ".experience", "activity.jsonl");
+        await fs.promises.appendFile(target, `${JSON.stringify(row)}\n`);
+    }
+    catch (err) {
+        const { logEeFailure, classifyEeError } = await import("../utils/ee-logger.js");
+        logEeFailure("search.mirrorRecallLocally", classifyEeError(err), err);
+    }
+}
+/**
+ * Semantic search over the EE brain. Token + base URL are resolved lazily from
+ * ~/.experience/config.json (works on thin clients). Returns null on
+ * unavailability/timeout — never throws for transport errors.
+ */
+export async function searchEE(query, opts = {}) {
+    const { createEEClient } = await import("./client.js");
+    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./auth.js");
+    const authToken = (await loadEEAuthToken()) ?? undefined;
+    const baseUrl = getCachedServerBaseUrl() ?? undefined;
+    return createEEClient({ baseUrl, authToken }).search(query, opts);
+}
+/**
+ * Active recall over the EE brain via /api/recall (recallMode) — the fixed
+ * pipeline (3 collections merged by raw cosine, integrity gates, records a
+ * surface) that returns the `[id col]` index. This is the recall path the MCP
+ * `ee.query` tool and the in-CLI builtin `ee_query` route through, so the
+ * agent's tool-driven recall is on par with exp-recall.js. Returns null on
+ * unavailability/timeout — never throws for transport errors.
+ */
+export async function recallEE(query, opts = {}) {
+    const { createEEClient } = await import("./client.js");
+    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./auth.js");
+    const authToken = (await loadEEAuthToken()) ?? undefined;
+    const baseUrl = getCachedServerBaseUrl() ?? undefined;
+    const sourceSession = opts.sourceSession ?? process.env.EXP_SESSION;
+    const cwd = opts.cwd ?? process.cwd();
+    const result = await createEEClient({ baseUrl, authToken }).recall(query, {
+        project: opts.project,
+        cwd,
+        sourceSession,
+        timeoutMs: opts.timeoutMs,
+    });
+    // Mirror the recall locally so the session-end runbook-candidate nudge sees
+    // MCP/builtin recalls too (parity with the exp-recall.js CLI path). Only on a
+    // non-null result (a transport failure already returned null to the caller).
+    if (result) {
+        await mirrorRecallLocally(query, { sourceSession, project: opts.project, entries: result.entries });
+    }
+    return result;
+}
+const VERDICT_WIRE = {
+    followed: "FOLLOWED",
+    ignored: "IGNORED",
+    noise: "IRRELEVANT",
+};
+/**
+ * Record an agent verdict on a recalled `[id col]` entry, byte-for-byte matching
+ * the exp-feedback.js wire shape the server already accepts
+ * (`{pointId, collection, verdict: FOLLOWED|IGNORED|IRRELEVANT, reason?}`). The
+ * server resolves a short pointId prefix and returns the full `resolvedId`. Never
+ * throws (graceful, logged) — returns `{ok:false, error}` on transport failure so
+ * the caller can keep the entry as unrated debt instead of clearing it.
+ */
+export async function feedbackEE(pointId, collection, verdict, reason) {
+    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./auth.js");
+    const authToken = (await loadEEAuthToken()) ?? undefined;
+    const baseUrl = (getCachedServerBaseUrl() ?? "http://localhost:8082").replace(/\/+$/, "");
+    const wire = VERDICT_WIRE[verdict];
+    const body = { pointId, collection, verdict: wire };
+    if (wire === "IRRELEVANT")
+        body.reason = reason;
+    const headers = { "Content-Type": "application/json" };
+    if (authToken)
+        headers.Authorization = `Bearer ${authToken}`;
+    try {
+        const res = await fetch(`${baseUrl}/api/feedback`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        const text = await res.text();
+        let json = null;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            /* non-JSON error body — fall through to status-based handling */
+        }
+        if (!res.ok) {
+            return { ok: false, error: json?.error || text || `HTTP ${res.status}` };
+        }
+        const resolvedId = json?.resolvedId || pointId;
+        await mirrorFeedbackLocally(resolvedId, collection, wire, reason);
+        return { ok: true, resolvedId, verdict: json?.verdict || wire, reason };
+    }
+    catch (err) {
+        const { logEeFailure, classifyEeError } = await import("../utils/ee-logger.js");
+        logEeFailure("search.feedbackEE", classifyEeError(err), err);
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Mirror a feedback verdict as a LOCAL `op:'feedback'` activity row (parity with
+ * mirrorRecallLocally's `op:'recall'`). Lets the session-end nudge + forensics
+ * compute unrated-recall debt as recalled ids minus fed-back ids. Best-effort.
+ */
+export async function mirrorFeedbackLocally(pointId, collection, verdict, reason, logPath) {
+    try {
+        const fs = await import("node:fs");
+        const os = await import("node:os");
+        const path = await import("node:path");
+        const row = {
+            ts: new Date().toISOString(),
+            op: "feedback",
+            pointId: String(pointId),
+            collection: collection ?? null,
+            verdict,
+            ...(reason ? { reason } : {}),
+        };
+        const target = logPath ?? process.env.EXPERIENCE_ACTIVITY_LOG ?? path.join(os.homedir(), ".experience", "activity.jsonl");
+        await fs.promises.appendFile(target, `${JSON.stringify(row)}\n`);
+    }
+    catch (err) {
+        const { logEeFailure, classifyEeError } = await import("../utils/ee-logger.js");
+        logEeFailure("search.mirrorFeedbackLocally", classifyEeError(err), err);
+    }
+}
+/** Reachability probe for the EE server. */
+export async function healthEE() {
+    const { createEEClient } = await import("./client.js");
+    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./auth.js");
+    const authToken = (await loadEEAuthToken()) ?? undefined;
+    const baseUrl = getCachedServerBaseUrl() ?? undefined;
+    return createEEClient({ baseUrl, authToken }).health();
+}
+//# sourceMappingURL=search.js.map

package/dist/src/ee/session-trajectory.js

@@ -62,7 +62,7 @@ export async function appendTrajectoryEvent(event) {
         }
         await fs.mkdir(_sessionsDir, { recursive: true });
         const file = sessionFilePath(event.sessionId);
-        const line = JSON.stringify(event) + "\n";
+        const line = `${JSON.stringify(event)}\n`;
         await fs.appendFile(file, line, "utf8");
     }
     catch (err) {

package/dist/src/ee/session-trajectory.test.js

@@ -11,7 +11,7 @@ beforeEach(async () => {
     disableTrajectoryLogging(false);
 });
 afterEach(async () => {
-    await fs.rm(tmp, { recursive: true, force: true }).catch(() => { });
+    await fs.rm(tmp, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => { });
 });
 describe("session-trajectory / append", () => {
     it("appends one JSONL line per event", async () => {

package/dist/src/ee/transcript-emit.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Transcript emit — resilient sidecar to extractSession.
+ *
+ * Writes the in-memory ModelMessage[] of the current session to a JSONL file
+ * under `~/.experience/muonroi-cli-sessions/{sessionId}.jsonl` using the SAME
+ * shape that Claude Code's `~/.claude/projects/*.jsonl` uses (one entry per
+ * message with `{ message: { role, content: [...blocks] } }`).
+ *
+ * Why this exists alongside extract-session.ts:
+ * - extractSession() POSTs directly to EE /api/extract — fast path, depends on
+ *   the engine being up at the moment of session-end / clear / compact.
+ * - This module is the SLOW PATH: dump-to-disk so the EE stop-extractor
+ *   backfill loop can pick the file up later, even if:
+ *     1. EE was offline at session-end (network blip, engine restart),
+ *     2. user closed the terminal with X (Node exits before HTTP fires),
+ *     3. user ran /compact (we want lessons from the compacted history too).
+ *
+ * The output mirrors Claude's JSONL shape so the existing
+ * stop-extractor `buildClaudeSessionData()` parser handles it unmodified —
+ * we just add a new scan path.
+ */
+import type { ModelMessage } from "ai";
+type ClaudeBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    content: string;
+};
+type ClaudeJsonlEntry = {
+    message: {
+        role: "user" | "assistant" | "tool" | "system";
+        content: ClaudeBlock[];
+    };
+    ts: string;
+    source: "muonroi-cli";
+    reason: "cli-exit" | "cli-clear" | "cli-compact" | "cli-signal";
+};
+/**
+ * Emit the session transcript to disk for later EE backfill.
+ *
+ * Returns the path written to, or null if no eligible content / sessionId.
+ * All errors swallowed — this is best-effort, never blocks shutdown.
+ */
+export declare function emitTranscriptToDisk(messages: ModelMessage[], sessionId: string | null | undefined, reason: ClaudeJsonlEntry["reason"], cwd?: string | null): string | null;
+export declare function getEmitRoot(): string;
+export {};