muonroi-cli 1.8.3 → 1.8.5

package/dist/src/ee/client.js

@@ -1,6 +1,29 @@
+import * as os from "node:os";
 import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
+import { redactor } from "../utils/redactor.js";
 import { drainQueue, enqueue } from "./offline-queue.js";
 const DEFAULT_BASE = "http://localhost:8082";
+function relativizePath(p) {
+    if (!p)
+        return p;
+    let normalized = p.replace(/\\/g, "/");
+    const home = os.homedir().replace(/\\/g, "/");
+    const normalizedHome = home.endsWith("/") ? home.slice(0, -1) : home;
+    if (normalized.startsWith(normalizedHome)) {
+        normalized = "~" + normalized.slice(normalizedHome.length);
+    }
+    return normalized;
+}
+function redactPayload(payload) {
+    if (!payload)
+        return payload;
+    try {
+        return JSON.parse(redactor.redact(JSON.stringify(payload)));
+    }
+    catch {
+        return payload;
+    }
+}
 /**
  * Intercept timeout budget.
  * Local: 100ms (localhost p99 is <10ms, 100ms catches wedged server).
@@ -195,8 +218,12 @@ export function createEEClient(opts = {}) {
             }
         },
         async intercept(req) {
+            const redactedReq = {
+                ...req,
+                cwd: relativizePath(req.cwd),
+            };
             // 1. Cache hit — skip network entirely
-            const cached = getCached(req);
+            const cached = getCached(redactedReq);
             if (cached)
                 return cached;
             // 2. Circuit breaker — skip if open
@@ -207,7 +234,7 @@ export function createEEClient(opts = {}) {
                 const resp = await f(`${baseUrl}/api/intercept`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify({ ...req, skipRoute: true }),
+                    body: JSON.stringify(redactPayload({ ...redactedReq, skipRoute: true })),
                     signal: AbortSignal.timeout(interceptTimeoutMs),
                 });
                 if (!resp.ok) {
@@ -221,7 +248,7 @@ export function createEEClient(opts = {}) {
                 const raw = (await resp.json());
                 const result = normalizeInterceptResponse(raw);
                 recordCircuitSuccess({ fetchImpl: f, headers: headers(), baseUrl });
-                setCached(req, result);
+                setCached(redactedReq, result);
                 return result;
             }
             catch (err) {
@@ -231,10 +258,14 @@ export function createEEClient(opts = {}) {
             }
         },
         async posttool(payload) {
+            const redactedPayload = {
+                ...payload,
+                cwd: relativizePath(payload.cwd),
+            };
             await f(`${baseUrl}/api/posttool`, {
                 method: "POST",
                 headers: headers(),
-                body: JSON.stringify(payload),
+                body: JSON.stringify(redactPayload(redactedPayload)),
                 signal: AbortSignal.timeout(postToolTimeoutMs),
             }).catch((err) => {
                 logEeFailure("client.posttool", classifyEeError(err), err);
@@ -243,6 +274,10 @@ export function createEEClient(opts = {}) {
         },
         async routeModel(req, signal) {
             try {
+                const redactedReq = {
+                    ...req,
+                    cwd: relativizePath(req.cwd),
+                };
                 const ctrl = new AbortController();
                 const t = setTimeout(() => ctrl.abort(), 250);
                 if (signal)
@@ -250,7 +285,7 @@ export function createEEClient(opts = {}) {
                 const resp = await f(`${baseUrl}/api/route-model`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify(req),
+                    body: JSON.stringify(redactPayload(redactedReq)),
                     signal: ctrl.signal,
                 });
                 clearTimeout(t);
@@ -264,6 +299,10 @@ export function createEEClient(opts = {}) {
         },
         async coldRoute(req, signal) {
             try {
+                const redactedReq = {
+                    ...req,
+                    cwd: relativizePath(req.cwd),
+                };
                 const ctrl = new AbortController();
                 const t = setTimeout(() => ctrl.abort(), 1000);
                 if (signal)
@@ -271,7 +310,7 @@ export function createEEClient(opts = {}) {
                 const resp = await f(`${baseUrl}/api/cold-route`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify(req),
+                    body: JSON.stringify(redactPayload(redactedReq)),
                     signal: ctrl.signal,
                 });
                 clearTimeout(t);
@@ -284,13 +323,14 @@ export function createEEClient(opts = {}) {
             }
         },
         feedback(payload) {
+            const redactedPayload = redactPayload(payload);
             f(`${baseUrl}/api/feedback`, {
                 method: "POST",
                 headers: headers(),
-                body: JSON.stringify(payload),
+                body: JSON.stringify(redactedPayload),
             }).catch((err) => {
                 logEeFailure("client.feedback", classifyEeError(err), err);
-                void enqueue({ endpoint: "/api/feedback", body: payload, enqueuedAt: Date.now() });
+                void enqueue({ endpoint: "/api/feedback", body: redactedPayload, enqueuedAt: Date.now() });
             });
         },
         /**
@@ -300,7 +340,7 @@ export function createEEClient(opts = {}) {
          * stale_rule). Fire-and-forget; queued offline like standard feedback.
          */
         noiseFeedback(payload) {
-            const body = { ...payload, verdict: "IRRELEVANT" };
+            const body = redactPayload({ ...payload, verdict: "IRRELEVANT" });
             f(`${baseUrl}/api/feedback`, {
                 method: "POST",
                 headers: headers(),
@@ -322,10 +362,11 @@ export function createEEClient(opts = {}) {
         },
         // ─── P0: Route feedback (fire-and-forget) ─────────────────────────────────
         routeFeedback(payload) {
+            const redactedPayload = redactPayload(payload);
             f(`${baseUrl}/api/route-feedback`, {
                 method: "POST",
                 headers: headers(),
-                body: JSON.stringify(payload),
+                body: JSON.stringify(redactedPayload),
             }).catch((err) => {
                 logEeFailure("client.routeFeedback", classifyEeError(err), err);
                 /* fire-and-forget */
@@ -333,41 +374,54 @@ export function createEEClient(opts = {}) {
         },
         // ─── P1: Prompt-stale reconciliation ──────────────────────────────────────
         async promptStale(req) {
+            const redactedReq = redactPayload({
+                ...req,
+                nextPromptMeta: req.nextPromptMeta
+                    ? {
+                        ...req.nextPromptMeta,
+                        cwd: req.nextPromptMeta.cwd ? relativizePath(req.nextPromptMeta.cwd) : undefined,
+                    }
+                    : undefined,
+            });
             try {
                 const resp = await f(`${baseUrl}/api/prompt-stale`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify(req),
+                    body: JSON.stringify(redactedReq),
                     signal: AbortSignal.timeout(2000),
                 });
                 if (!resp.ok) {
-                    void enqueue({ endpoint: "/api/prompt-stale", body: req, enqueuedAt: Date.now() });
+                    void enqueue({ endpoint: "/api/prompt-stale", body: redactedReq, enqueuedAt: Date.now() });
                     return null;
                 }
                 return (await resp.json());
             }
             catch {
-                void enqueue({ endpoint: "/api/prompt-stale", body: req, enqueuedAt: Date.now() });
+                void enqueue({ endpoint: "/api/prompt-stale", body: redactedReq, enqueuedAt: Date.now() });
                 return null;
             }
         },
         // ─── P1: Session extract ──────────────────────────────────────────────────
         async extract(req, signal) {
+            const redactedReq = redactPayload({
+                ...req,
+                projectPath: relativizePath(req.projectPath),
+            });
             try {
                 const resp = await f(`${baseUrl}/api/extract`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify(req),
+                    body: JSON.stringify(redactedReq),
                     signal: signal ?? AbortSignal.timeout(10_000),
                 });
                 if (!resp.ok) {
-                    void enqueue({ endpoint: "/api/extract", body: req, enqueuedAt: Date.now() });
+                    void enqueue({ endpoint: "/api/extract", body: redactedReq, enqueuedAt: Date.now() });
                     return null;
                 }
                 return (await resp.json());
             }
             catch {
-                void enqueue({ endpoint: "/api/extract", body: req, enqueuedAt: Date.now() });
+                void enqueue({ endpoint: "/api/extract", body: redactedReq, enqueuedAt: Date.now() });
                 return null;
             }
         },
@@ -527,11 +581,18 @@ export function createEEClient(opts = {}) {
         async recall(query, opts = {}) {
             const body = { query };
             if (opts.cwd)
-                body.cwd = opts.cwd;
+                body.cwd = relativizePath(opts.cwd);
             if (opts.project)
                 body.project_slug = opts.project;
             if (opts.sourceSession)
                 body.sourceSession = opts.sourceSession;
+            // Per-stance recall weighting (item 3): forward the council stance/role so
+            // the server weights recall collections toward what this stance cares about.
+            if (opts.stance)
+                body.stance = opts.stance;
+            if (opts.role)
+                body.role = opts.role;
+            const redactedBody = redactPayload(body);
             // 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
@@ -542,7 +603,7 @@ export function createEEClient(opts = {}) {
                 const resp = await f(`${baseUrl}/api/recall`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify(body),
+                    body: JSON.stringify(redactedBody),
                     signal: opts.signal ?? AbortSignal.timeout(timeoutMs),
                 });
                 if (!resp.ok)
@@ -588,6 +649,8 @@ export function createEEClient(opts = {}) {
                         body.maxTokens = options.maxTokens;
                     if (options.provider)
                         body.provider = options.provider;
+                    if (options.useExtractModel)
+                        body.useExtractModel = true;
                 }
                 const resp = await f(`${baseUrl}/api/brain`, {
                     method: "POST",

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

@@ -15,6 +15,7 @@ export interface ExportOptions {
     dryRun?: boolean;
     /** Minimum messages per session to bother emitting (default 4 — skip noise). */
     minMessages?: number;
+    dbOverride?: any;
 }
 export interface ExportResult {
     totalSessions: number;

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

@@ -10,9 +10,7 @@
  * 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 { getDatabase } from "../storage/db.js";
 import { emitTranscriptToDisk, getEmitRoot } from "./transcript-emit.js";
 async function openDb(dbPath) {
     // Prefer better-sqlite3 (sync), fall back to bun:sqlite when running under Bun.
@@ -52,17 +50,15 @@ 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);
+    const db = opts.dbOverride ?? getDatabase();
     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 sessions = db
+            .prepare(`SELECT id, updated_at, cwd_last FROM sessions WHERE updated_at >= '${cutoffIso}' ORDER BY updated_at DESC`)
+            .all();
         const out = {
             totalSessions: sessions.length,
             written: 0,
@@ -71,7 +67,9 @@ export async function exportTranscripts(opts = {}) {
             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`);
+            const rows = db
+                .prepare(`SELECT session_id, seq, role, message_json FROM messages WHERE session_id = '${s.id.replace(/'/g, "''")}' ORDER BY seq ASC`)
+                .all();
             if (rows.length === 0) {
                 out.skippedEmpty++;
                 continue;

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

@@ -47,9 +47,38 @@ export async function extractSession(messages, projectPath, source, sessionId) {
         getDefaultEEClient()
             .evolve("post-extract")
             .catch(() => { });
+        // WRITE arm of the who-am-i loop — fire-and-forget. Mine the user's working style from
+        // this transcript and persist it to experience-behavioral, which who-am-i-brain reads
+        // back next session (READ arm). Deliberately NOT awaited: the classify is a ~9s brain
+        // call and must not block cli-exit (same rationale as the async extract). It completes on
+        // cli-clear (process stays alive) and is best-effort on cli-exit — style converges over
+        // sessions, so a missed teardown is harmless. Fail-open, gated behind its own flag.
+        void writeStyleSignalsFireAndForget(transcript);
     }
     catch {
         // D-05: swallow all errors silently
     }
 }
+/**
+ * Fire-and-forget bridge from extractSession into the style WRITE arm. Kept separate so the
+ * bridge/search imports stay lazy (only paid when a real session ends) and so every failure
+ * mode — flag off, EE unreachable, classifier null, write error — degrades to a no-op.
+ */
+async function writeStyleSignalsFireAndForget(transcript) {
+    try {
+        const { isStyleExtractEnabled, writeStyleSignals } = await import("./extract-style.js");
+        if (!isStyleExtractEnabled())
+            return;
+        const { classifyViaBrain } = await import("./bridge.js");
+        const { writeExperienceEE } = await import("./search.js");
+        // No projectSlug: working style is a cross-repo property of the user, so style rules are
+        // written GLOBAL (unscoped) — who-am-i-brain searches experience-behavioral broadly and a
+        // repo-scoped style rule would be needlessly narrow. (Contrast the technical-lesson extract,
+        // which IS repo-scoped because a bug fix is repo-specific.)
+        await writeStyleSignals({ classifyViaBrain, writeExperience: writeExperienceEE }, transcript);
+    }
+    catch {
+        // swallow — style extraction is strictly best-effort
+    }
+}
 //# sourceMappingURL=extract-session.js.map

package/dist/src/ee/extract-style.d.ts

@@ -0,0 +1,58 @@
+import type { WriteExperienceResult } from "./search.js";
+/** Feature flag — default ON, opt out with MUONROI_STYLE_EXTRACT=0. */
+export declare function isStyleExtractEnabled(): boolean;
+/**
+ * PURE: build the style-mining prompt. Asks the brain to emit 0..N natural-language style
+ * rules about the USER (never the task), each standalone and reusable as future guidance,
+ * with a self-reported confidence. Emitting NOTHING when the transcript shows no clear style
+ * is explicitly the right answer — we would rather miss a session than pollute the brain.
+ */
+export declare function buildStyleExtractPrompt(transcript: string): string;
+export interface StyleRule {
+    rule: string;
+    confidence: number;
+}
+/**
+ * PURE: coerce a brain reply (JSON string, fenced block, or already-parsed object) into a
+ * gated list of style rules. Applies the confidence floor, length bounds, dedup by normalized
+ * text, and the per-session cap. Returns [] when nothing usable survives (fail-open).
+ */
+export declare function parseStyleRules(raw: unknown): StyleRule[];
+/**
+ * PURE: a stable title for a style rule so repeated sessions MERGE server-side instead of
+ * accreting near-duplicates. Derived deterministically from the rule text (lowercased, first
+ * few significant words) — same recurring preference → same title → storeImportedExperience
+ * can collapse them. Marked with a "user-style:" prefix so the entries are identifiable and
+ * prunable as a class.
+ */
+export declare function styleRuleTitle(rule: string): string;
+export interface StyleExtractDeps {
+    classifyViaBrain: (prompt: string, timeoutMs?: number, options?: {
+        systemPrompt?: string;
+        responseFormat?: {
+            type: string;
+        };
+        maxTokens?: number;
+        useExtractModel?: boolean;
+    }) => Promise<string | null>;
+    writeExperience: (lesson: string, opts: {
+        collection?: string;
+        title?: string;
+        projectSlug?: string;
+        confidence?: number;
+    }) => Promise<WriteExperienceResult>;
+}
+/**
+ * Classify the transcript into gated style rules. Fail-open []: a degraded brain must never
+ * break session teardown.
+ */
+export declare function extractStyleSignals(deps: StyleExtractDeps, transcript: string): Promise<StyleRule[]>;
+/**
+ * End-to-end WRITE arm: mine style rules from the transcript and persist each to
+ * experience-behavioral. Returns the number written. Fire-and-forget from extractSession —
+ * fail-open, never throws. `projectSlug` scopes the rule; confidence carries through so the
+ * brain can weight it.
+ */
+export declare function writeStyleSignals(deps: StyleExtractDeps, transcript: string, opts?: {
+    projectSlug?: string;
+}): Promise<number>;

package/dist/src/ee/extract-style.js

@@ -0,0 +1,270 @@
+// src/ee/extract-style.ts
+//
+// Personality / working-style extraction — the WRITE arm that CLOSES the who-am-i loop.
+//
+// The READ arm (who-am-i-brain.ts) derives a WhoAmIProfile from the `experience-behavioral`
+// brain: it searches the user's accumulated style rules and classifies them into dims that
+// the PIL layers read. But on a thin-client NOTHING was feeding that collection with style
+// signals mined from the user's OWN muonroi-cli sessions — the general server extract
+// (`extractFromSession`) only mines TECHNICAL mistakes/lessons (detectExperience → extractQA),
+// never "the user prefers concise answers / rejects hand-holding / decides fast". So the loop
+// was open: who-am-i could only read rules the user hand-authored or the Claude Code Stop hook
+// happened to capture.
+//
+// This module runs at session-end (alongside extractSession) and mines the transcript for the
+// USER's working-style, writing each high-confidence signal as a natural-language behavioral
+// rule into `experience-behavioral` via writeExperienceEE. Next session, who-am-i-brain reads
+// those rules back and classifies them into dims → the loop is closed.
+//
+// Design guarantees:
+//   • Agent-first (no keyword regex): the transcript→style mapping is decided by the brain LLM
+//     (classifyViaBrain), honouring the repo rule that classification is never regex. The only
+//     regex here is tolerant JSON extraction from the LLM reply.
+//   • Natural-language interface (NOT a shared enum): the WRITE side emits plain style
+//     sentences; the READ side (who-am-i-brain) re-classifies them with its own DIM_VOCAB.
+//     Neither side imports the other's vocabulary — so there is no cross-module enum coupling
+//     to drift (contrast the EE-side DIM_VOCAB lockstep this deliberately avoids).
+//   • Anti-pollution: experience-behavioral also drives passive hint injection, so a wrong or
+//     low-confidence guess is actively harmful (it feeds who-am-i AND every passive hint). We
+//     gate HARD — high confidence floor, length bounds, a small per-session cap, and a stable
+//     per-signal title so repeated sessions MERGE instead of accreting near-duplicates.
+//   • Fail-open: any gap (classifier null, unparseable output, dep throws, EE down) writes
+//     nothing and never throws. Style converges over many sessions; missing one is harmless.
+/** The collection who-am-i-brain reads back — keep in lockstep with BEHAVIORAL_COLLECTION there. */
+const BEHAVIORAL_COLLECTION = "experience-behavioral";
+/**
+ * Only signals at/above this confidence are written. High on purpose: a style rule that lands
+ * in experience-behavioral influences who-am-i AND passive hints, so a confident-but-wrong
+ * guess is worse than silence. The brain self-reports confidence per the prompt contract.
+ */
+const STYLE_WRITE_MIN_CONFIDENCE = 0.7;
+/** At most this many style rules per session — style is slow-moving; a burst is almost always noise. */
+const MAX_STYLE_RULES_PER_SESSION = 3;
+/** A style rule shorter than this is too vague to guide anything; longer than this is task prose leaking in. */
+const MIN_RULE_CHARS = 15;
+const MAX_RULE_CHARS = 240;
+/**
+ * Off the hot path (fire-and-forget at session-end), so a wide budget. The server's strong
+ * brainExtractModel is a reasoning model (deepseek-v4-flash) whose think+emit cycle runs
+ * ~4-10s on this transcript-sized prompt (verified live). 20s clears the tail; it never blocks
+ * anything (background). Mirrors who-am-i-brain's budget.
+ */
+const STYLE_CLASSIFY_TIMEOUT_MS = 20000;
+/**
+ * The rules JSON itself is tiny (~150 tokens), but the server's extract model
+ * (deepseek-v4-flash) is a REASONING model — its thinking tokens count against this same
+ * budget and land in a separate reasoning_content field, NOT the JSON. A tight cap (500) let
+ * the reasoning consume the whole budget and truncate the actual JSON to empty → intermittent
+ * zero-rule results (verified live: identical input gave 3 rules then 0). Give thinking ample
+ * headroom so the JSON always survives; the extra tokens are only spent when the model
+ * actually reasons, and this is an off-hot-path background call.
+ */
+const STYLE_CLASSIFY_MAX_TOKENS = 3000;
+/**
+ * System-prompt override — REQUIRED, same reason as who-am-i-brain: the EE brain proxy's
+ * default system prompt is a tier-classifier ("output ONE word … ignore content") that
+ * hijacks structured output into garbage. Verified on the live VPS (2026-07-05).
+ */
+const STYLE_SYSTEM_PROMPT = "You mine a developer's WORKING STYLE from a session transcript — how they prefer to " +
+    "communicate, decide, delegate, receive feedback, and handle risk. Follow the user " +
+    "message instructions EXACTLY and output ONLY the requested JSON object. Do not classify " +
+    "task complexity, do not output single words, do not add prose before or after the JSON.";
+/** Feature flag — default ON, opt out with MUONROI_STYLE_EXTRACT=0. */
+export function isStyleExtractEnabled() {
+    return process.env.MUONROI_STYLE_EXTRACT !== "0";
+}
+/**
+ * PURE: build the style-mining prompt. Asks the brain to emit 0..N natural-language style
+ * rules about the USER (never the task), each standalone and reusable as future guidance,
+ * with a self-reported confidence. Emitting NOTHING when the transcript shows no clear style
+ * is explicitly the right answer — we would rather miss a session than pollute the brain.
+ */
+export function buildStyleExtractPrompt(transcript) {
+    return [
+        "From the session transcript below, extract DURABLE signals about the DEVELOPER's working",
+        "style — not the task, not the code. Look for how they prefer to communicate (concise vs",
+        "detailed), decide (fast/intuitive vs deliberate), delegate (autonomous vs collaborative),",
+        "receive feedback (blunt correction vs gentle), and tolerate risk.",
+        "",
+        "Output ONLY a JSON object of the form:",
+        '{"rules": [{"rule": "<one imperative sentence of durable style guidance>", "confidence": 0.0-1.0}]}',
+        "",
+        "Rules:",
+        '- Each `rule` must be a standalone, reusable instruction (e.g. "The user prefers concise',
+        '  answers — skip preamble and lead with the recommendation."). NOT a fact about this task.',
+        "- Emit a signal ONLY when the transcript gives clear, repeated evidence. When in doubt, omit it.",
+        "- An EMPTY array is the correct answer for a task-only session with no style signal.",
+        "- Never invent a preference the transcript does not actually demonstrate.",
+        "- confidence reflects how strongly the transcript supports the rule.",
+        "",
+        "Transcript:",
+        transcript,
+    ].join("\n");
+}
+/**
+ * PURE: coerce a brain reply (JSON string, fenced block, or already-parsed object) into a
+ * gated list of style rules. Applies the confidence floor, length bounds, dedup by normalized
+ * text, and the per-session cap. Returns [] when nothing usable survives (fail-open).
+ */
+export function parseStyleRules(raw) {
+    let obj = raw;
+    if (typeof raw === "string") {
+        const json = extractJsonObject(raw);
+        if (!json)
+            return [];
+        try {
+            obj = JSON.parse(json);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!obj || typeof obj !== "object")
+        return [];
+    const arr = obj.rules;
+    if (!Array.isArray(arr))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const item of arr) {
+        if (!item || typeof item !== "object")
+            continue;
+        const rule = typeof item.rule === "string" ? item.rule.trim() : "";
+        const confidence = Number(item.confidence);
+        if (!rule || !Number.isFinite(confidence))
+            continue;
+        if (confidence < STYLE_WRITE_MIN_CONFIDENCE)
+            continue;
+        if (rule.length < MIN_RULE_CHARS || rule.length > MAX_RULE_CHARS)
+            continue;
+        const norm = rule.toLowerCase().replace(/\s+/g, " ");
+        if (seen.has(norm))
+            continue;
+        seen.add(norm);
+        out.push({ rule, confidence });
+        if (out.length >= MAX_STYLE_RULES_PER_SESSION)
+            break;
+    }
+    return out;
+}
+/** Tolerantly extract the first balanced JSON object from an LLM reply. */
+function extractJsonObject(text) {
+    const start = text.indexOf("{");
+    if (start === -1)
+        return null;
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inStr) {
+            if (esc)
+                esc = false;
+            else if (ch === "\\")
+                esc = true;
+            else if (ch === '"')
+                inStr = false;
+            continue;
+        }
+        if (ch === '"')
+            inStr = true;
+        else if (ch === "{")
+            depth++;
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * PURE: a stable title for a style rule so repeated sessions MERGE server-side instead of
+ * accreting near-duplicates. Derived deterministically from the rule text (lowercased, first
+ * few significant words) — same recurring preference → same title → storeImportedExperience
+ * can collapse them. Marked with a "user-style:" prefix so the entries are identifiable and
+ * prunable as a class.
+ */
+export function styleRuleTitle(rule) {
+    const words = rule
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 3 && !STOPWORDS.has(w))
+        .slice(0, 5)
+        .join("-");
+    return `user-style:${words || "general"}`;
+}
+const STOPWORDS = new Set([
+    "the",
+    "user",
+    "prefers",
+    "wants",
+    "with",
+    "that",
+    "this",
+    "they",
+    "them",
+    "their",
+    "when",
+    "into",
+    "over",
+    "from",
+    "answers",
+    "answer",
+    "reply",
+    "replies",
+]);
+/**
+ * Classify the transcript into gated style rules. Fail-open []: a degraded brain must never
+ * break session teardown.
+ */
+export async function extractStyleSignals(deps, transcript) {
+    try {
+        if (!transcript || transcript.trim().length < 100)
+            return [];
+        const reply = await deps.classifyViaBrain(buildStyleExtractPrompt(transcript), STYLE_CLASSIFY_TIMEOUT_MS, {
+            systemPrompt: STYLE_SYSTEM_PROMPT,
+            responseFormat: { type: "json_object" },
+            maxTokens: STYLE_CLASSIFY_MAX_TOKENS,
+            // Structured multi-signal extraction needs the server's stronger brainExtractModel;
+            // the hot-path model is too weak (verified on the live VPS for the READ side too).
+            useExtractModel: true,
+        });
+        if (!reply)
+            return [];
+        return parseStyleRules(reply);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * End-to-end WRITE arm: mine style rules from the transcript and persist each to
+ * experience-behavioral. Returns the number written. Fire-and-forget from extractSession —
+ * fail-open, never throws. `projectSlug` scopes the rule; confidence carries through so the
+ * brain can weight it.
+ */
+export async function writeStyleSignals(deps, transcript, opts = {}) {
+    if (!isStyleExtractEnabled())
+        return 0;
+    const rules = await extractStyleSignals(deps, transcript);
+    let written = 0;
+    for (const r of rules) {
+        try {
+            const res = await deps.writeExperience(r.rule, {
+                collection: BEHAVIORAL_COLLECTION,
+                title: styleRuleTitle(r.rule),
+                projectSlug: opts.projectSlug,
+                confidence: r.confidence,
+            });
+            if (res.ok)
+                written++;
+        }
+        catch {
+            // fail-open per rule — one bad write must not abort the rest
+        }
+    }
+    return written;
+}
+//# sourceMappingURL=extract-style.js.map