@psnext/slingcli 3.0.20260820-2 → 3.0.20260827-1

package/node_modules/@earendil-works/pi-coding-agent/dist/core/auth-storage.js

@@ -2,14 +2,16 @@
  * CredentialStore implementation backed by auth.json.
  * Provider auth orchestration belongs to ModelRuntime and pi-ai Models.
  */
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { setTimeout as sleep } from "timers/promises";
 import { getAgentDir } from "../config.js";
 import { raceWithAbortSignal } from "../utils/abort.js";
 import { getFileRevision, normalizePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { isCommandConfigValue, resolveConfigValue } from "./resolve-config-value.js";
+// The mode applies only on creation so administrator-managed modes and ACLs remain intact.
 const AUTH_FILE_WRITE_OPTIONS = { encoding: "utf-8", mode: 0o600 };
 let sharedAuthFileReadState;
 export class FileAuthStorageBackend {
@@ -26,7 +28,6 @@ export class FileAuthStorageBackend {
     ensureFileExists() {
         if (!existsSync(this.authPath)) {
             writeFileSync(this.authPath, "{}", AUTH_FILE_WRITE_OPTIONS);
-            chmodSync(this.authPath, 0o600);
         }
     }
     acquireLockSyncWithRetry(path) {
@@ -63,7 +64,6 @@ export class FileAuthStorageBackend {
             const { result, next } = fn(current);
             if (next !== undefined) {
                 writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
-                chmodSync(this.authPath, 0o600);
             }
             return result;
         }
@@ -138,7 +138,6 @@ export class FileAuthStorageBackend {
             options?.signal?.throwIfAborted();
             if (next !== undefined) {
                 writeFileSync(this.authPath, next, AUTH_FILE_WRITE_OPTIONS);
-                chmodSync(this.authPath, 0o600);
             }
             throwIfCompromised();
             return result;
@@ -166,7 +165,7 @@ export class ReadOnlyAuthStorage {
             return this.data;
         let parsed;
         try {
-            parsed = JSON.parse(readFileSync(this.authPath, "utf-8"));
+            parsed = JSON.parse(stripBom(readFileSync(this.authPath, "utf-8")));
         }
         catch (error) {
             if (error.code === "ENOENT") {
@@ -296,7 +295,7 @@ export class AuthStorage {
         if (!content) {
             return {};
         }
-        return JSON.parse(content);
+        return JSON.parse(stripBom(content));
     }
     updateReadState(data, revision) {
         this.readState.data = data;
@@ -417,7 +416,7 @@ export class AuthStorage {
  */
 export function readStoredCredential(providerId, authPath = join(getAgentDir(), "auth.json")) {
     try {
-        const data = JSON.parse(readFileSync(normalizePath(authPath), "utf-8"));
+        const data = JSON.parse(stripBom(readFileSync(normalizePath(authPath), "utf-8")));
         return data[providerId];
     }
     catch {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/compaction/branch-summarization.js

@@ -6,7 +6,7 @@
  */
 import { contentText } from "@earendil-works/pi-ai";
 import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
-import { completeSummarization, estimateTokens } from "./compaction.js";
+import { completeSummarization, estimateTokens, getSummarizationFailure } from "./compaction.js";
 import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
 // ============================================================================
 // Entry Collection
@@ -227,8 +227,12 @@ export async function generateBranchSummary(entries, options) {
     if (response.stopReason === "aborted") {
         return { aborted: true };
     }
-    if (response.stopReason === "error") {
-        return { error: response.errorMessage || "Summarization failed" };
+    const failure = getSummarizationFailure(response, "Branch summarization");
+    if (failure) {
+        return { error: failure };
+    }
+    if (response.content.some((block) => block.type === "toolCall")) {
+        return { error: "Branch summarization attempted to call a tool" };
     }
     let summary = contentText(response.content);
     // Prepend preamble to provide context about the branch summary

package/node_modules/@earendil-works/pi-coding-agent/dist/core/compaction/compaction.js

@@ -385,9 +385,7 @@ Use this EXACT format:
 - [Or "(none)" if not applicable]
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
-const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
-
-Update the existing structured summary with new information. RULES:
+const UPDATE_SUMMARIZATION_INSTRUCTIONS = `Update the existing structured summary with new information. RULES:
 - PRESERVE all existing information from the previous summary
 - ADD new progress, decisions, and context from the new messages
 - UPDATE the Progress section: move items from "In Progress" to "Done" when completed
@@ -423,8 +421,24 @@ Use this EXACT format:
 - [Preserve important context, add new if needed]
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
-function createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel) {
-    const options = { maxTokens, signal, apiKey, headers, env };
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+${UPDATE_SUMMARIZATION_INSTRUCTIONS}`;
+/**
+ * Returns an error message when a summarization response cannot safely be persisted.
+ * A length stop contains partial text and must not become a session checkpoint.
+ */
+export function getSummarizationFailure(response, label) {
+    if (response.stopReason === "error") {
+        return `${label} failed: ${response.errorMessage || "Unknown error"}`;
+    }
+    if (response.stopReason === "length") {
+        return `${label} failed: generation hit the token cap and the summary is incomplete`;
+    }
+    return undefined;
+}
+function createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel, sessionId) {
+    const options = { maxTokens, signal, apiKey, headers, env, sessionId };
     if (model.reasoning && thinkingLevel && thinkingLevel !== "off") {
         options.reasoning = thinkingLevel;
     }
@@ -438,11 +452,12 @@ function createSummarizationOptions(model, maxTokens, apiKey, headers, env, sign
  * immediately (see {@link retryAssistantCall}).
  */
 export async function completeSummarization(model, context, options, streamFn, retry, callbacks) {
-    // Summaries are standalone requests, so isolate routing and avoid cache writes that cannot be reused.
+    // Avoid cache writes for one-off summaries. Reuse caller-supplied routing when available;
+    // callers without a session ID, including branch summaries, receive a fresh routing ID.
     const requestOptions = {
         ...options,
         cacheRetention: "none",
-        sessionId: uuidv7(),
+        sessionId: options.sessionId ?? uuidv7(),
     };
     const produce = async () => streamFn
         ? (await streamFn(model, context, requestOptions)).result()
@@ -453,11 +468,24 @@ export async function completeSummarization(model, context, options, streamFn, r
  * Generate a summary of the conversation using the LLM.
  * If previousSummary is provided, uses the update prompt to merge.
  */
-export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks) {
-    return (await generateSummaryWithUsage(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks)).text;
+export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks, sessionId) {
+    return (await generateSummaryWithUsage(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks, sessionId)).text;
+}
+/** Build the provider context for a standalone summary request. */
+function buildSummarizationContext(promptText) {
+    return {
+        systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
+        messages: [
+            {
+                role: "user",
+                content: [{ type: "text", text: promptText }],
+                timestamp: Date.now(),
+            },
+        ],
+    };
 }
 /** Generate or update a conversation summary and return its provider usage. */
-export async function generateSummaryWithUsage(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks) {
+export async function generateSummaryWithUsage(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks, sessionId) {
     const maxTokens = Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
     // Use update prompt if we have a previous summary, otherwise initial prompt
     let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
@@ -474,17 +502,14 @@ export async function generateSummaryWithUsage(currentMessages, model, reserveTo
         promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
     }
     promptText += basePrompt;
-    const summarizationMessages = [
-        {
-            role: "user",
-            content: [{ type: "text", text: promptText }],
-            timestamp: Date.now(),
-        },
-    ];
-    const completionOptions = createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel);
-    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions, streamFn, retry, callbacks);
-    if (response.stopReason === "error") {
-        throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+    const completionOptions = createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel, sessionId);
+    const response = await completeSummarization(model, buildSummarizationContext(promptText), completionOptions, streamFn, retry, callbacks);
+    const failure = getSummarizationFailure(response, "Summarization");
+    if (failure) {
+        throw new Error(failure);
+    }
+    if (response.content.some((block) => block.type === "toolCall")) {
+        throw new Error("Summarization attempted to call a tool");
     }
     const textContent = contentText(response.content);
     return { text: textContent, usage: response.usage };
@@ -579,8 +604,9 @@ Be concise. Focus on what's needed to understand the kept suffix.`;
  *
  * @param preparation - Pre-calculated preparation from prepareCompaction()
  * @param customInstructions - Optional custom focus for the summary
+ * @param sessionId - Optional routing session ID forwarded without enabling prompt caching
  */
-export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, env, retry, callbacks) {
+export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, env, retry, callbacks, sessionId) {
     const { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, settings, } = preparation;
     // Generate summaries and merge into one
     let summary;
@@ -589,18 +615,18 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
         let historyText = "No prior history.";
         let historyUsage;
         if (messagesToSummarize.length > 0) {
-            const historyResult = await generateSummaryWithUsage(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks);
+            const historyResult = await generateSummaryWithUsage(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks, sessionId);
             historyText = historyResult.text;
             historyUsage = historyResult.usage;
         }
-        const turnPrefixResult = await generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, env, signal, thinkingLevel, streamFn, retry, callbacks);
+        const turnPrefixResult = await generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, env, signal, thinkingLevel, streamFn, retry, callbacks, sessionId);
         // Merge into single summary
         summary = `${historyText}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult.text}`;
         summaryUsage = historyUsage ? combineUsage(historyUsage, turnPrefixResult.usage) : turnPrefixResult.usage;
     }
     else {
         // Just generate history summary
-        const result = await generateSummaryWithUsage(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks);
+        const result = await generateSummaryWithUsage(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env, retry, callbacks, sessionId);
         summary = result.text;
         summaryUsage = result.usage;
     }
@@ -621,21 +647,18 @@ export async function compact(preparation, model, apiKey, headers, customInstruc
 /**
  * Generate a summary for a turn prefix (when splitting a turn).
  */
-async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, env, signal, thinkingLevel, streamFn, retry, callbacks) {
+async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, env, signal, thinkingLevel, streamFn, retry, callbacks, sessionId) {
     const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY); // Smaller budget for turn prefix
     const llmMessages = convertToLlm(messages);
     const conversationText = serializeConversation(llmMessages);
     const promptText = `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
-    const summarizationMessages = [
-        {
-            role: "user",
-            content: [{ type: "text", text: promptText }],
-            timestamp: Date.now(),
-        },
-    ];
-    const response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel), streamFn, retry, callbacks);
-    if (response.stopReason === "error") {
-        throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
+    const response = await completeSummarization(model, buildSummarizationContext(promptText), createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel, sessionId), streamFn, retry, callbacks);
+    const failure = getSummarizationFailure(response, "Turn prefix summarization");
+    if (failure) {
+        throw new Error(failure);
+    }
+    if (response.content.some((block) => block.type === "toolCall")) {
+        throw new Error("Turn prefix summarization attempted to call a tool");
     }
     return {
         text: contentText(response.content),

package/node_modules/@earendil-works/pi-coding-agent/dist/core/defaults.js

@@ -1,2 +1,11 @@
 export const DEFAULT_THINKING_LEVEL = "medium";
+export const THINKING_LEVEL_OPTIONS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
 //# sourceMappingURL=defaults.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/core/experimental.js

@@ -1,4 +1,8 @@
+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;
+}
 //# sourceMappingURL=experimental.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/index.js

@@ -4,6 +4,6 @@
 export { createExtensionRuntime, discoverAndLoadExtensions, loadExtensionFromFactory, loadExtensions, } from "./loader.js";
 export { ExtensionRunner } from "./runner.js";
 // Type guards
-export { defineTool, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, } from "./types.js";
+export { defineTool, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isPowerShellToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, } from "./types.js";
 export { wrapRegisteredTool, wrapRegisteredTools } from "./wrapper.js";
 //# sourceMappingURL=index.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/loader.js

@@ -28,7 +28,7 @@ import { execCommand } from "../exec.js";
 import { readPiManifest } from "../pi-manifest.js";
 import { createSyntheticSourceInfo } from "../source-info.js";
 import { time } from "../timings.js";
-/** Modules available to extensions via virtualModules (for compiled Bun binary) */
+/** Modules available to extensions via virtualModules (for compiled binaries) */
 const VIRTUAL_MODULES = {
     typebox: _bundledTypebox,
     "typebox/compile": _bundledTypeboxCompile,
@@ -55,10 +55,13 @@ const VIRTUAL_MODULES = {
     "@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 isBundledNode = typeof PI_BUNDLED_NODE !== "undefined" && PI_BUNDLED_NODE;
 const isTypeScriptSourceRuntime = !isBunBinary && path.extname(fileURLToPath(import.meta.url)) === ".ts";
 /**
  * Get aliases for jiti (used in built Node.js mode).
- * In Bun binary mode, virtualModules is used instead.
+ * In compiled binary mode, virtualModules is used instead.
  */
 let _aliases = null;
 function getAliases() {
@@ -204,16 +207,37 @@ export function createExtensionRuntime() {
  * Action methods delegate to the shared runtime.
  */
 function createExtensionAPI(extension, runtime, cwd, eventBus) {
+    const pendingFlagValues = new Map();
+    const pendingRuntimeChanges = [];
+    const loadingUnsubscribers = [];
+    let state = "loading";
+    const assertActive = () => {
+        if (state === "failed") {
+            throw new Error(`Extension "${extension.path}" failed to load and its API is no longer active.`);
+        }
+        runtime.assertActive();
+    };
+    const applyRuntimeChange = (change) => {
+        if (state === "loading")
+            pendingRuntimeChanges.push(change);
+        else
+            change();
+    };
+    const clearPending = () => {
+        pendingFlagValues.clear();
+        pendingRuntimeChanges.length = 0;
+        loadingUnsubscribers.length = 0;
+    };
     const api = {
         // Registration methods - write to extension
         on(event, handler) {
-            runtime.assertActive();
+            assertActive();
             const list = extension.handlers.get(event) ?? [];
             list.push(handler);
             extension.handlers.set(event, list);
         },
         registerTool(tool) {
-            runtime.assertActive();
+            assertActive();
             extension.tools.set(tool.name, {
                 definition: tool,
                 sourceInfo: extension.sourceInfo,
@@ -221,7 +245,7 @@ function createExtensionAPI(extension, runtime, cwd, eventBus) {
             runtime.refreshTools();
         },
         registerCommand(name, options) {
-            runtime.assertActive();
+            assertActive();
             extension.commands.set(name, {
                 name,
                 sourceInfo: extension.sourceInfo,
@@ -229,119 +253,154 @@ function createExtensionAPI(extension, runtime, cwd, eventBus) {
             });
         },
         registerShortcut(shortcut, options) {
-            runtime.assertActive();
+            assertActive();
             extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
         },
         registerFlag(name, options) {
-            runtime.assertActive();
+            assertActive();
+            if (options.default !== undefined && typeof options.default !== options.type) {
+                throw new Error(`Invalid default for flag "${name}": expected ${options.type}, got ${typeof options.default}`);
+            }
             extension.flags.set(name, { name, extensionPath: extension.path, ...options });
             if (options.default !== undefined && !runtime.flagValues.has(name)) {
-                runtime.flagValues.set(name, options.default);
+                if (state === "loading") {
+                    if (!pendingFlagValues.has(name))
+                        pendingFlagValues.set(name, options.default);
+                }
+                else {
+                    runtime.flagValues.set(name, options.default);
+                }
             }
         },
         registerMessageRenderer(customType, renderer) {
-            runtime.assertActive();
+            assertActive();
             extension.messageRenderers.set(customType, renderer);
         },
         registerMarkdownTransformer(transformer) {
-            runtime.assertActive();
+            assertActive();
             extension.markdownTransformer = transformer;
         },
         registerEntryRenderer(customType, renderer) {
-            runtime.assertActive();
+            assertActive();
             extension.entryRenderers ??= new Map();
             extension.entryRenderers.set(customType, renderer);
         },
         // Flag access - checks extension registered it, reads from runtime
         getFlag(name) {
-            runtime.assertActive();
+            assertActive();
             if (!extension.flags.has(name))
                 return undefined;
-            return runtime.flagValues.get(name);
+            return runtime.flagValues.has(name) ? runtime.flagValues.get(name) : pendingFlagValues.get(name);
         },
         // Action methods - delegate to shared runtime
         sendMessage(message, options) {
-            runtime.assertActive();
+            assertActive();
             runtime.sendMessage(message, options);
         },
         sendUserMessage(content, options) {
-            runtime.assertActive();
+            assertActive();
             runtime.sendUserMessage(content, options);
         },
         appendEntry(customType, data) {
-            runtime.assertActive();
+            assertActive();
             runtime.appendEntry(customType, data);
         },
         setSessionName(name) {
-            runtime.assertActive();
+            assertActive();
             runtime.setSessionName(name);
         },
         getSessionName() {
-            runtime.assertActive();
+            assertActive();
             return runtime.getSessionName();
         },
         setLabel(entryId, label) {
-            runtime.assertActive();
+            assertActive();
             runtime.setLabel(entryId, label);
         },
         exec(command, args, options) {
-            runtime.assertActive();
+            assertActive();
             return execCommand(command, args, options?.cwd ?? cwd, options);
         },
         getActiveTools() {
-            runtime.assertActive();
+            assertActive();
             return runtime.getActiveTools();
         },
         getAllTools() {
-            runtime.assertActive();
+            assertActive();
             return runtime.getAllTools();
         },
         setActiveTools(toolNames) {
-            runtime.assertActive();
+            assertActive();
             runtime.setActiveTools(toolNames);
         },
         getCommands() {
-            runtime.assertActive();
+            assertActive();
             return runtime.getCommands();
         },
         setModel(model) {
-            runtime.assertActive();
+            assertActive();
             return runtime.setModel(model);
         },
         getThinkingLevel() {
-            runtime.assertActive();
+            assertActive();
             return runtime.getThinkingLevel();
         },
         setThinkingLevel(level) {
-            runtime.assertActive();
+            assertActive();
             runtime.setThinkingLevel(level);
         },
         registerProvider(providerOrName, config) {
-            runtime.assertActive();
+            assertActive();
             if (typeof providerOrName === "string") {
                 if (!config)
                     throw new Error("Provider config is required when registering by name");
-                runtime.registerProvider(providerOrName, config, extension.path);
+                applyRuntimeChange(() => runtime.registerProvider(providerOrName, config, extension.path));
                 return;
             }
-            runtime.registerNativeProvider(providerOrName, extension.path);
+            applyRuntimeChange(() => runtime.registerNativeProvider(providerOrName, extension.path));
         },
         unregisterProvider(name) {
-            runtime.assertActive();
-            runtime.unregisterProvider(name, extension.path);
+            assertActive();
+            applyRuntimeChange(() => runtime.unregisterProvider(name, extension.path));
         },
         events: {
             emit(channel, data) {
-                runtime.assertActive();
+                assertActive();
                 eventBus.emit(channel, data);
             },
             on(channel, handler) {
-                runtime.assertActive();
-                return runtime.trackEventBusSubscription(eventBus.on(channel, handler));
+                assertActive();
+                const unsubscribe = runtime.trackEventBusSubscription(eventBus.on(channel, handler));
+                if (state === "loading")
+                    loadingUnsubscribers.push(unsubscribe);
+                return unsubscribe;
             },
         },
     };
-    return api;
+    return {
+        api,
+        commit: () => {
+            if (state !== "loading")
+                return;
+            runtime.assertActive();
+            for (const [name, value] of pendingFlagValues) {
+                if (!runtime.flagValues.has(name))
+                    runtime.flagValues.set(name, value);
+            }
+            for (const apply of pendingRuntimeChanges)
+                apply();
+            state = "active";
+            clearPending();
+        },
+        discard: () => {
+            if (state !== "loading")
+                return;
+            state = "failed";
+            for (const unsubscribe of loadingUnsubscribers)
+                unsubscribe();
+            clearPending();
+        },
+    };
 }
 function isCurrentCacheToken(cacheToken) {
     return (cacheToken !== undefined &&
@@ -357,9 +416,10 @@ async function loadExtensionModule(extensionPath, cacheToken) {
     }
     const jiti = createJiti(import.meta.url, {
         moduleCache: false,
-        // Bun uses modules embedded in the executable. Source TypeScript reuses the
-        // host-resolved modules and root tsconfig paths. Built Node uses dist aliases.
-        ...(isBunBinary
+        // 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.
+        ...(isBunBinary || isNodeSeaBinary || isBundledNode
             ? { virtualModules: VIRTUAL_MODULES, tryNative: false }
             : isTypeScriptSourceRuntime
                 ? { virtualModules: VIRTUAL_MODULES, tsconfigPaths: true }
@@ -396,6 +456,20 @@ function createExtension(extensionPath, resolvedPath) {
         shortcuts: new Map(),
     };
 }
+async function initializeExtension(factory, extensionPath, resolvedPath, cwd, eventBus, runtime) {
+    const extension = createExtension(extensionPath, resolvedPath);
+    const load = createExtensionAPI(extension, runtime, cwd, eventBus);
+    try {
+        await factory(load.api);
+        load.commit();
+    }
+    catch (error) {
+        load.discard();
+        throw error;
+    }
+    time(`${extensionPath} factory`, "extensions");
+    return extension;
+}
 async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken) {
     const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
     try {
@@ -404,10 +478,7 @@ async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken)
         if (!factory) {
             return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
         }
-        const extension = createExtension(extensionPath, resolvedPath);
-        const api = createExtensionAPI(extension, runtime, cwd, eventBus);
-        await factory(api);
-        time(`${extensionPath} factory`, "extensions");
+        const extension = await initializeExtension(factory, extensionPath, resolvedPath, cwd, eventBus, runtime);
         return { extension, error: null };
     }
     catch (err) {
@@ -419,12 +490,8 @@ async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken)
  * Create an Extension from an inline factory function.
  */
 export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
-    const extension = createExtension(extensionPath, extensionPath);
     const resolvedCwd = resolvePath(cwd);
-    const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
-    await factory(api);
-    time(`${extensionPath} factory`, "extensions");
-    return extension;
+    return initializeExtension(factory, extensionPath, extensionPath, resolvedCwd, eventBus, runtime);
 }
 /**
  * Load extensions from paths.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/types.js

@@ -21,6 +21,9 @@ export function defineTool(tool) {
 export function isBashToolResult(e) {
     return e.toolName === "bash";
 }
+export function isPowerShellToolResult(e) {
+    return e.toolName === "powershell";
+}
 export function isReadToolResult(e) {
     return e.toolName === "read";
 }

package/node_modules/@earendil-works/pi-coding-agent/dist/core/footer-data-provider.js

@@ -81,7 +81,7 @@ function shouldPollGitHead(repoDir) {
 }
 /**
  * Provides git branch and extension statuses - data not otherwise accessible to extensions.
- * Token stats, model info available via ctx.sessionManager and ctx.model.
+ * Context usage on ctx.getContextUsage(), token stats on ctx.sessionManager.getEntries(), model info on ctx.model.
  */
 export class FooterDataProvider {
     cwd;