pi-ui-extend 0.1.9 → 0.1.13

package/dist/app/commands/command-model-actions.js

@@ -1,4 +1,5 @@
 import { getIdleRuntime, getRuntime } from "./command-runtime.js";
+import { savePixAutocompleteModel, savePixDefaultModel, savePixDefaultThinking } from "../../config.js";
 import { createId } from "../id.js";
 import { isThinkingLevel, parseScopedModelRef } from "../model/model-ref.js";
 export class ModelCommandActions {
@@ -22,6 +23,7 @@ export class ModelCommandActions {
             `session: ${runtime.session.sessionFile ?? "in-memory"}`,
             `model: ${currentModel}`,
             `prompt enhancer model: ${this.host.promptEnhancerModelRef()}`,
+            `autocomplete model: ${this.host.autocompleteModelRef() || "disabled"}`,
             `thinking: ${runtime.session.thinkingLevel}`,
             `theme: ${settings.getTheme() ?? this.host.options.themeName}`,
             `skill commands: ${settings.getEnableSkillCommands() ? "enabled" : "disabled"}`,
@@ -70,6 +72,59 @@ export class ModelCommandActions {
             this.host.setSessionStatus(runtime.session);
         }
     }
+    async runDefaultModelSlashCommand(argumentsText) {
+        const modelRef = argumentsText.trim();
+        if (!modelRef) {
+            const selected = await this.host.showMenu(this.host.getModelMenuItems(""), {
+                title: "Select default model",
+                placeholder: "Search models",
+                emptyText: "No matching models",
+            });
+            if (!selected) {
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.render();
+                return;
+            }
+            this.saveDefaultModel(this.host.modelRef(selected.model));
+            this.host.render();
+            return;
+        }
+        const runtime = getRuntime(this.host, "default-model");
+        if (!runtime)
+            return;
+        const parsed = parseScopedModelRef(modelRef);
+        if (!parsed)
+            throw new Error("Model must use provider/model[:thinking] format");
+        runtime.services.modelRegistry.refresh();
+        const model = runtime.services.modelRegistry.find(parsed.provider, parsed.modelId);
+        if (!model)
+            throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
+        this.saveDefaultModel(modelRef);
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runAutocompleteSlashCommand(argumentsText) {
+        const modelRef = argumentsText.trim();
+        if (!modelRef) {
+            const saved = savePixAutocompleteModel("");
+            this.host.setAutocompleteModelRef(saved.modelRef);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: saved.modelRef ? `Autocomplete model set to ${saved.modelRef}` : "Inline autocomplete disabled." });
+            return;
+        }
+        const runtime = getRuntime(this.host, "autocomplete");
+        if (!runtime)
+            return;
+        const parsed = parseScopedModelRef(modelRef);
+        if (!parsed)
+            throw new Error("Model must use provider/model[:thinking] format, or run /autocomplete with no arguments to disable");
+        runtime.services.modelRegistry.refresh();
+        const model = runtime.services.modelRegistry.find(parsed.provider, parsed.modelId);
+        if (!model)
+            throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
+        const saved = savePixAutocompleteModel(modelRef);
+        this.host.setAutocompleteModelRef(saved.modelRef);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Autocomplete model set to ${saved.modelRef}.` });
+        this.host.setSessionStatus(runtime.session);
+    }
     async runScopedModelsCommand(argumentsText) {
         const runtime = getIdleRuntime(this.host, "scoped-models");
         if (!runtime)
@@ -152,6 +207,27 @@ export class ModelCommandActions {
             throw new Error(`Unknown thinking level: ${level}`);
         await this.runThinkingCommand(level);
     }
+    async runDefaultThinkingSlashCommand(argumentsText) {
+        const level = argumentsText.trim();
+        if (!level) {
+            const selected = await this.host.showMenu(this.host.getThinkingMenuItems(""), {
+                title: "Select default thinking level",
+                placeholder: "Search thinking levels",
+                emptyText: "No matching thinking levels",
+            });
+            if (!selected) {
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.render();
+                return;
+            }
+            this.saveDefaultThinking(selected.level);
+            this.host.render();
+            return;
+        }
+        if (!isThinkingLevel(level))
+            throw new Error(`Unknown thinking level: ${level}`);
+        this.saveDefaultThinking(level);
+    }
     async runModelCommand(model) {
         const runtime = getRuntime(this.host, "model");
         if (!runtime)
@@ -173,4 +249,32 @@ export class ModelCommandActions {
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected thinking level ${runtime.session.thinkingLevel}` });
         this.host.setSessionStatus(runtime.session);
     }
+    saveDefaultModel(modelRef) {
+        const saved = savePixDefaultModel(modelRef);
+        if (!saved)
+            throw new Error("Model must use provider/model[:thinking] format");
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: `Default model set to ${formatDefaultModelRef(saved)}. New sessions will use it unless --model is provided.`,
+        });
+    }
+    saveDefaultThinking(level) {
+        const runtime = getRuntime(this.host, "default-thinking");
+        if (!runtime)
+            return;
+        const fallbackModelRef = runtime.session.model ? this.host.modelRef(runtime.session.model) : undefined;
+        const saved = savePixDefaultThinking(level, fallbackModelRef);
+        if (!saved)
+            throw new Error("Set /default-model first or select a session model before setting default thinking");
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: `Default thinking level set to ${saved.thinking ?? level} for ${saved.modelRef}. New sessions will use it unless --model is provided.`,
+        });
+        this.host.setSessionStatus(runtime.session);
+    }
+}
+function formatDefaultModelRef(defaultModel) {
+    return defaultModel.thinking ? `${defaultModel.modelRef}:${defaultModel.thinking}` : defaultModel.modelRef;
 }

package/dist/app/commands/command-navigation-actions.d.ts

@@ -1,8 +1,12 @@
+import type { SessionInfo } from "@earendil-works/pi-coding-agent";
 import type { CommandControllerHost } from "./command-host.js";
+import { type ResumeSessionLoaderOptions } from "../session/resume-session-loader.js";
 import type { PopupMenuPlacement } from "../types.js";
 export declare class NavigationCommandActions {
     private readonly host;
-    constructor(host: CommandControllerHost);
+    private readonly resumeSessionLoader;
+    private resumeLoadId;
+    constructor(host: CommandControllerHost, resumeSessionLoader?: (options: ResumeSessionLoaderOptions) => Promise<readonly SessionInfo[]>);
     runForkCommand(argumentsText: string): Promise<void>;
     runCloneCommand(): Promise<void>;
     runTreeCommand(argumentsText: string): Promise<void>;
@@ -14,6 +18,7 @@ export declare class NavigationCommandActions {
         preserveStatus?: boolean;
         placement?: PopupMenuPlacement;
     }): Promise<void>;
+    private loadResumeSessionsInBackground;
     private formatSessionTree;
     private describeSessionTreeEntry;
 }

package/dist/app/commands/command-navigation-actions.js

@@ -1,15 +1,23 @@
 import { resolve } from "node:path";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { getIdleRuntime, getRuntime } from "./command-runtime.js";
 import { createId } from "../id.js";
 import { isRecord } from "../guards.js";
 import { renderContent } from "../rendering/message-content.js";
 import { sanitizeText } from "../rendering/render-text.js";
 import { createSessionSearchMenuItems, searchSessions } from "../session/session-search.js";
