@pencil-agent/nano-pencil 1.14.2 → 1.14.4

package/dist/core/i18n/slash-commands.zh.js

@@ -5,16 +5,27 @@
  * [HERE]: core/i18n/slash-commands.zh.ts - Chinese slash command translations
  */
 export const slashCommands = {
+    categories: {
+        core: "核心",
+        model: "模型",
+        memory: "记忆",
+        session: "会话",
+        workflow: "工作流",
+        agents: "Agent",
+        tools: "工具",
+        admin: "管理",
+    },
     settings: "打开设置菜单",
     model: "选择模型（打开选择器界面）",
-    "agent-loop": "设置本会话的 standard/弱模型兼容 agent loop",
-    "scoped-models": "启用/禁用 Ctrl+P 循环的模型",
+    thinking: "选择当前模型的推理深度",
+    "agent-loop": "选择 agent 推进任务的方式",
+    "scoped-models": "选择快速切换里出现的模型",
     apikey: "更新当前提供商的 API 密钥",
     mcp: "管理 MCP 服务器（列出、启用、禁用）",
     soul: "显示 AI 人格和统计（灵魂）",
     persona: "切换 AI 人格/个性包",
     memory: "显示项目记忆和知识（纳米记忆）",
-    dream: "整合项目记忆（纳米记忆）",
+    dream: "刷新长期项目记忆（纳米记忆）",
     export: "将会话导出为 HTML 文件",
     share: "将会话分享为保密的 GitHub gist",
     copy: "复制上一条 AI 消息到剪贴板",
@@ -24,6 +35,7 @@ export const slashCommands = {
     usage: "显示 token 使用量和费用统计",
     changelog: "显示更新日志条目",
     hotkeys: "显示所有键盘快捷键",
+    resources: "显示已加载的扩展、提示、技能和主题",
     fork: "从上一条消息创建新分支",
     tree: "导航会话树（切换分支）",
     login: "通过 OAuth 提供商登录",
@@ -34,7 +46,7 @@ export const slashCommands = {
     compact: "手动压缩会话上下文",
     resume: "恢复其他会话",
     reload: "重新加载扩展、技能、提示和主题",
-    "link-world": "安装 link-world 以获得互联网访问（Twitter、YouTube 等）",
+    "link-world": "设置联网访问工具",
     quit: "退出 NanoPencil",
     language: "切换语言（English/中文）",
 };

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

@@ -342,6 +342,10 @@ export declare class AgentSession {
     prompt(text: string, options?: PromptOptions): Promise<void>;
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
+     *
+     * Delegates to ExtensionRunner.invokeCommand() so command dispatch, error
+     * routing (emitError), and telemetry (ext_command_events) all happen in one
+     * place rather than being scattered across modes.
      */
     private _tryExecuteExtensionCommand;
     /**
@@ -516,6 +520,7 @@ export declare class AgentSession {
      * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
      */
     private _checkCompaction;
+    private _recoverModelErrorInLoop;
     /**
      * Internal: Run auto-compaction with events.
      */

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

@@ -1,5 +1,5 @@
 /**
- * [WHO]: AgentSession class, session lifecycle, event emission
+ * [WHO]: AgentSession class, session lifecycle, event emission, in-loop context-overflow recovery adapter
  * [FROM]: Depends on agent-core, ai, core/tools/*, core/session/*, core/config/*
  * [TO]: Consumed by core/index.ts, core/runtime/sdk.ts, modes/interactive/interactive-mode.ts, modes/print-mode.ts, modes/rpc/rpc-mode.ts, modes/acp/acp-mode.ts, modes/rpc/rpc-types.ts, modes/rpc/rpc-client.ts, modes/interactive/components/footer.ts, modes/interactive/components/skill-invocation-message.ts
  * [HERE]: Central runtime hub; all modes delegate to this class
@@ -29,6 +29,7 @@ import { CompactionCoordinator } from "../session/compaction/compaction-coordina
 import { ToolOrchestrator } from "../tools/orchestrator.js";
 import { ModelSwitcher } from "../model/index.js";
 import { DEFAULT_THINKING_LEVEL } from "../defaults.js";
+import { createExtensionTelemetrySink } from "../telemetry/index.js";
 import { exportSessionToHtml, } from "../export-html/index.js";
 import { createToolHtmlRenderer } from "../export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, wrapToolsWithExtensions, } from "../extensions/index.js";
@@ -158,6 +159,7 @@ export class AgentSession {
         this._soulManager = config.soulManager;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._baseToolsOverride = config.baseToolsOverride;
+        this.agent.setModelErrorRecovery((event) => this._recoverModelErrorInLoop(event));
         // Always subscribe to agent events for internal handling
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
@@ -844,32 +846,22 @@ export class AgentSession {
     }
     /**
      * Try to execute an extension command. Returns true if command was found and executed.
+     *
+     * Delegates to ExtensionRunner.invokeCommand() so command dispatch, error
+     * routing (emitError), and telemetry (ext_command_events) all happen in one
+     * place rather than being scattered across modes.
      */
     async _tryExecuteExtensionCommand(text) {
         if (!this._extensionRunner)
             return false;
-        // Parse command name and args
         const spaceIndex = text.indexOf(" ");
         const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
         const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1);
-        const command = this._extensionRunner.getCommand(commandName);
-        if (!command)
-            return false;
-        // Get command context from extension runner (includes session control methods)
         const ctx = this._extensionRunner.createCommandContext();
-        try {
-            await command.handler(args, ctx);
-            return true;
-        }
-        catch (err) {
-            // Emit error via extension runner
-            this._extensionRunner.emitError({
-                extensionPath: `command:${commandName}`,
-                event: "command",
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return true;
-        }
+        const result = await this._extensionRunner.invokeCommand(commandName, args, ctx, {
+            sessionId: this.sessionManager.getSessionId(),
+        });
+        return result.found;
     }
     /**
      * Expand skill commands (/skill:name args) to their full content.
@@ -1585,12 +1577,72 @@ export class AgentSession {
             await this._runAutoCompaction("threshold", false);
         }
     }
+    async _recoverModelErrorInLoop(event) {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (event.message.role !== "assistant")
+            return { action: "stop" };
+        const assistantMessage = event.message;
+        if (event.errorSubtype !== "context_overflow") {
+            if (!this._retryCoordinator.isRetryableError(assistantMessage)) {
+                return { action: "stop" };
+            }
+            const shouldRetry = await this._retryCoordinator.handleErrorInLoop(assistantMessage);
+            if (!shouldRetry)
+                return { action: "stop" };
+            const messages = this.agent.state.messages;
+            const retryMessages = messages.at(-1)?.role === "assistant" ? messages.slice(0, -1) : messages;
+            this.agent.replaceMessages(retryMessages);
+            return {
+                action: "retry",
+                messages: retryMessages,
+                transition: {
+                    reason: "model_error_recovery",
+                    subtype: event.errorSubtype,
+                    attempt: event.attempt,
+                },
+            };
+        }
+        if (!settings.enabled)
+            return { action: "stop" };
+        const contextWindow = this.model?.contextWindow ?? 0;
+        const sameModel = this.model &&
+            assistantMessage.provider === this.model.provider &&
+            assistantMessage.model === this.model.id;
+        if (!sameModel || !isContextOverflow(assistantMessage, contextWindow)) {
+            return { action: "stop" };
+        }
+        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
+        const errorIsFromBeforeCompaction = compactionEntry !== null &&
+            assistantMessage.timestamp < new Date(compactionEntry.timestamp).getTime();
+        if (errorIsFromBeforeCompaction)
+            return { action: "stop" };
+        const messages = this.agent.state.messages;
+        if (messages.length > 0 &&
+            messages[messages.length - 1].role === "assistant") {
+            this.agent.replaceMessages(messages.slice(0, -1));
+        }
+        const recoveredMessages = await this._runAutoCompaction("overflow", true, {
+            triggerContinue: false,
+        });
+        if (!recoveredMessages)
+            return { action: "stop" };
+        return {
+            action: "retry",
+            messages: recoveredMessages,
+            transition: {
+                reason: "model_error_recovery",
+                subtype: event.errorSubtype,
+                attempt: event.attempt,
+            },
+        };
+    }
     /**
      * Internal: Run auto-compaction with events.
      */
-    async _runAutoCompaction(reason, willRetry) {
+    async _runAutoCompaction(reason, willRetry, options) {
         this._logger.info("Auto-compaction triggered", { reason, willRetry });
         const settings = this.settingsManager.getCompactionSettings();
+        const triggerContinue = options?.triggerContinue ?? true;
         this._emit({ type: "auto_compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
         try {
@@ -1601,7 +1653,7 @@ export class AgentSession {
                     aborted: false,
                     willRetry: false,
                 });
-                return;
+                return undefined;
             }
             const apiKey = await this._modelRegistry.getApiKey(this.model);
             if (!apiKey) {
@@ -1611,7 +1663,7 @@ export class AgentSession {
                     aborted: false,
                     willRetry: false,
                 });
-                return;
+                return undefined;
             }
             const pathEntries = this.sessionManager.getBranch();
             const preparation = prepareCompaction(pathEntries, settings);
@@ -1622,7 +1674,7 @@ export class AgentSession {
                     aborted: false,
                     willRetry: false,
                 });
-                return;
+                return undefined;
             }
             let extensionCompaction;
             let fromExtension = false;
@@ -1641,7 +1693,7 @@ export class AgentSession {
                         aborted: true,
                         willRetry: false,
                     });
-                    return;
+                    return undefined;
                 }
                 if (extensionResult?.compaction) {
                     extensionCompaction = extensionResult.compaction;
@@ -1674,7 +1726,7 @@ export class AgentSession {
                     aborted: true,
                     willRetry: false,
                 });
-                return;
+                return undefined;
             }
             this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromExtension);
             const newEntries = this.sessionManager.getEntries();
