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

package/dist/builtin.d.ts

@@ -2,7 +2,9 @@
  * Built-in plugin registry wired by the CLI. Built-ins load through the trusted path of the
  * plugin host (unprefixed names, `internal` effect) and can be disabled by configuration
  * (`builtinPlugins.<id>.enabled: false`) or `--disable-plugin <id>`. Add a built-in by
- * appending an entry here.
+ * appending an entry here. Dedicated model providers (DeepSeek, OpenCode Console, OpenCode Go)
+ * are no longer built-ins: users install them independently via
+ * `alisio install npm:@alisio/plugin-{deepseek,opencode,opencode-go}`.
  */
 import type { BuiltinPlugin } from "@alisio/core";
 export declare const BUILTIN_PLUGINS: BuiltinPlugin[];

package/dist/builtin.js

@@ -1,31 +1,7 @@
-import { createDeepSeekPlugin } from "@alisio/plugin-deepseek";
 import { createMemoryPlugin } from "@alisio/plugin-memory";
 import { createOpenAICompatiblePlugin } from "@alisio/plugin-openai-compatible";
-import { createOpenCodePlugin } from "@alisio/plugin-opencode";
-import { createOpenCodeGoPlugin } from "@alisio/plugin-opencode-go";
 import { createSubagentsPlugin } from "@alisio/plugin-subagents";
 export const BUILTIN_PLUGINS = [
-    {
-        id: "deepseek",
-        name: "DeepSeek",
-        description: "Dedicated DeepSeek Chat Completions and Responses provider",
-        categories: ["model-provider"],
-        create: createDeepSeekPlugin,
-    },
-    {
-        id: "opencode",
-        name: "OpenCode Console (Zen)",
-        description: "Dedicated OpenCode Console (Zen) multi-protocol provider",
-        categories: ["model-provider"],
-        create: createOpenCodePlugin,
-    },
-    {
-        id: "opencode-go",
-        name: "OpenCode Go",
-        description: "Dedicated OpenCode Go multi-protocol provider",
-        categories: ["model-provider"],
-        create: createOpenCodeGoPlugin,
-    },
     {
         id: "openai-compatible",
         name: "OpenAI compatible",

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)) } } }
             : {}),

package/dist/tui/app.d.ts

@@ -1,4 +1,41 @@
 import type { AppOptions } from "@alisio/core";
