@alisio/alisio-code 0.1.0-alpha.14 → 0.1.0-alpha.15

package/dist/main.js

@@ -129,6 +129,19 @@ async function run(cmd, prompt, sessionId) {
     });
     for (const failure of app.mcpStartupFailures())
         process.stderr.write(`[startup] ${failure}\n`);
+    // The ACTIVE agent (built-in `build`/`plan` or a main-capable definition) drives the main
+    // session here too: its system prompt is appended and a read-only agent narrows the run. The
+    // TUI adds the picker and the model switch; effort is a TUI feature (validated against the
+    // active model's catalog).
+    const { agentCatalogFromState, agentRunOptions, resolveActiveAgent } = await import("./tui/agents.js");
+    let activeRunOptions = {};
+    try {
+        const reported = app.plugins.pluginState("subagents", "mainAgents");
+        activeRunOptions = agentRunOptions(resolveActiveAgent(agentCatalogFromState(reported), app.config.agents.active));
+    }
+    catch {
+        /* agent resolution is best-effort */
+    }
     const controller = new AbortController();
     const interrupt = () => controller.abort(new Error("Interrupted"));
     process.on("SIGINT", interrupt);
@@ -151,7 +164,10 @@ async function run(cmd, prompt, sessionId) {
             const match = /^\/skill:([a-z0-9-]+)\s*([\s\S]*)$/.exec(prompt);
             if (match?.[1])
                 prompt = `${await app.skills.load(match[1])}\n\nUser request: ${match[2] ?? ""}`;
-            await app.runner.run(session, template?.text ?? prompt, controller.signal, template ? { display: template.display } : {});
+            await app.runner.run(session, template?.text ?? prompt, controller.signal, {
+                ...activeRunOptions,
+                ...(template ? { display: template.display } : {}),
+            });
             if (!opts.json)
                 process.stdout.write(`\nSession: ${session}\n`);
             return;
@@ -211,7 +227,10 @@ async function run(cmd, prompt, sessionId) {
                 const input = match?.[1] ? `${await app.skills.load(match[1])}\n\n${match[2] ?? ""}` : line;
                 try {
                     const template = app.expandPrompt(input);
-                    await app.runner.run(session, template?.text ?? input, controller.signal, template ? { display: template.display } : {});
+                    await app.runner.run(session, template?.text ?? input, controller.signal, {
+                        ...activeRunOptions,
+                        ...(template ? { display: template.display } : {}),
+                    });
                 }
                 catch (e) {
                     console.error(String(e));

package/dist/tui/agents.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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.
+ */
+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[];

package/dist/tui/agents.js

@@ -0,0 +1,113 @@
+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).
+ */
+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(" · "),
+    }));
+}

package/dist/tui/app.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, getNativeClipboard, Key, matchesKey, ProcessTerminal, ScrollView, SelectList, TuiAltScreen, truncateToWidth, VStack, } from "@earendil-works/pi-tui";
 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";
@@ -13,7 +14,7 @@ import { InteractiveQueue } from "./queue.js";
 import { settingsMenuRows } from "./settings.js";
 import { SettingsMenu } from "./settings-menu.js";
 import { SkillsManager } from "./skills-manager.js";
-import { addItem, COMMANDS, configuredProviderModelItems, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, shortenPath, shortId, slashCompletionCommands, summarizeToolArgs, } from "./state.js";
+import { addItem, COMMANDS, configuredProviderModelItems, effectiveEffort, effortPickerItems, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, shortenPath, shortId, slashCompletionCommands, summarizeToolArgs, validateEffortLevel, } from "./state.js";
 import { editorTheme, selectListTheme, style } from "./theme.js";
 const VERSION = loadVersion(import.meta.url);
 /** Inline selection list with type-to-filter, rendered above the editor. */
@@ -106,17 +107,44 @@ export async function runTui(options) {
         modelList = undefined;
         throw e;
     }));
