pi-ui-extend 1.0.1 → 1.0.4

package/README.md

@@ -439,7 +439,7 @@ cd /path/to/project
 pix
 ```
 
-`/idx-update` updates the globally installed `indexer-cli`; it does not refresh a project's index.
+When `indexer-cli` is installed and available on `PATH`, Pix checks it at startup and runs its official updater when needed. Pix silently skips this check when `idx` is absent. `/idx-update` remains available for a manual retry; neither flow refreshes a project's index.
 
 ### An extension behaves differently
 

package/dist/app/app.d.ts

@@ -72,7 +72,7 @@ export declare class PiUiExtendApp {
     private applyPixConfig;
     private updateOutputFilters;
     start(): Promise<void>;
-    private checkPixUpdateOnStartup;
+    private checkUpdatesOnStartup;
     private bindCurrentSession;
     private awaitCurrentSessionExtensions;
     private activateRuntime;

package/dist/app/app.js

@@ -43,6 +43,7 @@ import { AppTerminalController } from "./terminal/terminal-controller.js";
 import { TerminalBellSoundController } from "./terminal/terminal-bell-sound-controller.js";
 import { AppToastController } from "./rendering/toast-controller.js";
 import { checkPiUpdate, checkPixUpdate, formatPixStartupUpdateDialog, formatPiStartupUpdateToast } from "./cli/update.js";
+import { checkAndUpdateIdxOnStartup, formatIdxStartupUpdateNotice } from "./cli/startup-checks.js";
 import { AppVoiceController } from "./input/voice-controller.js";
 import { createIsolatedExtensionEventBus } from "./extensions/extension-event-bus.js";
 import { setAppIconTheme } from "./icons.js";
@@ -864,9 +865,21 @@ export class PiUiExtendApp {
         await this.sessionLifecycle.start();
         this.modelUsageController.startPolling();
         this.nerdFontController.ensureInstalledOnStartup();
-        this.checkPixUpdateOnStartup();
+        this.checkUpdatesOnStartup();
     }
-    checkPixUpdateOnStartup() {
+    checkUpdatesOnStartup() {
+        void checkAndUpdateIdxOnStartup()
+            .then((result) => {
+            if (!this.running)
+                return;
+            const notice = formatIdxStartupUpdateNotice(result);
+            if (!notice)
+                return;
+            this.showToast(notice, result.status === "updated" ? "success" : "warning");
+        })
+            .catch(() => {
+            // Startup update checks should never interrupt the TUI.
+        });
         void checkPiUpdate()
             .then((result) => {
             if (result.status !== "newer")

package/dist/app/cli/startup-checks.d.ts

@@ -3,7 +3,29 @@ export type StartupAvailabilityIssue = {
     kind: "warning" | "error";
     message: string;
 };
+export type IdxStartupUpdateStatus = "current" | "updated" | "checked" | "skipped" | "unavailable" | "failed";
+export type IdxStartupUpdateResult = {
+    status: IdxStartupUpdateStatus;
+    previousVersion?: string;
+    currentVersion?: string;
+    reason?: string;
+};
+type IdxUpdateCommandResult = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    timedOut?: boolean;
+};
+export type IdxStartupUpdateOptions = {
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+    runUpdate?: (timeoutMs: number, env: NodeJS.ProcessEnv) => Promise<IdxUpdateCommandResult>;
+};
 export declare function collectStartupAvailabilityIssues(runtime: AgentSessionRuntime): Promise<StartupAvailabilityIssue[]>;
 export declare function checkSelectedModelAuthAvailability(runtime: AgentSessionRuntime): StartupAvailabilityIssue[];
 export declare function checkPiCliAvailability(pathValue?: string): Promise<StartupAvailabilityIssue[]>;
+export declare function checkAndUpdateIdxOnStartup(options?: IdxStartupUpdateOptions): Promise<IdxStartupUpdateResult>;
+export declare function formatIdxStartupUpdateNotice(result: IdxStartupUpdateResult): string | undefined;
 export declare function checkPiToolsSuiteExtensionAvailability(extensionsResult: LoadExtensionsResult): StartupAvailabilityIssue[];
+export {};

package/dist/app/cli/startup-checks.js

@@ -1,8 +1,12 @@
+import { spawn } from "node:child_process";
 import { access } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { constants as fsConstants } from "node:fs";
 const PI_CLI_COMMAND = "pi";
 const PI_TOOLS_SUITE_EXTENSION_ID = "pi-tools-suite";
+const IDX_CLI_COMMAND = "idx";
+const IDX_UPDATE_TIMEOUT_MS = 600_000;
+const MAX_IDX_UPDATE_OUTPUT_BYTES = 32_000;
 export async function collectStartupAvailabilityIssues(runtime) {
     return [
         ...(await checkPiCliAvailability()),
@@ -33,6 +37,60 @@ export async function checkPiCliAvailability(pathValue = process.env.PATH ?? "")
             message: "pi CLI is not available on PATH. Run `pix install` or add pi to PATH before starting pix.",
         }];
 }
+export async function checkAndUpdateIdxOnStartup(options = {}) {
+    const env = options.env ?? process.env;
+    const disabledReason = startupVersionCheckDisabledReason(env);
+    if (disabledReason)
+        return { status: "skipped", reason: disabledReason };
+    if (!options.runUpdate && !(await executableExistsOnPath(IDX_CLI_COMMAND, env.PATH ?? ""))) {
+        return { status: "unavailable" };
+    }
+    let commandResult;
+    try {
+        commandResult = await (options.runUpdate ?? runIdxUpdate)(options.timeoutMs ?? IDX_UPDATE_TIMEOUT_MS, env);
+    }
+    catch (error) {
+        if (isCommandNotFoundError(error)) {
+            return { status: "unavailable" };
+        }
+        return { status: "failed", reason: errorMessage(error) };
+    }
+    const output = [commandResult.stdout, commandResult.stderr].filter(Boolean).join("\n").trim();
+    if (commandResult.timedOut) {
+        return { status: "failed", reason: compactCommandFailure("idx update timed out", output) };
+    }
+    if (commandResult.code !== 0) {
+        const termination = commandResult.signal
+            ? `idx update terminated by signal ${commandResult.signal}`
+            : `idx update exited with code ${commandResult.code ?? "unknown"}`;
+        return { status: "failed", reason: compactCommandFailure(termination, output) };
+    }
+    const updatedVersions = parseUpdatedIdxVersions(output);
+    if (updatedVersions)
+        return { status: "updated", ...updatedVersions };
+    const currentVersion = parseCurrentIdxVersion(output);
+    if (currentVersion)
+        return { status: "current", currentVersion };
+    return { status: "checked" };
+}
+export function formatIdxStartupUpdateNotice(result) {
+    switch (result.status) {
+        case "updated": {
+            if (!result.currentVersion)
+                return "idx was updated to the latest version.";
+            const previousVersion = result.previousVersion ? ` from ${result.previousVersion}` : "";
+            return `idx updated${previousVersion} to ${result.currentVersion}.`;
+        }
+        case "unavailable":
+            return undefined;
+        case "failed":
+            return `idx startup update failed: ${result.reason ?? "unknown error"}`;
+        case "current":
+        case "checked":
+        case "skipped":
+            return undefined;
+    }
+}
 export function checkPiToolsSuiteExtensionAvailability(extensionsResult) {
     if (extensionsResult.extensions.some(isPiToolsSuiteExtension))
         return [];
@@ -64,6 +122,95 @@ async function executableExistsOnPath(command, pathValue) {
     }
     return false;
 }
+async function runIdxUpdate(timeoutMs, env) {
+    return await new Promise((resolve, reject) => {
+        const invocation = idxUpdateInvocation(env);
+        const child = spawn(invocation.command, invocation.args, {
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        timer.unref();
+        child.stdout?.on("data", (chunk) => {
+            stdout = appendBoundedOutput(stdout, chunk.toString());
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr = appendBoundedOutput(stderr, chunk.toString());
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, signal, stdout, stderr, ...(timedOut ? { timedOut: true } : {}) });
+        });
+    });
+}
+function idxUpdateInvocation(env) {
+    if (process.platform !== "win32")
+        return { command: IDX_CLI_COMMAND, args: ["update"] };
+    const commandProcessor = env.ComSpec ?? env.COMSPEC ?? process.env.ComSpec ?? process.env.COMSPEC ?? "cmd.exe";
+    return { command: commandProcessor, args: ["/d", "/s", "/c", `${IDX_CLI_COMMAND} update`] };
+}
+function appendBoundedOutput(existing, addition) {
+    const combined = `${existing}${addition}`;
+    if (Buffer.byteLength(combined, "utf8") <= MAX_IDX_UPDATE_OUTPUT_BYTES)
+        return combined;
+    return Buffer.from(combined, "utf8").subarray(-MAX_IDX_UPDATE_OUTPUT_BYTES).toString("utf8").replace(/^\uFFFD/u, "");
+}
+function parseUpdatedIdxVersions(output) {
+    const match = output.match(/(?:Updating|Updated) indexer-cli\s+v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\s*(?:→|->)\s*v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/iu);
+    const previousVersion = match?.[1];
+    const currentVersion = match?.[2];
+    if (!previousVersion || !currentVersion)
+        return undefined;
+    return { previousVersion, currentVersion };
+}
+function parseCurrentIdxVersion(output) {
+    return output.match(/already up to date\s*\(v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\)/iu)?.[1];
+}
+function startupVersionCheckDisabledReason(env) {
+    if (truthyEnv(env.PI_OFFLINE))
+        return "PI_OFFLINE is set";
+    if (truthyEnv(env.PI_SKIP_VERSION_CHECK))
+        return "PI_SKIP_VERSION_CHECK is set";
+    if (truthyEnv(env.PIX_SKIP_VERSION_CHECK))
+        return "PIX_SKIP_VERSION_CHECK is set";
+    return undefined;
+}
+function truthyEnv(value) {
+    if (!value)
+        return false;
+    return !["0", "false", "no", "off"].includes(value.toLowerCase());
+}
+function isCommandNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function compactCommandFailure(prefix, output) {
+    if (!output)
+        return prefix;
+    const singleLine = output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).slice(-4).join(" | ");
+    const summary = singleLine.length > 900 ? `${singleLine.slice(0, 897)}...` : singleLine;
+    return `${prefix}: ${summary}`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function isPiToolsSuiteExtension(extension) {
     return [
         extension.path,

package/dist/app/rendering/tool-block-renderer.js

@@ -27,39 +27,34 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const headerPrefix = headerLabel ? `${stateIcon} ${headerLabel}` : stateIcon;
     const headerArgs = formatToolHeaderArgs(entry.headerArgs);
     const headerArgsWidth = width - stringDisplayWidth(headerPrefix) - 1;
-    const clippedHeaderArgs = headerArgsWidth > 0 ? sliceByDisplayWidth(headerArgs, headerArgsWidth) : "";
-    const header = clippedHeaderArgs ? `${headerPrefix} ${clippedHeaderArgs}` : headerPrefix;
-    const headerArgsStart = headerPrefix.length + 1;
-    const clippedHeaderArgSegments = clippedHeaderArgs
-        ? clipAndShiftSegments(entry.headerArgSegments, headerArgsStart, clippedHeaderArgs.length)
-        : [];
-    const headerArgBaseSegments = clippedHeaderArgs
-        ? uncoveredSegments(headerArgsStart, header.length, toolOutputColor, clippedHeaderArgSegments)
-        : [];
     const target = { kind: "tool", id: entry.id };
     const showGutter = options.showGutter ?? true;
-    const headerLine = {
-        text: header,
+    const headerLines = renderToolHeaderLines({
+        entry,
+        expanded,
+        headerPrefix,
+        headerArgs,
+        headerArgsWidth,
+        stateIcon,
+        width,
         target,
-        colorOverride: toolColor,
-        ...(options.backgroundOverride && !options.skipHeaderBackground ? { backgroundOverride: options.backgroundOverride } : {}),
-        segments: [
-            { start: 0, end: stateIcon.length, foreground: toolStatusIconColor(entry, colors), bold: true },
-            { start: stateIcon.length, end: headerPrefix.length, bold: true },
-            ...headerArgBaseSegments,
-            ...clippedHeaderArgSegments,
-        ],
-    };
-    const headerLines = [headerLine];
+        toolColor,
+        toolOutputColor,
+        statusIconColor: toolStatusIconColor(entry, colors),
+        backgroundOverride: options.backgroundOverride && !options.skipHeaderBackground ? options.backgroundOverride : undefined,
+    });
+    const headerLine = headerLines[0];
+    if (!headerLine)
+        return [];
     if (expanded) {
-        headerLines.push(...renderToolBodyLines(entry.expandedText, width, target, toolOutputColor, entry.bodyStyle, colors, entry.syntaxHighlight, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter));
-        if (options.skipHeaderBackground && headerLines.length > 1) {
-            applyBackground(headerLines.slice(1));
+        const bodyLines = renderToolBodyLines(entry.expandedText, width, target, toolOutputColor, entry.bodyStyle, colors, entry.syntaxHighlight, entry.bodyWrap, hasLspDiagnostics, entry.bodyLineStyles, entry.preserveAnsi, showGutter);
+        if (options.skipHeaderBackground) {
+            applyBackground(bodyLines);
         }
         else {
-            applyBackground(headerLines);
+            applyBackground([...headerLines, ...bodyLines]);
         }
-        return headerLines;
+        return [...headerLines, ...bodyLines];
     }
     if (rule.compactHidden || (rule.defaultExpanded === true && !options.superCompact))
         return headerLines;
@@ -75,7 +70,7 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     if (!preview.text)
         return headerLines;
     const separator = " — ";
-    const availablePreviewWidth = width - stringDisplayWidth(header) - stringDisplayWidth(separator);
+    const availablePreviewWidth = width - stringDisplayWidth(headerLine.text) - stringDisplayWidth(separator);
     if (availablePreviewWidth <= 0)
         return headerLines;
     const markerPrefix = truncatedPreviewMarker();
@@ -83,8 +78,8 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     const clippedPreview = sliceByDisplayWidth(previewText, availablePreviewWidth);
     if (!clippedPreview)
         return headerLines;
-    headerLine.text = `${header}${separator}${clippedPreview}`;
-    const previewStart = header.length + separator.length;
+    headerLine.text = `${headerLine.text}${separator}${clippedPreview}`;
+    const previewStart = headerLine.text.length - clippedPreview.length;
     const previewTextStart = previewStart + (preview.overflow ? markerPrefix.length : 0);
     headerLine.segments = [
         ...(headerLine.segments ?? []),
@@ -93,15 +88,54 @@ export function renderToolBlock(entry, rule, width, colors, options = {}) {
     ];
     return headerLines;
 }
-function clipAndShiftSegments(segments, offset, length) {
-    if (!segments || length <= 0)
+function renderToolHeaderLines(input) {
+    const visibleArgs = input.expanded
+        ? indexedWrappedText(input.headerArgs, Math.max(1, input.headerArgsWidth))
+        : indexedClippedText(input.headerArgs, input.headerArgsWidth);
+    const chunks = visibleArgs.length > 0 ? visibleArgs : [{ text: "", start: 0, end: 0 }];
+    const continuationIndent = " ".repeat(Math.min(stringDisplayWidth(input.headerPrefix) + 1, Math.max(0, input.width - 1)));
+    return chunks.map((chunk, index) => {
+        let linePrefix = continuationIndent;
+        if (index === 0)
+            linePrefix = chunk.text ? `${input.headerPrefix} ` : input.headerPrefix;
+        const text = `${linePrefix}${chunk.text}`;
+        const argStart = linePrefix.length;
+        const customSegments = input.entry.headerArgSegments
+            ?.flatMap((segment) => shiftSegmentToRange(segment, chunk.start, chunk.end))
+            .map((segment) => ({ ...segment, start: segment.start + argStart, end: segment.end + argStart })) ?? [];
+        const baseSegments = uncoveredSegments(argStart, text.length, input.toolOutputColor, customSegments);
+        return {
+            text,
+            target: input.target,
+            colorOverride: input.toolColor,
+            ...(input.backgroundOverride ? { backgroundOverride: input.backgroundOverride } : {}),
+            segments: [
+                ...(index === 0 ? [
+                    { start: 0, end: input.stateIcon.length, foreground: input.statusIconColor, bold: true },
+                    { start: input.stateIcon.length, end: input.headerPrefix.length, bold: true },
+                ] : []),
+                ...baseSegments,
+                ...customSegments,
+            ],
+        };
+    });
+}
+function indexedClippedText(text, width) {
+    if (width <= 0)
+        return [];
+    const clipped = sliceByDisplayWidth(text, width);
+    return clipped ? [{ text: clipped, start: 0, end: clipped.length }] : [];
+}
+function indexedWrappedText(text, width) {
+    if (!text)
         return [];
-    return segments.flatMap((segment) => {
-        const start = Math.max(0, segment.start);
-        const end = Math.min(length, segment.end);
-        if (end <= start)
-            return [];
-        return [{ ...segment, start: offset + start, end: offset + end }];
+    let cursor = 0;
+    return wrapDisplayLineByWords(text, width).map((chunk) => {
+        const foundAt = text.indexOf(chunk, cursor);
+        const start = foundAt >= 0 ? foundAt : cursor;
+        const end = start + chunk.length;
+        cursor = end;
+        return { text: chunk, start, end };
     });
 }
 function uncoveredSegments(start, end, foreground, coveredSegments) {

package/dist/bundled-extensions/session-title/index.js

@@ -81,6 +81,7 @@ export default function sessionTitle(pi) {
     const refreshTimers = new Set();
     let pendingGeneration;
     let forkTitleState;
+    let resourceCommandTitleSessionId;
     function abortCurrentRequest() {
         controller?.abort();
         controller = undefined;
@@ -349,6 +350,7 @@ export default function sessionTitle(pi) {
         sessionId = ctx.sessionManager.getSessionId();
         pendingGeneration = undefined;
         forkTitleState = undefined;
+        resourceCommandTitleSessionId = undefined;
         lastRenderedName = undefined;
         lastRenderedTitle = undefined;
         refreshSessionUi(ctx, { force: true });
@@ -360,6 +362,7 @@ export default function sessionTitle(pi) {
         clearRetryTimer();
         clearRefreshTimers();
         forkTitleState = undefined;
+        resourceCommandTitleSessionId = undefined;
     });
     function refreshOnEvent(ctx) {
         refreshSessionUi(ctx);
@@ -378,24 +381,33 @@ export default function sessionTitle(pi) {
         scheduleSessionUiRefresh(ctx);
         if (event.source === "extension")
             return { action: "continue" };
-        const fallbackInput = fallbackTitleInputFromPrompt(event.text, event.images);
-        if (!fallbackInput)
-            return { action: "continue" };
-        const titleInput = titleGenerationInputFromPrompt(event.text, event.images) ?? fallbackInput;
-        if (event.text.trimStart().startsWith("/"))
-            return { action: "continue" };
         const currentSessionId = ctx.sessionManager.getSessionId();
         sessionId = currentSessionId;
         const currentName = currentSessionName(ctx);
         const activeForkTitleState = forkTitleState?.sessionId === currentSessionId ? forkTitleState : undefined;
-        if (!activeForkTitleState && hasExistingUserMessage(ctx)) {
+        if (event.text.trimStart().startsWith("/")) {
+            if (!activeForkTitleState
+                && !currentName
+                && (resourceCommandTitleSessionId === currentSessionId || !hasExistingUserMessage(ctx))) {
+                resourceCommandTitleSessionId = currentSessionId;
+            }
+            return { action: "continue" };
+        }
+        const fallbackInput = fallbackTitleInputFromPrompt(event.text, event.images);
+        if (!fallbackInput)
+            return { action: "continue" };
+        const titleInput = titleGenerationInputFromPrompt(event.text, event.images) ?? fallbackInput;
+        const titleEligibleAfterResourceCommand = resourceCommandTitleSessionId === currentSessionId;
+        if (!activeForkTitleState && !titleEligibleAfterResourceCommand && hasExistingUserMessage(ctx)) {
             forkTitleState = undefined;
             return { action: "continue" };
         }
         if (currentName && (!activeForkTitleState || currentName !== activeForkTitleState.inheritedSessionName)) {
             forkTitleState = undefined;
+            resourceCommandTitleSessionId = undefined;
             return { action: "continue" };
         }
+        resourceCommandTitleSessionId = undefined;
         if (!currentConfig.enabled) {
             applyFallbackSessionTitle(ctx, currentConfig, activeForkTitleState
                 ? buildForkTitleInput(activeForkTitleState.parentTitle, fallbackInput)

package/external/pi-tools-suite/package.json

@@ -43,9 +43,9 @@
     "vscode-languageserver-protocol": "^3.17.5"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "0.82.1",
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.83.0",
+    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@earendil-works/pi-tui": "0.83.0",
     "typebox": "*"
   },
   "devDependencies": {

package/external/pi-tools-suite/src/antigravity-auth/stream.ts

@@ -132,7 +132,7 @@ export function streamAntigravity(model: AntigravityModel, context: Context, opt
 			provider: model.provider,
 			model: model.id,
 			usage: baseUsage(),
-			stopReason: "stop",
+			stopReason: "pending",
 			timestamp: Date.now(),
 		};
 
@@ -258,12 +258,16 @@ export function streamAntigravity(model: AntigravityModel, context: Context, opt
 						stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 					}
 				}
-				if (candidate?.finishReason) output.stopReason = mapStopReason(candidate.finishReason);
-				if (output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
+				if (candidate?.finishReason) {
+					output.rawStopReason = candidate.finishReason;
+					output.stopReason = mapStopReason(candidate.finishReason);
+					if (output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
+				}
 			}
 			closeOpenText();
 			closeOpenThinking();
 			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "pending") throw new Error("Antigravity stream ended without a finish reason");
 			if (output.stopReason === "error" || output.stopReason === "aborted") throw new Error("Antigravity stopped with an error finish reason");
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {
@@ -75,9 +75,9 @@
     "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "0.82.1",
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.83.0",
+    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@earendil-works/pi-tui": "0.83.0",
     "@mariozechner/clipboard": "^0.3.9",
     "jsonc-parser": "3.3.1",
     "typebox": "1.1.38",