muonroi-cli 1.8.5 → 1.9.0

package/dist/src/ee/auth.js

@@ -71,6 +71,45 @@ export async function writeExperienceConfig(patch, opts = {}) {
     await fs.mkdir(path.dirname(p), { recursive: true, mode: 0o700 });
     await fs.writeFile(p, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
 }
+/** Where the EE config lives, for display in setup/status output. */
+export function getExperienceConfigPath(opts = {}) {
+    return configPath(opts.home);
+}
+/**
+ * Best-effort reachability probe against an EE server's /health.
+ *
+ * Returns a reason on failure rather than a bare boolean: "saved but not
+ * reachable" and "saved, server says 401" are different problems for the user
+ * to act on, and collapsing them to `false` hides which one they have.
+ * Never throws — a probe is diagnostics, and must not fail a config write that
+ * already succeeded.
+ */
+export async function probeEEHealth(baseUrl, token, opts = {}) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), opts.timeoutMs ?? 4000);
+    try {
+        const res = await fetch(`${baseUrl}/health`, {
+            signal: ac.signal,
+            headers: token ? { authorization: `Bearer ${token}` } : undefined,
+        });
+        if (res.ok)
+            return { ok: true, detail: `HTTP ${res.status}` };
+        return {
+            ok: false,
+            detail: res.status === 401 || res.status === 403
+                ? `HTTP ${res.status} — the server rejected this auth token`
+                : `HTTP ${res.status}`,
+        };
+    }
+    catch (err) {
+        const message = err?.name === "AbortError" ? "timed out" : (err?.message ?? String(err));
+        console.error(`[ee/auth] /health probe failed for ${baseUrl}: ${message}`);
+        return { ok: false, detail: message };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 export function getCachedAuthToken() {
     return _token;
 }

package/dist/src/ee/client.js

@@ -207,13 +207,23 @@ export function createEEClient(opts = {}) {
     }
     return {
         async health() {
+            const startedAt = Date.now();
             try {
                 const resp = await f(`${baseUrl}/health`, {
                     signal: AbortSignal.timeout(DEFAULT_HEALTH_TIMEOUT_MS),
                 });
                 return { ok: resp.ok, status: resp.status };
             }
-            catch {
+            catch (err) {
+                // status:0 means "no response" and says nothing about WHY. Timeout, DNS,
+                // refused connection and TLS failure all degrade to the same shape, so a
+                // bare catch here leaves an agent with an unfalsifiable symptom — exactly
+                // what happened on 2026-07-17, when status:0 was really the server
+                // blocking its event loop.
+                logEeFailure("client.health", classifyEeError(err), err, {
+                    elapsedMs: Date.now() - startedAt,
+                    budgetMs: DEFAULT_HEALTH_TIMEOUT_MS,
+                });
                 return { ok: false, status: 0 };
             }
         },
@@ -599,6 +609,7 @@ export function createEEClient(opts = {}) {
             // races the server and loses → spurious ee_unavailable. 15s gives margin
             // so a slow-but-valid recall still lands rather than being dropped.
             const timeoutMs = opts.timeoutMs ?? 15000;
+            const startedAt = Date.now();
             try {
                 const resp = await f(`${baseUrl}/api/recall`, {
                     method: "POST",
@@ -606,11 +617,25 @@ export function createEEClient(opts = {}) {
                     body: JSON.stringify(redactedBody),
                     signal: opts.signal ?? AbortSignal.timeout(timeoutMs),
                 });
-                if (!resp.ok)
+                if (!resp.ok) {
+                    // Keep returning null — callers map it to "EE unavailable" — but never
+                    // discard the status. Collapsing 429/401/500 into the same null a
+                    // timeout produces is what made the 2026-07-17 incident unfalsifiable
+                    // from the client: "is the server rate-limiting us?" could not be
+                    // answered without reading the server's source.
+                    logEeFailure("client.recall", "error", new Error(`HTTP ${resp.status}`), {
+                        status: resp.status,
+                        elapsedMs: Date.now() - startedAt,
+                    });
                     return null;
+                }
                 return (await resp.json());
             }
-            catch {
+            catch (err) {
+                logEeFailure("client.recall", classifyEeError(err), err, {
+                    elapsedMs: Date.now() - startedAt,
+                    budgetMs: timeoutMs,
+                });
                 return null;
             }
         },

package/dist/src/ee/ee-onboarding.js

@@ -8,27 +8,7 @@
  * health probe is reported, not hidden, and never blocks setup.
  */
 import { createInterface } from "node:readline";
-import { writeExperienceConfig } from "./auth.js";
-/** Best-effort reachability probe — returns true/false, never throws. */
-async function probeHealth(baseUrl, token) {
-    try {
-        const ac = new AbortController();
-        const timer = setTimeout(() => ac.abort(), 4000);
-        try {
-            const res = await fetch(`${baseUrl}/health`, {
-                signal: ac.signal,
-                headers: token ? { authorization: `Bearer ${token}` } : undefined,
-            });
-            return res.ok;
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    catch {
-        return false;
-    }
-}
+import { probeEEHealth, writeExperienceConfig } from "./auth.js";
 /**
  * Returns true when a config was written (so the caller can reload EE auth).
  * Returns false when skipped or invalid.
@@ -38,8 +18,8 @@ export async function firstRunEESetup() {
     const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a)));
     try {
         process.stderr.write("\nExperience Engine (optional) — a shared brain that recalls past decisions, gotchas,\n" +
-            "and recipes so the agent works like a senior on your stack. You can set this up later\n" +
-            "by editing ~/.experience/config.json or setting MUONROI_EE_BASE_URL.\n\n");
+            "and recipes so the agent works like a senior on your stack. Skipping is fine: you can\n" +
+            "connect one at any time with `/ee config <url> [token]`.\n\n");
         const url = (await ask("EE server URL (blank to skip): ")).trim();
         if (!url) {
             process.stderr.write("Skipped Experience Engine setup.\n");
@@ -59,10 +39,10 @@ export async function firstRunEESetup() {
             ...(token ? { serverAuthToken: token } : {}),
         });
         process.stderr.write(`Wrote Experience Engine config → ~/.experience/config.json (serverBaseUrl=${normalized}).\n`);
-        const reachable = await probeHealth(normalized, token || undefined);
-        process.stderr.write(reachable
+        const health = await probeEEHealth(normalized, token || undefined);
+        process.stderr.write(health.ok
             ? "  ✓ EE server reachable.\n"
-            : "  ⚠ Could not reach the EE server right now (saved anyway — run 'muonroi-cli doctor' to recheck).\n");
+            : `  ⚠ Could not reach the EE server right now — ${health.detail} (saved anyway; recheck with '/ee config').\n`);
         return true;
     }
     catch (err) {

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

@@ -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, compress via LLM (if provider given) or truncate, and restore 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, customInstructions?: 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,9 +4,9 @@
  * Serializes messages, extracts preserved blocks, compresses if over budget,
  * then restores preserved blocks into the output.
  */
-import { generateText } from "ai";
+import { streamText } from "ai";
 import { serializeConversation } from "../../orchestrator/compaction.js";
-import { resolveModelRuntime, resolveTemperatureParam, } from "../../providers/runtime.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";
@@ -16,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, compress via LLM (if provider given) or truncate, and restore 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, customInstructions) {
+export async function compressChat(messages, _systemPrompt, tokenBudget, modelId, customInstructions, onFraction) {
     const serialized = serializeConversation(messages);
     const { cleaned, blocks } = extractPreservedBlocks(serialized);
     // Estimate tokens of cleaned text
@@ -38,21 +38,34 @@ export async function compressChat(messages, _systemPrompt, tokenBudget, provide
     const availableChars = availableTokens * 4;
     let compressedContent = cleaned;
     let usedLLM = false;
-    if (provider && modelId) {
+    if (modelId) {
         try {
-            const runtime = resolveModelRuntime(provider, modelId);
+            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);
-            const result = await generateText({
+            // 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),
             });
-            compressedContent = result.text.trim();
+            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) {

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

@@ -14,7 +14,7 @@ export interface ExtractedDecisions {
 /**
  * Extract decisions, facts, and constraints from messages.
  *
- * Scans serialized conversation text for explicit markers, but if provider
- * and modelId are given, it asks the LLM to intelligently extract them.
+ * 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[], provider?: unknown, modelId?: string, customInstructions?: string): Promise<ExtractedDecisions>;
+export declare function extractDecisions(messages: ModelMessage[], modelId?: string, customInstructions?: string): Promise<ExtractedDecisions>;

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

@@ -7,7 +7,7 @@
  */
 import { generateText } from "ai";
 import { serializeConversation } from "../../orchestrator/compaction.js";
-import { resolveModelRuntime, resolveTemperatureParam, } from "../../providers/runtime.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";
@@ -27,10 +27,10 @@ function matchAll(text, re) {
 /**
  * Extract decisions, facts, and constraints from messages.
  *
- * Scans serialized conversation text for explicit markers, but if provider
- * and modelId are given, it asks the LLM to intelligently extract them.
+ * Scans serialized conversation text for explicit markers, but if modelId is
+ * given, it asks the LLM to intelligently extract them.
  */
-export async function extractDecisions(messages, provider, modelId, customInstructions) {
+export async function extractDecisions(messages, modelId, customInstructions) {
     if (messages.length === 0) {
         return { decisions: [], facts: [], constraints: [] };
     }
@@ -42,9 +42,9 @@ export async function extractDecisions(messages, provider, modelId, customInstru
     const facts = [];
     const constraints = [];
     let usedLLM = false;
-    if (provider && modelId) {
+    if (modelId) {
         try {
-            const runtime = resolveModelRuntime(provider, modelId);
+            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);

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

@@ -6,6 +6,7 @@
  * 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.
@@ -33,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, customInstructions?: string): Promise<CompactionResult>;
+export declare function deliberateCompact(flowDir: string, messages: ModelMessage[], systemPrompt: string, tokenBudget: number, modelId?: string, customInstructions?: string, onProgress?: CompactProgressFn): Promise<CompactionResult>;

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

@@ -15,6 +15,7 @@ import { logger } from "../../utils/logger.js";
 import { readArtifact, writeArtifact } from "../artifact-io.js";
 import { compressChat } from "./compress.js";
 import { extractDecisions } from "./extract.js";
+import { stageProgress } 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.
@@ -83,13 +84,35 @@ export function recordToolArtifactsForRehydrate(messages, projectPath) {
  * 3. Pass 2: compressChat -> compressed output
  * 4. Return metrics
  */
-export async function deliberateCompact(flowDir, messages, systemPrompt, tokenBudget, provider, modelId, customInstructions) {
+export async function deliberateCompact(flowDir, messages, systemPrompt, tokenBudget, modelId, customInstructions, onProgress) {
+    // Callers reach this through @ts-nocheck UI code, so an argument-order drift
+    // is invisible to tsc. It is NOT invisible at runtime: a non-string modelId
+    // makes resolveModelRuntime throw, compressChat catches it, and /compact
+    // silently degrades to truncation — which is how commit e2100fb7 shipped a
+    // broken /compact. Fail loudly instead of summarizing nothing.
+    if (modelId !== undefined && typeof modelId !== "string") {
+        throw new TypeError(`deliberateCompact: modelId must be a model id string, got ${typeof modelId}. ` +
+            `Check the argument order at the call site.`);
+    }
+    const report = (stage, fraction) => {
+        if (!onProgress)
+            return;
+        try {
+            onProgress(stageProgress(stage, fraction));
+        }
+        catch (err) {
+            // A broken progress sink must never fail the compaction it is reporting.
+            logger.error("orchestrator", "compact progress callback threw", { stage, message: err?.message });
+        }
+    };
+    report("artifacts");
     // Anti-mù parity: persist every tool result to the artifact cache (+ EE)
     // BEFORE we summarize the history away, so the model can still rehydrate a
     // specific tool output via ee_query "tool-artifact id=<id>" after /compact.
     recordToolArtifactsForRehydrate(messages, flowDir);
     // Pass 1: Extract decisions/facts/constraints
-    const extracted = await extractDecisions(messages, provider, modelId, customInstructions);
+    report("extract");
+    const extracted = await extractDecisions(messages, modelId, customInstructions);
     const totalExtracted = extracted.decisions.length + extracted.facts.length + extracted.constraints.length;
     // Append to decisions.md
     if (totalExtracted > 0) {
@@ -110,6 +133,7 @@ export async function deliberateCompact(flowDir, messages, systemPrompt, tokenBu
         await writeArtifact(flowDir, "decisions.md", existing, ["Decisions", "Facts", "Constraints"]);
     }
     // Snapshot full chat to history/
+    report("snapshot");
     const historyDir = path.join(flowDir, "history");
     await fs.mkdir(historyDir, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
@@ -122,7 +146,9 @@ export async function deliberateCompact(flowDir, messages, systemPrompt, tokenBu
     // Token estimation before
     const tokensBefore = estimateConversationTokens(systemPrompt, messages);
     // Pass 2: Compress
-    const compressed = await compressChat(messages, systemPrompt, tokenBudget, provider, modelId, customInstructions);
+    report("compress");
+    const compressed = await compressChat(messages, systemPrompt, tokenBudget, modelId, customInstructions, (f) => report("compress", f));
+    report("done");
     return {
         decisionsExtracted: totalExtracted,
         tokensBeforeCompress: tokensBefore,

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

@@ -0,0 +1,35 @@
+/**
+ * src/flow/compaction/progress.ts
+ *
+ * Progress model for deliberate (/compact) compaction.
+ *
+ * A compaction is a fixed pipeline of stages (see index.ts), so the percentage
+ * is stage-weighted rather than invented: each stage owns a span of the bar and
+ * only advances when that stage really advances. The two LLM passes dominate the
+ * wall-clock, which is why they own most of the span; the compress pass streams,
+ * so it reports a genuine within-stage fraction instead of freezing.
+ *
+ * Weights are ordered spans covering 0..100 with no gaps — asserted in tests so
+ * a new stage can't silently make the bar jump or stall.
+ */
+export type CompactStage = "artifacts" | "extract" | "snapshot" | "compress" | "done";
+export interface CompactProgress {
+    stage: CompactStage;
+    /** 0..100, monotonic across the run. */
+    percent: number;
+    /** Human-readable current step, e.g. "Compressing history…". */
+    label: string;
+}
+export type CompactProgressFn = (progress: CompactProgress) => void;
+interface StageSpan {
+    from: number;
+    to: number;
+    label: string;
+}
+export declare const COMPACT_STAGE_SPANS: Record<CompactStage, StageSpan>;
+/**
+ * Percent for a stage at `fraction` (0..1) of its own work. Callers that cannot
+ * measure within-stage progress pass 0 and land on the stage's start.
+ */
+export declare function stageProgress(stage: CompactStage, fraction?: number): CompactProgress;
+export {};

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

@@ -0,0 +1,35 @@
+/**
+ * src/flow/compaction/progress.ts
+ *
+ * Progress model for deliberate (/compact) compaction.
+ *
+ * A compaction is a fixed pipeline of stages (see index.ts), so the percentage
+ * is stage-weighted rather than invented: each stage owns a span of the bar and
+ * only advances when that stage really advances. The two LLM passes dominate the
+ * wall-clock, which is why they own most of the span; the compress pass streams,
+ * so it reports a genuine within-stage fraction instead of freezing.
+ *
+ * Weights are ordered spans covering 0..100 with no gaps — asserted in tests so
+ * a new stage can't silently make the bar jump or stall.
+ */
+export const COMPACT_STAGE_SPANS = {
+    artifacts: { from: 0, to: 5, label: "Preserving tool artifacts…" },
+    extract: { from: 5, to: 40, label: "Extracting decisions…" },
+    snapshot: { from: 40, to: 50, label: "Snapshotting history…" },
+    compress: { from: 50, to: 100, label: "Compressing history…" },
+    done: { from: 100, to: 100, label: "Compacted" },
+};
+/**
+ * Percent for a stage at `fraction` (0..1) of its own work. Callers that cannot
+ * measure within-stage progress pass 0 and land on the stage's start.
+ */
+export function stageProgress(stage, fraction = 0) {
+    const span = COMPACT_STAGE_SPANS[stage];
+    const clamped = Math.max(0, Math.min(1, Number.isFinite(fraction) ? fraction : 0));
+    return {
+        stage,
+        percent: Math.round(span.from + (span.to - span.from) * clamped),
+        label: span.label,
+    };
+}
+//# sourceMappingURL=progress.js.map

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

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.8.5";
+export declare const PACKAGE_VERSION = "1.9.0";
 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.8.5";
+export const PACKAGE_VERSION = "1.9.0";
 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/gsd/flags.d.ts

@@ -53,3 +53,14 @@ export declare function isRoundGroupsEnabled(): boolean;
  * MUONROI_TASK_AWARE_PANEL=0.
  */
 export declare function isTaskAwarePanelEnabled(): boolean;
+/**
+ * Plan-review debate retry budget. The council debate can return an EMPTY
+ * synthesis on any of its fail-open paths (provider unreachable, sub-phase
+ * catch, user/watchdog abort) — a silent null that plan-council previously
+ * collapsed into a permanent forced-`revise`, bricking an autonomous /ideal
+ * heavy run (0 code, no human to re-trigger plan-review). On empty synthesis
+ * we retry the debate up to this many times before falling back to the
+ * perspective path. Default 1 (up to 2 debate attempts). Env override:
+ * MUONROI_PLAN_REVIEW_DEBATE_RETRIES. Clamped to [0, 5].
+ */
+export declare function getPlanReviewDebateRetries(): number;

package/dist/src/gsd/flags.js

@@ -80,4 +80,23 @@ export function isTaskAwarePanelEnabled() {
     const raw = process.env.MUONROI_TASK_AWARE_PANEL;
     return raw !== "0" && raw?.toLowerCase() !== "false";
 }
+/**
+ * Plan-review debate retry budget. The council debate can return an EMPTY
+ * synthesis on any of its fail-open paths (provider unreachable, sub-phase
+ * catch, user/watchdog abort) — a silent null that plan-council previously
+ * collapsed into a permanent forced-`revise`, bricking an autonomous /ideal
+ * heavy run (0 code, no human to re-trigger plan-review). On empty synthesis
+ * we retry the debate up to this many times before falling back to the
+ * perspective path. Default 1 (up to 2 debate attempts). Env override:
+ * MUONROI_PLAN_REVIEW_DEBATE_RETRIES. Clamped to [0, 5].
+ */
+export function getPlanReviewDebateRetries() {
+    const raw = process.env.MUONROI_PLAN_REVIEW_DEBATE_RETRIES;
+    if (raw === undefined)
+        return 1;
+    const n = Number.parseInt(raw, 10);
+    if (Number.isNaN(n) || n < 0)
+        return 1;
+    return Math.min(n, 5);
+}
 //# sourceMappingURL=flags.js.map