pi-ui-extend 0.1.21 → 0.1.25

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

@@ -79,7 +79,7 @@ export declare class AppTabsController {
     private runtimeForCommand;
     private idleRuntime;
     private activeTab;
-    private settleStartupTabPlaceholders;
+    private clearStartupTabPlaceholders;
     private storeActiveRuntime;
     private setRuntimeForTab;
     private deleteRuntimeForTab;
@@ -109,6 +109,7 @@ export declare class AppTabsController {
     private sessionPath;
     private sessionTitle;
     private sessionTitleFromParts;
+    private updatedSessionTitle;
     private sessionActivity;
     private tabActivity;
     private clearTabAttention;
@@ -116,6 +117,9 @@ export declare class AppTabsController {
     private stopAttentionBlinkIfIdle;
     private restoredTabs;
     private defaultSessionTitleFromPath;
+    private loadSessionTitles;
+    private scheduleRestoredTabTitleRefresh;
+    private refreshRestoredTabTitles;
     private loadTabs;
     private parsePersistedInputState;
     private parsePersistedSubmittedUserMessages;

package/dist/app/session/tabs-controller.js

@@ -1,17 +1,18 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir, open as openFile, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { getAgentDir, } from "@earendil-works/pi-coding-agent";
 import { isRecord } from "../guards.js";
 import { createId } from "../id.js";
-import { createStartupInfoMessage, isEmptyStartupSession } from "../cli/startup-info.js";
 import { tabPanelRows } from "../rendering/tab-line-renderer.js";
 const TAB_STATE_VERSION = 3;
 const MAX_RESTORED_TABS = 8;
 const BACKGROUND_PREWARM_TAB_LIMIT = 2;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
 const LOADING_TAB_TITLE_PATTERN = /^loading(?:…|\.\.\.)?$/iu;
+const DEFAULT_SESSION_TITLE_PATTERN = /^session [0-9a-f]{8}$/iu;
+const SESSION_TITLE_SCAN_MAX_BYTES = 2 * 1024 * 1024;
 export class AppTabsController {
     host;
     tabItems = [];
@@ -140,7 +141,7 @@ export class AppTabsController {
             return;
         }
         if (!active) {
-            const tab = this.tabFromSession(session, { titlePlaceholder: this.restored ? "new" : "loading" });
+            const tab = this.tabFromSession(session, { titlePlaceholder: "loading" });
             this.tabItems.push(tab);
             this.activeTabId = tab.id;
             this.clearTabAttention(tab);
@@ -164,18 +165,18 @@ export class AppTabsController {
             return;
         this.syncActiveTabFromRuntime({ save: false });
         if (this.host.options.noSession) {
-            this.settleStartupTabPlaceholders();
+            this.clearStartupTabPlaceholders();
             return;
         }
         const saved = await this.loadTabs();
         if (!saved || saved.tabs.length === 0) {
-            this.settleStartupTabPlaceholders();
+            this.clearStartupTabPlaceholders();
             await this.saveTabs();
             return;
         }
         const restoredTabs = this.restoredTabs(saved);
         if (restoredTabs.length === 0) {
-            this.settleStartupTabPlaceholders();
+            this.clearStartupTabPlaceholders();
             await this.saveTabs();
             this.scheduleProjectSessionRetention();
             return;
@@ -191,11 +192,13 @@ export class AppTabsController {
         this.replaceTabs(restoredTabs, desiredPath);
         this.restorePersistedInputStates(saved);
         this.restorePersistedDeferredUserMessages(saved);
+        const restoredSessionPaths = saved.tabs.map((tab) => tab.path);
         if (explicitSessionPath && currentPath)
             this.ensureCurrentSessionTab(runtime.session);
         if (!desiredPath) {
-            this.settleStartupTabPlaceholders();
+            this.clearStartupTabPlaceholders();
             await this.saveTabs();
+            this.scheduleRestoredTabTitleRefresh(restoredSessionPaths);
             this.scheduleProjectSessionRetention();
             this.scheduleTabPrewarm();
             return;
@@ -212,20 +215,22 @@ export class AppTabsController {
                 this.host.showToast("Could not restore the previous active tab", "warning");
                 this.replaceTabs([this.tabFromSession(runtime.session), ...restoredTabs], currentPath);
                 this.storeActiveRuntime(runtime);
-                this.settleStartupTabPlaceholders();
+                this.clearStartupTabPlaceholders();
                 await this.saveTabs();
+                this.scheduleRestoredTabTitleRefresh(restoredSessionPaths);
                 this.scheduleProjectSessionRetention();
                 return;
             }
         }
         this.syncActiveTabFromRuntime({ save: false });
-        this.settleStartupTabPlaceholders();
+        this.clearStartupTabPlaceholders();
         if (this.activeTabId)
             this.restoreInputState(this.activeTabId);
         await this.saveTabs();
         this.scheduleProjectSessionRetention();
         this.scheduleTabPrewarm();
         await this.loadActiveSessionHistory(restoredRuntime);
+        this.scheduleRestoredTabTitleRefresh(restoredSessionPaths);
     }
     async openNewTab() {
         if (this.pendingActiveTabId) {
@@ -307,12 +312,7 @@ export class AppTabsController {
         this.scheduleProjectSessionRetention();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(targetTab.id);
-        if (isEmptyStartupSession(newRuntime)) {
-            this.host.addEntry({ id: createId("system"), kind: "system", text: createStartupInfoMessage(newRuntime) });
-        }
-        else {
-            this.host.addEntry({ id: createId("system"), kind: "system", text: `Opened a new tab. cwd=${newRuntime.cwd}` });
-        }
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Opened a new tab. cwd=${newRuntime.cwd}` });
         if (newRuntime.modelFallbackMessage)
             this.host.addEntry({ id: createId("system"), kind: "system", text: newRuntime.modelFallbackMessage });
         for (const diag of newRuntime.diagnostics ?? []) {
@@ -796,10 +796,9 @@ export class AppTabsController {
     activeTab() {
         return this.activeTabId ? this.tabItems.find((tab) => tab.id === this.activeTabId) : undefined;
     }
-    settleStartupTabPlaceholders() {
+    clearStartupTabPlaceholders() {
         for (const tab of this.tabItems) {
-            if (tab.titlePlaceholder === "loading")
-                tab.titlePlaceholder = "new";
+            delete tab.titlePlaceholder;
         }
     }
     storeActiveRuntime(runtime = this.host.runtime()) {
@@ -1071,9 +1070,10 @@ export class AppTabsController {
         };
     }
     updateTabFromSession(tab, session) {
-        tab.title = this.sessionTitle(session);
-        tab.activity = this.sessionActivity(session);
+        const previousSessionPath = tab.sessionPath ? resolve(tab.sessionPath) : undefined;
         const sessionPath = this.sessionPath(session);
+        tab.title = this.updatedSessionTitle(tab.title, this.sessionTitle(session), previousSessionPath, sessionPath, tab.titlePlaceholder !== undefined);
+        tab.activity = this.sessionActivity(session);
         if (sessionPath)
             tab.sessionPath = sessionPath;
     }
@@ -1087,6 +1087,15 @@ export class AppTabsController {
         const name = sessionName?.trim();
         return name && !LOADING_TAB_TITLE_PATTERN.test(name) ? name : `session ${sessionId.slice(0, 8)}`;
     }
+    updatedSessionTitle(currentTitle, nextTitle, currentSessionPath, nextSessionPath, hasTitlePlaceholder) {
+        if (!isDefaultSessionTitle(nextTitle))
+            return nextTitle;
+        if (hasTitlePlaceholder)
+            return nextTitle;
+        if (currentSessionPath !== undefined && nextSessionPath !== undefined && currentSessionPath !== nextSessionPath)
+            return nextTitle;
+        return validSessionTitle(currentTitle) && !isDefaultSessionTitle(currentTitle) ? currentTitle : nextTitle;
+    }
     sessionActivity(session) {
         return session?.isStreaming || session?.isCompacting ? "running" : "idle";
     }
@@ -1117,7 +1126,7 @@ export class AppTabsController {
             initialVisible: true,
         });
     }
-    restoredTabs(saved) {
+    restoredTabs(saved, sessionTitles = new Map()) {
         const tabs = [];
         const seen = new Set();
         for (const tab of saved.tabs) {
@@ -1129,11 +1138,11 @@ export class AppTabsController {
             seen.add(sessionPath);
             const savedTitle = tab.title?.trim();
             const restoredLoadingTitle = savedTitle !== undefined && LOADING_TAB_TITLE_PATTERN.test(savedTitle);
-            const title = restoredLoadingTitle ? this.defaultSessionTitleFromPath(sessionPath) : savedTitle;
+            const sessionTitle = validSessionTitle(sessionTitles.get(sessionPath));
+            const title = sessionTitle || (restoredLoadingTitle ? this.defaultSessionTitleFromPath(sessionPath) : savedTitle);
             tabs.push({
                 id: createId("tab"),
                 title: title || "session",
-                ...(restoredLoadingTitle ? { titlePlaceholder: "new" } : {}),
                 status: "waiting",
                 sessionPath,
             });
@@ -1148,6 +1157,40 @@ export class AppTabsController {
             ?? createHash("sha256").update(sessionPath).digest("hex").slice(0, 8);
         return `session ${sessionId}`;
     }
+    async loadSessionTitles(sessionPaths) {
+        const uniquePaths = [...new Set(sessionPaths.map((sessionPath) => resolve(sessionPath)))].slice(0, MAX_RESTORED_TABS);
+        const entries = await Promise.all(uniquePaths.map(async (sessionPath) => {
+            const title = await readLatestSessionTitle(sessionPath);
+            return title ? [sessionPath, title] : undefined;
+        }));
+        return new Map(entries.filter((entry) => entry !== undefined));
+    }
+    scheduleRestoredTabTitleRefresh(sessionPaths) {
+        if (sessionPaths.length === 0)
+            return;
+        setTimeout(() => {
+            void this.refreshRestoredTabTitles(sessionPaths);
+        }, 0).unref?.();
+    }
+    async refreshRestoredTabTitles(sessionPaths) {
+        const titles = await this.loadSessionTitles(sessionPaths);
+        if (titles.size === 0)
+            return;
+        let changed = false;
+        for (const tab of this.tabItems) {
+            const sessionPath = tab.sessionPath ? resolve(tab.sessionPath) : undefined;
+            const title = sessionPath ? titles.get(sessionPath) : undefined;
+            if (!title || tab.title === title)
+                continue;
+            tab.title = title;
+            delete tab.titlePlaceholder;
+            changed = true;
+        }
+        if (!changed)
+            return;
+        void this.saveTabs();
+        this.host.render();
+    }
     async loadTabs() {
         try {
             const raw = await readFile(this.filePath(), "utf8");
@@ -1408,6 +1451,51 @@ function parsePersistedImage(value) {
         ? { type: "image", data: value.data, mimeType: value.mimeType }
         : undefined;
 }
+async function readLatestSessionTitle(sessionPath) {
+    let file;
+    try {
+        file = await openFile(sessionPath, "r");
+        const { size } = await file.stat();
+        if (size <= 0)
+            return undefined;
+        const byteCount = Math.min(size, SESSION_TITLE_SCAN_MAX_BYTES);
+        const buffer = Buffer.alloc(byteCount);
+        await file.read(buffer, 0, byteCount, size - byteCount);
+        const text = buffer.toString("utf8");
+        const lines = text.split("\n");
+        if (size > byteCount)
+            lines.shift();
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+            const line = lines[index]?.trim();
+            if (!line)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(parsed) || parsed.type !== "session_info" || typeof parsed.name !== "string")
+                continue;
+            return validSessionTitle(parsed.name);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await file?.close();
+    }
+    return undefined;
+}
+function validSessionTitle(value) {
+    const title = value?.trim();
+    return title && !LOADING_TAB_TITLE_PATTERN.test(title) ? title : undefined;
+}
+function isDefaultSessionTitle(value) {
+    return DEFAULT_SESSION_TITLE_PATTERN.test(value.trim());
+}
 function clonePersistedAttachment(attachment) {
     if (attachment.kind === "image")
         return { kind: "image", tag: attachment.tag, image: { ...attachment.image } };

package/dist/app/types.d.ts

@@ -201,6 +201,8 @@ export type SubagentsWidgetState = {
 };
 export type RenderedLine = {
     text: string;
+    copyText?: string;
+    continuesOnNextLine?: boolean;
     variant?: "normal" | "muted" | "error" | "accent";
     colorOverride?: string;
     backgroundOverride?: string;
@@ -512,6 +514,9 @@ export type UserMessageMenuValue = "copy" | "fork" | "fork-new-tab" | "undo";
 export type UserMessageJumpMenuValue = {
     entryId?: string;
     sessionEntryId?: string;
+    text?: string;
+    userIndex?: number;
+    userCount?: number;
 };
 export type QueueMessageMenuValue = "cancel" | "edit" | "send-now";
 export type ResumeMenuValue = {

package/dist/app/workspace/workspace-actions-controller.d.ts

@@ -33,6 +33,9 @@ export declare class AppWorkspaceActionsController {
     forkFromUserMessage(entryId: string): Promise<void>;
     forkFromUserMessageInNewTab(entryId: string): Promise<void>;
     undoChangesFromUserMessage(entryId: string): Promise<void>;
+    private workspaceMutationPlanFromSessionEntry;
+    private workspaceMutationPlanForSingleEntry;
+    private findUserEntryBySessionEntryId;
     private resolveUserSessionEntryId;
     private getIdleRuntimeForAction;
     private workspaceMutationsForSessionEntry;

package/dist/app/workspace/workspace-actions-controller.js

@@ -130,18 +130,7 @@ export class AppWorkspaceActionsController {
         const sessionEntryId = this.resolveUserSessionEntryId(entry);
         if (!sessionEntryId)
             throw new Error("Session entry for this message is not available yet");
-        const hasMutationLog = entry.workspaceMutations !== undefined || this.hasWorkspaceMutationsForSessionEntry(sessionEntryId);
-        const mutations = entry.workspaceMutations ?? this.workspaceMutationsForSessionEntry(sessionEntryId);
-        if (!hasMutationLog) {
-            throw new Error("No workspace mutation log was captured for this message. Undo is available for messages sent after this build.");
-        }
-        if (mutations.length > 0) {
-            this.host.setStatus("reverting recorded commands");
-            this.host.render();
-        }
-        const reverted = mutations.length === 0 ? { ok: true, changedFiles: 0, revertedChanges: 0 } : await revertWorkspaceMutations(runtime.cwd, mutations);
-        if (!reverted.ok)
-            throw new Error(reverted.error);
+        const mutationPlan = this.workspaceMutationPlanFromSessionEntry(sessionEntryId);
         this.host.setStatus("truncating session");
         this.host.render();
         const result = await runtime.session.navigateTree(sessionEntryId);
@@ -157,15 +146,69 @@ export class AppWorkspaceActionsController {
         }
         this.host.resetSessionView();
         this.host.loadSessionHistory();
-        if (result.editorText && !this.host.getInput().trim())
-            this.host.setInput(result.editorText);
+        this.host.setInput(result.editorText ?? entry.text);
+        let revertSummary = "No recorded file mutations were found for the removed branch.";
+        let revertToastKind = "success";
+        if (mutationPlan.mutations.length > 0) {
+            this.host.setStatus("reverting recorded commands");
+            this.host.render();
+            const reverted = await revertWorkspaceMutations(runtime.cwd, mutationPlan.mutations);
+            if (reverted.ok) {
+                revertSummary = `Reverted ${reverted.revertedChanges} command${reverted.revertedChanges === 1 ? "" : "s"} across ${reverted.changedFiles} file${reverted.changedFiles === 1 ? "" : "s"}.`;
+            }
+            else {
+                revertSummary = `Workspace revert failed: ${reverted.error}`;
+                revertToastKind = "warning";
+            }
+        }
+        else if (mutationPlan.messagesWithoutLogs > 0) {
+            revertSummary = `No recorded file mutations were available for ${mutationPlan.messagesWithoutLogs} removed message${mutationPlan.messagesWithoutLogs === 1 ? "" : "s"}.`;
+            revertToastKind = "warning";
+        }
         this.host.addEntry({
             id: createId("system"),
             kind: "system",
-            text: `Undid changes from entry ${sessionEntryId}. Reverted ${reverted.revertedChanges} command${reverted.revertedChanges === 1 ? "" : "s"} across ${reverted.changedFiles} file${reverted.changedFiles === 1 ? "" : "s"}.`,
+            text: `Undid changes from entry ${sessionEntryId}. ${revertSummary}`,
         });
         this.host.setSessionStatus(runtime.session);
-        this.host.showToast("Changes undone", "success");
+        this.host.showToast(revertToastKind === "success" ? "Changes undone" : "Session rewound with revert warnings", revertToastKind);
+    }
+    workspaceMutationPlanFromSessionEntry(entryId) {
+        const runtime = this.host.runtime();
+        if (!runtime)
+            return { mutations: [], messagesWithoutLogs: 0 };
+        const branch = runtime.session.sessionManager.getBranch();
+        const startIndex = branch.findIndex((entry) => entry.id === entryId);
+        if (startIndex < 0) {
+            return this.workspaceMutationPlanForSingleEntry(entryId);
+        }
+        const mutations = [];
+        let messagesWithoutLogs = 0;
+        for (const branchEntry of branch.slice(startIndex)) {
+            if (branchEntry.type !== "message")
+                continue;
+            if (!isRecord(branchEntry.message) || branchEntry.message.role !== "user")
+                continue;
+            const visibleEntry = this.findUserEntryBySessionEntryId(branchEntry.id);
+            const hasMutationLog = visibleEntry?.workspaceMutations !== undefined || this.hasWorkspaceMutationsForSessionEntry(branchEntry.id);
+            const entryMutations = visibleEntry?.workspaceMutations ?? this.workspaceMutationsForSessionEntry(branchEntry.id);
+            if (!hasMutationLog) {
+                messagesWithoutLogs += 1;
+                continue;
+            }
+            mutations.push(...entryMutations);
+        }
+        return { mutations, messagesWithoutLogs };
+    }
+    workspaceMutationPlanForSingleEntry(entryId) {
+        const visibleEntry = this.findUserEntryBySessionEntryId(entryId);
+        const hasMutationLog = visibleEntry?.workspaceMutations !== undefined || this.hasWorkspaceMutationsForSessionEntry(entryId);
+        if (!hasMutationLog)
+            return { mutations: [], messagesWithoutLogs: 1 };
+        return { mutations: visibleEntry?.workspaceMutations ?? this.workspaceMutationsForSessionEntry(entryId), messagesWithoutLogs: 0 };
+    }
+    findUserEntryBySessionEntryId(sessionEntryId) {
+        return this.host.entries.find((entry) => entry.kind === "user" && entry.sessionEntryId === sessionEntryId);
     }
     resolveUserSessionEntryId(entry) {
         if (!entry.sessionEntryId)
@@ -204,6 +247,18 @@ export class AppWorkspaceActionsController {
         const key = this.workspaceUndoIndexKey(entryId);
         if (!key)
             return;
+        if (mutations.length === 0) {
+            if (!Object.prototype.hasOwnProperty.call(this.workspaceUndoIndex.entries, key))
+                return;
+            delete this.workspaceUndoIndex.entries[key];
+            try {
+                saveWorkspaceUndoIndex(getAgentDir(), this.workspaceUndoIndex);
+            }
+            catch {
+                // Undo persistence is best-effort; in-memory undo still works for this run.
+            }
+            return;
+        }
         const hasExisting = Object.prototype.hasOwnProperty.call(this.workspaceUndoIndex.entries, key);
         if (hasExisting && sameWorkspaceMutations(this.workspaceUndoIndex.entries[key] ?? [], mutations))
             return;

package/dist/app/workspace/workspace-undo.js

@@ -25,7 +25,7 @@ export function prepareWorkspaceMutation(cwd, toolName, args) {
     if (name !== "write")
         return undefined;
     const record = plainRecord(args);
-    const rawPath = stringValue(record?.path);
+    const rawPath = toolPathValue(record);
     const afterContent = stringValue(record?.content);
     if (!rawPath || afterContent === undefined)
         return undefined;
@@ -45,8 +45,9 @@ export function workspaceMutationFromToolExecution(input) {
     const name = normalizedToolName(input.toolName);
     if (name === "write" && input.preparation?.type === "write") {
         const record = plainRecord(input.args);
+        const rawPath = toolPathValue(record);
         const afterContent = stringValue(record?.content);
-        if (afterContent === undefined || input.preparation.beforeContent === afterContent)
+        if (!rawPath || afterContent === undefined || input.preparation.beforeContent === afterContent)
             return undefined;
         return {
             type: "write",
@@ -56,7 +57,8 @@ export function workspaceMutationFromToolExecution(input) {
             toolName: input.toolName,
         };
     }
-    const patch = patchFromDetails(input.details) ?? patchFromArgs(input.args);
+    const rawPatch = patchFromDetails(input.details) ?? patchFromArgs(input.args);
+    const patch = rawPatch && normalizePatchForWorkspace(input.cwd, rawPatch);
     if (!patch || !looksLikeUnifiedPatch(patch))
         return undefined;
     if (name === "edit" || name === "apply_patch" || name === "ast_apply") {
@@ -94,14 +96,17 @@ async function applyMutation(cwd, mutation, direction) {
     return applyWriteMutation(cwd, mutation, direction);
 }
 async function applyPatchMutation(cwd, mutation, direction) {
+    const patch = normalizePatchForWorkspace(cwd, mutation.patch);
+    if (!patch)
+        return { ok: false, error: "Refusing to apply patch with paths outside workspace." };
     const args = ["apply", ...(direction === "undo" ? ["--reverse"] : []), "--whitespace=nowarn"];
-    const check = await runGitApply(cwd, [...args, "--check"], mutation.patch);
+    const check = await runGitApply(cwd, [...args, "--check"], patch);
     if (check.status !== 0)
         return { ok: false, error: commandError(`git ${args.join(" ")} --check`, check) };
-    const apply = await runGitApply(cwd, args, mutation.patch);
+    const apply = await runGitApply(cwd, args, patch);
     if (apply.status !== 0)
         return { ok: false, error: commandError(`git ${args.join(" ")}`, apply) };
-    return { ok: true, changedFiles: filesFromPatch(mutation.patch) };
+    return { ok: true, changedFiles: filesFromPatch(patch) };
 }
 async function applyWriteMutation(cwd, mutation, direction) {
     const safePath = safeRelativePath(cwd, mutation.path);
@@ -163,6 +168,9 @@ function plainRecord(value) {
 function stringValue(value) {
     return typeof value === "string" ? value : undefined;
 }
+function toolPathValue(record) {
+    return stringValue(record?.path) ?? stringValue(record?.file_path);
+}
 function patchFromDetails(details) {
     const record = plainRecord(details);
     return stringValue(record?.patch) ?? stringValue(record?.diff);
@@ -174,6 +182,33 @@ function patchFromArgs(args) {
 function looksLikeUnifiedPatch(text) {
     return /^---\s+/m.test(text) && /^\+\+\+\s+/m.test(text) && /^@@\s/m.test(text);
 }
+function normalizePatchForWorkspace(cwd, patch) {
+    const normalizedLines = [];
+    for (const line of patch.split("\n")) {
+        const match = /^(---|\+\+\+)\s+(\S+)(.*)$/.exec(line);
+        if (!match) {
+            normalizedLines.push(line);
+            continue;
+        }
+        const marker = match[1];
+        const rawPath = match[2];
+        const suffix = match[3] ?? "";
+        if (rawPath === "/dev/null") {
+            normalizedLines.push(line);
+            continue;
+        }
+        const relativePath = patchWorkspacePath(cwd, rawPath);
+        if (!relativePath)
+            return undefined;
+        const prefix = marker === "---" ? "a" : "b";
+        normalizedLines.push(`${marker} ${prefix}/${relativePath}${suffix}`);
+    }
+    return normalizedLines.join("\n");
+}
+function patchWorkspacePath(cwd, inputPath) {
+    const path = !isAbsolute(inputPath) && /^[ab]\//u.test(inputPath) ? inputPath.slice(2) : inputPath;
+    return safeRelativePath(cwd, path);
+}
 function filesFromPatch(patch) {
     const files = new Set();
     for (const line of patch.split("\n")) {

package/dist/markdown-format.d.ts

@@ -1,6 +1,8 @@
 import { type SyntaxLineHighlight, type ToolBodySyntaxHighlights } from "./syntax-highlight.js";
 export type RenderedMarkdownLine = {
     text: string;
+    copyText?: string;
+    continuesOnNextLine?: boolean;
     segments: readonly {
         start: number;
         end: number;
@@ -10,6 +12,8 @@ export type RenderedMarkdownLine = {
 };
 export type RenderedMarkdownTextLine = {
     text: string;
+    copyText?: string;
+    continuesOnNextLine?: boolean;
     segments?: readonly {
         start: number;
         end: number;

package/dist/markdown-format.js

@@ -86,6 +86,8 @@ export function renderMarkdownTextLines(text, width, start = 0) {
         for (const wrapped of wrapRenderedMarkdownLine(markdownLine ?? { text: rawLine, segments: [] }, width)) {
             lines.push({
                 text: wrapped.text,
+                ...(wrapped.copyText === undefined ? {} : { copyText: wrapped.copyText }),
+                ...(wrapped.continuesOnNextLine ? { continuesOnNextLine: true } : {}),
                 ...(wrapped.segments.length > 0 ? { segments: wrapped.segments } : {}),
                 ...(syntaxHighlight ? { syntaxHighlight } : {}),
                 ...(isHeadingLine ? { heading: true } : {}),
@@ -124,8 +126,11 @@ function wrapRenderedMarkdownLine(line, width) {
     const safeWidth = Math.max(1, width);
     if (stringDisplayWidth(line.text) <= safeWidth)
         return [line];
-    return wrapDisplayLineByWordsWithRanges(line.text, safeWidth).map((range) => ({
+    const ranges = wrapDisplayLineByWordsWithRanges(line.text, safeWidth);
+    return ranges.map((range, index) => ({
         text: range.text,
+        copyText: line.text.slice(range.start, ranges[index + 1]?.start ?? range.end),
+        ...(index < ranges.length - 1 ? { continuesOnNextLine: true } : {}),
         segments: line.segments.flatMap((segment) => shiftSegmentToRange(segment, range.start, range.end)),
     }));
 }

package/dist/schemas/pi-tools-suite-schema.d.ts

@@ -83,7 +83,6 @@ export declare const PiToolsSuiteConfigSchema: Type.TObject<{
             maxTaskChars: Type.TOptional<Type.TNumber>;
             maxTokens: Type.TOptional<Type.TNumber>;
             maxRetries: Type.TOptional<Type.TNumber>;
-            temperature: Type.TOptional<Type.TNumber>;
             timeoutMs: Type.TOptional<Type.TNumber>;
             debug: Type.TOptional<Type.TBoolean>;
         }>>;

package/dist/schemas/pi-tools-suite-schema.js

@@ -115,7 +115,6 @@ const SubagentRoutingConfig = Type.Object({
     maxTaskChars: Type.Optional(Type.Number({ description: "Max task/scope characters sent to router.", minimum: 100 })),
     maxTokens: Type.Optional(Type.Number({ description: "Max router response tokens.", minimum: 8 })),
     maxRetries: Type.Optional(Type.Number({ description: "Router request retries.", minimum: 0 })),
-    temperature: Type.Optional(Type.Number({ description: "Router sampling temperature.", minimum: 0, maximum: 2 })),
     timeoutMs: Type.Optional(Type.Number({ description: "Router request timeout in ms.", minimum: 1000 })),
     debug: Type.Optional(Type.Boolean({ description: "Show routing debug warnings." })),
 }, { description: "LLM-based role routing configuration." });

package/dist/theme.js

@@ -36,15 +36,15 @@ export const THEMES = {
             warning: "#d49a4a",
             heading: "#d4b35e",
             info: "#7fb3c8",
-            toolMutation: "#b8899e", // ~10% brighter from #a67c8f
-            toolSearch: "#9d8abb", // ~10% brighter from #8c7aa8
-            toolTitle: "#899199", // ~10% brighter from #7b848c
-            toolBash: "#b89071", // ~10% brighter from #a68266
-            toolRead: "#6d9b82", // ~10% brighter from #628c76
-            toolIndex: "#7692b4", // ~10% brighter from #6a84a3
-            toolEdit: "#b47389", // ~10% brighter from #a3687c
-            toolWeb: "#8192b6", // ~10% brighter from #7584a6
-            toolMeta: "#7d8192", // ~10% brighter from #707485
+            toolMutation: "#b87f98",
+            toolSearch: "#9780bb",
+            toolTitle: "#858f99",
+            toolBash: "#b88862",
+            toolRead: "#639b7c",
+            toolIndex: "#698bb4",
+            toolEdit: "#b46680",
+            toolWeb: "#768ab6",
+            toolMeta: "#787d92",
             thinkingForeground: "#64748b",
             userForeground: "#d97706",
             thinkingXHigh: "#ff8a86",
@@ -91,15 +91,15 @@ export const THEMES = {
             warning: "#9a631d",
             heading: "#b88a28",
             info: "#246b8e",
-            toolMutation: "#8c5c70", // reverted
-            toolSearch: "#6e608c", // reverted
-            toolTitle: "#626c78", // reverted
-            toolBash: "#8c7556", // reverted
-            toolRead: "#507a62", // reverted
-            toolIndex: "#567a96", // reverted
-            toolEdit: "#8c586c", // reverted
-            toolWeb: "#5c6a8c", // reverted
-            toolMeta: "#787e8a", // reverted
+            toolMutation: "#8c526a",
+            toolSearch: "#68578c",
+            toolTitle: "#5d6978",
+            toolBash: "#8c704b",
+            toolRead: "#477a5d",
+            toolIndex: "#497496",
+            toolEdit: "#8c4d65",
+            toolWeb: "#52638c",
+            toolMeta: "#747b8a",
             thinkingForeground: "#6b5491",
             userForeground: "#854d0e",
             thinkingXHigh: "#cf333d",

package/extensions/session-title/config.ts

@@ -12,7 +12,6 @@ export interface SessionTitleConfig {
 	maxRetries: number;
 	generationAttempts: number;
 	retryDelayMs: number;
-	temperature: number;
 	timeoutMs: number;
 	terminalTitle: boolean;
 	terminalTitlePrefix: string;
@@ -29,7 +28,6 @@ const DEFAULT_CONFIG: SessionTitleConfig = {
 	maxRetries: 2,
 	generationAttempts: 3,
 	retryDelayMs: 3000,
-	temperature: 0.2,
 	timeoutMs: 12_000,
 	terminalTitle: true,
 	terminalTitlePrefix: "pi — ",
@@ -83,9 +81,6 @@ function mergeConfig(base: SessionTitleConfig, raw: Record<string, unknown>): Se
 	if (typeof raw.retryDelayMs === "number" && Number.isFinite(raw.retryDelayMs)) {
 		next.retryDelayMs = Math.max(250, Math.floor(raw.retryDelayMs));
 	}
-	if (typeof raw.temperature === "number" && Number.isFinite(raw.temperature)) {
-		next.temperature = Math.min(2, Math.max(0, raw.temperature));
-	}
 	if (typeof raw.timeoutMs === "number" && Number.isFinite(raw.timeoutMs)) {
 		next.timeoutMs = Math.max(1000, Math.floor(raw.timeoutMs));
 	}