@selesai/code 0.8.10 → 0.8.12

package/dist/core/tools/read-vision.test.js

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { captionImageWithModel } from "../vision-caption.js";
+import { captionImage } from "./read.js";
+const completeMock = vi.hoisted(() => vi.fn());
+vi.mock("@earendil-works/pi-ai/compat", async () => {
+    const actual = await vi.importActual("@earendil-works/pi-ai/compat");
+    return { ...actual, complete: completeMock };
+});
+const image = { type: "image", data: "aGVsbG8=", mimeType: "image/png" };
+function visionModel() {
+    return {
+        id: "kimi-k3",
+        name: "Kimi K3",
+        api: "openai-completions",
+        provider: "tokenin",
+        baseUrl: "https://example.com/v1",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 512000,
+        maxTokens: 64000,
+    };
+}
+function makeCtx() {
+    const find = vi.fn().mockReturnValue(visionModel());
+    const auth = vi.fn().mockResolvedValue({ ok: true, apiKey: "sk-test", headers: {} });
+    return {
+        ctx: {
+            model: { ...visionModel(), input: ["text"] },
+            modelRegistry: { find, getApiKeyAndHeaders: auth },
+        },
+        find,
+        auth,
+    };
+}
+describe("captionImage", () => {
+    beforeEach(() => {
+        completeMock.mockReset();
+    });
+    it("returns null when no caption model is configured", async () => {
+        const { ctx } = makeCtx();
+        const result = await captionImage(image, undefined, ctx, undefined);
+        expect(result).toBeNull();
+        expect(completeMock).not.toHaveBeenCalled();
+    });
+    it("returns null when the caption model cannot accept images", async () => {
+        const { ctx, find } = makeCtx();
+        find.mockReturnValue({ ...visionModel(), input: ["text"] });
+        const result = await captionImage(image, "tokenin/kimi-k3", ctx, undefined);
+        expect(result).toBeNull();
+        expect(completeMock).not.toHaveBeenCalled();
+    });
+    it("returns null when credentials are unavailable", async () => {
+        const { ctx, auth } = makeCtx();
+        auth.mockResolvedValue({ ok: false, error: "no key" });
+        const result = await captionImage(image, "tokenin/kimi-k3", ctx, undefined);
+        expect(result).toBeNull();
+    });
+    it("returns the caption text from the vision model", async () => {
+        completeMock.mockResolvedValue({
+            stopReason: "end_turn",
+            content: [{ type: "text", text: "A login form with a username field." }],
+        });
+        const { ctx, find } = makeCtx();
+        const result = await captionImage(image, "tokenin/kimi-k3", ctx, undefined);
+        expect(result).toBe("A login form with a username field.");
+        expect(find).toHaveBeenCalledWith("tokenin", "kimi-k3");
+        // The image block must be forwarded to the vision model.
+        const sentMessages = completeMock.mock.calls[0][1].messages;
+        expect(sentMessages[0].content).toContainEqual(image);
+    });
+    it("returns null and does not throw when the vision request errors", async () => {
+        completeMock.mockRejectedValue(new Error("boom"));
+        const { ctx } = makeCtx();
+        const result = await captionImage(image, "tokenin/kimi-k3", ctx, undefined);
+        expect(result).toBeNull();
+    });
+});
+describe("captionImageWithModel", () => {
+    beforeEach(() => {
+        completeMock.mockReset();
+    });
+    it("returns the caption text with a minimal context", async () => {
+        completeMock.mockResolvedValue({
+            stopReason: "end_turn",
+            content: [{ type: "text", text: "A red button labeled Save." }],
+        });
+        const result = await captionImageWithModel(visionModel(), image, {
+            apiKey: "sk-test",
+        });
+        expect(result).toBe("A red button labeled Save.");
+        const sentContext = completeMock.mock.calls[0][1];
+        // The caption request must not include any main-agent conversation history.
+        expect(sentContext.messages).toHaveLength(1);
+        expect(sentContext.messages[0].content).toContainEqual(image);
+        expect(completeMock.mock.calls[0][2]).toMatchObject({ apiKey: "sk-test" });
+    });
+    it("returns null on aborted stop reason", async () => {
+        completeMock.mockResolvedValue({ stopReason: "aborted", content: [] });
+        const result = await captionImageWithModel(visionModel(), image);
+        expect(result).toBeNull();
+    });
+    it("returns null on request failure", async () => {
+        completeMock.mockRejectedValue(new Error("network down"));
+        const result = await captionImageWithModel(visionModel(), image);
+        expect(result).toBeNull();
+    });
+    it("includes the user prompt and bounded context text", async () => {
+        completeMock.mockResolvedValue({
+            stopReason: "end_turn",
+            content: [{ type: "text", text: "A slider" }],
+        });
+        const result = await captionImageWithModel(visionModel(), image, {
+            userPrompt: "make this UI element bigger",
+            contextText: "User: we are fixing the settings panel",
+        });
+        expect(result).toBe("A slider");
+        const sentText = completeMock.mock.calls[0][1].messages[0].content[0].text;
+        expect(sentText).toContain("make this UI element bigger");
+        expect(sentText).toContain("we are fixing the settings panel");
+    });
+});

