muonroi-cli 1.7.2 → 1.8.1

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 {};

package/dist/src/ee/who-am-i.js

@@ -0,0 +1,143 @@
+// src/ee/who-am-i.ts
+//
+// "Who Am I" v4.0 profile provider for the PIL. The personality/work-style profile
+// is DEVICE-LOCAL (~/.experience/profile.yaml) and never leaves the machine, so it
+// cannot come from the EE HTTP API — we read it on-device, reusing the EE install's
+// parser (profile-model.js loadProfile) + privacy gate (config.js getPrivacyLevel)
+// via createRequire (the same in-process pattern as src/ee/bridge.ts).
+//
+// Privacy is enforced HERE at read time via a positive per-dimension-NAME allowlist
+// (defense in depth): the EE writer keeps committed values regardless of privacyLevel,
+// so a standard→minimal downgrade leaves stale Tang-2 values physically in the file —
+// trusting the file would leak opted-out data. Mirrors experience-engine
+// src/profile-render.js. Fail-open: any error / missing EE install returns null and the
+// PIL keeps its own per-turn defaults.
+import { createRequire } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
+// Tang 1 (work patterns + activity-derived decision_speed — namespaced personality.*
+// but its SOURCE is activity, so it belongs to the minimal tier; allowlist by NAME).
+const TIER_MINIMAL = [
+    "work_patterns.energy",
+    "work_patterns.multitasking",
+    "work_patterns.session_length",
+    "personality.decision_speed",
+];
+// Tang 2 (decision + communication style) added at standard. `full` == standard today
+// (no Tang-3 emotional dims exist); the allowlist guarantees emotional.* can never leak.
+const TIER_STANDARD = [
+    ...TIER_MINIMAL,
+    "communication.question_style",
+    "communication.feedback_style",
+    "communication.brevity",
+    "personality.conflict_style",
+    "personality.risk_tolerance",
+    // delegation_style is `work_patterns.*` by name but transcript-derived, so it commits
+    // only at standard+ (the EE writer skips the transcript at `minimal`). Standard-only.
+    "work_patterns.delegation_style",
+];
+const ALLOWLIST = {
+    minimal: TIER_MINIMAL,
+    standard: TIER_STANDARD,
+    full: TIER_STANDARD,
+};
+const WORK_DIMS = new Set(TIER_MINIMAL);
+// Coarse work dims commit over 2-3-way splits (confidence ~0.45-0.6); the lower floor
+// keeps the minimal tier usable. Mirrors experience-engine src/profile-render.js.
+const WORK_MIN_CONFIDENCE = 0.45;
+const MIN_CONFIDENCE = 0.6;
+/**
+ * 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 function selectWhoAmIDims(raw, level) {
+    const out = {};
+    const allow = ALLOWLIST[level];
+    if (!allow || !raw?.dimensions)
+        return out;
+    for (const name of allow) {
+        const d = raw.dimensions[name];
+        if (!d || d.value == null)
+            continue;
+        const confidence = Number(d.confidence) || 0;
+        const floor = WORK_DIMS.has(name) ? WORK_MIN_CONFIDENCE : MIN_CONFIDENCE;
+        if (confidence < floor)
+            continue;
+        out[name] = {
+            value: String(d.value),
+            confidence,
+            samples: Math.round(Number(d.sampleCount ?? d.samples) || 0),
+        };
+    }
+    return out;
+}
+/**
+ * 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 function outputStyleFromProfile(profile) {
+    if (!profile)
+        return null;
+    const brevity = profile.dims["communication.brevity"]?.value;
+    if (brevity === "concise")
+        return "concise";
+    if (brevity === "verbose")
+        return "detailed";
+    if (brevity === "moderate")
+        return "balanced";
+    const speed = profile.dims["personality.decision_speed"]?.value;
+    if (speed === "fast-intuitive")
+        return "concise";
+    if (speed === "deliberate")
+        return "detailed";
+    return null;
+}
+let _cache;
+/**
+ * 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 function getWhoAmIProfile() {
+    if (_cache !== undefined)
+        return _cache;
+    _cache = loadWhoAmIProfile();
+    return _cache;
+}
+/** Clear the cache — test-only / after a known profile change. */
+export function resetWhoAmICache() {
+    _cache = undefined;
+}
+function loadWhoAmIProfile() {
+    try {
+        const req = createRequire(import.meta.url);
+        const srcDir = path.join(os.homedir(), ".experience", "src");
+        const config = req(path.join(srcDir, "config.js"));
+        const model = req(path.join(srcDir, "profile-model.js"));
+        if (typeof config.getPrivacyLevel !== "function" || typeof config.getProfilePath !== "function")
+            return null;
+        if (typeof model.loadProfile !== "function")
+            return null;
+        const level = String(config.getPrivacyLevel() ?? "off");
+        if (level !== "minimal" && level !== "standard" && level !== "full")
+            return null;
+        const raw = model.loadProfile(config.getProfilePath());
+        const dims = selectWhoAmIDims(raw, level);
+        if (Object.keys(dims).length === 0)
+            return null;
+        return { level, dims };
+    }
+    catch (err) {
+        // EE not installed (module absent) is an expected feature-off condition, not a
+        // failure — stay quiet. Any other error (corrupt profile, throwing module) is a
+        // real fault: log it (No-Silent-Catch) and degrade.
+        const code = err?.code;
+        if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
+            logEeFailure("who-am-i.load", classifyEeError(err), err);
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=who-am-i.js.map

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

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

package/dist/src/ee/who-am-i.test.js

@@ -0,0 +1,101 @@
+import * as os from "node:os";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache, selectWhoAmIDims, } from "./who-am-i.js";
+// Build a raw EE profile (the shape ~/.experience/src/profile-model.js loadProfile() returns).
+function rawDim(value, confidence, sampleCount = 20) {
+    return { value, confidence, sampleCount, distribution: {}, evidence: null };
+}
+function rawProfile(dims) {
+    return { version: 1, updatedAt: null, dimensions: dims };
+}
+describe("selectWhoAmIDims — privacy allowlist + commit/confidence gates", () => {
+    const all = () => rawProfile({
+        "communication.question_style": rawDim("directive", 0.8),
+        "communication.feedback_style": rawDim("implicit", 0.75),
+        "communication.brevity": rawDim("concise", 0.83),
+        "personality.conflict_style": rawDim("direct-constructive", 0.7),
+        "personality.risk_tolerance": rawDim("experimental", 0.72),
+        "personality.decision_speed": rawDim("fast-intuitive", 0.7),
+        "work_patterns.energy": rawDim("night-owl", 0.6),
+        "work_patterns.multitasking": rawDim("sequential-deep", 0.65),
+        "work_patterns.session_length": rawDim("long", 0.55),
+        "work_patterns.delegation_style": rawDim("autonomous", 0.68),
+    });
+    test("minimal exposes only the 4 Tang-1 work dims", () => {
+        const dims = selectWhoAmIDims(all(), "minimal");
+        expect(Object.keys(dims).sort()).toEqual([
+            "personality.decision_speed",
+            "work_patterns.energy",
+            "work_patterns.multitasking",
+            "work_patterns.session_length",
+        ].sort());
+    });
+    test("standard exposes all 10 committed dims", () => {
+        const dims = selectWhoAmIDims(all(), "standard");
+        expect(Object.keys(dims).length).toBe(10);
+    });
+    test("delegation_style is standard-only — stripped at minimal (transcript-derived, not Tang-1)", () => {
+        expect(selectWhoAmIDims(all(), "minimal")["work_patterns.delegation_style"]).toBeUndefined();
+        expect(selectWhoAmIDims(all(), "standard")["work_patterns.delegation_style"]).toBeDefined();
+    });
+    test("standard-built profile rendered at minimal strips Tang-2 dims (no stale leak)", () => {
+        const dims = selectWhoAmIDims(all(), "minimal");
+        expect(dims["communication.brevity"]).toBeUndefined();
+        expect(dims["personality.conflict_style"]).toBeUndefined();
+    });
+    test("pending (value=null) dims are skipped", () => {
+        const dims = selectWhoAmIDims(rawProfile({ "communication.brevity": rawDim(null, 0.9, 5) }), "standard");
+        expect(Object.keys(dims).length).toBe(0);
+    });
+    test("per-tier confidence floors: 0.55 Tang-2 drops at 0.6, 0.50 work survives at 0.45", () => {
+        const dims = selectWhoAmIDims(rawProfile({
+            "communication.brevity": rawDim("concise", 0.55),
+            "work_patterns.energy": rawDim("night-owl", 0.5),
+        }), "standard");
+        expect(dims["communication.brevity"]).toBeUndefined();
+        expect(dims["work_patterns.energy"]).toBeDefined();
+    });
+    test("Tang-3 emotional.* is never exposed (not in any allowlist)", () => {
+        const dims = selectWhoAmIDims(rawProfile({ "emotional.mood": rawDim("calm", 0.99) }), "full");
+        expect(Object.keys(dims).length).toBe(0);
+    });
+    test("decision_speed (personality.* but Tang-1) is allowed at minimal — namespace trap", () => {
+        const dims = selectWhoAmIDims(rawProfile({ "personality.decision_speed": rawDim("measured", 0.7) }), "minimal");
+        expect(dims["personality.decision_speed"]).toBeDefined();
+    });
+});
+describe("outputStyleFromProfile — brevity/decision_speed → OutputStyle", () => {
+    const p = (dims) => ({ level: "standard", dims });
+    test("brevity concise → concise, verbose → detailed, moderate → balanced", () => {
+        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "concise", confidence: 0.8, samples: 20 } }))).toBe("concise");
+        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "verbose", confidence: 0.8, samples: 20 } }))).toBe("detailed");
+        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "moderate", confidence: 0.8, samples: 20 } }))).toBe("balanced");
+    });
+    test("no brevity → decision_speed fast-intuitive → concise; deliberate → detailed", () => {
+        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "fast-intuitive", confidence: 0.7, samples: 20 } }))).toBe("concise");
+        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "deliberate", confidence: 0.7, samples: 20 } }))).toBe("detailed");
+    });
+    test("null profile or no usable dim → null (caller keeps its own default)", () => {
+        expect(outputStyleFromProfile(null)).toBeNull();
+        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "measured", confidence: 0.7, samples: 20 } }))).toBeNull();
+    });
+});
+describe("getWhoAmIProfile — fail-open + cache", () => {
+    const origHome = process.env.HOME;
+    const origUser = process.env.USERPROFILE;
+    beforeEach(() => {
+        resetWhoAmICache();
+    });
+    afterEach(() => {
+        process.env.HOME = origHome;
+        process.env.USERPROFILE = origUser;
+        resetWhoAmICache();
+    });
+    test("returns null when no EE install is present (no ~/.experience modules)", () => {
+        const empty = os.tmpdir(); // no .experience/src here
+        process.env.HOME = empty;
+        process.env.USERPROFILE = empty;
+        expect(getWhoAmIProfile()).toBeNull();
+    });
+});
+//# sourceMappingURL=who-am-i.test.js.map

