muonroi-cli 1.7.1 → 1.8.0

package/dist/src/council/prompts.js

@@ -28,6 +28,11 @@ export function buildClarificationPrompt(topic, conversationContext, previousQA)
             `the project IS the one described in the "## Current Project" section of the context. DO NOT ask which project.\n` +
             `- Only ask about project identity when the topic mentions multiple distinct projects or external products.\n` +
             `- Use the project's package.json name and description as implicit context for follow-up questions.\n\n` +
+            `## Language Rule (mandatory)\n` +
+            `Write the "question", "why", and every "suggestions"/"recommended" option in the SAME ` +
+            `language the user used in the Topic below — detect it; if the user wrote Vietnamese, write ` +
+            `Vietnamese; if English, English. The user reads and answers these on a card, so they must ` +
+            `NOT default to English. Keep code identifiers, file paths, tech/product names, and JSON keys in English.\n\n` +
             `Output ONLY a JSON array (no markdown, no preamble):\n` +
             `[{"question": "...", "why": "why this matters for a focused discussion", "suggestions": ["option A", "option B"], "recommended": "option A", "isRequired": true}]\n\n` +
             `Rules for "recommended" (be decisive — the user should never face an unranked list):\n` +
@@ -49,7 +54,15 @@ export function buildSpecSynthesisPrompt(topic, conversationContext, qa) {
             `  "constraints": ["constraint 1", "constraint 2"],\n` +
             `  "successCriteria": ["criterion 1", "criterion 2"],\n` +
             `  "scope": "what is in and out of scope"\n` +
-            `}`,
+            `}\n\n` +
+            `## Language Rule (mandatory)\n` +
+            `Write EVERY field (problemStatement, constraints, successCriteria, scope) in the SAME ` +
+            `language the user used — detect it from the Original Topic and Clarification Q&A below. ` +
+            `If the user wrote Vietnamese, write Vietnamese; if English, English. Do NOT default to ` +
+            `English. This brief is shown to the user on the approval card AND the final synthesis ` +
+            `detects its output language from this problemStatement, so writing it in the wrong ` +
+            `language drags the whole council's output off the user's language. Keep code identifiers, ` +
+            `tech/product names, and JSON keys in English.`,
         prompt: `## Original Topic\n${topic}\n\n` +
             (conversationContext ? `## Context\n${conversationContext}\n\n` : "") +
             `## Clarification Q&A\n${qa.map((qa) => `Q: ${qa.question}\nA: ${qa.answer}`).join("\n\n")}`,
@@ -146,6 +159,25 @@ const EVIDENCE_RULE_FOLLOWUP = `\n## Evidence Rule\n` +
     `- Most follow-up turns will not need any tool call.\n` +
     `Tag verified results: \`[CONFIRMED via <tool>:<evidence>]\` or \`[REFUTED via <tool>:<evidence>]\`.\n` +
     `Uncited numbers you cannot verify: \`[UNVERIFIED: <claim>]\`.\n`;
+/**
+ * Length discipline injected into every debate turn (F13 token-thrift). The
+ * debate-turn ceilings are generous (4096-6144 maxTokens) and reasoning models
+ * left unbounded emit ~400-600 words/turn — ~17 turns/debate is token-heavy and
+ * directly fights the "tiết kiệm token" goal. A concrete word cap + "density
+ * over length" cuts filler / preamble / brief-restating while keeping the
+ * analytical core (position, reasoning bullets, the cross-question). This does
+ * NOT lower maxTokens: reasoning models need that headroom to think without
+ * empty-turn truncation (see llm.ts) — the saving comes from the model writing
+ * less, not from a hard output ceiling. The text deliberately contains none of
+ * the prompt substrings the council mocks route on (e.g. "responding to",
+ * "continuing a discussion", "team lead", "Summarize this discussion").
+ */
+function concisenessRule(maxWords) {
+    return (`\n## Length (be token-thrifty)\n` +
+        `Keep this turn under ~${maxWords} words. Open with your position in one line, ` +
+        `then 2-4 bullets of your strongest reasoning. No preamble, no restating the ` +
+        `brief, no filler — density over length. A tight argument beats a long one.\n`);
+}
 /** Resolve the persona label used inside debate prompts. Stance wins; role is fallback. */
 function personaOf(role, stance) {
     if (stance) {
@@ -171,6 +203,7 @@ export function buildOpeningPrompt(ctx) {
             focusLine +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_OPENING +
+            concisenessRule(220) +
             (stackLock ? `\n${stackLock}\n` : "") +
             guardrails +
             (ctx.conversationContext ? `\n## Conversation Context\n${ctx.conversationContext}\n\n---\n\n` : "\n") +
@@ -192,6 +225,7 @@ export function buildResponsePrompt(ctx) {
         system: `You are the "${me.label}" (lens: ${me.lens}) responding to the "${them.label}" (lens: ${them.lens}).\n` +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_RESPONSE +
+            concisenessRule(160) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n## Discussion Brief\n` +
             `Problem: ${ctx.spec.problemStatement}\n` +
@@ -216,6 +250,7 @@ export function buildFollowupPrompt(ctx) {
         system: `You are the "${me.label}" (lens: ${me.lens}) continuing a discussion (round ${ctx.round}) with the "${them.label}" (lens: ${them.lens}).\n` +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_FOLLOWUP +
+            concisenessRule(140) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n` +
             (ctx.runningSummary
@@ -513,33 +548,33 @@ export function buildSynthesisPrompt(ctx) {
     }
     let extraContext = "";
     if (ctx.refineContext) {
-        extraContext += `
-## User Refinements
-${ctx.refineContext}
+        extraContext += `
+## User Refinements
+${ctx.refineContext}
 `;
     }
     if (ctx.planEmphasis) {
-        extraContext += `
-## Additional Instruction
-The user has requested a concrete action plan with executable steps. Each action item MUST be an object with these fields:
-  {
-    "step": "<imperative action>",
-    "owner_lens": "<which stance owns this — frontend / backend / architecture / etc>",
-    "time_estimate": "<rough — e.g. '2h', '1d', '~30min'>",
-    "depends_on": ["<step keys this requires>"] or [],
-    "acceptance_criteria": "<how we know it's done>"
-  }
-Order action items by dependency: predecessors first, dependents after.
-Risks MUST be objects with: {"description", "severity": "High|Medium|Low", "mitigation"}.
-Do NOT emit loose strings for these fields — the user needs structured plan output.
+        extraContext += `
+## Additional Instruction
+The user has requested a concrete action plan with executable steps. Each action item MUST be an object with these fields:
+  {
+    "step": "<imperative action>",
+    "owner_lens": "<which stance owns this — frontend / backend / architecture / etc>",
+    "time_estimate": "<rough — e.g. '2h', '1d', '~30min'>",
+    "depends_on": ["<step keys this requires>"] or [],
+    "acceptance_criteria": "<how we know it's done>"
+  }
+Order action items by dependency: predecessors first, dependents after.
+Risks MUST be objects with: {"description", "severity": "High|Medium|Low", "mitigation"}.
+Do NOT emit loose strings for these fields — the user needs structured plan output.
 `;
     }
     return {
         system,
-        prompt: `Final positions:
-${ctx.finalPositions}
-
-Full discussion:
+        prompt: `Final positions:
+${ctx.finalPositions}
+
+Full discussion:
 ${ctx.allExchanges}${extraContext}`,
     };
 }

package/dist/src/council/types.d.ts

@@ -211,6 +211,13 @@ export interface CouncilConfig {
     internetFirst?: boolean;
     /** When true, leader sub-tasks downshift to cheaper tier models on the same provider. */
     costAware?: boolean;
+    /**
+     * Enclosing council run id (= sessionId). Used only as the correlationId on the
+     * observe-only `council-turn-length` harness event so per-turn length samples can
+     * be grouped by run. Optional: direct callers/tests may omit it (falls back to a
+     * stable literal); has no effect on debate behaviour.
+     */
+    runId?: string;
 }
 /**
  * JSON shape persisted as `[Council Memory] {...}` in the session messages.
@@ -270,7 +277,13 @@ export interface CouncilCallUsage {
 }
 export type UsageCallback = (usage: CouncilCallUsage) => void;
 export interface CouncilLLM {
-    generate(modelId: string, system: string, prompt: string, maxTokens?: number, onUsage?: UsageCallback): Promise<string>;
+    generate(modelId: string, system: string, prompt: string, maxTokens?: number, onUsage?: UsageCallback, 
+    /**
+     * User-abort signal. Threaded so a mid-council cancel (Esc/Ctrl-C) aborts
+     * the in-flight generate call. Trailing+optional for back-compat — existing
+     * positional callers/mocks are unaffected. See withCouncilSignal in index.ts.
+     */
+    signal?: AbortSignal): Promise<string>;
     research(modelId: string, topic: string, conversationContext: string, signal?: AbortSignal, persistTrace?: ToolTraceEmitter, options?: {
         internetFirst?: boolean;
     }, onUsage?: UsageCallback): Promise<string>;

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

@@ -49,7 +49,7 @@ function bootstrapDb(sessions) {
     db.close();
 }
 beforeEach(() => {
-    tmpHome = join(tmpdir(), "muonroi-test-export-" + Date.now());
+    tmpHome = join(tmpdir(), `muonroi-test-export-${Date.now()}`);
     const muonroiDir = join(tmpHome, ".muonroi-cli");
     const experienceDir = join(tmpHome, ".experience");
     mkdirSync(muonroiDir, { recursive: true });

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

@@ -1,4 +1,6 @@
 import { type PilContextResponse } from "../pil/schema.js";
+export type { WhoAmIDim, WhoAmIDimName, WhoAmIProfile } from "./who-am-i.js";
+export { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache } from "./who-am-i.js";
 interface EEPoint {
     id: string | number;
     score?: number;
@@ -37,7 +39,7 @@ export type { EEPoint, EERouteResult, EERouteTaskResult };
  *   2. Fat clients (local experience-core.js present) → in-process call.
  *   3. Otherwise → null (caller falls back to regex/keyword paths).
  */
-export declare function classifyViaBrain(prompt: string, timeoutMs?: number): Promise<string | null>;
+export declare function classifyViaBrain(prompt: string, timeoutMs?: number, options?: import("./types.js").BrainProxyOptions): Promise<string | null>;
 /**
  * Search a named Qdrant collection by embedding vector.
  * Falls back to FileStore inside experience-core.js if Qdrant is unavailable.

package/dist/src/ee/bridge.js

@@ -11,6 +11,12 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { PilContextResponseSchema } from "../pil/schema.js";
 import { classifyEeError, logEeFailure, readTimeoutEnv, withEeTimeout } from "../utils/ee-logger.js";
+// "Who Am I" v4.0 profile access. Re-exported through the bridge so PIL layers
+// reach it via the single sanctioned EE entry point (see the no-network-in-pil
+// arch guard: layer1/types may import `../ee/bridge` only). The provider is
+// local-only (no network), cached, and fail-open — the same contract as the rest
+// of this bridge.
+export { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache } from "./who-am-i.js";
 /**
  * Phase 21.5 — `routeModel` / `routeTask` budget. EE server unreachability used
  * to hang `/ideal` for the OS-level fetch connect timeout (~5 min on Windows).
@@ -82,7 +88,7 @@ async function silentCall(fn) {
  *   2. Fat clients (local experience-core.js present) → in-process call.
  *   3. Otherwise → null (caller falls back to regex/keyword paths).
  */
-export async function classifyViaBrain(prompt, timeoutMs = 5000) {
+export async function classifyViaBrain(prompt, timeoutMs = 5000, options) {
     // Thin-client HTTP path — required for CLIs without local experience-core.js.
     try {
         const { getCachedEEClientMode } = await import("./client-mode.js");
@@ -92,7 +98,7 @@ export async function classifyViaBrain(prompt, timeoutMs = 5000) {
             : !!(await import("./auth.js")).getCachedServerBaseUrl();
         if (useRemote) {
             const { getDefaultEEClient } = await import("./intercept.js");
-            const result = await getDefaultEEClient().brainProxy(prompt, timeoutMs);
+            const result = await getDefaultEEClient().brainProxy(prompt, timeoutMs, options);
             if (typeof result === "string")
                 return result;
             // Server unreachable — fall through to in-process path so a fat-client
@@ -110,7 +116,7 @@ export async function classifyViaBrain(prompt, timeoutMs = 5000) {
     try {
         // Race the in-process call against `timeoutMs + 200ms` so a buggy core that
         // ignores its own timeout argument cannot hang the host CLI.
-        return await withEeTimeout(silentCall(() => core.classifyViaBrain(prompt, timeoutMs)), timeoutMs + 200);
+        return await withEeTimeout(silentCall(() => core.classifyViaBrain(prompt, timeoutMs, options)), timeoutMs + 200);
     }
     catch (err) {
         logEeFailure("bridge.classifyViaBrain", classifyEeError(err), err, {

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

@@ -52,7 +52,7 @@ describe("bridge — loaded core", () => {
     it("Test 1: classifyViaBrain returns classification string when core loaded", async () => {
         const result = await classifyViaBrain("write a function to sort an array");
         expect(result).toBe("generate");
-        expect(mockCore.classifyViaBrain).toHaveBeenCalledWith("write a function to sort an array", 5000);
+        expect(mockCore.classifyViaBrain).toHaveBeenCalledWith("write a function to sort an array", 5000, undefined);
     });
     it("Test 2: searchCollection returns EEPoint[] when core loaded", async () => {
         const vector = [0.1, 0.2, 0.3];
@@ -210,7 +210,6 @@ describe("bridge — config isolation (BRIDGE-03)", () => {
         const _validCall = () => classifyViaBrain("prompt");
         const _validCallWithTimeout = () => classifyViaBrain("prompt", 3000);
         // These would cause @ts-expect-error if uncommented:
-        // @ts-expect-error — qdrantUrl is not a valid parameter
         const _invalidCall = () => classifyViaBrain("prompt", 3000, "http://localhost:6333");
         expect(_validCall).toBeDefined();
         expect(_validCallWithTimeout).toBeDefined();

package/dist/src/ee/client.js

@@ -568,7 +568,7 @@ export function createEEClient(opts = {}) {
                 return null;
             }
         },
-        async brainProxy(prompt, timeoutMs = 2000) {
+        async brainProxy(prompt, timeoutMs = 2000, options) {
             try {
                 // Tight client-side ceiling (~150ms grace over caller's intent budget)
                 // so we never wait longer than the PIL pipeline can use the result.
@@ -576,10 +576,23 @@ export function createEEClient(opts = {}) {
                 // we forward in the body — both ends abort together.
                 const ctrl = new AbortController();
                 const t = setTimeout(() => ctrl.abort(), timeoutMs + 150);
+                const body = { prompt, timeoutMs };
+                if (options) {
+                    if (options.systemPrompt)
+                        body.systemPrompt = options.systemPrompt;
+                    if (options.responseFormat)
+                        body.responseFormat = options.responseFormat;
+                    if (options.model)
+                        body.model = options.model;
+                    if (options.maxTokens != null)
+                        body.maxTokens = options.maxTokens;
+                    if (options.provider)
+                        body.provider = options.provider;
+                }
                 const resp = await f(`${baseUrl}/api/brain`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify({ prompt, timeoutMs }),
+                    body: JSON.stringify(body),
                     signal: ctrl.signal,
                 });
                 clearTimeout(t);

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

@@ -22,6 +22,8 @@ export interface RecallLedger {
     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;
+    /** Check if an id was ever cleared (fed back) in this session. Used by PIL Layer 3 to suppress re-injection. */
+    wasCleared(id: string): boolean;
     /** Oldest-first list of still-unrated recalls. */
     pending(): PendingRecall[];
     pendingCount(): number;
@@ -30,3 +32,21 @@ export interface RecallLedger {
 export declare function createRecallLedger(): RecallLedger;
 /** Process-scoped singleton = the current MCP session's unrated-recall debt. */
 export declare const sessionRecallLedger: RecallLedger;
+/**
+ * Whether the recall-feedback ledger is active. Mirrors the gate env the external
+ * MCP ee.query already honours (EXPERIENCE_RECALL_FEEDBACK_GATE) so an operator
+ * can disable in-CLI ledger accounting with the same switch. In-CLI we only need
+ * on/off — never a hard refusal — so a turn is never blocked. Default on (soft).
+ */
+export declare function isRecallLedgerEnabled(): boolean;
+/**
+ * Compact, token-bounded reminder of still-unrated surfaced/recalled handles, for
+ * injection next to the `[id]` handles the agent already saw. Names the actual
+ * `{id, collection}` pairs so an `ee_feedback(id, collection, verdict)` call is
+ * actionable — the legacy static nudge named no ids, so the model could not
+ * complete the rating even when willing. Capped so a long session can't bloat the
+ * prompt (token-thrift).
+ */
+export declare function formatPendingReminder(pending: PendingRecall[], opts?: {
+    max?: number;
+}): string;

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

@@ -12,6 +12,8 @@
  */
 export function createRecallLedger() {
     const map = new Map();
+    // Tracks ids that have been fed back, so PIL Layer 3 can suppress re-injection.
+    const cleared = new Set();
     return {
         record(entries, query) {
             if (!Array.isArray(entries))
@@ -34,7 +36,14 @@ export function createRecallLedger() {
             }
         },
         clear(id) {
-            return map.delete(String(id ?? "").trim());
+            const nid = String(id ?? "").trim();
+            const deleted = map.delete(nid);
+            if (deleted)
+                cleared.add(nid);
+            return deleted;
+        },
+        wasCleared(id) {
+            return cleared.has(String(id ?? "").trim());
         },
         pending() {
             return [...map.values()].sort((a, b) => a.ts - b.ts);
@@ -44,9 +53,39 @@ export function createRecallLedger() {
         },
         reset() {
             map.clear();
+            cleared.clear();
         },
     };
 }
 /** Process-scoped singleton = the current MCP session's unrated-recall debt. */
 export const sessionRecallLedger = createRecallLedger();
+/**
+ * Whether the recall-feedback ledger is active. Mirrors the gate env the external
+ * MCP ee.query already honours (EXPERIENCE_RECALL_FEEDBACK_GATE) so an operator
+ * can disable in-CLI ledger accounting with the same switch. In-CLI we only need
+ * on/off — never a hard refusal — so a turn is never blocked. Default on (soft).
+ */
+export function isRecallLedgerEnabled() {
+    return (String(process.env.EXPERIENCE_RECALL_FEEDBACK_GATE ?? "soft")
+        .trim()
+        .toLowerCase() !== "off");
+}
+/**
+ * Compact, token-bounded reminder of still-unrated surfaced/recalled handles, for
+ * injection next to the `[id]` handles the agent already saw. Names the actual
+ * `{id, collection}` pairs so an `ee_feedback(id, collection, verdict)` call is
+ * actionable — the legacy static nudge named no ids, so the model could not
+ * complete the rating even when willing. Capped so a long session can't bloat the
+ * prompt (token-thrift).
+ */
+export function formatPendingReminder(pending, opts = {}) {
+    if (pending.length === 0)
+        return "";
+    const max = Math.max(1, Math.min(opts.max ?? 5, 20));
+    const shown = pending.slice(0, max);
+    const lines = shown.map((p) => `  - [${p.id} ${p.collection ?? "?"}]`);
+    const more = pending.length > max ? `\n  …and ${pending.length - max} more` : "";
+    return (`↳ ${pending.length} earlier EE hint(s) still unrated — rate the one(s) you acted on so the brain keeps what helped: ` +
+        `ee_feedback(id, collection, followed|ignored|noise).\n${lines.join("\n")}${more}`);
+}
 //# sourceMappingURL=recall-ledger.js.map

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

@@ -92,6 +92,31 @@ export declare function feedbackEE(pointId: string, collection: string, verdict:
  * 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>;
+export interface WriteExperienceResult {
+    ok: boolean;
+    id?: string;
+    error?: string;
+}
+/**
+ * Write a NEW experience/lesson into the brain mid-session so it is RECALLABLE.
+ * POSTs to /api/import-memory → storeImportedExperience → upsertEntry, which
+ * embeds the text AND writes the `text_bm25` sparse vector (+ a proper payload via
+ * buildStorePayload). That dense+sparse write is what makes the lesson reliably
+ * recallable via ee_query / passive injection (both the dense and lexical legs can
+ * match it). NB: /api/ingest-point writes DENSE-ONLY (no sparse) — its points are
+ * lexically invisible and only surface on a strong dense match, so they are NOT
+ * reliably recallable; do not use it for recall-critical writes.
+ *
+ * This is the missing "agent proactively records a mistake→fix lesson" arm of the
+ * recall loop: ee_query recalls, ee_feedback rates, ee_write creates. Mirrors
+ * feedbackEE's direct-fetch transport (cached baseUrl + bearer token); fails soft.
+ */
+export declare function writeExperienceEE(lesson: string, opts?: {
+    collection?: string;
+    title?: string;
+    projectSlug?: string;
+    confidence?: number;
+}): Promise<WriteExperienceResult>;
 /** Reachability probe for the EE server. */
 export declare function healthEE(): Promise<{
     ok: boolean;

package/dist/src/ee/search.js

@@ -211,6 +211,79 @@ export async function mirrorFeedbackLocally(pointId, collection, verdict, reason
         logEeFailure("search.mirrorFeedbackLocally", classifyEeError(err), err);
     }
 }
+/**
+ * Write a NEW experience/lesson into the brain mid-session so it is RECALLABLE.
+ * POSTs to /api/import-memory → storeImportedExperience → upsertEntry, which
+ * embeds the text AND writes the `text_bm25` sparse vector (+ a proper payload via
+ * buildStorePayload). That dense+sparse write is what makes the lesson reliably
+ * recallable via ee_query / passive injection (both the dense and lexical legs can
+ * match it). NB: /api/ingest-point writes DENSE-ONLY (no sparse) — its points are
+ * lexically invisible and only surface on a strong dense match, so they are NOT
+ * reliably recallable; do not use it for recall-critical writes.
+ *
+ * This is the missing "agent proactively records a mistake→fix lesson" arm of the
+ * recall loop: ee_query recalls, ee_feedback rates, ee_write creates. Mirrors
+ * feedbackEE's direct-fetch transport (cached baseUrl + bearer token); fails soft.
+ */
+export async function writeExperienceEE(lesson, opts = {}) {
+    const { loadEEAuthToken, getCachedServerBaseUrl } = await import("./auth.js");
+    const { randomUUID } = await import("node:crypto");
+    const authToken = (await loadEEAuthToken()) ?? undefined;
+    const baseUrl = (getCachedServerBaseUrl() ?? "http://localhost:8082").replace(/\/+$/, "");
+    const collection = opts.collection ?? "experience-behavioral";
+    const id = randomUUID();
+    // storeImportedExperience embeds `${qa.trigger} ${qa.question} ${qa.solution}`,
+    // so put the lesson in solution (and the title in question) to anchor the vector.
+    const qa = {
+        trigger: "",
+        question: opts.title ?? "",
+        solution: lesson,
+        scope: opts.projectSlug ? { project_slug: opts.projectSlug } : {},
+    };
+    const body = {
+        experiences: [
+            {
+                id,
+                collection,
+                qa,
+                tier: 2,
+                confidence: opts.confidence ?? 0.65,
+                runtime: "muonroi-cli-agent",
+            },
+        ],
+    };
+    const headers = { "Content-Type": "application/json" };
+    if (authToken)
+        headers.Authorization = `Bearer ${authToken}`;
+    try {
+        const res = await fetch(`${baseUrl}/api/import-memory`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+        const respText = await res.text();
+        let parsed = null;
+        try {
+            parsed = JSON.parse(respText);
+        }
+        catch {
+            /* non-JSON error body — fall through to status handling */
+        }
+        if (!res.ok) {
+            return { ok: false, error: parsed?.error || respText || `HTTP ${res.status}` };
+        }
+        const r0 = parsed?.results?.[0];
+        if (!parsed?.stored || r0?.ok !== true) {
+            return { ok: false, error: r0?.reason ?? "not_stored" };
+        }
+        return { ok: true, id };
+    }
+    catch (err) {
+        const { logEeFailure, classifyEeError } = await import("../utils/ee-logger.js");
+        logEeFailure("search.writeExperienceEE", classifyEeError(err), err);
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
 /** Reachability probe for the EE server. */
 export async function healthEE() {
     const { createEEClient } = await import("./client.js");

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

@@ -361,6 +361,20 @@ export interface EERecallOptions {
 export interface EEUserResponse {
     user: string;
 }
+export interface BrainProxyOptions {
+    /** Override the default system prompt sent to the LLM. */
+    systemPrompt?: string;
+    /** Request JSON-mode response_format (e.g. { type: "json_object" }). */
+    responseFormat?: {
+        type: string;
+    };
+    /** Override the LLM model id used for classification. */
+    model?: string;
+    /** Override max_tokens for the LLM response. */
+    maxTokens?: number;
+    /** Override the brain provider (siliconflow | ollama | openai | ...). */
+    provider?: string;
+}
 export interface EEClient {
     health(): Promise<{
         ok: boolean;
@@ -392,7 +406,7 @@ export interface EEClient {
     /** Active recall via /api/recall (recallMode). Returns [id col] index + records a surface. */
     recall(query: string, opts?: EERecallOptions): Promise<EERecallResponse | null>;
     user(): Promise<EEUserResponse | null>;
-    brainProxy(prompt: string, timeoutMs?: number): Promise<string | null>;
+    brainProxy(prompt: string, timeoutMs?: number, options?: BrainProxyOptions): Promise<string | null>;
     pilContext(prompt: string, options?: {
         localeHint?: string;
         projectCtx?: Record<string, unknown>;

package/dist/src/ee/who-am-i.d.ts

@@ -0,0 +1,41 @@
+import type { OutputStyle } from "../pil/types.js";
+export type PrivacyLevel = "minimal" | "standard" | "full";
+export type WhoAmIDimName = "communication.question_style" | "communication.feedback_style" | "communication.brevity" | "personality.conflict_style" | "personality.risk_tolerance" | "personality.decision_speed" | "work_patterns.energy" | "work_patterns.multitasking" | "work_patterns.session_length" | "work_patterns.delegation_style";
+export interface WhoAmIDim {
+    value: string;
+    confidence: number;
+    samples: number;
+}
+export interface WhoAmIProfile {
+    level: PrivacyLevel;
+    dims: Partial<Record<WhoAmIDimName, WhoAmIDim>>;
+}
+interface RawDim {
+    value: string | null;
+    confidence?: number;
+    sampleCount?: number;
+    samples?: number;
+}
+interface RawProfile {
+    dimensions?: Record<string, RawDim>;
+}
+/**
+ * PURE: project a raw EE profile to the privacy-gated dims for `level`, applying the
+ * positive name allowlist + value!=null commit gate + per-tier confidence floor.
+ */
+export declare function selectWhoAmIDims(raw: RawProfile | null | undefined, level: PrivacyLevel): WhoAmIProfile["dims"];
+/**
+ * PURE: derive an output-style baseline from the profile. brevity is the primary
+ * signal; decision_speed is a weaker fallback. Returns null when no usable signal
+ * exists so the caller keeps its own per-turn default.
+ */
+export declare function outputStyleFromProfile(profile: WhoAmIProfile | null): OutputStyle | null;
+/**
+ * Load + cache the privacy-gated profile for this process. The profile changes
+ * slowly (rebuilt by the EE Stop hook), so one read per process is enough.
+ * Returns null when EE is not installed, privacy is off, or nothing is committed.
+ */
+export declare function getWhoAmIProfile(): WhoAmIProfile | null;
+/** Clear the cache — test-only / after a known profile change. */
+export declare function resetWhoAmICache(): void;
+export {};