@pencil-agent/nano-pencil 1.11.32 → 1.11.33

package/dist/core/model-registry.d.ts

@@ -83,6 +83,15 @@ export declare class ModelRegistry {
      */
     registerProvider(providerName: string, config: ProviderConfigInput): void;
     private applyProviderConfig;
+    private static readonly OPENROUTER_JSON_BASE;
+    private static readonly OPENROUTER_JSON_API;
+    /**
+     * Append an OpenRouter model to models.json by id (same string as on openrouter.ai, e.g. x-ai/grok-4.20).
+     * API key is not written; use /login openrouter or OPENROUTER_API_KEY.
+     */
+    appendOpenRouterModel(modelId: string, options?: {
+        name?: string;
+    }): void;
 }
 /**
  * Input type for registerProvider API.

package/dist/core/model-registry.js

@@ -7,7 +7,7 @@
 import { getModels, getProviders, registerApiProvider, registerOAuthProvider, } from "@pencil-agent/ai";
 import { Type } from "@sinclair/typebox";
 import AjvModule from "ajv";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { getAgentDir } from "../config.js";
 import { clearConfigValueCache, resolveConfigValue, resolveHeaders } from "./config/resolve-config-value.js";
@@ -536,5 +536,54 @@ export class ModelRegistry {
             });
         }
     }
+    static OPENROUTER_JSON_BASE = "https://openrouter.ai/api/v1";
+    static OPENROUTER_JSON_API = "openai-completions";
+    /**
+     * Append an OpenRouter model to models.json by id (same string as on openrouter.ai, e.g. x-ai/grok-4.20).
+     * API key is not written; use /login openrouter or OPENROUTER_API_KEY.
+     */
+    appendOpenRouterModel(modelId, options) {
+        const providerKey = "openrouter";
+        const trimmed = modelId.trim();
+        if (!trimmed) {
+            throw new Error("OpenRouter model id cannot be empty");
+        }
+        const modelsPath = this.modelsJsonPath;
+        if (!modelsPath) {
+            throw new Error("models.json path is not configured");
+        }
+        let data;
+        if (existsSync(modelsPath)) {
+            const raw = readFileSync(modelsPath, "utf-8");
+            data = JSON.parse(raw);
+        }
+        else {
+            data = { providers: {} };
+        }
+        if (!data.providers || typeof data.providers !== "object") {
+            data.providers = {};
+        }
+        const existing = data.providers[providerKey] ?? {};
+        const prevModels = Array.isArray(existing.models) ? [...existing.models] : [];
+        if (prevModels.some((m) => m && typeof m === "object" && m.id === trimmed)) {
+            throw new Error(`OpenRouter model "${trimmed}" already exists in models.json`);
+        }
+        const displayName = options?.name?.trim() || trimmed;
+        prevModels.push({
+            id: trimmed,
+            name: displayName,
+            input: ["text"],
+            contextWindow: 256000,
+            maxTokens: 8192,
+        });
+        data.providers[providerKey] = {
+            ...existing,
+            baseUrl: existing.baseUrl ?? ModelRegistry.OPENROUTER_JSON_BASE,
+            api: existing.api ?? ModelRegistry.OPENROUTER_JSON_API,
+            models: prevModels,
+        };
+        writeFileSync(modelsPath, JSON.stringify(data, null, 2), "utf-8");
+        this.refresh();
+    }
 }
 //# sourceMappingURL=model-registry.js.map

package/dist/modes/interactive/components/custom-editor.d.ts

@@ -1,6 +1,6 @@
 /**
- * [UPSTREAM]: Depends on @pencil-agent/tui
- * [SURFACE]: CustomEditor
+ * [UPSTREAM]:
+ * [SURFACE]:
  * [LOCUS]: modes/interactive/components/custom-editor.ts -
  * [COVENANT]: Change → update this header
  */