+import { type Component, type SelectItem } from "@earendil-works/pi-tui";
+/**
+ * Inline selection list with type-to-filter, rendered above the editor.
+ *
+ * Grouped item builders (pluginCatalogItems) interleave their output with non-selectable
+ * `__group:` header items. Headers stay in the SelectList so they render, scroll and truncate
+ * like rows, but selection is owned here: navigation jumps over headers via skipGroupHeaders
+ * (wrapping both directions), Enter never fires onSelect for a header, and the whole display
+ * sequence is re-derived on every filter keystroke so headers of fully-filtered groups vanish.
+ */
+export declare class Picker implements Component {
+    private title;
+    private readonly onSelectItem;
+    private readonly onCancelPick;
+    private filterable;
+    private detail?;
+    private list;
+    private filter;
+    /** Full item sequence (group headers + rows) before any filtering. */
+    private readonly allItems;
+    /** Display sequence: filtered rows plus the headers of groups that still match. */
+    private items;
+    /** Selection index within `items`; always a real row, never a group header. */
+    private index;
+    /** Picker height target: counted on real rows only, so headers never stretch the list. */
+    private readonly maxVisible;
+    constructor(title: string, items: SelectItem[], onSelectItem: (item: SelectItem) => void, onCancelPick: () => void, filterable?: boolean, detail?: string | undefined);
+    /** Copies items, dimming group-header labels (style helpers stay plain under NO_COLOR). */
+    private static displayItems;
+    /** (Re)builds the SelectList over the filtered display sequence; selection starts on a row. */
+    private resetList;
+    invalidate(): void;
+    /** The currently selected item — always a real row, never a group header. */
+    getSelectedItem(): SelectItem | null;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
 export interface TuiOptions extends AppOptions {
     session?: string;
     quiet?: boolean;

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";
@@ -14,38 +14,94 @@ 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, 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 { addItem, COMMANDS, configuredProviderModelItems, editorCopyKey, effectiveEffort, effortPickerItems, foldCandidates, foldToggleKey, formatContext, formatDuration, formatTokens, hostOf, initialViewState, isGroupHeader, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, richPartsOf, shortenPath, shortId, skipGroupHeaders, slashCompletionCommands, summarizeToolArgs, validateEffortLevel, visibleGroupedItems, } 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. */
-class Picker {
+/**
+ * Inline selection list with type-to-filter, rendered above the editor.
+ *
+ * Grouped item builders (pluginCatalogItems) interleave their output with non-selectable
+ * `__group:` header items. Headers stay in the SelectList so they render, scroll and truncate
+ * like rows, but selection is owned here: navigation jumps over headers via skipGroupHeaders
+ * (wrapping both directions), Enter never fires onSelect for a header, and the whole display
+ * sequence is re-derived on every filter keystroke so headers of fully-filtered groups vanish.
+ */
+export class Picker {
     title;
+    onSelectItem;
+    onCancelPick;
     filterable;
     detail;
-    list;
+    list = new SelectList([], 1, selectListTheme);
     filter = "";
-    constructor(title, items, onSelect, onCancel, filterable = false, detail) {
+    /** Full item sequence (group headers + rows) before any filtering. */
+    allItems;
+    /** Display sequence: filtered rows plus the headers of groups that still match. */
+    items = [];
+    /** Selection index within `items`; always a real row, never a group header. */
+    index = 0;
+    /** Picker height target: counted on real rows only, so headers never stretch the list. */
+    maxVisible;
+    constructor(title, items, onSelectItem, onCancelPick, filterable = false, detail) {
         this.title = title;
+        this.onSelectItem = onSelectItem;
+        this.onCancelPick = onCancelPick;
         this.filterable = filterable;
         this.detail = detail;
-        this.list = new SelectList(items, Math.min(10, Math.max(1, items.length)), selectListTheme);
-        this.list.onSelect = onSelect;
-        this.list.onCancel = onCancel;
+        this.allItems = items;
+        this.maxVisible = Math.min(10, Math.max(1, items.filter((item) => !isGroupHeader(item)).length));
+        this.resetList();
+    }
+    /** Copies items, dimming group-header labels (style helpers stay plain under NO_COLOR). */
+    static displayItems(items) {
+        return items.map((item) => isGroupHeader(item) ? { ...item, label: style.gray(item.label) } : item);
+    }
+    /** (Re)builds the SelectList over the filtered display sequence; selection starts on a row. */
+    resetList() {
+        this.items = Picker.displayItems(this.filter ? visibleGroupedItems(this.allItems, this.filter) : this.allItems);
+        this.list = new SelectList(this.items, this.maxVisible, selectListTheme);
+        this.list.onSelect = (item) => {
+            if (!isGroupHeader(item))
+                this.onSelectItem(item);
+        };
+        this.list.onCancel = this.onCancelPick;
+        this.index = this.items.length ? skipGroupHeaders(this.items, -1, 1) : 0;
+        if (this.index < 0)
+            this.index = 0;
+        this.list.setSelectedIndex(this.index);
     }
     invalidate() {
         this.list.invalidate();
     }
+    /** The currently selected item — always a real row, never a group header. */
+    getSelectedItem() {
+        return this.items[this.index] ?? null;
+    }
     handleInput(data) {
         if (this.filterable && matchesKey(data, Key.backspace)) {
             this.filter = this.filter.slice(0, -1);
-            this.list.setFilter(this.filter);
+            this.resetList();
         }
         else if (this.filterable && data.length === 1 && data >= " " && data <= "~") {
             this.filter += data;
-            this.list.setFilter(this.filter);
+            this.resetList();
         }
-        else
+        else if (matchesKey(data, Key.up) || matchesKey(data, Key.down)) {
+            const dir = matchesKey(data, Key.down) ? 1 : -1;
+            this.index = this.items.length ? skipGroupHeaders(this.items, this.index, dir) : 0;
+            this.list.setSelectedIndex(this.index);
+        }
+        else if (matchesKey(data, Key.enter)) {
+            const item = this.items[this.index];
+            if (item && !isGroupHeader(item))
+                this.onSelectItem(item);
+        }
+        else if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+            this.onCancelPick();
+        }
+        else {
             this.list.handleInput(data);
+        }
     }
     render(width) {
         const hint = this.filterable
@@ -85,6 +141,7 @@ export async function runTui(options) {
     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,
@@ -92,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;
@@ -334,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);
@@ -493,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
@@ -1213,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());
@@ -1297,7 +1395,7 @@ export async function runTui(options) {
             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.`;
+        return `**Tools**\n\n| Tool | Effect | State |\n| --- | --- | --- |\n${rows}\n\n\`ask\` prompts before running (allow once / session / deny). Use --allow-write / --allow-process to pre-allow; --read-only disables them. Paths outside the workspace ask per directory; pre-allow with --add-dir or the \`additionalDirectories\` config key. \`internal\` tools (built-in plugins) only write Alisio's own state.`;
     };
     const statsReport = () => {
         const s = view.stats;

package/dist/tui/components.d.ts

@@ -129,6 +129,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

@@ -588,6 +588,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

@@ -39,11 +39,46 @@ export interface PluginCatalogView {
 }
 /** Text markers remain meaningful without color: [x] active, [ ] inactive, [!] failed, [*] pending. */
 /** Group headings are derived from the primary category (or "General") of each plugin. */
-export declare function pluginCatalogItems(entries: PluginCatalogView[]): {
+/**
+ * Reserved value prefix marking a non-selectable group-header row in picker item lists. It can
+ * never collide with real entry ids (plugin ids, server names), which never start with "_".
+ */
+export declare const GROUP_HEADER_PREFIX = "__group:";
+/** True when the item is a group header emitted under GROUP_HEADER_PREFIX (never selectable). */
+export declare const isGroupHeader: (item: {
+    value: string;
+}) => boolean;
+/**
+ * Nearest non-header index from `index` stepping `dir` (1 = down, -1 = up), wrapping at the
+ * edges exactly like a plain list would, so navigation skips header rows in both directions and
+ * never stops on one. Returns -1 for an empty list and `index` unchanged when every item is a
+ * header (callers then treat it as "no move").
+ */
+export declare function skipGroupHeaders(items: readonly {
+    value: string;
+}[], index: number, dir: 1 | -1): number;
+/**
+ * The display sequence a picker should render for a filter: rows matching SelectList's own
+ * prefix semantics, plus the group header of every group that still has at least one visible
+ * row, in original order. Groups with no match emit no header.
+ */
+export declare function visibleGroupedItems(items: ReadonlyArray<{
+    value: string;
+    label: string;
+    description?: string;
+}>, filter: string): Array<{
+    value: string;
+    label: string;
+    description?: string;
+}>;
+export declare function pluginCatalogItems(entries: PluginCatalogView[]): ({
+    value: string;
+    label: string;
+} | {
     value: string;
     label: string;
     description: string;
-}[];
+})[];
 export declare const pluginToggleNeedsConfirmation: (entry: PluginCatalogView) => boolean;
 export interface McpServerView {
     name: string;

package/dist/tui/state.js

@@ -24,6 +24,55 @@ export function providerModelItems(provider, models, current) {
 }
 /** Text markers remain meaningful without color: [x] active, [ ] inactive, [!] failed, [*] pending. */
 /** Group headings are derived from the primary category (or "General") of each plugin. */
+/**
+ * Reserved value prefix marking a non-selectable group-header row in picker item lists. It can
+ * never collide with real entry ids (plugin ids, server names), which never start with "_".
+ */
+export const GROUP_HEADER_PREFIX = "__group:";
+/** True when the item is a group header emitted under GROUP_HEADER_PREFIX (never selectable). */
+export const isGroupHeader = (item) => item.value.startsWith(GROUP_HEADER_PREFIX);
+/**
+ * Nearest non-header index from `index` stepping `dir` (1 = down, -1 = up), wrapping at the
+ * edges exactly like a plain list would, so navigation skips header rows in both directions and
+ * never stops on one. Returns -1 for an empty list and `index` unchanged when every item is a
+ * header (callers then treat it as "no move").
+ */
+export function skipGroupHeaders(items, index, dir) {
+    const count = items.length;
+    if (!count)
+        return -1;
+    let next = (index + dir + count) % count;
+    for (let steps = 0; steps < count && next !== index; steps++) {
+        if (!isGroupHeader(items[next]))
+            return next;
+        next = (next + dir + count) % count;
+    }
+    return index;
+}
+/**
+ * The display sequence a picker should render for a filter: rows matching SelectList's own
+ * prefix semantics, plus the group header of every group that still has at least one visible
+ * row, in original order. Groups with no match emit no header.
+ */
+export function visibleGroupedItems(items, filter) {
+    const query = filter.toLowerCase();
+    const visible = [];
+    let header;
+    for (const item of items) {
+        if (isGroupHeader(item)) {
+            header = item;
+            continue;
+        }
+        if (item.value.toLowerCase().startsWith(query)) {
+            if (header) {
+                visible.push(header);
+                header = undefined;
+            }
+            visible.push(item);
+        }
+    }
+    return visible;
+}
 export function pluginCatalogItems(entries) {
     const marker = (entry) => entry.status === "active"
         ? "[x]"
@@ -37,11 +86,15 @@ export function pluginCatalogItems(entries) {
         const primary = entry.categories[0] ?? "General";
         grouped.set(primary, [...(grouped.get(primary) ?? []), entry]);
     }
-    return [...grouped].flatMap(([title, group]) => group.map((entry, index) => ({
-        value: entry.id,
-        label: `${index === 0 ? `${title} · ` : ""}${marker(entry)} ${entry.name} · ${entry.builtin ? "built-in" : entry.source}`,
-        description: `${entry.status}${entry.categories.length ? ` · ${entry.categories.join(", ")}` : ""} · ${entry.description}`,
-    })));
+    // Every group opens with its own non-selectable header row; plugin rows are indented under it.
+    return [...grouped].flatMap(([title, group]) => [
+        { value: `${GROUP_HEADER_PREFIX}${title}`, label: `${title} ›` },
+        ...group.map((entry) => ({
+            value: entry.id,
+            label: `  ${marker(entry)} ${entry.name} · ${entry.builtin ? "built-in" : entry.source}`,
+            description: `${entry.status}${entry.categories.length ? ` · ${entry.categories.join(", ")}` : ""} · ${entry.description}`,
+        })),
+    ]);
 }
 export const pluginToggleNeedsConfirmation = (entry) => !entry.builtin;
 const mcpSourceTitle = (kind) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.18",
+  "version": "0.1.0-alpha.20",
   "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,11 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.16",
-    "@alisio/plugin-deepseek": "0.1.0-alpha.10",
+    "@alisio/core": "0.1.0-alpha.17",
     "@alisio/plugin-memory": "0.1.0-alpha.9",
     "@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.10",
-    "@alisio/sdk": "0.1.0-alpha.11",
+    "@alisio/sdk": "0.1.0-alpha.12",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },