muonroi-cli 1.8.4 → 1.9.0

package/dist/src/router/peak-hour.js

@@ -0,0 +1,107 @@
+import { getModelByTier, getModelInfo, getProviderPeakHourRule, SWITCH_PROVIDER_ORDER } from "../models/registry.js";
+import { detectProviderForModel } from "../providers/runtime.js";
+import { getPeakHourPolicy, isProviderDisabled } from "../utils/settings.js";
+export function hourInTimezone(now, timezone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        hour: "numeric",
+        hour12: false,
+    }).formatToParts(now);
+    const hour = parts.find((p) => p.type === "hour")?.value;
+    return hour ? Number(hour) : 0;
+}
+/** @deprecated Use hourInTimezone — kept for tests referencing UTC+8. */
+export function hourUtc8(now) {
+    return hourInTimezone(now, "Asia/Shanghai");
+}
+export function peakHourWindows(rule) {
+    if (rule.windows?.length)
+        return rule.windows;
+    if (rule.start_hour != null && rule.end_hour != null) {
+        return [{ start_hour: rule.start_hour, end_hour: rule.end_hour }];
+    }
+    return [];
+}
+export function isPeakHourForProvider(provider, now, userPolicy = getPeakHourPolicy()) {
+    if (userPolicy.enabled === false)
+        return false;
+    const rule = getProviderPeakHourRule(provider);
+    if (!rule)
+        return false;
+    const h = hourInTimezone(now, rule.timezone);
+    return peakHourWindows(rule).some((w) => h >= w.start_hour && h < w.end_hour);
+}
+/** @deprecated Use isPeakHourForProvider(provider, ...) — window is per-provider from catalog. */
+export function isPeakHourUtc8(now, userPolicy) {
+    return isPeakHourForProvider("zai", now, userPolicy) || isPeakHourForProvider("deepseek", now, userPolicy);
+}
+function sameProviderDowngrade(modelId, provider) {
+    const rule = getProviderPeakHourRule(provider);
+    if (!rule)
+        return null;
+    if (!rule.sensitive_model_ids.includes(modelId))
+        return null;
+    return rule.fallback_model_id;
+}
+function pickSwitchFallback(excludeProvider) {
+    const rule = getProviderPeakHourRule(excludeProvider);
+    const order = rule?.switch_fallback_providers ?? SWITCH_PROVIDER_ORDER;
+    for (const p of order) {
+        if (p === excludeProvider)
+            continue;
+        if (isProviderDisabled(p))
+            continue;
+        const m = getModelByTier("fast", p) ?? getModelByTier("balanced", p);
+        if (m && m.provider === p)
+            return m;
+    }
+    return undefined;
+}
+/**
+ * Adjust a concrete model id for peak-hour policy. No-op outside the provider's
+ * catalog-defined window or when user policy is disabled.
+ */
+export function adjustPeakHourModel(modelId, opts) {
+    const userPolicy = opts?.policy ?? getPeakHourPolicy();
+    const now = opts?.now ?? new Date();
+    const provider = detectProviderForModel(modelId);
+    if (!isPeakHourForProvider(provider, now, userPolicy)) {
+        return { modelId, provider, adjusted: false };
+    }
+    const downgraded = sameProviderDowngrade(modelId, provider);
+    if (downgraded) {
+        if (userPolicy.mode === "switch") {
+            const alt = pickSwitchFallback(provider);
+            if (alt && alt.id !== modelId) {
+                return {
+                    modelId: alt.id,
+                    provider: alt.provider,
+                    adjusted: true,
+                    reason: `peak-hour(${provider}→${alt.provider}:${alt.id})`,
+                };
+            }
+        }
+        const info = getModelInfo(downgraded);
+        if (info?.provider === provider) {
+            return {
+                modelId: downgraded,
+                provider,
+                adjusted: true,
+                reason: `peak-hour(${modelId}→${downgraded})`,
+            };
+        }
+    }
+    return { modelId, provider, adjusted: false };
+}
+/** Tier lookup with peak-hour adjustment applied to the resolved model. */
+export function getRoutedModelByTier(tier, preferProvider, opts) {
+    const base = getModelByTier(tier, preferProvider);
+    if (!base)
+        return undefined;
+    const adj = adjustPeakHourModel(base.id, opts);
+    if (!adj.adjusted)
+        return base;
+    const info = getModelInfo(adj.modelId);
+    return info ?? base;
+}
+//# sourceMappingURL=peak-hour.js.map

package/dist/src/router/step-router.js

@@ -28,6 +28,7 @@ import { getModelByTier } from "../models/registry.js";
 import { detectProviderForModel } from "../providers/runtime.js";
 import { readTimeoutEnv } from "../utils/ee-logger.js";
 import { isModelDisabled, isProviderDisabled, loadUserSettings } from "../utils/settings.js";
+import { getRoutedModelByTier } from "./peak-hour.js";
 // ─── EE-guided SAMR override ─────────────────────────────────────────────────
 // EE_SAMR_TIMEOUT: per-call budget for consulting the EE brain about SAMR.
 // Default 2s, range 500ms..5s. Falls back to heuristics on timeout/error.
@@ -187,7 +188,7 @@ export function decideStepRouting(phase1ModelId, defaultProvider, config) {
 // ─── Internal helpers ────────────────────────────────────────────────────────
 function resolveExecutionModel(provider, tier, excludeModelId) {
     // Try same provider first
-    const sameProvider = getModelByTier(tier, provider);
+    const sameProvider = getRoutedModelByTier(tier, provider);
     if (sameProvider && sameProvider.id !== excludeModelId) {
         // Guard: check provider-disabled and model-disabled (mirrors cross-provider branch)
         if (!isProviderDisabled(sameProvider.provider) && !isModelDisabled(sameProvider.id)) {
@@ -195,7 +196,7 @@ function resolveExecutionModel(provider, tier, excludeModelId) {
         }
     }
     // If no same-provider model in this tier, try any provider
-    const anyProvider = getModelByTier(tier);
+    const anyProvider = getRoutedModelByTier(tier);
     if (anyProvider && anyProvider.id !== excludeModelId) {
         // Only use cross-provider if the provider and model aren't disabled
         if (!isProviderDisabled(anyProvider.provider) && !isModelDisabled(anyProvider.id)) {

package/dist/src/router/warm.js

@@ -6,13 +6,13 @@
  */
 import { routeModel as bridgeRouteModel } from "../ee/bridge.js";
 import { getDefaultEEClient } from "../ee/intercept.js";
-import { getModelByTier } from "../models/registry.js";
+import { getRoutedModelByTier } from "./peak-hour.js";
 import { PROVIDER_INHERIT } from "./provider-sentinel.js";
 /**
  * Map the session's provider to the EE runtime whose tier ladder the EE serves.
  * EE keys its `getModelTiers()` ladders by agent runtime, not provider, and only
- * the catalog-backed runtimes (claude/codex/gemini) resolve to a non-null model.
- * Providers without an EE runtime (deepseek/siliconflow/xai) map to "" — EE then
+ * the catalog-backed runtimes (claude/codex) resolve to a non-null model.
+ * Providers without an EE runtime (deepseek/xai) map to "" — EE then
  * returns the routing TIER with a null model and we resolve the concrete model
  * from the shared catalog for the session provider. This removes the old
  * hardcoded `runtime:"claude"`, which leaked EE's stale `claude-*` ids into the
@@ -21,7 +21,6 @@ import { PROVIDER_INHERIT } from "./provider-sentinel.js";
 const PROVIDER_TO_EE_RUNTIME = Object.freeze({
     anthropic: "claude",
     openai: "codex",
-    google: "gemini",
 });
 function eeRuntimeForProvider(provider) {
     return (provider && PROVIDER_TO_EE_RUNTIME[provider]) || "";
@@ -36,7 +35,7 @@ export async function callWarmRoute(prompt, opts) {
         // EE returns a model only for catalog-backed runtimes; otherwise resolve the
         // concrete model from the catalog for the session provider + decided tier.
         const catalogTier = TIER_TO_CATALOG_TIER[bridgeResult.tier] ?? "balanced";
-        const model = bridgeResult.model || getModelByTier(catalogTier, opts.defaultProvider)?.id;
+        const model = bridgeResult.model || getRoutedModelByTier(catalogTier, opts.defaultProvider)?.id;
         if (model) {
             return {
                 tier: bridgeResult.tier === "fast" ? "hot" : bridgeResult.tier === "premium" ? "cold" : "warm",

package/dist/src/scaffold/continuation-prompt.d.ts

@@ -10,3 +10,14 @@ export interface ContinuationPromptInput {
     installedPackages?: readonly string[];
 }
 export declare function buildIdealContinuationPrompt(input: ContinuationPromptInput): string;
+export interface AdoptExistingPromptInput {
+    originalPrompt: string;
+    projectDir: string;
+}
+/**
+ * Build the continuation prompt fed to the LLM after the user adopts an EXISTING
+ * project via the CB-3 "Point to existing" recovery option. Unlike the init_new
+ * variant this makes no template/BB assumptions — the target is an arbitrary
+ * repo the user already has, with a verify recipe already detected there.
+ */
+export declare function buildAdoptExistingContinuationPrompt(input: AdoptExistingPromptInput): string;

package/dist/src/scaffold/continuation-prompt.js

@@ -63,4 +63,30 @@ Constraints:
 - Don't ask "do you want me to continue?" — proceed end-to-end.
 - If you hit a blocker that genuinely needs the user, state EXACTLY which decision is blocking and stop.`;
 }
+/**
+ * Build the continuation prompt fed to the LLM after the user adopts an EXISTING
+ * project via the CB-3 "Point to existing" recovery option. Unlike the init_new
+ * variant this makes no template/BB assumptions — the target is an arbitrary
+ * repo the user already has, with a verify recipe already detected there.
+ */
+export function buildAdoptExistingContinuationPrompt(input) {
+    const { originalPrompt, projectDir } = input;
+    return `You are continuing a /ideal product loop in an EXISTING project the user pointed to at ${projectDir}. A verify recipe was detected there, so the project already has a runnable test/build setup — adopt it, do NOT re-scaffold.
+
+User's original request:
+"${originalPrompt}"
+
+Implement this now against the existing codebase. Do NOT ask the user to restate the request.
+
+1. Discover structure (1-2 tool calls max): list the project directory, then read the manifest that exists (package.json / pyproject.toml / go.mod / Cargo.toml / *.csproj) and any README/AGENTS.md to learn the stack, entry point, and conventions. Do NOT assume files — skip whatever is absent.
+2. Design briefly (5-10 lines): the entities/modules/endpoints to add, matching the conventions you observed (naming, error-handling, DI, folder layout).
+3. Implement: create/edit files in the EXISTING layout; mirror the surrounding patterns. Never hardcode secrets or URLs — read config from the project's existing mechanism.
+4. Verify: run the project's OWN detected test/build command; it must pass. Report the exact command + an output excerpt as evidence.
+5. Summarize in 3-5 bullets: what was added, where, and how to run/test it.
+
+Constraints:
+- Your working directory is already ${projectDir}; do NOT cd into it and do NOT re-scaffold.
+- Don't ask "do you want me to continue?" — proceed end-to-end.
+- If a genuine blocker needs the user (missing API key, ambiguous requirement), state EXACTLY which decision is blocking and stop.`;
+}
 //# sourceMappingURL=continuation-prompt.js.map

package/dist/src/scaffold/point-to-existing.d.ts

@@ -5,6 +5,7 @@
  * Designed for testability: callers inject detectVerifyRecipe so unit tests
  * never hit the real orchestrator.
  */
+import type { VerifyRecipe } from "../types/index.js";
 import { detectBBFramework } from "./init-new.js";
 export interface PointToExistingOptions {
     /** Raw path string entered by the user. May be relative or absolute. */
@@ -26,6 +27,26 @@ export interface PointToExistingResult {
     targetFramework?: "muonroi-building-block" | string;
 }
 export { detectBBFramework };
+/**
+ * Deterministic, filesystem-only verify-recipe detection for an existing project
+ * the user pointed to via the CB-3 recovery card.
+ *
+ * WHY NOT the orchestrator's detectVerifyRecipe: that path runs an LLM
+ * verify-detect sub-agent against the orchestrator's OWN (session) cwd via
+ * `this.bash.getCwd()` — it cannot inspect an arbitrary pointed-to directory, so
+ * wiring it here was deferred and the handler stubbed to `null` (point-to-existing
+ * therefore ALWAYS reported "no recipe", making the recovery option inert).
+ * `inferVerifyProjectProfile` reads the target dir's manifest/build files
+ * directly (package.json test/check/lint, Makefile, pyproject, go.mod, cargo,
+ * maven/gradle, *.csproj) — the correct detector for adopting an existing repo.
+ *
+ * Returns the recipe only when it is actually RUNNABLE (has a test/build/start
+ * command). The bare "unknown" fallback that `inferVerifyProjectProfile` emits
+ * for a directory with no recognizable project files carries empty commands →
+ * we return null so point-to-existing correctly reports `no_recipe` instead of
+ * falsely adopting an empty directory.
+ */
+export declare function detectExistingProjectRecipe(cwd: string): VerifyRecipe | null;
 /**
  * Resolve and validate a user-provided path for sprint re-entry.
  *

package/dist/src/scaffold/point-to-existing.js

@@ -7,8 +7,33 @@
  */
 import { realpathSync, statSync } from "node:fs";
 import * as path from "node:path";
+import { inferVerifyProjectProfile } from "../verify/recipes.js";
 import { detectBBFramework } from "./init-new.js";
 export { detectBBFramework };
+/**
+ * Deterministic, filesystem-only verify-recipe detection for an existing project
+ * the user pointed to via the CB-3 recovery card.
+ *
+ * WHY NOT the orchestrator's detectVerifyRecipe: that path runs an LLM
+ * verify-detect sub-agent against the orchestrator's OWN (session) cwd via
+ * `this.bash.getCwd()` — it cannot inspect an arbitrary pointed-to directory, so
+ * wiring it here was deferred and the handler stubbed to `null` (point-to-existing
+ * therefore ALWAYS reported "no recipe", making the recovery option inert).
+ * `inferVerifyProjectProfile` reads the target dir's manifest/build files
+ * directly (package.json test/check/lint, Makefile, pyproject, go.mod, cargo,
+ * maven/gradle, *.csproj) — the correct detector for adopting an existing repo.
+ *
+ * Returns the recipe only when it is actually RUNNABLE (has a test/build/start
+ * command). The bare "unknown" fallback that `inferVerifyProjectProfile` emits
+ * for a directory with no recognizable project files carries empty commands →
+ * we return null so point-to-existing correctly reports `no_recipe` instead of
+ * falsely adopting an empty directory.
+ */
+export function detectExistingProjectRecipe(cwd) {
+    const { recipe } = inferVerifyProjectProfile(cwd);
+    const runnable = recipe.testCommands.length > 0 || recipe.buildCommands.length > 0 || Boolean(recipe.startCommand);
+    return runnable ? recipe : null;
+}
 // ---------------------------------------------------------------------------
 // Implementation
 // ---------------------------------------------------------------------------

package/dist/src/self-qa/agentic-loop.js

@@ -141,15 +141,16 @@ export async function createLLMBrain(opts) {
     const apiKey = await loadKeyForProvider(provider);
     if (!apiKey)
         throw new Error(`No API key found for provider '${provider}'`);
-    const { factory } = createProviderFactory(provider, { apiKey });
-    const runtime = resolveModelRuntime(factory, opts.modelId);
+    // Registers the factory so resolveModelRuntime can derive it from the model.
+    createProviderFactory(provider, { apiKey });
+    const runtime = resolveModelRuntime(opts.modelId);
     const systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     const maxTokens = opts.maxTokens ?? 1024;
     const retryOnEmpty = opts.retryOnEmpty !== false;
     // @ai-sdk/openai-compatible's chat schema exposes `strictJsonSchema: false`
     // for providers that don't honour OpenAI's strict JSON schema mode.
-    // DeepSeek (and DeepSeek-compatible providers like SiliconFlow) only
-    // support `response_format: {type: "json_object"}` — they reject the full
+    // DeepSeek only supports `response_format: {type: "json_object"}` — it
+    // rejects the full
     // schema response_format. Setting strictJsonSchema=false makes AI SDK fall
     // back to lenient json_object mode silently (no "responseFormat not
     // supported" warning) while still steering the model toward JSON output.
@@ -161,7 +162,7 @@ export async function createLLMBrain(opts) {
     const mergedProviderOptions = {
         ...(runtime.providerOptions ?? {}),
     };
-    if (provider === "deepseek" || provider === "siliconflow") {
+    if (provider === "deepseek") {
         mergedProviderOptions[provider] = {
             ...(mergedProviderOptions[provider] ?? {}),
             strictJsonSchema: false,

package/dist/src/{ui/state → state}/active-run.d.ts

@@ -21,6 +21,25 @@ export declare const activeRunStore: {
     clearActiveRun: () => void;
     subscribe: (fn: Listener) => (() => void);
 };
+/**
+ * Single canonical writer for "which run is the workspace focused on".
+ * Writes the durable pointer (`state.md` `Active Run`) AND the in-memory cache
+ * atomically, so disk and StatusBar/reporter never drift (F8 follow-up).
+ *
+ * The disk write is idempotent with `ensureRunScoped`'s earlier write for the
+ * same runId — routing the focus moment through here just guarantees they agree.
+ */
+export declare function setWorkspaceFocus(flowDir: string, focus: {
+    runId: string;
+    productSlug: string;
+    reason?: string;
+}): Promise<void>;
+/**
+ * Clear the workspace focus cache when a run ends (shipped / halted).
+ * Cache-only by design: the durable `Active Run` pointer is left intact as a
+ * historical marker so `/ideal phases` still resolves the last run post-ship.
+ */
+export declare function clearWorkspaceFocus(): void;
 /** Test helper: reset to initial state. */
 export declare function __resetActiveRunStoreForTests(): void;
 export {};

package/dist/src/{ui/state → state}/active-run.js

@@ -37,6 +37,27 @@ function makeActiveRunStore() {
     };
 }
 export const activeRunStore = makeActiveRunStore();
+/**
+ * Single canonical writer for "which run is the workspace focused on".
+ * Writes the durable pointer (`state.md` `Active Run`) AND the in-memory cache
+ * atomically, so disk and StatusBar/reporter never drift (F8 follow-up).
+ *
+ * The disk write is idempotent with `ensureRunScoped`'s earlier write for the
+ * same runId — routing the focus moment through here just guarantees they agree.
+ */
+export async function setWorkspaceFocus(flowDir, focus) {
+    const { setActiveRunId } = await import("../flow/run-manager.js");
+    await setActiveRunId(flowDir, focus.runId);
+    activeRunStore.setActiveRun(focus.runId, flowDir, focus.productSlug);
+}
+/**
+ * Clear the workspace focus cache when a run ends (shipped / halted).
+ * Cache-only by design: the durable `Active Run` pointer is left intact as a
+ * historical marker so `/ideal phases` still resolves the last run post-ship.
+ */
+export function clearWorkspaceFocus() {
+    activeRunStore.clearActiveRun();
+}
 /** Test helper: reset to initial state. */
 export function __resetActiveRunStoreForTests() {
     activeRunStore.clearActiveRun();

package/dist/src/{ui/status-bar/store.d.ts → state/status-bar-store.d.ts}

@@ -1,9 +1,12 @@
 /**
- * src/ui/status-bar/store.ts
+ * src/state/status-bar-store.ts
  *
  * Status bar store: subscribable atom holding model/provider/tier/tokens/USD/degraded.
  * wireStatusBar() connects to routerStore (Plan 03), subscribeThresholds (Plan 04),
  * and subscribeDowngrade (Plan 05).
+ *
+ * Presentation-agnostic state — lives outside src/ui so the headless core
+ * (orchestrator/tool-engine/stream-runner) can read it without importing ui/.
  */
 export interface SprintProgressSegment {
     /** Active sprint index (1-based). */

package/dist/src/{ui/status-bar/store.js → state/status-bar-store.js}

@@ -1,15 +1,18 @@
 /**
- * src/ui/status-bar/store.ts
+ * src/state/status-bar-store.ts
  *
  * Status bar store: subscribable atom holding model/provider/tier/tokens/USD/degraded.
  * wireStatusBar() connects to routerStore (Plan 03), subscribeThresholds (Plan 04),
  * and subscribeDowngrade (Plan 05).
+ *
+ * Presentation-agnostic state — lives outside src/ui so the headless core
+ * (orchestrator/tool-engine/stream-runner) can read it without importing ui/.
  */
-import { getCircuitState } from "../../ee/client.js";
-import { routerStore } from "../../router/store.js";
-import { subscribeDowngrade } from "../../usage/downgrade.js";
-import { subscribeThresholds } from "../../usage/thresholds.js";
-import { activeRunStore } from "../state/active-run.js";
+import { getCircuitState } from "../ee/client.js";
+import { routerStore } from "../router/store.js";
+import { subscribeDowngrade } from "../usage/downgrade.js";
+import { subscribeThresholds } from "../usage/thresholds.js";
+import { activeRunStore } from "./active-run.js";
 function makeStore() {
     let state = {
         provider: "",
@@ -141,8 +144,8 @@ export function wireStatusBar() {
         }
         try {
             // Lazy import to avoid circular dependency at module load time.
-            const { readBacklog } = await import("../../product-loop/backlog-store.js");
-            const { readSprintPlan } = await import("../../product-loop/sprint-store.js");
+            const { readBacklog } = await import("../product-loop/backlog-store.js");
+            const { readSprintPlan } = await import("../product-loop/sprint-store.js");
             const [backlog, sprintPlan] = await Promise.all([
                 readBacklog(run.flowDir, run.runId).catch(() => null),
                 readSprintPlan(run.flowDir, run.runId).catch(() => null),
@@ -276,4 +279,4 @@ export function __resetStatusBarStoreForTests() {
     });
     wired = false;
 }
-//# sourceMappingURL=store.js.map
+//# sourceMappingURL=status-bar-store.js.map

package/dist/src/state/turn-trace.d.ts

@@ -0,0 +1,43 @@
+/**
+ * src/state/turn-trace.ts
+ *
+ * Pipeline debug-trace state — the toggle flag + recorded per-turn traces.
+ *
+ * Presentation-agnostic: the headless core (tool-engine, message-processor)
+ * records traces here without importing src/ui. The /debug slash command
+ * (src/ui/slash/debug.ts) owns the human formatting and toggling on top of
+ * this state.
+ */
+export interface PipelineStep {
+    name: string;
+    duration_ms: number;
+    input_summary: string;
+    output_summary: string;
+    tokens_saved?: number;
+}
+export interface TurnTrace {
+    turn_id: number;
+    timestamp: number;
+    raw_prompt: string;
+    steps: PipelineStep[];
+    model_requested: string;
+    model_used: string;
+    routed: boolean;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cost_usd: number;
+    estimated_savings: SavingsEstimate;
+}
+export interface SavingsEstimate {
+    pil_tokens_saved: number;
+    cache_tokens_saved: number;
+    router_cost_saved_usd: number;
+    total_tokens_saved: number;
+    total_cost_saved_usd: number;
+}
+export declare function isDebugEnabled(): boolean;
+export declare function setDebugEnabled(value: boolean): void;
+export declare function recordTurnTrace(trace: TurnTrace): void;
+export declare function getLastTrace(): TurnTrace | null;
+export declare function getAllTraces(): readonly TurnTrace[];

package/dist/src/state/turn-trace.js

@@ -0,0 +1,32 @@
+/**
+ * src/state/turn-trace.ts
+ *
+ * Pipeline debug-trace state — the toggle flag + recorded per-turn traces.
+ *
+ * Presentation-agnostic: the headless core (tool-engine, message-processor)
+ * records traces here without importing src/ui. The /debug slash command
+ * (src/ui/slash/debug.ts) owns the human formatting and toggling on top of
+ * this state.
+ */
+let debugEnabled = false;
+const turnTraces = [];
+export function isDebugEnabled() {
+    return debugEnabled;
+}
+export function setDebugEnabled(value) {
+    debugEnabled = value;
+}
+export function recordTurnTrace(trace) {
+    if (!debugEnabled)
+        return;
+    turnTraces.push(trace);
+    if (turnTraces.length > 50)
+        turnTraces.shift();
+}
+export function getLastTrace() {
+    return turnTraces[turnTraces.length - 1] ?? null;
+}
+export function getAllTraces() {
+    return turnTraces;
+}
+//# sourceMappingURL=turn-trace.js.map

package/dist/src/storage/db.js

@@ -9,7 +9,8 @@ let db = null;
 // async would be a much larger refactor.
 const requireSync = createRequire(import.meta.url);
 export function getDatabasePath() {
-    const dir = path.join(os.homedir(), ".muonroi-cli");
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+    const dir = path.join(home, ".muonroi-cli");
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     return path.join(dir, "muonroi.db");
 }

package/dist/src/storage/index.d.ts

@@ -3,7 +3,7 @@ export { loadConfig, type MuonroiConfig } from "./config.js";
 export { getDatabasePath } from "./db.js";
 export { type InteractionEventType, logInteraction } from "./interaction-log.js";
 export { SessionStore } from "./sessions.js";
-export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
+export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastApprovedPlan, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, getSessionChainInfos, loadLatestCompaction, loadRawTranscript, loadSessionChainTranscriptState, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistApprovedPlan, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, type SessionChainNode, } from "./transcript.js";
 export { buildEffectiveTranscript, type LoadedTranscriptState, type PersistedCompaction } from "./transcript-view.js";
 export { logUIInteraction, type UIInteractionSubtype } from "./ui-interaction-log.js";
 export { getSessionTotalTokens, listSessionUsage, recordUsageEvent, type TokenUsageLike } from "./usage.js";

package/dist/src/storage/index.js

@@ -4,7 +4,7 @@ export { loadConfig } from "./config.js";
 export { getDatabasePath } from "./db.js";
 export { logInteraction } from "./interaction-log.js";
 export { SessionStore } from "./sessions.js";
-export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
+export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastApprovedPlan, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, getSessionChainInfos, loadLatestCompaction, loadRawTranscript, loadSessionChainTranscriptState, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistApprovedPlan, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
 export { buildEffectiveTranscript } from "./transcript-view.js";
 export { logUIInteraction } from "./ui-interaction-log.js";
 export { getSessionTotalTokens, listSessionUsage, recordUsageEvent } from "./usage.js";

package/dist/src/storage/interaction-log.d.ts

@@ -4,7 +4,7 @@
  * Fire-and-forget interaction logging for detailed user-agent event tracking.
  * All calls are fail-open — logging never breaks the main flow.
  */
-export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer" | "session_experience";
+export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer" | "turn_tool_load" | "session_experience";
 export interface EEInjectionRow {
     session_id: string;
     event_subtype: string | null;

package/dist/src/storage/migrations.js

@@ -1,4 +1,4 @@
-const LATEST_DB_VERSION = 8;
+const LATEST_DB_VERSION = 10;
 export function applyMigrations(db) {
     const version = Number(db.pragma("user_version", { simple: true })) || 0;
     if (version >= LATEST_DB_VERSION)
@@ -96,9 +96,79 @@ export function applyMigrations(db) {
             db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_parent_id ON sessions(parent_session_id)");
             db.pragma("user_version = 8");
         }
+        if (version < 9) {
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS session_history_fts USING fts5(
+          session_id UNINDEXED,
+          seq UNINDEXED,
+          role UNINDEXED,
+          tool_name UNINDEXED,
+          content,
+          tool_args,
+          tool_output
+        );
+
+        CREATE TRIGGER IF NOT EXISTS t_sessions_delete_fts
+        AFTER DELETE ON sessions
+        BEGIN
+          DELETE FROM session_history_fts WHERE session_id = old.id;
+        END;
+      `);
+            db.pragma("user_version = 9");
+        }
+        if (version < 10) {
+            // Thread-aware resume. The resume picker groups sessions by conversation
+            // tree; `kind` distinguishes the two kinds of child (both previously only
+            // set parent_session_id, indistinguishable) and `root_session_id`
+            // denormalizes the tree root so the picker groups without a recursive CTE.
+            const cols = db.prepare("PRAGMA table_info(sessions)").all();
+            const colNames = new Set(cols.map((c) => c.name));
+            if (!colNames.has("kind")) {
+                db.exec("ALTER TABLE sessions ADD COLUMN kind TEXT NOT NULL DEFAULT 'conversation'");
+            }
+            if (!colNames.has("root_session_id")) {
+                db.exec("ALTER TABLE sessions ADD COLUMN root_session_id TEXT");
+            }
+            db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_root ON sessions(workspace_id, root_session_id)");
+            backfillSessionTrees(db);
+            db.pragma("user_version = 10");
+        }
     });
     migrate();
 }
