@alisio/alisio-code 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/main.js

@@ -200,7 +200,7 @@ async function run(cmd, prompt, sessionId) {
                 process.stderr.write(`[startup] ${JSON.stringify(d)}\n`);
         }
         if (!opts.quiet)
-            console.log("Alisio · /exit /new /skill:name /command plugin.id:name args");
+            console.log("Alisio · /exit /new /btw question /skill:name /command plugin.id:name args");
         process.stdout.write("\nalisio › ");
         try {
             for await (const rawLine of rl) {
@@ -217,6 +217,22 @@ async function run(cmd, prompt, sessionId) {
                     process.stdout.write("\nalisio › ");
                     continue;
                 }
+                if (line === "/btw" || line.startsWith("/btw ")) {
+                    // Side question: printed here only, never added to the conversation.
+                    try {
+                        const { CommandCatalog } = await import("@alisio/core");
+                        const result = await new CommandCatalog(app).execute("btw", line.slice(4), {
+                            sessionId: session,
+                            signal: controller.signal,
+                        });
+                        console.log(result.text ?? "");
+                    }
+                    catch (e) {
+                        console.error(e instanceof Error ? e.message : String(e));
+                    }
+                    process.stdout.write("\nalisio › ");
+                    continue;
+                }
                 if (line.startsWith("/command ")) {
                     const [name, ...args] = line.slice(9).split(" ");
                     const handler = app.plugins.commands.get(name ?? "");
@@ -260,6 +276,19 @@ program
     .argument("[prompt]")
     .action((id, prompt, _opts, cmd) => run(cmd, prompt, id));
 program.action((_opts, cmd) => run(cmd));
+program
+    .command("serve")
+    .description("Start the local web UI server (HTTP + SSE)")
+    .option("--port <port>", "Port to listen on (0 picks a free one)", "4317")
+    .option("--host <address>", "Address to bind; non-loopback requires --allow-remote", "127.0.0.1")
+    .option("--allow-remote", "Allow a non-loopback --host (no TLS; prefer an SSH tunnel)")
+    .option("--no-open", "Do not open the browser")
+    .option("--max-workspaces <n>", "Maximum workspaces open at once", "4")
+    .option("--max-runs <n>", "Maximum concurrent runs across all sessions", "4")
+    .action(async (flags, cmd) => {
+    const { serve } = await import("./serve.js");
+    await serve(flags, { ...(await cliDefaults()), ...options(cmd) }, VERSION);
+});
 program
     .command("setup")
     .description("Write an example configuration without secrets (for AGENTS.md use /init)")

package/dist/serve.d.ts

@@ -0,0 +1,15 @@
+import type { AppOptions } from "@alisio/core";
+export interface ServeFlags {
+    port: string;
+    host: string;
+    allowRemote?: boolean;
+    open: boolean;
+    maxWorkspaces: string;
+    maxRuns: string;
+}
+/** The operating system's URL opener for `platform`, as `[command, ...args]`. */
+export declare function browserCommand(platform: NodeJS.Platform, url: string): string[];
+/** Opens `url` in the default browser; failures are reported, never fatal. */
+export declare function openBrowser(url: string): void;
+/** Starts the server, prints the launch URL and stops cleanly on SIGINT/SIGTERM. */
+export declare function serve(flags: ServeFlags, app: AppOptions & Record<string, unknown>, version: string): Promise<void>;

package/dist/serve.js

@@ -0,0 +1,99 @@
+/**
+ * `alisio serve`: loaded only by the serve action, and it loads `@alisio/server` only then, so
+ * `alisio`, `alisio run` and the TUI never load the HTTP server (spec §3.4, T-12).
+ */
+import { spawn } from "node:child_process";
+/** The operating system's URL opener for `platform`, as `[command, ...args]`. */
+export function browserCommand(platform, url) {
+    if (platform === "darwin")
+        return ["open", url];
+    if (platform === "win32")
+        return ["cmd", "/c", "start", '""', url];
+    return ["xdg-open", url];
+}
+/** Opens `url` in the default browser; failures are reported, never fatal. */
+export function openBrowser(url) {
+    const [command = "", ...args] = browserCommand(process.platform, url);
+    try {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        child.on("error", () => process.stderr.write("Could not open a browser; open the URL above manually.\n"));
+        child.unref();
+    }
+    catch {
+        process.stderr.write("Could not open a browser; open the URL above manually.\n");
+    }
+}
+/** Parsed option keys that are not `AppOptions` (serve flags and UI-only globals). */
+const SERVE_ONLY_KEYS = new Set([
+    "port",
+    "host",
+    "allowRemote",
+    "open",
+    "maxWorkspaces",
+    "maxRuns",
+    "json",
+    "quiet",
+    "banner",
+    "tui",
+    "baseUrl",
+    "herdr",
+    "disablePlugin",
+    "addDir",
+    "agents",
+]);
+function positiveInt(value, flag, min = 1) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < min)
+        throw new Error(`${flag} expects an integer >= ${min}, got "${value}"`);
+    return parsed;
+}
+/** Starts the server, prints the launch URL and stops cleanly on SIGINT/SIGTERM. */
+export async function serve(flags, app, version) {
+    const port = positiveInt(flags.port, "--port", 0);
+    if (port > 65_535)
+        throw new Error(`--port expects a value up to 65535, got "${flags.port}"`);
+    const { startServer, isLoopbackHost } = await import("@alisio/server");
+    if (!isLoopbackHost(flags.host) && !flags.allowRemote)
+        throw new Error(`--host ${flags.host} is not a loopback address: add --allow-remote to expose the server on the network (no TLS; prefer an SSH tunnel).`);
+    // Global CLI options minus the serve flags and the UI-only ones: the rest are app options.
+    const { cwd, onEvent: _onEvent, approve: _approve, approveExternalDirectory: _approveDirectory, ...rest } = app;
+    const base = Object.fromEntries(Object.entries(rest).filter(([key]) => !SERVE_ONLY_KEYS.has(key)));
+    let server;
+    try {
+        server = await startServer({
+            host: flags.host,
+            port,
+            allowRemote: !!flags.allowRemote,
+            version,
+            maxOpenWorkspaces: positiveInt(flags.maxWorkspaces, "--max-workspaces"),
+            maxConcurrentRuns: positiveInt(flags.maxRuns, "--max-runs"),
+            defaultWorkspace: cwd ?? process.cwd(),
+            app: base,
+        });
+    }
+    catch (error) {
+        if (error.code === "EADDRINUSE")
+            throw new Error(`Port ${port} is already in use: choose another with --port <n> (0 picks a free one).`);
+        throw error;
+    }
+    process.stdout.write(`Alisio web UI: ${server.launchUrl}\n`);
+    if (!isLoopbackHost(flags.host))
+        process.stderr.write(`Warning: listening on ${flags.host} (--allow-remote). Anyone who can reach this address and obtains the token can drive the agent; traffic is not encrypted.\n`);
+    if (!server.webInstalled)
+        process.stderr.write("The web UI assets are not installed in this build; only the HTTP API is served.\n");
+    process.stderr.write("Press Ctrl+C to stop.\n");
+    if (flags.open)
+        openBrowser(server.launchUrl);
+    let stopping = false;
+    const stop = () => {
+        if (stopping)
+            process.exit(130);
+        stopping = true;
+        process.stderr.write("Stopping Alisio server…\n");
+        // Safety net: shutdown is bounded internally; never hang the terminal.
+        setTimeout(() => process.exit(1), 8_000).unref();
+        void server.close().finally(() => process.exit(0));
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+}

package/dist/tui/agents.d.ts

@@ -1,66 +1,5 @@
 /**
- * Pure logic for the ACTIVE (main-session) agent: the built-in catalog, user/plugin
- * contributions, resolution and the per-run options an agent implies. No terminal or pi-tui
- * imports here — the Picker and status-line rendering live in the TUI shell.
- *
- * The active agent drives the MAIN session (its `instructions` are appended per run and an
- * agent-specific `model` is offered on selection). This is deliberately separate from the
- * delegated child-session agents of the subagents plugin: a subagent definition becomes a main
- * agent only when it is marked main-capable (`mode: primary|all`), which the subagents plugin
- * publishes for the host to read.
+ * The ACTIVE (main-session) agent logic lives in `@alisio/core` (`agents/active.ts`) so every
+ * surface (TUI, headless, server) resolves agents the same way. Re-exported for compatibility.
  */
-export interface ActiveAgent {
-    /** Stable id, also the persisted `agents.active` value. */
-    id: string;
-    name: string;
-    description: string;
-    /** System prompt appended to the main session's instructions on every run. */
-    instructions?: string;
-    /** Optional default model selector (`provider/model` or an unambiguous model id). */
-    model?: string;
-    /** Read-only agents run with write/process/external tools disabled and approvals off. */
-    readOnly?: boolean;
-    /** Product built-ins are shown as built-in and never shadowed by contributed definitions. */
-    source: "builtin" | "user" | "plugin";
-}
-export declare const DEFAULT_AGENT_ID = "build";
-/** Product built-ins. `build` keeps the CURRENT behavior exactly: no added persona, full power. */
-export declare const BUILTIN_AGENTS: ActiveAgent[];
-export interface MainCapableAgentRecord {
-    name: string;
-    description: string;
-    prompt: string;
-    model?: string;
-    readOnly?: boolean;
-    source: string;
-    path?: string;
-}
-/** Maps a main-capable definition published by the subagents plugin to an active agent. */
-export declare function mainAgentFromRecord(record: MainCapableAgentRecord): ActiveAgent;
-/** Builds the selectable catalog from the subagents plugin's published state (best-effort). */
-export declare function agentCatalogFromState(untrusted: unknown): ActiveAgent[];
-/**
- * The full selectable catalog: built-ins first, then contributed main-capable definitions.
- * A contributed definition may never shadow a built-in id; later duplicates of a contributed id
- * are dropped (the subagents plugin already resolved precedence by its own discovery order).
- */
-export declare function activeAgentCatalog(contributions?: ActiveAgent[]): ActiveAgent[];
-/** Resolves the persisted agent id; unknown ids fall back to the built-in default (`build`). */
-export declare function resolveActiveAgent(agents: ActiveAgent[], id: string | undefined): ActiveAgent;
-/** The run options an active agent implies. An undefined agent yields the current behavior. */
-export declare function agentRunOptions(agent: ActiveAgent | undefined): {
-    instructions?: string;
-    policy?: {
-        write: false;
-        process: false;
-        external: false;
-    };
-    approvals?: false;
-};
-export interface AgentPickerItem {
-    value: string;
-    label: string;
-    description: string;
-}
-/** Picker rows for `/agents`: name with (current), built-in/default and read-only markers. */
-export declare function agentPickerItems(agents: ActiveAgent[], activeId: string): AgentPickerItem[];
+export { type ActiveAgent, type AgentPickerItem, activeAgentCatalog, agentCatalogFromState, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, DEFAULT_AGENT_ID, type MainCapableAgentRecord, mainAgentFromRecord, resolveActiveAgent, } from "@alisio/core";

package/dist/tui/agents.js

@@ -1,113 +1,5 @@
-export const DEFAULT_AGENT_ID = "build";
-const PLAN_INSTRUCTIONS = `You are the "plan" agent: a read-only planning assistant for this main session.
-
-Your job is analysis and planning only. Investigate the repository with read-only tools
-(list_files, search_text, read_file, git_status, git_diff) and return a concrete, ordered plan:
-files to change, functions to touch, risks and verification steps. You may run context and
-inspection tools that do not modify anything.
-
-You never edit, write or delete files, and you never start processes that change the workspace
-or the network. If a task requires changes, hand back a precise plan (and the exact commands)
-instead of making them.`;
-/** Product built-ins. `build` keeps the CURRENT behavior exactly: no added persona, full power. */
-export const BUILTIN_AGENTS = [
-    {
-        id: DEFAULT_AGENT_ID,
-        name: "build",
-        description: "Default full-power agent: edits code and files, runs processes and verifies its work through the normal permission flow.",
-        source: "builtin",
-    },
-    {
-        id: "plan",
-        name: "plan",
-        description: "Read-only planning agent: analyzes the codebase and returns an implementation plan without modifying anything.",
-        instructions: PLAN_INSTRUCTIONS,
-        readOnly: true,
-        source: "builtin",
-    },
-];
-/** Maps a main-capable definition published by the subagents plugin to an active agent. */
-export function mainAgentFromRecord(record) {
-    const source = String(record.source ?? "");
-    return {
-        id: record.name,
-        name: record.name,
-        description: record.description,
-        ...(record.prompt ? { instructions: record.prompt } : {}),
-        ...(record.model ? { model: record.model } : {}),
-        ...(record.readOnly ? { readOnly: true } : {}),
-        ...(source.startsWith("plugin:")
-            ? { source: "plugin" }
-            : { source: "user" }),
-    };
-}
-/** Builds the selectable catalog from the subagents plugin's published state (best-effort). */
-export function agentCatalogFromState(untrusted) {
-    if (!Array.isArray(untrusted))
-        return activeAgentCatalog([]);
-    const records = untrusted.filter((entry) => !!entry &&
-        typeof entry === "object" &&
-        typeof entry.name === "string" &&
-        typeof entry.description === "string" &&
-        entry.description.length > 0 &&
-        typeof entry.prompt === "string");
-    return activeAgentCatalog(records.map(mainAgentFromRecord));
-}
 /**
- * The full selectable catalog: built-ins first, then contributed main-capable definitions.
- * A contributed definition may never shadow a built-in id; later duplicates of a contributed id
- * are dropped (the subagents plugin already resolved precedence by its own discovery order).
+ * The ACTIVE (main-session) agent logic lives in `@alisio/core` (`agents/active.ts`) so every
+ * surface (TUI, headless, server) resolves agents the same way. Re-exported for compatibility.
  */
-export function activeAgentCatalog(contributions = []) {
-    const seen = new Set();
-    const out = [];
-    for (const agent of [...BUILTIN_AGENTS, ...contributions]) {
-        if (seen.has(agent.id))
-            continue;
-        seen.add(agent.id);
-        out.push(agent);
-    }
-    return out;
-}
-/** Resolves the persisted agent id; unknown ids fall back to the built-in default (`build`). */
-export function resolveActiveAgent(agents, id) {
-    const found = id ? agents.find((a) => a.id === id) : undefined;
-    if (found)
-        return found;
-    return agents.find((a) => a.id === DEFAULT_AGENT_ID) ?? agents[0] ?? BUILTIN_AGENTS[0];
-}
-/** The run options an active agent implies. An undefined agent yields the current behavior. */
-export function agentRunOptions(agent) {
-    if (!agent)
-        return {};
-    return {
-        ...(agent.instructions ? { instructions: agent.instructions } : {}),
-        ...(agent.readOnly
-            ? {
-                policy: { write: false, process: false, external: false },
-                approvals: false,
-            }
-            : {}),
-    };
-}
-/** Picker rows for `/agents`: name with (current), built-in/default and read-only markers. */
-export function agentPickerItems(agents, activeId) {
-    return agents.map((agent) => ({
-        value: agent.id,
-        label: [
-            agent.name,
-            agent.id === activeId ? "(current)" : undefined,
-            agent.id === DEFAULT_AGENT_ID ? "(default)" : undefined,
-            agent.readOnly ? "read-only" : undefined,
-        ]
-            .filter(Boolean)
-            .join(" · "),
-        description: [
-            agent.description,
-            agent.model ? `default model: ${agent.model}` : undefined,
-            agent.instructions ? "injects its system prompt from the next prompt" : undefined,
-        ]
-            .filter(Boolean)
-            .join(" · "),
-    }));
-}
+export { activeAgentCatalog, agentCatalogFromState, agentPickerItems, agentRunOptions, BUILTIN_AGENTS, DEFAULT_AGENT_ID, mainAgentFromRecord, resolveActiveAgent, } from "@alisio/core";

package/dist/tui/app.js

@@ -3,8 +3,9 @@ import { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, ge
 import { loadVersion } from "../version.js";
 import { activeAgentCatalog, agentPickerItems, agentRunOptions, mainAgentFromRecord, resolveActiveAgent, } from "./agents.js";
 import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_IMAGE_BYTES, pasteImageFromClipboard, removeLastAttachment, toApiAttachment, } from "./attachments.js";
+import { BTW_DESCRIPTION, BTW_USAGE, btwBrowser, btwPending } from "./btw.js";
 import { copyText, nodeSpawn } from "./clipboard.js";
-import { AttachmentsBar, BannerBlock, ContentInset, clock, contentInnerWidth, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
+import { AttachmentsBar, BannerBlock, BtwPanel, ContentInset, clock, contentInnerWidth, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
 import { ConnectInputPrompt } from "./connect-input.js";
 import { bounded, EXIT_PENDING_CAP_MS, EXIT_SESSION_END_CAP_MS } from "./exit.js";
 import { BRANCH_REFRESH_MS, createBranchCache } from "./git-branch.js";
@@ -136,7 +137,7 @@ export class Picker {
     }
 }
 export async function runTui(options) {
-    const { createApplication } = await import("@alisio/core");
+    const { createApplication, CommandCatalog } = await import("@alisio/core");
     const { BUILTIN_PLUGINS } = await import("../builtin.js");
     const { BUILTIN_PROMPTS } = await import("../prompts/index.js");
     let dispatch = () => { };
@@ -473,7 +474,7 @@ export async function runTui(options) {
         // pulls the persisted rich parts (ui/image) itself so native rendering survives resume.
         if (event.type === "tool_completed") {
             const data = (event.data ?? {});
-            const rich = richPartsOf(app.store.callResult(event.sessionId, String(data.id ?? "")));
+            const rich = richPartsOf(app.store.callResult(event.sessionId, String(data.id ?? "")), String(data.name ?? ""));
             if (rich.ui !== undefined || rich.image !== undefined)
                 event = { ...event, data: { ...data, ...rich } };
         }
@@ -1381,22 +1382,6 @@ export async function runTui(options) {
         notice(`Resumed session ${found.id}`);
         refreshEstimate();
     };
-    const toolsReport = () => {
-        const policy = app.runner.policy;
-        const rows = app.registry
-            .list()
-            .map((t) => {
-            const effect = t.effect ?? "external";
-            const state = effect === "read" || effect === "internal" || policy[effect]
-                ? "enabled"
-                : app.runner.approvals && (effect === "write" || effect === "process")
-                    ? "ask"
-                    : "disabled";
-            return `| \`${t.name}\` | ${effect} | ${state} |`;
-        })
-            .join("\n");
-        return `**Tools**\n\n| Tool | Effect | State |\n| --- | --- | --- |\n${rows}\n\n\`ask\` prompts before running (allow once / session / deny). Use --allow-write / --allow-process to pre-allow; --read-only disables them. Paths outside the workspace ask per directory; pre-allow with --add-dir or the \`additionalDirectories\` config key. \`internal\` tools (built-in plugins) only write Alisio's own state.`;
-    };
     const statsReport = () => {
         const s = view.stats;
         const budget = app.contextBudget(view.model);
@@ -1456,6 +1441,58 @@ export async function runTui(options) {
         "**Keys**: Enter send · Shift+Enter / Alt+Enter / Ctrl+J newline · Tab complete · ↑↓ history · Esc interrupt · Ctrl+C clear input (twice to exit) · Ctrl+D exit on empty input · c / y copy last response (empty input) · x expand/collapse latest thought/tool batch/output (empty input) · click a collapsible header row to toggle it · PgUp/PgDn or mouse wheel scroll · Ctrl+X agent panel · Ctrl+B background running agents",
         `**Paste**: multi-line text pastes as one block automatically · Ctrl+V attach a clipboard image (PNG/JPEG/GIF/WebP, up to ${(MAX_IMAGE_BYTES / (1024 * 1024)).toFixed(0)} MB, up to ${MAX_ATTACHMENTS_PER_MESSAGE} per message) · Ctrl+R remove the last attached image`,
     ].join("\n");
+    // `/btw` side questions: answered in the picker slot, never appended to the transcript. One
+    // question is in flight at a time; Esc cancels it (independent of the run's controller, so a
+    // side question also works, and is cancelled on its own, while a turn is running).
+    let btwController;
+    let btwPanel;
+    const btwHeight = () => Math.max(4, Math.floor((process.stdout.rows ?? 30) / 2) - 6);
+    const closeBtw = () => {
+        btwController?.abort(new Error("Cancelled"));
+        btwController = undefined;
+        if (btwPanel && picker === btwPanel)
+            closePicker();
+        btwPanel = undefined;
+    };
+    const sideQuestion = async (question) => {
+        const asked = session;
+        const entries = app.sideQuestions.history(asked);
+        if (!question) {
+            const state = btwBrowser(entries);
+            if (!state)
+                return notice(`${BTW_USAGE}\n${BTW_DESCRIPTION}`);
+            btwPanel = new BtwPanel(state, closeBtw, btwHeight);
+            return showPicker(btwPanel);
+        }
+        btwController?.abort(new Error("Cancelled"));
+        const controller = new AbortController();
+        btwController = controller;
+        const panel = new BtwPanel(btwPending(entries, question), closeBtw, btwHeight);
+        btwPanel = panel;
+        showPicker(panel);
+        try {
+            await app.sideQuestions.ask(asked, question, { signal: controller.signal });
+            if (controller.signal.aborted)
+                return;
+            panel.dispatch({ type: "answered", entries: app.sideQuestions.history(asked) });
+            // An approval may have taken the slot meanwhile: the answer is in the history anyway.
+            if (picker !== panel)
+                flashHint("Side answer ready: /btw to view it", 4000);
+        }
+        catch (e) {
+            if (controller.signal.aborted)
+                return;
+            panel.dispatch({ type: "failed", message: e instanceof Error ? e.message : String(e) });
+            if (picker !== panel)
+                error(e);
+        }
+        finally {
+            if (btwController === controller)
+                btwController = undefined;
+            tui.requestRender();
+        }
+    };
+    const commandCatalog = new CommandCatalog(app);
     const mutating = new Set([
         "connect",
         "model",
@@ -1508,7 +1545,11 @@ export async function runTui(options) {
                 case "stats":
                     return info(statsReport());
                 case "tools":
-                    return info(toolsReport());
+                case "sessions": {
+                    // Text-identical core handlers (parity-tested): output comes from the CommandCatalog.
+                    const result = await commandCatalog.execute(name, parsed.args, { sessionId: session });
+                    return result.tone === "notice" ? notice(result.text ?? "") : info(result.text ?? "");
+                }
                 case "connect":
                     return await connect();
                 case "model":
@@ -1532,6 +1573,8 @@ export async function runTui(options) {
                     tui.flash(message);
                     return result.ok ? undefined : notice(message);
                 }
+                case "btw":
+                    return await sideQuestion(parsed.args);
                 case "ask": {
                     if (!parsed.args)
                         return notice("Usage: /ask <question>");
@@ -1575,16 +1618,6 @@ export async function runTui(options) {
                     void app.herdr.report("idle", session);
                     return refreshEstimate();
                 }
-                case "sessions": {
-                    const list = workspaceSessions().slice(0, 20);
-                    if (!list.length)
-                        return notice("No sessions in this workspace");
-                    return info([
-                        "**Recent sessions** (use `/resume <id-prefix>`)",
-                        "",
-                        ...list.map((s) => `- \`${s.id}\` ${s.id === session ? "**(current)** " : ""}${s.model} · ${app.store.messages(s.id).length} msgs · ${firstPrompt(s.id) || "_empty_"}`),
-                    ].join("\n"));
-                }
                 case "resume":
                     if (parsed.args)
                         return resume(parsed.args);
@@ -1855,6 +1888,7 @@ export async function runTui(options) {
     const ticker = setInterval(() => {
         clock.now = Date.now();
         if (busy ||
+            btwPanel?.pending ||
             view.items.some((i) => i.kind === "tool" && i.status === "running") ||
             panelNodes().some((n) => n.status === "running")) {
             clock.frame++;

package/dist/tui/btw.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure state of the TUI `/btw` panel: a pending side question, its answer, and browsing earlier
+ * answers of the session. The panel lives in the picker slot and never touches the transcript.
+ *
+ * Keys: ←/→ earlier/later answer, ↑/↓ (and PgUp/PgDn) scroll a long answer, Esc cancels a pending
+ * question or closes the panel.
+ */
+import type { SideQuestionEntry } from "@alisio/sdk";
+export declare const BTW_USAGE = "Usage: /btw <question>";
+export declare const BTW_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+export interface BtwState {
+    entries: SideQuestionEntry[];
+    /** Index of the entry on screen (ignored while `pending`). */
+    index: number;
+    /** A question waiting for its answer. */
+    pending?: {
+        question: string;
+        startedAt: number;
+    };
+    /** Why the last question failed (shown until the user navigates). */
+    error?: {
+        question: string;
+        message: string;
+    };
+    /** First answer line on screen. */
+    scroll: number;
+}
+export type BtwAction = {
+    type: "prev";
+} | {
+    type: "next";
+} | {
+    type: "scroll";
+    lines: number;
+} | {
+    type: "answered";
+    entries: SideQuestionEntry[];
+} | {
+    type: "failed";
+    message: string;
+};
+/** The browser for `/btw` without a question: the newest entry, or undefined when none. */
+export declare function btwBrowser(entries: SideQuestionEntry[]): BtwState | undefined;
+/** The panel while `question` is being answered (earlier entries stay browsable afterwards). */
+export declare function btwPending(entries: SideQuestionEntry[], question: string, now?: number): BtwState;
+export declare function reduceBtw(state: BtwState, action: BtwAction): BtwState;
+/** The entry on screen, if the panel is not pending or showing an error. */
+export declare function btwCurrent(state: BtwState): SideQuestionEntry | undefined;
+/** "2/5" for the entry on screen; empty while pending or on an error. */
+export declare function btwPosition(state: BtwState): string;
+/** Footer hints for the current state. */
+export declare function btwHints(state: BtwState, overflow: boolean): string;
+/** "model · 12 in · 3 out tokens" for an entry. */
+export declare function btwUsageLine(entry: SideQuestionEntry): string;
+/** The visible slice of `lines` for `scroll` (clamped) and whether more lines exist. */
+export declare function btwWindow(lines: string[], scroll: number, height: number): {
+    lines: string[];
+    scroll: number;
+    above: boolean;
+    below: boolean;
+};

package/dist/tui/btw.js

@@ -0,0 +1,84 @@
+export const BTW_USAGE = "Usage: /btw <question>";
+export const BTW_DESCRIPTION = "Ask a side question about the current session without adding to the conversation.";
+/** The browser for `/btw` without a question: the newest entry, or undefined when none. */
+export function btwBrowser(entries) {
+    return entries.length ? { entries, index: entries.length - 1, scroll: 0 } : undefined;
+}
+/** The panel while `question` is being answered (earlier entries stay browsable afterwards). */
+export function btwPending(entries, question, now = Date.now()) {
+    return {
+        entries,
+        index: Math.max(0, entries.length - 1),
+        pending: { question, startedAt: now },
+        scroll: 0,
+    };
+}
+export function reduceBtw(state, action) {
+    switch (action.type) {
+        case "prev":
+        case "next": {
+            if (state.pending || !state.entries.length)
+                return state;
+            const step = action.type === "prev" ? -1 : 1;
+            // Leaving an error shows the stored entries again (the newest first).
+            const from = state.error ? state.entries.length : state.index;
+            const index = Math.min(state.entries.length - 1, Math.max(0, from + step));
+            if (index === state.index && !state.error)
+                return state;
+            return { entries: state.entries, index, scroll: 0 };
+        }
+        case "scroll":
+            return { ...state, scroll: Math.max(0, state.scroll + action.lines) };
+        case "answered":
+            return {
+                entries: action.entries,
+                index: Math.max(0, action.entries.length - 1),
+                scroll: 0,
+            };
+        case "failed": {
+            const { pending: _pending, ...rest } = state;
+            return {
+                ...rest,
+                error: { question: state.pending?.question ?? "", message: action.message },
+                scroll: 0,
+            };
+        }
+    }
+}
+/** The entry on screen, if the panel is not pending or showing an error. */
+export function btwCurrent(state) {
+    return state.pending || state.error ? undefined : state.entries[state.index];
+}
+/** "2/5" for the entry on screen; empty while pending or on an error. */
+export function btwPosition(state) {
+    return btwCurrent(state) ? `${state.index + 1}/${state.entries.length}` : "";
+}
+/** Footer hints for the current state. */
+export function btwHints(state, overflow) {
+    if (state.pending)
+        return "Esc cancel";
+    const current = btwCurrent(state);
+    const hints = [
+        ...(state.entries.length > 1 || (state.error && state.entries.length)
+            ? ["←/→ earlier/later"]
+            : []),
+        ...(overflow ? ["↑/↓ scroll"] : []),
+        "Esc close",
+    ];
+    return current || state.error ? hints.join(" · ") : "Esc close";
+}
+/** "model · 12 in · 3 out tokens" for an entry. */
+export function btwUsageLine(entry) {
+    return `${entry.model} · ${entry.usage.input} in · ${entry.usage.output} out tokens${entry.truncated ? " · truncated" : ""}`;
+}
+/** The visible slice of `lines` for `scroll` (clamped) and whether more lines exist. */
+export function btwWindow(lines, scroll, height) {
+    const max = Math.max(0, lines.length - height);
+    const start = Math.min(Math.max(0, scroll), max);
+    return {
+        lines: lines.slice(start, start + height),
+        scroll: start,
+        above: start > 0,
+        below: start + height < lines.length,
+    };
+}

package/dist/tui/components.d.ts

@@ -1,6 +1,7 @@
 import type { PanelNode, TreeNode, UiBlock } from "@alisio/sdk";
 import { type Component, Container } from "@earendil-works/pi-tui";
 import { type PendingAttachment } from "./attachments.ts";
+import { type BtwAction, type BtwState } from "./btw.ts";
 import { type QuestionPanelState, type QuestionSpec } from "./questions.ts";
 import { type ContextBudget, type FoldableKind, type FoldCandidate, type GroupedTool, type IdentityInput, type TranscriptEntry, type TranscriptItem, type ViewState } from "./state.ts";
 export declare const SPINNER: string[];
@@ -21,7 +22,11 @@ export declare const exitCodeLine: (code: number | undefined, indent?: string) =
  * `|-`/`` `- ``/`|` otherwise.
  */
 export declare function renderTreeLines(nodes: TreeNode[], unicode: boolean): string[];
-/** Renders a `{type:"ui"}` block to styled lines for the given inner width. */
+/**
+ * Renders a `{type:"ui"}` block to styled lines for the given inner width. Blocks come from
+ * persisted transcripts too, so anything that does not validate (a kind added by a newer Alisio,
+ * or a malformed plugin block) falls back to labeled JSON instead of throwing.
+ */
 export declare function renderUiBlock(block: UiBlock, width: number, unicode: boolean): string[];
 export type PermissionState = "on" | "ask" | "off";
 export interface HeaderInfo {
@@ -251,3 +256,21 @@ export declare class QuestionPanel implements Component {
     handleInput(data: string): void;
     render(width: number): string[];
 }
+/**
+ * The `/btw` side-question panel (picker slot, never the transcript): a pending question with a
+ * spinner, then the answer rendered as Markdown like assistant text, scrollable, with ←/→ through
+ * the session's earlier side answers. `onClose` runs on Esc (the app cancels a pending question).
+ */
+export declare class BtwPanel implements Component {
+    private state;
+    private readonly onClose;
+    private readonly height;
+    private markdown?;
+    constructor(state: BtwState, onClose: () => void, height: () => number);
+    get pending(): boolean;
+    dispatch(action: BtwAction): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    private answerLines;
+    render(width: number): string[];
+}

package/dist/tui/components.js

@@ -1,10 +1,11 @@
 import { Container, getCapabilities, getImageDimensions, Image, Key, Markdown, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 import { terminalCapabilities } from "../banner.js";
 import { attachmentCaption, MAX_ATTACHMENTS_PER_MESSAGE, } from "./attachments.js";
+import { btwCurrent, btwHints, btwPosition, btwUsageLine, btwWindow, reduceBtw, } from "./btw.js";
 import { branchDisplay } from "./git-branch.js";
 import { initialQuestionState, reduceQuestions, } from "./questions.js";
-import { contextLevel, contextPercent, editSummary, entryKeyOf, fitIdentityParts, fitSegments, foldCandidateOf, formatContext, formatDuration, formatTokens, groupIdentity, groupToolEntries, humanizeToolName, previewLinesFor, previewRows, REASONING_EXPAND_MAX_LINES, reasoningDurationMs, } from "./state.js";
-import { highlightCode, imageTheme, levelColor, markdownDefaultTextStyle, markdownTheme, markdownTransform, style, } from "./theme.js";
+import { contextLevel, contextPercent, editSummary, entryKeyOf, fitIdentityParts, fitSegments, foldCandidateOf, formatContext, formatDuration, formatTokens, groupIdentity, groupToolEntries, humanizeToolName, isUiBlock, previewLinesFor, previewRows, REASONING_EXPAND_MAX_LINES, reasoningDurationMs, } from "./state.js";
+import { highlightCode, imageTheme, levelColor, markdownDefaultTextStyle, markdownTheme, markdownTransform, sanitizeCode, style, } from "./theme.js";
 export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 /** Shared animation clock advanced by the app while work is running. */
 export const clock = { frame: 0, now: Date.now() };
@@ -169,8 +170,133 @@ function renderCodeBlock(block, _width) {
         style.dim("```"),
     ];
 }
-/** Renders a `{type:"ui"}` block to styled lines for the given inner width. */
+/** Longest JSON/unknown-block text shown inline before a `… truncated` marker. */
+const MAX_BLOCK_LINES = 200;
+const MAX_BLOCK_CHARS = 20_000;
+/** Caps free-form text by lines and characters, appending a dim marker when anything is cut. */
+function capText(text) {
+    let out = text.length > MAX_BLOCK_CHARS ? text.slice(0, MAX_BLOCK_CHARS) : text;
+    const lines = out.split("\n");
+    if (lines.length > MAX_BLOCK_LINES)
+        out = lines.slice(0, MAX_BLOCK_LINES).join("\n");
+    return { text: out, truncated: out.length < text.length };
+}
+/** `JSON.stringify` that never throws and never returns `undefined`. */
+function jsonText(value) {
+    try {
+        return JSON.stringify(value, null, 2) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function renderCappedCode(code, lang, caption) {
+    const capped = capText(code);
+    return [
+        ...renderCodeBlock({
+            kind: "code",
+            code: capped.text,
+            ...(lang ? { lang } : {}),
+            ...(caption ? { caption } : {}),
+        }, 0),
+        ...(capped.truncated ? [style.gray("… truncated")] : []),
+    ];
+}
+function renderDiffBlock(block) {
+    const caption = [block.caption, block.path].filter(Boolean).join(" · ") || undefined;
+    if (block.patch !== undefined)
+        return renderCappedCode(block.patch, "diff", caption);
+    if (block.before === undefined && block.after === undefined)
+        return [...(caption ? [style.dim(caption)] : []), style.gray("(empty diff)")];
+    return [
+        ...(caption ? [style.dim(caption)] : []),
+        ...renderCappedCode(block.before ?? "", block.lang, "before"),
+        ...renderCappedCode(block.after ?? "", block.lang, "after"),
+    ];
+}
+function renderTerminalBlock(block) {
+    const head = block.command
+        ? [style.dim(`$ ${block.command}${block.cwd ? `  (${block.cwd})` : ""}`)]
+        : [];
+    const status = [
+        block.exitCode !== undefined ? `exit ${block.exitCode}` : "",
+        block.durationMs !== undefined ? formatDuration(block.durationMs) : "",
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    const paint = block.exitCode !== undefined && block.exitCode !== 0 ? style.red : style.gray;
+    return [
+        ...head,
+        ...renderCappedCode(sanitizeCode(block.output), undefined),
+        ...(block.truncated ? [style.gray("… output truncated")] : []),
+        ...(status ? [paint(status)] : []),
+    ];
+}
+function renderTestResultsBlock(block, width, unicode) {
+    const cases = block.suites.flatMap((suite) => suite.cases.map((c) => ({ suite, c })));
+    const counts = new Map();
+    for (const { c } of cases)
+        counts.set(c.status, (counts.get(c.status) ?? 0) + 1);
+    const summary = [
+        block.framework,
+        ["passed", "failed", "skipped", "todo"]
+            .filter((status) => counts.get(status))
+            .map((status) => `${counts.get(status)} ${status}`)
+            .join(", ") || "no tests",
+        block.durationMs !== undefined ? formatDuration(block.durationMs) : undefined,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    const table = renderTableBlock({
+        kind: "table",
+        columns: ["suite", "case", "status", "time"],
+        rows: cases.map(({ suite, c }) => [
+            suite.name,
+            c.name,
+            c.status,
+            c.durationMs !== undefined ? formatDuration(c.durationMs) : "",
+        ]),
+        caption: summary,
+    }, width);
+    const errors = cases
+        .filter(({ c }) => c.status === "failed" && c.error)
+        .map(({ suite, c }) => style.red(`${unicode ? "✗" : "x"} ${suite.name} ${unicode ? "›" : ">"} ${c.name}${suite.file ? ` (${suite.file}${c.line !== undefined ? `:${c.line}` : ""})` : ""}: ${c.error}`));
+    return [...table, ...errors];
+}
+const PROGRESS_GLYPHS = {
+    unicode: { completed: "✓", running: "●", pending: "○", failed: "✗", cancelled: "⊘" },
+    ascii: { completed: "[x]", running: "[>]", pending: "[ ]", failed: "[!]", cancelled: "[-]" },
+};
+function renderProgressBlock(block, unicode) {
+    const glyphs = PROGRESS_GLYPHS[unicode ? "unicode" : "ascii"];
+    const paint = {
+        completed: style.green,
+        running: style.brightCyan,
+        pending: style.gray,
+        failed: style.red,
+        cancelled: style.gray,
+    };
+    return [
+        ...(block.title ? [style.bold(block.title)] : []),
+        ...(block.steps.length ? [] : [style.gray("(no steps)")]),
+        ...block.steps.map((step) => `${paint[step.status](glyphs[step.status])} ${step.label}${step.detail ? ` ${style.dim(step.detail)}` : ""}`),
+    ];
+}
+/** Text fallback for a kind this build does not know (or a malformed block): never throws. */
+function renderUnknownBlock(block) {
+    const kind = block && typeof block === "object" && typeof block.kind === "string"
+        ? block.kind
+        : "unknown";
+    return [style.gray(`[ui block: ${kind}]`), ...renderCappedCode(jsonText(block), "json")];
+}
+/**
+ * Renders a `{type:"ui"}` block to styled lines for the given inner width. Blocks come from
+ * persisted transcripts too, so anything that does not validate (a kind added by a newer Alisio,
+ * or a malformed plugin block) falls back to labeled JSON instead of throwing.
+ */
 export function renderUiBlock(block, width, unicode) {
+    if (!isUiBlock(block))
+        return renderUnknownBlock(block);
     switch (block.kind) {
         case "table":
             return renderTableBlock(block, width);
@@ -186,6 +312,22 @@ export function renderUiBlock(block, width, unicode) {
             });
             return md.render(Math.max(1, width - 2));
         }
+        case "diff":
+            return renderDiffBlock(block);
+        case "terminal":
+            return renderTerminalBlock(block);
+        case "mermaid":
+            return renderCappedCode(block.source, "mermaid", block.title);
+        case "math":
+            return block.latex.split("\n");
+        case "json":
+            return renderCappedCode(jsonText(block.value), "json", block.caption);
+        case "test-results":
+            return renderTestResultsBlock(block, width, unicode);
+        case "progress":
+            return renderProgressBlock(block, unicode);
+        default:
+            return renderUnknownBlock(block);
     }
 }
 const permission = (label, state, priority) => ({
@@ -972,3 +1114,89 @@ export class QuestionPanel {
         return fit(lines, width);
     }
 }
+/**
+ * The `/btw` side-question panel (picker slot, never the transcript): a pending question with a
+ * spinner, then the answer rendered as Markdown like assistant text, scrollable, with ←/→ through
+ * the session's earlier side answers. `onClose` runs on Esc (the app cancels a pending question).
+ */
+export class BtwPanel {
+    state;
+    onClose;
+    height;
+    markdown;
+    constructor(state, onClose, height) {
+        this.state = state;
+        this.onClose = onClose;
+        this.height = height;
+    }
+    get pending() {
+        return !!this.state.pending;
+    }
+    dispatch(action) {
+        this.state = reduceBtw(this.state, action);
+    }
+    invalidate() {
+        this.markdown = undefined;
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape))
+            return this.onClose();
+        if (matchesKey(data, Key.left))
+            return this.dispatch({ type: "prev" });
+        if (matchesKey(data, Key.right))
+            return this.dispatch({ type: "next" });
+        if (matchesKey(data, Key.up))
+            return this.dispatch({ type: "scroll", lines: -1 });
+        if (matchesKey(data, Key.down))
+            return this.dispatch({ type: "scroll", lines: 1 });
+        if (matchesKey(data, Key.pageUp))
+            return this.dispatch({ type: "scroll", lines: -this.height() });
+        if (matchesKey(data, Key.pageDown))
+            return this.dispatch({ type: "scroll", lines: this.height() });
+    }
+    answerLines(id, text, width) {
+        if (this.markdown?.id === id && this.markdown.width === width)
+            return this.markdown.lines;
+        const lines = new Markdown(text, 0, 0, markdownTheme, markdownDefaultTextStyle, {
+            transform: markdownTransform,
+        }).render(Math.max(1, width));
+        this.markdown = { id, width, lines };
+        return lines;
+    }
+    render(width) {
+        const s = this.state;
+        const inner = Math.max(1, width - 2);
+        const bar = style.gray("│");
+        const current = btwCurrent(s);
+        const position = btwPosition(s);
+        const lines = [
+            "",
+            `${style.bold(style.yellow("btw"))}${position ? ` ${style.dim(position)}` : ""}${style.dim(" · side question, not added to the conversation")}`,
+        ];
+        const question = s.pending?.question ?? s.error?.question ?? current?.question ?? "";
+        lines.push(...wrap(question, inner).map((l) => `${bar} ${style.bold(l)}`));
+        let overflow = false;
+        if (s.pending) {
+            const spinner = SPINNER[clock.frame % SPINNER.length] ?? "…";
+            lines.push(`${bar} ${style.cyan(spinner)} Thinking… ${style.dim(formatDuration(clock.now - s.pending.startedAt))}`);
+        }
+        else if (s.error) {
+            lines.push(...wrap(s.error.message, inner).map((l) => `${bar} ${style.red(l)}`));
+        }
+        else if (current) {
+            const body = this.answerLines(current.id, current.answer, inner);
+            const view = btwWindow(body, s.scroll, Math.max(3, this.height()));
+            if (view.scroll !== s.scroll)
+                this.state = { ...s, scroll: view.scroll };
+            overflow = view.above || view.below;
+            if (view.above)
+                lines.push(`${bar} ${style.dim("↑ more")}`);
+            lines.push(...view.lines.map((l) => `${bar} ${l}`));
+            if (view.below)
+                lines.push(`${bar} ${style.dim("↓ more")}`);
+            lines.push(`${bar} ${style.dim(btwUsageLine(current))}`);
+        }
+        lines.push(style.dim(`  ${btwHints(this.state, overflow)}`));
+        return fit(lines, width);
+    }
+}

package/dist/tui/state.d.ts

@@ -1,7 +1,3 @@
-/**
- * Pure presentation logic for the TUI: formatting, command parsing and the reduction of
- * versioned runner events into a view model. No terminal or pi-tui imports here.
- */
 import type { Message, ModelInfo, RunEvent, ToolResult, TreeNode, UiBlock } from "@alisio/sdk";
 export type Level = "ok" | "warn" | "danger";
 export declare function formatTokens(n: number): string;
@@ -151,6 +147,10 @@ export interface CommandSpec {
     argumentHint?: string;
     aliases?: string[];
 }
+/**
+ * Built-in slash commands the TUI offers, derived from the core `CommandCatalog` (the TUI
+ * surface of `BUILTIN_COMMANDS`). Kept as `COMMANDS` for compatibility.
+ */
 export declare const COMMANDS: CommandSpec[];
 /** Every TUI slash name (commands, aliases and routing prefixes); templates cannot take them. */
 export declare function reservedCommandNames(): string[];
@@ -382,7 +382,7 @@ export declare function isImagePart(value: unknown): value is {
     data: string;
 };
 /** Rich (ui/image) parts of a persisted tool result, if any. */
-export declare function richPartsOf(result: ToolResult | undefined): {
+export declare function richPartsOf(result: ToolResult | undefined, toolName?: string): {
     ui?: UiBlock;
     image?: {
         mimeType: string;

package/dist/tui/state.js

@@ -1,3 +1,8 @@
+/**
+ * Pure presentation logic for the TUI: formatting, command parsing and the reduction of
+ * versioned runner events into a view model. No terminal or pi-tui imports here.
+ */
+import { CommandCatalog } from "@alisio/core";
 const trimZero = (value) => value.replace(/\.0$/, "");
 export function formatTokens(n) {
     if (!Number.isFinite(n) || n < 0)
@@ -251,61 +256,27 @@ export function fitSegments(segments, width, separator) {
         kept[0] = { ...only, text: truncatePlain(only.text, width) };
     return kept;
 }
-export const COMMANDS = [
-    { name: "help", description: "Show commands and keys" },
-    { name: "connect", description: "Configure a provider and choose its active model" },
-    {
-        name: "model",
-        description: "Switch provider and model",
-        aliases: ["models"],
-    },
-    { name: "compact", description: "Summarize older history", argumentHint: "[focus]" },
-    { name: "stats", description: "Session statistics" },
-    { name: "clear", description: "Start a new session", aliases: ["new"] },
-    { name: "sessions", description: "List recent sessions" },
-    { name: "resume", description: "Resume a session by ID or prefix", argumentHint: "<id>" },
-    { name: "tools", description: "List tools and permission state" },
-    {
-        name: "plugins",
-        description: "Browse and manage project plugins",
-        aliases: ["plugin"],
-    },
-    {
-        name: "skills",
-        description: "Browse and manage effective skills",
-        aliases: ["skill"],
-    },
-    { name: "mcp", description: "Browse and manage MCP servers" },
-    {
-        name: "settings",
-        description: "Open the settings menu",
-        aliases: ["prefs"],
-    },
-    { name: "copy", description: "Copy the last assistant response to the clipboard" },
-    {
-        name: "agents",
-        description: "List and switch the active agent (applies from the next prompt)",
-        argumentHint: "[<verb>]",
-    },
-    {
-        name: "effort",
-        description: "Set the reasoning effort level for the active model",
-        argumentHint: "[level]",
-    },
-    {
-        name: "ask",
-        description: "Ask the agent to turn your question into a multiple-choice ask_user_question",
-        argumentHint: "<question>",
-    },
-    { name: "exit", description: "Exit Alisio", aliases: ["quit"] },
-];
+/** Built-ins only: plugin, template and skill commands are resolved against the live app. */
+const BUILTIN_CATALOG = new CommandCatalog();
+/**
+ * Built-in slash commands the TUI offers, derived from the core `CommandCatalog` (the TUI
+ * surface of `BUILTIN_COMMANDS`). Kept as `COMMANDS` for compatibility.
+ */
+export const COMMANDS = BUILTIN_CATALOG.list("tui")
+    .filter((c) => c.source === "builtin")
+    .map((c) => ({
+    name: c.name,
+    description: c.description,
+    ...(c.argumentHint ? { argumentHint: c.argumentHint } : {}),
+    ...(c.aliases ? { aliases: c.aliases } : {}),
+}));
 /** Every TUI slash name (commands, aliases and routing prefixes); templates cannot take them. */
 export function reservedCommandNames() {
     return [...COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]), "command"];
 }
 export function resolveCommand(name) {
-    const lower = name.toLowerCase();
-    return COMMANDS.find((c) => c.name === lower || c.aliases?.includes(lower))?.name;
+    const found = BUILTIN_CATALOG.resolve(name);
+    return found?.source === "builtin" && found.surfaces.includes("tui") ? found.name : undefined;
 }
 export function parseCommand(input) {
     const match = /^\/([A-Za-z][\w:.-]*)(?:\s+([\s\S]*))?$/.exec(input.trim());
@@ -828,10 +799,51 @@ export function isUiBlock(value) {
                 (block.caption === undefined || typeof block.caption === "string"));
         case "markdown":
             return typeof block.text === "string";
+        case "diff":
+            return optionalStrings(block, ["path", "patch", "before", "after", "lang", "caption"]);
+        case "terminal":
+            return (typeof block.output === "string" &&
+                optionalStrings(block, ["command", "cwd"]) &&
+                optionalNumbers(block, ["exitCode", "durationMs"]) &&
+                (block.truncated === undefined || typeof block.truncated === "boolean"));
+        case "mermaid":
+            return typeof block.source === "string" && optionalStrings(block, ["title"]);
+        case "math":
+            return (typeof block.latex === "string" &&
+                (block.display === undefined || typeof block.display === "boolean"));
+        case "json":
+            return ("value" in block &&
+                optionalNumbers(block, ["collapsedDepth"]) &&
+                optionalStrings(block, ["caption"]));
+        case "test-results":
+            return (optionalStrings(block, ["framework"]) &&
+                optionalNumbers(block, ["durationMs"]) &&
+                Array.isArray(block.suites) &&
+                block.suites.every((suite) => isRecord(suite) &&
+                    typeof suite.name === "string" &&
+                    optionalStrings(suite, ["file"]) &&
+                    Array.isArray(suite.cases) &&
+                    suite.cases.every((c) => isRecord(c) &&
+                        typeof c.name === "string" &&
+                        TEST_STATUSES.has(c.status) &&
+                        optionalStrings(c, ["error"]) &&
+                        optionalNumbers(c, ["durationMs", "line"]))));
+        case "progress":
+            return (optionalStrings(block, ["title"]) &&
+                Array.isArray(block.steps) &&
+                block.steps.every((step) => isRecord(step) &&
+                    typeof step.label === "string" &&
+                    PROGRESS_STATUSES.has(step.status) &&
+                    optionalStrings(step, ["detail"])));
         default:
             return false;
     }
 }
+const TEST_STATUSES = new Set(["passed", "failed", "skipped", "todo"]);
+const PROGRESS_STATUSES = new Set(["pending", "running", "completed", "failed", "cancelled"]);
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const optionalStrings = (record, keys) => keys.every((key) => record[key] === undefined || typeof record[key] === "string");
+const optionalNumbers = (record, keys) => keys.every((key) => record[key] === undefined || typeof record[key] === "number");
 /** True when an unknown event value is a `{type:"image"}`-style part (mime + base64 data). */
 export function isImagePart(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -839,11 +851,24 @@ export function isImagePart(value) {
     const record = value;
     return typeof record.mimeType === "string" && typeof record.data === "string";
 }
+/**
+ * Display blocks the standard tools attach for the web UI only (spec §8.6): the TUI already
+ * shows the same content from the text (output rows, exit line), so rendering them would repeat it.
+ */
+const WEB_ONLY_UI = {
+    write_file: "diff",
+    edit_file: "diff",
+    shell: "terminal",
+    run_process: "terminal",
+};
 /** Rich (ui/image) parts of a persisted tool result, if any. */
-export function richPartsOf(result) {
+export function richPartsOf(result, toolName) {
     if (!result)
         return {};
-    const ui = result.content.find((part) => part.type === "ui");
+    const skip = toolName !== undefined && Object.hasOwn(WEB_ONLY_UI, toolName)
+        ? WEB_ONLY_UI[toolName]
+        : undefined;
+    const ui = result.content.find((part) => part.type === "ui" && part.block.kind !== skip);
     const image = result.content.find((part) => part.type === "image");
     return {
         ...(ui?.type === "ui" ? { ui: ui.block } : {}),
@@ -1191,7 +1216,7 @@ export function itemsFromHistory(messages) {
                     preview,
                     toolKind: toolKindOf(c.name),
                     ...exitCodePart(preview),
-                    ...richPartsOf(r?.result),
+                    ...richPartsOf(r?.result, c.name),
                 });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.22",
   "description": "Alisio: an extensible, provider-agnostic coding-agent harness for your terminal. TUI, OpenAI-compatible providers, permissioned local tools, context compaction, persistent memory and a typed plugin SDK.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,11 +45,12 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.17",
+    "@alisio/core": "0.1.0-alpha.19",
     "@alisio/plugin-memory": "0.1.0-alpha.9",
     "@alisio/plugin-openai-compatible": "0.1.0-alpha.9",
     "@alisio/plugin-subagents": "0.1.0-alpha.10",
-    "@alisio/sdk": "0.1.0-alpha.12",
+    "@alisio/sdk": "0.1.0-alpha.16",
+    "@alisio/server": "0.1.0-alpha.2",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },