@alisio/alisio-code 0.1.0-alpha.19 → 0.1.0-alpha.21

package/dist/main.js

@@ -38,6 +38,7 @@ program
     .option("--allow-external", "Allow network tools: webfetch, websearch and provider-native search")
     .option("--allow-mcp", "Allow configured MCP servers and remote tool calls")
     .option("--allow-agents", "Allow messaging neighboring agents through Herdr")
+    .option("--add-dir <paths...>", "Additional directories tools may read/write outside the workspace (repeatable)")
     .option("--no-herdr", "Disable automatic Herdr lifecycle reports")
     .option("--read-only", "Disable writes, arbitrary processes, network tools, executable plugins and MCP")
     .option("--db <path>", "Session database")
@@ -54,6 +55,7 @@ const options = (cmd) => {
         baseURL: o.baseUrl,
         noHerdr: o.herdr === false,
         disablePlugins: o.disablePlugin,
+        addDirs: o.addDir,
         ...(o.agents
             ? { pluginOptions: { subagents: { agents: parseAgents(String(o.agents)) } } }
             : {}),
@@ -258,6 +260,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

@@ -4,7 +4,7 @@ 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 { copyText, nodeSpawn } from "./clipboard.js";
-import { AttachmentsBar, BannerBlock, clock, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
+import { AttachmentsBar, BannerBlock, 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,11 +136,12 @@ 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 = () => { };
     let approve = async () => "deny";
+    let approveExternalDirectory = async () => "deny";
     const app = await createApplication({
         builtins: BUILTIN_PLUGINS,
         builtinPrompts: BUILTIN_PROMPTS,
@@ -148,6 +149,7 @@ export async function runTui(options) {
         ...options,
         onEvent: (event) => dispatch(event),
         approve: (request) => approve(request),
+        approveExternalDirectory: (request) => approveExternalDirectory(request),
     });
     let activeProvider = app.providerInfo;
     let session = options.session ?? app.store.create(app.workspace, app.provider.id, app.provider.model).id;
@@ -390,14 +392,21 @@ export async function runTui(options) {
     // working (copyOnSelect must never be disturbed). The region sits between the ScrollView and
     // the content switch; content rows = visible rows + the scroll offset.
     let transcriptScroll;
-    const transcriptRegion = new MouseRegion(new Switch(() => (viewedState() ? childView.container : transcript)), (event) => {
+    // Transcript content is inset from both borders in ONE place: the wrapper hands children a
+    // reduced width and prefixes every row, so agent text, copy hints, tool sub-lines, reasoning
+    // lines and group headers all share the same visual column. The config is read live, so a
+    // `/settings` change applies on the next render without rebuilding the view.
+    const contentInsetX = () => app.config.tui.contentPaddingX;
+    const transcriptRegion = new MouseRegion(new ContentInset(new Switch(() => (viewedState() ? childView.container : transcript)), contentInsetX), (event) => {
         if (picker || event.type !== "click" || event.button !== "left")
             return undefined;
         const scroll = transcriptScroll;
         if (!scroll)
             return undefined;
         const visible = visibleTranscript();
-        const candidate = visible.sync.entryAt(event.y + scroll.scrollTop, event.width);
+        // entryAt re-renders each row to measure its height, so it must use the same reduced width
+        // the wrapper hands the rows during render.
+        const candidate = visible.sync.entryAt(event.y + scroll.scrollTop, contentInnerWidth(event.width, contentInsetX()));
         if (!candidate)
             return undefined;
         toggleFold(candidate);
@@ -464,7 +473,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 } };
         }
@@ -549,6 +558,36 @@ export async function runTui(options) {
             ], (item) => finish(item.value), () => finish("deny")));
         }),
     });
+    /**
+     * External-directory approval: a tool path outside the workspace and every declared extra root
+     * asks here before the call runs, scoped to the containing directory (not the individual file),
+     * so one approval covers that directory's subtree for the session. Same queue and the same
+     * allow-once / allow-session / deny choices as the capability approval above.
+     */
+    approveExternalDirectory = (request) => interactiveQueue.submit({
+        sessionId: request.session,
+        label: request.label,
+        signal: request.signal,
+        onWithdrawn: () => "deny",
+        run: () => new Promise((resolve) => {
+            let settled = false;
+            const finish = (decision) => {
+                if (settled)
+                    return;
+                settled = true;
+                request.signal.removeEventListener("abort", onAbort);
+                closePicker();
+                resolve(decision);
+            };
+            const onAbort = () => finish("deny");
+            request.signal.addEventListener("abort", onAbort, { once: true });
+            showPicker(new Picker(`${request.label ? `[${request.label}] ` : ""}Allow access outside the workspace to ${shortenPath(request.directory, homedir(), 72)}?`, [
+                { value: "once", label: "Allow once" },
+                { value: "session", label: "Always allow this directory in this session" },
+                { value: "deny", label: "Deny" },
+            ], (item) => finish(item.value), () => finish("deny")));
+        }),
+    });
     /**
      * `ask_user_question` / `/ask`: routed through the same `interactiveQueue` as `approve`/`select`,
      * so a root or subagent question never races another prompt for the screen. A question withdrawn
@@ -1269,6 +1308,9 @@ export async function runTui(options) {
                 .then(() => {
                 if (row.id === "tui.paddingX")
                     editor.setPaddingX(Number(value));
+                // The inset wrapper reads the live config; repaint so the new value shows immediately.
+                if (row.id === "tui.contentPaddingX")
+                    tui.requestRender();
                 // Rebuild the slash provider: the toggle gates the skill:<id> entries immediately.
                 if (row.id === "tui.skillSlashCommands")
                     editor.setAutocompleteProvider(buildSlashCompletionProvider());
@@ -1339,22 +1381,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. \`internal\` tools (built-in plugins) only write Alisio's own state.`;
-    };
     const statsReport = () => {
         const s = view.stats;
         const budget = app.contextBudget(view.model);
@@ -1414,6 +1440,7 @@ 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");
+    const commandCatalog = new CommandCatalog(app);
     const mutating = new Set([
         "connect",
         "model",
@@ -1466,7 +1493,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":
@@ -1533,16 +1564,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);

package/dist/tui/components.d.ts

@@ -21,7 +21,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 {
@@ -129,6 +133,33 @@ export declare class InfoBlock implements Component {
     invalidate(): void;
     render(width: number): string[];
 }
+/**
+ * Minimum usable inner width (cells) the transcript keeps no matter how narrow the terminal is or
+ * how large the configured inset grows. The effective inset is clamped so this floor is honored,
+ * which also keeps the inner width positive.
+ */
+export declare const MIN_CONTENT_WIDTH = 20;
+/**
+ * Inset actually applied on each side: the configured value capped so the inner column stays at
+ * least `MIN_CONTENT_WIDTH` wide. On terminals narrower than that floor the inset degrades to 0
+ * rather than overflowing (the inner width then simply equals the terminal width).
+ */
+export declare function effectiveContentInset(width: number, inset: number): number;
+/** Inner width handed to transcript children after the effective inset is applied. Always >= 1. */
+export declare function contentInnerWidth(width: number, inset: number): number;
+/**
+ * Applies the transcript's horizontal inset in ONE place: it hands children a reduced width and
+ * prefixes every produced line with the inset, so all transcript chrome (text, copy hint, tool
+ * sub-lines, reasoning lines, group headers) shares the same visual column. The reduced width is a
+ * deterministic function of the terminal width, so per-row caches keyed by width stay effective.
+ */
+export declare class ContentInset implements Component {
+    private readonly inner;
+    private readonly inset;
+    constructor(inner: Component, inset: () => number);
+    invalidate(): void;
+    render(width: number): string[];
+}
 export declare function componentFor(entry: TranscriptEntry): Component;
 /**
  * Keeps a container of transcript components in step with view-model items. Rows are keyed

package/dist/tui/components.js

@@ -3,8 +3,8 @@ import { terminalCapabilities } from "../banner.js";
 import { attachmentCaption, MAX_ATTACHMENTS_PER_MESSAGE, } from "./attachments.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 +169,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 +311,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) => ({
@@ -588,6 +729,51 @@ export class InfoBlock {
         return fit(["", ...inner.map((l) => `${style.gray("│")} ${l}`)], width);
     }
 }
+/**
+ * Minimum usable inner width (cells) the transcript keeps no matter how narrow the terminal is or
+ * how large the configured inset grows. The effective inset is clamped so this floor is honored,
+ * which also keeps the inner width positive.
+ */
+export const MIN_CONTENT_WIDTH = 20;
+/**
+ * Inset actually applied on each side: the configured value capped so the inner column stays at
+ * least `MIN_CONTENT_WIDTH` wide. On terminals narrower than that floor the inset degrades to 0
+ * rather than overflowing (the inner width then simply equals the terminal width).
+ */
+export function effectiveContentInset(width, inset) {
+    const requested = Math.max(0, Math.floor(inset));
+    const max = Math.max(0, Math.floor((Math.floor(width) - MIN_CONTENT_WIDTH) / 2));
+    return Math.min(requested, max);
+}
+/** Inner width handed to transcript children after the effective inset is applied. Always >= 1. */
+export function contentInnerWidth(width, inset) {
+    return Math.max(1, Math.floor(width) - effectiveContentInset(width, inset) * 2);
+}
+/**
+ * Applies the transcript's horizontal inset in ONE place: it hands children a reduced width and
+ * prefixes every produced line with the inset, so all transcript chrome (text, copy hint, tool
+ * sub-lines, reasoning lines, group headers) shares the same visual column. The reduced width is a
+ * deterministic function of the terminal width, so per-row caches keyed by width stay effective.
+ */
+export class ContentInset {
+    inner;
+    inset;
+    constructor(inner, inset) {
+        this.inner = inner;
+        this.inset = inset;
+    }
+    invalidate() {
+        this.inner.invalidate();
+    }
+    render(width) {
+        const inset = effectiveContentInset(width, this.inset());
+        const lines = this.inner.render(contentInnerWidth(width, inset));
+        if (!inset)
+            return lines;
+        const pad = " ".repeat(inset);
+        return lines.map((line) => `${pad}${line}`);
+    }
+}
 export function componentFor(entry) {
     if (entry.kind === "group")
         return new ToolGroupBlock(entry.group);

package/dist/tui/settings.d.ts

@@ -56,6 +56,7 @@ export interface SettingsConfigView {
     };
     tui: {
         paddingX: number;
+        contentPaddingX: number;
         skillSlashCommands: boolean;
     };
     mcp: {

package/dist/tui/settings.js

@@ -13,7 +13,7 @@ export const defaultConfig = {
     compaction: { auto: true, threshold: 0.85, keepTurns: 2, maxOutputTokens: 16_000 },
     context: { claudeMdFallback: false, maxBytes: 32 * 1024 },
     limits: { maxTurns: 100, maxOutputTokens: 16_384, maxContextChars: 800_000, timeoutMs: 300_000 },
-    tui: { paddingX: 1, skillSlashCommands: true },
+    tui: { paddingX: 1, contentPaddingX: 2, skillSlashCommands: true },
     mcp: { allow: false },
     websearch: { provider: undefined },
     pluginHooks: { timeoutMs: 15_000 },
@@ -161,6 +161,15 @@ export const SETTINGS_DEFINITIONS = [
         read: (config) => config.tui.paddingX,
         description: "Horizontal padding (columns) around the editor input box. Applied immediately to the current editor.",
     },
+    {
+        id: "tui.contentPaddingX",
+        label: "Content inset",
+        category: "TUI",
+        valueType: "number",
+        values: [0, 1, 2, 3, 4, 6, 8, 12],
+        read: (config) => config.tui.contentPaddingX,
+        description: "Horizontal inset (columns) on each side of the transcript content, keeping agent-written rows clear of the window borders. Clamped on narrow terminals so the content column stays usable. Applied immediately.",
+    },
     {
         id: "tui.skillSlashCommands",
         label: "Skill slash commands",

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.19",
+  "version": "0.1.0-alpha.21",
   "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.16",
+    "@alisio/core": "0.1.0-alpha.18",
     "@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.11",
+    "@alisio/sdk": "0.1.0-alpha.15",
+    "@alisio/server": "0.1.0-alpha.1",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },