@pencil-agent/nano-pencil 1.11.14 → 1.11.16

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

@@ -16,7 +16,7 @@ const isProductionBuild = typeof import.meta.url === "string" && import.meta.url
 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) {

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,16 @@ 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[];
+    /**
+     * Try to execute an extension slash command directly.
+     * Returns true when a matching extension command was found, even if it failed internally.
+     */
+    tryExecuteExtensionCommand(text: string): Promise<boolean>;
     /** Emit an event to all listeners */
     private _emit;
     private _lastAssistantMessage;

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

@@ -219,6 +219,51 @@ 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,
+        ];
+    }
+    /**
+     * Try to execute an extension slash command directly.
+     * Returns true when a matching extension command was found, even if it failed internally.
+     */
+    async tryExecuteExtensionCommand(text) {
+        return this._tryExecuteExtensionCommand(text);
+    }
     // =========================================================================
     // Event Subscription
     // =========================================================================

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

@@ -39,6 +39,20 @@ function recordLoopEvent(pi, message) {
         timestamp: Date.now(),
     });
 }
+function publishLoopUpdate(pi, bus, message, type = "info") {
+    recordLoopEvent(pi, message);
+    notify(bus, message, type);
+    pi.sendMessage({
+        customType: LOOP_CUSTOM_TYPE,
+        content: message,
+        display: true,
+        details: {
+            message,
+            level: type,
+            timestamp: Date.now(),
+        },
+    });
+}
 function notify(bus, message, type = "info") {
     notifyByBus.get(bus)?.(message, type);
 }
@@ -243,7 +257,7 @@ function dispatchNextIteration(pi, bus, controller) {
     }
     const prompt = controller.buildPrompt();
     controller.markDispatched();
-    notify(bus, `[Loop] Starting iteration ${task.currentIteration} for ${task.id}`, "info");
+    publishLoopUpdate(pi, bus, `[Loop] Starting iteration ${task.currentIteration} for ${task.id}.`, "info");
     pi.sendUserMessage(prompt, { deliverAs: "followUp" });
 }
 export default async function loopExtension(pi) {
@@ -294,11 +308,10 @@ export default async function loopExtension(pi) {
             const failure = controller.recordFailure("Loop run ended without an assistant message.");
             if (failure.action === "stop") {
                 const message = describeTerminalSnapshot(failure.snapshot);
-                recordLoopEvent(pi, message);
-                notify(bus, message, "warning");
+                publishLoopUpdate(pi, bus, message, "warning");
                 return;
             }
-            recordLoopEvent(pi, `[Loop] Iteration failed. Retrying iteration ${failure.task?.currentIteration}.`);
+            publishLoopUpdate(pi, bus, `[Loop] Iteration failed. Retrying iteration ${failure.task?.currentIteration}.`, "warning");
             dispatchNextIteration(pi, bus, controller);
             return;
         }
@@ -307,20 +320,18 @@ export default async function loopExtension(pi) {
             const failure = controller.recordFailure("Assistant response did not include a valid <loop-state> block.");
             if (failure.action === "stop") {
                 const message = describeTerminalSnapshot(failure.snapshot);
-                recordLoopEvent(pi, message);
-                notify(bus, message, "warning");
+                publishLoopUpdate(pi, bus, message, "warning");
                 return;
             }
-            recordLoopEvent(pi, `[Loop] Missing or invalid loop-state block. Retrying iteration ${failure.task?.currentIteration}.`);
+            publishLoopUpdate(pi, bus, `[Loop] Missing or invalid loop-state block. Retrying iteration ${failure.task?.currentIteration}.`, "warning");
             dispatchNextIteration(pi, bus, controller);
             return;
         }
-        recordLoopEvent(pi, describeDecision(decision));
+        publishLoopUpdate(pi, bus, describeDecision(decision), "info");
         const next = controller.finishTurn(decision);
         if (next.action === "stop") {
             const message = describeTerminalSnapshot(next.snapshot);
-            recordLoopEvent(pi, message);
-            notify(bus, message, decision.status === "complete" ? "info" : "warning");
+            publishLoopUpdate(pi, bus, message, decision.status === "complete" ? "info" : "warning");
             return;
         }
         dispatchNextIteration(pi, bus, controller);
@@ -335,8 +346,7 @@ export default async function loopExtension(pi) {
             if (parsed.type === "help") {
                 const reason = parsed.reason === "empty" ? "Missing loop goal." : undefined;
                 const help = buildHelp(reason);
-                recordLoopEvent(pi, help);
-                notify(bus, help, "warning");
+                publishLoopUpdate(pi, bus, help, "warning");
                 return;
             }
             if (parsed.type === "status") {
@@ -346,16 +356,14 @@ export default async function loopExtension(pi) {
                     : state.lastTerminal
                         ? formatSnapshot(state.lastTerminal)
                         : "[Loop] No loop task has been started in this session.";
-                recordLoopEvent(pi, message);
-                notify(bus, message, "info");
+                publishLoopUpdate(pi, bus, message, "info");
                 return;
             }
             if (parsed.type === "stop") {
                 const activeTask = controller.getActiveTask();
                 if (!activeTask) {
                     const message = "[Loop] No active loop is running.";
-                    recordLoopEvent(pi, message);
-                    notify(bus, message, "warning");
+                    publishLoopUpdate(pi, bus, message, "warning");
                     return;
                 }
                 controller.stop("Stopped by user request.", "stopped");
@@ -363,8 +371,7 @@ export default async function loopExtension(pi) {
                     ctx.abort();
                 }
                 const message = `[Loop] Stopped loop ${activeTask.id}.`;
-                recordLoopEvent(pi, message);
-                notify(bus, message, "info");
+                publishLoopUpdate(pi, bus, message, "info");
                 return;
             }
             try {
@@ -374,15 +381,13 @@ export default async function loopExtension(pi) {
                     `Goal: ${task.goal}`,
                     `Safety limits: ${task.maxIterations} iterations, ${task.maxConsecutiveFailures} consecutive failures.`,
                 ].join("\n");
-                recordLoopEvent(pi, message);
-                notify(bus, `[Loop] Started ${task.id}: ${summarizeGoal(task.goal)}`, "info");
+                publishLoopUpdate(pi, bus, message, "info");
                 dispatchNextIteration(pi, bus, controller);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 const output = `[Loop] ${message}`;
-                recordLoopEvent(pi, output);
-                notify(bus, output, "error");
+                publishLoopUpdate(pi, bus, output, "error");
             }
         },
     });

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/defaults/team/index.js

