@psnext/slingcli 2.4.20260601-1 → 2.5.20260602-2

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

@@ -1,8 +1,10 @@
 import { uuidv7 } from "@earendil-works/pi-agent-core";
 import { randomUUID } from "crypto";
-import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "fs";
-import { readdir, readFile, stat } from "fs/promises";
+import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, statSync, writeFileSync, } from "fs";
+import { readdir, stat } from "fs/promises";
 import { join, resolve } from "path";
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
 import { getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
@@ -10,6 +12,11 @@ export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
     return uuidv7();
 }
+export function assertValidSessionId(id) {
+    if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
+        throw new Error("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
+    }
+}
 /** Generate a unique short ID (8 hex chars, collision-checked) */
 function generateId(byId) {
     for (let i = 0; i < 100; i++) {
@@ -210,34 +217,65 @@ export function buildSessionContext(entries, leafId, byId) {
  * Compute the default session directory for a cwd.
  * Encodes cwd into a safe directory name under ~/.pi/agent/sessions/.
  */
-export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
+function getDefaultSessionDirPath(cwd, agentDir = getDefaultAgentDir()) {
     const resolvedCwd = resolvePath(cwd);
     const resolvedAgentDir = resolvePath(agentDir);
     const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-    const sessionDir = join(resolvedAgentDir, "sessions", safePath);
+    return join(resolvedAgentDir, "sessions", safePath);
+}
+export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
+    const sessionDir = getDefaultSessionDirPath(cwd, agentDir);
     if (!existsSync(sessionDir)) {
         mkdirSync(sessionDir, { recursive: true });
     }
     return sessionDir;
 }
+const SESSION_READ_BUFFER_SIZE = 1024 * 1024;
+function parseSessionEntryLine(line) {
+    if (!line.trim())
+        return null;
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        // Skip malformed lines
+        return null;
+    }
+}
 /** Exported for testing */
 export function loadEntriesFromFile(filePath) {
     const resolvedFilePath = normalizePath(filePath);
     if (!existsSync(resolvedFilePath))
         return [];
-    const content = readFileSync(resolvedFilePath, "utf8");
     const entries = [];
-    const lines = content.trim().split("\n");
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        try {
-            const entry = JSON.parse(line);
-            entries.push(entry);
-        }
-        catch {
-            // Skip malformed lines
+    const fd = openSync(resolvedFilePath, "r");
+    try {
+        const decoder = new StringDecoder("utf8");
+        const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+        let pending = "";
+        while (true) {
+            const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            pending += decoder.write(buffer.subarray(0, bytesRead));
+            let lineStart = 0;
+            let newlineIndex = pending.indexOf("\n", lineStart);
+            while (newlineIndex !== -1) {
+                const entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
+                if (entry)
+                    entries.push(entry);
+                lineStart = newlineIndex + 1;
+                newlineIndex = pending.indexOf("\n", lineStart);
+            }
+            pending = pending.slice(lineStart);
         }
+        pending += decoder.end();
+        const finalEntry = parseSessionEntryLine(pending);
+        if (finalEntry)
+            entries.push(finalEntry);
+    }
+    finally {
+        closeSync(fd);
     }
     // Validate session header
     if (entries.length === 0)
@@ -248,7 +286,7 @@ export function loadEntriesFromFile(filePath) {
     }
     return entries;
 }
-function isValidSessionFile(filePath) {
+function readSessionHeader(filePath) {
     try {
         const fd = openSync(filePath, "r");
         const buffer = Buffer.alloc(512);
@@ -256,23 +294,36 @@ function isValidSessionFile(filePath) {
         closeSync(fd);
         const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
         if (!firstLine)
-            return false;
+            return null;
         const header = JSON.parse(firstLine);
-        return header.type === "session" && typeof header.id === "string";
+        if (header.type !== "session" || typeof header.id !== "string") {
+            return null;
+        }
+        return header;
     }
     catch {
-        return false;
+        return null;
     }
 }
+function getSessionHeaderCwd(header) {
+    const cwd = header.cwd;
+    return typeof cwd === "string" ? cwd : undefined;
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+    return cwd !== undefined && cwd !== "" && resolvePath(cwd) === resolvedCwd;
+}
 /** Exported for testing */
-export function findMostRecentSession(sessionDir) {
+export function findMostRecentSession(sessionDir, cwd) {
     const resolvedSessionDir = normalizePath(sessionDir);
+    const resolvedCwd = cwd ? resolvePath(cwd) : undefined;
     try {
         const files = readdirSync(resolvedSessionDir)
             .filter((f) => f.endsWith(".jsonl"))
             .map((f) => join(resolvedSessionDir, f))
-            .filter(isValidSessionFile)
-            .map((path) => ({ path, mtime: statSync(path).mtime }))
+            .map((path) => ({ path, header: readSessionHeader(path) }))
+            .filter((file) => file.header !== null &&
+            (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
+            .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
             .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         return files[0]?.path || null;
     }
@@ -293,73 +344,53 @@ function extractTextContent(message) {
         .map((block) => block.text)
         .join(" ");
 }
-function getLastActivityTime(entries) {
-    let lastActivityTime;
-    for (const entry of entries) {
-        if (entry.type !== "message")
-            continue;
-        const message = entry.message;
-        if (!isMessageWithContent(message))
-            continue;
-        if (message.role !== "user" && message.role !== "assistant")
-            continue;
-        const msgTimestamp = message.timestamp;
-        if (typeof msgTimestamp === "number") {
-            lastActivityTime = Math.max(lastActivityTime ?? 0, msgTimestamp);
-            continue;
-        }
-        const entryTimestamp = entry.timestamp;
-        if (typeof entryTimestamp === "string") {
-            const t = new Date(entryTimestamp).getTime();
-            if (!Number.isNaN(t)) {
-                lastActivityTime = Math.max(lastActivityTime ?? 0, t);
-            }
-        }
-    }
-    return lastActivityTime;
-}
-function getSessionModifiedDate(entries, header, statsMtime) {
-    const lastActivityTime = getLastActivityTime(entries);
-    if (typeof lastActivityTime === "number" && lastActivityTime > 0) {
-        return new Date(lastActivityTime);
+function getMessageActivityTime(entry) {
+    const message = entry.message;
+    if (!isMessageWithContent(message))
+        return undefined;
+    if (message.role !== "user" && message.role !== "assistant")
+        return undefined;
+    const msgTimestamp = message.timestamp;
+    if (typeof msgTimestamp === "number") {
+        return msgTimestamp;
     }
-    const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
-    return !Number.isNaN(headerTime) ? new Date(headerTime) : statsMtime;
+    const t = new Date(entry.timestamp).getTime();
+    return Number.isNaN(t) ? undefined : t;
 }
 async function buildSessionInfo(filePath) {
     try {
-        const content = await readFile(filePath, "utf8");
-        const entries = [];
-        const lines = content.trim().split("\n");
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                entries.push(JSON.parse(line));
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-        if (entries.length === 0)
-            return null;
-        const header = entries[0];
-        if (header.type !== "session")
-            return null;
         const stats = await stat(filePath);
+        let header = null;
         let messageCount = 0;
         let firstMessage = "";
         const allMessages = [];
         let name;
-        for (const entry of entries) {
+        let lastActivityTime;
+        const rl = createInterface({
+            input: createReadStream(filePath, { encoding: "utf8" }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            const entry = parseSessionEntryLine(line);
+            if (!entry)
+                continue;
+            if (!header) {
+                if (entry.type !== "session")
+                    return null;
+                header = entry;
+                continue;
+            }
             // Extract session name (use latest, including explicit clears)
             if (entry.type === "session_info") {
-                const infoEntry = entry;
-                name = infoEntry.name?.trim() || undefined;
+                name = entry.name?.trim() || undefined;
             }
             if (entry.type !== "message")
                 continue;
             messageCount++;
+            const activityTime = getMessageActivityTime(entry);
+            if (typeof activityTime === "number") {
+                lastActivityTime = Math.max(lastActivityTime ?? 0, activityTime);
+            }
             const message = entry.message;
             if (!isMessageWithContent(message))
                 continue;
@@ -373,9 +404,16 @@ async function buildSessionInfo(filePath) {
                 firstMessage = textContent;
             }
         }
+        if (!header)
+            return null;
         const cwd = typeof header.cwd === "string" ? header.cwd : "";
         const parentSessionPath = header.parentSession;
-        const modified = getSessionModifiedDate(entries, header, stats.mtime);
+        const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+        const modified = typeof lastActivityTime === "number" && lastActivityTime > 0
+            ? new Date(lastActivityTime)
+            : !Number.isNaN(headerTime)
+                ? new Date(headerTime)
+                : stats.mtime;
         return {
             path: filePath,
             id: header.id,
@@ -475,7 +513,7 @@ export class SessionManager {
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
-    constructor(cwd, sessionDir, sessionFile, persist) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
@@ -486,7 +524,7 @@ export class SessionManager {
             this.setSessionFile(sessionFile);
         }
         else {
-            this.newSession();
+            this.newSession(newSessionOptions);
         }
     }
     /** Switch to a different session file (used for resume and branching) */
@@ -519,6 +557,9 @@ export class SessionManager {
         }
     }
     newSession(options) {
+        if (options?.id !== undefined) {
+            assertValidSessionId(options.id);
+        }
         this.sessionId = options?.id ?? createSessionId();
         const timestamp = new Date().toISOString();
         const header = {
@@ -565,8 +606,15 @@ export class SessionManager {
     _rewriteFile() {
         if (!this.persist || !this.sessionFile)
             return;
-        const content = `${this.fileEntries.map((e) => JSON.stringify(e)).join("\n")}\n`;
-        writeFileSync(this.sessionFile, content);
+        const fd = openSync(this.sessionFile, "w");
+        try {
+            for (const entry of this.fileEntries) {
+                writeFileSync(fd, `${JSON.stringify(entry)}\n`);
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
     }
     isPersisted() {
         return this.persist;
@@ -577,6 +625,9 @@ export class SessionManager {
     getSessionDir() {
         return this.sessionDir;
     }
+    usesDefaultSessionDir() {
+        return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+    }
     getSessionId() {
         return this.sessionId;
     }
@@ -588,13 +639,24 @@ export class SessionManager {
             return;
         const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
         if (!hasAssistant) {
-            // Mark as not flushed so when assistant arrives, all entries get written
-            this.flushed = false;
+            if (this.flushed) {
+                appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
+            }
+            else {
+                // Mark as not flushed so when assistant arrives, all entries get written
+                this.flushed = false;
+            }
             return;
         }
         if (!this.flushed) {
-            for (const e of this.fileEntries) {
-                appendFileSync(this.sessionFile, `${JSON.stringify(e)}\n`);
+            const fd = openSync(this.sessionFile, "wx");
+            try {
+                for (const e of this.fileEntries) {
+                    writeFileSync(fd, `${JSON.stringify(e)}\n`);
+                }
+            }
+            finally {
+                closeSync(fd);
             }
             this.flushed = true;
         }
@@ -1004,9 +1066,9 @@ export class SessionManager {
      * @param cwd Working directory (stored in session header)
      * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
      */
-    static create(cwd, sessionDir) {
+    static create(cwd, sessionDir, options) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        return new SessionManager(cwd, dir, undefined, true);
+        return new SessionManager(cwd, dir, undefined, true, options);
     }
     /**
      * Open a specific session file.
@@ -1031,7 +1093,8 @@ export class SessionManager {
      */
     static continueRecent(cwd, sessionDir) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const mostRecent = findMostRecentSession(dir);
+        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const mostRecent = findMostRecentSession(dir, filterCwd ? cwd : undefined);
         if (mostRecent) {
             return new SessionManager(cwd, dir, mostRecent, true);
         }
@@ -1048,7 +1111,7 @@ export class SessionManager {
      * @param targetCwd Target working directory (where the new session will be stored)
      * @param sessionDir Optional session directory. If omitted, uses default for targetCwd.
      */
-    static forkFrom(sourcePath, targetCwd, sessionDir) {
+    static forkFrom(sourcePath, targetCwd, sessionDir, options) {
         const resolvedSourcePath = resolvePath(sourcePath);
         const resolvedTargetCwd = resolvePath(targetCwd);
         const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
@@ -1064,7 +1127,10 @@ export class SessionManager {
             mkdirSync(dir, { recursive: true });
         }
         // Create new session file with new ID but forked content
-        const newSessionId = createSessionId();
+        if (options?.id !== undefined) {
+            assertValidSessionId(options.id);
+        }
+        const newSessionId = options?.id ?? createSessionId();
         const timestamp = new Date().toISOString();
         const fileTimestamp = timestamp.replace(/[:.]/g, "-");
         const newSessionFile = join(dir, `${fileTimestamp}_${newSessionId}.jsonl`);
@@ -1077,7 +1143,7 @@ export class SessionManager {
             cwd: resolvedTargetCwd,
             parentSession: resolvedSourcePath,
         };
-        appendFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`);
+        writeFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`, { flag: "wx" });
         // Copy all non-header entries from source
         for (const entry of sourceEntries) {
             if (entry.type !== "session") {
@@ -1094,15 +1160,20 @@ export class SessionManager {
      */
     static async list(cwd, sessionDir, onProgress) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
-        const sessions = await listSessionsFromDir(dir, onProgress);
+        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const resolvedCwd = resolvePath(cwd);
+        const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
         sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
         return sessions;
     }
-    /**
-     * List all sessions across all project directories.
-     * @param onProgress Optional callback for progress updates (loaded, total)
-     */
-    static async listAll(onProgress) {
+    static async listAll(sessionDirOrOnProgress, onProgress) {
+        const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;
+        const progress = typeof sessionDirOrOnProgress === "function" ? sessionDirOrOnProgress : onProgress;
+        if (customSessionDir) {
+            const sessions = await listSessionsFromDir(customSessionDir, progress);
+            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+            return sessions;
+        }
         const sessionsDir = getSessionsDir();
         try {
             if (!existsSync(sessionsDir)) {
@@ -1129,7 +1200,7 @@ export class SessionManager {
             const allFiles = dirFiles.flat();
             const results = await buildSessionInfosWithConcurrency(allFiles, () => {
                 loaded++;
-                onProgress?.(loaded, totalFiles);
+                progress?.(loaded, totalFiles);
             });
             for (const info of results) {
                 if (info) {

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

@@ -29,6 +29,16 @@ function deepMergeSettings(base, overrides) {
     }
     return result;
 }
+function parseTimeoutSetting(value, settingName) {
+    const timeoutMs = parseHttpIdleTimeoutMs(value);
+    if (timeoutMs !== undefined) {
+        return timeoutMs;
+    }
+    if (value !== undefined) {
+        throw new Error(`Invalid ${settingName} setting: ${String(value)}`);
+    }
+    return undefined;
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
@@ -494,15 +504,7 @@ export class SettingsManager {
         };
     }
     getHttpIdleTimeoutMs() {
-        const value = this.settings.httpIdleTimeoutMs;
-        const timeoutMs = parseHttpIdleTimeoutMs(value);
-        if (timeoutMs !== undefined) {
-            return timeoutMs;
-        }
-        if (value !== undefined) {
-            throw new Error(`Invalid httpIdleTimeoutMs setting: ${String(value)}`);
-        }
-        return DEFAULT_HTTP_IDLE_TIMEOUT_MS;
+        return parseTimeoutSetting(this.settings.httpIdleTimeoutMs, "httpIdleTimeoutMs") ?? DEFAULT_HTTP_IDLE_TIMEOUT_MS;
     }
     setHttpIdleTimeoutMs(timeoutMs) {
         if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
@@ -519,6 +521,9 @@ export class SettingsManager {
             maxRetryDelayMs: this.settings.retry?.provider?.maxRetryDelayMs ?? 60000,
         };
     }
+    getWebSocketConnectTimeoutMs() {
+        return parseTimeoutSetting(this.settings.websocketConnectTimeoutMs, "websocketConnectTimeoutMs");
+    }
     getHideThinkingBlock() {
         return this.settings.hideThinkingBlock ?? false;
     }

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

@@ -68,9 +68,6 @@ export function buildSystemPrompt(options) {
     if (hasBash && !hasGrep && !hasFind && !hasLs) {
         addGuideline("Use bash for file operations like ls, rg, find");
     }
-    else if (hasBash && (hasGrep || hasFind || hasLs)) {
-        addGuideline("Prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore)");
-    }
     for (const guideline of promptGuidelines ?? []) {
         const normalized = guideline.trim();
         if (normalized.length > 0) {

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

@@ -6,7 +6,7 @@ import { renderDiff } from "../../modes/interactive/components/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";
+import { renderToolPath, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 const replaceEditSchema = Type.Object({
     oldText: Type.String({
@@ -93,11 +93,8 @@ function getRenderablePreviewInput(args) {
     }
     return null;
 }
-function formatEditCall(args, theme) {
-    const invalidArg = invalidArgText(theme);
-    const rawPath = str(args?.file_path ?? args?.path);
-    const path = rawPath !== null ? shortenPath(rawPath) : null;
-    const pathDisplay = path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
+function formatEditCall(args, theme, cwd) {
+    const pathDisplay = renderToolPath(str(args?.file_path ?? args?.path), theme, cwd);
     return `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
 }
 function formatEditResult(args, preview, result, theme, isError) {
@@ -132,10 +129,10 @@ function getEditHeaderBg(preview, settledError, theme) {
     }
     return (text) => theme.bg("toolPendingBg", text);
 }
-function buildEditCallComponent(component, args, theme) {
+function buildEditCallComponent(component, args, theme, cwd) {
     component.setBgFn(getEditHeaderBg(component.preview, component.settledError, theme));
     component.clear();
-    component.addChild(new Text(formatEditCall(args, theme), 0, 0));
+    component.addChild(new Text(formatEditCall(args, theme, cwd), 0, 0));
     if (!component.preview) {
         return component;
     }
@@ -245,7 +242,7 @@ export function createEditToolDefinition(cwd, options) {
                     }
                 });
             }
-            return buildEditCallComponent(component, args, theme);
+            return buildEditCallComponent(component, args, theme, context.cwd);
         },
         renderResult(result, _options, theme, context) {
             const callComponent = context.state.callComponent;
@@ -266,7 +263,7 @@ export function createEditToolDefinition(cwd, options) {
                     changed = true;
                 }
                 if (changed) {
-                    buildEditCallComponent(callComponent, context.args, theme);
+                    buildEditCallComponent(callComponent, context.args, theme, context.cwd);
                 }
             }
             const output = formatEditResult(context.args, callComponent?.preview, typedResult, theme, context.isError);

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

@@ -4,7 +4,7 @@ import nodePath from "path";
 import { Type } from "typebox";
 import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
 import { pathExists, resolveToCwd } from "./path-utils.js";
-import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";
+import { getTextOutput, renderToolPath, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, formatSize, truncateHead } from "./truncate.js";
 const lsSchema = Type.Object({
@@ -17,12 +17,10 @@ const defaultLsOperations = {
     stat: fsStat,
     readdir: fsReaddir,
 };
-function formatLsCall(args, theme) {
-    const rawPath = str(args?.path);
-    const path = rawPath !== null ? shortenPath(rawPath || ".") : null;
+function formatLsCall(args, theme, cwd) {
     const limit = args?.limit;
-    const invalidArg = invalidArgText(theme);
-    let text = `${theme.fg("toolTitle", theme.bold("ls"))} ${path === null ? invalidArg : theme.fg("accent", path)}`;
+    const pathDisplay = renderToolPath(str(args?.path), theme, cwd, { emptyFallback: "." });
+    let text = `${theme.fg("toolTitle", theme.bold("ls"))} ${pathDisplay}`;
     if (limit !== undefined) {
         text += theme.fg("toolOutput", ` (limit ${limit})`);
     }
@@ -153,7 +151,7 @@ export function createLsToolDefinition(cwd, options) {
         },
         renderCall(args, theme, context) {
             const text = context.lastComponent ?? new Text("", 0, 0);
-            text.setText(formatLsCall(args, theme));
+            text.setText(formatLsCall(args, theme, context.cwd));
             return text;
         },
         renderResult(result, options, theme, context) {

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

@@ -10,7 +10,7 @@ import { formatDimensionNote, resizeImage } from "../../utils/image-resize.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { formatPathRelativeToCwdOrAbsolute } from "../../utils/paths.js";
 import { resolveReadPathAsync, resolveToCwd } from "./path-utils.js";
-import { getTextOutput, invalidArgText, replaceTabs, shortenPath, str } from "./render-utils.js";
+import { getTextOutput, renderToolPath, replaceTabs, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead } from "./truncate.js";
 const readSchema = Type.Object({
@@ -31,11 +31,8 @@ function formatReadLineRange(args, theme) {
     const endLine = args.limit !== undefined ? startLine + args.limit - 1 : "";
     return theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
 }
-function formatReadCall(args, theme) {
-    const rawPath = str(args?.file_path ?? args?.path);
-    const path = rawPath !== null ? shortenPath(rawPath) : null;
-    const invalidArg = invalidArgText(theme);
-    const pathDisplay = path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
+function formatReadCall(args, theme, cwd) {
+    const pathDisplay = renderToolPath(str(args?.file_path ?? args?.path), theme, cwd);
     return `${theme.fg("toolTitle", theme.bold("read"))} ${pathDisplay}${formatReadLineRange(args, theme)}`;
 }
 function trimTrailingEmptyLines(lines) {
@@ -274,7 +271,9 @@ export function createReadToolDefinition(cwd, options) {
         renderCall(args, theme, context) {
             const text = context.lastComponent ?? new Text("", 0, 0);
             const classification = !context.expanded ? getCompactReadClassification(args, context.cwd) : undefined;
-            text.setText(classification ? formatCompactReadCall(classification, args, theme) : formatReadCall(args, theme));
+            text.setText(classification
+                ? formatCompactReadCall(classification, args, theme)
+                : formatReadCall(args, theme, context.cwd));
             return text;
         },
         renderResult(result, options, theme, context) {

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

@@ -1,6 +1,8 @@
 import * as os from "node:os";
-import { getCapabilities, getImageDimensions, imageFallback } from "@earendil-works/pi-tui";
+import { pathToFileURL } from "node:url";
+import { getCapabilities, getImageDimensions, hyperlink, imageFallback } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../../utils/ansi.js";
+import { resolvePath } from "../../utils/paths.js";
 import { sanitizeBinaryOutput } from "../../utils/shell.js";
 export function shortenPath(path) {
     if (typeof path !== "string")
@@ -11,6 +13,12 @@ export function shortenPath(path) {
     }
     return path;
 }
+export function linkPath(styledText, rawPath, cwd) {
+    if (!getCapabilities().hyperlinks)
+        return styledText;
+    const absolutePath = resolvePath(rawPath, cwd);
+    return hyperlink(styledText, pathToFileURL(absolutePath).href);
+}
 export function str(value) {
     if (typeof value === "string")
         return value;
@@ -46,4 +54,12 @@ export function getTextOutput(result, showImages) {
 export function invalidArgText(theme) {
     return theme.fg("error", "[invalid arg]");
 }
+export function renderToolPath(rawPath, theme, cwd, options) {
+    if (rawPath === null)
+        return invalidArgText(theme);
+    const value = rawPath || options?.emptyFallback;
+    if (!value)
+        return theme.fg("toolOutput", "...");
+    return linkPath(theme.fg("accent", shortenPath(value)), value, cwd);
+}
 //# sourceMappingURL=render-utils.js.map