@@ -1701,7 +1753,7 @@ export class AgentSession {
                 aborted: false,
                 willRetry,
             });
-            if (willRetry) {
+            if (willRetry && triggerContinue) {
                 const messages = this.agent.state.messages;
                 const lastMsg = messages[messages.length - 1];
                 if (lastMsg?.role === "assistant" &&
@@ -1712,13 +1764,14 @@ export class AgentSession {
                     this.agent.continue().catch(() => { });
                 }, 100);
             }
-            else if (this.agent.hasQueuedMessages()) {
+            else if (!willRetry && this.agent.hasQueuedMessages()) {
                 // Auto-compaction can complete while follow-up/steering/custom messages are waiting.
                 // Kick the loop so queued messages are actually delivered.
                 setTimeout(() => {
                     this.agent.continue().catch(() => { });
                 }, 100);
             }
+            return sessionContext.messages;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
@@ -1731,6 +1784,7 @@ export class AgentSession {
                     ? `Context overflow recovery failed: ${errorMessage}`
                     : `Auto-compaction failed: ${errorMessage}`,
             });
+            return undefined;
         }
         finally {
             this._autoCompactionAbortController = undefined;
@@ -1881,6 +1935,10 @@ export class AgentSession {
         if (this._extensionRunner) {
             this._bindExtensionCore(this._extensionRunner);
             this._applyExtensionBindings(this._extensionRunner);
+            // P1 extension telemetry: every /command invocation writes one row to
+            // ext_command_events. Returns a noop sink when no insforge credentials
+            // are configured, so this is zero-cost for users not opted in.
+            this._extensionRunner.setTelemetrySink(createExtensionTelemetrySink({ workspaceRoot: this._cwd }));
         }
         const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
         const allCustomTools = [

package/dist/core/runtime/extension-core-bindings.d.ts

@@ -1,8 +1,8 @@
 /**
- * [WHO]: Provides bindExtensionCore()
- * [FROM]: Depends on ExtensionRunner, model/session/resource abstractions, slash command metadata
+ * [WHO]: Provides bindExtensionCore() — wires AgentSession host methods to ExtensionRunner APIs, including LLM call telemetry (every ctx.completeSimple / completeSimpleWithUsage / completeJson emits one ext_llm_calls row)
+ * [FROM]: Depends on ExtensionRunner, model/session/resource abstractions, slash command metadata, core/telemetry (getExtCallerContext for caller attribution + LlmCallEventInput shape)
  * [TO]: Consumed by AgentSession when initializing extension runtime capabilities
- * [HERE]: core/runtime/extension-core-bindings.ts - adapts AgentSession host methods to ExtensionRunner APIs
+ * [HERE]: core/runtime/extension-core-bindings.ts - the LLM-call instrumentation point; reads AsyncLocalStorage context pushed by runner.invokeCommand (user-initiated=true) or runner.invokeHookHandler (user-initiated=false) to attribute each call. is_user_initiated=false rows grouped by extension_name + caller_context are the idle-thinking bug detector.
  */
 import type { Model } from "@pencil-agent/ai";
 import type { ThinkingLevel } from "@pencil-agent/agent-core";

package/dist/core/runtime/extension-core-bindings.js

@@ -1,4 +1,5 @@
 import { completeSimple } from "@pencil-agent/ai";
+import { getExtCallerContext } from "../telemetry/index.js";
 import { buildExtensionSlashCommands } from "./slash-command-catalog.js";
 function getStructuredToolChoice(model, toolName) {
     switch (model.api) {
@@ -21,33 +22,73 @@ function isTextContent(block) {
 function isNamedToolCall(block, toolName) {
     return block.type === "toolCall" && "name" in block && block.name === toolName;
 }
-async function completeTextWithCurrentModel(host, systemPrompt, userMessage) {
-    const result = await completeTextWithUsage(host, systemPrompt, userMessage);
+/**
+ * Build the LlmCallEventInput row for one extension-initiated LLM call. Reads
+ * the AsyncLocalStorage caller context pushed by ExtensionRunner — that's how
+ * we know which extension and whether the path was user-initiated. Falls back
+ * to `extension_name="unknown"` + `is_user_initiated=false` when no context is
+ * set (defensive: that combination shows up in dashboards as "unattributed",
+ * a useful signal in itself).
+ */
+function buildLlmCallEvent(args) {
+    const callerCtx = getExtCallerContext();
+    return {
+        extensionName: callerCtx?.extensionName ?? "unknown",
+        callerContext: callerCtx?.callerContext ?? "unknown",
+        isUserInitiated: callerCtx?.isUserInitiated ?? false,
+        modelId: args.model?.id ?? null,
+        tokensIn: args.usage?.input ?? null,
+        tokensOut: args.usage?.output ?? null,
+        costTotal: args.usage?.cost?.total ?? null,
+        durationMs: Math.round(performance.now() - args.startPerf),
+        ok: args.ok,
+        errorCode: args.errorCode,
+        startedAt: args.startedAt,
+        endedAt: new Date(),
+        sessionId: callerCtx?.sessionId ?? args.host.sessionManager.getSessionId(),
+        runId: callerCtx?.runId ?? null,
+        variant: callerCtx?.variant ?? null,
+    };
+}
+async function completeTextWithCurrentModel(runner, host, systemPrompt, userMessage) {
+    const result = await completeTextWithUsage(runner, host, systemPrompt, userMessage);
     return result?.text;
 }
-async function completeTextWithUsage(host, systemPrompt, userMessage) {
+async function completeTextWithUsage(runner, host, systemPrompt, userMessage) {
     const model = host.model;
     if (!model)
         return undefined;
     const apiKey = await host.modelRegistry.getApiKey(model);
     if (!apiKey)
         return undefined;
+    const startedAt = new Date();
+    const startPerf = performance.now();
+    let ok = true;
+    let errorCode = null;
+    let usage;
+    let text;
     try {
         const response = await completeSimple(model, {
             systemPrompt,
             messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
         }, { maxTokens: 1500, temperature: 0.2, apiKey });
-        const text = response.content
-            ?.filter(isTextContent)
-            .map((block) => block.text ?? "")
-            .join("") ?? "";
-        return { text, usage: response.usage };
+        usage = response.usage;
+        text =
+            response.content
+                ?.filter(isTextContent)
+                .map((block) => block.text ?? "")
+                .join("") ?? "";
     }
-    catch {
-        return undefined;
+    catch (err) {
+        ok = false;
+        errorCode = err instanceof Error ? err.constructor.name : "unknown";
     }
+    runner.writeLlmCallEvent(buildLlmCallEvent({ host, model, startedAt, startPerf, ok, errorCode, usage }));
+    if (!ok || text === undefined || usage === undefined)
+        return undefined;
+    return { text, usage };
 }
-async function completeJsonWithCurrentModel(host, systemPrompt, userMessage, schema, options) {
+async function completeJsonWithCurrentModel(runner, host, systemPrompt, userMessage, schema, options) {
     const model = host.model;
     if (!model)
         return undefined;
@@ -55,6 +96,12 @@ async function completeJsonWithCurrentModel(host, systemPrompt, userMessage, sch
     if (!apiKey)
         return undefined;
     const toolName = options?.toolName || "submit_json";
+    const startedAt = new Date();
+    const startPerf = performance.now();
+    let ok = true;
+    let errorCode = null;
+    let usage;
+    let payloadString;
     try {
         const toolSchema = schema;
         const completionOptions = {
@@ -74,15 +121,21 @@ async function completeJsonWithCurrentModel(host, systemPrompt, userMessage, sch
                 },
             ],
         }, completionOptions);
+        usage = response.usage;
         const toolCall = response.content?.find((block) => isNamedToolCall(block, toolName));
-        if (!toolCall)
-            return undefined;
-        const payload = options?.resultKey ? toolCall.arguments?.[options.resultKey] : toolCall.arguments;
-        return JSON.stringify(payload);
+        if (toolCall) {
+            const payload = options?.resultKey ? toolCall.arguments?.[options.resultKey] : toolCall.arguments;
+            payloadString = JSON.stringify(payload);
+        }
     }
-    catch {
-        return undefined;
+    catch (err) {
+        ok = false;
+        errorCode = err instanceof Error ? err.constructor.name : "unknown";
     }
+    runner.writeLlmCallEvent(buildLlmCallEvent({ host, model, startedAt, startPerf, ok, errorCode, usage }));
+    if (!ok)
+        return undefined;
+    return payloadString;
 }
 export function bindExtensionCore(runner, host) {
     runner.bindCore({
@@ -146,9 +199,9 @@ export function bindExtensionCore(runner, host) {
         setThinkingLevel: (level) => host.setThinkingLevel(level),
     }, {
         getModel: () => host.model,
-        completeSimple: (systemPrompt, userMessage) => completeTextWithCurrentModel(host, systemPrompt, userMessage),
-        completeSimpleWithUsage: (systemPrompt, userMessage) => completeTextWithUsage(host, systemPrompt, userMessage),
-        completeJson: (systemPrompt, userMessage, schema, options) => completeJsonWithCurrentModel(host, systemPrompt, userMessage, schema, options),
+        completeSimple: (systemPrompt, userMessage) => completeTextWithCurrentModel(runner, host, systemPrompt, userMessage),
+        completeSimpleWithUsage: (systemPrompt, userMessage) => completeTextWithUsage(runner, host, systemPrompt, userMessage),
+        completeJson: (systemPrompt, userMessage, schema, options) => completeJsonWithCurrentModel(runner, host, systemPrompt, userMessage, schema, options),
         getSettings: () => host.settingsManager.getSettings(),
         isIdle: () => !host.isStreaming,
         abort: () => {

package/dist/core/runtime/retry-coordinator.d.ts

@@ -1,5 +1,5 @@
 /**
- * [WHO]: RetryCoordinator class, auto-retry with exponential backoff
+ * [WHO]: RetryCoordinator class, auto-retry with exponential backoff, in-loop retry preparation
  * [FROM]: Depends on agent-core (AssistantMessage), ai (isContextOverflow), core/runtime/utils/sleep
  * [TO]: Consumed by core/runtime/agent-session.ts
  * [HERE]: core/runtime/retry-coordinator.ts - retry orchestration extracted from AgentSession
@@ -62,6 +62,15 @@ export declare class RetryCoordinator {
      * @returns true if retry was initiated, false if max retries exceeded or disabled
      */
     handleError(message: AssistantMessage): Promise<boolean>;
+    /**
+     * Handle a retryable error inside an active agent loop.
+     *
+     * Unlike handleError(), this does not mutate host messages and does not
+     * schedule agent.continue(); the caller remains responsible for replacing
+     * loop context and continuing in-place.
+     */
+    handleErrorInLoop(message: AssistantMessage): Promise<boolean>;
+    private _prepareRetry;
     /**
      * Called when an assistant response succeeds — resets retry counter
      * and resolves the pending retry promise.

package/dist/core/runtime/retry-coordinator.js

@@ -44,6 +44,26 @@ export class RetryCoordinator {
      * @returns true if retry was initiated, false if max retries exceeded or disabled
      */
     async handleError(message) {
+        const shouldRetry = await this._prepareRetry(message);
+        if (!shouldRetry)
+            return false;
+        // Remove error message from agent state
+        this._host.removeLastAssistantMessage();
+        // Trigger retry via continue()
+        this._host.triggerContinue();
+        return true;
+    }
+    /**
+     * Handle a retryable error inside an active agent loop.
+     *
+     * Unlike handleError(), this does not mutate host messages and does not
+     * schedule agent.continue(); the caller remains responsible for replacing
+     * loop context and continuing in-place.
+     */
+    async handleErrorInLoop(message) {
+        return this._prepareRetry(message);
+    }
+    async _prepareRetry(message) {
         const settings = this._host.getRetrySettings();
         if (!settings.enabled)
             return false;
@@ -73,8 +93,6 @@ export class RetryCoordinator {
             delayMs,
             errorMessage: message.errorMessage || "Unknown error",
         });
-        // Remove error message from agent state
-        this._host.removeLastAssistantMessage();
         // Wait with exponential backoff (abortable)
         this._retryAbortController = new AbortController();
         try {
@@ -94,8 +112,6 @@ export class RetryCoordinator {
             return false;
         }
         this._retryAbortController = undefined;
-        // Trigger retry via continue()
-        this._host.triggerContinue();
         return true;
     }
     /**

package/dist/core/runtime/sdk.js

@@ -1,5 +1,5 @@
 /**
- * [WHO]: createAgentSession(options) → AgentSession + load results
+ * [WHO]: createAgentSession(options) → AgentSession + load results, runtime loop setting wiring
  * [FROM]: Depends on agent-core, ai, core/config/*, core/tools/*, core/session/*, core/mcp-*, i18n/*
  * [TO]: Consumed by index.ts, main.ts, test/presence-opening.test.ts, extensions/defaults/team/index.ts
  * [HERE]: SDK factory; creates all services with DI, wires up extensions
@@ -250,6 +250,7 @@ export async function createAgentSession(options = {}) {
         agentLoopFramework: settingsManager.getAgentLoopFramework(),
         thinkingBudgets: settingsManager.getThinkingBudgets(),
         maxRetryDelayMs: settingsManager.getRetrySettings().maxDelayMs,
+        maxToolResultBatchSizeChars: settingsManager.getAgentLoopSettings().maxToolResultBatchSizeChars,
         getApiKey: async (provider) => {
             // Use the provider argument from the in-flight request;
             // agent.state.model may already be switched mid-turn.

package/dist/core/runtime/slash-command-catalog.d.ts

@@ -7,11 +7,12 @@
 import type { ResourceLoader } from "../config/resource-loader.js";
 import type { ExtensionRunner } from "../extensions/index.js";
 import type { PromptTemplate } from "../prompt/prompt-templates.js";
-import { getLocalizedCommands, type SlashCommandInfo } from "../slash-commands.js";
+import { getLocalizedCommands, type SlashCommandInfo, type SlashCommandCategory } from "../slash-commands.js";
 export interface SessionSlashCommandDescriptor {
     name: string;
     description?: string;
     source: "builtin" | SlashCommandInfo["source"];
+    category?: SlashCommandCategory;
 }
 type Translate = Parameters<typeof getLocalizedCommands>[0];
 export interface SlashCommandCatalogSource {

package/dist/core/runtime/slash-command-catalog.js

@@ -1,4 +1,4 @@
-import { BUILTIN_SLASH_COMMANDS, getLocalizedCommands, } from "../slash-commands.js";
+import { BUILTIN_SLASH_COMMANDS, getLocalizedCommands, inferSlashCommandCategory, } from "../slash-commands.js";
 function normalizeLocation(source) {
     if (source === "user" || source === "project" || source === "path") {
         return source;
@@ -16,6 +16,7 @@ function getExtensionCommands(runner, reservedBuiltins) {
         name: command.name,
         description: command.description,
         path: extensionPath,
+        category: inferSlashCommandCategory(command.name, "extension"),
     })) ?? []);
 }
 export function buildSessionSlashCommands(source, translate) {
@@ -23,22 +24,26 @@ export function buildSessionSlashCommands(source, translate) {
         name: command.name,
         description: command.description,
         source: "builtin",
+        category: command.category,
     }));
     const reservedBuiltins = getReservedBuiltinNames();
     const extensionCommands = getExtensionCommands(source.extensionRunner, reservedBuiltins).map((command) => ({
         name: command.name,
         description: command.description,
         source: "extension",
+        category: command.category,
     }));
     const promptCommands = source.promptTemplates.map((template) => ({
         name: template.name,
         description: template.description,
         source: "prompt",
+        category: inferSlashCommandCategory(template.name, "prompt"),
     }));
     const skillCommands = source.resourceLoader.getSkills().skills.map((skill) => ({
         name: `skill:${skill.name}`,
         description: skill.description,
         source: "skill",
+        category: inferSlashCommandCategory(skill.name, "skill"),
     }));
     return [
         ...builtins,
@@ -53,12 +58,14 @@ export function buildExtensionSlashCommands(source) {
         name: command.name,
         description: command.description,
         source: "extension",
+        category: command.category,
         path: command.path,
     }));
     const templates = source.promptTemplates.map((template) => ({
         name: template.name,
         description: template.description,
         source: "prompt",
+        category: inferSlashCommandCategory(template.name, "prompt"),
         location: normalizeLocation(template.source),
         path: template.filePath,
     }));
@@ -68,6 +75,7 @@ export function buildExtensionSlashCommands(source) {
         name: `skill:${skill.name}`,
         description: skill.description,
         source: "skill",
+        category: inferSlashCommandCategory(skill.name, "skill"),
         location: normalizeLocation(skill.source),
         path: skill.filePath,
     }));

package/dist/core/slash-commands.d.ts

@@ -1,25 +1,36 @@
 /**
- * [WHO]: SlashCommandInfo, BuiltinSlashCommand, slashCommand definitions, getLocalizedCommands()
+ * [WHO]: SlashCommandInfo, BuiltinSlashCommand, slashCommand definitions, category helpers, getLocalizedCommands()
  * [FROM]: No external dependencies
  * [TO]: Consumed by modes/interactive/interactive-mode.ts, modes/acp/acp-mode.ts
  * [HERE]: core/slash-commands.ts - slash command types and registry
  */
 export type SlashCommandSource = "extension" | "prompt" | "skill";
 export type SlashCommandLocation = "user" | "project" | "path";
+export type SlashCommandCategory = "core" | "model" | "memory" | "session" | "workflow" | "agents" | "tools" | "admin";
+export type SlashCommandImplementation = "core" | "extension";
 export interface SlashCommandInfo {
     name: string;
     description?: string;
     source: SlashCommandSource;
+    category?: SlashCommandCategory;
     location?: SlashCommandLocation;
     path?: string;
 }
 export interface BuiltinSlashCommand {
     name: string;
     descriptionKey: string;
+    category: SlashCommandCategory;
+    implementation?: SlashCommandImplementation;
 }
 export declare const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand>;
+export declare function getExtensionBackedBuiltinCommandNames(): Set<string>;
+export declare function inferSlashCommandCategory(name: string, source?: SlashCommandSource): SlashCommandCategory;
+export declare function getSlashCommandCategoryLabel(category: SlashCommandCategory, t: (key: string) => string): string;
+export declare function formatSlashCommandDescription(description: string | undefined, category: SlashCommandCategory | undefined, t: (key: string) => string): string | undefined;
 export interface LocalizedSlashCommand {
     name: string;
     description: string;
+    category: SlashCommandCategory;
+    categoryLabel: string;
 }
 export declare function getLocalizedCommands(t: (key: string) => string): LocalizedSlashCommand[];