@@ -349,6 +349,49 @@ function formatState(state) {
     }
     return lines.join("\n");
 }
+function createProgressReport(state) {
+    return {
+        id: state.id,
+        goal: state.goal,
+        mode: state.mode,
+        status: state.status,
+        startedAt: state.startedAt,
+        finishedAt: state.updatedAt,
+        plan: state.plan ?? createFallbackPlan(state.goal, state.mode),
+        results: [...state.results],
+        finalSummary: state.lastWorkerSummary ?? "",
+    };
+}
+function buildProgressUpdate(state, message) {
+    const lines = [
+        `Team run ${state.id} is in stage "${state.stage}".`,
+        `Goal: ${summarizeGoal(state.goal, 120)}`,
+    ];
+    if (message) {
+        lines.push(`Progress: ${message}`);
+    }
+    if (state.plan?.summary) {
+        lines.push(`Plan: ${state.plan.summary}`);
+    }
+    if (state.results.length > 0) {
+        lines.push(`Completed workers: ${state.results.length}`);
+    }
+    if (state.lastWorkerSummary) {
+        lines.push(`Latest result: ${state.lastWorkerSummary}`);
+    }
+    if (state.lastError) {
+        lines.push(`Last error: ${state.lastError}`);
+    }
+    return lines.join("\n");
+}
+function emitProgressUpdate(onUpdate, state, message) {
+    if (!onUpdate || !state)
+        return;
+    onUpdate({
+        content: [{ type: "text", text: buildProgressUpdate(state, message) }],
+        details: createProgressReport(state),
+    });
+}
 function formatReport(report) {
     const lines = [
         `[Team] Run ${report.id}`,
@@ -733,7 +776,7 @@ async function runWorker(pi, ctx, goal, plan, worker, previousResults) {
     }
     return parsed;
 }
-async function orchestrateTeamRun(pi, ctx, goal, mode) {
+async function orchestrateTeamRun(pi, ctx, goal, mode, onUpdate) {
     const controller = getController(pi);
     const active = controller.getActive();
     if (!active) {
@@ -742,16 +785,21 @@ async function orchestrateTeamRun(pi, ctx, goal, mode) {
     controller.update({ stage: "planning" });
     persistState(pi, controller.getActive());
     syncRunUi(ctx, controller.getActive());
+    emitProgressUpdate(onUpdate, controller.getActive(), "Creating the team plan.");
     const plan = await createPlan(pi, ctx, goal, mode);
     controller.update({ plan, stage: "parallel research" });
     persistState(pi, controller.getActive());
     syncRunUi(ctx, controller.getActive());
-    const researchResults = await Promise.all(plan.researchWorkers.map((worker) => runWorker(pi, ctx, goal, plan, worker, [])));
-    for (const result of researchResults) {
+    emitProgressUpdate(onUpdate, controller.getActive(), `Plan ready. Launching ${plan.researchWorkers.length} research worker${plan.researchWorkers.length === 1 ? "" : "s"}.`);
+    const researchResults = await Promise.all(plan.researchWorkers.map(async (worker) => {
+        emitProgressUpdate(onUpdate, controller.getActive(), `Started ${worker.role} (${worker.id}).`);
+        const result = await runWorker(pi, ctx, goal, plan, worker, []);
         controller.appendResult(result);
         persistState(pi, controller.getActive());
         syncRunUi(ctx, controller.getActive());
-    }
+        emitProgressUpdate(onUpdate, controller.getActive(), `${worker.role} finished with status ${result.status}.`);
+        return result;
+    }));
     const allResults = [...researchResults];
     const executionMode = mode === "research" ? "research_only" : plan.executionMode;
     if (executionMode === "implement_and_review") {
@@ -765,10 +813,12 @@ async function orchestrateTeamRun(pi, ctx, goal, mode) {
         controller.update({ stage: "implementation" });
         persistState(pi, controller.getActive());
         syncRunUi(ctx, controller.getActive());
+        emitProgressUpdate(onUpdate, controller.getActive(), "Starting the implementation worker.");
         const implementationResult = await runWorker(pi, ctx, goal, plan, implementationWorker, allResults);
         controller.appendResult(implementationResult);
         persistState(pi, controller.getActive());
         syncRunUi(ctx, controller.getActive());
+        emitProgressUpdate(onUpdate, controller.getActive(), `Implementation worker finished with status ${implementationResult.status}.`);
         allResults.push(implementationResult);
         const reviewWorker = {
             id: "reviewer",
@@ -780,10 +830,12 @@ async function orchestrateTeamRun(pi, ctx, goal, mode) {
         controller.update({ stage: "review" });
         persistState(pi, controller.getActive());
         syncRunUi(ctx, controller.getActive());
+        emitProgressUpdate(onUpdate, controller.getActive(), "Starting the review worker.");
         const reviewResult = await runWorker(pi, ctx, goal, plan, reviewWorker, allResults);
         controller.appendResult(reviewResult);
         persistState(pi, controller.getActive());
         syncRunUi(ctx, controller.getActive());
+        emitProgressUpdate(onUpdate, controller.getActive(), `Review worker finished with status ${reviewResult.status}.`);
         allResults.push(reviewResult);
     }
     const status = allResults.some((result) => result.status === "failed")
@@ -803,6 +855,14 @@ async function orchestrateTeamRun(pi, ctx, goal, mode) {
         finalSummary: "",
     };
     const finalSummary = buildFinalSummary(provisionalReport);
+    controller.update({
+        stage: "finished",
+        status,
+        lastWorkerSummary: finalSummary,
+    });
+    persistState(pi, controller.getActive());
+    syncRunUi(ctx, controller.getActive());
+    emitProgressUpdate(onUpdate, controller.getActive(), `Team run finished with status ${status}.`);
     const report = controller.finish(status, finalSummary);
     if (!report) {
         return { ...provisionalReport, finalSummary };
@@ -887,13 +947,14 @@ export default async function teamExtension(pi) {
         description: "Delegate a task to a coordinated team of workers, but only when the user explicitly asked for Agent team or multi-agent execution.",
         guidance: "Only use team_run when the user explicitly requested Agent team, multi-agent, or subagent execution. Do not call it proactively.",
         parameters: TEAM_TOOL_PARAMS,
-        execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
+        execute: async (_toolCallId, params, _signal, onUpdate, ctx) => {
             ensureExplicitTeamTrigger(ctx, params.goal);
             const controller = getController(pi);
             const active = controller.start(params.goal, params.mode ?? "auto");
             persistState(pi, active);
+            emitProgressUpdate(onUpdate, active, "Team run started.");
             try {
-                const report = await orchestrateTeamRun(pi, ctx, params.goal, params.mode ?? "auto");
+                const report = await orchestrateTeamRun(pi, ctx, params.goal, params.mode ?? "auto", onUpdate);
                 report.artifactPath = writeReportArtifact(report, ctx.cwd);
                 persistReport(pi, report);
                 return {
@@ -904,6 +965,7 @@ export default async function teamExtension(pi) {
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 controller.update({ lastError: message, stage: "failed" });
+                emitProgressUpdate(onUpdate, controller.getActive(), message);
                 const report = controller.finish("failed", message) ?? {
                     id: active.id,
                     goal: params.goal,

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