+import { loadResumeSessionsInChunks } from "../session/resume-session-loader.js";
+function nextTick() {
+    return new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}
 export class NavigationCommandActions {
     host;
-    constructor(host) {
+    resumeSessionLoader;
+    resumeLoadId = 0;
+    constructor(host, resumeSessionLoader = loadResumeSessionsInChunks) {
         this.host = host;
+        this.resumeSessionLoader = resumeSessionLoader;
     }
     async runForkCommand(argumentsText) {
         const runtime = getIdleRuntime(this.host, "fork");
@@ -197,29 +205,44 @@ export class NavigationCommandActions {
             this.host.setStatus("loading sessions…");
         this.host.openDirectPopupMenu("resume", { preserveStatus, ...(placement === undefined ? {} : { placement }) });
         this.host.setDirectPopupMenuQuery(initialQuery);
+        if (this.host.getResumeSessions().length > 0) {
+            this.host.openResumeMenuWithQuery(initialQuery);
+        }
         this.host.render();
+        const loadId = ++this.resumeLoadId;
+        void this.loadResumeSessionsInBackground({ loadId, preserveStatus, session: runtime.session });
+    }
+    async loadResumeSessionsInBackground(options) {
         try {
-            const sessions = await SessionManager.list(this.host.options.cwd);
-            this.host.setResumeSessions(sessions);
-            this.host.setResumeLoading(false);
-            if (this.host.getDirectPopupMenu() !== "resume")
-                return;
-            this.host.openResumeMenuWithQuery(this.host.getDirectPopupMenuQuery());
-            if (!preserveStatus)
-                this.host.setSessionStatus(runtime.session);
-            this.host.render();
+            await nextTick();
+            await this.resumeSessionLoader({
+                cwd: this.host.options.cwd,
+                onChunk: (sessions, progress) => {
+                    if (options.loadId !== this.resumeLoadId)
+                        return;
+                    this.host.setResumeSessions([...sessions]);
+                    if (progress.done) {
+                        this.host.setResumeLoading(false);
+                        if (!options.preserveStatus)
+                            this.host.setSessionStatus(options.session);
+                    }
+                    this.host.render();
+                },
+            });
         }
         catch (error) {
+            if (options.loadId !== this.resumeLoadId)
+                return;
             this.host.setResumeLoading(false);
             this.host.setDirectPopupMenu(undefined);
             this.host.setDirectPopupMenuPreserveStatus(false);
             this.host.setDirectPopupMenuQuery("");
             this.host.closeResumeMenu();
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Session list failed: ${error instanceof Error ? error.message : String(error)}` });
-            if (!preserveStatus)
+            if (!options.preserveStatus)
                 this.host.toast.error("Failed to load sessions");
-            if (!preserveStatus)
-                this.host.setSessionStatus(runtime.session);
+            if (!options.preserveStatus)
+                this.host.setSessionStatus(options.session);
             this.host.render();
         }
     }

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

@@ -3,13 +3,17 @@ import type { SlashCommand } from "../types.js";
 export type CommandRegistryActions = {
     runSettingsCommand(): Promise<void>;
     runModelSlashCommand(argumentsText: string): Promise<void>;
+    runDefaultModelSlashCommand(argumentsText: string): Promise<void>;
+    runAutocompleteSlashCommand(argumentsText: string): Promise<void>;
     runScopedModelsCommand(argumentsText: string): Promise<void>;
     runThinkingSlashCommand(argumentsText: string): Promise<void>;
+    runDefaultThinkingSlashCommand(argumentsText: string): Promise<void>;
     runEnhanceCommand(): Promise<void>;
     runExportCommand(argumentsText: string): Promise<void>;
     runImportCommand(argumentsText: string): Promise<void>;
     runShareCommand(): Promise<void>;
     runCopyCommand(): Promise<void>;
+    runQueueCommand(argumentsText: string): Promise<void>;
     runNameCommand(argumentsText: string): Promise<void>;
     runSessionInfoCommand(): Promise<void>;
     runUsageCommand(): Promise<void>;

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

@@ -16,6 +16,22 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runModelSlashCommand(argumentsText),
         },
+        {
+            name: "default-model",
+            description: "Set the default model for new sessions",
+            kind: "builtin",
+            keywords: ["model", "provider", "startup", "config"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runDefaultModelSlashCommand(argumentsText),
+        },
+        {
+            name: "autocomplete",
+            description: "Set inline autocomplete model, or empty to disable",
+            kind: "builtin",
+            keywords: ["complete", "ghost", "suggest", "llm", "model"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runAutocompleteSlashCommand(argumentsText),
+        },
         {
             name: "scoped-models",
             description: "Show or set models used by the model selector/cycling",
@@ -32,6 +48,14 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runThinkingSlashCommand(argumentsText),
         },
+        {
+            name: "default-thinking",
+            description: "Set the default thinking level for new sessions",
+            kind: "builtin",
+            keywords: ["thinking", "reasoning", "startup", "config"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runDefaultThinkingSlashCommand(argumentsText),
+        },
         {
             name: "enhance",
             description: "Improve the current prompt draft",
@@ -69,6 +93,14 @@ export function createSlashCommands(actions, host) {
             keywords: ["clipboard", "assistant", "message"],
             run: () => actions.runCopyCommand(),
         },
+        {
+            name: "queue",
+            description: "Queue a message for manual sending later",
+            kind: "builtin",
+            keywords: ["defer", "delayed", "message", "send later"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runQueueCommand(argumentsText),
+        },
         {
             name: "name",
             description: "Show or set the session display name",

package/dist/app/commands/command-session-actions.d.ts

@@ -6,6 +6,7 @@ export declare class SessionCommandActions {
     runImportCommand(argumentsText: string): Promise<void>;
     runShareCommand(): Promise<void>;
     runCopyCommand(): Promise<void>;
+    runQueueCommand(argumentsText: string): Promise<void>;
     runNameCommand(argumentsText: string): Promise<void>;
     runSessionInfoCommand(): Promise<void>;
     runUsageCommand(): Promise<void>;

package/dist/app/commands/command-session-actions.js

@@ -1,11 +1,12 @@
-import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { copyToClipboard, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getIdleRuntime, getRuntime, parsePathArgument } from "./command-runtime.js";
 import { createId } from "../id.js";
+import { runProcess } from "../process.js";
+import { copyTextToClipboard } from "../screen/clipboard.js";
 import { formatAccountUsageReport, queryAccountUsageReport } from "../model/model-usage-status.js";
 import { checkPixUpdate, formatPixUpdateCheck, parsePixUpdateArgs, pixUpdateUsage } from "../cli/update.js";
 export class SessionCommandActions {
@@ -50,7 +51,7 @@ export class SessionCommandActions {
         const runtime = getIdleRuntime(this.host, "share");
         if (!runtime)
             return;
-        const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf8" });
+        const authResult = await runProcess("gh", ["auth", "status"], { maxBufferBytes: 32 * 1024 });
         if (authResult.status !== 0)
             throw new Error("GitHub CLI is not installed or is not logged in. Run `gh auth login` first.");
         const shareDir = join(getAgentDir(), "pix");
@@ -60,7 +61,7 @@ export class SessionCommandActions {
             this.host.setStatus("creating share gist");
             this.host.render();
             await runtime.session.exportToHtml(tmpFile);
-            const gistResult = spawnSync("gh", ["gist", "create", "--public=false", tmpFile], { encoding: "utf8" });
+            const gistResult = await runProcess("gh", ["gist", "create", "--public=false", tmpFile], { maxBufferBytes: 64 * 1024 });
             if (gistResult.status !== 0)
                 throw new Error(gistResult.stderr?.trim() || "Failed to create gist");
             const gistUrl = gistResult.stdout.trim();
@@ -79,11 +80,19 @@ export class SessionCommandActions {
         const text = runtime.session.getLastAssistantText();
         if (!text)
             throw new Error("No agent messages to copy yet");
-        await copyToClipboard(text);
+        await copyTextToClipboard(text);
         this.host.addEntry({ id: createId("system"), kind: "system", text: "Copied last agent message to clipboard." });
         this.host.setSessionStatus(runtime.session);
         this.host.toast.success("Copied last agent message");
     }
+    async runQueueCommand(argumentsText) {
+        const text = argumentsText.trim();
+        if (!text)
+            throw new Error("Usage: /queue <message to send later>");
+        this.host.queueUserMessage(text);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: "Queued message for manual sending." });
+        this.host.setSessionStatus(this.host.runtime()?.session);
+    }
     async runNameCommand(argumentsText) {
         const runtime = getRuntime(this.host, "name");
         if (!runtime)
@@ -201,6 +210,7 @@ export class SessionCommandActions {
                 "Enter: send message / run selected command",
                 "!command: run a local shell command in chat (not saved to the session)",
                 "while shell is running: Enter sends editor text to stdin; Ctrl-C interrupts; !!command uses the raw terminal",
+                "/queue <message>: save a delayed message; send it later from the queued-message menu or status button",
                 "Tab: autocomplete selected popup item",
                 "Esc: close popup; abort running work when input is empty",
                 "Up/Down: history or popup navigation",

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/commands/shell-controller.d.ts

@@ -9,6 +9,7 @@ export type AppShellControllerHost = {
     setSessionActivity(activity: SessionActivity): void;
     restoreSessionStatus(): void;
     render(): void;
+    scheduleRender(): void;
 };
 export declare class AppShellController {
     private readonly host;

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

@@ -89,7 +89,7 @@ export class AppShellController {
         this.renderTimer = setTimeout(() => {
             this.renderTimer = undefined;
             if (this.host.isRunning())
-                this.host.render();
+                this.host.scheduleRender();
         }, SHELL_RENDER_THROTTLE_MS);
         this.renderTimer.unref?.();
     }

package/dist/app/constants.d.ts

@@ -38,7 +38,7 @@ export declare const SUBAGENTS_POLL_INTERVAL_MS = 1500;
 export declare const SUBAGENTS_WIDGET_MAX_ROWS = 8;
 export declare const DEFAULT_THINKING_TOOL_RULE: ResolvedToolRule;
 export declare const TERMINAL_COMMAND_MODIFIER_FLAG = 8;
-export declare const GIT_BRANCH_CACHE_MS = 2000;
+export declare const GIT_BRANCH_CACHE_MS = 30000;
 export declare const TODO_TOOL_NAME = "todo";
 export declare const TODO_ACTIONS: readonly ["create", "update", "batch_create", "batch_update", "list", "get", "delete", "clear", "export", "import"];
 export declare const TODO_STATUSES: readonly ["pending", "in_progress", "deferred", "completed", "deleted"];

package/dist/app/constants.js

@@ -75,7 +75,7 @@ export const DEFAULT_THINKING_TOOL_RULE = {
     color: "accent",
 };
 export const TERMINAL_COMMAND_MODIFIER_FLAG = 8;
-export const GIT_BRANCH_CACHE_MS = 2_000;
+export const GIT_BRANCH_CACHE_MS = 30_000;
 export const TODO_TOOL_NAME = "todo";
 export const TODO_ACTIONS = [
     "create",

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: "♪",
@@ -53,7 +55,7 @@ const FALLBACK_ICONS = {
     compactTools: "≡",
     thinkingExpanded: ">",
     stopCircle: "■",
-    timerSand: "…",
+    timerSand: "⏳",
     down: "v",
 };
 export const APP_ICON_THEMES = {

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

@@ -0,0 +1,52 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteConfig } from "../../config.js";
+import type { InputEditor } from "../../input-editor.js";
+export type AppAutocompleteControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    inputEditor(): InputEditor;
+    autocompleteConfig(): AutocompleteConfig;
+    isRunning(): boolean;
+    render(): void;
+};
+export type AutocompleteHistoryMessage = {
+    role: "user" | "assistant";
+    text: string;
+};
+type AutocompleteRunner = typeof completeInputWithPi;
+export type AppAutocompleteControllerOptions = {
+    completeInputWithPi?: AutocompleteRunner;
+    debounceMs?: number;
+};
+export declare class AppAutocompleteController {
+    private readonly host;
+    private timer;
+    private lastObservedKey;
+    private requestSeq;
+    private suggestion;
+    private activeAbortController;
+    private readonly completeInputWithPi;
+    private readonly debounceOverrideMs;
+    constructor(host: AppAutocompleteControllerHost, options?: AppAutocompleteControllerOptions);
+    observeInput(): void;
+    suggestionText(): string | undefined;
+    acceptSuggestion(): boolean;
+    dispose(): void;
+    private runAutocomplete;
+    private currentTarget;
+    private targetKey;
+    private sameTarget;
+    private currentDebounceMs;
+    private clearTimer;
+    private cancelInFlight;
+}
+export declare function completeInputWithPi(runtime: AgentSessionRuntime, draft: string, config: AutocompleteConfig, signal?: AbortSignal): Promise<string>;
+export declare function autocompleteHistoryFromMessages(messages: readonly unknown[], includeRecentMessages: number): AutocompleteHistoryMessage[];
+export declare function buildAutocompletePrompt(input: {
+    cwd: string;
+    draft: string;
+    history: readonly AutocompleteHistoryMessage[];
+    maxPromptTokens?: number;
+}): string;
+export declare function autocompletePromptTokenEstimate(prompt: string, systemPrompt?: string): number;
+export declare function cleanupCompletion(output: string, draft: string, config?: Pick<AutocompleteConfig, "maxTokens">): string;
+export {};