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

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 { CombinedAutocompleteProvider, Container, Editor, getImageDimensions, getNativeClipboard, Key, MouseRegion, 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, editorCopyKey, effectiveEffort, effortPickerItems, foldCandidates, foldToggleKey, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, richPartsOf, 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,
@@ -142,6 +170,23 @@ export async function runTui(options) {
     // Read-only views of child sessions (subagents), fed by their events.
     const childViews = new Map();
     const childView = new TranscriptSync();
+    // Fold state of every collapsible transcript row (reasoning sections, tool batches, long
+    // outputs). Keyed by stable fold keys from state.ts; absent entries use the pure defaults.
+    const folded = new Map();
+    const foldOf = (candidate) => folded.get(candidate.key) ?? candidate.defaultExpanded;
+    main.setFoldResolver(foldOf);
+    childView.setFoldResolver(foldOf);
+    /** Which transcript is on screen right now (child view while viewing a subagent, else main). */
+    const visibleTranscript = () => viewedState()
+        ? { items: viewedState()?.items ?? [], sync: childView }
+        : { items: view.items, sync: main };
+    /** Applies one fold toggle and re-syncs only the affected transcript (cheap: events, not frames). */
+    const toggleFold = (candidate) => {
+        folded.set(candidate.key, !(folded.get(candidate.key) ?? candidate.defaultExpanded));
+        const visible = visibleTranscript();
+        visible.sync.sync(visible.items);
+        tui.requestRender();
+    };
     let panelState = initialPanelState();
     const startupDiagnostics = [];
     let hint;
@@ -170,6 +215,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 +240,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 +293,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)
@@ -256,18 +329,32 @@ export async function runTui(options) {
     bottom.addChild(editor);
     bottom.addChild(treePanel);
     bottom.addChild(footer);
+    // Click-to-toggle on collapsible transcript rows: pi-tui synthesizes `click` events after a
+    // press+release without movement, so plain clicks fold/unfold while drag-selection keeps
+    // 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) => {
+        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);
+        if (!candidate)
+            return undefined;
+        toggleFold(candidate);
+        return { handled: true };
+    });
+    transcriptScroll = new ScrollView(transcriptRegion, {
+        follow: "end",
+        primary: true,
+        overscroll: "chain",
+    });
     tui.setLayoutRoot(new VStack([
         { component: header, basis: "auto" },
-        {
-            component: new ScrollView(new Switch(() => (viewedState() ? childView.container : transcript)), {
-                follow: "end",
-                primary: true,
-                overscroll: "chain",
-            }),
-            basis: 0,
-            grow: 1,
-            minSize: 1,
-        },
+        { component: transcriptScroll, basis: 0, grow: 1, minSize: 1 },
         { component: bottom, basis: "auto", shrink: 1, minSize: 3 },
     ]));
     // Prime the active provider's catalog so the context bar shows the model's real window
@@ -317,6 +404,14 @@ export async function runTui(options) {
     const info = (text) => push({ kind: "info", text });
     let terminalEvent = false;
     dispatch = (event) => {
+        // The event stream stays text-only (headless/JSONL consumers see the projection); the TUI
+        // 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 ?? "")));
+            if (rich.ui !== undefined || rich.image !== undefined)
+                event = { ...event, data: { ...data, ...rich } };
+        }
         if (event.sessionId !== session) {
             // Child session (e.g. a subagent): keep a view model for its read-only view.
             const child = childViews.get(event.sessionId) ?? initialViewState(view.model);
@@ -489,7 +584,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 +1055,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
@@ -1166,7 +1355,7 @@ export async function runTui(options) {
         "- `/init` (above) writes AGENTS.md; the shell command `alisio setup` only scaffolds `.alisio/config.json`",
         "- `/command plugin.id:name args` — run a plugin command",
         "",
-        "**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 · PgUp/PgDn or mouse wheel scroll · Ctrl+X agent panel · Ctrl+B background running agents",
+        "**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 mutating = new Set([
@@ -1256,6 +1445,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;
@@ -1433,6 +1646,20 @@ export async function runTui(options) {
                 removeAttachment();
                 return { consume: true };
             }
+            // `x` on an EMPTY editor line toggles the nearest collapsible transcript row — a finished
+            // `Thought` section, a grouped batch of tool calls, or a long command output. Same
+            // empty-input convention as Enter, Ctrl+D and `c`/`y`; typing `x` mid-message is never
+            // intercepted, and with nothing collapsible it types normally.
+            if (foldToggleKey(data, {
+                text: editor.getText(),
+                autocomplete: editor.isShowingAutocomplete(),
+            })) {
+                const target = foldCandidates(visibleTranscript().items).at(-1);
+                if (target) {
+                    toggleFold(target);
+                    return { consume: true };
+                }
+            }
         }
         if (!picker) {
             if (matchesKey(data, Key.ctrl("x"))) {
@@ -1469,6 +1696,24 @@ export async function runTui(options) {
                     return { consume: true };
                 }
             }
+            // `c`/`y` on an EMPTY editor line copies the last assistant response as raw text, the same
+            // as /copy; typing `c` or `y` mid-message is never intercepted.
+            if (editorCopyKey(data, {
+                text: editor.getText(),
+                autocomplete: editor.isShowingAutocomplete(),
+                busy,
+            })) {
+                const last = lastAssistantText(view.items);
+                if (last) {
+                    void copy(last).then((result) => {
+                        const message = copyMessage(result);
+                        tui.flash(message);
+                        if (!result.ok)
+                            notice(message);
+                    });
+                }
+                return { consume: true };
+            }
         }
         if (matchesKey(data, Key.escape)) {
             if (busy && !picker && !editor.isShowingAutocomplete()) {