@psnext/slingcli 2.5.20260623-1 → 2.5.20260705-1

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

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import * as undici from "undici";
 export const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 300_000;
 export const HTTP_IDLE_TIMEOUT_CHOICES = [
@@ -39,16 +40,42 @@ export function applyHttpProxySettings(httpProxy) {
     process.env.HTTP_PROXY ??= proxy;
     process.env.HTTPS_PROXY ??= proxy;
 }
+const ignoreUndiciDispatcherError = (_error) => { };
+// Undici can emit an internal Client "error" while terminating a mid-stream
+// fetch body. The body stream still rejects through reader.read(); this listener
+// only prevents EventEmitter's unhandled "error" special case from crashing pi.
+function withUndiciErrorListener(dispatcher) {
+    if (dispatcher instanceof EventEmitter) {
+        EventEmitter.prototype.on.call(dispatcher, "error", ignoreUndiciDispatcherError);
+    }
+    return dispatcher;
+}
+function createUndiciClient(origin, options) {
+    return withUndiciErrorListener(new undici.Client(origin, options));
+}
+function createUndiciOriginDispatcher(origin, options) {
+    const dispatcherOptions = options;
+    if (dispatcherOptions.connections === 1) {
+        return createUndiciClient(origin, dispatcherOptions);
+    }
+    return withUndiciErrorListener(new undici.Pool(origin, {
+        ...dispatcherOptions,
+        factory: createUndiciClient,
+    }));
+}
 export function configureHttpDispatcher(timeoutMs = DEFAULT_HTTP_IDLE_TIMEOUT_MS) {
     const normalizedTimeoutMs = parseHttpIdleTimeoutMs(timeoutMs);
     if (normalizedTimeoutMs === undefined) {
         throw new Error(`Invalid HTTP idle timeout: ${String(timeoutMs)}`);
     }
-    undici.setGlobalDispatcher(new undici.EnvHttpProxyAgent({
+    const dispatcher = withUndiciErrorListener(new undici.EnvHttpProxyAgent({
         allowH2: false,
         bodyTimeout: normalizedTimeoutMs,
         headersTimeout: normalizedTimeoutMs,
+        clientFactory: createUndiciClient,
+        factory: createUndiciOriginDispatcher,
     }));
+    undici.setGlobalDispatcher(dispatcher);
     // Keep fetch and the dispatcher on the same undici implementation. Node 26.0's
     // bundled fetch can otherwise consume compressed responses through npm undici's
     // dispatcher without decompressing them, causing response.json() failures.

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

@@ -402,13 +402,11 @@ export class ModelRegistry {
                 }
             }
             else if (!isBuiltIn) {
-                // Non-built-in providers with custom models require endpoint + auth.
+                // Non-built-in providers with custom models require an endpoint.
+                // Auth can come from auth.json, --api-key, or provider request config.
                 if (!providerConfig.baseUrl) {
                     throw new Error(`Provider ${providerName}: "baseUrl" is required when defining custom models.`);
                 }
-                if (!providerConfig.apiKey) {
-                    throw new Error(`Provider ${providerName}: "apiKey" is required when defining custom models.`);
-                }
             }
             // Built-in providers with custom models: baseUrl/apiKey/api are optional,
             // inherited from built-in models. Auth comes from env vars / auth storage.

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

@@ -11,7 +11,7 @@ export const defaultModelPerProvider = {
     "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
     "ant-ling": "Ring-2.6-1T",
     anthropic: "claude-opus-4-8",
-    openai: "gpt-5.4",
+    openai: "gpt-5.5",
     "azure-openai-responses": "gpt-5.4",
     "openai-codex": "gpt-5.5",
     nvidia: "nvidia/nemotron-3-super-120b-a12b",
@@ -195,20 +195,10 @@ export function parseModelPattern(pattern, availableModels, options) {
         return result;
     }
 }
-/**
- * Resolve model patterns to actual Model objects with optional thinking levels
- * Format: "pattern:level" where :level is optional
- * For each pattern, finds all matching models and picks the best version:
- * 1. Prefer alias (e.g., claude-sonnet-4-5) over dated versions (claude-sonnet-4-5-20250929)
- * 2. If no alias, pick the latest dated version
- *
- * Supports models with colons in their IDs (e.g., OpenRouter's model:exacto).
- * The algorithm tries to match the full pattern first, then progressively
- * strips colon-suffixes to find a match.
- */
-export async function resolveModelScope(patterns, modelRegistry) {
+export async function resolveModelScopeWithDiagnostics(patterns, modelRegistry) {
     const availableModels = await modelRegistry.getAvailable();
     const scopedModels = [];
+    const diagnostics = [];
     for (const pattern of patterns) {
         // Check if pattern contains glob characters
         if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[")) {
@@ -230,7 +220,7 @@ export async function resolveModelScope(patterns, modelRegistry) {
                 return minimatch(fullId, globPattern, { nocase: true }) || minimatch(m.id, globPattern, { nocase: true });
             });
             if (matchingModels.length === 0) {
-                console.warn(chalk.yellow(`Warning: No models match pattern "${pattern}"`));
+                diagnostics.push({ type: "warning", message: `No models match pattern "${pattern}"`, pattern });
                 continue;
             }
             for (const model of matchingModels) {
@@ -242,10 +232,10 @@ export async function resolveModelScope(patterns, modelRegistry) {
         }
         const { model, thinkingLevel, warning } = parseModelPattern(pattern, availableModels);
         if (warning) {
-            console.warn(chalk.yellow(`Warning: ${warning}`));
+            diagnostics.push({ type: "warning", message: warning, pattern });
         }
         if (!model) {
-            console.warn(chalk.yellow(`Warning: No models match pattern "${pattern}"`));
+            diagnostics.push({ type: "warning", message: `No models match pattern "${pattern}"`, pattern });
             continue;
         }
         // Avoid duplicates
@@ -253,6 +243,13 @@ export async function resolveModelScope(patterns, modelRegistry) {
             scopedModels.push({ model, thinkingLevel });
         }
     }
+    return { scopedModels, diagnostics };
+}
+export async function resolveModelScope(patterns, modelRegistry) {
+    const { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics(patterns, modelRegistry);
+    for (const diagnostic of diagnostics) {
+        console.warn(chalk.yellow(`Warning: ${diagnostic.message}`));
+    }
     return scopedModels;
 }
 /**
@@ -447,10 +444,10 @@ export async function findInitialModel(options) {
             fallbackMessage: undefined,
         };
     }
-    // 3. Try saved default from settings
+    // 3. Try saved default from settings if auth is configured.
     if (defaultProvider && defaultModelId) {
         const found = modelRegistry.find(defaultProvider, defaultModelId);
-        if (found) {
+        if (found && modelRegistry.hasConfiguredAuth(found)) {
             model = found;
             if (defaultThinkingLevel) {
                 thinkingLevel = defaultThinkingLevel;

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

@@ -2,7 +2,7 @@ import { CONFIG_DIR_NAME } from "../config.js";
 import { emitProjectTrustEvent } from "./extensions/runner.js";
 import { getProjectTrustOptions, hasTrustRequiringProjectResources, } from "./trust-manager.js";
 function formatProjectTrustPrompt(cwd) {
-    return `Trust project folder?\n${cwd}\n\nThis allows sling to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
+    return `Trust project folder?\n${cwd}\n\nThis allows pi to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
 }
 async function selectProjectTrustOption(cwd, ctx) {
     const options = getProjectTrustOptions(cwd, { includeSessionOnly: true });

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

@@ -4,7 +4,6 @@ const NVIDIA_NIM_HOST = "integrate.api.nvidia.com";
 const CLOUDFLARE_API_HOST = "api.cloudflare.com";
 const CLOUDFLARE_AI_GATEWAY_HOST = "gateway.ai.cloudflare.com";
 const OPENCODE_HOST = "opencode.ai";
-const VERCEL_GATEWAY_HOST = "ai-gateway.vercel.sh";
 function matchesHost(baseUrl, expectedHost) {
     try {
         return new URL(baseUrl).hostname === expectedHost;
@@ -25,9 +24,6 @@ function isCloudflareModel(model) {
         matchesHost(model.baseUrl, CLOUDFLARE_API_HOST) ||
         matchesHost(model.baseUrl, CLOUDFLARE_AI_GATEWAY_HOST));
 }
-function isVercelGatewayModel(model) {
-    return model.provider === "vercel-ai-gateway" || matchesHost(model.baseUrl, VERCEL_GATEWAY_HOST);
-}
 function getDefaultAttributionHeaders(model, settingsManager) {
     if (!isInstallTelemetryEnabled(settingsManager)) {
         return undefined;
@@ -49,12 +45,6 @@ function getDefaultAttributionHeaders(model, settingsManager) {
             "User-Agent": "pi-coding-agent",
         };
     }
-    if (isVercelGatewayModel(model)) {
-        return {
-            "http-referer": "https://pi.dev",
-            "x-title": "pi",
-        };
-    }
     return undefined;
 }
 function getSessionHeaders(model, sessionId) {

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

@@ -11,6 +11,7 @@ import { loadPromptTemplates } from "./prompt-templates.js";
 import { SettingsManager } from "./settings-manager.js";
 import { loadSkills } from "./skills.js";
 import { createSourceInfo } from "./source-info.js";
+import { resetTimings } from "./timings.js";
 function resolvePromptInput(input, description) {
     if (!input) {
         return undefined;
@@ -216,6 +217,7 @@ export class DefaultResourceLoader {
         return this.loadCurrentExtensionSet({ includeInlineFactories: true });
     }
     async reload(options) {
+        resetTimings("extensions");
         if (this.loaded) {
             clearExtensionCache();
         }

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

@@ -112,47 +112,40 @@ export function getLatestCompactionEntry(entries) {
     }
     return null;
 }
-/**
- * Build the session context from entries using tree traversal.
- * If leafId is provided, walks from that entry to root.
- * Handles compaction and branch summaries along the path.
- */
-export function buildSessionContext(entries, leafId, byId) {
-    // Build uuid index if not available
-    if (!byId) {
-        byId = new Map();
-        for (const entry of entries) {
-            byId.set(entry.id, entry);
-        }
+function buildEntryIndex(entries, byId) {
+    if (byId)
+        return byId;
+    const index = new Map();
+    for (const entry of entries) {
+        index.set(entry.id, entry);
     }
-    // Find leaf
+    return index;
+}
+function buildSessionPath(entries, leafId, byId) {
+    const index = buildEntryIndex(entries, byId);
     let leaf;
     if (leafId === null) {
-        // Explicitly null - return no messages (navigated to before first entry)
-        return { messages: [], thinkingLevel: "off", model: null };
+        return [];
     }
     if (leafId) {
-        leaf = byId.get(leafId);
+        leaf = index.get(leafId);
     }
+    leaf ??= entries[entries.length - 1];
     if (!leaf) {
-        // Fallback to last entry (when leafId is undefined)
-        leaf = entries[entries.length - 1];
-    }
-    if (!leaf) {
-        return { messages: [], thinkingLevel: "off", model: null };
+        return [];
     }
-    // Walk from leaf to root, collecting path
     const path = [];
     let current = leaf;
     while (current) {
         path.push(current);
-        current = current.parentId ? byId.get(current.parentId) : undefined;
+        current = current.parentId ? index.get(current.parentId) : undefined;
     }
     path.reverse();
-    // Extract settings and find compaction
+    return path;
+}
+function getSessionContextSettings(path) {
     let thinkingLevel = "off";
     let model = null;
-    let compaction = null;
     for (const entry of path) {
         if (entry.type === "thinking_level_change") {
             thinkingLevel = entry.thinkingLevel;
@@ -163,55 +156,74 @@ export function buildSessionContext(entries, leafId, byId) {
         else if (entry.type === "message" && entry.message.role === "assistant") {
             model = { provider: entry.message.provider, modelId: entry.message.model };
         }
-        else if (entry.type === "compaction") {
+    }
+    return { thinkingLevel, model };
+}
+/**
+ * Project one selected session entry into LLM/runtime messages.
+ * Plain custom entries are display/state entries and do not participate in context.
+ */
+export function sessionEntryToContextMessages(entry) {
+    if (entry.type === "message") {
+        return [entry.message];
+    }
+    if (entry.type === "custom_message") {
+        return [createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp)];
+    }
+    if (entry.type === "branch_summary" && entry.summary) {
+        return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
+    }
+    if (entry.type === "compaction") {
+        return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+    }
+    return [];
+}
+/**
+ * Build the active, compaction-aware session entry list.
+ *
+ * This follows the current leaf path. If the path contains compaction entries,
+ * the latest compaction is represented by the compaction entry itself, followed
+ * by the kept entries starting at firstKeptEntryId and all entries after the
+ * compaction entry. Older summarized entries are omitted.
+ */
+export function buildContextEntries(entries, leafId, byId) {
+    const path = buildSessionPath(entries, leafId, byId);
+    let compaction = null;
+    for (const entry of path) {
+        if (entry.type === "compaction") {
             compaction = entry;
         }
     }
-    // Build messages and collect corresponding entries
-    // When there's a compaction, we need to:
-    // 1. Emit summary first (entry = compaction)
-    // 2. Emit kept messages (from firstKeptEntryId up to compaction)
-    // 3. Emit messages after compaction
-    const messages = [];
-    const appendMessage = (entry) => {
-        if (entry.type === "message") {
-            messages.push(entry.message);
-        }
-        else if (entry.type === "custom_message") {
-            messages.push(createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp));
-        }
-        else if (entry.type === "branch_summary" && entry.summary) {
-            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
-        }
-    };
-    if (compaction) {
-        // Emit summary first
-        messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
-        // Find compaction index in path
-        const compactionIdx = path.findIndex((e) => e.type === "compaction" && e.id === compaction.id);
-        // Emit kept messages (before compaction, starting from firstKeptEntryId)
-        let foundFirstKept = false;
-        for (let i = 0; i < compactionIdx; i++) {
-            const entry = path[i];
-            if (entry.id === compaction.firstKeptEntryId) {
-                foundFirstKept = true;
-            }
-            if (foundFirstKept) {
-                appendMessage(entry);
-            }
-        }
-        // Emit messages after compaction
-        for (let i = compactionIdx + 1; i < path.length; i++) {
-            const entry = path[i];
-            appendMessage(entry);
-        }
+    if (!compaction) {
+        return path;
     }
-    else {
-        // No compaction - emit all messages, handle branch summaries and custom messages
-        for (const entry of path) {
-            appendMessage(entry);
+    const compactionIdx = path.findIndex((entry) => entry.id === compaction.id);
+    if (compactionIdx < 0) {
+        return path;
+    }
+    const contextEntries = [compaction];
+    let foundFirstKept = false;
+    for (let i = 0; i < compactionIdx; i++) {
+        const entry = path[i];
+        if (entry.id === compaction.firstKeptEntryId) {
+            foundFirstKept = true;
+        }
+        if (foundFirstKept) {
+            contextEntries.push(entry);
         }
     }
+    contextEntries.push(...path.slice(compactionIdx + 1));
+    return contextEntries;
+}
+/**
+ * Build the session context from entries using tree traversal.
+ * If leafId is provided, walks from that entry to root.
+ * Handles compaction and branch summaries along the path.
+ */
+export function buildSessionContext(entries, leafId, byId) {
+    const path = buildSessionPath(entries, leafId, byId);
+    const { thinkingLevel, model } = getSessionContextSettings(path);
+    const messages = buildContextEntries(entries, leafId, byId).flatMap(sessionEntryToContextMessages);
     return { messages, thinkingLevel, model };
 }
 /**
@@ -533,10 +545,13 @@ export class SessionManager {
         this.sessionFile = resolvePath(sessionFile);
         if (existsSync(this.sessionFile)) {
             this.fileEntries = loadEntriesFromFile(this.sessionFile);
-            // If file was empty or corrupted (no valid header), truncate and start fresh
-            // to avoid appending messages without a session header (which breaks the session)
+            // If file was empty, initialize it with a valid session header. If it was
+            // non-empty but did not parse as a pi session, fail without modifying it.
             if (this.fileEntries.length === 0) {
                 const explicitPath = this.sessionFile;
+                if (statSync(explicitPath).size > 0) {
+                    throw new Error(`Session file is not a valid pi session: ${explicitPath}`);
+                }
                 this.newSession();
                 this.sessionFile = explicitPath;
                 this._rewriteFile();
@@ -744,12 +759,13 @@ export class SessionManager {
     }
     /** Append a session info entry (e.g., display name). Returns entry id. */
     appendSessionInfo(name) {
+        const sanitizedName = name.replace(/[\r\n]+/g, " ").trim();
         const entry = {
             type: "session_info",
             id: generateId(this.byId),
             parentId: this.leafId,
             timestamp: new Date().toISOString(),
-            name: name.trim(),
+            name: sanitizedName,
         };
         this._appendEntry(entry);
         return entry.id;
@@ -863,6 +879,13 @@ export class SessionManager {
         path.reverse();
         return path;
     }
+    /**
+     * Build the active, compaction-aware entry list for context/rendering.
+     * Uses tree traversal from current leaf.
+     */
+    buildContextEntries() {
+        return buildContextEntries(this.getEntries(), this.leafId, this.byId);
+    }
     /**
      * Build the session context (what gets sent to the LLM).
      * Uses tree traversal from current leaf.
@@ -1112,8 +1135,8 @@ export class SessionManager {
         return new SessionManager(cwd, dir, undefined, true);
     }
     /** Create an in-memory session (no file persistence) */
-    static inMemory(cwd = process.cwd()) {
-        return new SessionManager(cwd, "", undefined, false);
+    static inMemory(cwd = process.cwd(), options) {
+        return new SessionManager(cwd, "", undefined, false, options);
     }
     /**
      * Fork a session from another project directory into the current project.

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

@@ -581,6 +581,17 @@ export class SettingsManager {
     getHideThinkingBlock() {
         return this.settings.hideThinkingBlock ?? false;
     }
+    getExternalEditorCommand() {
+        const configuredEditor = this.settings.externalEditor;
+        if (typeof configuredEditor === "string" && configuredEditor.trim() !== "") {
+            return configuredEditor;
+        }
+        const environmentEditor = process.env.VISUAL || process.env.EDITOR;
+        if (environmentEditor) {
+            return environmentEditor;
+        }
+        return process.platform === "win32" ? "notepad" : "nano";
+    }
     setHideThinkingBlock(hide) {
         this.globalSettings.hideThinkingBlock = hide;
         this.markModified("hideThinkingBlock");
@@ -851,6 +862,14 @@ export class SettingsManager {
         this.markModified("editorPaddingX");
         this.save();
     }
+    getOutputPad() {
+        return this.settings.outputPad === 0 ? 0 : 1;
+    }
+    setOutputPad(padding) {
+        this.globalSettings.outputPad = padding;
+        this.markModified("outputPad");
+        this.save();
+    }
     getAutocompleteMaxVisible() {
         return this.settings.autocompleteMaxVisible ?? 5;
     }

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

@@ -3,29 +3,39 @@
  * Enable with PI_TIMING=1 environment variable.
  */
 const ENABLED = process.env.PI_TIMING === "1";
-const timings = [];
-let lastTime = Date.now();
-export function resetTimings() {
+const timingNamespaces = new Map();
+export function resetTimings(namespace = "main") {
     if (!ENABLED)
         return;
-    timings.length = 0;
-    lastTime = Date.now();
+    timingNamespaces.set(namespace, { timings: [], lastTime: Date.now() });
 }
-export function time(label) {
+export function time(label, namespace = "main") {
     if (!ENABLED)
         return;
     const now = Date.now();
-    timings.push({ label, ms: now - lastTime });
-    lastTime = now;
+    if (!timingNamespaces.has(namespace)) {
+        resetTimings(namespace);
+    }
+    const timingNamespace = timingNamespaces.get(namespace);
+    timingNamespace.timings.push({ label, ms: now - timingNamespace.lastTime });
+    timingNamespace.lastTime = now;
 }
-export function printTimings() {
-    if (!ENABLED || timings.length === 0)
+function printTimingGroup(title, timings) {
+    const printableTimings = timings.filter((timing) => timing.ms >= 0);
+    if (printableTimings.length === 0)
         return;
-    console.error("\n--- Startup Timings ---");
-    for (const t of timings) {
+    console.error(`\n--- ${title} ---`);
+    for (const t of printableTimings) {
         console.error(`  ${t.label}: ${t.ms}ms`);
     }
-    console.error(`  TOTAL: ${timings.reduce((a, b) => a + b.ms, 0)}ms`);
-    console.error("------------------------\n");
+    console.error(`  TOTAL: ${printableTimings.reduce((a, b) => a + b.ms, 0)}ms`);
+    console.error(`${"-".repeat(title.length + 8)}\n`);
+}
+export function printTimings() {
+    if (!ENABLED)
+        return;
+    for (const [namespace, timingNamespace] of timingNamespaces) {
+        printTimingGroup(`Startup Timings: ${namespace}`, timingNamespace.timings);
+    }
 }
 //# sourceMappingURL=timings.js.map

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

@@ -12,6 +12,20 @@ import { OutputAccumulator } from "./output-accumulator.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
+const MAX_TIMEOUT_MS = 2_147_483_647;
+const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
+function resolveTimeoutMs(timeout) {
+    if (timeout === undefined)
+        return undefined;
+    if (!Number.isFinite(timeout) || timeout <= 0) {
+        throw new Error("Invalid timeout: must be a finite number of seconds");
+    }
+    const timeoutMs = timeout * 1000;
+    if (timeoutMs > MAX_TIMEOUT_MS) {
+        throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
+    }
+    return timeoutMs;
+}
 const bashSchema = Type.Object({
     command: Type.String({ description: "Bash command to execute" }),
     timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
@@ -25,6 +39,10 @@ const bashSchema = Type.Object({
 export function createLocalBashOperations(options) {
     return {
         exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const timeoutMs = resolveTimeoutMs(timeout);
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
             const shellConfig = getShellConfig(options?.shellPath);
             try {
                 await fsAccess(cwd, constants.F_OK);
@@ -32,9 +50,6 @@ export function createLocalBashOperations(options) {
             catch {
                 throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
             }
-            if (signal?.aborted) {
-                throw new Error("aborted");
-            }
             const commandFromStdin = shellConfig.commandTransport === "stdin";
             const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
                 cwd,
@@ -57,12 +72,12 @@ export function createLocalBashOperations(options) {
             };
             try {
                 // Set timeout if provided.
-                if (timeout !== undefined && timeout > 0) {
+                if (timeoutMs !== undefined) {
                     timeoutHandle = setTimeout(() => {
                         timedOut = true;
                         if (child.pid)
                             killProcessTree(child.pid);
-                    }, timeout * 1000);
+                    }, timeoutMs);
                 }
                 // Stream stdout and stderr.
                 child.stdout?.on("data", onData);

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

@@ -13,13 +13,13 @@ const replaceEditSchema = Type.Object({
         description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",
     }),
     newText: Type.String({ description: "Replacement text for this targeted edit." }),
-}, { additionalProperties: false });
+}, {});
 const editSchema = Type.Object({
     path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
     edits: Type.Array(replaceEditSchema, {
         description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
     }),
-}, { additionalProperties: false });
+}, {});
 const defaultEditOperations = {
     readFile: (path) => fsReadFile(path),
     writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),