+/**
+ * Backfill kind + root_session_id for pre-v10 rows.
+ *
+ * - Rows with no parent become their own root (kind 'conversation').
+ * - Rows WITH a parent are marked 'rotation' — historical data cannot tell
+ *   rotation apart from sub-agent spawns, and marking them 'rotation' collapses
+ *   them under their root rather than risking hiding a real conversation.
+ * - root_session_id propagates down the parent chain via a bounded fixpoint
+ *   loop (chains are shallow; the bound also guards against FK cycles).
+ */
+function backfillSessionTrees(db) {
+    // Roots: own id, keep default kind 'conversation'.
+    db.exec("UPDATE sessions SET root_session_id = id WHERE parent_session_id IS NULL AND root_session_id IS NULL");
+    // Children of a real parent → rotation (default kind was 'conversation').
+    db.exec("UPDATE sessions SET kind = 'rotation' WHERE parent_session_id IS NOT NULL");
+    // Propagate root down the chain until no row changes (bounded to 100 passes).
+    for (let i = 0; i < 100; i++) {
+        db.exec(`
+      UPDATE sessions
+      SET root_session_id = (SELECT p.root_session_id FROM sessions p WHERE p.id = sessions.parent_session_id)
+      WHERE root_session_id IS NULL
+        AND parent_session_id IS NOT NULL
+        AND (SELECT p.root_session_id FROM sessions p WHERE p.id = sessions.parent_session_id) IS NOT NULL
+    `);
+        const remaining = db
+            .prepare("SELECT COUNT(*) AS c FROM sessions WHERE root_session_id IS NULL AND parent_session_id IS NOT NULL")
+            .get();
+        if (!remaining || remaining.c === 0)
+            break;
+    }
+    // Any leftover (orphaned/cyclic parent chains) → treat as its own root.
+    db.exec("UPDATE sessions SET root_session_id = id WHERE root_session_id IS NULL");
+}
 function createInitialSchema(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS workspaces (