package/dist/core/tools/read.d.ts

@@ -1,6 +1,7 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { ImageContent } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
-import type { ToolDefinition } from "../extensions/types.ts";
+import type { ExtensionContext, ToolDefinition } from "../extensions/types.ts";
 import { type TruncationResult } from "./truncate.ts";
 declare const readSchema: Type.TObject<{
     path: Type.TString;
@@ -26,9 +27,20 @@ export interface ReadOperations {
 export interface ReadToolOptions {
     /** Whether to auto-resize images to 2000x2000 max. Default: true */
     autoResizeImages?: boolean;
+    /**
+     * Vision model ("provider/modelId") used to describe images when the active
+     * model cannot accept image input. The caption text is returned in place of
+     * the image block. Default: unset (images are omitted as before).
+     */
+    imageCaptionModel?: string;
     /** Custom operations for file reading. Default: local filesystem */
     operations?: ReadOperations;
 }
+/**
+ * Ask a vision model to describe an image. Returns the caption text, or null if
+ * the caption model/credentials are unavailable or the request fails.
+ */
+export declare function captionImage(image: ImageContent, captionModelId: string | undefined, ctx: ExtensionContext | undefined, signal: AbortSignal | undefined): Promise<string | null>;
 export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition<typeof readSchema, ReadToolDetails | undefined>;
 export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
 export {};

package/dist/core/tools/read.js

@@ -10,6 +10,7 @@ import { processImage } from "../../utils/image-process.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { formatPathRelativeToCwdOrAbsolute } from "../../utils/paths.js";
 import { getExperimentalToolSampling } from "../experimental.js";
+import { captionImageWithModel } from "../vision-caption.js";
 import { resolveReadPathAsync, resolveToCwd } from "./path-utils.js";
 import { getTextOutput, renderToolPath, replaceTabs, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -49,6 +50,36 @@ function getNonVisionImageNote(model) {
     }
     return "[Current model does not support images. The image will be omitted from this request.]";
 }
+/**
+ * Ask a vision model to describe an image. Returns the caption text, or null if
+ * the caption model/credentials are unavailable or the request fails.
+ */
+export async function captionImage(image, captionModelId, ctx, signal) {
+    if (!captionModelId || !ctx?.modelRegistry || !ctx.model)
+        return null;
+    const slash = captionModelId.indexOf("/");
+    if (slash <= 0 || slash === captionModelId.length - 1)
+        return null;
+    const provider = captionModelId.slice(0, slash);
+    const modelId = captionModelId.slice(slash + 1);
+    const captionModel = ctx.modelRegistry.find(provider, modelId);
+    if (!captionModel || !captionModel.input.includes("image"))
+        return null;
+    let auth;
+    try {
+        auth = await ctx.modelRegistry.getApiKeyAndHeaders(captionModel);
+    }
+    catch {
+        return null;
+    }
+    if (!auth.ok)
+        return null;
+    return captionImageWithModel(captionModel, image, {
+        apiKey: auth.apiKey,
+        headers: auth.headers,
+        signal,
+    });
+}
 function toPosixPath(filePath) {
     return filePath.split(sep).join("/");
 }
@@ -130,6 +161,7 @@ function formatReadResult(args, result, options, theme, showImages, _cwd, isErro
 }
 export function createReadToolDefinition(cwd, options) {
     const autoResizeImages = options?.autoResizeImages ?? true;
+    const imageCaptionModel = options?.imageCaptionModel;
     const ops = options?.operations ?? defaultReadOperations;
     return {
         name: "read",
@@ -178,11 +210,29 @@ export function createReadToolDefinition(cwd, options) {
                                 let textNote = `Read image file [${processed.mimeType}]`;
                                 if (processed.hints.length > 0)
                                     textNote += `\n${processed.hints.join("\n")}`;
+                                const image = { type: "image", data: processed.data, mimeType: processed.mimeType };
+                                // Vision relay: when the active model cannot accept images, ask a
+                                // configured vision model to describe the image and use that text instead.
+                                if (nonVisionImageNote) {
+                                    const caption = await captionImage(image, imageCaptionModel, ctx, signal);
+                                    if (caption) {
+                                        content = [
+                                            {
+                                                type: "text",
+                                                text: `Read image file [${processed.mimeType}] (described by vision model)\n${caption}`,
+                                            },
+                                        ];
+                                        if (aborted)
+                                            return;
+                                        resolve({ content, details });
+                                        return;
+                                    }
+                                }
                                 if (nonVisionImageNote)
                                     textNote += `\n${nonVisionImageNote}`;
                                 content = [
                                     { type: "text", text: textNote },
-                                    { type: "image", data: processed.data, mimeType: processed.mimeType },
+                                    image,
                                 ];
                             }
                         }

package/dist/core/vision-caption.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared vision-caption relay: ask a vision-capable model to describe an image
+ * as plain text, so a text-only main model can still work from it.
+ */
+import type { Api, ImageContent, Model, ProviderHeaders } from "@earendil-works/pi-ai";
+export declare const VISION_CAPTION_SYSTEM_PROMPT: string;
+export interface VisionCaptionRequestOptions {
+    apiKey?: string;
+    headers?: ProviderHeaders;
+    signal?: AbortSignal;
+    /** Called with the underlying error message when the caption request fails. */
+    onError?: (message: string) => void;
+    /**
+     * The user's current instruction (e.g. "make this UI element bigger").
+     * Included so the caption is targeted at the task, not generic.
+     */
+    userPrompt?: string;
+    /**
+     * A small, already-bounded slice of recent conversation text (or other relevant
+     * context) to help the caption model understand intent. Must be small enough to
+     * stay safely under the caption model's context window. Omit for none.
+     */
+    contextText?: string;
+}
+/**
+ * Ask a vision model to describe an image. Returns the caption text, or null if
+ * the request fails or is aborted. The request context is minimal (prompt +
+ * image only), so it is independent of any main-agent context usage.
+ */
+export declare function captionImageWithModel(captionModel: Model<Api>, image: ImageContent, options?: VisionCaptionRequestOptions): Promise<string | null>;

package/dist/core/vision-caption.js

@@ -0,0 +1,62 @@
+/**
+ * Shared vision-caption relay: ask a vision-capable model to describe an image
+ * as plain text, so a text-only main model can still work from it.
+ */
+import { complete } from "@earendil-works/pi-ai/compat";
+export const VISION_CAPTION_SYSTEM_PROMPT = "You are an image captioner for a coding agent whose main model cannot see images. " +
+    "Describe the image as completely and precisely as possible in plain text so that a programmer " +
+    "can work from your description alone, as if looking at the image themselves. " +
+    "Read any visible text, code, UI labels, error messages, terminal output, or diagrams verbatim. " +
+    "Cover layout, colors, spatial relationships, relative positions and sizes of elements, " +
+    "window or panel structure, and anything relevant to debugging or implementing. " +
+    "When a simple ASCII sketch clarifies the layout, include it.";
+function buildUserPrompt(userPrompt, contextText) {
+    const lines = [];
+    if (userPrompt) {
+        lines.push(`The user said:\n${userPrompt}`);
+    }
+    if (contextText) {
+        lines.push(`Relevant context (recent conversation):\n${contextText}`);
+    }
+    lines.push("Describe this image in detail:");
+    return lines.join("\n\n");
+}
+/**
+ * Ask a vision model to describe an image. Returns the caption text, or null if
+ * the request fails or is aborted. The request context is minimal (prompt +
+ * image only), so it is independent of any main-agent context usage.
+ */
+export async function captionImageWithModel(captionModel, image, options) {
+    const aiContext = {
+        systemPrompt: VISION_CAPTION_SYSTEM_PROMPT,
+        messages: [
+            {
+                role: "user",
+                timestamp: Date.now(),
+                content: [
+                    { type: "text", text: buildUserPrompt(options?.userPrompt, options?.contextText) },
+                    image,
+                ],
+            },
+        ],
+    };
+    try {
+        const response = await complete(captionModel, aiContext, {
+            apiKey: options?.apiKey,
+            headers: options?.headers,
+            signal: options?.signal,
+        });
+        if (response.stopReason === "aborted")
+            return null;
+        const text = response.content
+            .filter((c) => c.type === "text")
+            .map((c) => c.text)
+            .join("\n")
+            .trim();
+        return text.length > 0 ? text : null;
+    }
+    catch (error) {
+        options?.onError?.(error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}

package/dist/defaults/models.json

@@ -24,11 +24,22 @@
             "high": null,
             "xhigh": null,
             "max": "max"
-          },
-          "compat": {
-            "supportsDeveloperRole": false,
-            "requiresReasoningContentOnAssistantMessages": true,
-            "thinkingFormat": "deepseek"
+          }
+        },
+        {
+          "id": "auto-premium",
+          "name": "Auto Premium",
+          "reasoning": true,
+          "input": ["text"],
+          "contextWindow": 512000,
+          "maxTokens": 64000,
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": null,
+            "medium": null,
+            "high": null,
+            "xhigh": null,
+            "max": "max"
           }
         },
         {
@@ -132,6 +143,18 @@
             "supportsDeveloperRole": false,
             "supportsReasoningEffort": true
           }
+        },
+        {
+          "id": "gemma-4",
+          "name": "Gemma 4 31B (Vision)",
+          "reasoning": false,
+          "input": ["text", "image"],
+          "contextWindow": 256000,
+          "maxTokens": 8192,
+          "compat": {
+            "supportsDeveloperRole": false,
+            "supportsReasoningEffort": false
+          }
         }
       ]
     }