package/dist/src/flow/compaction/index.d.ts

@@ -11,6 +11,7 @@ export interface CompactionResult {
     tokensBeforeCompress: number;
     tokensAfterCompress: number;
     historyPath: string;
+    summary: string;
 }
 /**
  * Orchestrate two-pass deliberate compaction.

package/dist/src/flow/compaction/index.js

@@ -49,6 +49,9 @@ export async function deliberateCompact(flowDir, messages, systemPrompt, tokenBu
     const historyPath = path.join(historyDir, `${timestamp}.md`);
     const fullSerialized = serializeConversation(messages);
     await atomicWriteText(historyPath, fullSerialized);
+    // Save full JSON history next to the md file for exact expand/restore
+    const jsonPath = path.join(historyDir, `${timestamp}.json`);
+    await atomicWriteText(jsonPath, JSON.stringify(messages, null, 2));
     // Token estimation before
     const tokensBefore = estimateConversationTokens(systemPrompt, messages);
     // Pass 2: Compress
@@ -58,6 +61,7 @@ export async function deliberateCompact(flowDir, messages, systemPrompt, tokenBu
         tokensBeforeCompress: tokensBefore,
         tokensAfterCompress: compressed.tokensAfter,
         historyPath,
+        summary: compressed.summary,
     };
 }
 //# sourceMappingURL=index.js.map

package/dist/src/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.7.2";
+export declare const PACKAGE_VERSION = "1.8.1";
 export declare const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/dist/src/generated/version.js

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
 // Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.7.2";
+export const PACKAGE_VERSION = "1.8.1";
 export const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";
 //# sourceMappingURL=version.js.map

package/dist/src/headless/council-answers.js

@@ -9,6 +9,7 @@ export function createCouncilAutoAnswerer(opts) {
         "pil-interview": [],
         "pil-acceptance": [],
         "tool-loop-cap": [],
+        "safety-override": [],
     };
     const preflightApprove = opts.file?.preflightApprove ?? true;
     return {

package/dist/src/headless/output.d.ts

@@ -1,5 +1,5 @@
 import type { ProcessMessageObserver } from "../orchestrator/agent-options.js";
-import type { StreamChunk, ToolCall, ToolResult } from "../types/index.js";
+import type { StreamChunk, StructuredResponse, ToolCall, ToolResult } from "../types/index.js";
 export type HeadlessOutputFormat = "text" | "json";
 export interface HeadlessWrites {
     stdout?: string;
@@ -42,6 +42,13 @@ export type HeadlessJsonEvent = {
         totalTokens?: number;
         costUsdTicks?: number;
     };
+} | {
+    type: "structured_response";
+    sessionID?: string;
+    stepNumber: number;
+    timestamp: number;
+    taskType: string;
+    data: Record<string, unknown>;
 } | {
     type: "error";
     sessionID?: string;
@@ -54,6 +61,28 @@ export declare function renderHeadlessPrelude(format: HeadlessOutputFormat, sess
  * Headless text output only. JSON streaming uses {@link createHeadlessJsonlEmitter} + `Agent.processMessage` observer.
  */
 export declare function renderHeadlessChunk(chunk: StreamChunk): HeadlessWrites;
+/**
+ * Plain-text rendering of a respond_* terminal answer for headless `--format
+ * text`. Mirrors the per-taskType layout of {@link StructuredResponseView}
+ * (src/ui/components/structured-response-view.tsx) but emits flat text (no ANSI
+ * box-drawing) so the answer pipes cleanly. Falls back to the primary text
+ * field, then raw JSON, for taskTypes without a dedicated layout.
+ */
+export declare function formatStructuredResponseText(sr: StructuredResponse): string;
+/**
+ * Stateful headless TEXT consumer. Streams tool/error progress to stderr (via
+ * {@link renderHeadlessChunk}) but BUFFERS assistant `content` so that a
+ * terminal `respond_*` answer ({@link StructuredResponse}) supersedes any
+ * preamble the model leaked before calling the response tool — otherwise the
+ * answer would print twice (once as raw leaked content, once formatted). For a
+ * normal chat turn with no structured answer, the buffered content is flushed
+ * verbatim at the end. Mirrors the buffer-and-supersede design of
+ * {@link createHeadlessJsonlEmitter}.
+ */
+export declare function createHeadlessTextEmitter(): {
+    consumeChunk(chunk: StreamChunk): HeadlessWrites;
+    flush(): HeadlessWrites;
+};
 /**
  * Buffers assistant `content` per step and emits JSONL: step_start, text, tool_use, step_finish, error.
  * Pair with `agent.processMessage(prompt, emitter.observer)` in headless JSON mode only.