@selesai/code 0.13.26 → 0.13.27

package/dist/core/crash-log.js

@@ -0,0 +1,70 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir, VERSION } from "../config.js";
+const MAX_CRASH_RECORDS = 5;
+const MAX_AGE = 7 * 24 * 60 * 60 * 1000;
+function crashLogPath(agentDir = getAgentDir()) {
+    return join(agentDir, "crashes.json");
+}
+export function readCrashLog(path = crashLogPath()) {
+    try {
+        const records = JSON.parse(readFileSync(path, "utf8"));
+        return Array.isArray(records)
+            ? records.filter((record) => typeof record === "object" &&
+                record !== null &&
+                typeof record.timestamp === "string" &&
+                typeof record.message === "string")
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeCrashLog(records, path) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(records, null, 2)}\n`);
+}
+/** Best-effort persistence for callers that are already crashing. */
+export function recordCrash(crash, path = crashLogPath()) {
+    try {
+        const { error } = crash;
+        const record = {
+            timestamp: new Date().toISOString(),
+            version: VERSION,
+            kind: crash.kind,
+            message: error instanceof Error ? error.message || error.name : String(error),
+            stack: error instanceof Error && error.stack ? error.stack : null,
+            sessionFile: crash.sessionFile ?? null,
+            cwd: crash.cwd,
+        };
+        writeCrashLog([...readCrashLog(path), record].slice(-MAX_CRASH_RECORDS), path);
+        return record;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Return the newest recent crash, marking pending records as announced. */
+export function takeUnnotifiedCrash(path = crashLogPath(), now = Date.now()) {
+    const records = readCrashLog(path);
+    const crash = [...records]
+        .reverse()
+        .find((record) => !record.notified && now - Date.parse(record.timestamp) <= MAX_AGE);
+    if (!crash)
+        return undefined;
+    try {
+        writeCrashLog(records.map((record) => (record.notified ? record : { ...record, notified: true })), path);
+    }
+    catch {
+        // Showing the notice again is harmless.
+    }
+    return crash;
+}
+export function clearCrashLog(path = crashLogPath()) {
+    try {
+        rmSync(path, { force: true });
+    }
+    catch {
+        // The records can be attached again if cleanup fails.
+    }
+}

package/dist/core/experimental.d.ts

@@ -1,5 +1 @@
 export declare function areExperimentalFeaturesEnabled(): boolean;
-export declare function getExperimentalToolSampling(): {
-    readonly type: "json_schema";
-    readonly strict: "prefer";
-} | undefined;

package/dist/core/experimental.js

@@ -1,7 +1,3 @@
-const PREFER_STRICT_TOOL_SAMPLING = { type: "json_schema", strict: "prefer" };
 export function areExperimentalFeaturesEnabled() {
     return process.env.PI_EXPERIMENTAL === "1";
 }
-export function getExperimentalToolSampling() {
-    return areExperimentalFeaturesEnabled() ? PREFER_STRICT_TOOL_SAMPLING : undefined;
-}

package/dist/core/extensions/index.d.ts

@@ -6,6 +6,6 @@ export type { SourceInfo } from "../source-info.ts";
 export { createExtensionRuntime, discoverAndLoadExtensions, loadExtensionFromFactory, loadExtensions, } from "./loader.ts";
 export type { ExtensionErrorListener, ForkHandler, NavigateTreeHandler, NewSessionHandler, ShutdownHandler, SwitchSessionHandler, } from "./runner.ts";
 export { ExtensionRunner } from "./runner.ts";
-export type { AfterProviderResponseEvent, AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppendEntryHandler, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BashToolResultEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BuildSystemPromptOptions, CompactOptions, ContextEvent, ContextEventResult, ContextUsage, CustomToolCallEvent, CustomToolResultEvent, EditorFactory, EditToolCallEvent, EditToolResultEvent, EntryRenderer, EntryRenderOptions, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, FindToolResultEvent, GetActiveToolsHandler, GetAllToolsHandler, GetCommandsHandler, GetThinkingLevelHandler, GrepToolCallEvent, GrepToolResultEvent, InlineExtension, InputEvent, InputEventResult, InputSource, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, LsToolResultEvent, MessageEndEvent, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ModelSelectEvent, ModelSelectSource, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, ReadToolResultEvent, RegisteredCommand, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResolvedSkillInfo, ResourcesDiscoverEvent, ResourcesDiscoverResult, SendMessageHandler, SendUserMessageHandler, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeForkEvent, SessionBeforeForkResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionCompactEvent, SessionEvent, SessionInfoChangedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SetActiveToolsHandler, SetLabelHandler, SetModelHandler, SetThinkingLevelHandler, TerminalInputHandler, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolInfo, ToolRenderResultOptions, ToolResultEvent, ToolResultEventResult, TreePreparation, TurnEndEvent, TurnStartEvent, UIPromptEndEvent, UIPromptKind, UIPromptStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, WriteToolResultEvent, } from "./types.ts";
+export type { AfterProviderResponseEvent, AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppendEntryHandler, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BashToolResultEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BuildSystemPromptOptions, CacheWarmingDecisionEvent, CacheWarmingDecisionEventResult, CompactOptions, ContextEvent, ContextEventResult, ContextUsage, CustomToolCallEvent, CustomToolResultEvent, EditorFactory, EditToolCallEvent, EditToolResultEvent, EntryRenderer, EntryRenderOptions, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, FindToolResultEvent, GetActiveToolsHandler, GetAllToolsHandler, GetCommandsHandler, GetThinkingLevelHandler, GrepToolCallEvent, GrepToolResultEvent, InlineExtension, InputEvent, InputEventResult, InputSource, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, LsToolResultEvent, MessageEndEvent, MessageEndEventResult, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ModelSelectEvent, ModelSelectSource, MarkdownTransformContext, MarkdownTransformer, NormalizedBuildSystemPromptOptions, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, ReadToolResultEvent, RegisteredCommand, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResolvedSkillInfo, ResourcesDiscoverEvent, ResourcesDiscoverResult, SendMessageHandler, SendUserMessageHandler, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeForkEvent, SessionBeforeForkResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionCompactEvent, SessionCompactFailedEvent, SessionEvent, SessionInfoChangedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SetActiveToolsHandler, SetLabelHandler, SetModelHandler, SetThinkingLevelHandler, TerminalInputHandler, ThinkingLevelSelectEvent, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolInfo, ToolRenderResultOptions, ToolResultEvent, ToolResultEventResult, TreePreparation, TurnEndEvent, TurnStartEvent, UIPromptEndEvent, UIPromptKind, UIPromptStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, WriteToolResultEvent, } from "./types.ts";
 export { defineTool, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, } from "./types.ts";
 export { wrapRegisteredTool, wrapRegisteredTools } from "./wrapper.ts";

package/dist/core/extensions/jiti-loader.d.ts

@@ -0,0 +1 @@
+export { createJiti } from "jiti";

package/dist/core/extensions/jiti-loader.js

@@ -0,0 +1,3 @@
+// Normal Node runtimes use jiti's lazy transform so Babel is loaded only when
+// native loading fails and an extension needs transformation.
+export { createJiti } from "jiti";

package/dist/core/extensions/jiti-static-loader.d.ts

@@ -0,0 +1 @@
+export { createJiti } from "jiti/static";

package/dist/core/extensions/jiti-static-loader.js

@@ -0,0 +1,3 @@
+// Compiled binaries need jiti's static entry so Bun and SEA bundlers embed the
+// Babel transform. The module itself remains lazy until an extension is loaded.
+export { createJiti } from "jiti/static";

package/dist/core/extensions/loader.js

@@ -6,58 +6,27 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import * as _bundledPiAgentCore from "@earendil-works/pi-agent-core";
-import * as _bundledPiAiCompat from "@earendil-works/pi-ai/compat";
-import * as _bundledPiAiOauth from "@earendil-works/pi-ai/oauth";
-import * as _bundledPiAiProviders from "@earendil-works/pi-ai/providers/all";
-import * as _bundledPiTui from "@earendil-works/pi-tui";
-import { createJiti } from "jiti/static";
-// Static imports of packages that extensions may use.
-// These MUST be static so Bun bundles them into the compiled binary.
-// The virtualModules option then makes them available to extensions.
-import * as _bundledTypebox from "typebox";
-import * as _bundledTypeboxCompile from "typebox/compile";
-import * as _bundledTypeboxValue from "typebox/value";
-import { CONFIG_DIR_NAME, getAgentDir, isBunBinary } from "../../config.js";
-// NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
-// avoiding a circular dependency. Extensions can import from @earendil-works/pi-coding-agent.
-import * as _bundledPiCodingAgent from "../../index.js";
+import { CONFIG_DIR_NAME, getAgentDir, isBunBinary, isBundledNode } from "../../config.js";
 import { resolvePath } from "../../utils/paths.js";
 import { createEventBus } from "../event-bus.js";
 import { execCommand } from "../exec.js";
 import { createSyntheticSourceInfo } from "../source-info.js";
 import { time } from "../timings.js";
-/** Modules available to extensions via virtualModules (for compiled Bun binary) */
-const VIRTUAL_MODULES = {
-    typebox: _bundledTypebox,
-    "typebox/compile": _bundledTypeboxCompile,
-    "typebox/value": _bundledTypeboxValue,
-    "@sinclair/typebox": _bundledTypebox,
-    "@sinclair/typebox/compile": _bundledTypeboxCompile,
-    "@sinclair/typebox/value": _bundledTypeboxValue,
-    "@earendil-works/pi-agent-core": _bundledPiAgentCore,
-    "@earendil-works/pi-tui": _bundledPiTui,
-    // Extensions resolve the pi-ai root to the compat entrypoint (a strict
-    // superset of the core entrypoint): existing extensions using the old
-    // global API keep working at runtime until compat is removed.
-    "@earendil-works/pi-ai": _bundledPiAiCompat,
-    "@earendil-works/pi-ai/compat": _bundledPiAiCompat,
-    "@earendil-works/pi-ai/oauth": _bundledPiAiOauth,
-    "@earendil-works/pi-ai/providers/all": _bundledPiAiProviders,
-    "@earendil-works/pi-coding-agent": _bundledPiCodingAgent,
-    "@selesai/code": _bundledPiCodingAgent,
-    "@mariozechner/pi-agent-core": _bundledPiAgentCore,
-    "@mariozechner/pi-tui": _bundledPiTui,
-    "@mariozechner/pi-ai": _bundledPiAiCompat,
-    "@mariozechner/pi-ai/compat": _bundledPiAiCompat,
-    "@mariozechner/pi-ai/oauth": _bundledPiAiOauth,
-    "@mariozechner/pi-ai/providers/all": _bundledPiAiProviders,
-    "@mariozechner/pi-coding-agent": _bundledPiCodingAgent,
-};
 const require = createRequire(import.meta.url);
 const isNodeSeaBinary = ("sea" in process.features && process.features.sea === true) ||
     process.getBuiltinModule("node:sea")?.isSea() === true;
 const isTypeScriptSourceRuntime = !isBunBinary && path.extname(fileURLToPath(import.meta.url)) === ".ts";
+const usesEmbeddedModules = isBunBinary || isNodeSeaBinary || isBundledNode;
+let createJitiPromise;
+function getCreateJiti() {
+    createJitiPromise ??= (usesEmbeddedModules ? import("./jiti-static-loader.js") : import("./jiti-loader.js")).then((module) => module.createJiti);
+    return createJitiPromise;
+}
+let virtualModulesPromise;
+function getVirtualModules() {
+    virtualModulesPromise ??= import("./virtual-modules.js").then((module) => module.VIRTUAL_MODULES);
+    return virtualModulesPromise;
+}
 /**
  * Get aliases for jiti (used in Node.js/development mode).
  * In Bun binary mode, virtualModules is used instead.
@@ -210,12 +179,27 @@ function createExtensionAPI(extension, runtime, cwd, eventBus) {
         // Registration methods - write to extension
         on(event, handler) {
             assertActive();
+            const registeredHandler = (...args) => handler(...args);
             const list = extension.handlers.get(event) ?? [];
-            list.push(handler);
+            list.push(registeredHandler);
             extension.handlers.set(event, list);
+            return () => {
+                const handlers = extension.handlers.get(event);
+                if (!handlers)
+                    return;
+                const handlerIndex = handlers.indexOf(registeredHandler);
+                if (handlerIndex === -1)
+                    return;
+                handlers.splice(handlerIndex, 1);
+                if (handlers.length === 0)
+                    extension.handlers.delete(event);
+            };
         },
         registerTool(tool) {
             assertActive();
+            if (typeof tool.parameters !== "object" || tool.parameters === null || Array.isArray(tool.parameters)) {
+                throw new Error(`Tool "${tool.name}" registered by extension "${extension.path}" must define an object parameter schema.`);
+            }
             extension.tools.set(tool.name, {
                 definition: tool,
                 sourceInfo: extension.sourceInfo,
@@ -396,12 +380,18 @@ async function loadExtensionModule(extensionPath, cacheToken) {
             return cachedFactory;
         }
     }
-    const jiti = createJiti(import.meta.url, {
+    const createJitiImpl = await getCreateJiti();
+    // Compiled binaries and the bundled Node distribution use embedded modules.
+    // Source TypeScript reuses host modules and root tsconfig paths. Unbundled
+    // Node builds use dist aliases and do not need the bundled virtual modules.
+    const resolutionOptions = usesEmbeddedModules
+        ? { virtualModules: await getVirtualModules(), tryNative: false }
+        : isTypeScriptSourceRuntime
+            ? { virtualModules: await getVirtualModules(), tsconfigPaths: true }
+            : { alias: getAliases() };
+    const jiti = createJitiImpl(import.meta.url, {
         moduleCache: false,
-        // In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
-        // Also disable tryNative so jiti handles ALL imports (not just the entry point)
-        // In Node.js/dev: use aliases to resolve to node_modules paths
-        ...(isBunBinary ? { virtualModules: VIRTUAL_MODULES, tryNative: false } : { alias: getAliases() }),
+        ...resolutionOptions,
     });
     const module = await jiti.import(extensionPath, { default: true });
     const factory = module;

package/dist/core/extensions/runner.d.ts

@@ -4,22 +4,23 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { ImageContent, Provider, ProviderHeaders } from "@earendil-works/pi-ai";
 import type { KeyId } from "@earendil-works/pi-tui";
+import type { CacheWarmingAction } from "../cache-warmer.ts";
 import type { ResourceDiagnostic } from "../diagnostics.ts";
 import type { KeybindingsConfig } from "../keybindings.ts";
 import type { ModelRegistry } from "../model-registry.ts";
 import type { SessionManager } from "../session-manager.ts";
-import type { BuildSystemPromptOptions } from "../system-prompt.ts";
-import type { BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, ContextEvent, EntryRenderer, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, InputSource, LoadExtensionsResult, MessageEndEvent, MessageRenderer, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventResult, ProviderConfig, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, SessionBeforeCompactResult, SessionBeforeForkResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionShutdownEvent, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult } from "./types.ts";
-/** Combined result from all before_agent_start handlers */
+import { type BuildSystemPromptOptions, type NormalizedBuildSystemPromptOptions } from "../system-prompt.ts";
+import type { BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, CacheWarmingDecisionEvent, ContextEvent, EntryRenderer, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, InputSource, LoadExtensionsResult, MessageEndEvent, MessageRenderer, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventResult, ProviderConfig, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, SessionBeforeCompactResult, SessionBeforeForkResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionShutdownEvent, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult } from "./types.ts";
+/** Combined result from all before_agent_start handlers. */
 interface BeforeAgentStartCombinedResult {
-    messages?: NonNullable<BeforeAgentStartEventResult["message"]>[];
-    systemPrompt?: string;
+    messages: NonNullable<BeforeAgentStartEventResult["message"]>[];
+    systemPromptOptions: NormalizedBuildSystemPromptOptions;
 }
 /**
  * Events handled by the generic emit() method.
  * Events with dedicated emitXxx() methods are excluded for stronger type safety.
  */
-type RunnerEmitEvent = Exclude<ExtensionEvent, ToolCallEvent | ProjectTrustEvent | ToolResultEvent | UserBashEvent | ContextEvent | BeforeProviderRequestEvent | BeforeProviderHeadersEvent | BeforeAgentStartEvent | MessageEndEvent | ResourcesDiscoverEvent | InputEvent>;
+type RunnerEmitEvent = Exclude<ExtensionEvent, ToolCallEvent | ProjectTrustEvent | ToolResultEvent | UserBashEvent | ContextEvent | CacheWarmingDecisionEvent | BeforeProviderRequestEvent | BeforeProviderHeadersEvent | BeforeAgentStartEvent | MessageEndEvent | ResourcesDiscoverEvent | InputEvent>;
 type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends {
     type: "session_before_switch";
 } ? SessionBeforeSwitchResult | undefined : TEvent extends {
@@ -148,6 +149,8 @@ export declare class ExtensionRunner {
     createCommandContext(): ExtensionCommandContext;
     private isSessionBeforeEvent;
     emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>>;
+    /** Returns the event's own action unless a handler overrides it; the last override wins. */
+    emitCacheWarmingDecision(event: CacheWarmingDecisionEvent): Promise<CacheWarmingAction>;
     emitMessageEnd(event: MessageEndEvent): Promise<AgentMessage | undefined>;
     emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;
     emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined>;
@@ -155,7 +158,7 @@ export declare class ExtensionRunner {
     emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
     emitBeforeProviderRequest(payload: unknown): Promise<unknown>;
     emitBeforeProviderHeaders(headers: ProviderHeaders): Promise<ProviderHeaders>;
-    emitBeforeAgentStart(prompt: string, images: ImageContent[] | undefined, systemPrompt: string, systemPromptOptions: BuildSystemPromptOptions): Promise<BeforeAgentStartCombinedResult | undefined>;
+    emitBeforeAgentStart(prompt: string, images: ImageContent[] | undefined, systemPromptOptions: BuildSystemPromptOptions): Promise<BeforeAgentStartCombinedResult>;
     emitResourcesDiscover(cwd: string, reason: ResourcesDiscoverEvent["reason"]): Promise<{
         skillPaths: Array<{
             path: string;

package/dist/core/extensions/runner.js

@@ -2,6 +2,7 @@
  * Extension runner - executes extensions and manages their lifecycle.
  */
 import { theme } from "../../modes/interactive/theme/theme.js";
+import { buildSystemPrompt, normalizeBuildSystemPromptOptions, } from "../system-prompt.js";
 // Extension shortcuts compete with canonical keybinding ids from keybindings.json.
 // Only editor-global shortcuts are reserved here. Picker-specific bindings are not.
 const RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
@@ -46,6 +47,31 @@ const buildBuiltinKeybindings = (resolvedKeybindings) => {
     }
     return builtinKeybindings;
 };
+function isUserBashEventResult(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value;
+    const hasOperations = candidate.operations !== undefined;
+    const hasResult = candidate.result !== undefined;
+    if (hasOperations === hasResult)
+        return false;
+    if (hasOperations) {
+        const operations = candidate.operations;
+        if (typeof operations !== "object" || operations === null)
+            return false;
+        return typeof operations.exec === "function";
+    }
+    const result = candidate.result;
+    if (typeof result !== "object" || result === null)
+        return false;
+    const resultRecord = result;
+    return (typeof resultRecord.output === "string" &&
+        "exitCode" in resultRecord &&
+        (resultRecord.exitCode === undefined || typeof resultRecord.exitCode === "number") &&
+        typeof resultRecord.cancelled === "boolean" &&
+        typeof resultRecord.truncated === "boolean" &&
+        (resultRecord.fullOutputPath === undefined || typeof resultRecord.fullOutputPath === "string"));
+}
 /**
  * Helper function to emit session_shutdown event to extensions.
  * Returns true if the event was emitted, false if there were no handlers.
@@ -57,14 +83,14 @@ export async function emitSessionShutdownEvent(extensionRunner, event) {
     }
     return false;
 }
+function snapshotEventHandlers(extensions, event) {
+    return extensions.map((ext) => ({ ext, handlers: ext.handlers.get(event)?.slice() ?? [] }));
+}
 export async function emitProjectTrustEvent(extensionsResult, event, ctx) {
     const errors = [];
-    for (const ext of extensionsResult.extensions) {
+    for (const { ext, handlers } of snapshotEventHandlers(extensionsResult.extensions, "project_trust")) {
         // A single extension may register multiple handlers for the same event.
         // The first project_trust handler that returns yes/no wins; undecided falls through.
-        const handlers = ext.handlers.get("project_trust");
-        if (!handlers || handlers.length === 0)
-            continue;
         for (const handler of handlers) {
             try {
                 const handlerResult = (await handler(event, ctx));
@@ -139,7 +165,7 @@ export class ExtensionRunner {
     getContextUsageFn = () => undefined;
     compactFn = () => { };
     getSystemPromptFn = () => "";
-    getSystemPromptOptionsFn = () => ({ cwd: this.cwd });
+    getSystemPromptOptionsFn = () => normalizeBuildSystemPromptOptions({ cwd: this.cwd });
     newSessionHandler = async () => ({ cancelled: false });
     forkHandler = async () => ({ cancelled: false });
     navigateTreeHandler = async () => ({ cancelled: false });
@@ -187,7 +213,8 @@ export class ExtensionRunner {
         this.getContextUsageFn = contextActions.getContextUsage;
         this.compactFn = contextActions.compact;
         this.getSystemPromptFn = contextActions.getSystemPrompt;
-        this.getSystemPromptOptionsFn = contextActions.getSystemPromptOptions ?? (() => ({ cwd: this.cwd }));
+        this.getSystemPromptOptionsFn =
+            contextActions.getSystemPromptOptions ?? (() => normalizeBuildSystemPromptOptions({ cwd: this.cwd }));
         // Flush provider registrations queued during extension loading
         for (const { name, config, extensionPath } of this.runtime.pendingProviderRegistrations) {
             try {
@@ -625,10 +652,7 @@ export class ExtensionRunner {
     async emit(event) {
         const ctx = this.createContext();
         let result;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get(event.type);
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, event.type)) {
             for (const handler of handlers) {
                 try {
                     const handlerResult = await handler(event, ctx);
@@ -653,14 +677,34 @@ export class ExtensionRunner {
         }
         return result;
     }
+    /** Returns the event's own action unless a handler overrides it; the last override wins. */
+    async emitCacheWarmingDecision(event) {
+        const ctx = this.createContext();
+        let action = event.action;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, event.type)) {
+            for (const handler of handlers) {
+                try {
+                    const result = (await handler(event, ctx));
+                    if (result?.action !== undefined)
+                        action = result.action;
+                }
+                catch (err) {
+                    this.emitError({
+                        extensionPath: ext.path,
+                        event: event.type,
+                        error: err instanceof Error ? err.message : String(err),
+                        stack: err instanceof Error ? err.stack : undefined,
+                    });
+                }
+            }
+        }
+        return action;
+    }
     async emitMessageEnd(event) {
         const ctx = this.createContext();
         let currentMessage = event.message;
         let modified = false;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("message_end");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "message_end")) {
             for (const handler of handlers) {
                 try {
                     const currentEvent = { ...event, message: currentMessage };
@@ -697,10 +741,7 @@ export class ExtensionRunner {
         const currentEvent = { ...event };
         let modified = false;
         let terminate;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("tool_result");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "tool_result")) {
             for (const handler of handlers) {
                 try {
                     const handlerResult = (await handler(currentEvent, ctx));
@@ -753,10 +794,7 @@ export class ExtensionRunner {
     async emitToolCall(event) {
         const ctx = this.createContext();
         let result;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("tool_call");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { handlers } of snapshotEventHandlers(this.extensions, "tool_call")) {
             for (const handler of handlers) {
                 const handlerResult = await handler(event, ctx);
                 if (handlerResult) {
@@ -771,16 +809,16 @@ export class ExtensionRunner {
     }
     async emitUserBash(event) {
         const ctx = this.createContext();
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("user_bash");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "user_bash")) {
             for (const handler of handlers) {
                 try {
                     const handlerResult = await handler(event, ctx);
-                    if (handlerResult) {
-                        return handlerResult;
+                    if (handlerResult === undefined)
+                        continue;
+                    if (!isUserBashEventResult(handlerResult)) {
+                        throw new Error("Invalid user_bash handler result: return undefined for local execution or exactly one valid { operations } or { result } object");
                     }
+                    return handlerResult;
                 }
                 catch (err) {
                     const message = err instanceof Error ? err.message : String(err);
@@ -791,6 +829,7 @@ export class ExtensionRunner {
                         error: message,
                         stack,
                     });
+                    throw err;
                 }
             }
         }
@@ -799,10 +838,7 @@ export class ExtensionRunner {
     async emitContext(messages) {
         const ctx = this.createContext();
         let currentMessages = structuredClone(messages);
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("context");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "context")) {
             for (const handler of handlers) {
                 try {
                     const event = { type: "context", messages: currentMessages };
@@ -828,10 +864,7 @@ export class ExtensionRunner {
     async emitBeforeProviderRequest(payload) {
         const ctx = this.createContext();
         let currentPayload = payload;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("before_provider_request");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "before_provider_request")) {
             for (const handler of handlers) {
                 try {
                     const event = {
@@ -859,10 +892,7 @@ export class ExtensionRunner {
     }
     async emitBeforeProviderHeaders(headers) {
         const ctx = this.createContext();
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("before_provider_headers");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "before_provider_headers")) {
             for (const handler of handlers) {
                 try {
                     // Handlers mutate `headers` in place; the return value is ignored.
@@ -886,37 +916,34 @@ export class ExtensionRunner {
         }
         return headers;
     }
-    async emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
-        let currentSystemPrompt = systemPrompt;
+    async emitBeforeAgentStart(prompt, images, systemPromptOptions) {
+        const currentOptions = normalizeBuildSystemPromptOptions(systemPromptOptions);
+        const renderCurrentSystemPrompt = () => buildSystemPrompt(currentOptions);
         const ctx = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
         ctx.getSystemPrompt = () => {
             this.assertActive();
-            return currentSystemPrompt;
+            return renderCurrentSystemPrompt();
         };
         const messages = [];
-        let systemPromptModified = false;
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("before_agent_start");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "before_agent_start")) {
             for (const handler of handlers) {
                 try {
                     const event = {
                         type: "before_agent_start",
                         prompt,
                         images,
-                        systemPrompt: currentSystemPrompt,
-                        systemPromptOptions,
+                        get systemPrompt() {
+                            return renderCurrentSystemPrompt();
+                        },
+                        systemPromptOptions: currentOptions,
                     };
                     const handlerResult = await handler(event, ctx);
                     if (handlerResult) {
                         const result = handlerResult;
-                        if (result.message) {
+                        if (result.message)
                             messages.push(result.message);
-                        }
                         if (result.systemPrompt !== undefined) {
-                            currentSystemPrompt = result.systemPrompt;
-                            systemPromptModified = true;
+                            currentOptions.forceSystemPrompt = result.systemPrompt;
                         }
                     }
                 }
@@ -932,23 +959,14 @@ export class ExtensionRunner {
                 }
             }
         }
-        if (messages.length > 0 || systemPromptModified) {
-            return {
-                messages: messages.length > 0 ? messages : undefined,
-                systemPrompt: systemPromptModified ? currentSystemPrompt : undefined,
-            };
-        }
-        return undefined;
+        return { messages, systemPromptOptions: currentOptions };
     }
     async emitResourcesDiscover(cwd, reason) {
         const ctx = this.createContext();
         const skillPaths = [];
         const promptPaths = [];
         const themePaths = [];
-        for (const ext of this.extensions) {
-            const handlers = ext.handlers.get("resources_discover");
-            if (!handlers || handlers.length === 0)
-                continue;
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "resources_discover")) {
             for (const handler of handlers) {
                 try {
                     const event = { type: "resources_discover", cwd, reason };
@@ -983,8 +1001,8 @@ export class ExtensionRunner {
         const ctx = this.createContext();
         let currentText = text;
         let currentImages = images;
-        for (const ext of this.extensions) {
-            for (const handler of ext.handlers.get("input") ?? []) {
+        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "input")) {
+            for (const handler of handlers) {
                 try {
                     const event = {
                         type: "input",