@selesai/code 0.13.40 → 0.14.3

package/dist/modes/interactive/tui-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { Terminal } from "@earendil-works/pi-tui";
+import type { Terminal, WheelScrollLines } from "@earendil-works/pi-tui";
 import { type TUI, TuiAltScreen, TuiMainScreen } from "@earendil-works/pi-tui";
 export interface InteractiveTuiOptions {
     readonly tuiMode: "regular" | "fullscreen";
@@ -7,6 +7,7 @@ export interface InteractiveTuiOptions {
     readonly terminal?: Terminal;
     readonly onRightClickPaste?: () => void;
     readonly fullscreenCopyOnSelect?: boolean;
+    readonly fullscreenWheelScrollLines?: WheelScrollLines;
 }
 /** Composition root shared by coding-agent presentations. */
 export declare function createInteractiveTui(options: InteractiveTuiOptions & {

package/dist/modes/interactive/tui-renderer.js

@@ -19,6 +19,7 @@ export function createInteractiveTui(options) {
             openUrl: openBrowser,
             onRightClickPaste: options.onRightClickPaste,
             copyOnSelect: options.fullscreenCopyOnSelect,
+            wheelScrollLines: options.fullscreenWheelScrollLines ?? "auto",
             copySelection: async (text) => {
                 try {
                     await copyToClipboard(text);

package/dist/modes/json-event.d.ts

@@ -0,0 +1,33 @@
+import type { Usage } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent } from "../core/agent-session.ts";
+type WithoutPartial<T> = T extends {
+    partial: unknown;
+} ? Omit<T, "partial"> : T;
+type ToJsonAssistantMessageEvent<T> = T extends {
+    type: "toolcall_start";
+    partial: unknown;
+} ? WithoutPartial<T> & {
+    id: string;
+    toolName: string;
+} : WithoutPartial<T>;
+type MessageUpdateEvent = Extract<AgentSessionEvent, {
+    type: "message_update";
+}>;
+type JsonMessageUpdateEvent = {
+    type: "message_update";
+    usage: Usage;
+    assistantMessageEvent: ToJsonAssistantMessageEvent<MessageUpdateEvent["assistantMessageEvent"]>;
+};
+/** Session event shape emitted by the JSON and RPC stdout protocols. */
+export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
+    type: "message_update";
+}> | JsonMessageUpdateEvent;
+/**
+ * Remove cumulative assistant snapshots from streaming wire events.
+ * `message_start` provides the initial message, deltas build it, and
+ * `message_end` provides the final authoritative message. Cumulative usage,
+ * tool-call ids, and tool names remain available because their size is constant.
+ */
+export declare function toJsonEvent(event: MessageUpdateEvent): JsonMessageUpdateEvent;
+export declare function toJsonEvent(event: AgentSessionEvent): JsonAgentSessionEvent;
+export {};

package/dist/modes/json-event.js

@@ -0,0 +1,28 @@
+function toJsonAssistantMessageEvent(event) {
+    if (event.type === "toolcall_start") {
+        const toolCall = event.partial.content[event.contentIndex];
+        if (toolCall?.type !== "toolCall") {
+            throw new Error(`toolcall_start content at index ${event.contentIndex} is not a tool call`);
+        }
+        const { partial: _partial, ...deltaEvent } = event;
+        return { ...deltaEvent, id: toolCall.id, toolName: toolCall.name };
+    }
+    if (!("partial" in event)) {
+        return event;
+    }
+    const { partial: _partial, ...deltaEvent } = event;
+    return deltaEvent;
+}
+export function toJsonEvent(event) {
+    if (event.type !== "message_update") {
+        return event;
+    }
+    if (event.message.role !== "assistant") {
+        throw new Error("message_update message is not an assistant message");
+    }
+    return {
+        type: "message_update",
+        usage: event.message.usage,
+        assistantMessageEvent: toJsonAssistantMessageEvent(event.assistantMessageEvent),
+    };
+}

package/dist/modes/print-mode.js

@@ -6,9 +6,10 @@
  * - `pi --mode json "prompt"` - JSON event stream
  */
 import { PACKAGE_NAME, VERSION, getUpdateInstruction } from "../config.js";
-import { flushRawStdout, writeRawStdout } from "../core/output-guard.js";
+import { flushRawStdout, waitForRawStdoutBackpressure, writeRawStdout } from "../core/output-guard.js";
 import { checkForNewPiVersion } from "../utils/version-check.js";
 import { killTrackedDetachedChildren } from "../utils/shell.js";
+import { toJsonEvent } from "./json-event.js";
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.
@@ -18,6 +19,7 @@ export async function runPrintMode(runtimeHost, options) {
     let exitCode = 0;
     let session = runtimeHost.session;
     let unsubscribe;
+    let unsubscribeBackpressure;
     let disposed = false;
     const signalCleanupHandlers = [];
     const disposeRuntime = async () => {
@@ -25,6 +27,7 @@ export async function runPrintMode(runtimeHost, options) {
             return;
         disposed = true;
         unsubscribe?.();
+        unsubscribeBackpressure?.();
         await runtimeHost.dispose();
     };
     const registerSignalHandlers = () => {
@@ -87,11 +90,18 @@ export async function runPrintMode(runtimeHost, options) {
             },
         });
         unsubscribe?.();
+        unsubscribeBackpressure?.();
         unsubscribe = session.subscribe((event) => {
             if (mode === "json") {
-                writeRawStdout(`${JSON.stringify(event)}\n`);
+                writeRawStdout(`${JSON.stringify(toJsonEvent(event))}\n`);
             }
         });
+        unsubscribeBackpressure =
+            mode === "json"
+                ? session.agent.subscribe(async () => {
+                    await waitForRawStdoutBackpressure();
+                })
+                : undefined;
     };
     try {
         if (mode === "json") {

package/dist/modes/rpc/rpc-client.d.ts

@@ -2,7 +2,7 @@ import type { SubagentRpcSnapshot } from "../../core/subagent-rpc.ts";
 import type { ReleaseReadiness, ReleaseResult, StopAllBackgroundResult } from "../../core/release-rpc.ts";
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { ImageContent, Model } from "@earendil-works/pi-ai";
-import type { SessionStats } from "../../core/agent-session.ts";
+import type { PromptDisposition, QueuedInputDisposition, SessionStats } from "../../core/agent-session.ts";
 import type { KeybindingsConfig } from "../../core/keybindings.ts";
 import type { Settings } from "../../core/settings-manager.ts";
 import type { BashResult } from "../../core/bash-executor.ts";
@@ -59,19 +59,19 @@ export declare class RpcClient {
     getStderr(): string;
     /**
      * Send a prompt to the agent.
-     * Returns immediately after sending; use onEvent() to receive streaming events.
-     * Use waitForIdle() to wait for completion.
-     * @param queueWhileCompacting - Buffer the prompt during compaction and send after compaction_end.
+     * Returns the prompt's disposition after acceptance; use onEvent() to receive streaming events.
+     * If the disposition is "handled", no run started for this prompt, so don't wait for agent_settled.
+     * Boolean third arguments retain the fork compaction-buffer option; strings select streaming behavior.
      */
-    prompt(message: string, images?: ImageContent[], queueWhileCompacting?: boolean): Promise<void>;
+    prompt(message: string, images?: ImageContent[], streamingBehavior?: "steer" | "followUp" | boolean, queueWhileCompacting?: boolean): Promise<PromptDisposition>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
-    steer(message: string, images?: ImageContent[]): Promise<void>;
+    steer(message: string, images?: ImageContent[]): Promise<QueuedInputDisposition>;
     /**
      * Queue a follow-up message to be processed after the agent finishes.
      */
-    followUp(message: string, images?: ImageContent[]): Promise<void>;
+    followUp(message: string, images?: ImageContent[]): Promise<QueuedInputDisposition>;
     /**
      * Abort current operation.
      */
@@ -130,7 +130,7 @@ export declare class RpcClient {
         id: string;
     }>;
     /**
-     * Cycle to next (or previous) model.
+     * Cycle to next model.
      */
     cycleModel(direction?: "forward" | "backward"): Promise<{
         model: {
@@ -175,14 +175,6 @@ export declare class RpcClient {
      * Set auto-compaction enabled/disabled.
      */
     setAutoCompaction(enabled: boolean): Promise<void>;
-    /**
-     * Set auto-handoff enabled/disabled.
-     */
-    setAutoHandoff(enabled: boolean): Promise<void>;
-    /**
-     * Set auto-handoff threshold in tokens.
-     */
-    setAutoHandoffThresholdTokens(tokens: number): Promise<void>;
     /**
      * Set auto-retry enabled/disabled.
      */
@@ -246,7 +238,7 @@ export declare class RpcClient {
         leafId: string | null;
     }>;
     /**
-     * Get the session entry tree, optionally filtered.
+     * Get the session entry tree.
      */
     getTree(filter?: "default" | "no-tools" | "user-only" | "labeled-only" | "all"): Promise<{
         tree: SessionTreeNode[];
@@ -307,7 +299,7 @@ export declare class RpcClient {
      */
     getMessages(): Promise<AgentMessage[]>;
     /**
-     * Get available commands (extension commands, prompt templates, builtins).
+     * Get available commands (extension commands, prompt templates, skills).
      */
     getCommands(): Promise<RpcSlashCommand[]>;
     /**
@@ -449,7 +441,7 @@ export declare class RpcClient {
     /**
      * Collect events until agent becomes idle.
      */
-    collectEvents(timeout?: number): Promise<RpcEvent[]>;
+    collectEvents(timeout?: number, signal?: AbortSignal): Promise<RpcEvent[]>;
     /**
      * Send prompt and wait for completion, returning all events.
      */

package/dist/modes/rpc/rpc-client.js

@@ -129,24 +129,31 @@ export class RpcClient {
     // =========================================================================
     /**
      * Send a prompt to the agent.
-     * Returns immediately after sending; use onEvent() to receive streaming events.
-     * Use waitForIdle() to wait for completion.
-     * @param queueWhileCompacting - Buffer the prompt during compaction and send after compaction_end.
-     */
-    async prompt(message, images, queueWhileCompacting) {
-        await this.send({ type: "prompt", message, images, queueWhileCompacting });
+     * Returns the prompt's disposition after acceptance; use onEvent() to receive streaming events.
+     * If the disposition is "handled", no run started for this prompt, so don't wait for agent_settled.
+     * Boolean third arguments retain the fork compaction-buffer option; strings select streaming behavior.
+     */
+    async prompt(message, images, streamingBehavior, queueWhileCompacting) {
+        const response = await this.send({
+            type: "prompt", message, images,
+            streamingBehavior: typeof streamingBehavior === "string" ? streamingBehavior : undefined,
+            queueWhileCompacting: typeof streamingBehavior === "boolean" ? streamingBehavior : queueWhileCompacting,
+        });
+        return this.getData(response).disposition;
     }
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
     async steer(message, images) {
-        await this.send({ type: "steer", message, images });
+        const response = await this.send({ type: "steer", message, images });
+        return this.getData(response).disposition;
     }
     /**
      * Queue a follow-up message to be processed after the agent finishes.
      */
     async followUp(message, images) {
-        await this.send({ type: "follow_up", message, images });
+        const response = await this.send({ type: "follow_up", message, images });
+        return this.getData(response).disposition;
     }
     /**
      * Abort current operation.
@@ -228,7 +235,7 @@ export class RpcClient {
         return this.getData(response);
     }
     /**
-     * Cycle to next (or previous) model.
+     * Cycle to next model.
      */
     async cycleModel(direction) {
         const response = await this.send({ type: "cycle_model", direction });
@@ -287,18 +294,6 @@ export class RpcClient {
     async setAutoCompaction(enabled) {
         await this.send({ type: "set_auto_compaction", enabled });
     }
-    /**
-     * Set auto-handoff enabled/disabled.
-     */
-    async setAutoHandoff(enabled) {
-        await this.send({ type: "set_auto_handoff", enabled });
-    }
-    /**
-     * Set auto-handoff threshold in tokens.
-     */
-    async setAutoHandoffThresholdTokens(tokens) {
-        await this.send({ type: "set_auto_handoff_threshold", tokens });
-    }
     /**
      * Set auto-retry enabled/disabled.
      */
@@ -377,7 +372,7 @@ export class RpcClient {
         return this.getData(response);
     }
     /**
-     * Get the session entry tree, optionally filtered.
+     * Get the session entry tree.
      */
     async getTree(filter) {
         const response = await this.send({ type: "get_tree", ...(filter ? { filter } : {}) });
@@ -448,7 +443,7 @@ export class RpcClient {
         return this.getData(response).messages;
     }
     /**
-     * Get available commands (extension commands, prompt templates, builtins).
+     * Get available commands (extension commands, prompt templates, skills).
      */
     async getCommands() {
         const response = await this.send({ type: "get_commands" });
@@ -639,30 +634,51 @@ export class RpcClient {
     /**
      * Collect events until agent becomes idle.
      */
-    collectEvents(timeout = 60000) {
+    collectEvents(timeout = 60000, signal) {
         return new Promise((resolve, reject) => {
             const events = [];
-            const timer = setTimeout(() => {
+            const cleanup = () => {
+                clearTimeout(timer);
                 unsubscribe();
+                signal?.removeEventListener("abort", finish);
+            };
+            const finish = () => {
+                cleanup();
+                resolve(events);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
                 reject(new Error(`Timeout collecting events. Stderr: ${this.stderr}`));
             }, timeout);
             const unsubscribe = this.onEvent((event) => {
                 events.push(event);
-                if (event.type === "agent_settled") {
-                    clearTimeout(timer);
-                    unsubscribe();
-                    resolve(events);
-                }
+                if (event.type === "agent_settled")
+                    finish();
             });
+            signal?.addEventListener("abort", finish, { once: true });
+            if (signal?.aborted)
+                finish();
         });
     }
     /**
      * Send prompt and wait for completion, returning all events.
      */
     async promptAndWait(message, images, timeout = 60000) {
-        const eventsPromise = this.collectEvents(timeout);
-        await this.prompt(message, images);
-        return eventsPromise;
+        const controller = new AbortController();
+        const eventsPromise = this.collectEvents(timeout, controller.signal);
+        try {
+            const [, events] = await Promise.all([
+                this.prompt(message, images).then((disposition) => {
+                    if (disposition === "handled")
+                        controller.abort();
+                }),
+                eventsPromise,
+            ]);
+            return events;
+        }
+        finally {
+            controller.abort();
+        }
     }
     // =========================================================================
     // Internal
@@ -677,8 +693,9 @@ export class RpcClient {
                 pending.resolve(data);
                 return;
             }
-            // Otherwise it's an event
-            for (const listener of this.eventListeners) {
+            // Otherwise it's an event. Iterate a snapshot so listeners that unsubscribe during dispatch
+            // do not cause later listeners to miss this event.
+            for (const listener of [...this.eventListeners]) {
                 listener(data);
             }
         }

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

@@ -19,6 +19,7 @@ import { spawnSync } from "node:child_process";
 import { chmodSync, copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
+import { toJsonEvent } from "../json-event.js";
 import { generateHandoff } from "../../core/handoff.js";
 import { buildGitCommandPrompt } from "../../core/git-command.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -396,7 +397,7 @@ export async function runRpcMode(runtimeHost) {
         unsubscribe?.();
         unsubscribeBackpressure?.();
         unsubscribe = session.subscribe((event) => {
-            output(event);
+            output(toJsonEvent(event));
             if (event.type === "agent_settled") {
                 void checkShutdownRequested();
             }
@@ -625,7 +626,7 @@ export async function runRpcMode(runtimeHost) {
                         images: command.images,
                         streamingBehavior: command.streamingBehavior,
                     };
-                    output(success(id, "prompt")); // accepted into the buffer
+                    output(success(id, "prompt", { disposition: "queued" })); // accepted into the buffer
                     compactionPromptQueue.push(queued);
                     return undefined;
                 }
@@ -635,11 +636,9 @@ export async function runRpcMode(runtimeHost) {
                     images: command.images,
                     streamingBehavior: command.streamingBehavior,
                     source: "rpc",
-                    preflightResult: (didSucceed) => {
-                        if (didSucceed) {
-                            preflightSucceeded = true;
-                            output(success(id, "prompt"));
-                        }
+                    preflightResult: (disposition) => {
+                        preflightSucceeded = true;
+                        output(success(id, "prompt", { disposition }));
                     },
                 })
                     .catch((e) => {
@@ -653,12 +652,12 @@ export async function runRpcMode(runtimeHost) {
                 return undefined;
             }
             case "steer": {
-                await session.steer(command.message, command.images, { source: "rpc" });
-                return success(id, "steer");
+                const disposition = await session.steer(command.message, command.images, { source: "rpc" });
+                return success(id, "steer", { disposition });
             }
             case "follow_up": {
-                await session.followUp(command.message, command.images, { source: "rpc" });
-                return success(id, "follow_up");
+                const disposition = await session.followUp(command.message, command.images, { source: "rpc" });
+                return success(id, "follow_up", { disposition });
             }
             case "abort": {
                 // TUI Esc parity: cancel in-flight branch summarization and compaction as well,
@@ -717,8 +716,6 @@ export async function runRpcMode(runtimeHost) {
                     sessionId: session.sessionId,
                     sessionName: session.sessionName,
                     autoCompactionEnabled: session.autoCompactionEnabled,
-                    autoHandoffEnabled: session.autoHandoffEnabled,
-                    autoHandoffThresholdTokens: session.autoHandoffThresholdTokens,
                     messageCount: session.messages.length,
                     pendingMessageCount: session.pendingMessageCount,
                     steering: session.getSteeringMessages(),
@@ -752,7 +749,7 @@ export async function runRpcMode(runtimeHost) {
             // Model
             // =================================================================
             case "set_model": {
-                const models = await session.modelRuntime.getAvailable();
+                const models = session.modelRuntime.getAvailableSnapshot();
                 const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
                 if (!model) {
                     return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
@@ -824,18 +821,6 @@ export async function runRpcMode(runtimeHost) {
                 session.setAutoCompactionEnabled(command.enabled);
                 return success(id, "set_auto_compaction");
             }
-            case "set_auto_handoff": {
-                session.settingsManager.setAutoHandoffEnabled(command.enabled);
-                return success(id, "set_auto_handoff");
-            }
-            case "set_auto_handoff_threshold": {
-                const tokens = command.tokens;
-                if (!Number.isFinite(tokens) || tokens < 1000) {
-                    return error(id, "set_auto_handoff_threshold", "Threshold must be at least 1000 tokens");
-                }
-                session.settingsManager.setAutoHandoffThresholdTokens(tokens);
-                return success(id, "set_auto_handoff_threshold");
-            }
             // =================================================================
             // Retry
             // =================================================================

package/dist/modes/rpc/rpc-types.d.ts

@@ -9,12 +9,12 @@ export type { ReleaseCommand, ReleaseResponse, ReleaseResult, ReleaseReadinessCo
  * Responses and events are emitted as JSON lines on stdout.
  */
 import type { IntercomRpcCommand, IntercomRpcResponse, IntercomRpcEvent } from "../../core/intercom-rpc.ts";
-import type { AgentSessionEvent } from "../../core/agent-session.ts";
+import type { JsonAgentSessionEvent } from "../json-event.ts";
 export type { IntercomRpcCommand, IntercomRpcResponse, IntercomRpcEvent, IntercomRpcStatus, IntercomRpcDelivery, IntercomRpcMessageOptions, IntercomRpcDataMap } from "../../core/intercom-rpc.ts";
-export type RpcEvent = AgentSessionEvent | IntercomRpcEvent | SubagentRpcEvent | RpcExtensionUIRequest;
+export type RpcEvent = JsonAgentSessionEvent | IntercomRpcEvent | SubagentRpcEvent | RpcExtensionUIRequest;
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { ImageContent, Model } from "@earendil-works/pi-ai";
-import type { SessionStats } from "../../core/agent-session.ts";
+import type { PromptDisposition, QueuedInputDisposition, SessionStats } from "../../core/agent-session.ts";
 import type { KeybindingsConfig } from "../../core/keybindings.ts";
 import type { Settings, SettingsScope } from "../../core/settings-manager.ts";
 import type { BashResult } from "../../core/bash-executor.ts";
@@ -101,14 +101,6 @@ export type RpcCommand = IntercomRpcCommand | SubagentRpcCommand | ReleaseReadin
     id?: string;
     type: "set_auto_compaction";
     enabled: boolean;
-} | {
-    id?: string;
-    type: "set_auto_handoff";
-    enabled: boolean;
-} | {
-    id?: string;
-    type: "set_auto_handoff_threshold";
-    tokens: number;
 } | {
     id?: string;
     type: "set_auto_retry";
@@ -320,8 +312,6 @@ export interface RpcSessionState {
     sessionId: string;
     sessionName?: string;
     autoCompactionEnabled: boolean;
-    autoHandoffEnabled: boolean;
-    autoHandoffThresholdTokens: number;
     messageCount: number;
     pendingMessageCount: number;
     steering: readonly string[];
@@ -341,16 +331,25 @@ export type RpcResponse = IntercomRpcResponse | SubagentRpcResponse | ReleaseRea
     type: "response";
     command: "prompt";
     success: true;
+    data: {
+        disposition: PromptDisposition;
+    };
 } | {
     id?: string;
     type: "response";
     command: "steer";
     success: true;
+    data: {
+        disposition: QueuedInputDisposition;
+    };
 } | {
     id?: string;
     type: "response";
     command: "follow_up";
     success: true;
+    data: {
+        disposition: QueuedInputDisposition;
+    };
 } | {
     id?: string;
     type: "response";
@@ -453,16 +452,6 @@ export type RpcResponse = IntercomRpcResponse | SubagentRpcResponse | ReleaseRea
     type: "response";
     command: "set_auto_compaction";
     success: true;
-} | {
-    id?: string;
-    type: "response";
-    command: "set_auto_handoff";
-    success: true;
-} | {
-    id?: string;
-    type: "response";
-    command: "set_auto_handoff_threshold";
-    success: true;
 } | {
     id?: string;
     type: "response";

package/dist/package-manager-cli.js

@@ -7,11 +7,11 @@ import { APP_NAME, CONFIG_DIR_NAME, detectInstallMethod, getAgentDir, getPackage
 import { ModelRuntime } from "./core/model-runtime.js";
 import { DefaultPackageManager } from "./core/package-manager.js";
 import { resolveProjectTrusted } from "./core/project-trust.js";
-import { DefaultResourceLoader } from "./core/resource-loader.js";
+import { DefaultResourceLoader, isBuiltinExtension } from "./core/resource-loader.js";
 import { SettingsManager } from "./core/settings-manager.js";
 import { hasTrustRequiringProjectResources, ProjectTrustStore } from "./core/trust-manager.js";
 import { spawnProcess } from "./utils/child-process.js";
-import { getLatestPackageRelease, getLatestPiRelease, isNewerPackageVersion } from "./utils/version-check.js";
+import { formatVersionCheckError, getLatestPackageRelease, getLatestPiRelease, isNewerPackageVersion } from "./utils/version-check.js";
 import { cleanupWindowsSelfUpdateQuarantine, quarantineWindowsNativeDependencies, } from "./utils/windows-self-update.js";
 const SELF_UPDATE_NOTE_MARKDOWN_THEME = {
     heading: (text) => chalk.bold(chalk.yellow(text)),
@@ -356,6 +356,12 @@ async function refreshModelCatalogs(agentDir) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 15_000);
     try {
+        const modelRuntime = await ModelRuntime.create({
+            authPath: join(agentDir, "auth.json"),
+            modelsPath: join(agentDir, "models.json"),
+            allowModelNetwork: false,
+            signal: controller.signal,
+        });
         const result = await modelRuntime.refresh({
             allowNetwork: true,
             force: true,
@@ -425,8 +431,9 @@ async function getSelfUpdatePlan(force, installMethod = detectInstallMethod()) {
             APP_NAME === "pi" ? await getLatestPiRelease(VERSION) : await getLatestPackageRelease(PACKAGE_NAME, VERSION);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Could not determine latest ${APP_NAME} version: ${message}`);
+        throw new Error(`Could not determine latest ${APP_NAME} version: ${formatVersionCheckError(error)}`, {
+            cause: error,
+        });
     }
     if (!latestRelease) {
         throw new Error(`Could not determine latest ${APP_NAME} version.`);
@@ -572,14 +579,18 @@ export async function handleConfigCommand(args, runtimeOptions = {}) {
         return true;
     }
     reportSettingsErrors(settingsManager, "config command");
+    const builtinExtensions = (runtimeOptions.extensionFactories ?? [])
+        .filter(isBuiltinExtension)
+        .map((input) => input.name);
     const globalSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
     const globalResolvedPaths = await new DefaultPackageManager({
         cwd,
         agentDir,
         settingsManager: globalSettingsManager,
+        builtinExtensions,
     }).resolve();
     const projectResolvedPaths = settingsManager.isProjectTrusted()
-        ? await new DefaultPackageManager({ cwd, agentDir, settingsManager }).resolve()
+        ? await new DefaultPackageManager({ cwd, agentDir, settingsManager, builtinExtensions }).resolve()
         : globalResolvedPaths;
     await selectConfig({
         resolvedPaths: { global: globalResolvedPaths, project: projectResolvedPaths },

package/dist/rpc-entry.js

@@ -4,6 +4,7 @@ import { configureHttpDispatcher } from "./core/http-dispatcher.js";
 import { main } from "./main.js";
 process.title = `${APP_NAME}-rpc`;
 process.env.PI_CODING_AGENT = "true";
+process.env.AI_AGENT = "pi";
 process.emitWarning = (() => { });
 configureHttpDispatcher();
 main(["--mode", "rpc", ...process.argv.slice(2)]);