pi-ui-extend 0.1.13 → 0.1.15

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

@@ -1,15 +1,17 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { mkdir, 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 MAX_PROJECT_SESSIONS = 20;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
+const LOADING_TAB_TITLE_PATTERN = /^loading(?:…|\.\.\.)?$/iu;
 export class AppTabsController {
     host;
     tabItems = [];
@@ -21,6 +23,8 @@ export class AppTabsController {
     pendingActiveTabId;
     historyLoadGeneration = 0;
     restored = false;
+    retentionCleanupRunning = false;
+    retentionCleanupScheduled = false;
     constructor(host) {
         this.host = host;
     }
@@ -153,17 +157,21 @@ export class AppTabsController {
         if (!runtime)
             return;
         this.syncActiveTabFromRuntime({ save: false });
-        if (this.host.options.noSession)
+        if (this.host.options.noSession) {
+            this.settleStartupTabPlaceholders();
             return;
+        }
         const saved = await this.loadTabs();
         if (!saved || saved.tabs.length === 0) {
+            this.settleStartupTabPlaceholders();
             await this.saveTabs();
             return;
         }
-        const sessionTitles = await this.loadSessionTitles();
-        const restoredTabs = this.restoredTabs(saved, sessionTitles);
+        const restoredTabs = this.restoredTabs(saved);
         if (restoredTabs.length === 0) {
+            this.settleStartupTabPlaceholders();
             await this.saveTabs();
+            this.scheduleProjectSessionRetention();
             return;
         }
         const currentPath = runtime.session.sessionFile ? resolve(runtime.session.sessionFile) : undefined;
@@ -180,35 +188,41 @@ export class AppTabsController {
         if (explicitSessionPath && currentPath)
             this.ensureCurrentSessionTab(runtime.session);
         if (!desiredPath) {
+            this.settleStartupTabPlaceholders();
             await this.saveTabs();
+            this.scheduleProjectSessionRetention();
             return;
         }
+        let restoredRuntime = runtime;
         if (currentPath !== desiredPath) {
             this.host.setStatus("restoring tabs");
             this.host.render();
             try {
-                const result = await runtime.switchSession(desiredPath);
-                if (result.cancelled)
-                    throw new Error("restore cancelled");
+                restoredRuntime = await this.host.createRuntimeForSession(desiredPath);
+                await this.host.activateRuntime(restoredRuntime);
             }
             catch {
                 this.host.showToast("Could not restore the previous active tab", "warning");
                 this.replaceTabs([this.tabFromSession(runtime.session), ...restoredTabs], currentPath);
                 this.storeActiveRuntime(runtime);
+                this.settleStartupTabPlaceholders();
                 await this.saveTabs();
+                this.scheduleProjectSessionRetention();
                 return;
             }
         }
         this.syncActiveTabFromRuntime({ save: false });
+        this.settleStartupTabPlaceholders();
         this.host.resetSessionView();
         if (this.activeTabId)
             this.restoreDeferredUserMessages(this.activeTabId);
         this.host.loadSessionHistory();
-        this.host.setSessionStatus(runtime.session);
-        this.host.setSessionActivity(this.sessionActivity(runtime.session));
+        this.host.setSessionStatus(restoredRuntime.session);
+        this.host.setSessionActivity(this.sessionActivity(restoredRuntime.session));
         if (this.activeTabId)
             this.restoreInputState(this.activeTabId);
         await this.saveTabs();
+        this.scheduleProjectSessionRetention();
     }
     async openNewTab() {
         if (this.pendingActiveTabId) {
@@ -237,6 +251,7 @@ export class AppTabsController {
         this.updateTabFromSession(tab, newRuntime.session);
         this.setRuntimeForTab(tab.id, newRuntime);
         this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
         try {
             await this.host.activateRuntime(newRuntime);
         }
@@ -245,6 +260,7 @@ export class AppTabsController {
                 this.pendingActiveTabId = undefined;
         }
         void this.saveTabs();
+        this.scheduleProjectSessionRetention();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(tab.id);
         if (isEmptyStartupSession(newRuntime)) {
@@ -307,6 +323,7 @@ export class AppTabsController {
         this.updateTabFromSession(tab, newRuntime.session);
         this.setRuntimeForTab(tab.id, newRuntime);
         this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
         try {
             await this.host.activateRuntime(newRuntime);
         }
@@ -316,6 +333,7 @@ export class AppTabsController {
             this.activeTabId = previousTabId;
             if (previousTabId)
                 this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
                     await this.host.activateRuntime(previousRuntime);
@@ -346,6 +364,120 @@ export class AppTabsController {
         await this.loadActiveSessionHistory(newRuntime);
         return true;
     }
+    async forkSessionEntryInNewTab(entryId) {
+        if (this.pendingActiveTabId) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            return false;
+        }
+        const runtime = this.idleRuntime("fork");
+        if (!runtime)
+            return false;
+        if (this.host.options.noSession) {
+            this.host.showToast("Fork in new tab is unavailable with --no-session", "warning");
+            return false;
+        }
+        const currentSessionPath = runtime.session.sessionFile ? resolve(runtime.session.sessionFile) : undefined;
+        if (!currentSessionPath) {
+            this.host.showToast("Fork in new tab requires a persisted session", "warning");
+            return false;
+        }
+        this.cancelHistoryLoad();
+        this.syncActiveTabFromRuntime({ save: false });
+        this.storeActiveInputState();
+        this.storeActiveDeferredUserMessages();
+        const previousTabId = this.activeTabId;
+        const previousRuntime = runtime;
+        this.host.setStatus("forking session tab");
+        this.host.render();
+        let forkRuntime;
+        try {
+            forkRuntime = await this.host.createRuntimeForSession(currentSessionPath);
+        }
+        catch {
+            this.host.showToast("Could not fork in new tab", "warning");
+            this.host.setSessionStatus(previousRuntime.session);
+            this.host.render();
+            return false;
+        }
+        let result;
+        try {
+            result = await forkRuntime.fork(entryId);
+        }
+        catch (error) {
+            void this.host.disposeRuntime(forkRuntime);
+            throw error;
+        }
+        if (result.cancelled) {
+            void this.host.disposeRuntime(forkRuntime);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
+            this.host.setSessionStatus(previousRuntime.session);
+            this.host.render();
+            return false;
+        }
+        const existingTab = this.findTabForSession(forkRuntime.session);
+        if (existingTab) {
+            if (result.selectedText)
+                this.inputStatesByTabId.set(existingTab.id, this.inputStateFromText(result.selectedText));
+            void this.host.disposeRuntime(forkRuntime);
+            await this.switchToTab(existingTab.id);
+            this.host.showToast("Fork opened in existing tab", "success");
+            return true;
+        }
+        const tab = this.tabFromSession(forkRuntime.session, { titlePlaceholder: "new" });
+        this.tabItems.push(tab);
+        this.activeTabId = tab.id;
+        this.pendingActiveTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, forkRuntime.session);
+        this.setRuntimeForTab(tab.id, forkRuntime);
+        if (result.selectedText)
+            this.inputStatesByTabId.set(tab.id, this.inputStateFromText(result.selectedText));
+        this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
+        try {
+            await this.host.activateRuntime(forkRuntime);
+        }
+        catch {
+            this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
+            if (this.host.runtime() !== previousRuntime) {
+                try {
+                    await this.host.activateRuntime(previousRuntime);
+                }
+                catch {
+                    // Keep the best available runtime below and surface the switch failure.
+                }
+            }
+            void this.host.disposeRuntime(forkRuntime);
+            this.host.showToast("Could not open fork tab", "warning");
+            this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
+            this.host.loadSessionHistory();
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
+            this.host.render();
+            return false;
+        }
+        this.pendingActiveTabId = undefined;
+        this.activeTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, forkRuntime.session);
+        this.setRuntimeForTab(tab.id, forkRuntime);
+        this.restoreInputState(tab.id);
+        void this.saveTabs();
+        this.scheduleProjectSessionRetention();
+        await this.loadActiveSessionHistory(forkRuntime);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Forked from entry ${entryId} in a new tab.` });
+        this.host.setSessionStatus(forkRuntime.session);
+        this.host.showToast("Fork opened in new tab", "success");
+        this.host.render();
+        return true;
+    }
     async switchToTab(tabId) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
@@ -376,6 +508,7 @@ export class AppTabsController {
         target.activity = "thinking";
         this.clearTabAttention(target);
         this.restoreInputState(target.id);
+        this.host.closeMenusForTabSwitch?.();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(target.id);
         this.host.setStatus("switching tab");
@@ -397,6 +530,7 @@ export class AppTabsController {
             this.activeTabId = previousTabId;
             if (previousTabId)
                 this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
                     await this.host.activateRuntime(previousRuntime);
@@ -481,6 +615,7 @@ export class AppTabsController {
         this.updateTabFromSession(nextTab, nextRuntime.session);
         this.setRuntimeForTab(nextTab.id, nextRuntime);
         this.restoreInputState(nextTab.id);
+        this.host.closeMenusForTabSwitch?.();
         void this.host.disposeRuntime(runtime);
         void this.saveTabs();
         await this.loadActiveSessionHistory(nextRuntime);
@@ -509,6 +644,7 @@ export class AppTabsController {
         this.inputStatesByTabId.delete(tab.id);
         this.deferredUserMessagesByTabId.delete(tab.id);
         this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
         this.stopAttentionBlinkIfIdle();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(tab.id);
@@ -522,6 +658,7 @@ export class AppTabsController {
         this.host.setSessionStatus(runtime.session);
         this.host.setSessionActivity(this.sessionActivity(runtime.session));
         void this.saveTabs();
+        this.scheduleProjectSessionRetention();
         this.host.render();
     }
     async loadActiveSessionHistory(runtime) {
@@ -539,6 +676,7 @@ export class AppTabsController {
                 if (!isCancelled())
                     this.host.render();
             },
+            lazyOlderHistory: true,
         });
         if (!completed || isCancelled())
             return;
@@ -583,6 +721,12 @@ export class AppTabsController {
     activeTab() {
         return this.activeTabId ? this.tabItems.find((tab) => tab.id === this.activeTabId) : undefined;
     }
+    settleStartupTabPlaceholders() {
+        for (const tab of this.tabItems) {
+            if (tab.titlePlaceholder === "loading")
+                tab.titlePlaceholder = "new";
+        }
+    }
     storeActiveRuntime(runtime = this.host.runtime()) {
         if (!this.activeTabId || !runtime)
             return;
@@ -662,6 +806,9 @@ export class AppTabsController {
     restoreInputState(tabId) {
         this.host.restoreInputState(this.inputStatesByTabId.get(tabId) ?? { text: "", cursor: 0 });
     }
+    inputStateFromText(text) {
+        return { text, cursor: text.length };
+    }
     restoreDeferredUserMessages(tabId) {
         this.host.restoreDeferredUserMessages?.(this.deferredUserMessagesByTabId.get(tabId) ?? []);
     }
@@ -712,6 +859,7 @@ export class AppTabsController {
             this.tabItems.push({
                 id: tab.id,
                 title: tab.title,
+                ...(tab.titlePlaceholder ? { titlePlaceholder: tab.titlePlaceholder } : {}),
                 status: "waiting",
                 activity: tab.activity ?? "idle",
                 ...(sessionPath ? { sessionPath } : {}),
@@ -800,8 +948,11 @@ export class AppTabsController {
         return session.sessionFile ? resolve(session.sessionFile) : undefined;
     }
     sessionTitle(session) {
-        const name = session.sessionName?.trim();
-        return name ? name : `session ${session.sessionId.slice(0, 8)}`;
+        return this.sessionTitleFromParts(session.sessionId, session.sessionName);
+    }
+    sessionTitleFromParts(sessionId, sessionName) {
+        const name = sessionName?.trim();
+        return name && !LOADING_TAB_TITLE_PATTERN.test(name) ? name : `session ${sessionId.slice(0, 8)}`;
     }
     sessionActivity(session) {
         return session?.isStreaming || session?.isCompacting ? "running" : "idle";
@@ -833,19 +984,7 @@ export class AppTabsController {
             initialVisible: true,
         });
     }
-    async loadSessionTitles() {
-        try {
-            const sessions = await SessionManager.list(this.host.options.cwd);
-            return new Map(sessions.map((session) => [
-                resolve(session.path),
-                (session.name?.trim() || `session ${session.id.slice(0, 8)}`),
-            ]));
-        }
-        catch {
-            return new Map();
-        }
-    }
-    restoredTabs(saved, titles) {
+    restoredTabs(saved) {
         const tabs = [];
         const seen = new Set();
         for (const tab of saved.tabs) {
@@ -855,10 +994,13 @@ export class AppTabsController {
             if (seen.has(sessionPath) || (!existsSync(sessionPath) && !hasDraftInput && !hasDeferredQueue))
                 continue;
             seen.add(sessionPath);
-            const title = titles.get(sessionPath) ?? tab.title?.trim();
+            const savedTitle = tab.title?.trim();
+            const restoredLoadingTitle = savedTitle !== undefined && LOADING_TAB_TITLE_PATTERN.test(savedTitle);
+            const title = restoredLoadingTitle ? this.defaultSessionTitleFromPath(sessionPath) : savedTitle;
             tabs.push({
                 id: createId("tab"),
                 title: title || "session",
+                ...(restoredLoadingTitle ? { titlePlaceholder: "new" } : {}),
                 status: "waiting",
                 sessionPath,
             });
@@ -867,6 +1009,12 @@ export class AppTabsController {
         }
         return tabs;
     }
+    defaultSessionTitleFromPath(sessionPath) {
+        const fileName = basename(sessionPath, extname(sessionPath));
+        const sessionId = /^[0-9a-f]{8}/iu.exec(fileName)?.[0]?.toLowerCase()
+            ?? createHash("sha256").update(sessionPath).digest("hex").slice(0, 8);
+        return `session ${sessionId}`;
+    }
     async loadTabs() {
         try {
             const raw = await readFile(this.filePath(), "utf8");
@@ -978,4 +1126,77 @@ export class AppTabsController {
         const key = createHash("sha256").update(resolve(this.host.options.cwd)).digest("hex").slice(0, 24);
         return join(getAgentDir(), "pix", "tabs", `${key}.json`);
     }
+    sessionDir() {
+        const safePath = `--${resolve(this.host.options.cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+        return join(getAgentDir(), "sessions", safePath);
+    }
+    scheduleProjectSessionRetention() {
+        if (this.host.options.noSession || this.retentionCleanupScheduled || this.retentionCleanupRunning)
+            return;
+        this.retentionCleanupScheduled = true;
+        setTimeout(() => {
+            this.retentionCleanupScheduled = false;
+            void this.cleanupOldProjectSessions();
+        }, 0);
+    }
+    async cleanupOldProjectSessions() {
+        if (this.retentionCleanupRunning)
+            return;
+        this.retentionCleanupRunning = true;
+        try {
+            const sessionDir = this.sessionDir();
+            const preserved = this.preservedSessionPaths();
+            const entries = await readdir(sessionDir, { withFileTypes: true });
+            const sessions = [];
+            for (const entry of entries) {
+                if (!entry.isFile() || extname(entry.name) !== ".jsonl")
+                    continue;
+                const path = resolve(sessionDir, entry.name);
+                try {
+                    const info = await stat(path);
+                    sessions.push({ path, modifiedMs: info.mtimeMs });
+                }
+                catch {
+                    // Ignore files that disappear while cleanup is scanning.
+                }
+            }
+            if (sessions.length <= MAX_PROJECT_SESSIONS)
+                return;
+            sessions.sort((a, b) => b.modifiedMs - a.modifiedMs);
+            const keep = new Set(preserved);
+            for (const session of sessions) {
+                if (keep.size >= MAX_PROJECT_SESSIONS)
+                    break;
+                keep.add(session.path);
+            }
+            for (const session of sessions) {
+                if (keep.has(session.path))
+                    continue;
+                try {
+                    await unlink(session.path);
+                }
+                catch {
+                    // Session retention must never interrupt the terminal UI.
+                }
+            }
+        }
+        catch {
+            // Session retention must never interrupt the terminal UI.
+        }
+        finally {
+            this.retentionCleanupRunning = false;
+        }
+    }
+    preservedSessionPaths() {
+        const preserved = new Set();
+        const add = (sessionPath) => {
+            if (sessionPath)
+                preserved.add(resolve(sessionPath));
+        };
+        add(this.host.options.sessionPath);
+        add(this.host.runtime()?.session.sessionFile);
+        for (const tab of this.tabItems)
+            add(tab.sessionPath);
+        return preserved;
+    }
 }

package/dist/app/todo/todo-model.d.ts

@@ -1,7 +1,8 @@
-import type { StyledSegment, TodoAction, TodoDetails, TodoLiveStateEvent, TodoPriority, TodoStatus, TodoTask, TodoTaskLinePart, TodoTaskRow } from "../types.js";
+import type { StyledSegment, ThinkingLevel, TodoAction, TodoDetails, TodoLiveStateEvent, TodoPriority, TodoStatus, TodoTask, TodoTaskLinePart, TodoTaskRow } from "../types.js";
 export declare function isTodoAction(value: unknown): value is TodoAction;
 export declare function isTodoStatus(value: unknown): value is TodoStatus;
 export declare function isTodoPriority(value: unknown): value is TodoPriority;
+export declare function isTodoThinkingLevel(value: unknown): value is ThinkingLevel;
 export declare function isTodoTask(value: unknown): value is TodoTask;
 export declare function isTodoDetails(value: unknown): value is TodoDetails;
 export declare function isTodoLiveStateEvent(value: unknown): value is TodoLiveStateEvent;
@@ -17,6 +18,7 @@ export declare function formatTodoTaskLine(task: TodoTask, options?: {
 }): string;
 export declare function todoTaskLineSegments(task: TodoTask, mutedColor: string, options?: {
     depth?: number;
+    thinkingColor?: (level: ThinkingLevel) => string;
 }): StyledSegment[];
 export declare function shiftSegmentsToSlice(segments: readonly StyledSegment[], start: number, length: number): StyledSegment[];
 export declare function formatTodoPanelStats(tasks: readonly TodoTask[]): string;

package/dist/app/todo/todo-model.js

@@ -1,4 +1,4 @@
-import { TODO_ACTIONS, TODO_PRIORITIES, TODO_STATUSES } from "../constants.js";
+import { THINKING_LEVELS, TODO_ACTIONS, TODO_PRIORITIES, TODO_STATUSES } from "../constants.js";
 import { isNumberArray, isRecord, isStringArray } from "../guards.js";
 import { APP_ICONS } from "../icons.js";
 export function isTodoAction(value) {
@@ -10,6 +10,9 @@ export function isTodoStatus(value) {
 export function isTodoPriority(value) {
     return typeof value === "string" && TODO_PRIORITIES.includes(value);
 }
+export function isTodoThinkingLevel(value) {
+    return typeof value === "string" && THINKING_LEVELS.includes(value);
+}
 export function isTodoTask(value) {
     if (!isRecord(value))
         return false;
@@ -25,6 +28,8 @@ export function isTodoTask(value) {
         return false;
     if (value.priority !== undefined && !isTodoPriority(value.priority))
         return false;
+    if (value.thinking !== undefined && !isTodoThinkingLevel(value.thinking))
+        return false;
     if (value.parentId !== undefined && typeof value.parentId !== "number")
         return false;
     if (value.blockedBy !== undefined && !isNumberArray(value.blockedBy))
@@ -121,6 +126,8 @@ export function todoTaskLineParts(task, options = {}) {
         parts.push({ text: `— ${task.activeForm}` });
     if (task.priority)
         parts.push({ text: `(${task.priority})`, muted: true });
+    if (task.thinking)
+        parts.push({ text: `[${task.thinking}]`, thinking: task.thinking });
     if (task.parentId !== undefined)
         parts.push({ text: `parent:#${task.parentId}` });
     if (task.blockedBy && task.blockedBy.length > 0)
@@ -141,7 +148,12 @@ export function todoTaskLineSegments(task, mutedColor, options = {}) {
         const start = offset;
         const end = start + part.text.length;
         const segment = { start, end };
-        if (part.muted)
+        if (part.thinking) {
+            const foreground = options.thinkingColor?.(part.thinking);
+            if (foreground)
+                segment.foreground = foreground;
+        }
+        else if (part.muted)
             segment.foreground = mutedColor;
         if (task.status === "completed" && index > 0)
             segment.strikethrough = true;

package/dist/app/types.d.ts

@@ -100,6 +100,7 @@ export type TodoTask = {
     description?: string;
     activeForm?: string;
     priority?: TodoPriority;
+    thinking?: ThinkingLevel;
     parentId?: number;
     blockedBy?: number[];
     tags?: string[];
@@ -109,6 +110,7 @@ export type TodoTask = {
 export type TodoTaskLinePart = {
     text: string;
     muted?: boolean;
+    thinking?: ThinkingLevel;
 };
 export type TodoTaskRow = {
     task: TodoTask;
@@ -498,9 +500,10 @@ export type ThinkingMenuValue = {
     level: ThinkingLevel;
     current: boolean;
 };
-export type UserMessageMenuValue = "copy" | "fork" | "undo";
+export type UserMessageMenuValue = "copy" | "fork" | "fork-new-tab" | "undo";
 export type UserMessageJumpMenuValue = {
-    entryId: string;
+    entryId?: string;
+    sessionEntryId?: string;
 };
 export type QueueMessageMenuValue = "cancel" | "edit" | "send-now";
 export type ResumeMenuValue = {

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

@@ -18,6 +18,7 @@ export type AppWorkspaceActionsControllerHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
     isRunning(): boolean;
+    forkSessionEntryInNewTab(sessionEntryId: string): Promise<boolean>;
 };
 export declare class AppWorkspaceActionsController {
     private readonly host;
@@ -30,6 +31,7 @@ export declare class AppWorkspaceActionsController {
     syncUserSessionEntryMetadata(): void;
     copyUserMessage(entryId: string): Promise<void>;
     forkFromUserMessage(entryId: string): Promise<void>;
+    forkFromUserMessageInNewTab(entryId: string): Promise<void>;
     undoChangesFromUserMessage(entryId: string): Promise<void>;
     private resolveUserSessionEntryId;
     private getIdleRuntimeForAction;

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

@@ -108,6 +108,18 @@ export class AppWorkspaceActionsController {
         this.host.setSessionStatus(runtime.session);
         this.host.showToast("Session forked", "success");
     }
+    async forkFromUserMessageInNewTab(entryId) {
+        const runtime = this.getIdleRuntimeForAction("fork in new tab");
+        if (!runtime)
+            return;
+        const entry = this.host.findUserEntry(entryId);
+        if (!entry)
+            throw new Error("User message is no longer available");
+        const sessionEntryId = this.resolveUserSessionEntryId(entry);
+        if (!sessionEntryId)
+            throw new Error("Session entry for this message is not available yet");
+        await this.host.forkSessionEntryInNewTab(sessionEntryId);
+    }
     async undoChangesFromUserMessage(entryId) {
         const runtime = this.getIdleRuntimeForAction("undo changes");
         if (!runtime)

package/dist/config.d.ts

@@ -67,16 +67,20 @@ export type PixConfig = {
     modelColors: ModelColorsConfig;
     iconTheme: IconThemeConfig;
     dictation: DictationConfig;
+    ignoreContextFiles: boolean;
 };
 export declare function getPixConfigPath(homeDir?: string): string;
+export declare function getProjectPixConfigPath(cwd: string): string;
 export declare function resolveDefaultModelRef(config: PixConfig): string | undefined;
 export declare function savePixDefaultModel(modelRef: string): DefaultModelConfig | undefined;
 export declare function savePixDefaultThinking(thinking: string, fallbackModelRef?: string): DefaultModelConfig | undefined;
 export declare function savePixAutocompleteModel(modelRef: string): AutocompleteConfig;
+export declare function saveProjectPixIgnoreContextFiles(cwd: string, ignoreContextFiles: boolean): boolean;
+export declare function upsertPixIgnoreContextFilesInJsonc(source: string, ignoreContextFiles: boolean): string;
 export declare function upsertPixDefaultModelInJsonc(source: string, modelRef: string): string;
 export declare function upsertPixDefaultThinkingInJsonc(source: string, thinking: string, fallbackModelRef?: string): string;
 export declare function upsertPixAutocompleteModelInJsonc(source: string, modelRef: string): string;
-export declare function loadPixConfig(): PixConfig;
+export declare function loadPixConfig(cwd?: string): PixConfig;
 export declare function savePixDictationLanguage(language: string): void;
 export declare function upsertPixDictationLanguageInJsonc(source: string, language: string): string;
 export declare function resolveModelColor(modelRef: string, config: ModelColorsConfig): string | undefined;