@psnext/slingcli 2.4.20260526-1 → 2.4.20260527-3

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

@@ -1,10 +1,9 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import { join, resolve, sep } from "node:path";
 import chalk from "chalk";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { loadThemeFromPath } from "../modes/interactive/theme/theme.js";
-import { canonicalizePath, isLocalPath } from "../utils/paths.js";
+import { canonicalizePath, isLocalPath, resolvePath } from "../utils/paths.js";
 import { createEventBus } from "./event-bus.js";
 import { createExtensionRuntime, loadExtensionFromFactory, loadExtensions } from "./extensions/loader.js";
 import { DefaultPackageManager } from "./package-manager.js";
@@ -46,8 +45,8 @@ function loadContextFileFromDir(dir) {
     return null;
 }
 export function loadProjectContextFiles(options) {
-    const resolvedCwd = options.cwd;
-    const resolvedAgentDir = options.agentDir;
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
     const contextFiles = [];
     const seenPaths = new Set();
     const globalContext = loadContextFileFromDir(resolvedAgentDir);
@@ -116,8 +115,8 @@ export class DefaultResourceLoader {
     lastPromptPaths;
     lastThemePaths;
     constructor(options) {
-        this.cwd = options.cwd;
-        this.agentDir = options.agentDir;
+        this.cwd = resolvePath(options.cwd);
+        this.agentDir = resolvePath(options.agentDir);
         this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir);
         this.eventBus = options.eventBus ?? createEventBus();
         this.packageManager = new DefaultPackageManager({
@@ -283,8 +282,11 @@ export class DefaultResourceLoader {
             extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
         }
         for (const p of this.additionalExtensionPaths) {
-            if (isLocalPath(p) && !existsSync(p)) {
-                extensionsResult.errors.push({ path: p, error: `Extension path does not exist: ${p}` });
+            if (isLocalPath(p)) {
+                const resolved = this.resolveResourcePath(p);
+                if (!existsSync(resolved)) {
+                    extensionsResult.errors.push({ path: resolved, error: `Extension path does not exist: ${resolved}` });
+                }
             }
         }
         this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult;
@@ -295,8 +297,11 @@ export class DefaultResourceLoader {
         this.lastSkillPaths = skillPaths;
         this.updateSkillsFromPaths(skillPaths, metadataByPath);
         for (const p of this.additionalSkillPaths) {
-            if (isLocalPath(p) && !existsSync(p) && !this.skillDiagnostics.some((d) => d.path === p)) {
-                this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: p });
+            if (isLocalPath(p)) {
+                const resolved = this.resolveResourcePath(p);
+                if (!existsSync(resolved) && !this.skillDiagnostics.some((d) => d.path === resolved)) {
+                    this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: resolved });
+                }
             }
         }
         const promptPaths = this.noPromptTemplates
@@ -305,8 +310,15 @@ export class DefaultResourceLoader {
         this.lastPromptPaths = promptPaths;
         this.updatePromptsFromPaths(promptPaths, metadataByPath);
         for (const p of this.additionalPromptTemplatePaths) {
-            if (isLocalPath(p) && !existsSync(p) && !this.promptDiagnostics.some((d) => d.path === p)) {
-                this.promptDiagnostics.push({ type: "error", message: "Prompt template path does not exist", path: p });
+            if (isLocalPath(p)) {
+                const resolved = this.resolveResourcePath(p);
+                if (!existsSync(resolved) && !this.promptDiagnostics.some((d) => d.path === resolved)) {
+                    this.promptDiagnostics.push({
+                        type: "error",
+                        message: "Prompt template path does not exist",
+                        path: resolved,
+                    });
+                }
             }
         }
         const themePaths = this.noThemes
@@ -315,8 +327,9 @@ export class DefaultResourceLoader {
         this.lastThemePaths = themePaths;
         this.updateThemesFromPaths(themePaths, metadataByPath);
         for (const p of this.additionalThemePaths) {
-            if (!existsSync(p) && !this.themeDiagnostics.some((d) => d.path === p)) {
-                this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: p });
+            const resolved = this.resolveResourcePath(p);
+            if (!existsSync(resolved) && !this.themeDiagnostics.some((d) => d.path === resolved)) {
+                this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: resolved });
             }
         }
         const agentsFiles = {
@@ -336,10 +349,15 @@ export class DefaultResourceLoader {
             : baseAppend;
     }
     normalizeExtensionPaths(entries) {
-        return entries.map((entry) => ({
-            path: this.resolveResourcePath(entry.path),
-            metadata: entry.metadata,
-        }));
+        return entries.map((entry) => {
+            const metadata = entry.metadata.baseDir
+                ? { ...entry.metadata, baseDir: this.resolveResourcePath(entry.metadata.baseDir) }
+                : entry.metadata;
+            return {
+                path: this.resolveResourcePath(entry.path),
+                metadata,
+            };
+        });
     }
     updateSkillsFromPaths(skillPaths, metadataByPath) {
         let skillsResult;
@@ -507,18 +525,7 @@ export class DefaultResourceLoader {
         return merged;
     }
     resolveResourcePath(p) {
-        const trimmed = p.trim();
-        let expanded = trimmed;
-        if (trimmed === "~") {
-            expanded = homedir();
-        }
-        else if (trimmed.startsWith("~/")) {
-            expanded = join(homedir(), trimmed.slice(2));
-        }
-        else if (trimmed.startsWith("~")) {
-            expanded = join(homedir(), trimmed.slice(1));
-        }
-        return resolve(this.cwd, expanded);
+        return resolvePath(p, this.cwd, { trim: true });
     }
     loadThemes(paths, includeDefaults = true) {
         const themes = [];
@@ -530,7 +537,7 @@ export class DefaultResourceLoader {
             }
         }
         for (const p of paths) {
-            const resolved = resolve(this.cwd, p);
+            const resolved = this.resolveResourcePath(p);
             if (!existsSync(resolved)) {
                 diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
                 continue;

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

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { Agent } from "@earendil-works/pi-agent-core";
 import { clampThinkingLevel, streamSimple } from "@earendil-works/pi-ai";
 import { getAgentDir } from "../config.js";
+import { resolvePath } from "../utils/paths.js";
 import { AgentSession } from "./agent-session.js";
 import { formatNoModelsAvailableMessage } from "./auth-guidance.js";
 import { AuthStorage } from "./auth-storage.js";
@@ -24,7 +25,11 @@ createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEd
 function getDefaultAgentDir() {
     return getAgentDir();
 }
-function getAttributionHeaders(model, settingsManager) {
+function getAttributionHeaders(model, settingsManager, sessionId) {
+    if (sessionId &&
+        (model.provider === "opencode" || model.provider === "opencode-go" || model.baseUrl.includes("opencode.ai"))) {
+        return { "x-opencode-session": sessionId, "x-opencode-client": "pi" };
+    }
     if (!isInstallTelemetryEnabled(settingsManager)) {
         return undefined;
     }
@@ -81,8 +86,8 @@ function getAttributionHeaders(model, settingsManager) {
  * ```
  */
 export async function createAgentSession(options = {}) {
-    const cwd = options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd();
-    const agentDir = options.agentDir ?? getDefaultAgentDir();
+    const cwd = resolvePath(options.cwd ?? options.sessionManager?.getCwd() ?? process.cwd());
+    const agentDir = options.agentDir ? resolvePath(options.agentDir) : getDefaultAgentDir();
     let resourceLoader = options.resourceLoader;
     // Use provided or create AuthStorage and ModelRegistry
     const authPath = options.agentDir ? join(agentDir, "auth.json") : undefined;
@@ -201,7 +206,7 @@ export async function createAgentSession(options = {}) {
                 throw new Error(auth.error);
             }
             const providerRetrySettings = settingsManager.getProviderRetrySettings();
-            const attributionHeaders = getAttributionHeaders(model, settingsManager);
+            const attributionHeaders = getAttributionHeaders(model, settingsManager, options?.sessionId);
             return streamSimple(model, context, {
                 ...options,
                 apiKey: auth.apiKey,

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

@@ -4,6 +4,7 @@ import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync
 import { readdir, readFile, stat } from "fs/promises";
 import { join, resolve } from "path";
 import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
+import { normalizePath, resolvePath } from "../utils/paths.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
 export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
@@ -210,8 +211,10 @@ export function buildSessionContext(entries, leafId, byId) {
  * Encodes cwd into a safe directory name under ~/.pi/agent/sessions/.
  */
 export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
-    const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-    const sessionDir = join(agentDir, "sessions", safePath);
+    const resolvedCwd = resolvePath(cwd);
+    const resolvedAgentDir = resolvePath(agentDir);
+    const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    const sessionDir = join(resolvedAgentDir, "sessions", safePath);
     if (!existsSync(sessionDir)) {
         mkdirSync(sessionDir, { recursive: true });
     }
@@ -219,9 +222,10 @@ export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
 }
 /** Exported for testing */
 export function loadEntriesFromFile(filePath) {
-    if (!existsSync(filePath))
+    const resolvedFilePath = normalizePath(filePath);
+    if (!existsSync(resolvedFilePath))
         return [];
-    const content = readFileSync(filePath, "utf8");
+    const content = readFileSync(resolvedFilePath, "utf8");
     const entries = [];
     const lines = content.trim().split("\n");
     for (const line of lines) {
@@ -262,10 +266,11 @@ function isValidSessionFile(filePath) {
 }
 /** Exported for testing */
 export function findMostRecentSession(sessionDir) {
+    const resolvedSessionDir = normalizePath(sessionDir);
     try {
-        const files = readdirSync(sessionDir)
+        const files = readdirSync(resolvedSessionDir)
             .filter((f) => f.endsWith(".jsonl"))
-            .map((f) => join(sessionDir, f))
+            .map((f) => join(resolvedSessionDir, f))
             .filter(isValidSessionFile)
             .map((path) => ({ path, mtime: statSync(path).mtime }))
             .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
@@ -471,11 +476,11 @@ export class SessionManager {
     labelTimestampsById = new Map();
     leafId = null;
     constructor(cwd, sessionDir, sessionFile, persist) {
-        this.cwd = cwd;
-        this.sessionDir = sessionDir;
+        this.cwd = resolvePath(cwd);
+        this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
-        if (persist && sessionDir && !existsSync(sessionDir)) {
-            mkdirSync(sessionDir, { recursive: true });
+        if (persist && this.sessionDir && !existsSync(this.sessionDir)) {
+            mkdirSync(this.sessionDir, { recursive: true });
         }
         if (sessionFile) {
             this.setSessionFile(sessionFile);
@@ -486,7 +491,7 @@ export class SessionManager {
     }
     /** Switch to a different session file (used for resume and branching) */
     setSessionFile(sessionFile) {
-        this.sessionFile = resolve(sessionFile);
+        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
@@ -1000,7 +1005,7 @@ export class SessionManager {
      * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
      */
     static create(cwd, sessionDir) {
-        const dir = sessionDir ?? getDefaultSessionDir(cwd);
+        const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
         return new SessionManager(cwd, dir, undefined, true);
     }
     /**
@@ -1010,13 +1015,14 @@ export class SessionManager {
      * @param cwdOverride Optional cwd override instead of the session header cwd.
      */
     static open(path, sessionDir, cwdOverride) {
+        const resolvedPath = resolvePath(path);
         // Extract cwd from session header if possible, otherwise use process.cwd()
-        const entries = loadEntriesFromFile(path);
+        const entries = loadEntriesFromFile(resolvedPath);
         const header = entries.find((e) => e.type === "session");
         const cwd = cwdOverride ?? header?.cwd ?? process.cwd();
         // If no sessionDir provided, derive from file's parent directory
-        const dir = sessionDir ?? resolve(path, "..");
-        return new SessionManager(cwd, dir, path, true);
+        const dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");
+        return new SessionManager(cwd, dir, resolvedPath, true);
     }
     /**
      * Continue the most recent session, or create new if none.
@@ -1024,7 +1030,7 @@ export class SessionManager {
      * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
      */
     static continueRecent(cwd, sessionDir) {
-        const dir = sessionDir ?? getDefaultSessionDir(cwd);
+        const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
         const mostRecent = findMostRecentSession(dir);
         if (mostRecent) {
             return new SessionManager(cwd, dir, mostRecent, true);
@@ -1043,15 +1049,17 @@ export class SessionManager {
      * @param sessionDir Optional session directory. If omitted, uses default for targetCwd.
      */
     static forkFrom(sourcePath, targetCwd, sessionDir) {
-        const sourceEntries = loadEntriesFromFile(sourcePath);
+        const resolvedSourcePath = resolvePath(sourcePath);
+        const resolvedTargetCwd = resolvePath(targetCwd);
+        const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
         if (sourceEntries.length === 0) {
-            throw new Error(`Cannot fork: source session file is empty or invalid: ${sourcePath}`);
+            throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
         }
         const sourceHeader = sourceEntries.find((e) => e.type === "session");
         if (!sourceHeader) {
-            throw new Error(`Cannot fork: source session has no header: ${sourcePath}`);
+            throw new Error(`Cannot fork: source session has no header: ${resolvedSourcePath}`);
         }
-        const dir = sessionDir ?? getDefaultSessionDir(targetCwd);
+        const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(resolvedTargetCwd);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
@@ -1066,8 +1074,8 @@ export class SessionManager {
             version: CURRENT_SESSION_VERSION,
             id: newSessionId,
             timestamp,
-            cwd: targetCwd,
-            parentSession: sourcePath,
+            cwd: resolvedTargetCwd,
+            parentSession: resolvedSourcePath,
         };
         appendFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`);
         // Copy all non-header entries from source
@@ -1076,7 +1084,7 @@ export class SessionManager {
                 appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
             }
         }
-        return new SessionManager(targetCwd, dir, newSessionFile, true);
+        return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
     }
     /**
      * List all sessions for a directory.
@@ -1085,7 +1093,7 @@ export class SessionManager {
      * @param onProgress Optional callback for progress updates (loaded, total)
      */
     static async list(cwd, sessionDir, onProgress) {
-        const dir = sessionDir ?? getDefaultSessionDir(cwd);
+        const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
         const sessions = await listSessionsFromDir(dir, onProgress);
         sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         return sessions;

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

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
+import { normalizePath, resolvePath } from "../utils/paths.js";
 import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
 function deepMergeSettings(base, overrides) {
@@ -33,8 +33,10 @@ export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
     constructor(cwd, agentDir) {
-        this.globalSettingsPath = join(agentDir, "settings.json");
-        this.projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        this.globalSettingsPath = join(resolvedAgentDir, "settings.json");
+        this.projectSettingsPath = join(resolvedCwd, CONFIG_DIR_NAME, "settings.json");
     }
     acquireLockSyncWithRetry(path) {
         const maxAttempts = 10;
@@ -375,16 +377,7 @@ export class SettingsManager {
     }
     getSessionDir() {
         const sessionDir = this.settings.sessionDir;
-        if (!sessionDir) {
-            return sessionDir;
-        }
-        if (sessionDir === "~") {
-            return homedir();
-        }
-        if (sessionDir.startsWith("~/")) {
-            return join(homedir(), sessionDir.slice(2));
-        }
-        return sessionDir;
+        return sessionDir ? normalizePath(sessionDir) : sessionDir;
     }
     getDefaultProvider() {
         return this.settings.defaultProvider;

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

@@ -1,10 +1,9 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
 import ignore from "ignore";
-import { homedir } from "os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import { basename, dirname, join, relative, resolve, sep } from "path";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { parseFrontmatter } from "../utils/frontmatter.js";
-import { canonicalizePath } from "../utils/paths.js";
+import { canonicalizePath, resolvePath } from "../utils/paths.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 /** Max name length per spec */
 const MAX_NAME_LENGTH = 64;
@@ -285,28 +284,15 @@ function escapeXml(str) {
         .replace(/"/g, """)
         .replace(/'/g, "'");
 }
-function normalizePath(input) {
-    const trimmed = input.trim();
-    if (trimmed === "~")
-        return homedir();
-    if (trimmed.startsWith("~/"))
-        return join(homedir(), trimmed.slice(2));
-    if (trimmed.startsWith("~"))
-        return join(homedir(), trimmed.slice(1));
-    return trimmed;
-}
-function resolveSkillPath(p, cwd) {
-    const normalized = normalizePath(p);
-    return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
-}
 /**
  * Load skills from all configured locations.
  * Returns skills and any validation diagnostics.
  */
 export function loadSkills(options) {
-    const { cwd, agentDir, skillPaths, includeDefaults } = options;
+    const { agentDir, skillPaths, includeDefaults } = options;
     // Resolve agentDir - if not provided, use default from config
-    const resolvedAgentDir = agentDir ?? getAgentDir();
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(agentDir ?? getAgentDir());
     const skillMap = new Map();
     const realPathSet = new Set();
     const allDiagnostics = [];
@@ -342,10 +328,10 @@ export function loadSkills(options) {
     }
     if (includeDefaults) {
         addSkills(loadSkillsFromDirInternal(join(resolvedAgentDir, "skills"), "user", true));
-        addSkills(loadSkillsFromDirInternal(resolve(cwd, CONFIG_DIR_NAME, "skills"), "project", true));
+        addSkills(loadSkillsFromDirInternal(resolve(resolvedCwd, CONFIG_DIR_NAME, "skills"), "project", true));
     }
     const userSkillsDir = join(resolvedAgentDir, "skills");
-    const projectSkillsDir = resolve(cwd, CONFIG_DIR_NAME, "skills");
+    const projectSkillsDir = resolve(resolvedCwd, CONFIG_DIR_NAME, "skills");
     const isUnderPath = (target, root) => {
         const normalizedRoot = resolve(root);
         if (target === normalizedRoot) {
@@ -364,7 +350,7 @@ export function loadSkills(options) {
         return "path";
     };
     for (const rawPath of skillPaths) {
-        const resolvedPath = resolveSkillPath(rawPath, cwd);
+        const resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: true });
         if (!existsSync(resolvedPath)) {
             allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
             continue;

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

@@ -1,4 +1,5 @@
-import { existsSync } from "node:fs";
+import { constants } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
 import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { spawn } from "child_process";
 import { Type } from "typebox";
@@ -23,24 +24,33 @@ const bashSchema = Type.Object({
  */
 export function createLocalBashOperations(options) {
     return {
-        exec: (command, cwd, { onData, signal, timeout, env }) => {
-            return new Promise((resolve, reject) => {
-                const { shell, args } = getShellConfig(options?.shellPath);
-                if (!existsSync(cwd)) {
-                    reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`));
-                    return;
-                }
-                const child = spawn(shell, [...args, command], {
-                    cwd,
-                    detached: process.platform !== "win32",
-                    env: env ?? getShellEnv(),
-                    stdio: ["ignore", "pipe", "pipe"],
-                    windowsHide: true,
-                });
+        exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const { shell, args } = getShellConfig(options?.shellPath);
+            try {
+                await fsAccess(cwd, constants.F_OK);
+            }
+            catch {
+                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
+            }
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
+            const child = spawn(shell, [...args, command], {
+                cwd,
+                detached: process.platform !== "win32",
+                env: env ?? getShellEnv(),
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            if (child.pid)
+                trackDetachedChildPid(child.pid);
+            let timedOut = false;
+            let timeoutHandle;
+            const onAbort = () => {
                 if (child.pid)
-                    trackDetachedChildPid(child.pid);
-                let timedOut = false;
-                let timeoutHandle;
+                    killProcessTree(child.pid);
+            };
+            try {
                 // Set timeout if provided.
                 if (timeout !== undefined && timeout > 0) {
                     timeoutHandle = setTimeout(() => {
@@ -53,10 +63,6 @@ export function createLocalBashOperations(options) {
                 child.stdout?.on("data", onData);
                 child.stderr?.on("data", onData);
                 // Handle abort signal by killing the entire process tree.
-                const onAbort = () => {
-                    if (child.pid)
-                        killProcessTree(child.pid);
-                };
                 if (signal) {
                     if (signal.aborted)
                         onAbort();
@@ -65,34 +71,23 @@ export function createLocalBashOperations(options) {
                 }
                 // Handle shell spawn errors and wait for the process to terminate without hanging
                 // on inherited stdio handles held by detached descendants.
-                waitForChildProcess(child)
-                    .then((code) => {
-                    if (child.pid)
-                        untrackDetachedChildPid(child.pid);
-                    if (timeoutHandle)
-                        clearTimeout(timeoutHandle);
-                    if (signal)
-                        signal.removeEventListener("abort", onAbort);
-                    if (signal?.aborted) {
-                        reject(new Error("aborted"));
-                        return;
-                    }
-                    if (timedOut) {
-                        reject(new Error(`timeout:${timeout}`));
-                        return;
-                    }
-                    resolve({ exitCode: code });
-                })
-                    .catch((err) => {
-                    if (child.pid)
-                        untrackDetachedChildPid(child.pid);
-                    if (timeoutHandle)
-                        clearTimeout(timeoutHandle);
-                    if (signal)
-                        signal.removeEventListener("abort", onAbort);
-                    reject(err);
-                });
-            });
+                const exitCode = await waitForChildProcess(child);
+                if (signal?.aborted) {
+                    throw new Error("aborted");
+                }
+                if (timedOut) {
+                    throw new Error(`timeout:${timeout}`);
+                }
+                return { exitCode };
+            }
+            finally {
+                if (child.pid)
+                    untrackDetachedChildPid(child.pid);
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                if (signal)
+                    signal.removeEventListener("abort", onAbort);
+            }
         },
     };
 }
@@ -122,7 +117,15 @@ function formatBashCall(args) {
 function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt) {
     const state = component.state;
     component.clear();
-    const output = getTextOutput(result, showImages).trim();
+    let output = getTextOutput(result, showImages).trim();
+    const truncation = result.details?.truncation;
+    const fullOutputPath = result.details?.fullOutputPath;
+    if (!options.isPartial && truncation?.truncated && fullOutputPath && output.endsWith("]")) {
+        const footerStart = output.lastIndexOf("\n\n[");
+        if (footerStart !== -1 && output.slice(footerStart).includes(fullOutputPath)) {
+            output = output.slice(0, footerStart).trimEnd();
+        }
+    }
     if (output) {
         const styledOutput = output
             .split("\n")
@@ -155,8 +158,6 @@ function rebuildBashResultRenderComponent(component, result, options, showImages
             });
         }
     }
-    const truncation = result.details?.truncation;
-    const fullOutputPath = result.details?.fullOutputPath;
     if (truncation?.truncated || fullOutputPath) {
         const warnings = [];
         if (fullOutputPath) {

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

@@ -184,8 +184,15 @@ export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
     }
     return { baseContent, newContent };
 }
+/** Generate a standard unified patch. */
+export function generateUnifiedPatch(path, oldContent, newContent, contextLines = 4) {
+    return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+        context: contextLines,
+        headerOptions: Diff.FILE_HEADERS_ONLY,
+    });
+}
 /**
- * Generate a unified diff string with line numbers and context.
+ * Generate a display-oriented diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
 export function generateDiffString(oldContent, newContent, contextLines = 4) {