pi-ui-extend 0.1.11 → 0.1.15

package/dist/app/commands/shell-command.d.ts

@@ -1,3 +1,9 @@
+import { spawn } from "node:child_process";
+type ShellCommandDeps = {
+    spawn: typeof spawn;
+    waitForReturnToPix: () => Promise<void>;
+};
+export declare function setShellCommandTestDeps(overrides: Partial<ShellCommandDeps>): () => void;
 export type InteractiveShellCommandResult = {
     exitCode: number | null;
     signal: NodeJS.Signals | null;
@@ -25,3 +31,4 @@ export declare function shellCommandFromBangInput(text: string): string | undefi
 export declare function runChatShellCommand(command: string, cwd: string, handlers?: ChatShellCommandHandlers): RunningChatShellCommand;
 export declare function runInteractiveShellCommand(command: string, cwd: string): Promise<InteractiveShellCommandResult>;
 export declare function formatShellCommandEntry(command: string, result: InteractiveShellCommandResult, prefix?: string): string;
+export {};

package/dist/app/commands/shell-command.js

@@ -1,4 +1,12 @@
 import { spawn } from "node:child_process";
+let deps = { spawn, waitForReturnToPix: waitForReturnToPixImpl };
+export function setShellCommandTestDeps(overrides) {
+    const previous = deps;
+    deps = { ...deps, ...overrides };
+    return () => {
+        deps = previous;
+    };
+}
 export function bangShellCommandFromInput(text) {
     const trimmed = text.trimStart();
     if (!trimmed.startsWith("!"))
@@ -12,7 +20,7 @@ export function shellCommandFromBangInput(text) {
 export function runChatShellCommand(command, cwd, handlers = {}) {
     let child;
     try {
-        child = spawn(command, {
+        child = deps.spawn(command, {
             cwd,
             env: process.env,
             shell: shellOption(),
@@ -79,7 +87,7 @@ export async function runInteractiveShellCommand(command, cwd) {
     try {
         const result = await spawnShellCommand(command, cwd);
         process.stdout.write(`\n[pix] ${formatInteractiveShellResult(result)}\n`);
-        await waitForReturnToPix();
+        await deps.waitForReturnToPix();
         return result;
     }
     finally {
@@ -93,7 +101,7 @@ export function formatShellCommandEntry(command, result, prefix = "!") {
 }
 async function spawnShellCommand(command, cwd) {
     try {
-        const child = spawn(command, {
+        const child = deps.spawn(command, {
             cwd,
             env: process.env,
             shell: shellOption(),
@@ -160,7 +168,7 @@ function formatInteractiveShellResult(result) {
         return `terminated by ${result.signal}`;
     return `exit ${result.exitCode ?? 0}`;
 }
-async function waitForReturnToPix() {
+async function waitForReturnToPixImpl() {
     if (!process.stdin.isTTY || !process.stdin.readable)
         return;
     process.stdout.write("[pix] Press Enter to return to pix…");

package/dist/app/extensions/extension-ui-controller.d.ts

@@ -7,10 +7,14 @@ export type ExtensionTerminalInputResult = {
 };
 export type ExtensionUiControllerHost = {
     readonly theme: Theme;
+    activeExtensionUiScope?(): string | undefined;
     isRunning(): boolean;
     render(): void;
-    showToast(message: string, kind?: ToastKind): void;
+    showToast(message: string, kind?: ToastKind, options?: {
+        scopeKey?: string;
+    }): void;
     readonly toastNotifier: ToastNotifier;
+    toastNotifierForScope?(scopeKey: string | undefined): ToastNotifier;
     readonly menuController: PixMenuController;
     setStatus(status: string): void;
     restoreSessionStatus(): void;
@@ -23,22 +27,24 @@ export declare class ExtensionUiController {
     private readonly host;
     private readonly extensionWidgets;
     private readonly terminalInputHandlers;
-    private activeCustomUi;
-    private readonly aboveInputRenderer;
+    private readonly activeCustomUis;
     constructor(host: ExtensionUiControllerHost);
     get widgets(): ReadonlyMap<string, ExtensionWidgetRegistration>;
     createExtensionTheme(): ExtensionWidgetTheme;
     setWidget(key: string, content: unknown, options?: {
         placement?: WidgetPlacement;
+        scopeKey?: string;
+    }): void;
+    clearWidgets(scopeKey?: string, options?: {
+        cancelCustomUi?: boolean;
     }): void;
-    clearWidgets(): void;
     suppressWidget(key: string): void;
     handleTerminalInput(data: string): ExtensionTerminalInputResult;
     renderActiveCustomUi(width: number): string[] | undefined;
     activeCustomUiUsesEditor(): boolean;
     handleCustomUiMouse(event: ExtensionInputMouseEvent): boolean;
     widgetTuiHandle(): WidgetTuiHandle;
-    createExtensionUIContext(): PixExtensionUIContext;
+    createExtensionUIContext(scopeKey?: string): PixExtensionUIContext;
     private setAboveInputWidget;
     private clearAboveInputWidget;
     private selectDialog;
@@ -53,5 +59,10 @@ export declare class ExtensionUiController {
     private cancelActiveCustomUi;
     private rejectActiveCustomUi;
     private finishActiveCustomUi;
+    private activeCustomUiForActiveScope;
+    private activeScopeKey;
+    private normalizeScopeKey;
+    private scopedWidgetKey;
+    private unscopedWidgetKey;
     private invalidateWidget;
 }

package/dist/app/extensions/extension-ui-controller.js

@@ -6,20 +6,15 @@ export class ExtensionUiController {
     host;
     extensionWidgets = new Map();
     terminalInputHandlers = new Set();
-    activeCustomUi;
-    aboveInputRenderer = {
-        set: (key, content) => {
-            this.setAboveInputWidget(key, content);
-        },
-        clear: (key) => {
-            this.clearAboveInputWidget(key);
-        },
-    };
+    activeCustomUis = new Map();
     constructor(host) {
         this.host = host;
     }
     get widgets() {
-        return this.extensionWidgets;
+        const activeScopeKey = this.activeScopeKey();
+        return new Map([...this.extensionWidgets.entries()]
+            .filter(([, widget]) => widget.scopeKey === activeScopeKey)
+            .map(([scopedKey, widget]) => [this.unscopedWidgetKey(scopedKey, widget.scopeKey), widget]));
     }
     createExtensionTheme() {
         const colors = this.host.theme.colors;
@@ -47,44 +42,54 @@ export class ExtensionUiController {
         };
     }
     setWidget(key, content, options) {
-        const existing = this.extensionWidgets.get(key);
+        const scopeKey = this.normalizeScopeKey(options?.scopeKey);
+        const scopedKey = this.scopedWidgetKey(scopeKey, key);
+        const existing = this.extensionWidgets.get(scopedKey);
         if (existing)
             this.invalidateWidget(existing);
         if (content === undefined) {
-            this.extensionWidgets.delete(key);
+            this.extensionWidgets.delete(scopedKey);
             if (this.host.isRunning())
                 this.host.render();
             return;
         }
         if (!Array.isArray(content) && typeof content !== "function")
             return;
-        this.extensionWidgets.set(key, {
+        this.extensionWidgets.set(scopedKey, {
             key,
+            scopeKey,
             placement: options?.placement === "belowEditor" ? "belowEditor" : "aboveEditor",
             content: content,
         });
         if (this.host.isRunning())
             this.host.render();
     }
-    clearWidgets() {
-        this.cancelActiveCustomUi();
-        for (const widget of this.extensionWidgets.values())
+    clearWidgets(scopeKey, options = {}) {
+        const normalizedScopeKey = this.normalizeScopeKey(scopeKey);
+        if (options.cancelCustomUi !== false)
+            this.cancelActiveCustomUi(normalizedScopeKey);
+        for (const [key, widget] of this.extensionWidgets.entries()) {
+            if (widget.scopeKey !== normalizedScopeKey)
+                continue;
             this.invalidateWidget(widget);
-        this.extensionWidgets.clear();
+            this.extensionWidgets.delete(key);
+        }
     }
     suppressWidget(key) {
-        const widget = this.extensionWidgets.get(key);
+        const scopedKey = this.scopedWidgetKey(this.activeScopeKey(), key);
+        const widget = this.extensionWidgets.get(scopedKey);
         if (!widget)
             return;
         this.invalidateWidget(widget);
-        this.extensionWidgets.delete(key);
+        this.extensionWidgets.delete(scopedKey);
     }
     handleTerminalInput(data) {
-        if (this.activeCustomUi) {
+        const active = this.activeCustomUiForActiveScope();
+        if (active) {
             if (data === "\u0003")
                 return { consume: false };
             try {
-                const result = this.activeCustomUi.component.handleInput?.(data);
+                const result = active.component.handleInput?.(data);
                 if (result && typeof result === "object") {
                     return {
                         consume: result.consume !== false,
@@ -98,7 +103,10 @@ export class ExtensionUiController {
             return { consume: true };
         }
         let current = data;
-        for (const handler of [...this.terminalInputHandlers]) {
+        const activeScopeKey = this.activeScopeKey();
+        for (const { scopeKey, handler } of [...this.terminalInputHandlers]) {
+            if (scopeKey !== activeScopeKey)
+                continue;
             const result = handler(current);
             if (result?.data !== undefined)
                 current = result.data;
@@ -108,7 +116,7 @@ export class ExtensionUiController {
         return current === data ? { consume: false } : { consume: false, data: current };
     }
     renderActiveCustomUi(width) {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return undefined;
         try {
@@ -119,7 +127,7 @@ export class ExtensionUiController {
         }
     }
     activeCustomUiUsesEditor() {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return false;
         try {
@@ -130,7 +138,7 @@ export class ExtensionUiController {
         }
     }
     handleCustomUiMouse(event) {
-        const active = this.activeCustomUi;
+        const active = this.activeCustomUiForActiveScope();
         if (!active)
             return false;
         try {
@@ -142,13 +150,14 @@ export class ExtensionUiController {
         }
     }
     widgetTuiHandle() {
+        const activeScopeToastNotifier = this.host.toastNotifierForScope?.(this.activeScopeKey()) ?? this.host.toastNotifier;
         return {
             requestRender: () => {
                 if (this.host.isRunning())
                     this.host.render();
             },
-            showToast: this.host.toastNotifier.show,
-            toast: this.host.toastNotifier,
+            showToast: activeScopeToastNotifier.show,
+            toast: activeScopeToastNotifier,
             showMenu: this.host.menuController.show,
             menu: this.host.menuController,
             pix: {
@@ -157,9 +166,11 @@ export class ExtensionUiController {
             },
         };
     }
-    createExtensionUIContext() {
+    createExtensionUIContext(scopeKey) {
+        const contextScopeKey = this.normalizeScopeKey(scopeKey);
+        const scopedToastNotifier = this.host.toastNotifierForScope?.(contextScopeKey) ?? this.host.toastNotifier;
         const notify = (message, type) => {
-            this.host.showToast(message, isToastKind(type) ? type : "info");
+            this.host.showToast(message, isToastKind(type) ? type : "info", { scopeKey: contextScopeKey });
         };
         const extensionTheme = this.createExtensionTheme();
         const renderIfRunning = () => {
@@ -169,17 +180,24 @@ export class ExtensionUiController {
         return {
             select: async (title, options, opts) => await this.selectDialog(title, options, opts),
             confirm: async (title, message, opts) => await this.confirmDialog(title, message, opts),
-            input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts),
+            input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts, contextScopeKey),
             notify,
-            toast: this.host.toastNotifier,
-            aboveInput: this.aboveInputRenderer,
+            toast: scopedToastNotifier,
+            aboveInput: {
+                set: (key, content) => {
+                    this.setAboveInputWidget(key, content, contextScopeKey);
+                },
+                clear: (key) => {
+                    this.clearAboveInputWidget(key, contextScopeKey);
+                },
+            },
             renderAboveInput: (key, content) => {
-                this.setAboveInputWidget(key, content);
+                this.setAboveInputWidget(key, content, contextScopeKey);
             },
             showMenu: this.host.menuController.show,
             menu: this.host.menuController,
             onTerminalInput: (handler) => {
-                const terminalInputHandler = handler;
+                const terminalInputHandler = { scopeKey: contextScopeKey, handler: handler };
                 this.terminalInputHandlers.add(terminalInputHandler);
                 return () => {
                     this.terminalInputHandlers.delete(terminalInputHandler);
@@ -187,13 +205,13 @@ export class ExtensionUiController {
             },
             setStatus: (_key, text) => {
                 if (text)
-                    this.host.showToast(text, "info");
+                    this.host.showToast(text, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
             setWorkingMessage: (message) => {
                 if (message)
-                    this.host.showToast(message, "info");
+                    this.host.showToast(message, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
@@ -201,7 +219,7 @@ export class ExtensionUiController {
             setWorkingIndicator: () => undefined,
             setHiddenThinkingLabel: () => undefined,
             setWidget: ((key, content, options) => {
-                this.setWidget(key, content, options);
+                this.setWidget(key, content, { ...options, scopeKey: contextScopeKey });
             }),
             setFooter: () => undefined,
             setHeader: () => undefined,
@@ -209,7 +227,7 @@ export class ExtensionUiController {
                 process.title = title;
                 renderIfRunning();
             },
-            custom: (async (factory) => await this.showCustomUi(factory)),
+            custom: (async (factory) => await this.showCustomUi(factory, { scopeKey: contextScopeKey })),
             pasteToEditor: (text) => {
                 this.host.setInput(text);
                 renderIfRunning();
@@ -219,7 +237,7 @@ export class ExtensionUiController {
                 renderIfRunning();
             },
             getEditorText: () => this.host.getInput(),
-            editor: async (title, prefill) => await this.editorDialog(title, prefill),
+            editor: async (title, prefill) => await this.editorDialog(title, prefill, contextScopeKey),
             addAutocompleteProvider: () => undefined,
             setEditorComponent: () => undefined,
             getEditorComponent: () => undefined,
@@ -241,11 +259,11 @@ export class ExtensionUiController {
             },
         };
     }
-    setAboveInputWidget(key, content) {
-        this.setWidget(key, content, { placement: "aboveEditor" });
+    setAboveInputWidget(key, content, scopeKey = this.activeScopeKey()) {
+        this.setWidget(key, content, { placement: "aboveEditor", scopeKey });
     }
-    clearAboveInputWidget(key) {
-        this.setWidget(key, undefined, { placement: "aboveEditor" });
+    clearAboveInputWidget(key, scopeKey = this.activeScopeKey()) {
+        this.setWidget(key, undefined, { placement: "aboveEditor", scopeKey });
     }
     async selectDialog(title, options, opts) {
         if (opts?.signal?.aborted)
@@ -265,7 +283,7 @@ export class ExtensionUiController {
         });
         return selected === true;
     }
-    async inputDialog(title, placeholder, opts) {
+    async inputDialog(title, placeholder, opts, scopeKey = this.activeScopeKey()) {
         if (opts?.signal?.aborted)
             return undefined;
         return await this.editorBackedDialog({
@@ -274,21 +292,21 @@ export class ExtensionUiController {
             mode: "input",
             ...(placeholder === undefined ? {} : { placeholder }),
             ...(opts === undefined ? {} : { opts }),
-        });
+        }, scopeKey);
     }
-    async editorDialog(title, prefill = "") {
+    async editorDialog(title, prefill = "", scopeKey = this.activeScopeKey()) {
         return await this.editorBackedDialog({
             title,
             initialValue: prefill,
             mode: "editor",
-        });
+        }, scopeKey);
     }
-    async editorBackedDialog(options) {
+    async editorBackedDialog(options, scopeKey = this.activeScopeKey()) {
         if (options.opts?.signal?.aborted)
             return undefined;
         if (!this.host.isRunning())
             return undefined;
-        if (this.activeCustomUi)
+        if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = this.host.getInput();
         this.host.setInput(options.initialValue);
@@ -315,9 +333,9 @@ export class ExtensionUiController {
                     return { consume: false, data };
                 },
             };
-        }, { savedInput });
+        }, { savedInput, scopeKey });
         return await this.withDialogAutoDismiss(promise, options.opts, () => {
-            this.cancelActiveCustomUi();
+            this.cancelActiveCustomUi(scopeKey);
         });
     }
     renderEditorBackedDialog(options, width) {
@@ -356,7 +374,8 @@ export class ExtensionUiController {
     async showCustomUi(factory, options = {}) {
         if (!this.host.isRunning())
             return undefined;
-        if (this.activeCustomUi)
+        const scopeKey = this.normalizeScopeKey(options.scopeKey);
+        if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = options.savedInput ?? this.host.getInput();
         return await new Promise((resolve, reject) => {
@@ -365,7 +384,7 @@ export class ExtensionUiController {
                 if (settled)
                     return;
                 settled = true;
-                this.finishActiveCustomUi(value, { resolve: true });
+                this.finishActiveCustomUi(scopeKey, value, { resolve: true });
                 resolve(value);
             };
             void (async () => {
@@ -375,8 +394,9 @@ export class ExtensionUiController {
                         component.dispose?.();
                         return;
                     }
-                    this.activeCustomUi = {
+                    this.activeCustomUis.set(scopeKey, {
                         key: CUSTOM_UI_WIDGET_KEY,
+                        scopeKey,
                         component,
                         savedInput,
                         resolve: (value) => {
@@ -391,7 +411,7 @@ export class ExtensionUiController {
                             settled = true;
                             reject(error);
                         },
-                    };
+                    });
                     if (this.host.isRunning())
                         this.host.render();
                 }
@@ -404,17 +424,20 @@ export class ExtensionUiController {
             })();
         });
     }
-    cancelActiveCustomUi() {
-        this.finishActiveCustomUi(undefined, { resolve: true });
+    cancelActiveCustomUi(scopeKey = this.activeScopeKey()) {
+        this.finishActiveCustomUi(scopeKey, undefined, { resolve: true });
     }
     rejectActiveCustomUi(error) {
-        this.finishActiveCustomUi(error, { resolve: false });
+        const active = this.activeCustomUiForActiveScope();
+        if (!active)
+            return;
+        this.finishActiveCustomUi(active.scopeKey, error, { resolve: false });
     }
-    finishActiveCustomUi(value, options) {
-        const active = this.activeCustomUi;
+    finishActiveCustomUi(scopeKey, value, options) {
+        const active = this.activeCustomUis.get(scopeKey);
         if (!active)
             return;
-        this.activeCustomUi = undefined;
+        this.activeCustomUis.delete(scopeKey);
         if (this.host.getInput() !== active.savedInput)
             this.host.setInput(active.savedInput);
         try {
@@ -436,6 +459,21 @@ export class ExtensionUiController {
         if (this.host.isRunning())
             this.host.render();
     }
+    activeCustomUiForActiveScope() {
+        return this.activeCustomUis.get(this.activeScopeKey());
+    }
+    activeScopeKey() {
+        return this.normalizeScopeKey(this.host.activeExtensionUiScope?.());
+    }
+    normalizeScopeKey(scopeKey) {
+        return scopeKey ?? "";
+    }
+    scopedWidgetKey(scopeKey, key) {
+        return `${scopeKey.length}:${scopeKey}:${key}`;
+    }
+    unscopedWidgetKey(scopedKey, scopeKey) {
+        return scopedKey.slice(`${scopeKey.length}:${scopeKey}:`.length);
+    }
     invalidateWidget(widget) {
         try {
             widget.component?.dispose?.();

package/dist/app/icons.d.ts

@@ -14,6 +14,7 @@ declare const NERD_FONT_ICONS: {
     readonly info: "󰋼";
     readonly microphone: "󰍬";
     readonly plus: "󰐕";
+    readonly pause: "󰏤";
     readonly record: "󰑊";
     readonly refresh: "󰑐";
     readonly volumeHigh: "󰕾";

package/dist/app/icons.js

@@ -20,6 +20,7 @@ const NERD_FONT_ICONS = {
     info: "\u{f02fc}",
     microphone: "\u{f036c}",
     plus: "\u{f0415}",
+    pause: "\u{f03e4}",
     record: "\u{f044a}",
     refresh: "\u{f0450}",
     volumeHigh: "\u{f057e}",
@@ -45,6 +46,7 @@ const FALLBACK_ICONS = {
     info: "i",
     microphone: "m",
     plus: "+",
+    pause: "⏸",
     record: "●",
     refresh: "↻",
     volumeHigh: "♪",

package/dist/app/input/input-action-controller.d.ts

@@ -39,6 +39,7 @@ export declare class AppInputActionController {
     queueInputFromEditor(): Promise<void>;
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
+    private closeActiveGlobalUi;
     private abortStreamingSession;
     private restoreSessionState;
     private sessionActivity;

package/dist/app/input/input-action-controller.js

@@ -63,6 +63,8 @@ export class AppInputActionController {
         await this.host.stop();
     }
     async handleEscape() {
+        if (this.closeActiveGlobalUi())
+            return;
         const session = this.host.runtime()?.session;
         if (session?.isCompacting) {
             this.host.setStatus("aborting compaction");
@@ -76,8 +78,12 @@ export class AppInputActionController {
                 await this.abortStreamingSession(runtime, { stopIfAlreadyAborting: false });
             return;
         }
-        if (this.popupMenus.syncActivePopupMenu())
-            this.popupMenus.cancelActivePopupMenu();
+    }
+    closeActiveGlobalUi() {
+        if (!this.popupMenus.syncActivePopupMenu())
+            return false;
+        this.popupMenus.cancelActivePopupMenu();
+        return true;
     }
     async abortStreamingSession(runtime, options) {
         const session = runtime.session;

package/dist/app/input/prompt-enhancer-controller.d.ts

@@ -1,4 +1,4 @@
-import { type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionServices, SessionManager, type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
 import type { PromptEnhancerConfig } from "../../config.js";
 import type { InputEditor } from "../../input-editor.js";
 import type { ToastNotifier } from "../../ui.js";
@@ -19,6 +19,12 @@ export type AppPromptEnhancerControllerHost = {
     render(): void;
 };
 type PromptEnhanceRunner = typeof enhancePromptWithPi;
+type PromptEnhancerPiDeps = {
+    createAgentSessionServices: typeof createAgentSessionServices;
+    createAgentSessionFromServices: typeof createAgentSessionFromServices;
+    sessionManagerInMemory: typeof SessionManager.inMemory;
+};
+export declare function setPromptEnhancerPiTestDeps(overrides?: Partial<PromptEnhancerPiDeps>): void;
 type AppPromptEnhancerControllerOptions = {
     enhancePromptWithPi?: PromptEnhanceRunner;
 };

package/dist/app/input/prompt-enhancer-controller.js

@@ -11,6 +11,15 @@ Do not add unsupported assumptions.
 Add useful constraints, acceptance criteria, and context requests when helpful.
 Output only the improved prompt. No commentary, no markdown fences.`;
 const PROMPT_ENHANCER_MIN_TEXT_LENGTH = 3;
+const defaultPromptEnhancerPiDeps = {
+    createAgentSessionServices,
+    createAgentSessionFromServices,
+    sessionManagerInMemory: SessionManager.inMemory,
+};
+let promptEnhancerPiDeps = defaultPromptEnhancerPiDeps;
+export function setPromptEnhancerPiTestDeps(overrides) {
+    promptEnhancerPiDeps = overrides ? { ...defaultPromptEnhancerPiDeps, ...overrides } : defaultPromptEnhancerPiDeps;
+}
 export class AppPromptEnhancerController {
     host;
     enhancing = false;
@@ -115,7 +124,7 @@ export function promptEnhancerTextIsSufficient(text) {
 }
 async function enhancePromptWithPi(runtime, draft, config) {
     const parsedModel = parseModelRef(config.modelRef);
-    const services = await createAgentSessionServices({
+    const services = await promptEnhancerPiDeps.createAgentSessionServices({
         cwd: runtime.cwd,
         agentDir: runtime.services.agentDir,
         authStorage: runtime.services.authStorage,
@@ -135,9 +144,9 @@ async function enhancePromptWithPi(runtime, draft, config) {
     if (!model) {
         throw new Error(modelNotFoundMessage(parsedModel.provider, parsedModel.modelId, services.modelRegistry.getAll()));
     }
-    const { session } = await createAgentSessionFromServices({
+    const { session } = await promptEnhancerPiDeps.createAgentSessionFromServices({
         services,
-        sessionManager: SessionManager.inMemory(runtime.cwd),
+        sessionManager: promptEnhancerPiDeps.sessionManagerInMemory(runtime.cwd),
         model,
         thinkingLevel: parsedModel.thinkingLevel ?? "minimal",
         noTools: "all",