@pencil-agent/nano-pencil 1.11.13 → 1.11.15

package/dist/core/extensions/runner.js

@@ -195,7 +195,10 @@ export class ExtensionRunner {
         return this.uiContext;
     }
     hasUI() {
-        return this.uiContext !== noOpUIContext;
+        if (this.uiContext === noOpUIContext) {
+            return false;
+        }
+        return this.uiContext.__nonInteractive !== true;
     }
     getExtensionPaths() {
         return this.extensions.map((e) => e.path);

package/dist/core/mcp/mcp-client.js

@@ -9,13 +9,14 @@ import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { getAgentDir } from "../../config.js";
 import { AuthStorage } from "../config/auth-storage.js";
+import { getMCPConfigPath } from "./mcp-config.js";
 // Log level control: DEBUG shows all MCP messages, RELEASE only shows summary
 // Check if running from installed location (production) vs development
 const isProductionBuild = typeof import.meta.url === "string" && import.meta.url.includes("node_modules");
 const isDebugMode = process.env.NODE_ENV === "development" || (process.env.NODE_ENV !== "production" && !isProductionBuild);
 function mcpLog(...args) {
     if (isDebugMode) {
-        console.log(...args);
+        console.error(...args);
     }
 }
 function mcpWarn(...args) {
@@ -45,8 +46,7 @@ export class MCPClient {
      * Load MCP server configurations from config file
      */
     loadServersFromConfig() {
-        const configDir = getAgentDir();
-        const configPath = join(configDir, "mcp.json");
+        const configPath = getMCPConfigPath();
         if (!existsSync(configPath)) {
             return;
         }

package/dist/core/prompt/system-prompt.js

@@ -21,7 +21,7 @@ export function buildSystemPrompt(options = {}) {
         second: "2-digit",
         timeZoneName: "short",
     });
-    const timeReasoningInstruction = "\nFor exact current time or date-sensitive reasoning, use the `time` tool instead of relying only on this prompt timestamp.";
+    const timeReasoningInstruction = "\nFor exact current time or any date-sensitive reasoning, you must use the `time` tool before answering. This includes questions about the current time, current date, today, tomorrow, yesterday, this week, deadlines, elapsed time, or anything that depends on the real system clock. Do not rely only on this prompt timestamp for those answers.";
     const appendSection = appendSystemPrompt ? `\n\n${appendSystemPrompt}` : "";
     const contextFiles = providedContextFiles ?? [];
     const skills = providedSkills ?? [];

package/dist/core/runtime/agent-session.d.ts

@@ -26,6 +26,7 @@ import { type PromptTemplate } from "../prompt/prompt-templates.js";
 import type { ResourceLoader } from "../config/resource-loader.js";
 import type { BranchSummaryEntry, SessionManager } from "../session/session-manager.js";
 import type { SettingsManager } from "../config/settings-manager.js";
+import { type SlashCommandInfo } from "../slash-commands.js";
 import type { BashOperations } from "../tools/bash.js";
 /** Parsed skill block from a user message */
 export interface ParsedSkillBlock {
@@ -138,6 +139,11 @@ export interface SessionStats {
     };
     cost: number;
 }
+export interface SessionSlashCommandDescriptor {
+    name: string;
+    description?: string;
+    source: "builtin" | SlashCommandInfo["source"];
+}
 export declare class AgentSession {
     readonly agent: Agent;
     readonly sessionManager: SessionManager;
@@ -211,6 +217,11 @@ export declare class AgentSession {
     /** Model registry for API key resolution and model discovery */
     get modelRegistry(): ModelRegistry;
     get cwd(): string;
+    /**
+     * Return all currently available slash-like commands for the session.
+     * Includes built-in commands, extension commands, prompt templates, and skills.
+     */
+    getSlashCommands(): SessionSlashCommandDescriptor[];
     /** Emit an event to all listeners */
     private _emit;
     private _lastAssistantMessage;

package/dist/core/runtime/agent-session.js

@@ -219,6 +219,44 @@ export class AgentSession {
     get cwd() {
         return this._cwd;
     }
+    /**
+     * Return all currently available slash-like commands for the session.
+     * Includes built-in commands, extension commands, prompt templates, and skills.
+     */
+    getSlashCommands() {
+        const builtins = BUILTIN_SLASH_COMMANDS.map((command) => ({
+            name: command.name,
+            description: command.description,
+            source: "builtin",
+        }));
+        const reservedBuiltins = new Set(BUILTIN_SLASH_COMMANDS.map((command) => command.name));
+        const extensionCommands = this._extensionRunner
+            ?.getRegisteredCommandsWithPaths()
+            .filter(({ command }) => !reservedBuiltins.has(command.name))
+            .map(({ command }) => ({
+            name: command.name,
+            description: command.description,
+            source: "extension",
+        })) ?? [];
+        const promptCommands = this.promptTemplates.map((template) => ({
+            name: template.name,
+            description: template.description,
+            source: "prompt",
+        }));
+        const skillCommands = this._resourceLoader
+            .getSkills()
+            .skills.map((skill) => ({
+            name: `skill:${skill.name}`,
+            description: skill.description,
+            source: "skill",
+        }));
+        return [
+            ...builtins,
+            ...extensionCommands,
+            ...promptCommands,
+            ...skillCommands,
+        ];
+    }
     // =========================================================================
     // Event Subscription
     // =========================================================================

package/dist/core/tools/index.js

@@ -80,7 +80,7 @@ export const toolGuidance = {
     ls: "列出目录内容。",
 };
 toolGuidance.time =
-    "Get the real current system time. Use this for time-sensitive confirmations like current date/time, today/tomorrow, deadlines, and temporal reasoning.";
+    "Get the real current system time. You must use this for current time/date questions, today/tomorrow/yesterday, deadlines, schedules, or any temporal reasoning that depends on the live system clock.";
 /**
  * Get guidance for a specific tool
  */

package/dist/core/tools/time.js

@@ -34,7 +34,7 @@ export function createTimeTool() {
     return {
         name: "time",
         label: "time",
-        description: "Get the current system time. Use this for time-sensitive questions such as 'what time is it', 'today', 'tomorrow', deadlines, or when you need to confirm the real current date/time instead of relying on prompt context.",
+        description: "Get the current system time. You must use this for time-sensitive questions such as 'what time is it', 'what day is it', 'today', 'tomorrow', 'yesterday', deadlines, schedules, elapsed time, or any request that depends on the real current date/time instead of prompt context.",
         parameters: timeSchema,
         execute: async (_toolCallId, { timeZone, locale }) => {
             return {

package/dist/extensions/defaults/soul/index.js

@@ -266,7 +266,7 @@ export default async function soulExtension(pi) {
         console.warn("[soul] Failed to initialize Soul manager.");
         return;
     }
-    console.log("[soul] Soul extension loaded successfully.");
+    console.error("[soul] Soul extension loaded successfully.");
     // Register event handlers
     // agent_start: Initialize personality
     pi.on("agent_start", async (_event, _ctx) => {

package/dist/extensions/optional/export-html/index.js

@@ -243,9 +243,9 @@ export default async function exportHtmlExtension(pi) {
             // Export the session (use default output path)
             // Pass undefined for state since we don't have access to it here
             const filePath = await extExportSessionToHtml(sessionManager, undefined);
-            console.log(`Session exported to: ${filePath}`);
+            console.error(`Session exported to: ${filePath}`);
         },
     });
-    console.log("[export-html] Extension loaded");
+    console.error("[export-html] Extension loaded");
 }
 //# sourceMappingURL=index.js.map

package/dist/main.js

@@ -695,7 +695,53 @@ export async function main(args) {
     }
     if (parsed.acp) {
         const { runAcpMode } = await import("./modes/acp/acp-mode.js");
-        await runAcpMode(session);
+        const createAcpSessionForCwd = async (workspaceCwd) => {
+            const resolvedWorkspaceCwd = resolveWorkingDirectory(workspaceCwd);
+            const workspaceSettingsManager = SettingsManager.create(resolvedWorkspaceCwd, agentDir);
+            reportSettingsErrors(workspaceSettingsManager, "acp startup");
+            const workspaceResourceLoader = new DefaultResourceLoader({
+                cwd: resolvedWorkspaceCwd,
+                agentDir,
+                settingsManager: workspaceSettingsManager,
+                additionalExtensionPaths: [...defaultExtPaths, ...(parsed.extensions ?? [])],
+                additionalSkillPaths: parsed.skills,
+                additionalPromptTemplatePaths: parsed.promptTemplates,
+                additionalThemePaths: parsed.themes,
+                noExtensions: parsed.noExtensions,
+                noSkills: parsed.noSkills,
+                noPromptTemplates: parsed.noPromptTemplates,
+                noThemes: parsed.noThemes,
+                systemPrompt: parsed.systemPrompt,
+                appendSystemPrompt: parsed.appendSystemPrompt,
+            });
+            await workspaceResourceLoader.reload();
+            const workspaceExtensionsResult = workspaceResourceLoader.getExtensions();
+            for (const { path, error } of workspaceExtensionsResult.errors) {
+                console.error(chalk.red(`Failed to load extension "${path}": ${error}`));
+            }
+            for (const { name, config } of workspaceExtensionsResult.runtime.pendingProviderRegistrations) {
+                modelRegistry.registerProvider(name, config);
+            }
+            workspaceExtensionsResult.runtime.pendingProviderRegistrations = [];
+            let workspaceScopedModels = [];
+            if (modelPatterns && modelPatterns.length > 0) {
+                workspaceScopedModels = await resolveModelScope(modelPatterns, modelRegistry);
+            }
+            const workspaceSessionManager = parsed.noSession
+                ? SessionManager.inMemory(resolvedWorkspaceCwd)
+                : SessionManager.create(resolvedWorkspaceCwd, parsed.sessionDir);
+            const { options: workspaceSessionOptions } = buildSessionOptions(parsed, workspaceScopedModels, workspaceSessionManager, modelRegistry, workspaceSettingsManager);
+            workspaceSessionOptions.cwd = resolvedWorkspaceCwd;
+            workspaceSessionOptions.authStorage = authStorage;
+            workspaceSessionOptions.modelRegistry = modelRegistry;
+            workspaceSessionOptions.resourceLoader = workspaceResourceLoader;
+            workspaceSessionOptions.settingsManager = workspaceSettingsManager;
+            workspaceSessionOptions.enableMCP = sessionOptions.enableMCP;
+            workspaceSessionOptions.enableSoul = sessionOptions.enableSoul;
+            const { session: workspaceSession } = await createAgentSession(workspaceSessionOptions);
+            return workspaceSession;
+        };
+        await runAcpMode(session, { createSessionForCwd: createAcpSessionForCwd });
     }
     else if (mode === "rpc") {
         await runRpcMode(session);

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

@@ -3,15 +3,15 @@
  *
  * Used for integrating with ACP-compatible editors like Zed and JetBrains.
  * Communication via stdin/stdout using JSON-RPC 2.0 messages.
- *
- * Protocol:
- * - Client → Agent: initialize, session/new, session/prompt, session/cancel
- * - Agent → Client: session/update (streaming events), session/request_permission
  */
 import type { AgentSession } from "../../core/runtime/agent-session.js";
+interface AcpModeOptions {
+    createSessionForCwd?: (cwd: string) => Promise<AgentSession>;
+}
 /**
  * Run in ACP mode.
  * Listens for JSON-RPC 2.0 messages on stdin, outputs JSON-RPC responses/events on stdout.
  */
-export declare function runAcpMode(session: AgentSession): Promise<never>;
+export declare function runAcpMode(session: AgentSession, options?: AcpModeOptions): Promise<never>;
+export {};
 //# sourceMappingURL=acp-mode.d.ts.map

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

@@ -3,14 +3,30 @@
  *
  * Used for integrating with ACP-compatible editors like Zed and JetBrains.
  * Communication via stdin/stdout using JSON-RPC 2.0 messages.
- *
- * Protocol:
- * - Client → Agent: initialize, session/new, session/prompt, session/cancel
- * - Agent → Client: session/update (streaming events), session/request_permission
  */
 import * as acp from "@agentclientprotocol/sdk";
+import { SessionManager } from "../../core/session/session-manager.js";
+import { randomUUID } from "node:crypto";
 import { Readable, Writable } from "node:stream";
 import { theme } from "../interactive/theme/theme.js";
+const ACP_MODES = [
+    {
+        id: "ask",
+        name: "Ask before write",
+        description: "Request permission before mutating files or running commands.",
+    },
+    {
+        id: "read-only",
+        name: "Read-only",
+        description: "Disable editing tools and command execution.",
+    },
+    {
+        id: "bypass",
+        name: "Bypass permissions",
+        description: "Allow normal coding actions without permission prompts.",
+    },
+];
+const MUTATING_TOOL_NAMES = new Set(["edit", "write", "bash"]);
 /**
  * Map nanoPencil tool names to ACP tool kinds.
  */
@@ -34,16 +50,78 @@ function mapToolKind(toolName) {
             return "other";
     }
 }
+function createMessageId() {
+    return randomUUID();
+}
+function textToContent(text) {
+    return { type: "text", text };
+}
+function asText(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function createSlashCommandsUpdate(session) {
+    const commands = session.getSlashCommands();
+    const seen = new Set();
+    return commands
+        .filter((command) => {
+        const key = command.name.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .map((command) => ({
+        name: `/${command.name}`,
+        description: command.description ?? `Run /${command.name}`,
+        input: { hint: "Enter command arguments" },
+    }));
+}
+function getMessageText(message) {
+    if (!("content" in message) || !Array.isArray(message.content)) {
+        return "";
+    }
+    return message.content
+        .map((block) => {
+        if (typeof block === "string")
+            return block;
+        if ("type" in block && block.type === "text")
+            return block.text;
+        return "";
+    })
+        .filter((part) => part.length > 0)
+        .join("\n");
+}
+function isMutatingTool(tool) {
+    if (MUTATING_TOOL_NAMES.has(tool.name))
+        return true;
+    if (/^mcp_.*(?:use_figma|generate_figma_design)$/i.test(tool.name))
+        return true;
+    return false;
+}
+function unsupportedAcpUi(feature) {
+    throw new Error(`${feature} is not available in ACP mode yet. In Zed or other ACP clients, use argument-driven commands when available, or run this command in the terminal nanoPencil UI.`);
+}
+function formatMoney(value) {
+    return value.toFixed(4);
+}
 /**
  * Create an extension UI context for ACP mode.
  * Returns silent defaults since ACP mode has no interactive UI.
  */
 function createAcpExtensionUIContext() {
     return {
-        select: async () => undefined,
-        confirm: async () => false,
-        input: async () => undefined,
-        editor: async () => undefined,
+        __nonInteractive: true,
+        select: async () => unsupportedAcpUi("Interactive selection"),
+        confirm: async () => unsupportedAcpUi("Interactive confirmation"),
+        input: async () => unsupportedAcpUi("Interactive text input"),
+        editor: async () => unsupportedAcpUi("Interactive editor"),
         notify(message, type) {
             process.stderr.write(`[${type ?? "info"}] ${message}\n`);
         },
@@ -58,7 +136,7 @@ function createAcpExtensionUIContext() {
         setEditorText() { },
         getEditorText: () => "",
         async custom() {
-            return undefined;
+            return unsupportedAcpUi("Custom interactive UI");
         },
         onTerminalInput() {
             return () => { };
@@ -90,58 +168,178 @@ function createAcpExtensionUIContext() {
 class NanoPencilAgent {
     connection;
     session;
-    activeSessions;
-    constructor(connection, session) {
+    sessions = new Map();
+    currentSessionId;
+    createSessionForCwd;
+    extensionBindings;
+    ready;
+    constructor(connection, session, options = {}) {
         this.connection = connection;
         this.session = session;
-        this.activeSessions = new Map();
+        this.createSessionForCwd = options.createSessionForCwd;
+        this.extensionBindings = {
+            uiContext: createAcpExtensionUIContext(),
+            commandContextActions: {
+                waitForIdle: () => this.session.agent.waitForIdle(),
+                newSession: async (options) => {
+                    const success = await this.session.newSession(options);
+                    return { cancelled: !success };
+                },
+                fork: async (entryId) => {
+                    const result = await this.session.fork(entryId);
+                    return { cancelled: result.cancelled };
+                },
+                navigateTree: async (targetId, options) => {
+                    const result = await this.session.navigateTree(targetId, options);
+                    return { cancelled: result.cancelled };
+                },
+                switchSession: async (sessionPath) => {
+                    const success = await this.session.switchSession(sessionPath);
+                    return { cancelled: !success };
+                },
+                reload: async () => {
+                    await this.session.reload();
+                },
+            },
+            shutdownHandler: () => {
+                process.exit(0);
+            },
+            onError: (err) => {
+                process.stderr.write(`[extension_error] ${err.extensionPath}: ${err.error}\n`);
+            },
+        };
+        this.ready = this.bindSession(this.session);
     }
-    async initialize(params) {
+    async initialize(_params) {
+        await this.ready;
         return {
             protocolVersion: acp.PROTOCOL_VERSION,
+            agentInfo: {
+                name: "nanoPencil",
+                version: "acp",
+            },
             agentCapabilities: {
-                loadSession: false,
+                loadSession: true,
+                sessionCapabilities: {
+                    list: {},
+                },
             },
         };
     }
     async newSession(params) {
-        const sessionId = `sess-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        this.activeSessions.set(sessionId, { abortController: null });
-        return { sessionId };
+        await this.ready;
+        await this.ensureWorkspaceSession(params.cwd);
+        await this.session.newSession();
+        const sessionId = this.session.sessionManager.getSessionId();
+        const state = this.createStateFromCurrentSession(sessionId, params.cwd);
+        this.sessions.set(sessionId, state);
+        this.currentSessionId = sessionId;
+        await this.applySessionMode(state);
+        await this.emitSessionMetadata(state);
+        await this.emitAvailableCommands(sessionId);
+        return {
+            sessionId,
+            models: this.buildModelState(),
+            modes: this.buildModeState(state.modeId),
+        };
+    }
+    async loadSession(params) {
+        await this.ready;
+        const info = await this.findSessionInfo(params.sessionId, params.cwd);
+        if (!info) {
+            throw new Error(`Session ${params.sessionId} not found`);
+        }
+        await this.ensureWorkspaceSession(info.cwd || params.cwd);
+        const switched = await this.session.switchSession(info.path);
+        if (!switched) {
+            throw new Error(`Failed to load session ${params.sessionId}`);
+        }
+        const existing = this.sessions.get(params.sessionId);
+        const state = {
+            sessionId: params.sessionId,
+            sessionFile: info.path,
+            cwd: info.cwd || params.cwd,
+            title: info.name || info.firstMessage || existing?.title,
+            modeId: existing?.modeId ?? "ask",
+            abortController: null,
+            allowAllMutations: existing?.allowAllMutations ?? false,
+            rejectAllMutations: existing?.rejectAllMutations ?? false,
+        };
+        this.sessions.set(params.sessionId, state);
+        this.currentSessionId = params.sessionId;
+        await this.applySessionMode(state);
+        await this.emitSessionMetadata(state);
+        await this.emitAvailableCommands(params.sessionId);
+        await this.replayHistory(params.sessionId);
+        return {
+            models: this.buildModelState(),
+            modes: this.buildModeState(state.modeId),
+        };
     }
-    async authenticate(params) {
-        // Authentication not implemented
+    async listSessions(params) {
+        await this.ready;
+        const infos = params.cwd
+            ? await SessionManager.list(params.cwd)
+            : await SessionManager.listAll();
+        const merged = new Map();
+        for (const info of infos) {
+            merged.set(info.id, {
+                sessionId: info.id,
+                cwd: info.cwd,
+                title: info.name || info.firstMessage || undefined,
+                updatedAt: info.modified.toISOString(),
+            });
+        }
+        for (const state of this.sessions.values()) {
+            if (params.cwd && state.cwd !== params.cwd)
+                continue;
+            if (!merged.has(state.sessionId)) {
+                merged.set(state.sessionId, {
+                    sessionId: state.sessionId,
+                    cwd: state.cwd,
+                    title: state.title,
+                    updatedAt: new Date().toISOString(),
+                });
+            }
+        }
+        return {
+            sessions: Array.from(merged.values()),
+        };
+    }
+    async authenticate(_params) {
+        await this.ready;
         return;
     }
     async prompt(params) {
-        const { sessionId, prompt } = params;
-        const sessionState = this.activeSessions.get(sessionId);
-        if (!sessionState) {
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        // Abort any previous prompt
+        await this.ready;
+        const sessionState = this.requireSession(params.sessionId);
+        await this.activateSession(sessionState);
         sessionState.abortController?.abort();
         sessionState.abortController = new AbortController();
-        // Extract text from prompt content blocks
-        const userText = prompt
+        const userText = params.prompt
             .filter((block) => "text" in block && typeof block.text === "string")
             .map((block) => block.text)
             .join("\n");
-        // Subscribe to events and forward as ACP session/update
+        const builtinHandled = await this.handleBuiltinSlashCommand(params.sessionId, sessionState, userText);
+        if (builtinHandled) {
+            return { stopReason: "end_turn" };
+        }
         const unsubscribe = this.session.subscribe((event) => {
-            this.mapEventToAcp(sessionId, event);
+            this.mapEventToAcp(params.sessionId, event);
         });
         try {
             // @ts-expect-error - source is for internal use
             await this.session.prompt(userText, { source: "acp" });
+            await this.emitSessionMetadata(sessionState);
             return { stopReason: "end_turn" };
         }
         catch (error) {
             if (sessionState.abortController.signal.aborted) {
                 return { stopReason: "cancelled" };
             }
-            // For errors, return end_turn - the client should detect errors via other means
-            process.stderr.write(`[error] ${error instanceof Error ? error.message : String(error)}\n`);
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[error] ${message}\n`);
+            await this.sendAssistantText(params.sessionId, `Command failed: ${message}`);
             return { stopReason: "end_turn" };
         }
         finally {
@@ -150,15 +348,440 @@ class NanoPencilAgent {
         }
     }
     async cancel(params) {
-        const sessionState = this.activeSessions.get(params.sessionId);
+        await this.ready;
+        const sessionState = this.sessions.get(params.sessionId);
         if (sessionState) {
+            await this.activateSession(sessionState);
             sessionState.abortController?.abort();
             await this.session.abort();
         }
     }
     async setSessionMode(params) {
-        // Session mode not implemented
-        return;
+        await this.ready;
+        const sessionState = this.requireSession(params.sessionId);
+        if (!ACP_MODES.some((mode) => mode.id === params.modeId)) {
+            throw new Error(`Unknown ACP mode: ${params.modeId}`);
+        }
+        sessionState.modeId = params.modeId;
+        sessionState.allowAllMutations = false;
+        sessionState.rejectAllMutations = false;
+        await this.activateSession(sessionState);
+        await this.connection.sessionUpdate({
+            sessionId: params.sessionId,
+            update: {
+                sessionUpdate: "current_mode_update",
+                currentModeId: sessionState.modeId,
+            },
+        });
+        return {};
+    }
+    async unstable_setSessionModel(params) {
+        await this.ready;
+        const sessionState = this.requireSession(params.sessionId);
+        await this.activateSession(sessionState);
+        const model = this.parseAcpModelId(params.modelId);
+        if (!model) {
+            throw new Error(`Unknown model: ${params.modelId}`);
+        }
+        await this.session.setModel(model);
+        await this.emitSessionMetadata(sessionState);
+        return {};
+    }
+    requireSession(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        return state;
+    }
+    createStateFromCurrentSession(sessionId, cwd) {
+        const sessionFile = this.session.sessionManager.getSessionFile();
+        return {
+            sessionId,
+            sessionFile,
+            cwd,
+            title: this.getCurrentSessionTitle(),
+            modeId: "ask",
+            abortController: null,
+            allowAllMutations: false,
+            rejectAllMutations: false,
+        };
+    }
+    getCurrentSessionTitle() {
+        return (this.session.sessionManager.getSessionName() ||
+            this.session.agent.state.messages.find((message) => message.role === "user")
+            ? getMessageText(this.session.agent.state.messages.find((message) => message.role === "user")).slice(0, 80)
+            : undefined);
+    }
+    async findSessionInfo(sessionId, cwd) {
+        const existing = this.sessions.get(sessionId);
+        if (existing?.sessionFile) {
+            return {
+                id: existing.sessionId,
+                path: existing.sessionFile,
+                cwd: existing.cwd,
+                name: existing.title,
+                firstMessage: "",
+            };
+        }
+        const cwdSessions = await SessionManager.list(cwd);
+        const direct = cwdSessions.find((info) => info.id === sessionId);
+        if (direct)
+            return direct;
+        const allSessions = await SessionManager.listAll();
+        return allSessions.find((info) => info.id === sessionId);
+    }
+    async findSessionByQuery(query, cwd) {
+        const trimmed = query.trim().toLowerCase();
+        if (!trimmed)
+            return undefined;
+        const cwdSessions = await SessionManager.list(cwd);
+        const allSessions = await SessionManager.listAll();
+        const candidates = [...cwdSessions, ...allSessions].filter((info, index, array) => array.findIndex((other) => other.id === info.id) === index);
+        return candidates.find((info) => {
+            const title = (info.name || info.firstMessage || "").toLowerCase();
+            return (info.id.toLowerCase() === trimmed ||
+                info.id.toLowerCase().startsWith(trimmed) ||
+                title.includes(trimmed));
+        });
+    }
+    buildModeState(currentModeId) {
+        return {
+            availableModes: ACP_MODES,
+            currentModeId,
+        };
+    }
+    buildModelState() {
+        const models = this.session.modelRegistry.getAvailable();
+        const current = this.session.model;
+        const availableModels = models.map((model) => ({
+            modelId: this.toAcpModelId(model),
+            name: model.name || `${model.provider}/${model.id}`,
+            description: `${model.provider} / ${model.id}`,
+        }));
+        return {
+            availableModels,
+            currentModelId: current ? this.toAcpModelId(current) : availableModels[0]?.modelId ?? "unknown/unknown",
+        };
+    }
+    toAcpModelId(model) {
+        return `${model.provider}/${model.id}`;
+    }
+    parseAcpModelId(modelId) {
+        const slashIndex = modelId.indexOf("/");
+        if (slashIndex === -1)
+            return undefined;
+        const provider = modelId.slice(0, slashIndex);
+        const id = modelId.slice(slashIndex + 1);
+        return this.session.modelRegistry.find(provider, id);
+    }
+    async emitAvailableCommands(sessionId) {
+        await this.connection.sessionUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "available_commands_update",
+                availableCommands: createSlashCommandsUpdate(this.session),
+            },
+        });
+    }
+    async emitSessionMetadata(state) {
+        state.title = this.getCurrentSessionTitle() ?? state.title;
+        await this.connection.sessionUpdate({
+            sessionId: state.sessionId,
+            update: {
+                sessionUpdate: "session_info_update",
+                title: state.title ?? null,
+                updatedAt: new Date().toISOString(),
+            },
+        });
+    }
+    async replayHistory(sessionId) {
+        for (const message of this.session.agent.state.messages) {
+            if (message.role !== "user" && message.role !== "assistant")
+                continue;
+            const text = getMessageText(message);
+            if (!text.trim())
+                continue;
+            await this.connection.sessionUpdate({
+                sessionId,
+                update: {
+                    sessionUpdate: message.role === "user" ? "user_message_chunk" : "agent_message_chunk",
+                    content: textToContent(text),
+                    messageId: createMessageId(),
+                },
+            });
+        }
+    }
+    async activateSession(state) {
+        await this.ensureWorkspaceSession(state.cwd);
+        const currentFile = this.session.sessionManager.getSessionFile();
+        if (state.sessionFile && state.sessionFile !== currentFile) {
+            const switched = await this.session.switchSession(state.sessionFile);
+            if (!switched) {
+                throw new Error(`Failed to switch to session ${state.sessionId}`);
+            }
+        }
+        this.currentSessionId = state.sessionId;
+        await this.applySessionMode(state);
+    }
+    async bindSession(session) {
+        await session.bindExtensions(this.extensionBindings);
+    }
+    async ensureWorkspaceSession(cwd) {
+        if (!cwd || this.session.cwd === cwd || !this.createSessionForCwd) {
+            return;
+        }
+        await this.session.extensionRunner?.emit({ type: "session_shutdown" });
+        const nextSession = await this.createSessionForCwd(cwd);
+        this.session = nextSession;
+        await this.bindSession(nextSession);
+    }
+    async handleBuiltinSlashCommand(sessionId, state, text) {
+        const trimmed = text.trim();
+        if (!trimmed.startsWith("/"))
+            return false;
+        if (trimmed === "/new") {
+            await this.session.newSession();
+            state.sessionFile = this.session.sessionManager.getSessionFile();
+            state.title = this.getCurrentSessionTitle();
+            await this.emitSessionMetadata(state);
+            await this.sendAssistantText(sessionId, "Started a new session.");
+            return true;
+        }
+        if (trimmed === "/reload") {
+            await this.session.reload();
+            await this.activateSession(state);
+            await this.emitAvailableCommands(sessionId);
+            await this.sendAssistantText(sessionId, "Reloaded extensions, skills, prompts, and themes.");
+            return true;
+        }
+        if (trimmed === "/session") {
+            const stats = this.session.getSessionStats();
+            const context = this.session.getContextUsage();
+            const current = this.session.model;
+            const lines = [
+                `Session ID: ${stats.sessionId}`,
+                `Session name: ${this.session.sessionManager.getSessionName() || "(unnamed)"}`,
+                `Session file: ${stats.sessionFile ?? "(in-memory)"}`,
+                `Model: ${current ? `${current.provider}/${current.id}` : "none"}`,
+                `Thinking: ${this.session.thinkingLevel}`,
+                `Messages: ${stats.totalMessages} total (${stats.userMessages} user, ${stats.assistantMessages} assistant, ${stats.toolResults} tool results)`,
+                `Tool calls: ${stats.toolCalls}`,
+            ];
+            if (context) {
+                lines.push(`Context: ${context.tokens ?? "unknown"} / ${context.contextWindow} tokens${context.percent != null ? ` (${context.percent.toFixed(1)}%)` : ""}`);
+            }
+            await this.sendAssistantText(sessionId, lines.join("\n"));
+            return true;
+        }
+        if (trimmed === "/usage") {
+            const stats = this.session.getSessionStats();
+            const lines = [
+                "Usage summary",
+                `Input tokens: ${stats.tokens.input}`,
+                `Output tokens: ${stats.tokens.output}`,
+                `Cache read: ${stats.tokens.cacheRead}`,
+                `Cache write: ${stats.tokens.cacheWrite}`,
+                `Total tokens: ${stats.tokens.total}`,
+                `Estimated cost: $${formatMoney(stats.cost)}`,
+            ];
+            await this.sendAssistantText(sessionId, lines.join("\n"));
+            return true;
+        }
+        if (trimmed === "/name" || trimmed.startsWith("/name ")) {
+            const arg = trimmed.slice("/name".length).trim();
+            if (!arg) {
+                await this.sendAssistantText(sessionId, `Current session name: ${this.session.sessionManager.getSessionName() || "(unnamed)"}`);
+                return true;
+            }
+            this.session.sessionManager.appendSessionInfo(arg);
+            state.title = arg;
+            await this.emitSessionMetadata(state);
+            await this.sendAssistantText(sessionId, `Session name set to "${arg}".`);
+            return true;
+        }
+        if (trimmed === "/resume" || trimmed.startsWith("/resume ")) {
+            const arg = trimmed.slice("/resume".length).trim();
+            if (!arg) {
+                const sessions = await SessionManager.list(state.cwd);
+                const summary = sessions
+                    .slice(0, 10)
+                    .map((info) => `- ${info.id} | ${info.name || info.firstMessage || "(untitled)"}`)
+                    .join("\n");
+                await this.sendAssistantText(sessionId, summary
+                    ? `Recent sessions for this workspace:\n${summary}\n\nUse /resume <session-id-or-title>.`
+                    : "No saved sessions were found for this workspace.");
+                return true;
+            }
+            const target = await this.findSessionByQuery(arg, state.cwd);
+            if (!target) {
+                await this.sendAssistantText(sessionId, `No saved session matched "${arg}". Use /resume with no arguments to list recent sessions.`);
+                return true;
+            }
+            const switched = await this.session.switchSession(target.path);
+            if (!switched) {
+                await this.sendAssistantText(sessionId, `Failed to load session ${target.id}.`);
+                return true;
+            }
+            state.sessionFile = target.path;
+            state.cwd = target.cwd;
+            state.title = target.name || target.firstMessage || state.title;
+            await this.emitSessionMetadata(state);
+            await this.emitAvailableCommands(sessionId);
+            await this.sendAssistantText(sessionId, `Resumed session ${target.id}${state.title ? ` (${state.title})` : ""}. Future turns now use that saved conversation context.`);
+            return true;
+        }
+        if (trimmed === "/thinking" || trimmed.startsWith("/thinking ")) {
+            const arg = trimmed.slice("/thinking".length).trim().toLowerCase();
+            if (!arg) {
+                const levels = this.session.getAvailableThinkingLevels().join(", ");
+                await this.sendAssistantText(sessionId, `Current thinking level: ${this.session.thinkingLevel}\nAvailable levels: ${levels}`);
+                return true;
+            }
+            const levels = this.session.getAvailableThinkingLevels();
+            if (!levels.includes(arg)) {
+                await this.sendAssistantText(sessionId, `Unknown thinking level: ${arg}\nAvailable levels: ${levels.join(", ")}`);
+                return true;
+            }
+            this.session.setThinkingLevel(arg);
+            await this.sendAssistantText(sessionId, `Thinking level set to ${this.session.thinkingLevel}.`);
+            return true;
+        }
+        if (trimmed === "/model" || trimmed.startsWith("/model ")) {
+            const arg = trimmed.slice("/model".length).trim();
+            if (!arg) {
+                const current = this.session.model;
+                const summary = this.session.modelRegistry
+                    .getAvailable()
+                    .slice(0, 20)
+                    .map((model) => `- ${model.provider}/${model.id}`)
+                    .join("\n");
+                await this.sendAssistantText(sessionId, `Current model: ${current ? `${current.provider}/${current.id}` : "none"}\nAvailable models:\n${summary}`);
+                return true;
+            }
+            const model = this.findExactModelMatch(arg);
+            if (!model) {
+                const matches = this.session.modelRegistry
+                    .getAvailable()
+                    .filter((candidate) => {
+                    const full = `${candidate.provider}/${candidate.id}`.toLowerCase();
+                    return full.includes(arg.toLowerCase()) || candidate.id.toLowerCase().includes(arg.toLowerCase());
+                })
+                    .slice(0, 10)
+                    .map((candidate) => `- ${candidate.provider}/${candidate.id}`)
+                    .join("\n");
+                await this.sendAssistantText(sessionId, matches
+                    ? `No exact model match for "${arg}". Closest matches:\n${matches}`
+                    : `No model match for "${arg}".`);
+                return true;
+            }
+            await this.session.setModel(model);
+            await this.sendAssistantText(sessionId, `Model switched to ${model.provider}/${model.id}.`);
+            return true;
+        }
+        if (trimmed === "/compact" || trimmed.startsWith("/compact ")) {
+            const instructions = trimmed.slice("/compact".length).trim() || undefined;
+            const result = await this.session.compact(instructions);
+            await this.sendAssistantText(sessionId, `Compaction completed.\nFirst kept entry: ${result.firstKeptEntryId}\nTokens before: ${result.tokensBefore}`);
+            return true;
+        }
+        return false;
+    }
+    findExactModelMatch(searchTerm) {
+        const term = searchTerm.trim().toLowerCase();
+        if (!term)
+            return undefined;
+        let provider;
+        let modelId = term;
+        if (term.includes("/")) {
+            const [rawProvider, rawModelId] = term.split("/", 2);
+            provider = rawProvider?.trim();
+            modelId = rawModelId?.trim() ?? "";
+        }
+        if (!modelId)
+            return undefined;
+        return this.session.modelRegistry.getAvailable().find((model) => {
+            if (provider && model.provider.toLowerCase() !== provider)
+                return false;
+            return model.id.toLowerCase() === modelId;
+        });
+    }
+    async sendAssistantText(sessionId, text) {
+        await this.connection.sessionUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "agent_message_chunk",
+                content: textToContent(text),
+                messageId: createMessageId(),
+            },
+        });
+    }
+    async applySessionMode(state) {
+        const allToolNames = this.session.getAllTools().map((tool) => tool.name);
+        if (state.modeId === "read-only") {
+            const readOnlyToolNames = allToolNames.filter((name) => ["read", "grep", "find", "ls", "time"].includes(name));
+            this.session.setActiveToolsByName(readOnlyToolNames);
+            return;
+        }
+        this.session.setActiveToolsByName(allToolNames);
+        if (state.modeId === "ask") {
+            const wrapped = this.wrapToolsForAskMode(this.session.agent.state.tools, state);
+            this.session.agent.setTools(wrapped);
+        }
+    }
+    wrapToolsForAskMode(tools, state) {
+        return tools.map((tool) => {
+            if (!isMutatingTool(tool))
+                return tool;
+            return {
+                ...tool,
+                execute: async (toolCallId, params, signal, onUpdate) => {
+                    await this.requestPermissionIfNeeded(state, tool, toolCallId, params);
+                    return tool.execute(toolCallId, params, signal, onUpdate);
+                },
+            };
+        });
+    }
+    async requestPermissionIfNeeded(state, tool, toolCallId, params) {
+        if (state.allowAllMutations)
+            return;
+        if (state.rejectAllMutations) {
+            throw new Error("Permission denied for mutating tools in this session.");
+        }
+        const options = [
+            { optionId: "allow_once", name: "Allow once", kind: "allow_once" },
+            { optionId: "allow_always", name: "Always allow", kind: "allow_always" },
+            { optionId: "reject_once", name: "Reject once", kind: "reject_once" },
+            { optionId: "reject_always", name: "Always reject", kind: "reject_always" },
+        ];
+        const response = await this.connection.requestPermission({
+            sessionId: state.sessionId,
+            options,
+            toolCall: {
+                toolCallId,
+                title: `Run ${tool.name}`,
+                kind: mapToolKind(tool.name),
+                status: "pending",
+                locations: [],
+                rawInput: params,
+            },
+        });
+        if (response.outcome.outcome === "cancelled") {
+            throw new Error("Permission request was cancelled.");
+        }
+        switch (response.outcome.optionId) {
+            case "allow_once":
+                return;
+            case "allow_always":
+                state.allowAllMutations = true;
+                return;
+            case "reject_always":
+                state.rejectAllMutations = true;
+                throw new Error("Permission denied for mutating tools in this session.");
+            case "reject_once":
+            default:
+                throw new Error("Permission denied for this tool call.");
+        }
     }
     /**
      * Map nanoPencil AgentSessionEvent to ACP session/update notifications.
@@ -169,29 +792,30 @@ class NanoPencilAgent {
                 const sub = event.assistantMessageEvent;
                 switch (sub.type) {
                     case "text_delta":
-                        this.connection.sessionUpdate({
+                        void this.connection.sessionUpdate({
                             sessionId,
                             update: {
                                 sessionUpdate: "agent_message_chunk",
-                                content: { type: "text", text: sub.delta },
+                                content: textToContent(sub.delta),
+                                messageId: createMessageId(),
                             },
                         });
                         break;
                     case "thinking_delta":
-                        this.connection.sessionUpdate({
+                        void this.connection.sessionUpdate({
                             sessionId,
                             update: {
                                 sessionUpdate: "agent_thought_chunk",
-                                content: { type: "text", text: sub.delta },
+                                content: textToContent(sub.delta),
+                                messageId: createMessageId(),
                             },
                         });
                         break;
-                    // toolcall_start, toolcall_end, etc. are handled by tool_execution_* events
                 }
                 break;
             }
             case "tool_execution_start":
-                this.connection.sessionUpdate({
+                void this.connection.sessionUpdate({
                     sessionId,
                     update: {
                         sessionUpdate: "tool_call",
@@ -200,11 +824,12 @@ class NanoPencilAgent {
                         kind: mapToolKind(event.toolName),
                         status: "pending",
                         locations: [],
+                        rawInput: event.args,
                     },
                 });
                 break;
             case "tool_execution_end":
-                this.connection.sessionUpdate({
+                void this.connection.sessionUpdate({
                     sessionId,
                     update: {
                         sessionUpdate: "tool_call_update",
@@ -215,16 +840,14 @@ class NanoPencilAgent {
                                 type: "content",
                                 content: {
                                     type: "text",
-                                    text: typeof event.result === "string"
-                                        ? event.result
-                                        : JSON.stringify(event.result, null, 2),
+                                    text: asText(event.result),
                                 },
                             },
                         ],
+                        rawOutput: event.result,
                     },
                 });
                 break;
-            // agent_start, agent_end, turn_start, turn_end, etc. don't need mapping
         }
     }
 }
@@ -232,44 +855,12 @@ class NanoPencilAgent {
  * Run in ACP mode.
  * Listens for JSON-RPC 2.0 messages on stdin, outputs JSON-RPC responses/events on stdout.
  */
-export async function runAcpMode(session) {
-    // Bind extensions with headless UI context
-    await session.bindExtensions({
-        uiContext: createAcpExtensionUIContext(),
-        commandContextActions: {
-            waitForIdle: () => session.agent.waitForIdle(),
-            newSession: async (options) => {
-                const success = await session.newSession(options);
-                return { cancelled: !success };
-            },
-            fork: async (entryId) => {
-                const result = await session.fork(entryId);
-                return { cancelled: result.cancelled };
-            },
-            navigateTree: async (targetId, options) => {
-                const result = await session.navigateTree(targetId, options);
-                return { cancelled: result.cancelled };
-            },
-            switchSession: async (sessionPath) => {
-                const success = await session.switchSession(sessionPath);
-                return { cancelled: !success };
-            },
-            reload: async () => {
-                await session.reload();
-            },
-        },
-        shutdownHandler: () => {
-            process.exit(0);
-        },
-        onError: (err) => {
-            process.stderr.write(`[extension_error] ${err.extensionPath}: ${err.error}\n`);
-        },
-    });
+export async function runAcpMode(session, options = {}) {
     // Set up ACP connection via stdin/stdout
     const input = Writable.toWeb(process.stdout);
     const output = Readable.toWeb(process.stdin);
     const stream = acp.ndJsonStream(input, output);
-    new acp.AgentSideConnection((conn) => new NanoPencilAgent(conn, session), stream);
+    new acp.AgentSideConnection((conn) => new NanoPencilAgent(conn, session, options), stream);
     // Keep process alive
     return new Promise(() => { });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pencil-agent/nano-pencil",
-  "version": "1.11.13",
+  "version": "1.11.15",
   "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": {