package/dist/extensions/model-prompt-injector/config.json

@@ -1,7 +1,7 @@
 {
   "rules": [
     {
-      "match": ["deepseek-v4-pro"],
+      "match": ["deepseek-v4-*"],
       "mode": "prepend",
       "prompt": "text: You are a helpful software engineer assistant.\n\ndescription: Bootstrap with shell/read, then expose the full Standard tool catalog after the first durable tool call.\n\nwhen you thought, start with `we need...`",
       "enabled": true

package/dist/modes/interactive/components/settings-selector.d.ts

@@ -3,6 +3,13 @@ import type { Transport } from "@earendil-works/pi-ai";
 import { Container, type ScrollViewScrollbar, SettingsList } from "@earendil-works/pi-tui";
 import type { DefaultProjectTrust, FullscreenExitOutput, TuiMode, WarningSettings } from "../../../core/settings-manager.ts";
 import { type TerminalTheme } from "../theme/theme.ts";
+export interface SkillToggleItem {
+    name: string;
+    enabled: boolean;
+    pattern: string;
+    scope: "user" | "project";
+    id: string;
+}
 export interface SettingsConfig {
     autoCompact: boolean;
     autoHandoffEnabled: boolean;
@@ -11,6 +18,9 @@ export interface SettingsConfig {
     imageWidthCells: number;
     autoResizeImages: boolean;
     blockImages: boolean;
+    imageCaptionModel: string | undefined;
+    imageCaptionContextTokens: number;
+    visionModels: string[];
     steeringMode: "all" | "one-at-a-time";
     followUpMode: "all" | "one-at-a-time";
     transport: Transport;
@@ -38,6 +48,7 @@ export interface SettingsConfig {
     fullscreenExitOutput: FullscreenExitOutput;
     fullscreenScrollbar: ScrollViewScrollbar;
     warnings: WarningSettings;
+    skills: SkillToggleItem[];
 }
 export interface SettingsCallbacks {
     onAutoCompactChange: (enabled: boolean) => void;
@@ -47,6 +58,8 @@ export interface SettingsCallbacks {
     onImageWidthCellsChange: (width: number) => void;
     onAutoResizeImagesChange: (enabled: boolean) => void;
     onBlockImagesChange: (blocked: boolean) => void;
+    onImageCaptionModelChange: (modelId: string | undefined) => void;
+    onImageCaptionContextTokensChange: (tokens: number) => void;
     onSteeringModeChange: (mode: "all" | "one-at-a-time") => void;
     onFollowUpModeChange: (mode: "all" | "one-at-a-time") => void;
     onTransportChange: (transport: Transport) => void;
@@ -72,6 +85,8 @@ export interface SettingsCallbacks {
     onFullscreenExitOutputChange: (output: FullscreenExitOutput) => void;
     onFullscreenScrollbarChange: (mode: ScrollViewScrollbar) => void;
     onWarningsChange: (warnings: WarningSettings) => void;
+    onSkillsToggle: (item: SkillToggleItem, enabled: boolean) => void;
+    onSkillsReload: () => void;
     onCancel: () => void;
 }
 /**

package/dist/modes/interactive/components/settings-selector.js

@@ -22,6 +22,46 @@ const DEFAULT_PROJECT_TRUST_LABELS = {
     never: "Never trust",
 };
 const DEFAULT_PROJECT_TRUST_BY_LABEL = new Map(Object.entries(DEFAULT_PROJECT_TRUST_LABELS).map(([value, label]) => [label, value]));
+class SkillsSubmenu extends Container {
+    settingsList;
+    constructor(skills, onToggle, onCancel) {
+        super();
+        const initial = skills.map((s) => ({ ...s }));
+        const nameCounts = new Map();
+        for (const skill of initial) {
+            nameCounts.set(skill.name, (nameCounts.get(skill.name) ?? 0) + 1);
+        }
+        const items = initial.map((skill) => ({
+            id: skill.id,
+            label: (nameCounts.get(skill.name) ?? 0) > 1 ? `${skill.name} (${skill.pattern})` : skill.name,
+            description: `Scope: ${skill.scope}${(nameCounts.get(skill.name) ?? 0) > 1 ? ` — ${skill.pattern}` : ""}`,
+            currentValue: skill.enabled ? "true" : "false",
+            values: ["true", "false"],
+        }));
+        if (items.length === 0) {
+            items.push({
+                id: "no-skills",
+                label: "No skills discovered",
+                currentValue: "",
+            });
+        }
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
+            const skill = initial.find((s) => s.id === id);
+            if (skill) {
+                const enabled = newValue === "true";
+                skill.enabled = enabled;
+                const source = skills.find((s) => s.id === id);
+                if (source)
+                    source.enabled = enabled;
+                onToggle(skill, enabled);
+            }
+        }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
 /**
  * A submenu component for selecting from a list of options.
  */
@@ -272,6 +312,7 @@ export class SettingsSelectorComponent extends Container {
         const supportsImages = getCapabilities().images;
         const followUpKey = keyDisplayText("app.message.followUp");
         let currentWarnings = { ...config.warnings };
+        let skillsChanged = false;
         const items = [
             {
                 id: "autocompact",
@@ -378,6 +419,16 @@ export class SettingsSelectorComponent extends Container {
                 currentValue: config.treeFilterMode,
                 values: ["default", "no-tools", "user-only", "labeled-only", "all"],
             },
+            {
+                id: "skills",
+                label: "Skills",
+                description: "Choose which skills are loaded (opt-in). Skills apply and reload when you close this menu.",
+                currentValue: `${config.skills.filter((s) => s.enabled).length}/${config.skills.length} enabled`,
+                submenu: (_currentValue, done) => new SkillsSubmenu(config.skills, (item, enabled) => {
+                    callbacks.onSkillsToggle(item, enabled);
+                    skillsChanged = true;
+                }, () => done()),
+            },
             {
                 id: "warnings",
                 label: "Warnings",
@@ -466,9 +517,30 @@ export class SettingsSelectorComponent extends Container {
             currentValue: config.blockImages ? "true" : "false",
             values: ["true", "false"],
         });
-        // Hardware cursor toggle (insert after block-images)
+        // Vision caption model picker (image -> text relay for text-only main models).
+        // Values are the available vision-capable models plus "off" for none.
+        const visionModelValues = ["off", ...config.visionModels];
+        const currentCaptionModel = config.imageCaptionModel ?? "off";
         const blockImagesIndex = items.findIndex((item) => item.id === "block-images");
         items.splice(blockImagesIndex + 1, 0, {
+            id: "image-caption-model",
+            label: "Vision caption model",
+            description: "Model used to describe images when the main model can't see them (off disables)",
+            currentValue: currentCaptionModel,
+            values: visionModelValues,
+        });
+        // Vision caption context-token budget
+        const captionModelIndex = items.findIndex((item) => item.id === "image-caption-model");
+        items.splice(captionModelIndex + 1, 0, {
+            id: "image-caption-context-tokens",
+            label: "Vision context tokens",
+            description: "Budget (approx) for recent-conversation context sent to the vision model",
+            currentValue: String(config.imageCaptionContextTokens),
+            values: ["0", "4096", "16384", "32768", "65536"],
+        });
+        // Hardware cursor toggle (insert after the image-caption settings)
+        const visionSettingsIndex = items.findIndex((item) => item.id === "image-caption-context-tokens");
+        items.splice(visionSettingsIndex + 1, 0, {
             id: "show-hardware-cursor",
             label: "Show hardware cursor",
             description: "Show the terminal cursor while still positioning it for IME support",
@@ -545,6 +617,12 @@ export class SettingsSelectorComponent extends Container {
                 case "block-images":
                     callbacks.onBlockImagesChange(newValue === "true");
                     break;
+                case "image-caption-model":
+                    callbacks.onImageCaptionModelChange(newValue === "off" ? undefined : newValue);
+                    break;
+                case "image-caption-context-tokens":
+                    callbacks.onImageCaptionContextTokensChange(parseInt(newValue, 10) || 0);
+                    break;
                 case "steering-mode":
                     callbacks.onSteeringModeChange(newValue);
                     break;
@@ -620,7 +698,12 @@ export class SettingsSelectorComponent extends Container {
                     callbacks.onThemeChange(newValue);
                     break;
             }
-        }, callbacks.onCancel, { enableSearch: true });
+        }, () => {
+            if (skillsChanged) {
+                callbacks.onSkillsReload();
+            }
+            callbacks.onCancel();
+        }, { enableSearch: true });
         this.addChild(this.settingsList);
         this.addChild(new DynamicBorder());
     }

package/dist/modes/interactive/components/status-indicator.d.ts

@@ -1,6 +1,6 @@
 import { type Component, Loader, type TUI } from "@earendil-works/pi-tui";
 import type { WorkingIndicatorOptions } from "../../../core/extensions/index.ts";
-export type StatusIndicatorKind = "working" | "retry" | "compaction" | "branchSummary";
+export type StatusIndicatorKind = "working" | "retry" | "compaction" | "branchSummary" | "imageCaptioning";
 export declare class StatusIndicator extends Loader {
     readonly kind: StatusIndicatorKind;
     constructor(kind: StatusIndicatorKind, ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message: string, indicator?: WorkingIndicatorOptions);
@@ -9,6 +9,9 @@ export declare class StatusIndicator extends Loader {
 export declare class WorkingStatusIndicator extends StatusIndicator {
     constructor(ui: TUI, message: string, indicator?: WorkingIndicatorOptions);
 }
+export declare class ImageCaptioningStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI);
+}
 export declare class RetryStatusIndicator extends StatusIndicator {
     private countdown;
     constructor(ui: TUI, attempt: number, maxAttempts: number, delayMs: number);

package/dist/modes/interactive/components/status-indicator.js

@@ -17,6 +17,11 @@ export class WorkingStatusIndicator extends StatusIndicator {
         super("working", ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), message, indicator);
     }
 }
+export class ImageCaptioningStatusIndicator extends StatusIndicator {
+    constructor(ui) {
+        super("imageCaptioning", ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), "Reading image with vision model...");
+    }
+}
 export class RetryStatusIndicator extends StatusIndicator {
     countdown;
     constructor(ui, attempt, maxAttempts, delayMs) {

package/dist/modes/interactive/interactive-mode.d.ts

@@ -373,6 +373,10 @@ export declare class InteractiveMode {
      */
     private showSelector;
     private showSettingsSelector;
+    private getVisionModels;
+    private buildSkillToggleItems;
+    private toggleSkillSetting;
+    private reloadAfterSkillChange;
     private handleModelCommand;
     private findExactModelMatch;
     private getModelCandidates;