+    /** Active-provider catalog by model id; feeds effort support and display names. */
+    let modelCatalog = new Map();
     /**
      * Reloads the active-provider catalog and repaints when it lands, so the context bar learns
      * the ACTIVE model's real window (previously only the first /model picker or autocomplete
      * call loaded it, leaving a fabricated 40k total on screen). Called at startup and after
      * every provider/model switch; the bar honestly shows `?` until the catalog arrives.
+     * The same refresh feeds the effort status (supported levels + default) and the model
+     * display name used by the header and the status line below the editor.
      */
     const primeModels = () => {
         void models()
-            .then(() => tui.requestRender())
+            .then((list) => {
+            modelCatalog = new Map(list.map((m) => [m.id, m]));
+            refreshEffort();
+            tui.requestRender();
+        })
             .catch(() => { });
     };
+    const effortSupportFor = (model) => modelCatalog.get(model)?.effort;
+    const modelDisplayName = (model) => modelCatalog.get(model)?.name ?? model;
+    /** Persisted `agents.effort` is silently replaced by the model default when unsupported; one notice. */
+    let notifiedEffortFallback = "";
+    function refreshEffort() {
+        const persisted = app.config.agents.effort;
+        const capability = effortSupportFor(view.model);
+        if (!persisted || !capability?.supportedLevels?.length)
+            return;
+        if (capability.supportedLevels.includes(persisted))
+            return;
+        const key = `${view.model}:${persisted}`;
+        if (notifiedEffortFallback !== key) {
+            notifiedEffortFallback = key;
+            flashHint(`Reasoning effort "${persisted}" is not supported by ${modelDisplayName(view.model)}; using ${capability.defaultLevel ? `"${capability.defaultLevel}"` : "the provider default"}.`, 7000);
+        }
+    }
+    /** Effective effort sent on runs: the persisted level when supported, else the model default. */
+    const currentEffort = () => effectiveEffort(app.config.agents.effort, effortSupportFor(view.model));
     const terminal = new ProcessTerminal();
     const copy = async (text) => copyText(text, {
         platform: process.platform,
@@ -170,6 +198,24 @@ export async function runTui(options) {
     };
     refreshBranch();
     const branchTimer = setInterval(refreshBranch, BRANCH_REFRESH_MS);
+    /**
+     * Selectable ACTIVE (main-session) agents: the built-in `build`/`plan` pair plus the
+     * main-capable definitions the subagents plugin publishes (`mode: primary|all`) through its
+     * plugin state. Never imports the plugin package; a missing/unavailable contribution is just
+     * an empty extra list. The persisted `agents.active` id resolves against this catalog.
+     */
+    const mainAgents = () => {
+        let contributions = [];
+        try {
+            const records = app.plugins.pluginState("subagents", "mainAgents");
+            contributions = (records ?? []).map(mainAgentFromRecord);
+        }
+        catch {
+            /* plugin state is best-effort */
+        }
+        return activeAgentCatalog(contributions);
+    };
+    const currentAgent = () => resolveActiveAgent(mainAgents(), app.config.agents.active);
     const headerInfo = () => {
         const policy = app.runner.policy, ask = app.runner.approvals;
         return {
@@ -177,6 +223,8 @@ export async function runTui(options) {
             host: hostOf(String(activeProvider?.profile.baseURL ?? app.config.provider.baseURL)),
             apiMode: String(activeProvider?.profile.apiMode ?? app.config.provider.apiMode),
             provider: app.providers.get(activeProvider?.id ?? "")?.name,
+            modelName: modelDisplayName(view.model),
+            effort: currentEffort(),
             cwd: shortenPath(app.workspace, homedir()),
             session: shortId(session),
             branch: branchName,
@@ -228,7 +276,15 @@ export async function runTui(options) {
         : panelState.focus === "view"
             ? viewHint()
             : undefined;
-    const footer = new Footer(() => viewedState() ?? view, () => app.contextBudget((viewedState() ?? view).model), () => panelHint() ?? hint, () => [...app.plugins.status.values()].map((s) => s.text));
+    const footer = new Footer(() => viewedState() ?? view, () => app.contextBudget((viewedState() ?? view).model), () => panelHint() ?? hint, () => [...app.plugins.status.values()].map((s) => s.text), 
+    // Status row below the editor: `agent: <name> · <model> · <provider> · <effort>` (the
+    // effort segment appears only when the active model advertises supported levels).
+    () => ({
+        agent: currentAgent().name,
+        model: modelDisplayName(view.model),
+        provider: app.providers.get(activeProvider?.id ?? "")?.name,
+        effort: currentEffort(),
+    }));
     const treePanel = new TreePanel(() => {
         const entry = panelEntry();
         if (!entry)
@@ -489,7 +545,14 @@ export async function runTui(options) {
         pendingAttachments = [];
         attachmentsBar.invalidate();
         push({ kind: "user", text: display });
+        // The ACTIVE agent drives the main session: its system prompt is appended per run and a
+        // read-only agent narrows the run to reads (no approvals). The persisted reasoning effort is
+        // resolved against the ACTIVE model and sent when the model advertises supported levels.
+        const agent = currentAgent();
+        const effort = currentEffort();
         return task((signal) => app.runner.run(session, prompt, signal, {
+            ...agentRunOptions(agent),
+            ...(effort ? { reasoningEffort: effort } : {}),
             ...(persistDisplay ? { display: persistDisplay } : {}),
             ...(attachments.length ? { attachments } : {}),
         }));
@@ -953,6 +1016,93 @@ export async function runTui(options) {
         };
         openCatalog();
     };
+    /**
+     * `/agents` (active agent): a navigable picker listing every selectable main-session agent with
+     * its description. Selecting one persists `agents.active` globally (applies from the next
+     * prompt), optionally switches the session model to the agent's declared model, and starts a
+     * fresh session just like `/model` when it does. Esc returns to the editor.
+     */
+    const openAgentsPicker = () => {
+        const agents = mainAgents();
+        const current = currentAgent();
+        showPicker(new Picker("Active agent", agentPickerItems(agents, current.id), (item) => {
+            const agent = agents.find((candidate) => candidate.id === item.value);
+            if (agent)
+                void applyActiveAgent(agent);
+        }, closePicker, true, "Changing the active agent takes effect from the next prompt; the current session is kept unless the agent declares a different model."));
+    };
+    const applyActiveAgent = (agent) => {
+        void (async () => {
+            closePicker();
+            const previous = currentAgent().name;
+            try {
+                await app.updateSetting("agents.active", agent.id);
+                let switched = false;
+                if (agent.model && app.store.get(session).model !== agent.model) {
+                    flashHint(`Switching to ${agent.name}'s model ${agent.model}…`, 60_000);
+                    const created = await app.switchModel(agent.model);
+                    if (created) {
+                        activeProvider = app.providerInfo;
+                        modelList = undefined;
+                        session = created.id;
+                        reset(initialViewState(created.model));
+                        switched = true;
+                    }
+                }
+                notice(`Active agent: ${agent.name}${agent.readOnly ? " (read-only)" : ""}. Applies from the next prompt.`);
+                if (agent.model && switched)
+                    notice(`Agent ${agent.name} switches the session model to ${app.store.get(session).model}.`);
+                else if (agent.model)
+                    flashHint(`Agent ${agent.name} keeps the current model (already ${view.model}). Override any time with /model.`);
+                else
+                    flashHint(`Active agent: ${agent.name} (was ${previous}).`);
+                refreshEffort();
+                primeModels();
+                tui.requestRender();
+            }
+            catch (cause) {
+                error(cause);
+            }
+        })();
+    };
+    /**
+     * `/effort [level]`: without an argument, a picker over the ACTIVE model's advertised effort
+     * levels (marking the model default); with an argument, the level is validated against
+     * `effort.supportedLevels` and persisted globally. The chosen level is sent from the next
+     * prompt; if the model later changes to one that does not support it, the model's default is
+     * used silently with a one-time notice.
+     */
+    const setEffort = async (args) => {
+        const capability = effortSupportFor(view.model);
+        if (!args) {
+            if (!capability?.supportedLevels?.length)
+                return notice(`${view.model} does not advertise reasoning effort levels (ModelInfo.effort), so /effort is not available for it.`);
+            const items = effortPickerItems(capability, currentEffort());
+            showPicker(new Picker(`Reasoning effort · ${modelDisplayName(view.model)}`, items, (item) => void applyEffort(item.value), closePicker, true));
+            return;
+        }
+        const invalid = validateEffortLevel(args, capability);
+        if (invalid)
+            return notice(invalid);
+        await applyEffort(args);
+    };
+    const applyEffort = async (value) => {
+        const clear = value === "!clear";
+        closePicker();
+        try {
+            await app.updateSetting("agents.effort", clear ? undefined : value);
+            const capability = effortSupportFor(view.model);
+            const effective = effectiveEffort(clear ? undefined : value, capability);
+            notice(clear
+                ? `Reasoning effort cleared; ${capability?.defaultLevel ? `the model default "${capability.defaultLevel}" is used` : "the provider default is used"}.`
+                : `Reasoning effort: ${value}${value === capability?.defaultLevel ? ` (default for ${modelDisplayName(view.model)})` : ""}${effective && effective !== value ? ` — effective: ${effective}` : ""}. Applies from the next prompt.`);
+            refreshEffort();
+            tui.requestRender();
+        }
+        catch (cause) {
+            error(cause);
+        }
+    };
     /**
      * Navigation rows at the bottom of `/settings`: they route to the existing managers and one-shot
      * actions exactly like the old picker, so every prior entry stays reachable. `compact` and
@@ -1256,6 +1406,30 @@ export async function runTui(options) {
                         `(reuse the user's own wording for the question text). Do not answer in plain text ` +
                         `first; call the tool right away.`);
                 }
+                case "agents": {
+                    // The subagents plugin registers its own built-in `/agents` command for subagent task
+                    // management (list/open/cancel/kill/resume/merge/discard/defs). With arguments, route
+                    // to it verbatim (still available while a turn runs, exactly as before); without
+                    // arguments, this opens the ACTIVE-agent picker.
+                    if (parsed.args) {
+                        const handler = app.plugins.commands.get("agents");
+                        if (handler)
+                            return info(await handler(parsed.args, { sessionId: session }));
+                    }
+                    if (busy) {
+                        editor.setText(raw);
+                        flashHint("A turn is running: wait for it to finish before switching the active agent");
+                        return;
+                    }
+                    return openAgentsPicker();
+                }
+                case "effort":
+                    if (busy) {
+                        editor.setText(raw);
+                        flashHint("A turn is running: wait for it to finish before changing the effort");
+                        return;
+                    }
+                    return await setEffort(parsed.args);
                 case "clear": {
                     await endSession("clear");
                     session = app.store.create(app.workspace, app.provider.id, view.model).id;

package/dist/tui/components.d.ts

@@ -2,7 +2,7 @@ import type { PanelNode } from "@alisio/sdk";
 import { type Component, Container } from "@earendil-works/pi-tui";
 import { type PendingAttachment } from "./attachments.ts";
 import { type QuestionPanelState, type QuestionSpec } from "./questions.ts";
-import { type ContextBudget, type TranscriptItem, type ViewState } from "./state.ts";
+import { type ContextBudget, type IdentityInput, type TranscriptItem, type ViewState } from "./state.ts";
 export declare const SPINNER: string[];
 /** Shared animation clock advanced by the app while work is running. */
 export declare const clock: {
@@ -15,6 +15,10 @@ export interface HeaderInfo {
     host: string;
     apiMode: string;
     provider?: string;
+    /** Model display name (catalog `name`), falling back to the session model id. */
+    modelName?: string;
+    /** Effective reasoning effort of the active model, when it advertises supported levels. */
+    effort?: string;
     cwd: string;
     session: string;
     /** Git branch (or short SHA on a detached HEAD) of the session workspace; undefined when unavailable. */
@@ -36,7 +40,8 @@ export declare class Footer implements Component {
     private budget;
     private hint;
     private statuses;
-    constructor(view: () => ViewState, budget: () => ContextBudget | undefined, hint: () => string | undefined, statuses?: () => string[]);
+    private identity?;
+    constructor(view: () => ViewState, budget: () => ContextBudget | undefined, hint: () => string | undefined, statuses?: () => string[], identity?: (() => IdentityInput | undefined) | undefined);
     invalidate(): void;
     render(width: number): string[];
 }

package/dist/tui/components.js

@@ -3,7 +3,7 @@ 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, fitSegments, formatContext, formatDuration, formatTokens, } from "./state.js";
+import { contextLevel, contextPercent, editSummary, fitIdentityParts, fitSegments, formatContext, formatDuration, formatTokens, } from "./state.js";
 import { imageTheme, levelColor, markdownTheme, style } from "./theme.js";
 export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 /** Shared animation clock advanced by the app while work is running. */
@@ -33,12 +33,14 @@ export class Header {
             { text: "◆ Alisio Code", priority: 8, paint: (t) => style.bold(style.brightCyan(t)) },
             { text: `v${i.version}`, priority: 1, paint: style.gray },
             {
-                text: v.model || "not connected",
+                text: i.modelName || v.model || "not connected",
                 priority: 10,
-                paint: v.model ? style.bold : style.yellow,
+                paint: v.model ? (t) => style.bold(style.cyan(t)) : style.yellow,
             },
-            ...(i.provider ? [{ text: i.provider, priority: 6, paint: style.cyan }] : []),
-            { text: i.host, priority: 5, paint: style.gray },
+            // `model · provider · effort` with each piece in a distinct color.
+            ...(i.provider ? [{ text: i.provider, priority: 6, paint: style.magenta }] : []),
+            ...(i.effort ? [{ text: i.effort, priority: 5, paint: style.yellow }] : []),
+            { text: i.host, priority: 4, paint: style.gray },
             { text: i.apiMode, priority: 2, paint: style.gray },
         ], width);
         const perms = i.readOnly
@@ -78,11 +80,13 @@ export class Footer {
     budget;
     hint;
     statuses;
-    constructor(view, budget, hint, statuses = () => []) {
+    identity;
+    constructor(view, budget, hint, statuses = () => [], identity) {
         this.view = view;
         this.budget = budget;
         this.hint = hint;
         this.statuses = statuses;
+        this.identity = identity;
     }
     invalidate() { }
     render(width) {
@@ -124,7 +128,22 @@ export class Footer {
             (v.streaming || v.compacting
                 ? "Esc interrupt · Ctrl+C clear/exit"
                 : "Enter send · Shift+Enter newline · /help commands · Ctrl+D exit");
-        return fit([line1, style.dim(hint)], width);
+        // Status row below the editor: `agent: <name> · <model> · <provider> · <effort>`, each piece
+        // in a distinct color (model bold/cyan, provider magenta, effort yellow); the effort part is
+        // omitted when the active model advertises no supported levels. Truncation drops the lowest
+        // priority parts first (effort, then provider) before truncating what remains.
+        const identity = this.identity?.();
+        const identityLine = identity
+            ? fitIdentityParts(identity, width)
+                .map((part) => ({
+                agent: (t) => style.bold(style.magenta(t)),
+                model: (t) => style.bold(style.cyan(t)),
+                provider: style.magenta,
+                effort: style.yellow,
+            })[part.role](part.text))
+                .join(style.gray(" · "))
+            : undefined;
+        return fit(identityLine ? [identityLine, line1, style.dim(hint)] : [line1, style.dim(hint)], width);
     }
 }
 export class UserBlock {

package/dist/tui/state.d.ts

@@ -124,6 +124,44 @@ export declare function parseCommand(input: string): {
     name: string;
     args: string;
 } | undefined;
+/** Reasoning-effort capability advertised by a model's catalog entry (`ModelInfo.effort`). */
+export interface EffortCapability {
+    supportedLevels: string[];
+    defaultLevel?: string;
+}
+/**
+ * The effective reasoning effort to send for a model: the persisted level when the model
+ * supports it, otherwise the model's default level (silent fallback), and nothing when the
+ * model advertises no effort levels at all.
+ */
+export declare function effectiveEffort(persisted: string | undefined, capability: EffortCapability | undefined): string | undefined;
+/** Validates a `/effort <level>` argument against the active model; returns an error or nothing. */
+export declare function validateEffortLevel(level: string, capability: EffortCapability | undefined): string | undefined;
+export declare function effortPickerItems(capability: EffortCapability, active: string | undefined): Array<{
+    value: string;
+    label: string;
+    description?: string;
+}>;
+/** Role of a status-line identity part; the renderer maps each role to a distinct color. */
+export type IdentityRole = "agent" | "model" | "provider" | "effort";
+export interface IdentityPart extends Segment {
+    role: IdentityRole;
+}
+export interface IdentityInput {
+    agent: string;
+    model: string;
+    provider?: string;
+    effort?: string;
+}
+/**
+ * The ordered identity parts for the status line below the editor:
+ * `agent: <name> · <model> · <provider> · <effort>`, with the effort part omitted when the
+ * active model advertises no supported levels (`effort === undefined`). Colors are applied by
+ * the renderer per role; this module stays terminal-free and testable.
+ */
+export declare function identityParts(input: IdentityInput): IdentityPart[];
+/** Drops the lowest-priority identity parts until the line fits `width`; truncates the survivor. */
+export declare function fitIdentityParts(input: IdentityInput, width: number): IdentityPart[];
 /** Minimal structural view of a skill for slash autocompletion (subset of the core catalog entry). */
 export interface SkillCompletionEntry {
     id: string;

package/dist/tui/state.js

@@ -229,6 +229,16 @@ export const COMMANDS = [
         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",
@@ -250,6 +260,68 @@ export function parseCommand(input) {
         return undefined;
     return { name: match[1], args: (match[2] ?? "").trim() };
 }
+/**
+ * The effective reasoning effort to send for a model: the persisted level when the model
+ * supports it, otherwise the model's default level (silent fallback), and nothing when the
+ * model advertises no effort levels at all.
+ */
+export function effectiveEffort(persisted, capability) {
+    if (!capability?.supportedLevels?.length)
+        return undefined;
+    if (persisted && capability.supportedLevels.includes(persisted))
+        return persisted;
+    return capability.defaultLevel;
+}
+/** Validates a `/effort <level>` argument against the active model; returns an error or nothing. */
+export function validateEffortLevel(level, capability) {
+    if (!capability?.supportedLevels?.length)
+        return "This model does not advertise reasoning effort levels, so no effort is sent to it.";
+    if (!capability.supportedLevels.includes(level))
+        return `Unsupported effort level "${level}". Supported levels: ${capability.supportedLevels.join(", ")}.`;
+    return undefined;
+}
+export function effortPickerItems(capability, active) {
+    const items = capability.supportedLevels.map((level) => ({
+        value: level,
+        label: [
+            level,
+            level === active ? "(current)" : undefined,
+            level === capability.defaultLevel ? "(default)" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" · "),
+        ...(level === capability.defaultLevel ? { description: "The model's own default" } : {}),
+    }));
+    return [
+        ...items,
+        {
+            value: "!clear",
+            label: "Auto · provider default",
+            description: "Clear the saved effort; the provider uses its own default",
+        },
+    ];
+}
+/**
+ * The ordered identity parts for the status line below the editor:
+ * `agent: <name> · <model> · <provider> · <effort>`, with the effort part omitted when the
+ * active model advertises no supported levels (`effort === undefined`). Colors are applied by
+ * the renderer per role; this module stays terminal-free and testable.
+ */
+export function identityParts(input) {
+    const parts = [
+        { text: `agent: ${input.agent}`, priority: 10, role: "agent" },
+        { text: input.model || "not connected", priority: 9, role: "model" },
+    ];
+    if (input.provider)
+        parts.push({ text: input.provider, priority: 8, role: "provider" });
+    if (input.effort)
+        parts.push({ text: input.effort, priority: 7, role: "effort" });
+    return parts;
+}
+/** Drops the lowest-priority identity parts until the line fits `width`; truncates the survivor. */
+export function fitIdentityParts(input, width) {
+    return fitSegments(identityParts(input), width, " · ");
+}
 export const SKILL_COMPLETION_DESCRIPTION_LIMIT = 80;
 /** Status hint prefixes (no color): shadowed < disabled < locked states shown by /skills. */
 const skillStatus = (skill) => !skill.effective

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.14",
+  "version": "0.1.0-alpha.15",
   "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,14 +45,14 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.12",
-    "@alisio/plugin-deepseek": "0.1.0-alpha.9",
+    "@alisio/core": "0.1.0-alpha.13",
+    "@alisio/plugin-deepseek": "0.1.0-alpha.10",
     "@alisio/plugin-memory": "0.1.0-alpha.7",
     "@alisio/plugin-openai-compatible": "0.1.0-alpha.9",
     "@alisio/plugin-opencode": "0.1.0-alpha.8",
     "@alisio/plugin-opencode-go": "0.1.0-alpha.8",
-    "@alisio/plugin-subagents": "0.1.0-alpha.8",
-    "@alisio/sdk": "0.1.0-alpha.7",
+    "@alisio/plugin-subagents": "0.1.0-alpha.9",
+    "@alisio/sdk": "0.1.0-alpha.8",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },