muonroi-cli 1.8.4 → 1.9.0

package/dist/src/ui/modals/session-picker-modal.js

@@ -21,11 +21,9 @@ export function SessionPickerModal({ t, sessions, focusIndex, width, height, })
                             const titleRaw = s.title?.trim() || "(untitled)";
                             const titleMax = Math.max(8, panelWidth - 38);
                             const title = titleRaw.length > titleMax ? `${titleRaw.slice(0, titleMax - 1)}…` : titleRaw;
-                            // Show the FULL session id (not slice(-8)). The resumed-session
-                            // header displays the full id, so a truncated id here made users
-                            // think they had resumed a "different" session when it was the
-                            // same one shown in two formats.
-                            const idLabel = s.id;
+                            // Short 8-char id — the tree's root id, enough to disambiguate
+                            // rows without crowding the model column.
+                            const idLabel = s.id.slice(0, 8);
                             return (_jsx(Semantic, { id: `session-item-${idx}`, role: "listitem", name: `${title} ${idLabel}`, value: s.id, selected: focused || undefined, children: _jsxs("box", { backgroundColor: focused ? t.selectedBg : undefined, paddingLeft: 2, paddingRight: 2, width: "100%", flexDirection: "row", justifyContent: "space-between", children: [_jsx("text", { fg: focused ? t.selected : t.text, children: `${ts}  ${title}` }), _jsx("text", { fg: focused ? t.primary : t.textMuted, children: `${s.model}  ${idLabel}` })] }) }, s.id));
                         })) }), _jsx("box", { flexShrink: 0, paddingLeft: 2, paddingRight: 2, paddingTop: 1, children: _jsx("text", { fg: t.textMuted, children: "↑↓ navigate · enter resume (restarts CLI) · esc cancel" }) })] }) }) }));
 }

package/dist/src/ui/picker-providers.d.ts

@@ -9,7 +9,7 @@ import type { ProviderId } from "../providers/types.js";
  * previously hidden because `configuredProviders` stayed pinned to the splash
  * list (app.tsx never re-applied the async `getConfiguredProviders()` result).
  *
- * Providers with no catalog models (anthropic/ollama/google in the default
+ * Providers with no catalog models (anthropic/ollama in the default
  * catalog) are excluded — they cannot be routed to and would render as dead
  * chips with an empty model list. (xai now ships catalog models, so a
  * configured/OAuth-logged-in xai surfaces here.)

package/dist/src/ui/picker-providers.js

@@ -8,7 +8,7 @@
  * previously hidden because `configuredProviders` stayed pinned to the splash
  * list (app.tsx never re-applied the async `getConfiguredProviders()` result).
  *
- * Providers with no catalog models (anthropic/ollama/google in the default
+ * Providers with no catalog models (anthropic/ollama in the default
  * catalog) are excluded — they cannot be routed to and would render as dead
  * chips with an empty model list. (xai now ships catalog models, so a
  * configured/OAuth-logged-in xai surfaces here.)

package/dist/src/ui/primitives/index.d.ts

@@ -0,0 +1 @@
+export * from "./semantic-primitives.js";

package/dist/src/ui/primitives/index.js

@@ -0,0 +1,2 @@
+export * from "./semantic-primitives.js";
+//# sourceMappingURL=index.js.map

package/dist/src/ui/primitives/semantic-primitives.d.ts

@@ -0,0 +1,76 @@
+/**
+ * src/ui/primitives/semantic-primitives.tsx
+ *
+ * Role-fixed semantic primitives. Compose these instead of hand-writing
+ * `<Semantic role="...">` in feature code. Two things they buy you:
+ *
+ *   1. The `role` is fixed per component, so it can't be typo'd or drift, and
+ *      TypeScript enforces the right props per role.
+ *   2. Interactive state is passed as plain booleans (`focused`, `selected`,
+ *      `disabled`, `hidden`) and mirrored to the Semantic node's `true|undefined`
+ *      flags automatically — no more `focus={cond ? true : undefined}` written
+ *      by hand at every call site (the #1 source of harness/state drift).
+ *
+ * Feature authors should reach for these first; a raw `<Semantic>` is only for
+ * genuinely bespoke roles not covered here (or a namespaced `x-*` role).
+ *
+ * These are invisible wrappers (like `<Semantic>` itself): zero OpenTUI element,
+ * zero runtime cost when the agent runtime is unset.
+ */
+import type * as React from "react";
+/**
+ * Common props shared by every primitive. `focused`/`selected`/`disabled`/
+ * `hidden` are plain booleans here (not `true`-literal) and are mirrored to the
+ * underlying Semantic flags.
+ */
+export interface BlockProps {
+    id: string;
+    name?: string;
+    value?: string;
+    state?: string;
+    focused?: boolean;
+    selected?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    props?: Record<string, unknown>;
+    children?: React.ReactNode;
+}
+/** A modal dialog. `isModal` defaults to true (pass `isModal={false}` to opt out). */
+export declare function Dialog({ isModal, ...rest }: BlockProps & {
+    isModal?: boolean;
+}): React.ReactNode;
+/** A generic grouping region / panel. */
+export declare function Region(props: BlockProps): React.ReactNode;
+/** A titled content panel (IDE-style). */
+export declare function Panel(props: BlockProps): React.ReactNode;
+/** A single-line or multi-line text input. Pass `value` + `focused`. */
+export declare function TextBox(props: BlockProps): React.ReactNode;
+/** A pressable button. Pass `disabled`/`focused` as booleans. */
+export declare function Button(props: BlockProps): React.ReactNode;
+/** A toggle. Reflect checked state via `selected`. */
+export declare function Checkbox(props: BlockProps): React.ReactNode;
+/** A scrollable list container. */
+export declare function ListBox(props: BlockProps): React.ReactNode;
+/** A single list row. Reflect highlight via `selected`. */
+export declare function ListItem(props: BlockProps): React.ReactNode;
+/** A command / context menu. `isModal` defaults to true. */
+export declare function Menu({ isModal, ...rest }: BlockProps & {
+    isModal?: boolean;
+}): React.ReactNode;
+/** A single menu entry. */
+export declare function MenuItem(props: BlockProps): React.ReactNode;
+/** A transient notification. */
+export declare function Toast(props: BlockProps): React.ReactNode;
+/** The persistent status bar. */
+export declare function StatusBar(props: BlockProps): React.ReactNode;
+/** A determinate/indeterminate progress indicator. Put `0..1` in `value`. */
+export declare function ProgressBar(props: BlockProps): React.ReactNode;
+/** A scrollback / message log. */
+export declare function Log(props: BlockProps): React.ReactNode;
+/**
+ * Escape hatch for a namespaced custom role not covered above. `role` MUST start
+ * with `x-` (enforced by the `Role` type). Prefer a named primitive when one fits.
+ */
+export declare function CustomBlock({ role, ...rest }: BlockProps & {
+    role: `x-${string}`;
+}): React.ReactNode;

package/dist/src/ui/primitives/semantic-primitives.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "@opentui/react/jsx-runtime";
+import { Semantic } from "@muonroi/agent-harness-opentui";
+/** Coerce a boolean into the Semantic flag shape (`true` present, else absent). */
+function flag(value) {
+    return value ? true : undefined;
+}
+/**
+ * Internal base. Renders a `<Semantic>` with a fixed `role`, mapping the plain
+ * boolean props to the flag shape. `isModal` is passed through for the roles
+ * that support it (dialog/menu).
+ */
+function Block({ role, isModal, id, name, value, state, focused, selected, disabled, hidden, props, children, }) {
+    return (_jsx(Semantic, { id: id, role: role, name: name, value: value, state: state, focus: flag(focused), selected: flag(selected), disabled: flag(disabled), hidden: flag(hidden), isModal: flag(isModal), props: props, children: children }));
+}
+// ---------------------------------------------------------------------------
+// Role-fixed primitives
+// ---------------------------------------------------------------------------
+/** A modal dialog. `isModal` defaults to true (pass `isModal={false}` to opt out). */
+export function Dialog({ isModal = true, ...rest }) {
+    return _jsx(Block, { role: "dialog", isModal: isModal, ...rest });
+}
+/** A generic grouping region / panel. */
+export function Region(props) {
+    return _jsx(Block, { role: "region", ...props });
+}
+/** A titled content panel (IDE-style). */
+export function Panel(props) {
+    return _jsx(Block, { role: "panel", ...props });
+}
+/** A single-line or multi-line text input. Pass `value` + `focused`. */
+export function TextBox(props) {
+    return _jsx(Block, { role: "textbox", ...props });
+}
+/** A pressable button. Pass `disabled`/`focused` as booleans. */
+export function Button(props) {
+    return _jsx(Block, { role: "button", ...props });
+}
+/** A toggle. Reflect checked state via `selected`. */
+export function Checkbox(props) {
+    return _jsx(Block, { role: "checkbox", ...props });
+}
+/** A scrollable list container. */
+export function ListBox(props) {
+    return _jsx(Block, { role: "listbox", ...props });
+}
+/** A single list row. Reflect highlight via `selected`. */
+export function ListItem(props) {
+    return _jsx(Block, { role: "listitem", ...props });
+}
+/** A command / context menu. `isModal` defaults to true. */
+export function Menu({ isModal = true, ...rest }) {
+    return _jsx(Block, { role: "menu", isModal: isModal, ...rest });
+}
+/** A single menu entry. */
+export function MenuItem(props) {
+    return _jsx(Block, { role: "menuitem", ...props });
+}
+/** A transient notification. */
+export function Toast(props) {
+    return _jsx(Block, { role: "toast", ...props });
+}
+/** The persistent status bar. */
+export function StatusBar(props) {
+    return _jsx(Block, { role: "statusbar", ...props });
+}
+/** A determinate/indeterminate progress indicator. Put `0..1` in `value`. */
+export function ProgressBar(props) {
+    return _jsx(Block, { role: "progressbar", ...props });
+}
+/** A scrollback / message log. */
+export function Log(props) {
+    return _jsx(Block, { role: "log", ...props });
+}
+/**
+ * Escape hatch for a namespaced custom role not covered above. `role` MUST start
+ * with `x-` (enforced by the `Role` type). Prefer a named primitive when one fits.
+ */
+export function CustomBlock({ role, ...rest }) {
+    return _jsx(Block, { role: role, ...rest });
+}
+//# sourceMappingURL=semantic-primitives.js.map

package/dist/src/ui/slash/compact.js

@@ -15,11 +15,9 @@ import { FLOW_DIR_NAME } from "../../flow/scaffold.js";
 import { registerSlash } from "./registry.js";
 export const handleCompactSlash = async (_args, ctx) => {
     const flowDir = path.join(ctx.cwd, FLOW_DIR_NAME);
-    // Check for active run
+    // Check for active run (informational only). /compact should work on any
+    // session, not only inside a product-loop run, so we no longer block here.
     const runId = await getActiveRunId(flowDir);
-    if (!runId) {
-        return "No active run. Nothing to compact. Start with /discuss to create a run.";
-    }
     // Fire-and-forget: notify EE that surfaced suggestions are going stale due to compact
     const { surfacedIds, timestamp } = getLastSurfacedState();
     if (surfacedIds.length > 0) {
@@ -31,9 +29,9 @@ export const handleCompactSlash = async (_args, ctx) => {
             .catch(() => { });
     }
     // Return signal for orchestrator to perform compaction
-    // The orchestrator intercepts __COMPACT__ and calls deliberateCompact()
-    // with its own this.messages and this.systemPrompt
-    return `__COMPACT__\nRun: ${runId}\nReady for two-pass compaction.`;
+    const instructions = _args.length > 0 ? `\nInstructions: ${_args.join(" ")}` : "";
+    const runLine = runId ? `Run: ${runId}` : "No active run — compacting chat history only.";
+    return `__COMPACT__\n${runLine}${instructions}\nReady for two-pass compaction.`;
 };
 // Self-register on module import
 registerSlash("compact", handleCompactSlash);

package/dist/src/ui/slash/cost.js

@@ -9,7 +9,7 @@
  */
 import { healthDetailed } from "../../ee/health.js";
 import { getDefaultEEClient } from "../../ee/intercept.js";
-import { statusBarStore } from "../status-bar/store.js";
+import { statusBarStore } from "../../state/status-bar-store.js";
 import { registerSlash } from "./registry.js";
 export const handleCostSlash = async (_args, _ctx) => {
     const s = statusBarStore.getState();

package/dist/src/ui/slash/council.js

@@ -1,3 +1,4 @@
+import { getCouncilLanguage, normalizeCouncilLanguage, saveUserSettings } from "../../utils/settings.js";
 import { handleCouncilInspectSlash } from "./council-inspect.js";
 import { registerSlash } from "./registry.js";
 export const handleCouncilSlash = async (args, ctx) => {
@@ -5,6 +6,22 @@ export const handleCouncilSlash = async (args, ctx) => {
     if (args[0] === "inspect") {
         return handleCouncilInspectSlash(args.slice(1), ctx);
     }
+    // Feature B — /council lang [value] : read or set the debate language.
+    // The chosen language IS the debate language (no translate pass).
+    if (args[0] === "lang" || args[0] === "language") {
+        const value = args.slice(1).join(" ").trim();
+        if (!value) {
+            const current = getCouncilLanguage();
+            return (`Council debate language: ${current}\n` +
+                `- "auto" (default): debate + conclusion follow the language of your prompt.\n` +
+                `- "english": force the historical English-only debate.\n` +
+                `- <locale> (e.g. "vietnamese", "日本語"): pin the debate to that language.\n` +
+                `Set with: /council lang <value>`);
+        }
+        const normalized = normalizeCouncilLanguage(value);
+        saveUserSettings({ councilLanguage: normalized });
+        return `Council debate language set to: ${normalized}`;
+    }
     let rounds;
     const firstArg = args[0];
     if (firstArg && /^\d+$/.test(firstArg)) {
@@ -14,7 +31,8 @@ export const handleCouncilSlash = async (args, ctx) => {
     const topic = args.join(" ") || ctx.lastPrompt || "";
     if (!topic) {
         return ("/council [rounds] <topic> — multi-model discussion\n" +
-            "Default: uses models from the same provider. Set councilPreferMultiProvider + roleModels for cross-provider.\n" +
+            "Default: multi-provider lineup from catalog (implement/verify/research across providers).\n" +
+            "Override via roleModels in settings, or councilPreferMultiProvider: false for same-provider.\n" +
             "Example: /council 3 REST vs gRPC for our microservices");
     }
     return `__COUNCIL__\n${rounds ?? ""}\n${topic}`;

package/dist/src/ui/slash/debug.d.ts

@@ -10,36 +10,8 @@
  *   /debug off    — disable
  *   /debug status — show current pipeline state without toggling
  */
+import { isDebugEnabled, recordTurnTrace } from "../../state/turn-trace.js";
 import type { SlashHandler } from "./registry.js";
-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 recordTurnTrace(trace: TurnTrace): void;
-export declare function getLastTrace(): TurnTrace | null;
+export type { PipelineStep, SavingsEstimate, TurnTrace } from "../../state/turn-trace.js";
+export { isDebugEnabled, recordTurnTrace };
 export declare const handleDebugSlash: SlashHandler;

package/dist/src/ui/slash/debug.js

@@ -10,23 +10,10 @@
  *   /debug off    — disable
  *   /debug status — show current pipeline state without toggling
  */
-import { statusBarStore } from "../status-bar/store.js";
+import { statusBarStore } from "../../state/status-bar-store.js";
+import { getAllTraces, getLastTrace, isDebugEnabled, recordTurnTrace, setDebugEnabled, } from "../../state/turn-trace.js";
 import { registerSlash } from "./registry.js";
-let debugEnabled = false;
-const turnTraces = [];
-export function isDebugEnabled() {
-    return debugEnabled;
-}
-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 { isDebugEnabled, recordTurnTrace };
 function formatTrace(trace) {
     const lines = [];
     lines.push(`┌─ Turn #${trace.turn_id} ─────────────────────────────────`);
@@ -62,6 +49,7 @@ function formatTrace(trace) {
 }
 function formatSessionSummary() {
     const s = statusBarStore.getState();
+    const turnTraces = getAllTraces();
     const totalSavings = turnTraces.reduce((acc, t) => ({
         tokens: acc.tokens + t.estimated_savings.total_tokens_saved,
         cost: acc.cost + t.estimated_savings.total_cost_saved_usd,
@@ -82,11 +70,11 @@ function formatSessionSummary() {
 export const handleDebugSlash = async (args, _ctx) => {
     const cmd = args[0]?.toLowerCase();
     if (cmd === "on") {
-        debugEnabled = true;
+        setDebugEnabled(true);
         return "Pipeline debug tracing: ON\nEach turn will show: PIL → Router → EE hooks → Model → Savings";
     }
     if (cmd === "off") {
-        debugEnabled = false;
+        setDebugEnabled(false);
         return "Pipeline debug tracing: OFF";
     }
     if (cmd === "status") {
@@ -99,8 +87,9 @@ export const handleDebugSlash = async (args, _ctx) => {
         return formatTrace(last);
     }
     // Toggle
-    debugEnabled = !debugEnabled;
-    if (debugEnabled) {
+    const next = !isDebugEnabled();
+    setDebugEnabled(next);
+    if (next) {
         return "Pipeline debug tracing: ON\nEach turn will show: PIL → Router → EE hooks → Model → Savings\n\nCommands: /debug off | /debug status | /debug last";
     }
     return "Pipeline debug tracing: OFF";

package/dist/src/ui/slash/ee.js

@@ -154,6 +154,8 @@ const HELP = [
     "**Experience Engine (/ee)**",
     "",
     "Usage:",
+    "  /ee config               — Show EE connection settings",
+    "  /ee config <url> [token] — Connect to an EE server (writes ~/.experience/config.json)",
     "  /ee stats [7d|30d|all]   — Knowledge base statistics",
     "  /ee timeline <topic>     — Chronological principle evolution",
     "  /ee graph <id>           — Principle relationship graph",
@@ -167,10 +169,89 @@ const HELP = [
     "  /ee mode                 — Show detected client mode (thin/fat/disabled)",
 ].join("\n");
 // ─── Handler ─────────────────────────────────────────────────────────────────
+/** Never echo a token back in full — the transcript is persisted to SQLite. */
+function maskToken(token) {
+    if (!token)
+        return "(none)";
+    return token.length <= 4 ? "set (…)" : `set (…${token.slice(-4)})`;
+}
+/**
+ * Show or set the EE connection. Until this existed, EE was configurable only
+ * by the one-shot first-run wizard — and index.ts marks eeSetupPrompted even
+ * when the user SKIPS it, so skipping once left hand-editing
+ * ~/.experience/config.json as the only way back in.
+ */
+async function handleConfig(args) {
+    const { getCachedServerBaseUrl, getCachedAuthToken, getExperienceConfigPath, probeEEHealth, refreshAuthToken } = await import("../../ee/auth.js");
+    const url = args[0];
+    if (!url) {
+        const baseUrl = getCachedServerBaseUrl();
+        const lines = [
+            "**EE Config**",
+            "",
+            `  serverBaseUrl: ${baseUrl ?? "(not configured)"}`,
+            `  serverAuthToken: ${maskToken(getCachedAuthToken())}`,
+            `  config file: ${getExperienceConfigPath()}`,
+        ];
+        if (process.env.MUONROI_EE_BASE_URL) {
+            lines.push("", `  ⚠ MUONROI_EE_BASE_URL=${process.env.MUONROI_EE_BASE_URL} overrides the config file.`);
+        }
+        if (baseUrl) {
+            const health = await probeEEHealth(baseUrl, getCachedAuthToken() ?? undefined);
+            lines.push("", health.ok ? `  ✓ reachable (${health.detail})` : `  ⚠ not reachable — ${health.detail}`);
+        }
+        else {
+            lines.push("", "Connect one with: `/ee config <url> [token]`");
+        }
+        return lines.join("\n");
+    }
+    let normalized;
+    try {
+        normalized = new URL(url).toString().replace(/\/$/, "");
+    }
+    catch {
+        return `"${url}" is not a valid URL. Example: \`/ee config https://experience.example.com <token>\``;
+    }
+    const token = args[1];
+    try {
+        const { writeExperienceConfig } = await import("../../ee/auth.js");
+        await writeExperienceConfig({
+            serverBaseUrl: normalized,
+            ...(token ? { serverAuthToken: token } : {}),
+        });
+    }
+    catch (err) {
+        const message = err?.message ?? String(err);
+        console.error(`[slash/ee] writing ${getExperienceConfigPath()} failed: ${message}`);
+        return `Could not write ${getExperienceConfigPath()}: ${message}`;
+    }
+    // Re-read so THIS session picks the change up; without it the new server is
+    // only live after a restart.
+    await refreshAuthToken();
+    const { detectEEClientMode, describeMode } = await import("../../ee/client-mode.js");
+    const info = await detectEEClientMode({ force: true });
+    const health = await probeEEHealth(normalized, token || (getCachedAuthToken() ?? undefined));
+    return [
+        "**EE Config saved**",
+        "",
+        `  serverBaseUrl: ${normalized}`,
+        `  serverAuthToken: ${maskToken(token ?? getCachedAuthToken())}`,
+        `  config file: ${getExperienceConfigPath()}`,
+        `  client mode: ${info.mode} — ${describeMode(info)}`,
+        "",
+        health.ok
+            ? `  ✓ reachable (${health.detail}) — recall is live for this session.`
+            : `  ⚠ saved, but not reachable — ${health.detail}. EE calls degrade gracefully until it responds.`,
+    ].join("\n");
+}
 export const handleEESlash = async (args, _ctx) => {
     const sub = args[0]?.toLowerCase();
     if (!sub)
         return HELP;
+    // `config` must not construct the EE client: it is the command you reach for
+    // precisely when there is no server configured yet.
+    if (sub === "config" || sub === "setup")
+        return await handleConfig(args.slice(1));
     const client = getDefaultEEClient();
     switch (sub) {
         case "stats": {

package/dist/src/ui/slash/ideal.d.ts

@@ -7,7 +7,7 @@
  *   /ideal "<idea>"          start a new product run (default)
  *   /ideal status            list active runs
  *   /ideal status <runId>    detail of one run
- *   /ideal resume <runId>    resume halted/crashed run
+ *   /ideal resume [runId]    resume halted/crashed run (no id = newest incomplete)
  *   /ideal abort  <runId>    hard kill
  *   /ideal ship   <runId>    force user-approval gate (skip if Cond #1-#4 pass)
  *
@@ -47,7 +47,7 @@ export interface IdealFlags {
     /** Mode C only — opt-in: run `gh pr create` after PR is built. Default false. */
     ghPr?: boolean;
 }
-export type IdealSubcommand = "start" | "status" | "resume" | "abort" | "ship" | "help";
+export type IdealSubcommand = "start" | "status" | "resume" | "abort" | "ship" | "review" | "milestones" | "phases" | "help";
 export interface IdealParseResult {
     subcommand: IdealSubcommand;
     idea?: string;
@@ -60,6 +60,10 @@ export interface IdealParseResult {
  * SlashHandler signature (which depends on a SlashContext).
  */
 export declare function parseIdealArgs(args: string[]): IdealParseResult;
+/** Render `/ideal milestones` — every milestone with its phases + linked runs. */
+export declare function renderMilestones(cwd: string): Promise<string>;
+/** Render `/ideal phases [milestoneId]` — phases under one milestone. */
+export declare function renderPhases(cwd: string, milestoneId?: string): Promise<string>;
 /**
  * Slash handler. Returns a sentinel string parseable by app.tsx, OR a help/error
  * string when no orchestrator dispatch is appropriate.

package/dist/src/ui/slash/ideal.js

@@ -7,7 +7,7 @@
  *   /ideal "<idea>"          start a new product run (default)
  *   /ideal status            list active runs
  *   /ideal status <runId>    detail of one run
- *   /ideal resume <runId>    resume halted/crashed run
+ *   /ideal resume [runId]    resume halted/crashed run (no id = newest incomplete)
  *   /ideal abort  <runId>    hard kill
  *   /ideal ship   <runId>    force user-approval gate (skip if Cond #1-#4 pass)
  *
@@ -25,7 +25,9 @@
  * app.tsx parses and dispatches to orchestrator.runProductLoopV1, mirroring
  * the existing __COUNCIL__ pattern in src/ui/slash/council.ts.
  */
+import * as path from "node:path";
 import { Command, InvalidArgumentError } from "commander";
+import { getActivePointer, listMilestones, listPhases, migrateLegacyRuns } from "../../flow/hierarchy.js";
 import { registerSlash } from "./registry.js";
 const DEFAULTS = {
     maxCost: 50,
@@ -38,8 +40,11 @@ const HELP_TEXT = [
     "Subcommands:",
     '  /ideal "<idea>"           Start a new product run',
     "  /ideal status [runId]    List active runs (or detail one)",
-    "  /ideal resume <runId>    Resume a halted / crashed run",
-    "  /ideal abort  <runId>    Hard-kill a run",
+    "  /ideal resume [runId]    Resume a run (no id = newest incomplete run)",
+    "  /ideal review [runId]    Render a run's transcript + sprint scores (no id = newest run)",
+    "  /ideal milestones        List milestones (idea/product groups) and their phases",
+    "  /ideal phases [mId]      List phases under a milestone (no id = active milestone)",
+    "  /ideal abort  [runId]    Hard-kill a run (no id = newest incomplete run)",
     "  /ideal ship   <runId>    Force user-approval gate (skip Cond #1-#4 if passing)",
     "",
     "Flags (start only):",
@@ -85,7 +90,18 @@ export function parseIdealArgs(args) {
         return { subcommand: "help", flags: { ...DEFAULTS, noCustomerDebate }, warnings };
     }
     // Detect non-start subcommands by first token (subcommand keywords are reserved).
-    const RESERVED = new Set(["status", "resume", "abort", "ship", "help", "--help", "-h"]);
+    const RESERVED = new Set([
+        "status",
+        "resume",
+        "abort",
+        "ship",
+        "review",
+        "milestones",
+        "phases",
+        "help",
+        "--help",
+        "-h",
+    ]);
     const head = args[0];
     if (RESERVED.has(head)) {
         if (head === "help" || head === "--help" || head === "-h") {
@@ -193,18 +209,92 @@ export function parseIdealArgs(args) {
         warnings,
     };
 }
+function flowDirOf(cwd) {
+    return path.join(cwd, ".muonroi-flow");
+}
+/** Render `/ideal milestones` — every milestone with its phases + linked runs. */
+export async function renderMilestones(cwd) {
+    const flowDir = flowDirOf(cwd);
+    // Lazily backfill pre-hierarchy runs so old work is visible. Idempotent.
+    await migrateLegacyRuns(flowDir, new Date().toISOString()).catch(() => 0);
+    const milestones = await listMilestones(flowDir);
+    if (milestones.length === 0) {
+        return 'No milestones yet. Start one with `/ideal "<idea>"`.';
+    }
+    const { milestoneId: activeM, phaseId: activeP } = await getActivePointer(flowDir);
+    const lines = ["# Milestones", ""];
+    for (const m of milestones) {
+        const active = m.id === activeM ? " ← active" : "";
+        lines.push(`## ${m.id}: ${m.title} [${m.status}]${active}`);
+        if (m.goal)
+            lines.push(`  goal: ${m.goal}`);
+        const phases = await listPhases(flowDir, m.id);
+        if (phases.length === 0) {
+            lines.push("  (no phases yet)");
+        }
+        else {
+            for (const p of phases) {
+                const runs = p.runIds.length > 0 ? ` — runs: ${p.runIds.join(", ")}` : "";
+                const pActive = m.id === activeM && p.id === activeP ? " ←" : "";
+                lines.push(`  - [${p.status === "done" ? "x" : " "}] ${p.id}: ${p.title} [${p.status}]${runs}${pActive}`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}
+/** Render `/ideal phases [milestoneId]` — phases under one milestone. */
+export async function renderPhases(cwd, milestoneId) {
+    const flowDir = flowDirOf(cwd);
+    let mId = milestoneId;
+    if (!mId) {
+        mId = (await getActivePointer(flowDir)).milestoneId ?? undefined;
+    }
+    if (!mId) {
+        return "No active milestone. Run `/ideal milestones` to list, or pass a milestone id.";
+    }
+    const phases = await listPhases(flowDir, mId);
+    if (phases.length === 0) {
+        return `No phases under ${mId}.`;
+    }
+    const { phaseId: activeP } = await getActivePointer(flowDir);
+    const lines = [`# Phases of ${mId}`, ""];
+    for (const p of phases) {
+        const runs = p.runIds.length > 0 ? ` — runs: ${p.runIds.join(", ")}` : "";
+        const pActive = p.id === activeP ? " ← active" : "";
+        lines.push(`- [${p.status === "done" ? "x" : " "}] ${p.id}: ${p.title} [${p.status}]${runs}${pActive}`);
+        if (p.goal)
+            lines.push(`  goal: ${p.goal}`);
+    }
+    return lines.join("\n");
+}
 /**
  * Slash handler. Returns a sentinel string parseable by app.tsx, OR a help/error
  * string when no orchestrator dispatch is appropriate.
  */
-export const handleIdealSlash = async (args) => {
+export const handleIdealSlash = async (args, ctx) => {
     const result = parseIdealArgs(args);
     if (result.subcommand === "help") {
         const warnings = result.warnings.length ? `\n\n${result.warnings.join("\n")}` : "";
         return `${HELP_TEXT}${warnings}`;
     }
-    // Status/abort/resume/ship without a runId: status is allowed (lists), the rest are not.
-    if (result.subcommand !== "start" && result.subcommand !== "status" && !result.runId) {
+    // Milestones/phases are read-only index views — render inline (no orchestrator
+    // dispatch). `runId` carries the optional milestone id for `phases`.
+    if (result.subcommand === "milestones") {
+        return renderMilestones(ctx.cwd);
+    }
+    if (result.subcommand === "phases") {
+        return renderPhases(ctx.cwd, result.runId);
+    }
+    // Status/resume/abort without a runId are allowed: status lists all runs,
+    // resume + abort auto-detect the newest incomplete run (A/B). ship still
+    // requires an explicit runId.
+    if (result.subcommand !== "start" &&
+        result.subcommand !== "status" &&
+        result.subcommand !== "resume" &&
+        result.subcommand !== "abort" &&
+        result.subcommand !== "review" &&
+        !result.runId) {
         return `error: /ideal ${result.subcommand} requires a runId\n\n${HELP_TEXT}`;
     }
     const payload = {