@pencil-agent/nano-pencil 1.11.15 → 1.11.16

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

@@ -222,6 +222,11 @@ export declare class AgentSession {
      * 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

@@ -257,6 +257,13 @@ export class AgentSession {
             ...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/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/modes/acp/acp-mode.js

@@ -66,6 +66,21 @@ function asText(value) {
         return String(value);
     }
 }
+function toolPayloadToText(value) {
+    if (value &&
+        typeof value === "object" &&
+        "content" in value &&
+        Array.isArray(value.content)) {
+        const text = value.content
+            .filter((block) => block?.type === "text" && typeof block.text === "string")
+            .map((block) => block.text)
+            .join("\n");
+        if (text.trim()) {
+            return text;
+        }
+    }
+    return asText(value);
+}
 function createSlashCommandsUpdate(session) {
     const commands = session.getSlashCommands();
     const seen = new Set();
@@ -98,6 +113,14 @@ function getMessageText(message) {
         .filter((part) => part.length > 0)
         .join("\n");
 }
+function isVisibleCustomMessage(message) {
+    return (typeof message === "object" &&
+        message !== null &&
+        "role" in message &&
+        message.role === "custom" &&
+        "display" in message &&
+        message.display === true);
+}
 function isMutatingTool(tool) {
     if (MUTATING_TOOL_NAMES.has(tool.name))
         return true;
@@ -328,6 +351,11 @@ class NanoPencilAgent {
             this.mapEventToAcp(params.sessionId, event);
         });
         try {
+            const extensionHandled = await this.session.tryExecuteExtensionCommand(userText);
+            if (extensionHandled) {
+                await this.emitSessionMetadata(sessionState);
+                return { stopReason: "end_turn" };
+            }
             // @ts-expect-error - source is for internal use
             await this.session.prompt(userText, { source: "acp" });
             await this.emitSessionMetadata(sessionState);
@@ -814,6 +842,21 @@ class NanoPencilAgent {
                 }
                 break;
             }
+            case "message_end":
+                if (isVisibleCustomMessage(event.message)) {
+                    const text = getMessageText(event.message);
+                    if (text.trim()) {
+                        void this.connection.sessionUpdate({
+                            sessionId,
+                            update: {
+                                sessionUpdate: "agent_message_chunk",
+                                content: textToContent(text),
+                                messageId: createMessageId(),
+                            },
+                        });
+                    }
+                }
+                break;
             case "tool_execution_start":
                 void this.connection.sessionUpdate({
                     sessionId,
@@ -828,6 +871,26 @@ class NanoPencilAgent {
                     },
                 });
                 break;
+            case "tool_execution_update":
+                void this.connection.sessionUpdate({
+                    sessionId,
+                    update: {
+                        sessionUpdate: "tool_call_update",
+                        toolCallId: event.toolCallId,
+                        status: "pending",
+                        content: [
+                            {
+                                type: "content",
+                                content: {
+                                    type: "text",
+                                    text: toolPayloadToText(event.partialResult),
+                                },
+                            },
+                        ],
+                        rawOutput: event.partialResult,
+                    },
+                });
+                break;
             case "tool_execution_end":
                 void this.connection.sessionUpdate({
                     sessionId,
@@ -840,7 +903,7 @@ class NanoPencilAgent {
                                 type: "content",
                                 content: {
                                     type: "text",
-                                    text: asText(event.result),
+                                    text: toolPayloadToText(event.result),
                                 },
                             },
                         ],

package/package.json

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