@psnext/slingcli 2.4.20260525-4 → 2.4.20260527-2

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

@@ -3,7 +3,7 @@ import { constants } from "fs";
 import { access as fsAccess, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { Type } from "typebox";
 import { renderDiff } from "../../modes/interactive/components/diff.js";
-import { applyEditsToNormalizedContent, computeEditsDiff, detectLineEnding, generateDiffString, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
+import { applyEditsToNormalizedContent, computeEditsDiff, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, stripBom, } from "./edit-diff.js";
 import { withFileMutationQueue } from "./file-mutation-queue.js";
 import { resolveToCwd } from "./path-utils.js";
 import { invalidArgText, shortenPath, str } from "./render-utils.js";
@@ -177,88 +177,51 @@ export function createEditToolDefinition(cwd, options) {
         async execute(_toolCallId, input, signal, _onUpdate, _ctx) {
             const { path, edits } = validateEditInput(input);
             const absolutePath = resolveToCwd(path, cwd);
-            return withFileMutationQueue(absolutePath, () => new Promise((resolve, reject) => {
-                // Check if already aborted.
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let aborted = false;
-                // Set up abort handler.
-                const onAbort = () => {
-                    aborted = true;
-                    reject(new Error("Operation aborted"));
+            return withFileMutationQueue(absolutePath, async () => {
+                // Do not reject from an abort event listener here: that would release the
+                // mutation queue while an in-flight filesystem operation may still finish.
+                // Checking signal.aborted after each await observes the same aborts while
+                // keeping the queue locked until the current operation has settled.
+                const throwIfAborted = () => {
+                    if (signal?.aborted)
+                        throw new Error("Operation aborted");
                 };
-                if (signal) {
-                    signal.addEventListener("abort", onAbort, { once: true });
+                throwIfAborted();
+                // Check if file exists.
+                try {
+                    await ops.access(absolutePath);
                 }
-                // Perform the edit operation.
-                void (async () => {
-                    try {
-                        // Check if file exists.
-                        try {
-                            await ops.access(absolutePath);
-                        }
-                        catch (error) {
-                            const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
-                            if (signal) {
-                                signal.removeEventListener("abort", onAbort);
-                            }
-                            reject(new Error(`Could not edit file: ${path}. ${errorMessage}.`));
-                            return;
-                        }
-                        // Check if aborted before reading.
-                        if (aborted) {
-                            return;
-                        }
-                        // Read the file.
-                        const buffer = await ops.readFile(absolutePath);
-                        const rawContent = buffer.toString("utf-8");
-                        // Check if aborted after reading.
-                        if (aborted) {
-                            return;
-                        }
-                        // Strip BOM before matching. The model will not include an invisible BOM in oldText.
-                        const { bom, text: content } = stripBom(rawContent);
-                        const originalEnding = detectLineEnding(content);
-                        const normalizedContent = normalizeToLF(content);
-                        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
-                        // Check if aborted before writing.
-                        if (aborted) {
-                            return;
-                        }
-                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-                        await ops.writeFile(absolutePath, finalContent);
-                        // Check if aborted after writing.
-                        if (aborted) {
-                            return;
-                        }
-                        // Clean up abort handler.
-                        if (signal) {
-                            signal.removeEventListener("abort", onAbort);
-                        }
-                        const diffResult = generateDiffString(baseContent, newContent);
-                        resolve({
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Successfully replaced ${edits.length} block(s) in ${path}.`,
-                                },
-                            ],
-                            details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
-                        });
-                    }
-                    catch (error) {
-                        // Clean up abort handler.
-                        if (signal) {
-                            signal.removeEventListener("abort", onAbort);
-                        }
-                        if (!aborted) {
-                            reject(error instanceof Error ? error : new Error(String(error)));
-                        }
-                    }
-                })();
-            }));
+                catch (error) {
+                    throwIfAborted();
+                    const errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+                    throw new Error(`Could not edit file: ${path}. ${errorMessage}.`);
+                }
+                throwIfAborted();
+                // Read the file.
+                const buffer = await ops.readFile(absolutePath);
+                const rawContent = buffer.toString("utf-8");
+                throwIfAborted();
+                // Strip BOM before matching. The model will not include an invisible BOM in oldText.
+                const { bom, text: content } = stripBom(rawContent);
+                const originalEnding = detectLineEnding(content);
+                const normalizedContent = normalizeToLF(content);
+                const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path);
+                throwIfAborted();
+                const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                await ops.writeFile(absolutePath, finalContent);
+                throwIfAborted();
+                const diffResult = generateDiffString(baseContent, newContent);
+                const patch = generateUnifiedPatch(path, baseContent, newContent);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Successfully replaced ${edits.length} block(s) in ${path}.`,
+                        },
+                    ],
+                    details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },
+                };
+            });
         },
         renderCall(args, theme, context) {
             const component = getEditCallRenderComponent(context.state, context.lastComponent);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/file-mutation-queue.js

@@ -1,13 +1,23 @@
-import { realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 const fileMutationQueues = new Map();
-function getMutationQueueKey(filePath) {
+let registrationQueue = Promise.resolve();
+function isMissingPathError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+async function getMutationQueueKey(filePath) {
     const resolvedPath = resolve(filePath);
     try {
-        return realpathSync.native(resolvedPath);
+        return await realpath(resolvedPath);
     }
-    catch {
-        return resolvedPath;
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return resolvedPath;
+        }
+        throw error;
     }
 }
 /**
@@ -15,14 +25,19 @@ function getMutationQueueKey(filePath) {
  * Operations for different files still run in parallel.
  */
 export async function withFileMutationQueue(filePath, fn) {
-    const key = getMutationQueueKey(filePath);
-    const currentQueue = fileMutationQueues.get(key) ?? Promise.resolve();
-    let releaseNext;
-    const nextQueue = new Promise((resolveQueue) => {
-        releaseNext = resolveQueue;
+    const registration = registrationQueue.then(async () => {
+        const key = await getMutationQueueKey(filePath);
+        const currentQueue = fileMutationQueues.get(key) ?? Promise.resolve();
+        let releaseNext;
+        const nextQueue = new Promise((resolveQueue) => {
+            releaseNext = resolveQueue;
+        });
+        const chainedQueue = currentQueue.then(() => nextQueue);
+        fileMutationQueues.set(key, chainedQueue);
+        return { key, currentQueue, chainedQueue, releaseNext };
     });
-    const chainedQueue = currentQueue.then(() => nextQueue);
-    fileMutationQueues.set(key, chainedQueue);
+    registrationQueue = registration.then(() => undefined, () => undefined);
+    const { key, currentQueue, chainedQueue, releaseNext } = await registration;
     await currentQueue;
     try {
         return await fn();

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

@@ -1,12 +1,11 @@
 import { createInterface } from "node:readline";
 import { Text } from "@earendil-works/pi-tui";
 import { spawn } from "child_process";
-import { existsSync } from "fs";
 import path from "path";
 import { Type } from "typebox";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
 import { ensureTool } from "../../utils/tools-manager.js";
-import { resolveToCwd } from "./path-utils.js";
+import { pathExists, resolveToCwd } from "./path-utils.js";
 import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
@@ -22,7 +21,7 @@ const findSchema = Type.Object({
 });
 const DEFAULT_LIMIT = 1000;
 const defaultFindOperations = {
-    exists: existsSync,
+    exists: pathExists,
     // This is a placeholder. Actual fd execution happens in execute() when no custom glob is provided.
     glob: () => [],
 };

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

@@ -1,7 +1,7 @@
+import { readFile as fsReadFile, stat as fsStat } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Text } from "@earendil-works/pi-tui";
 import { spawn } from "child_process";
-import { readFileSync, statSync } from "fs";
 import path from "path";
 import { Type } from "typebox";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
@@ -21,8 +21,8 @@ const grepSchema = Type.Object({
 });
 const DEFAULT_LIMIT = 100;
 const defaultGrepOperations = {
-    isDirectory: (p) => statSync(p).isDirectory(),
-    readFile: (p) => readFileSync(p, "utf-8"),
+    isDirectory: async (p) => (await fsStat(p)).isDirectory(),
+    readFile: (p) => fsReadFile(p, "utf-8"),
 };
 function formatGrepCall(args, theme) {
     const pattern = str(args?.pattern);

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

@@ -1,9 +1,9 @@
+import { readdir as fsReaddir, stat as fsStat } from "node:fs/promises";
 import { Text } from "@earendil-works/pi-tui";
-import { existsSync, readdirSync, statSync } from "fs";
 import nodePath from "path";
 import { Type } from "typebox";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
-import { resolveToCwd } from "./path-utils.js";
+import { pathExists, resolveToCwd } from "./path-utils.js";
 import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
@@ -13,9 +13,9 @@ const lsSchema = Type.Object({
 });
 const DEFAULT_LIMIT = 500;
 const defaultLsOperations = {
-    exists: existsSync,
-    stat: statSync,
-    readdir: readdirSync,
+    exists: pathExists,
+    stat: fsStat,
+    readdir: fsReaddir,
 };
 function formatLsCall(args, theme) {
     const rawPath = str(args?.path);

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

@@ -29,8 +29,10 @@ export class OutputAccumulator {
     tailStartsAtLineBoundary = true;
     totalRawBytes = 0;
     totalDecodedBytes = 0;
-    totalLines = 1;
+    completedLines = 0;
+    totalLines = 0;
     currentLineBytes = 0;
+    hasOpenLine = false;
     finished = false;
     tempFilePath;
     tempFileStream;
@@ -133,11 +135,15 @@ export class OutputAccumulator {
         }
         if (newlines === 0) {
             this.currentLineBytes += bytes;
+            this.hasOpenLine = true;
         }
         else {
-            this.totalLines += newlines;
-            this.currentLineBytes = byteLength(text.slice(lastNewline + 1));
+            this.completedLines += newlines;
+            const tail = text.slice(lastNewline + 1);
+            this.currentLineBytes = byteLength(tail);
+            this.hasOpenLine = tail.length > 0;
         }
+        this.totalLines = this.completedLines + (this.hasOpenLine ? 1 : 0);
     }
     trimTail() {
         const buffer = Buffer.from(this.tailText, "utf-8");

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

@@ -1,11 +1,7 @@
 import { accessSync, constants } from "node:fs";
-import * as os from "node:os";
-import { isAbsolute, resolve as resolvePath } from "node:path";
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+import { access } from "node:fs/promises";
+import { normalizePath, resolvePath } from "../../utils/paths.js";
 const NARROW_NO_BREAK_SPACE = "\u202F";
-function normalizeUnicodeSpaces(str) {
-    return str.replace(UNICODE_SPACES, " ");
-}
 function tryMacOSScreenshotPath(filePath) {
     return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
 }
@@ -27,29 +23,24 @@ function fileExists(filePath) {
         return false;
     }
 }
-function normalizeAtPrefix(filePath) {
-    return filePath.startsWith("@") ? filePath.slice(1) : filePath;
-}
-export function expandPath(filePath) {
-    const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
-    if (normalized === "~") {
-        return os.homedir();
+export async function pathExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
     }
-    if (normalized.startsWith("~/")) {
-        return os.homedir() + normalized.slice(1);
+    catch {
+        return false;
     }
-    return normalized;
+}
+export function expandPath(filePath) {
+    return normalizePath(filePath, { normalizeUnicodeSpaces: true, stripAtPrefix: true });
 }
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.
  */
 export function resolveToCwd(filePath, cwd) {
-    const expanded = expandPath(filePath);
-    if (isAbsolute(expanded)) {
-        return expanded;
-    }
-    return resolvePath(cwd, expanded);
+    return resolvePath(filePath, cwd, { normalizeUnicodeSpaces: true, stripAtPrefix: true });
 }
 export function resolveReadPath(filePath, cwd) {
     const resolved = resolveToCwd(filePath, cwd);
@@ -78,4 +69,31 @@ export function resolveReadPath(filePath, cwd) {
     }
     return resolved;
 }
+export async function resolveReadPathAsync(filePath, cwd) {
+    const resolved = resolveToCwd(filePath, cwd);
+    if (await pathExists(resolved)) {
+        return resolved;
+    }
+    // Try macOS AM/PM variant (narrow no-break space before AM/PM)
+    const amPmVariant = tryMacOSScreenshotPath(resolved);
+    if (amPmVariant !== resolved && (await pathExists(amPmVariant))) {
+        return amPmVariant;
+    }
+    // Try NFD variant (macOS stores filenames in NFD form)
+    const nfdVariant = tryNFDVariant(resolved);
+    if (nfdVariant !== resolved && (await pathExists(nfdVariant))) {
+        return nfdVariant;
+    }
+    // Try curly quote variant (macOS uses U+2019 in screenshot names)
+    const curlyVariant = tryCurlyQuoteVariant(resolved);
+    if (curlyVariant !== resolved && (await pathExists(curlyVariant))) {
+        return curlyVariant;
+    }
+    // Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
+    const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+    if (nfdCurlyVariant !== resolved && (await pathExists(nfdCurlyVariant))) {
+        return nfdCurlyVariant;
+    }
+    return resolved;
+}
 //# sourceMappingURL=path-utils.js.map

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

@@ -9,7 +9,7 @@ import { getLanguageFromPath, highlightCode } from "../../modes/interactive/them
 import { formatDimensionNote, resizeImage } from "../../utils/image-resize.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { formatPathRelativeToCwdOrAbsolute } from "../../utils/paths.js";
-import { resolveReadPath } from "./path-utils.js";
+import { resolveReadPathAsync, resolveToCwd } from "./path-utils.js";
 import { getTextOutput, invalidArgText, replaceTabs, shortenPath, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead } from "./truncate.js";
@@ -73,7 +73,7 @@ function getCompactReadClassification(args, cwd) {
     const rawPath = str(args?.file_path ?? args?.path);
     if (!rawPath)
         return undefined;
-    const absolutePath = resolveReadPath(rawPath, cwd);
+    const absolutePath = resolveToCwd(rawPath, cwd);
     const fileName = basename(absolutePath);
     if (fileName === "SKILL.md") {
         return { kind: "skill", label: basename(dirname(absolutePath)) || fileName };
@@ -100,8 +100,8 @@ function formatCompactReadCall(classification, args, theme) {
         formatReadLineRange(args, theme) +
         expandHint);
 }
-function formatReadResult(args, result, options, theme, showImages, cwd, isError) {
-    if (!options.expanded && !isError && getCompactReadClassification(args, cwd)) {
+function formatReadResult(args, result, options, theme, showImages, _cwd, isError) {
+    if (!options.expanded && !isError) {
         return "";
     }
     const rawPath = str(args?.file_path ?? args?.path);
@@ -141,7 +141,6 @@ export function createReadToolDefinition(cwd, options) {
         promptGuidelines: ["Use read to examine files instead of cat or sed."],
         parameters: readSchema,
         async execute(_toolCallId, { path, offset, limit }, signal, _onUpdate, ctx) {
-            const absolutePath = resolveReadPath(path, cwd);
             return new Promise((resolve, reject) => {
                 if (signal?.aborted) {
                     reject(new Error("Operation aborted"));
@@ -155,6 +154,9 @@ export function createReadToolDefinition(cwd, options) {
                 signal?.addEventListener("abort", onAbort, { once: true });
                 (async () => {
                     try {
+                        const absolutePath = await resolveReadPathAsync(path, cwd);
+                        if (aborted)
+                            return;
                         // Check if file exists and is readable.
                         await ops.access(absolutePath);
                         if (aborted)
@@ -166,10 +168,9 @@ export function createReadToolDefinition(cwd, options) {
                         if (mimeType) {
                             // Read image as binary.
                             const buffer = await ops.readFile(absolutePath);
-                            const base64 = buffer.toString("base64");
                             if (autoResizeImages) {
                                 // Resize image if needed before sending it back to the model.
-                                const resized = await resizeImage({ type: "image", data: base64, mimeType });
+                                const resized = await resizeImage(buffer, mimeType);
                                 if (!resized) {
                                     let textNote = `Read image file [${mimeType}]\n[Image omitted: could not be resized below the inline image size limit.]`;
                                     if (nonVisionImageNote)
@@ -195,7 +196,7 @@ export function createReadToolDefinition(cwd, options) {
                                     textNote += `\n${nonVisionImageNote}`;
                                 content = [
                                     { type: "text", text: textNote },
-                                    { type: "image", data: base64, mimeType },
+                                    { type: "image", data: buffer.toString("base64"), mimeType },
                                 ];
                             }
                         }

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

@@ -10,6 +10,16 @@
 export const DEFAULT_MAX_LINES = 2000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+function splitLinesForCounting(content) {
+    if (content.length === 0) {
+        return [];
+    }
+    const lines = content.split("\n");
+    if (content.endsWith("\n")) {
+        lines.pop();
+    }
+    return lines;
+}
 /**
  * Format bytes as human-readable size.
  */
@@ -35,7 +45,7 @@ export function truncateHead(content, options = {}) {
     const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
     const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
     const totalBytes = Buffer.byteLength(content, "utf-8");
-    const lines = content.split("\n");
+    const lines = splitLinesForCounting(content);
     const totalLines = lines.length;
     // Check if no truncation needed
     if (totalLines <= maxLines && totalBytes <= maxBytes) {
@@ -114,7 +124,7 @@ export function truncateTail(content, options = {}) {
     const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
     const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
     const totalBytes = Buffer.byteLength(content, "utf-8");
-    const lines = content.split("\n");
+    const lines = splitLinesForCounting(content);
     const totalLines = lines.length;
     // Check if no truncation needed
     if (totalLines <= maxLines && totalBytes <= maxBytes) {

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

@@ -141,42 +141,27 @@ export function createWriteToolDefinition(cwd, options) {
         async execute(_toolCallId, { path, content }, signal, _onUpdate, _ctx) {
             const absolutePath = resolveToCwd(path, cwd);
             const dir = dirname(absolutePath);
-            return withFileMutationQueue(absolutePath, () => new Promise((resolve, reject) => {
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let aborted = false;
-                const onAbort = () => {
-                    aborted = true;
-                    reject(new Error("Operation aborted"));
+            return withFileMutationQueue(absolutePath, async () => {
+                // Do not reject from an abort event listener here: that would release the
+                // mutation queue while an in-flight filesystem operation may still finish.
+                // Checking signal.aborted after each await observes the same aborts while
+                // keeping the queue locked until the current operation has settled.
+                const throwIfAborted = () => {
+                    if (signal?.aborted)
+                        throw new Error("Operation aborted");
                 };
-                signal?.addEventListener("abort", onAbort, { once: true });
-                (async () => {
-                    try {
-                        // Create parent directories if needed.
-                        await ops.mkdir(dir);
-                        if (aborted)
-                            return;
-                        // Write the file contents.
-                        await ops.writeFile(absolutePath, content);
-                        if (aborted)
-                            return;
-                        signal?.removeEventListener("abort", onAbort);
-                        resolve({
-                            content: [
-                                { type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` },
-                            ],
-                            details: undefined,
-                        });
-                    }
-                    catch (error) {
-                        signal?.removeEventListener("abort", onAbort);
-                        if (!aborted)
-                            reject(error);
-                    }
-                })();
-            }));
+                throwIfAborted();
+                // Create parent directories if needed.
+                await ops.mkdir(dir);
+                throwIfAborted();
+                // Write the file contents.
+                await ops.writeFile(absolutePath, content);
+                throwIfAborted();
+                return {
+                    content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
+                    details: undefined,
+                };
+            });
         },
         renderCall(args, theme, context) {
             const renderArgs = args;

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

@@ -4,7 +4,6 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
-import { resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { modelsAreEqual } from "@earendil-works/pi-ai";
 import { ProcessTerminal, setKeybindings, TUI } from "@earendil-works/pi-tui";
@@ -33,7 +32,7 @@ import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
 import { ExtensionSelectorComponent } from "./modes/interactive/components/extension-selector.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
 import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
-import { isLocalPath } from "./utils/paths.js";
+import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.js";
 import { cleanupWindowsSelfUpdateQuarantine } from "./utils/windows-self-update.js";
 /**
  * Read all content from piped stdin.
@@ -106,9 +105,9 @@ async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
  * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
  */
 async function resolveSessionPath(sessionArg, cwd, sessionDir) {
-    // If it looks like a file path, use as-is
+    // If it looks like a file path, resolve it before handing it to the session manager.
     if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-        return { type: "path", path: sessionArg };
+        return { type: "path", path: resolvePath(sessionArg, cwd) };
     }
     // Try to match as session ID in current project first
     const localSessions = await SessionManager.list(cwd, sessionDir);
@@ -296,7 +295,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
     return { options, cliThinkingFromModel, diagnostics };
 }
 function resolveCliPaths(cwd, paths) {
-    return paths?.map((value) => (isLocalPath(value) ? resolve(cwd, value) : value));
+    return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
 }
 async function promptForMissingSessionCwd(issue, settingsManager) {
     initTheme(settingsManager.getTheme());
@@ -387,7 +386,7 @@ export async function main(args, options) {
     // the target session cwd is known. The startup-cwd settings manager is used only for
     // sessionDir lookup during session selection.
     const envSessionDir = process.env[ENV_SESSION_DIR];
-    const sessionDir = parsed.sessionDir ??
+    const sessionDir = (parsed.sessionDir ? normalizePath(parsed.sessionDir) : undefined) ??
         (envSessionDir ? expandTildePath(envSessionDir) : undefined) ??
         startupSettingsManager.getSessionDir();
     let sessionManager = await createSessionManager(parsed, cwd, sessionDir, startupSettingsManager);

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/config-selector.js

@@ -462,7 +462,7 @@ class ResourceList {
     }
     getResourcePattern(item) {
         const scope = item.metadata.scope;
-        const baseDir = this.getTopLevelBaseDir(scope);
+        const baseDir = item.metadata.baseDir ?? this.getTopLevelBaseDir(scope);
         return relative(baseDir, item.path);
     }
     getPackageResourcePattern(item) {

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/footer.js

@@ -1,3 +1,4 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { theme } from "../theme/theme.js";
 /**
@@ -25,6 +26,18 @@ function formatTokens(count) {
         return `${(count / 1000000).toFixed(1)}M`;
     return `${Math.round(count / 1000000)}M`;
 }
+export function formatCwdForFooter(cwd, home) {
+    if (!home)
+        return cwd;
+    const resolvedCwd = resolve(cwd);
+    const resolvedHome = resolve(home);
+    const relativeToHome = relative(resolvedHome, resolvedCwd);
+    const isInsideHome = relativeToHome === "" ||
+        (relativeToHome !== ".." && !relativeToHome.startsWith(`..${sep}`) && !isAbsolute(relativeToHome));
+    if (!isInsideHome)
+        return cwd;
+    return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}
 /**
  * Footer component that shows pwd, token stats, and context usage.
  * Computes token/context stats from session, gets git branch and extension statuses from provider.
@@ -81,11 +94,7 @@ export class FooterComponent {
         const contextPercentValue = contextUsage?.percent ?? 0;
         const contextPercent = contextUsage?.percent !== null ? contextPercentValue.toFixed(1) : "?";
         // Replace home directory with ~
-        let pwd = this.session.sessionManager.getCwd();
-        const home = process.env.HOME || process.env.USERPROFILE;
-        if (home && pwd.startsWith(home)) {
-            pwd = `~${pwd.slice(home.length)}`;
-        }
+        let pwd = formatCwdForFooter(this.session.sessionManager.getCwd(), process.env.HOME || process.env.USERPROFILE);
         // Add git branch if available
         const branch = this.footerData.getGitBranch();
         if (branch) {