@@ -17,6 +17,8 @@ export declare class CustomEditor extends Editor {
     onPasteImage?: () => void;
     /** Handler for extension-registered shortcuts. Returns true if handled. */
     onExtensionShortcut?: (data: string) => boolean;
+    /** Handler for attachment navigation (arrow keys, delete). Returns true if handled. */
+    onAttachmentKey?: (data: string) => boolean;
     constructor(tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: EditorOptions);
     /**
      * Register a handler for an app action.

package/dist/modes/interactive/components/custom-editor.js

@@ -1,10 +1,10 @@
 /**
- * [UPSTREAM]: Depends on @pencil-agent/tui
- * [SURFACE]: CustomEditor
+ * [UPSTREAM]:
+ * [SURFACE]:
  * [LOCUS]: modes/interactive/components/custom-editor.ts -
  * [COVENANT]: Change → update this header
  */
-import { Editor } from "@pencil-agent/tui";
+import { Editor, getEditorKeybindings, matchesKey } from "@pencil-agent/tui";
 /**
  * Custom editor that handles app-level keybindings for coding-agent.
  */
@@ -17,6 +17,8 @@ export class CustomEditor extends Editor {
     onPasteImage;
     /** Handler for extension-registered shortcuts. Returns true if handled. */
     onExtensionShortcut;
+    /** Handler for attachment navigation (arrow keys, delete). Returns true if handled. */
+    onAttachmentKey;
     constructor(tui, theme, keybindings, options) {
         super(tui, theme, options);
         this.keybindings = keybindings;
@@ -32,10 +34,19 @@ export class CustomEditor extends Editor {
         if (this.onExtensionShortcut?.(data)) {
             return;
         }
-        // Check for paste image keybinding
-        if (this.keybindings.matches(data, "pasteImage")) {
-            this.onPasteImage?.();
-            return;
+        // Detect image paste via empty bracketed paste — the terminal sends an
+        // empty bracket sequence when the clipboard contains an image (since
+        // raw image bytes can't be pasted as text).  This is the ONLY trigger
+        // for clipboard image reading; we intentionally do NOT intercept the
+        // raw Ctrl+V key code because Windows keeps stale image data in the
+        // clipboard even after the user copies text, which would cause the
+        // wrong content to be pasted.
+        if (this.onPasteImage && data.includes("\x1b[200~") && data.includes("\x1b[201~")) {
+            const content = data.replace("\x1b[200~", "").replace("\x1b[201~", "").trim();
+            if (content.length === 0) {
+                this.onPasteImage();
+                return;
+            }
         }
         // Check app keybindings first
         // Escape/interrupt - only if autocomplete is NOT active
@@ -69,6 +80,21 @@ export class CustomEditor extends Editor {
                 return;
             }
         }
+        // Forward navigation/delete keys to the attachment handler. The handler
+        // only consumes them when appropriate (e.g. Delete only when an
+        // attachment is selected), otherwise returns false so the editor
+        // processes the key normally.
+        if (this.onAttachmentKey) {
+            const kb = getEditorKeybindings();
+            if (kb.matches(data, "cursorUp") ||
+                kb.matches(data, "cursorDown") ||
+                matchesKey(data, "delete") ||
+                matchesKey(data, "backspace")) {
+                if (this.onAttachmentKey(data)) {
+                    return;
+                }
+            }
+        }
         // Pass to parent for editor handling
         super.handleInput(data);
     }

package/dist/modes/interactive/components/index.d.ts

@@ -5,6 +5,7 @@
  * [COVENANT]: Change components → update this header
  */
 export { ArminComponent } from "./armin.js";
+export { AttachmentsBarComponent } from "./attachments-bar.js";
 export { AssistantMessageComponent } from "./assistant-message.js";
 export { promptForApiKey } from "./apikey-input.js";
 export { BashExecutionComponent } from "./bash-execution.js";

package/dist/modes/interactive/components/index.js

@@ -6,6 +6,7 @@
  */
 // UI Components for extensions
 export { ArminComponent } from "./armin.js";
+export { AttachmentsBarComponent } from "./attachments-bar.js";
 export { AssistantMessageComponent } from "./assistant-message.js";
 export { promptForApiKey } from "./apikey-input.js";
 export { BashExecutionComponent } from "./bash-execution.js";

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

@@ -35,9 +35,11 @@ export declare class ModelSelectorComponent extends Container implements Focusab
     private scopeText?;
     private scopeHintText?;
     private filterByProvider?;
+    /** When set, Ctrl+N runs this (parent closes selector and prompts for OpenRouter model id). */
+    private onAddOpenRouterModel?;
     get focused(): boolean;
     set focused(value: boolean);
-    constructor(tui: TUI, currentModel: Model<any> | undefined, settingsManager: SettingsManager, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, ensureProviderConfigured: EnsureProviderConfigured | undefined, onSelect: (model: Model<any>) => void, onCancel: () => void, initialSearchInput?: string, filterByProvider?: string);
+    constructor(tui: TUI, currentModel: Model<any> | undefined, settingsManager: SettingsManager, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, ensureProviderConfigured: EnsureProviderConfigured | undefined, onSelect: (model: Model<any>) => void, onCancel: () => void, initialSearchInput?: string, filterByProvider?: string, onAddOpenRouterModel?: () => void);
     private loadModels;
     private sortModels;
     private getScopeText;

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

@@ -5,7 +5,7 @@
  * [COVENANT]: Change → update this header
  */
 import { modelsAreEqual } from "@pencil-agent/ai";
-import { Container, fuzzyFilter, getEditorKeybindings, Input, Spacer, Text, } from "@pencil-agent/tui";
+import { Container, fuzzyFilter, getEditorKeybindings, Input, matchesKey, Spacer, Text, } from "@pencil-agent/tui";
 import { theme } from "../theme/theme.js";
 import { promptForApiKey } from "./apikey-input.js";
 import { DynamicBorder } from "./dynamic-border.js";
@@ -32,6 +32,8 @@ export class ModelSelectorComponent extends Container {
     scopeText;
     scopeHintText;
     filterByProvider;
+    /** When set, Ctrl+N runs this (parent closes selector and prompts for OpenRouter model id). */
+    onAddOpenRouterModel;
     get focused() {
         return this._focused;
     }
@@ -39,7 +41,7 @@ export class ModelSelectorComponent extends Container {
         this._focused = value;
         this.searchInput.focused = value;
     }
-    constructor(tui, currentModel, settingsManager, modelRegistry, scopedModels, ensureProviderConfigured, onSelect, onCancel, initialSearchInput, filterByProvider) {
+    constructor(tui, currentModel, settingsManager, modelRegistry, scopedModels, ensureProviderConfigured, onSelect, onCancel, initialSearchInput, filterByProvider, onAddOpenRouterModel) {
         super();
         this.tui = tui;
         this.currentModel = currentModel;
@@ -48,6 +50,7 @@ export class ModelSelectorComponent extends Container {
         this.scopedModels = scopedModels;
         this.ensureProviderConfigured = ensureProviderConfigured;
         this.filterByProvider = filterByProvider;
+        this.onAddOpenRouterModel = onAddOpenRouterModel;
         this.scope = scopedModels.length > 0 && !filterByProvider ? "scoped" : "all";
         this.onSelectCallback = onSelect;
         this.onCancelCallback = onCancel;
@@ -73,6 +76,10 @@ export class ModelSelectorComponent extends Container {
             }
         };
         this.addChild(this.searchInput);
+        if (this.onAddOpenRouterModel) {
+            this.addChild(new Spacer(1));
+            this.addChild(new Text(theme.fg("muted", "Ctrl+N: add OpenRouter model by id (same as openrouter.ai)"), 0, 0));
+        }
         this.addChild(new Spacer(1));
         this.listContainer = new Container();
         this.addChild(this.listContainer);
@@ -255,6 +262,9 @@ export class ModelSelectorComponent extends Container {
         else if (kb.matches(keyData, "selectCancel")) {
             this.onCancelCallback();
         }
+        else if (this.onAddOpenRouterModel && matchesKey(keyData, "ctrl+n")) {
+            this.onAddOpenRouterModel();
+        }
         else {
             this.searchInput.handleInput(keyData);
             this.filterModels(this.searchInput.getValue());

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

@@ -19,6 +19,8 @@ export interface InteractiveModeOptions {
 }
 export declare class InteractiveMode {
     private options;
+    private static clipboardImageSeq;
+    private clipboardImageFiles;
     private session;
     private ui;
     private chatContainer;
@@ -71,6 +73,10 @@ export declare class InteractiveMode {
     private headerContainer;
     private builtInHeader;
     private customHeader;
+    private attachments;
+    private selectedAttachmentIndex;
+    private attachmentsContainer;
+    private attachmentsBar;
     private get agent();
     private get sessionManager();
     private get settingsManager();
@@ -194,7 +200,6 @@ export declare class InteractiveMode {
      * Show a notification for extensions.
      */
     private showExtensionNotify;
-    private isMemoryTraceMessage;
     private shouldRenderToolTrace;
     private hasActiveExtensionPrompt;
     private restoreEditorFocusIfPossible;
@@ -210,12 +215,22 @@ export declare class InteractiveMode {
     private showExtensionError;
     private setupKeyHandlers;
     private handleClipboardImagePaste;
+    private updateAttachmentsBar;
+    private deleteAttachment;
+    private handleAttachmentKeyNavigation;
+    /**
+     * Convert attachment files to ImageContent array for sending to the model.
+     * Reads each file, base64-encodes, and resizes.
+     */
+    private processAttachmentFiles;
     /**
      * Extract image file paths from text, read them as base64 ImageContent,
      * and return the cleaned text with image references plus the image array.
      */
     private extractImagesFromText;
     private setupEditorSubmitHandler;
+    private cleanupStaleClipboardFiles;
+    private cleanupClipboardImages;
     private subscribeToAgent;
     private addSessionNavigationBanner;
     private handleEvent;

package/dist/modes/interactive/interactive-mode.js

@@ -1,10 +1,3 @@
-/**
- * [UPSTREAM]: Depends on agent-core, ai, tui, core/* (session, model, config, tools)
- * [SURFACE]: InteractiveMode class, runInteractiveMode()
- * [LOCUS]: modes/interactive/interactive-mode.ts - TUI orchestration hub
- * [COVENANT]: Change TUI behavior → update P2 modes/CLAUDE.md
- */
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -31,6 +24,7 @@ import { ensureTool } from "../../core/utils/tools-manager.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize.js";
 import { ArminComponent } from "./components/armin.js";
+import { AttachmentsBarComponent } from "./components/attachments-bar.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BorderedLoader } from "./components/bordered-loader.js";
@@ -68,6 +62,8 @@ function isExpandable(obj) {
 }
 export class InteractiveMode {
     options;
+    static clipboardImageSeq = 0;
+    clipboardImageFiles = [];
     session;
     ui;
     chatContainer;
@@ -141,6 +137,11 @@ export class InteractiveMode {
     builtInHeader = undefined;
     // Custom header from extension (undefined = use built-in header)
     customHeader = undefined;
+    // Attachments state
+    attachments = [];
+    selectedAttachmentIndex = -1;
+    attachmentsContainer = undefined;
+    attachmentsBar = undefined;
     // Convenience accessors
     get agent() {
         return this.session.agent;
@@ -172,6 +173,8 @@ export class InteractiveMode {
         });
         this.editor = this.defaultEditor;
         this.editorContainer = new Container();
+        this.attachmentsContainer = new Container();
+        this.editorContainer.addChild(this.attachmentsContainer);
         this.editorContainer.addChild(this.editor);
         this.footerDataProvider = new FooterDataProvider(session.cwd);
         this.footer = new FooterComponent(session, this.footerDataProvider, this.settingsManager.getShowTokenStats());
@@ -255,6 +258,8 @@ export class InteractiveMode {
     async init() {
         if (this.isInitialized)
             return;
+        // Clean up stale clipboard image files from previous sessions
+        this.cleanupStaleClipboardFiles();
         // Do not show changelog on startup; version check will prompt to update CLI when newer version exists
         // Ensure fd and rg are available (downloads if missing, adds to PATH via getBinDir)
         // Both are needed: fd for autocomplete, rg for grep tool and bash commands
@@ -1345,11 +1350,6 @@ export class InteractiveMode {
      * Show a notification for extensions.
      */
     showExtensionNotify(message, type) {
-        if (type !== "error" &&
-            this.isMemoryTraceMessage(message) &&
-            !this.settingsManager.getShowMemoryTrace()) {
-            return;
-        }
         if (type === "error") {
             this.showError(message);
         }
@@ -1360,9 +1360,6 @@ export class InteractiveMode {
             this.showStatus(message);
         }
     }
-    isMemoryTraceMessage(message) {
-        return message.startsWith("NanoMem");
-    }
     shouldRenderToolTrace(toolName) {
         if (toolName.startsWith("nanomem_")) {
             return this.settingsManager.getShowMemoryTrace();
@@ -1544,6 +1541,9 @@ export class InteractiveMode {
             if (this.loadingAnimation) {
                 this.restoreQueuedMessagesToEditor({ abort: true });
             }
+            else if (this.session.isStreaming) {
+                this.agent.abort();
+            }
             else if (this.session.isBashRunning) {
                 this.session.abortBash();
             }
@@ -1604,6 +1604,10 @@ export class InteractiveMode {
         this.defaultEditor.onPasteImage = () => {
             this.handleClipboardImagePaste();
         };
+        // Handle attachment navigation keys (arrow keys, delete)
+        this.defaultEditor.onAttachmentKey = (data) => {
+            return this.handleAttachmentKeyNavigation(data);
+        };
     }
     async handleClipboardImagePaste() {
         try {
@@ -1611,20 +1615,138 @@ export class InteractiveMode {
             if (!image) {
                 return;
             }
-            // Write to temp file
-            const tmpDir = os.tmpdir();
+            // Save to a dedicated _paste/ directory so the model finds ONLY
+            // the clipboard image when browsing (avoids confusion with other
+            // image files like IMG_*.JPG in the project root).
             const ext = extensionForImageMimeType(image.mimeType) ?? "png";
-            const fileName = `pi-clipboard-${crypto.randomUUID()}.${ext}`;
-            const filePath = path.join(tmpDir, fileName);
+            const seq = ++InteractiveMode.clipboardImageSeq;
+            const fileName = `image_${seq}.${ext}`;
+            const pasteDir = path.join(this.session.cwd, "_paste");
+            fs.mkdirSync(pasteDir, { recursive: true });
+            const filePath = path.join(pasteDir, fileName);
             fs.writeFileSync(filePath, Buffer.from(image.bytes));
-            // Insert file path directly
-            this.editor.insertTextAtCursor?.(filePath);
+            // Track for cleanup and add to attachments list
+            this.clipboardImageFiles.push(filePath);
+            this.attachments.push({ path: filePath, mimeType: image.mimeType });
+            this.updateAttachmentsBar();
             this.ui.requestRender();
         }
         catch {
             // Silently ignore clipboard errors (may not have permission, etc.)
         }
     }
+    updateAttachmentsBar() {
+        if (!this.attachmentsContainer)
+            return;
+        this.attachmentsContainer.clear();
+        if (this.attachments.length === 0) {
+            this.attachmentsBar = undefined;
+            this.editorContainer.removeChild(this.attachmentsContainer);
+            return;
+        }
+        // Ensure attachmentsContainer is placed before the editor in the layout
+        if (!this.editorContainer.children.includes(this.attachmentsContainer)) {
+            const editorIdx = this.editorContainer.children.indexOf(this.editor);
+            if (editorIdx >= 0) {
+                this.editorContainer.children.splice(editorIdx, 0, this.attachmentsContainer);
+            }
+            else {
+                this.editorContainer.addChild(this.attachmentsContainer);
+            }
+        }
+        const themeName = this.settingsManager.getTheme();
+        const theme = getThemeByName(themeName || "dark") ?? getThemeByName("dark");
+        this.attachmentsBar = new AttachmentsBarComponent(this.attachments, this.selectedAttachmentIndex, theme);
+        this.attachmentsContainer.addChild(this.attachmentsBar);
+    }
+    deleteAttachment(index) {
+        if (index < 0 || index >= this.attachments.length)
+            return;
+        // Remove the attachment file
+        const attachment = this.attachments[index];
+        try {
+            fs.unlinkSync(attachment.path);
+        }
+        catch {
+            // Ignore file deletion errors
+        }
+        this.attachments.splice(index, 1);
+        if (this.selectedAttachmentIndex >= this.attachments.length) {
+            this.selectedAttachmentIndex = this.attachments.length - 1;
+        }
+        this.updateAttachmentsBar();
+        this.ui.requestRender();
+    }
+    handleAttachmentKeyNavigation(data) {
+        if (this.attachments.length === 0)
+            return false;
+        // Only intercept up/down arrows when multiple attachments need navigation.
+        // With a single attachment, let the editor handle arrows for history browsing.
+        if (this.attachments.length > 1) {
+            if (matchesKey(data, "up")) {
+                if (this.selectedAttachmentIndex < 0) {
+                    this.selectedAttachmentIndex = 0;
+                }
+                else if (this.selectedAttachmentIndex > 0) {
+                    this.selectedAttachmentIndex--;
+                }
+                this.updateAttachmentsBar();
+                this.ui.requestRender();
+                return true;
+            }
+            if (matchesKey(data, "down")) {
+                if (this.selectedAttachmentIndex < 0) {
+                    this.selectedAttachmentIndex = 0;
+                }
+                else if (this.selectedAttachmentIndex < this.attachments.length - 1) {
+                    this.selectedAttachmentIndex++;
+                }
+                this.updateAttachmentsBar();
+                this.ui.requestRender();
+                return true;
+            }
+        }
+        // Delete/backspace only removes attachment when one is explicitly selected
+        if (this.selectedAttachmentIndex >= 0 &&
+            (matchesKey(data, "delete") || matchesKey(data, "backspace"))) {
+            this.deleteAttachment(this.selectedAttachmentIndex);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Convert attachment files to ImageContent array for sending to the model.
+     * Reads each file, base64-encodes, and resizes.
+     */
+    async processAttachmentFiles(attachments) {
+        const result = [];
+        for (const attachment of attachments) {
+            try {
+                if (!fs.existsSync(attachment.path))
+                    continue;
+                const mimeType = attachment.mimeType ??
+                    (await detectSupportedImageMimeTypeFromFile(attachment.path));
+                if (!mimeType)
+                    continue;
+                const content = fs.readFileSync(attachment.path);
+                const base64Content = content.toString("base64");
+                const resized = await resizeImage({
+                    type: "image",
+                    data: base64Content,
+                    mimeType,
+                });
+                result.push({
+                    type: "image",
+                    mimeType: resized.mimeType,
+                    data: resized.data,
+                });
+            }
+            catch {
+                // Skip unreadable attachment files
+            }
+        }
+        return result;
+    }
     /**
      * Extract image file paths from text, read them as base64 ImageContent,
      * and return the cleaned text with image references plus the image array.
@@ -1886,11 +2008,34 @@ export class InteractiveMode {
                 this.editor.addToHistory?.(text);
                 this.editor.setText("");
                 const steerResult = await this.extractImagesFromText(text);
-                await this.session.prompt(steerResult.text, {
+                const steerImages = steerResult.images;
+                let steerAttachmentPaths = [];
+                if (this.attachments.length > 0) {
+                    const pendingAttachments = this.attachments.splice(0);
+                    this.selectedAttachmentIndex = -1;
+                    this.updateAttachmentsBar();
+                    this.ui.requestRender();
+                    steerAttachmentPaths = pendingAttachments.map((a) => a.path);
+                }
+                // Drop images if model doesn't support them
+                const steerModel = this.session.model;
+                if ((steerImages.length > 0 || steerAttachmentPaths.length > 0) &&
+                    steerModel &&
+                    !steerModel.input.includes("image")) {
+                    steerImages.length = 0;
+                    steerAttachmentPaths = [];
+                }
+                let steerPromptText = steerResult.text;
+                if (steerAttachmentPaths.length > 0) {
+                    const cwd = this.session.cwd;
+                    const refs = steerAttachmentPaths
+                        .map((p) => `@${path.relative(cwd, p).replace(/\\/g, "/")}`)
+                        .join(" ");
+                    steerPromptText = refs + "  " + steerPromptText;
+                }
+                await this.session.prompt(steerPromptText, {
                     streamingBehavior: "steer",
-                    images: steerResult.images.length > 0
-                        ? steerResult.images
-                        : undefined,
+                    images: steerImages.length > 0 ? steerImages : undefined,
                 });
                 this.updatePendingMessagesDisplay();
                 this.ui.requestRender();
@@ -1908,6 +2053,37 @@ export class InteractiveMode {
             this.editor.setText("");
             // Extract images from clipboard-pasted file paths in the text
             const { text: processedText, images } = await this.extractImagesFromText(text);
+            // Collect and clear pending attachments upfront (ensures cleanup even on error).
+            // Clipboard images are saved under .pi/images/ so models can read them via
+            // file tools — this is more reliable than inline base64 (some models like
+            // Kimi K2.5 re-map inline images to internal server paths that break MCP).
+            let attachmentPaths = [];
+            if (this.attachments.length > 0) {
+                const pendingAttachments = this.attachments.splice(0);
+                this.selectedAttachmentIndex = -1;
+                this.updateAttachmentsBar();
+                this.ui.requestRender();
+                attachmentPaths = pendingAttachments.map((a) => a.path);
+            }
+            // Check model image support; warn and drop images if not supported
+            if (images.length > 0 || attachmentPaths.length > 0) {
+                const currentModel = this.session.model;
+                if (currentModel && !currentModel.input.includes("image")) {
+                    this.showWarning(`Model "${currentModel.name}" does not support image input. Images have been removed from this message.`);
+                    images.length = 0;
+                    attachmentPaths = [];
+                }
+            }
+            // Build image references using the relative path (_paste/image_N.ext).
+            // Prepended before user text so the model processes it first.
+            let imageRefPrefix = "";
+            if (attachmentPaths.length > 0) {
+                const cwd = this.session.cwd;
+                const refs = attachmentPaths
+                    .map((p) => `@${path.relative(cwd, p).replace(/\\/g, "/")}`)
+                    .join(" ");
+                imageRefPrefix = refs + "  ";
+            }
             if (!processedText.startsWith("/")) {
                 const displayContent = [
                     { type: "text", text: processedText },
@@ -1926,7 +2102,10 @@ export class InteractiveMode {
             try {
                 // Clear persona switch flag - interview should now run normally for subsequent messages
                 delete process.env.PI_JUST_SWITCHED_PERSONA;
-                await this.session.prompt(processedText, {
+                const promptText = imageRefPrefix
+                    ? imageRefPrefix + processedText
+                    : processedText;
+                await this.session.prompt(promptText, {
                     images: images.length > 0 ? images : undefined,
                 });
             }
@@ -1941,8 +2120,67 @@ export class InteractiveMode {
             }
             this.updatePendingMessagesDisplay();
             this.ui.requestRender();
+            // Clean up temporary clipboard image files from project root
+            this.cleanupClipboardImages();
         };
     }
+    cleanupStaleClipboardFiles() {
+        try {
+            const cwd = this.session.cwd;
+            // Clean old-format root files (_clipboard_*.png)
+            for (const entry of fs.readdirSync(cwd)) {
+                if (/^_clipboard_\d+\.\w+$/.test(entry)) {
+                    try {
+                        fs.unlinkSync(path.join(cwd, entry));
+                    }
+                    catch { /* best-effort */ }
+                }
+            }
+            // Clean _paste/ directory from previous sessions
+            const pasteDir = path.join(cwd, "_paste");
+            if (fs.existsSync(pasteDir)) {
+                for (const entry of fs.readdirSync(pasteDir)) {
+                    try {
+                        fs.unlinkSync(path.join(pasteDir, entry));
+                    }
+                    catch { /* best-effort */ }
+                }
+                try {
+                    fs.rmdirSync(pasteDir);
+                }
+                catch { /* best-effort */ }
+            }
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+    }
+    cleanupClipboardImages() {
+        for (const filePath of this.clipboardImageFiles) {
+            try {
+                if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch {
+                // Best-effort cleanup
+            }
+        }
+        this.clipboardImageFiles = [];
+        // Remove _paste/ directory if empty
+        try {
+            const pasteDir = path.join(this.session.cwd, "_paste");
+            if (fs.existsSync(pasteDir)) {
+                const remaining = fs.readdirSync(pasteDir);
+                if (remaining.length === 0) {
+                    fs.rmdirSync(pasteDir);
+                }
+            }
+        }
+        catch {
+            // Best-effort
+        }
+    }
     subscribeToAgent() {
         this.unsubscribe = this.session.subscribe(async (event) => {
             await this.handleEvent(event);
@@ -3342,7 +3580,31 @@ export class InteractiveMode {
             }, () => {
                 done();
                 this.ui.requestRender();
-            }, initialSearchInput, filterByProvider);
+            }, initialSearchInput, filterByProvider, () => {
+                void (async () => {
+                    done();
+                    const modelId = await this.showExtensionInput("Add OpenRouter model", "Model id (e.g. x-ai/grok-4.20)");
+                    if (!modelId?.trim()) {
+                        this.showModelSelector(initialSearchInput, filterByProvider);
+                        return;
+                    }
+                    const nameInput = await this.showExtensionInput("Display name (optional)", "Leave empty to use model id", { initialValue: modelId.trim() });
+                    if (nameInput === undefined) {
+                        this.showModelSelector(initialSearchInput, filterByProvider);
+                        return;
+                    }
+                    try {
+                        this.session.modelRegistry.appendOpenRouterModel(modelId.trim(), {
+                            name: nameInput.trim() || undefined,
+                        });
+                        this.showStatus(`Added OpenRouter model ${modelId.trim()}`);
+                    }
+                    catch (error) {
+                        this.showError(error instanceof Error ? error.message : String(error));
+                    }
+                    this.showModelSelector(initialSearchInput, filterByProvider);
+                })();
+            });
             return { component: selector, focus: selector };
         });
     }

package/dist/nanopencil-defaults.d.ts

@@ -75,6 +75,12 @@ export declare const NANOPENCIL_DEFAULT_MODELS_JSON: {
             readonly baseUrl: "https://api.minimaxi.com/anthropic";
             readonly api: "openai-completions";
             readonly models: readonly [{
+                readonly id: "MiniMax-M2.7";
+                readonly name: "MiniMax M2.7";
+                readonly input: readonly ["text"];
+                readonly contextWindow: 204800;
+                readonly maxTokens: 65536;
+            }, {
                 readonly id: "MiniMax-M2.5";
                 readonly name: "MiniMax M2.5";
                 readonly input: readonly ["text"];

package/dist/nanopencil-defaults.js

@@ -99,6 +99,13 @@ export const NANOPENCIL_DEFAULT_MODELS_JSON = {
             baseUrl: MINIMAX_CODING_BASE_URL,
             api: "openai-completions",
             models: [
+                {
+                    id: "MiniMax-M2.7",
+                    name: "MiniMax M2.7",
+                    input: ["text"],
+                    contextWindow: 204800,
+                    maxTokens: 65536,
+                },
                 {
                     id: "MiniMax-M2.5",
                     name: "MiniMax M2.5",
@@ -461,6 +468,58 @@ function mergeNanopencilModelsIfNeeded(modelsPath) {
             writeFileSync(modelsPath, JSON.stringify(data, null, 2), "utf-8");
         }
     }
+    // 合并 minimax-coding：不存在则添加默认配置，存在则补充默认模型
+    const minimaxProvider = data.providers[NANOPENCIL_MINIMAX_CODING_PROVIDER];
+    const minimaxConfig = NANOPENCIL_DEFAULT_MODELS_JSON.providers[NANOPENCIL_MINIMAX_CODING_PROVIDER];
+    if (!minimaxProvider) {
+        data.providers[NANOPENCIL_MINIMAX_CODING_PROVIDER] = {
+            baseUrl: minimaxConfig.baseUrl,
+            api: minimaxConfig.api,
+            models: DEFAULT_MINIMAX_MODELS.map((m) => ({ ...m })),
+        };
+        writeFileSync(modelsPath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    else {
+        const minimaxModels = (Array.isArray(minimaxProvider.models) ? [...minimaxProvider.models] : []);
+        const minimaxById = new Map();
+        for (const m of minimaxModels) {
+            const id = m?.id;
+            if (typeof id === "string")
+                minimaxById.set(id, m);
+        }
+        let minimaxChanged = false;
+        for (const def of DEFAULT_MINIMAX_MODELS) {
+            const id = def.id;
+            const existing = minimaxById.get(id);
+            if (!existing) {
+                minimaxModels.push({ ...def });
+                minimaxById.set(id, minimaxModels[minimaxModels.length - 1]);
+                minimaxChanged = true;
+            }
+            else {
+                if (existing.contextWindow !== def.contextWindow) {
+                    existing.contextWindow = def.contextWindow;
+                    minimaxChanged = true;
+                }
+                if (existing.maxTokens !== def.maxTokens) {
+                    existing.maxTokens = def.maxTokens;
+                    minimaxChanged = true;
+                }
+                if (JSON.stringify(existing.input) !== JSON.stringify(def.input)) {
+                    existing.input = def.input;
+                    minimaxChanged = true;
+                }
+                if (existing.name !== def.name) {
+                    existing.name = def.name;
+                    minimaxChanged = true;
+                }
+            }
+        }
+        if (minimaxChanged) {
+            data.providers[NANOPENCIL_MINIMAX_CODING_PROVIDER].models = minimaxModels;
+            writeFileSync(modelsPath, JSON.stringify(data, null, 2), "utf-8");
+        }
+    }
     // 合并 ollama：不存在则添加默认配置，存在则补充默认模型
     const ollamaProvider = data.providers[NANOPENCIL_OLLAMA_PROVIDER];
     const ollamaConfig = NANOPENCIL_DEFAULT_MODELS_JSON.providers[NANOPENCIL_OLLAMA_PROVIDER];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pencil-agent/nano-pencil",
-  "version": "1.11.32",
+  "version": "1.11.33",
   "description": "CLI writing agent with read, bash, edit, write tools and session management. Based on pi; supports DashScope Coding Plan. Soul enabled by default for AI personality evolution.",
   "type": "module",
   "bin": {
@@ -29,6 +29,7 @@
     "bundle:packages": "node scripts/bundle-deps.js",
     "watch": "tsc --watch",
     "test:presence": "node --test --import tsx test/presence-opening.test.ts",
+    "test:interactive-memory-notify": "node --test --import tsx test/interactive-memory-notify.test.ts",
     "start": "npx cross-env NODE_ENV=production node --no-deprecation dist/cli.js",
     "prepublishOnly": "npm run build",
     "changelog": "node scripts/generate-changelog.js",