muonroi-cli 1.8.4 → 1.9.0

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

@@ -0,0 +1,220 @@
+// src/ee/who-am-i-brain.ts
+//
+// Brain-derived "Who Am I" fallback for THIN-CLIENTS.
+//
+// The device-local profile.yaml pipeline (src/ee/who-am-i.ts) is full-brain-only:
+// the EE prompt interceptor bails early on remote mode (`if (isRemoteMode()) return`),
+// no /api/profile endpoint exists, and signal-extraction from transcripts never runs
+// on a thin-client. So on a thin-client getWhoAmIProfile() is structurally always
+// null and the PIL loses every style signal.
+//
+// The user's working style IS reachable though — it lives in the `experience-behavioral`
+// brain (their own authored rules: "recommend, don't ask", "keep it concise", etc.),
+// which the runtime already queries via searchByText() over /api/search. This module
+// derives the SAME WhoAmIProfile shape from those rules so all existing PIL wiring
+// (outputStyleFromProfile, the layer4/5/6 dim reads) works unchanged.
+//
+// Design guarantees:
+//   • Agent-first (no keyword regex): the rule→dim mapping is decided by the brain LLM
+//     itself (classifyViaBrain), honouring the repo rule that classification is never
+//     regex. The only regex here is tolerant JSON extraction from the LLM's reply.
+//   • Privacy: dims are re-gated locally through selectWhoAmIDims — the positive
+//     name-allowlist + per-tier confidence floor. Brain rules are user-authored style
+//     guidance (Tang-2 equivalent), so we gate at the "standard" tier; emotional.* can
+//     never surface (not on the allowlist). This is decoupled from the EE file
+//     privacyLevel (which governs the *auto-derived* on-device profile — a different,
+//     more sensitive data source that is off by default on thin-clients).
+//   • Fail-open: any gap (no rules, classifier null, unparseable output, dep throws)
+//     returns null → the PIL keeps its own per-turn default. Never throws.
+import { selectWhoAmIDims } from "./who-am-i.js";
+const BEHAVIORAL_COLLECTION = "experience-behavioral";
+const BRAIN_TOPK = 12;
+/** Brain rules are style-level guidance → the standard tier (never emotional). */
+const BRAIN_TIER = "standard";
+/**
+ * System prompt override — REQUIRED. The EE brain proxy's default system prompt is a
+ * tier-classifier ("output ONE word: fast|balanced|premium … ignore the task content"),
+ * which actively hijacks any structured-output request → malformed JSON. Verified on the
+ * live VPS (2026-07-05): omitting this made even DeepSeek-V3 emit garbage; supplying it
+ * makes the DEFAULT server model (Qwen2.5-7B) emit clean, accurate dims JSON. We do NOT
+ * override the model/provider — that would hardcode a model id (Zero-Hardcode Rule) and
+ * cost the user's own provider; the server's default brain model + key does the work.
+ */
+const STYLE_SYSTEM_PROMPT = "You extract a developer's working-style profile from their accumulated behavioral " +
+    "rules. 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.";
+/**
+ * Probe the behavioral brain for working-style rules. Free-text; the server embeds
+ * + searches Qdrant. Intentionally broad — it should surface brevity / decision /
+ * feedback / delegation / risk / conflict guidance the user has accumulated.
+ */
+const STYLE_PROBE = "the user's preferred working style: communication brevity, decision speed, " +
+    "feedback and correction style, delegation style, risk tolerance, conflict style";
+// The dims the brain may emit, with the EXACT value vocabulary. Source of truth is
+// the EE profile renderer (~/.experience/src/profile-render.js DIRECTIVES) — the same
+// values the device-local profile uses and that the PIL layers compare against
+// literally (e.g. layer4 tests delegation === "autonomous", layer6 tests
+// feedback_style === "precise-correction"). A value outside this set would populate a
+// dim that no lever reads → silently inert. Keep in lockstep with the EE enum.
+const DIM_VOCAB = {
+    "communication.brevity": ["concise", "moderate", "verbose"],
+    "communication.feedback_style": ["implicit", "precise-correction"],
+    "communication.question_style": ["comparison", "debugging", "exploratory", "directive"],
+    "personality.decision_speed": ["fast-intuitive", "measured", "deliberate"],
+    "personality.risk_tolerance": ["experimental"],
+    "personality.conflict_style": ["direct-constructive", "authoritative", "cautious"],
+    "work_patterns.energy": ["night-owl", "daytime", "mixed"],
+    "work_patterns.multitasking": ["task-switcher", "sequential-deep"],
+    "work_patterns.session_length": ["short", "medium", "long"],
+    "work_patterns.delegation_style": ["autonomous", "collaborative"],
+};
+/** Feature flag — default ON, opt out with MUONROI_WHOAMI_BRAIN=0. */
+export function isBrainWhoAmIEnabled() {
+    return process.env.MUONROI_WHOAMI_BRAIN !== "0";
+}
+/**
+ * PURE: build the classify prompt. Asks the brain to distil the retrieved rules into
+ * a strict dims JSON using only the allowed names + vocabulary. Emitting fewer dims
+ * (only the confident ones) is explicitly encouraged — downstream drops the rest.
+ */
+export function buildStyleClassifyPrompt(rules) {
+    const vocabLines = Object.entries(DIM_VOCAB)
+        .map(([name, values]) => `  "${name}": one of ${values.map((v) => `"${v}"`).join(" | ")}`)
+        .join("\n");
+    const ruleBlock = rules.length
+        ? rules.map((r, i) => `${i + 1}. ${r}`).join("\n")
+        : "(no explicit rules retrieved — infer nothing; emit an empty dimensions object)";
+    return [
+        "You classify a developer's working style from their accumulated behavioral rules.",
+        "Output ONLY a JSON object of the form:",
+        '{"dimensions": {"<dim.name>": {"value": "<allowed value>", "confidence": 0.0-1.0, "sampleCount": <int>}}}',
+        "",
+        "Allowed dimensions and their vocabulary (use these names/values EXACTLY):",
+        vocabLines,
+        "",
+        "Rules:",
+        "- Include a dimension ONLY when the rules give clear evidence for it.",
+        "- Omit anything uncertain — a small, confident object beats a complete guess.",
+        "- confidence reflects how strongly the rules support the value; sampleCount = how many rules back it.",
+        "- Never invent dimension names or values outside the vocabulary above.",
+        "",
+        "Behavioral rules:",
+        ruleBlock,
+    ].join("\n");
+}
+/** 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: coerce a brain reply (JSON string, fenced block, or already-parsed object)
+ * into a privacy-gated WhoAmIProfile. Reuses selectWhoAmIDims for the allowlist +
+ * confidence floor. Returns null when nothing usable survives.
+ */
+export function parseBrainProfile(raw, level = BRAIN_TIER) {
+    let obj = raw;
+    if (typeof raw === "string") {
+        const json = extractJsonObject(raw);
+        if (!json)
+            return null;
+        try {
+            obj = JSON.parse(json);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!obj || typeof obj !== "object")
+        return null;
+    const gated = selectWhoAmIDims(obj, level);
+    // Value validation — the name allowlist in selectWhoAmIDims does NOT check the VALUE,
+    // and weaker brain models mis-spell the vocabulary (verified on the live VPS:
+    // Qwen2.5-7B emitted "precice-correction"). An off-vocab value populates a dim that
+    // the PIL layers — which compare literally — can never fire on, so it's worse than
+    // absent (looks set, does nothing). Drop any value not in DIM_VOCAB[name].
+    const dims = {};
+    for (const [name, dim] of Object.entries(gated)) {
+        const vocab = DIM_VOCAB[name];
+        if (vocab && !vocab.includes(dim.value))
+            continue;
+        dims[name] = dim;
+    }
+    if (Object.keys(dims).length === 0)
+        return null;
+    return { level, dims };
+}
+/**
+ * Off the hot path (fire-and-forget boot warm), so a wide budget. The server's
+ * brainExtractModel is a REASONING model (deepseek-v4-flash) and the who-am-i prompt is large
+ * (12 retrieved rules + the full dim-vocabulary schema), so the think+emit cycle runs ~10-15s
+ * — verified live that a 15s cap intermittently truncated to a timeout/null. 25s clears the
+ * tail; the cost is nil because this never blocks anything (background warm).
+ */
+const BRAIN_CLASSIFY_TIMEOUT_MS = 25000;
+/**
+ * The dims JSON is tiny (~200 tokens), but the server's extract model (deepseek-v4-flash) is a
+ * REASONING model — its thinking tokens count against this same budget (landing in a separate
+ * reasoning_content field, not the JSON). A tight cap let the reasoning consume the budget and
+ * truncate the actual JSON to empty → intermittent null profiles. Give thinking ample headroom
+ * so the dims JSON always survives; extra tokens are only spent when the model reasons, and
+ * this is an off-hot-path boot warm.
+ */
+const BRAIN_CLASSIFY_MAX_TOKENS = 3000;
+/**
+ * Derive a WhoAmIProfile from the behavioral brain. Search the user's style rules →
+ * classify them into dims via the brain LLM → privacy-gate locally. Fail-open null.
+ */
+export async function deriveWhoAmIFromBrain(deps, level = BRAIN_TIER) {
+    try {
+        const points = await deps.searchByText(STYLE_PROBE, [BEHAVIORAL_COLLECTION], BRAIN_TOPK);
+        const rules = points
+            .map((p) => (typeof p.payload?.text === "string" ? p.payload.text.trim() : ""))
+            .filter((t) => t.length > 0);
+        if (rules.length === 0)
+            return null;
+        const reply = await deps.classifyViaBrain(buildStyleClassifyPrompt(rules), BRAIN_CLASSIFY_TIMEOUT_MS, {
+            systemPrompt: STYLE_SYSTEM_PROMPT,
+            responseFormat: { type: "json_object" },
+            maxTokens: BRAIN_CLASSIFY_MAX_TOKENS,
+            // Structured multi-dim extraction needs the server's stronger brainExtractModel;
+            // the hot-path model mis-spells the vocabulary (verified on the live VPS).
+            useExtractModel: true,
+        });
+        if (!reply)
+            return null;
+        return parseBrainProfile(reply, level);
+    }
+    catch {
+        // Fail-open — a degraded brain must never break the PIL hot path.
+        return null;
+    }
+}
+//# sourceMappingURL=who-am-i-brain.js.map

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

@@ -10,13 +10,13 @@ export interface WhoAmIProfile {
     level: PrivacyLevel;
     dims: Partial<Record<WhoAmIDimName, WhoAmIDim>>;
 }
-interface RawDim {
+export interface RawDim {
     value: string | null;
     confidence?: number;
     sampleCount?: number;
     samples?: number;
 }
-interface RawProfile {
+export interface RawProfile {
     dimensions?: Record<string, RawDim>;
 }
 /**
@@ -38,4 +38,11 @@ export declare function outputStyleFromProfile(profile: WhoAmIProfile | null): O
 export declare function getWhoAmIProfile(): WhoAmIProfile | null;
 /** Clear the cache — test-only / after a known profile change. */
 export declare function resetWhoAmICache(): void;
-export {};
+/**
+ * Prime the per-process cache with an externally-derived profile (e.g. the
+ * thin-client brain fallback in who-am-i-brain.ts, wired via the bridge). Only
+ * overwrites when the device-local read produced nothing (`_cache` is null/unset)
+ * so a real on-device profile always wins over a brain-derived one. No-op when a
+ * device-local profile is already loaded.
+ */
+export declare function primeWhoAmICache(profile: WhoAmIProfile | null): void;

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

@@ -110,6 +110,18 @@ export function getWhoAmIProfile() {
 export function resetWhoAmICache() {
     _cache = undefined;
 }
+/**
+ * Prime the per-process cache with an externally-derived profile (e.g. the
+ * thin-client brain fallback in who-am-i-brain.ts, wired via the bridge). Only
+ * overwrites when the device-local read produced nothing (`_cache` is null/unset)
+ * so a real on-device profile always wins over a brain-derived one. No-op when a
+ * device-local profile is already loaded.
+ */
+export function primeWhoAmICache(profile) {
+    if (_cache)
+        return;
+    _cache = profile;
+}
 function loadWhoAmIProfile() {
     try {
         const req = createRequire(import.meta.url);

package/dist/src/ee/workflow-event.d.ts

@@ -0,0 +1,48 @@
+/**
+ * src/ee/workflow-event.ts
+ *
+ * Part C/D client for the EE `/api/workflow-event` write-during-execution
+ * channel (added in experience-engine Part D). Lets the council workflow persist
+ * experience MID-RUN — per-round debate outcomes, sprint results, decisions,
+ * mistakes — into the `workflow_*` collections, so a later run (or a later
+ * sprint in the SAME run) can recall it.
+ *
+ * Contract with the two Kill findings from the plan review:
+ *   - Kill #7: on a 404 (endpoint disabled / older server) DROP the event — do
+ *     NOT enqueue. Queuing 404s head-of-line-poisons the offline queue against a
+ *     server that will never accept them.
+ *   - Kill #4/#5: writes are fire-and-forget and off the critical path. Recall of
+ *     these hot entries stays gated on the server side (tier:"intra-session").
+ *
+ * On a transient network failure the event IS enqueued to the offline queue so
+ * a later drain retries it. Never throws; never blocks the workflow.
+ */
+import { enqueue } from "./offline-queue.js";
+export type WorkflowEventKind = "council-debate" | "sprint-execution" | "decision" | "mistake";
+export interface WorkflowEventPayload {
+    kind: WorkflowEventKind;
+    /** Run/phase reference, e.g. `runs/<runId>` or `runs/<runId>#sprint-3`. */
+    phaseRef: string;
+    sessionId?: string;
+    /** Short embeddable summary; falls back to a derived string server-side. */
+    text?: string;
+    /** Arbitrary structured detail persisted alongside the entry. */
+    payload?: Record<string, unknown>;
+}
+export interface FireWorkflowEventOpts {
+    baseUrl?: string;
+    authToken?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    /** Test seam: override the offline-queue enqueue. */
+    enqueueImpl?: typeof enqueue;
+}
+/**
+ * POST a workflow event. Returns `true` when the server accepted it, `false`
+ * otherwise (dropped on 404, enqueued on network error). Never throws.
+ */
+export declare function fireWorkflowEvent(payload: WorkflowEventPayload, opts?: FireWorkflowEventOpts): Promise<boolean>;
+/** Fire-and-forget wrapper — never throws, never blocks the workflow. */
+export declare function fireAndForgetWorkflowEvent(payload: WorkflowEventPayload, opts?: FireWorkflowEventOpts): void;
+/** Test-only: reset the once-per-process warning latch. */
+export declare function _resetWorkflowEventState(): void;

package/dist/src/ee/workflow-event.js

@@ -0,0 +1,81 @@
+/**
+ * src/ee/workflow-event.ts
+ *
+ * Part C/D client for the EE `/api/workflow-event` write-during-execution
+ * channel (added in experience-engine Part D). Lets the council workflow persist
+ * experience MID-RUN — per-round debate outcomes, sprint results, decisions,
+ * mistakes — into the `workflow_*` collections, so a later run (or a later
+ * sprint in the SAME run) can recall it.
+ *
+ * Contract with the two Kill findings from the plan review:
+ *   - Kill #7: on a 404 (endpoint disabled / older server) DROP the event — do
+ *     NOT enqueue. Queuing 404s head-of-line-poisons the offline queue against a
+ *     server that will never accept them.
+ *   - Kill #4/#5: writes are fire-and-forget and off the critical path. Recall of
+ *     these hot entries stays gated on the server side (tier:"intra-session").
+ *
+ * On a transient network failure the event IS enqueued to the offline queue so
+ * a later drain retries it. Never throws; never blocks the workflow.
+ */
+import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
+import { getCachedAuthToken, getCachedServerBaseUrl } from "./auth.js";
+import { enqueue } from "./offline-queue.js";
+const DEFAULT_BASE = "http://localhost:8082";
+const DEFAULT_TIMEOUT_MS = 3000;
+const ENDPOINT = "/api/workflow-event";
+let _warnedOnce = false;
+/**
+ * POST a workflow event. Returns `true` when the server accepted it, `false`
+ * otherwise (dropped on 404, enqueued on network error). Never throws.
+ */
+export async function fireWorkflowEvent(payload, opts = {}) {
+    const baseUrl = opts.baseUrl ?? getCachedServerBaseUrl() ?? DEFAULT_BASE;
+    const authToken = opts.authToken ?? getCachedAuthToken() ?? undefined;
+    const f = opts.fetchImpl ?? fetch;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const doEnqueue = opts.enqueueImpl ?? enqueue;
+    const headers = { "Content-Type": "application/json" };
+    if (authToken)
+        headers.Authorization = `Bearer ${authToken}`;
+    try {
+        const resp = await f(`${baseUrl}${ENDPOINT}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (resp.ok)
+            return true;
+        // 404 = endpoint disabled or older server → DROP (Kill #7: never queue 404s).
+        if (resp.status === 404)
+            return false;
+        // Other non-OK (5xx, etc.) → treat like a transient failure: enqueue.
+        await doEnqueue({ endpoint: ENDPOINT, body: payload, enqueuedAt: Date.now() }).catch(() => { });
+        if (!_warnedOnce) {
+            _warnedOnce = true;
+            console.warn(`[ee] workflow-event non-OK ${resp.status}; queued (silenced after first warning)`);
+        }
+        return false;
+    }
+    catch (err) {
+        // Network error / timeout → enqueue for later drain.
+        await doEnqueue({ endpoint: ENDPOINT, body: payload, enqueuedAt: Date.now() }).catch(() => { });
+        if (!_warnedOnce) {
+            _warnedOnce = true;
+            console.warn(`[ee] workflow-event failed: ${err.message}; queued (silenced after first warning)`);
+        }
+        return false;
+    }
+}
+/** Fire-and-forget wrapper — never throws, never blocks the workflow. */
+export function fireAndForgetWorkflowEvent(payload, opts = {}) {
+    void fireWorkflowEvent(payload, opts).catch((err) => {
+        logEeFailure("workflow-event.fireAndForgetWorkflowEvent", classifyEeError(err), err);
+        /* swallow */
+    });
+}
+/** Test-only: reset the once-per-process warning latch. */
+export function _resetWorkflowEventState() {
+    _warnedOnce = false;
+}
+//# sourceMappingURL=workflow-event.js.map

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

@@ -4,7 +4,7 @@
  * Serializes messages, extracts preserved blocks, compresses if over budget,
  * then restores preserved blocks into the output.
  */
-import type { ModelMessage } from "ai";
+import { type ModelMessage } from "ai";
 import { type PreservedBlock } from "./preserve.js";
 export interface CompressResult {
     summary: string;
@@ -17,6 +17,6 @@ export interface CompressResult {
  * 1. Serialize messages via serializeConversation().
  * 2. Extract preserved blocks.
  * 3. If under budget, return as-is (with preserved blocks restored).
- * 4. If over budget, truncate/compress and restore preserved blocks.
+ * 4. If over budget, compress via LLM (if modelId given) or truncate, and restore blocks.
  */
-export declare function compressChat(messages: ModelMessage[], _systemPrompt: string, tokenBudget: number, _provider?: unknown, _modelId?: string): Promise<CompressResult>;
+export declare function compressChat(messages: ModelMessage[], _systemPrompt: string, tokenBudget: number, modelId?: string, customInstructions?: string, onFraction?: (fraction: number) => void): Promise<CompressResult>;

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

@@ -4,7 +4,11 @@
  * Serializes messages, extracts preserved blocks, compresses if over budget,
  * then restores preserved blocks into the output.
  */
+import { streamText } from "ai";
 import { serializeConversation } from "../../orchestrator/compaction.js";
+import { resolveModelRuntime, resolveTemperatureParam } from "../../providers/runtime.js";
+import { logger } from "../../utils/logger.js";
+import { capCompactionInput } from "./input-guard.js";
 import { extractPreservedBlocks, restorePreservedBlocks } from "./preserve.js";
 /**
  * Compress chat messages within a token budget.
@@ -12,9 +16,9 @@ import { extractPreservedBlocks, restorePreservedBlocks } from "./preserve.js";
  * 1. Serialize messages via serializeConversation().
  * 2. Extract preserved blocks.
  * 3. If under budget, return as-is (with preserved blocks restored).
- * 4. If over budget, truncate/compress and restore preserved blocks.
+ * 4. If over budget, compress via LLM (if modelId given) or truncate, and restore blocks.
  */
-export async function compressChat(messages, _systemPrompt, tokenBudget, _provider, _modelId) {
+export async function compressChat(messages, _systemPrompt, tokenBudget, modelId, customInstructions, onFraction) {
     const serialized = serializeConversation(messages);
     const { cleaned, blocks } = extractPreservedBlocks(serialized);
     // Estimate tokens of cleaned text
@@ -28,16 +32,62 @@ export async function compressChat(messages, _systemPrompt, tokenBudget, _provid
             tokensAfter: Math.ceil(restored.length / 4),
         };
     }
-    // Over budget — truncate to fit budget while keeping preserved blocks
     // Calculate space taken by preserved blocks
     const preservedTokens = blocks.reduce((sum, b) => sum + Math.ceil(b.content.length / 4), 0);
     const availableTokens = Math.max(0, tokenBudget - preservedTokens);
     const availableChars = availableTokens * 4;
-    // Truncate the cleaned text to fit
-    const truncated = cleaned.length > availableChars
-        ? `${cleaned.slice(0, availableChars)}\n\n[... ${cleaned.length - availableChars} characters truncated]`
-        : cleaned;
-    const restored = restorePreservedBlocks(truncated, blocks);
+    let compressedContent = cleaned;
+    let usedLLM = false;
+    if (modelId) {
+        try {
+            const runtime = resolveModelRuntime(modelId);
+            const extraPrompt = customInstructions ? `\n\nUSER FOCUS/INSTRUCTIONS:\n${customInstructions}\n` : "";
+            // Guard the compaction INPUT against the model's own context window —
+            // compaction fires when history is large, which is exactly when the full
+            // serialized text can overflow the summarizer. Keep head + tail.
+            const guardedInput = capCompactionInput(cleaned, runtime.modelInfo?.contextWindow ?? 0);
+            // Streamed rather than awaited whole so the caller can report real
+            // progress: this pass is the bulk of a /compact's wall-clock, and a bar
+            // that freezes for a minute reads as a hang. The summary text is still
+            // only used once complete.
+            const result = streamText({
+                model: runtime.model,
+                system: "You are an AI context compaction agent. Your job is to heavily summarize a chat history. Keep the core outcomes, the final state, and the technical context. Remove verbose pleasantries, step-by-step thinking, and irrelevant intermediate steps. Do NOT wrap in markdown unless it's code.",
+                prompt: `The following conversation exceeds the token budget. Please summarize it concisely, maintaining the essence of what was discussed, what code was written, and what decisions were reached:${extraPrompt}\n\n${guardedInput}`,
+                ...resolveTemperatureParam(runtime, 0.1),
+            });
+            let streamed = "";
+            for await (const delta of result.textStream) {
+                streamed += delta;
+                // availableChars is the size the model was ASKED to fit under, so it is
+                // the only honest denominator available — a concise summary finishes
+                // early and the caller jumps the bar to done rather than overshooting.
+                if (onFraction && availableChars > 0)
+                    onFraction(Math.min(1, streamed.length / availableChars));
+            }
+            compressedContent = streamed.trim();
+            usedLLM = true;
+        }
+        catch (e) {
+            // Fall back to deterministic truncation below, but do NOT swallow the
+            // reason — a hidden compaction-LLM failure (auth, overflow, provider
+            // 400) is exactly what makes "why did compaction do nothing" undebuggable.
+            logger.error("orchestrator", "compressChat LLM summarize failed — falling back to truncation", {
+                modelId,
+                inputChars: cleaned.length,
+                message: e?.message,
+                stack: e?.stack?.split("\n").slice(0, 3),
+            });
+        }
+    }
+    if (!usedLLM) {
+        // Over budget — truncate to fit budget while keeping preserved blocks
+        compressedContent =
+            cleaned.length > availableChars
+                ? `${cleaned.slice(0, availableChars)}\n\n[... ${cleaned.length - availableChars} characters truncated]`
+                : cleaned;
+    }
+    const restored = restorePreservedBlocks(compressedContent, blocks);
     return {
         summary: restored,
         preservedBlocks: blocks,

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

@@ -5,7 +5,7 @@
  * Scans for "Decision:", "Decided:", "Fact:", "Constraint:" patterns
  * and content inside <!-- preserve --> blocks.
  */
-import type { ModelMessage } from "ai";
+import { type ModelMessage } from "ai";
 export interface ExtractedDecisions {
     decisions: string[];
     facts: string[];
@@ -14,10 +14,7 @@ export interface ExtractedDecisions {
 /**
  * Extract decisions, facts, and constraints from messages.
  *
- * Scans serialized conversation text for:
- * - Lines matching "Decision:" or "Decided:" -> decisions
- * - Lines matching "Fact:" -> facts
- * - Lines matching "Constraint:" -> constraints
- * - All content inside <!-- preserve --> blocks -> decisions (verbatim)
+ * Scans serialized conversation text for explicit markers, but if modelId is
+ * given, it asks the LLM to intelligently extract them.
  */
-export declare function extractDecisions(messages: ModelMessage[]): ExtractedDecisions;
+export declare function extractDecisions(messages: ModelMessage[], modelId?: string, customInstructions?: string): Promise<ExtractedDecisions>;

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

@@ -5,7 +5,11 @@
  * Scans for "Decision:", "Decided:", "Fact:", "Constraint:" patterns
  * and content inside <!-- preserve --> blocks.
  */
+import { generateText } from "ai";
 import { serializeConversation } from "../../orchestrator/compaction.js";
+import { resolveModelRuntime, resolveTemperatureParam } from "../../providers/runtime.js";
+import { logger } from "../../utils/logger.js";
+import { capCompactionInput } from "./input-guard.js";
 import { extractPreservedBlocks } from "./preserve.js";
 const DECISION_RE = /(?:Decision|Decided):\s*(.+)/gi;
 const FACT_RE = /Fact:\s*(.+)/gi;
@@ -23,13 +27,10 @@ function matchAll(text, re) {
 /**
  * Extract decisions, facts, and constraints from messages.
  *
- * Scans serialized conversation text for:
- * - Lines matching "Decision:" or "Decided:" -> decisions
- * - Lines matching "Fact:" -> facts
- * - Lines matching "Constraint:" -> constraints
- * - All content inside <!-- preserve --> blocks -> decisions (verbatim)
+ * Scans serialized conversation text for explicit markers, but if modelId is
+ * given, it asks the LLM to intelligently extract them.
  */
-export function extractDecisions(messages) {
+export async function extractDecisions(messages, modelId, customInstructions) {
     if (messages.length === 0) {
         return { decisions: [], facts: [], constraints: [] };
     }
@@ -37,10 +38,49 @@ export function extractDecisions(messages) {
     // Extract preserved blocks as decisions
     const { blocks } = extractPreservedBlocks(serialized);
     const preservedDecisions = blocks.map((b) => b.content);
-    // Pattern-match for explicit markers
-    const decisions = [...matchAll(serialized, DECISION_RE), ...preservedDecisions];
-    const facts = matchAll(serialized, FACT_RE);
-    const constraints = matchAll(serialized, CONSTRAINT_RE);
+    const decisions = [];
+    const facts = [];
+    const constraints = [];
+    let usedLLM = false;
+    if (modelId) {
+        try {
+            const runtime = resolveModelRuntime(modelId);
+            const extraPrompt = customInstructions ? `\n\nUSER FOCUS/INSTRUCTIONS:\n${customInstructions}\n` : "";
+            // Guard input against the summarizer's context window (see input-guard).
+            const guardedInput = capCompactionInput(serialized, runtime.modelInfo?.contextWindow ?? 0);
+            const result = await generateText({
+                model: runtime.model,
+                system: 'You are an AI context compaction agent. Extract all core decisions, technical facts, and project constraints from this conversation. Return strict JSON with { "decisions": string[], "facts": string[], "constraints": string[] }.',
+                prompt: `Current conversation messages:\n\n${guardedInput}\n\nExtract decisions, facts, and constraints.${extraPrompt} Return strict JSON ONLY.`,
+                ...resolveTemperatureParam(runtime, 0.1),
+            });
+            const match = result.text.match(/\{[\s\S]*\}/);
+            if (match) {
+                const parsed = JSON.parse(match[0]);
+                if (Array.isArray(parsed.decisions))
+                    decisions.push(...parsed.decisions);
+                if (Array.isArray(parsed.facts))
+                    facts.push(...parsed.facts);
+                if (Array.isArray(parsed.constraints))
+                    constraints.push(...parsed.constraints);
+                usedLLM = true;
+            }
+        }
+        catch (e) {
+            // Fall back to regex extraction, but log the reason — a swallowed failure
+            // here silently degrades /compact to marker-only extraction.
+            logger.error("orchestrator", "extractDecisions LLM failed — falling back to regex", {
+                modelId,
+                message: e?.message,
+            });
+        }
+    }
+    if (!usedLLM) {
+        decisions.push(...matchAll(serialized, DECISION_RE));
+        facts.push(...matchAll(serialized, FACT_RE));
+        constraints.push(...matchAll(serialized, CONSTRAINT_RE));
+    }
+    decisions.push(...preservedDecisions);
     return { decisions, facts, constraints };
 }
 //# sourceMappingURL=extract.js.map

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

@@ -6,6 +6,19 @@
  * Snapshot full chat to history/<timestamp>.md before compressing.
  */
 import type { ModelMessage } from "ai";
+import { type CompactProgressFn } from "./progress.js";
+/**
+ * Anti-mù for the deliberate (/compact) path — parity with the auto/tool-loop
+ * compaction which persists every elided tool output via persistArtifact.
+ *
+ * deliberateCompact rewrites the whole history into a prose summary, so without
+ * this the model loses the ability to `ee_query "tool-artifact id=<id>"` a
+ * specific tool result after /compact. We record each tool result into the
+ * in-process + disk artifact cache (the tier ee_query reads FIRST, before EE),
+ * and fire a best-effort EE extract so cross-session rehydrate also survives.
+ * Fail-open: a cache/EE hiccup never blocks the compaction.
+ */
+export declare function recordToolArtifactsForRehydrate(messages: ModelMessage[], projectPath: string): number;
 export interface CompactionResult {
     decisionsExtracted: number;
     tokensBeforeCompress: number;
@@ -21,4 +34,4 @@ export interface CompactionResult {
  * 3. Pass 2: compressChat -> compressed output
  * 4. Return metrics
  */
-export declare function deliberateCompact(flowDir: string, messages: ModelMessage[], systemPrompt: string, tokenBudget: number, provider?: unknown, modelId?: string): Promise<CompactionResult>;
+export declare function deliberateCompact(flowDir: string, messages: ModelMessage[], systemPrompt: string, tokenBudget: number, modelId?: string, customInstructions?: string, onProgress?: CompactProgressFn): Promise<CompactionResult>;