pi-ui-extend 0.1.18 → 0.1.19

package/dist/app/rendering/tab-line-renderer.js

@@ -50,7 +50,7 @@ export class TabLineRenderer {
                 segments.push({
                     start: separatorOffset + 1,
                     end: separatorOffset + 2,
-                    foreground: this.host.theme.colors.inputBorder,
+                    foreground: this.host.theme.colors.tabBorder,
                 });
                 displayColumn += separatorWidth;
             }
@@ -89,7 +89,7 @@ export class TabLineRenderer {
         segments.push({
             start: newTabDividerOffset,
             end: newTabDividerOffset + 1,
-            foreground: this.host.theme.colors.inputBorder,
+            foreground: this.host.theme.colors.tabBorder,
         });
         segments.push({
             start: lineText.length - APP_ICONS.plus.length,
@@ -119,7 +119,7 @@ export class TabLineRenderer {
     }
     renderBottom(row, layout, width) {
         return this.host.screenStyler.styleLine(row, this.bottomText(layout, width), width, {
-            foreground: this.host.theme.colors.inputBorder,
+            foreground: this.host.theme.colors.tabBorder,
         });
     }
     bottomText(layout, width) {

package/dist/app/runtime.js

@@ -133,6 +133,32 @@ function isBundledQuestionConflict(error, bundledExtensionPaths) {
     }
     return false;
 }
+const bundledSkillsInstallPromises = new Map();
+const piToolsSuiteInstallPromises = new Map();
+async function ensureBundledSkillsInstalledOnce(options = {}) {
+    const targetPath = resolve(options.targetPath ?? bundledSkillsInstallPath(options.homeDir));
+    const existing = bundledSkillsInstallPromises.get(targetPath);
+    if (existing)
+        return await existing;
+    const pending = ensureBundledSkillsInstalled(options).catch((error) => {
+        bundledSkillsInstallPromises.delete(targetPath);
+        throw error;
+    });
+    bundledSkillsInstallPromises.set(targetPath, pending);
+    return await pending;
+}
+async function ensurePiToolsSuiteExtensionInstalledOnce(options = {}) {
+    const targetPath = resolve(options.targetPath ?? piToolsSuiteExtensionInstallPath(options.agentDir));
+    const existing = piToolsSuiteInstallPromises.get(targetPath);
+    if (existing)
+        return await existing;
+    const pending = ensurePiToolsSuiteExtensionInstalled(options).catch((error) => {
+        piToolsSuiteInstallPromises.delete(targetPath);
+        throw error;
+    });
+    piToolsSuiteInstallPromises.set(targetPath, pending);
+    return await pending;
+}
 export function resolvePixRuntimeModelRef(options, sessionManager, config = loadPixConfig()) {
     if (options.modelRef)
         return options.modelRef;
@@ -176,8 +202,8 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
         const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
         const parsedModel = effectiveModelRef ? parseModelRef(effectiveModelRef) : undefined;
         const initialThinkingLevel = resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config);
-        await ensureBundledSkillsInstalled();
-        await ensurePiToolsSuiteExtensionInstalled({ agentDir });
+        await ensureBundledSkillsInstalledOnce();
+        await ensurePiToolsSuiteExtensionInstalledOnce({ agentDir });
         const bundledExtensionPaths = getBundledExtensionPaths();
         const services = await createAgentSessionServices({
             cwd,
@@ -232,7 +258,7 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
         sessionManager: options.noSession
             ? SessionManager.inMemory(options.cwd)
             : options.sessionPath
-                ? openLazySessionManager(options.sessionPath, { cwdOverride: options.cwd })
+                ? await openLazySessionManager(options.sessionPath, { cwdOverride: options.cwd })
                 : SessionManager.create(options.cwd),
     });
 }

package/dist/app/screen/file-link-opener.d.ts

@@ -3,6 +3,8 @@ import { spawn } from "node:child_process";
 import type { RenderedLink } from "./file-links.js";
 type FileLinkOpenerDeps = {
     existsSync: typeof existsSync;
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
     spawn: typeof spawn;
 };
 export declare function setFileLinkOpenerTestDeps(overrides: Partial<FileLinkOpenerDeps>): () => void;

package/dist/app/screen/file-link-opener.js

@@ -1,8 +1,8 @@
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
-import { delimiter, join } from "node:path";
+import { isAbsolute, posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
-let deps = { existsSync, spawn };
+let deps = { existsSync, env: process.env, platform: process.platform, spawn };
 export function setFileLinkOpenerTestDeps(overrides) {
     const previous = deps;
     deps = { ...deps, ...overrides };
@@ -14,13 +14,10 @@ export function openFileLink(link) {
     const filePath = link.filePath ?? filePathFromUrl(link.url);
     if (!filePath)
         return false;
-    const target = zedTarget(filePath, link.line, link.column);
-    const candidates = zedCommandCandidates();
-    if (trySpawnCandidates(candidates, [target]))
+    const editorLaunch = preferredEditorLaunch(filePath, link.line, link.column);
+    if (editorLaunch && trySpawnCandidates(editorLaunch.candidates, editorLaunch.args))
         return true;
-    if (process.platform === "darwin")
-        return spawnDetached("open", ["-a", "Zed", filePath]);
-    return false;
+    return openPathWithSystemViewer(filePath);
 }
 function filePathFromUrl(url) {
     if (!url.startsWith("file://"))
@@ -37,29 +34,99 @@ function zedTarget(filePath, line, column) {
         return filePath;
     return column === undefined ? `${filePath}:${line}` : `${filePath}:${line}:${column}`;
 }
+function gotoTarget(filePath, line, column) {
+    if (line === undefined)
+        return filePath;
+    return column === undefined ? `${filePath}:${line}` : `${filePath}:${line}:${column}`;
+}
+function preferredEditorLaunch(filePath, line, column) {
+    switch (detectEditor(deps.env)) {
+        case "cursor":
+            return { args: ["--goto", gotoTarget(filePath, line, column)], candidates: commandCandidates(deps.env.CURSOR_CLI, "cursor") };
+        case "jetbrains":
+            return {
+                args: jetbrainsTargetArgs(filePath, line),
+                candidates: commandCandidates(deps.env.JETBRAINS_IDE_CLI, "idea", "idea64", "webstorm", "webstorm64", "pycharm", "pycharm64", "goland", "goland64", "clion", "clion64", "phpstorm", "phpstorm64", "rubymine", "rubymine64", "rider", "rider64"),
+            };
+        case "vscode":
+            return { args: ["--goto", gotoTarget(filePath, line, column)], candidates: commandCandidates(deps.env.VSCODE_CLI, "code", "code-insiders") };
+        case "windsurf":
+            return { args: ["--goto", gotoTarget(filePath, line, column)], candidates: commandCandidates(deps.env.WINDSURF_CLI, "windsurf") };
+        case "zed":
+            return { args: [zedTarget(filePath, line, column)], candidates: zedCommandCandidates() };
+        default:
+            return undefined;
+    }
+}
+function detectEditor(env) {
+    const termProgram = env.TERM_PROGRAM?.trim().toLowerCase();
+    const terminalEmulator = env.TERMINAL_EMULATOR?.trim().toLowerCase();
+    const terminalProvider = env.TERMINAL_PROVIDER?.trim().toLowerCase();
+    if (termProgram === "cursor" || env.CURSOR_TRACE_ID || env.CURSOR_TRACE)
+        return "cursor";
+    if (termProgram === "windsurf")
+        return "windsurf";
+    if (termProgram === "zed" || env.ZED_CLI)
+        return "zed";
+    if (termProgram === "vscode" || env.VSCODE_IPC_HOOK_CLI || env.VSCODE_GIT_IPC_HANDLE)
+        return "vscode";
+    if (terminalEmulator?.includes("jetbrains") || terminalProvider === "jetbrains")
+        return "jetbrains";
+    return undefined;
+}
 function zedCommandCandidates() {
-    const candidates = [process.env.ZED_CLI, "zed", "zeditor"];
-    if (process.platform === "darwin")
+    const candidates = [deps.env.ZED_CLI, "zed", "zeditor"];
+    if (deps.platform === "darwin")
         candidates.push("/opt/homebrew/bin/zed", "/usr/local/bin/zed");
     return candidates.filter((candidate) => Boolean(candidate));
 }
+function commandCandidates(primary, ...rest) {
+    return [primary, ...rest].filter((candidate) => Boolean(candidate));
+}
+function jetbrainsTargetArgs(filePath, line) {
+    if (line === undefined)
+        return [filePath];
+    return ["--line", `${line}`, filePath];
+}
 function trySpawnCandidates(candidates, args) {
     for (const command of candidates) {
-        if (command.includes("/") && !deps.existsSync(command))
-            continue;
-        if (!command.includes("/") && !commandOnPath(command))
+        if (!canRunCommand(command))
             continue;
         if (spawnDetached(command, args))
             return true;
     }
     return false;
 }
+function canRunCommand(command) {
+    if (hasPathSeparator(command) || isAbsolute(command))
+        return deps.existsSync(command);
+    return commandOnPath(command);
+}
+function hasPathSeparator(command) {
+    return command.includes("/") || command.includes("\\");
+}
 function commandOnPath(command) {
-    const pathEntries = process.env.PATH?.split(delimiter) ?? [];
-    const extensions = process.platform === "win32"
-        ? (process.env.PATHEXT?.split(";") ?? [".EXE", ".CMD", ".BAT", ".COM"])
+    const pathEntries = deps.env.PATH?.split(pathDelimiter()) ?? [];
+    const extensions = deps.platform === "win32"
+        ? (deps.env.PATHEXT?.split(";") ?? [".EXE", ".CMD", ".BAT", ".COM"])
         : [""];
-    return pathEntries.some((entry) => extensions.some((extension) => deps.existsSync(join(entry, `${command}${extension}`))));
+    return pathEntries.some((entry) => pathCommandCandidates(entry, command, extensions).some((candidate) => deps.existsSync(candidate)));
+}
+function pathDelimiter() {
+    return deps.platform === "win32" ? ";" : ":";
+}
+function pathCommandCandidates(entry, command, extensions) {
+    const pathApi = deps.platform === "win32" ? win32 : posix;
+    if (deps.platform !== "win32" || pathApi.extname(command))
+        return [pathApi.join(entry, command)];
+    return [pathApi.join(entry, command), ...extensions.map((extension) => pathApi.join(entry, `${command}${extension}`))];
+}
+function openPathWithSystemViewer(filePath) {
+    if (deps.platform === "darwin")
+        return spawnDetached("open", [filePath]);
+    if (deps.platform === "win32")
+        return spawnDetached("cmd", ["/c", "start", "", filePath]);
+    return spawnDetached("xdg-open", [filePath]);
 }
 function spawnDetached(command, args) {
     try {

package/dist/app/screen/mouse-controller.d.ts

@@ -21,8 +21,6 @@ export type InputFrameCopyRows = {
     inputEndRow: number;
     inputSeparatorRow: number;
     inputBottomSeparatorRow: number;
-    contentStartColumn: number;
-    contentEndColumn: number;
 };
 export type AppMouseControllerHost = {
     terminalColumns(): number;

package/dist/app/screen/mouse-controller.js

@@ -320,7 +320,7 @@ export class AppMouseController {
             return false;
         const opened = this.host.openFileLink?.(link) ?? openDetectedFileLink(link);
         if (!opened)
-            this.host.showToast("Could not open file link. Install the Zed CLI or set ZED_CLI.", "warning");
+            this.host.showToast("Could not open file link in the detected editor or system viewer.", "warning");
         return true;
     }
     handleInputScrollBar(event) {
@@ -789,8 +789,6 @@ export class AppMouseController {
             inputEndRow: toScreenRowExclusive(layout.inputStartRow + layout.renderedInput.lines.length),
             inputSeparatorRow: toScreenRow(layout.inputSeparatorRow),
             inputBottomSeparatorRow: toScreenRow(layout.inputBottomSeparatorRow),
-            contentStartColumn: 2,
-            contentEndColumn: columns,
         };
     }
     getSelectedConversationText(anchor, current) {
@@ -800,11 +798,13 @@ export class AppMouseController {
         const renderedLines = this.host.conversationViewport().slice(width, range.start.line, count);
         const lines = [];
         for (let index = 0; index < count; index += 1) {
-            const text = renderedLines[index]?.text ?? "";
+            const rendered = renderedLines[index];
+            const text = rendered?.text ?? "";
             const line = range.start.line + index;
             const startColumn = line === range.start.line ? range.start.x : 1;
             const endColumn = line === range.end.line ? range.end.x : text.length + 1;
-            lines.push(sliceByDisplayColumns(text, startColumn, endColumn).trimEnd());
+            const lineText = sliceByDisplayColumns(text, startColumn, endColumn);
+            lines.push(lineText.trimEnd());
         }
         return lines.join("\n").replace(/\s+$/u, "");
     }
@@ -938,13 +938,7 @@ export function screenSelectionLineText(row, text, startColumn, endColumn, input
     if (inputFrame && (row === inputFrame.inputSeparatorRow || row === inputFrame.inputBottomSeparatorRow)) {
         return undefined;
     }
-    let copyStartColumn = startColumn;
-    let copyEndColumn = endColumn;
-    if (inputFrame && row >= inputFrame.inputStartRow && row < inputFrame.inputEndRow) {
-        copyStartColumn = Math.max(copyStartColumn, inputFrame.contentStartColumn);
-        copyEndColumn = Math.min(copyEndColumn, inputFrame.contentEndColumn);
-    }
-    return sliceByDisplayColumns(text, copyStartColumn, copyEndColumn);
+    return sliceByDisplayColumns(text, startColumn, endColumn);
 }
 function sameConversationPoint(left, right) {
     return !!left && left.line === right.line && left.x === right.x;

package/dist/app/screen/screen-styler.js

@@ -75,7 +75,7 @@ export class ScreenStyler {
     }
     styleInputLine(row, text, tagSpans, suggestionSpans, width, tagColor, suggestionColor, frameColor) {
         const colors = this.host.theme.colors;
-        const baseOptions = { foreground: colors.inputForeground };
+        const baseOptions = { foreground: colors.warning };
         if (this.selectionRangeForRow(row, width, text))
             return this.styleLine(row, text, width, baseOptions);
         const plain = padOrTrimPlain(text, width);

package/dist/app/session/lazy-session-manager.d.ts

@@ -8,4 +8,4 @@ export type LazySessionHistoryReader = {
     hasOlder(): boolean;
     readOlder(limit: number): Promise<SessionEntry[]>;
 };
-export declare function openLazySessionManager(sessionPath: string, options?: LazySessionManagerOptions): SessionManager;
+export declare function openLazySessionManager(sessionPath: string, options?: LazySessionManagerOptions): Promise<SessionManager>;

package/dist/app/session/lazy-session-manager.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "node:fs";
-import { open as openFile } from "node:fs/promises";
+import { appendFileSync, createReadStream, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdir, open as openFile, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { buildSessionContext, SessionManager, } from "@earendil-works/pi-coding-agent";
@@ -9,8 +9,8 @@ const CURRENT_SESSION_VERSION = 3;
 const DEFAULT_TAIL_ENTRY_COUNT = 180;
 const INITIAL_TAIL_BYTES = 256 * 1024;
 const MAX_TAIL_BYTES = 16 * 1024 * 1024;
-export function openLazySessionManager(sessionPath, options = {}) {
-    return new LazySessionManager(sessionPath, options);
+export async function openLazySessionManager(sessionPath, options = {}) {
+    return await LazySessionManager.open(sessionPath, options);
 }
 class LazySessionManager {
     sessionFilePath;
@@ -29,9 +29,18 @@ class LazySessionManager {
         this.sessionFilePath = resolve(sessionPath);
         this.sessionDirPath = resolve(options.sessionDir ?? dirname(this.sessionFilePath));
         this.tailEntryCount = Math.max(1, Math.floor(options.tailEntryCount ?? DEFAULT_TAIL_ENTRY_COUNT));
-        this.header = this.loadHeader(options.cwdOverride);
-        this.cwdPath = resolve(options.cwdOverride ?? this.header.cwd ?? process.cwd());
-        this.loadTailEntries();
+        this.cwdPath = resolve(options.cwdOverride ?? process.cwd());
+        this.header = createSessionHeader(this.cwdPath);
+    }
+    static async open(sessionPath, options = {}) {
+        const manager = new LazySessionManager(sessionPath, options);
+        await manager.initialize(options.cwdOverride);
+        return manager;
+    }
+    async initialize(cwdOverride) {
+        this.header = await this.loadHeaderAsync(cwdOverride);
+        this.cwdPath = resolve(cwdOverride ?? this.header.cwd ?? process.cwd());
+        await this.loadTailEntriesAsync();
     }
     setSessionFile(sessionFile) {
         if (this.hydrated) {
@@ -40,9 +49,7 @@ class LazySessionManager {
         }
         this.sessionFilePath = resolve(sessionFile);
         this.sessionDirPath = dirname(this.sessionFilePath);
-        this.header = this.loadHeader(this.cwdPath);
-        this.cwdPath = resolve(this.header.cwd || this.cwdPath);
-        this.loadTailEntries();
+        throw new Error("LazySessionManager.setSessionFile() before hydration is unsupported");
     }
     newSession(options) {
         if (this.hydrated)
@@ -106,16 +113,25 @@ class LazySessionManager {
         if (this.hydrated || this.tailStartOffset <= 0)
             return undefined;
         let cursorOffset = this.tailStartOffset;
-        const firstEntryOffset = readFirstSessionEntryOffset(this.sessionFilePath);
+        let firstEntryOffset = 0;
+        let firstEntryOffsetPromise;
+        const loadFirstEntryOffset = async () => {
+            firstEntryOffsetPromise ??= readFirstSessionEntryOffset(this.sessionFilePath).then((offset) => {
+                firstEntryOffset = offset;
+                return offset;
+            });
+            return await firstEntryOffsetPromise;
+        };
         return {
             hasOlder: () => cursorOffset > firstEntryOffset,
             readOlder: async (limit) => {
-                if (cursorOffset <= firstEntryOffset)
+                const resolvedFirstEntryOffset = await loadFirstEntryOffset();
+                if (cursorOffset <= resolvedFirstEntryOffset)
                     return [];
                 const result = await readSessionEntriesBeforeOffset(this.sessionFilePath, cursorOffset, Math.max(1, Math.floor(limit)));
                 cursorOffset = result.startOffset;
                 if (result.entries.length === 0)
-                    cursorOffset = firstEntryOffset;
+                    cursorOffset = resolvedFirstEntryOffset;
                 return result.entries;
             },
         };
@@ -256,18 +272,17 @@ class LazySessionManager {
         }
         return this.hydrated;
     }
-    loadHeader(cwdOverride) {
-        if (!existsSync(this.sessionFilePath)) {
-            mkdirSync(dirname(this.sessionFilePath), { recursive: true });
-            const header = createSessionHeader(resolve(cwdOverride ?? process.cwd()));
-            writeFileSync(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
-            return header;
-        }
-        const header = readSessionHeaderFast(this.sessionFilePath);
-        return header ?? createSessionHeader(resolve(cwdOverride ?? process.cwd()));
-    }
-    loadTailEntries() {
-        const result = readTailSessionEntries(this.sessionFilePath, this.tailEntryCount);
+    async loadHeaderAsync(cwdOverride) {
+        const existingHeader = await readSessionHeaderFast(this.sessionFilePath);
+        if (existingHeader)
+            return existingHeader;
+        await mkdir(dirname(this.sessionFilePath), { recursive: true });
+        const header = createSessionHeader(resolve(cwdOverride ?? process.cwd()));
+        await writeFile(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
+        return header;
+    }
+    async loadTailEntriesAsync() {
+        const result = await readTailSessionEntries(this.sessionFilePath, this.tailEntryCount);
         this.entries = result.entries;
         this.tailStartOffset = result.startOffset;
         this.rebuildIndexes();
@@ -338,8 +353,8 @@ function createSessionHeader(cwd) {
 function createSessionId() {
     return randomUUID();
 }
-function readSessionHeaderFast(filePath) {
-    const line = readFirstLine(filePath, 64 * 1024);
+async function readSessionHeaderFast(filePath) {
+    const line = await readFirstLine(filePath, 64 * 1024);
     if (!line)
         return undefined;
     try {
@@ -353,12 +368,12 @@ function readSessionHeaderFast(filePath) {
         return undefined;
     }
 }
-function readFirstLine(filePath, maxBytes) {
-    let fd;
+async function readFirstLine(filePath, maxBytes) {
+    let file;
     try {
-        fd = openSync(filePath, "r");
+        file = await openFile(filePath, "r");
         const buffer = Buffer.alloc(maxBytes);
-        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
         const text = buffer.toString("utf8", 0, bytesRead);
         return text.split("\n")[0];
     }
@@ -366,16 +381,15 @@ function readFirstLine(filePath, maxBytes) {
         return undefined;
     }
     finally {
-        if (fd !== undefined)
-            closeSync(fd);
+        await file?.close();
     }
 }
-function readFirstSessionEntryOffset(filePath) {
-    let fd;
+async function readFirstSessionEntryOffset(filePath) {
+    let file;
     try {
-        fd = openSync(filePath, "r");
+        file = await openFile(filePath, "r");
         const buffer = Buffer.alloc(64 * 1024);
-        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
         const entries = parseSessionEntryBufferLines(buffer.subarray(0, bytesRead), 0);
         return entries[0]?.offset ?? 0;
     }
@@ -383,34 +397,30 @@ function readFirstSessionEntryOffset(filePath) {
         return 0;
     }
     finally {
-        if (fd !== undefined)
-            closeSync(fd);
+        await file?.close();
     }
 }
-function readTailSessionEntries(filePath, limit) {
-    if (!existsSync(filePath))
-        return { entries: [], startOffset: 0 };
-    const size = statSync(filePath).size;
+async function readTailSessionEntries(filePath, limit) {
+    const size = await stat(filePath).then((result) => result.size).catch(() => 0);
     if (size <= 0)
         return { entries: [], startOffset: 0 };
     let byteCount = Math.min(size, INITIAL_TAIL_BYTES);
     const maxBytes = Math.min(size, MAX_TAIL_BYTES);
     while (byteCount <= maxBytes) {
-        const result = readTailSessionEntriesWithByteCount(filePath, byteCount, limit);
+        const result = await readTailSessionEntriesWithByteCount(filePath, byteCount, limit, size);
         if (result.entries.length >= limit || byteCount >= maxBytes || byteCount >= size)
             return result;
         byteCount = Math.min(size, Math.max(byteCount + 1, byteCount * 2));
     }
     return { entries: [], startOffset: 0 };
 }
-function readTailSessionEntriesWithByteCount(filePath, byteCount, limit) {
-    let fd;
+async function readTailSessionEntriesWithByteCount(filePath, byteCount, limit, size) {
+    let file;
     try {
-        const size = statSync(filePath).size;
         const start = Math.max(0, size - byteCount);
         const buffer = Buffer.alloc(size - start);
-        fd = openSync(filePath, "r");
-        readSync(fd, buffer, 0, buffer.length, start);
+        file = await openFile(filePath, "r");
+        await file.read(buffer, 0, buffer.length, start);
         let parseStart = 0;
         if (start > 0) {
             const firstNewline = buffer.indexOf(10);
@@ -422,12 +432,14 @@ function readTailSessionEntriesWithByteCount(filePath, byteCount, limit) {
         return { entries: [], startOffset: 0 };
     }
     finally {
-        if (fd !== undefined)
-            closeSync(fd);
+        await file?.close();
     }
 }
 async function readSessionEntriesBeforeOffset(filePath, endOffset, limit) {
-    if (!existsSync(filePath) || endOffset <= 0)
+    if (endOffset <= 0)
+        return { entries: [], startOffset: 0 };
+    const exists = await stat(filePath).then(() => true).catch(() => false);
+    if (!exists)
         return { entries: [], startOffset: 0 };
     let byteCount = Math.min(endOffset, INITIAL_TAIL_BYTES);
     const maxBytes = Math.min(endOffset, MAX_TAIL_BYTES);

package/dist/app/session/queued-message-controller.d.ts

@@ -51,6 +51,12 @@ export declare class AppQueuedMessageController {
     findQueuedEntry(entryId: string): Extract<Entry, {
         kind: "queued";
     }> | undefined;
+    queuedEntries(): Extract<Entry, {
+        kind: "queued";
+    }>[];
+    deferredQueuedEntries(): Extract<Entry, {
+        kind: "queued";
+    }>[];
     private shouldDeferUserMessage;
     deferUserMessage(message: SubmittedUserMessage): void;
     private rewriteSdkQueuedMessages;

package/dist/app/session/queued-message-controller.js

@@ -1,5 +1,6 @@
 import { createId } from "../id.js";
 import { stringifyUnknown, submittedUserDisplayText } from "../rendering/message-content.js";
+import { deferredQueuedMessageEntries, queuedMessageEntries } from "./queued-message-entries.js";
 export class AppQueuedMessageController {
     host;
     deferredUserMessages = [];
@@ -228,9 +229,16 @@ export class AppQueuedMessageController {
         }
     }
     findQueuedEntry(entryId) {
-        const entry = this.host.visibleEntries().find((candidate) => candidate.id === entryId);
+        const entry = this.queuedEntries().find((candidate) => candidate.id === entryId)
+            ?? this.host.visibleEntries().find((candidate) => candidate.id === entryId);
         return entry?.kind === "queued" ? entry : undefined;
     }
+    queuedEntries() {
+        return queuedMessageEntries(this.host.runtime()?.session, this.deferredUserMessages);
+    }
+    deferredQueuedEntries() {
+        return deferredQueuedMessageEntries(this.deferredUserMessages);
+    }
     shouldDeferUserMessage(session) {
         return session.isCompacting || this.promptSubmissionInFlight;
     }

package/dist/app/session/queued-message-entries.d.ts

@@ -0,0 +1,8 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { Entry, SubmittedUserMessage } from "../types.js";
+export type QueuedEntry = Extract<Entry, {
+    kind: "queued";
+}>;
+export declare function sdkQueuedMessageEntries(session: AgentSession | undefined): QueuedEntry[];
+export declare function deferredQueuedMessageEntries(messages: readonly SubmittedUserMessage[]): QueuedEntry[];
+export declare function queuedMessageEntries(session: AgentSession | undefined, deferredUserMessages: readonly SubmittedUserMessage[]): QueuedEntry[];

package/dist/app/session/queued-message-entries.js

@@ -0,0 +1,41 @@
+import { shortHash } from "../rendering/render-text.js";
+export function sdkQueuedMessageEntries(session) {
+    const entries = [];
+    for (const [index, text] of (session?.getSteeringMessages() ?? []).entries()) {
+        entries.push({
+            id: `queued-sdk-steering-${index}-${shortHash(text)}`,
+            kind: "queued",
+            mode: "steering",
+            text,
+            queueSource: "sdk-steering",
+            queueIndex: index,
+        });
+    }
+    for (const [index, text] of (session?.getFollowUpMessages() ?? []).entries()) {
+        entries.push({
+            id: `queued-sdk-follow-up-${index}-${shortHash(text)}`,
+            kind: "queued",
+            mode: "follow-up",
+            text,
+            queueSource: "sdk-follow-up",
+            queueIndex: index,
+        });
+    }
+    return entries;
+}
+export function deferredQueuedMessageEntries(messages) {
+    return messages.map((message, index) => ({
+        id: `${message.id}-${index}`,
+        kind: "queued",
+        mode: "steering",
+        text: message.displayText,
+        queueSource: "deferred",
+        queueIndex: index,
+    }));
+}
+export function queuedMessageEntries(session, deferredUserMessages) {
+    return [
+        ...sdkQueuedMessageEntries(session),
+        ...deferredQueuedMessageEntries(deferredUserMessages),
+    ];
+}

package/dist/app/session/session-lifecycle-controller.d.ts

@@ -48,17 +48,25 @@ export type AppSessionLifecycleHost = {
     restoreTabsAfterStartup(): Promise<void>;
     render(): void;
 };
+export type BindCurrentSessionOptions = {
+    awaitExtensions?: boolean;
+};
 export declare class AppSessionLifecycleController {
     private readonly host;
     private unsubscribe;
+    private extensionBindPromise;
+    private extensionBindRuntime;
+    private extensionBindSession;
     constructor(host: AppSessionLifecycleHost);
     start(): Promise<void>;
-    bindCurrentSession(): Promise<void>;
+    bindCurrentSession(options?: BindCurrentSessionOptions): Promise<void>;
     unsubscribeSession(): void;
     afterSessionReplacement(message?: string): void;
     private loadReplacementHistory;
     resetSessionView(): void;
     loadSessionHistory(): void;
     requireRuntime(): AgentSessionRuntime;
+    private bindSessionExtensions;
+    private isCurrentRuntimeSession;
     private extensionUiScope;
 }