pi-ui-extend 0.1.69 → 0.1.71

package/dist/app/terminal/terminal-controller.d.ts

@@ -2,6 +2,7 @@ import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
 export type AppTerminalControllerHost = {
     isRunning(): boolean;
     setRunning(running: boolean): void;
+    cancelPendingTabLifecycle(): void;
     runtime(): AgentSessionRuntime | undefined;
     saveInputStateForQuit(): Promise<void>;
     disposeInactiveRuntimesForQuit(): Promise<void>;
@@ -26,8 +27,10 @@ export declare class AppTerminalController {
     private stopPromise;
     private keyboardProtocolNegotiationBuffer;
     private keyboardProtocolBufferFlushTimer;
+    private inputDecoder;
     private kittyProtocolActive;
     private modifyOtherKeysActive;
+    private shutdownDeadlineAt;
     private readonly enterInteractiveSequence;
     private readonly exitInteractiveSequence;
     constructor(host: AppTerminalControllerHost);
@@ -41,6 +44,7 @@ export declare class AppTerminalController {
     private suspendForInteractiveProcess;
     private resumeAfterInteractiveProcess;
     private stopInternal;
+    private runBestEffort;
     private scheduleForcedProcessExit;
     private readonly onResize;
     private readonly onInputData;

package/dist/app/terminal/terminal-controller.js

@@ -1,3 +1,4 @@
+import { StringDecoder } from "node:string_decoder";
 import { ANSI_RESET } from "../../theme.js";
 import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_MODIFY_OTHER_KEYS, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RESET_TERMINAL_VIEWPORT_STATE, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
 export class AppTerminalController {
@@ -7,8 +8,10 @@ export class AppTerminalController {
     stopPromise;
     keyboardProtocolNegotiationBuffer = "";
     keyboardProtocolBufferFlushTimer;
+    inputDecoder = new StringDecoder("utf8");
     kittyProtocolActive = false;
     modifyOtherKeysActive = false;
+    shutdownDeadlineAt;
     enterInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}\x1b[?1049h${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`;
     exitInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`;
     constructor(host) {
@@ -38,10 +41,13 @@ export class AppTerminalController {
         await this.stopPromise;
     }
     async disposeRuntimeForQuit(runtime) {
+        const graceMs = this.shutdownDeadlineAt === undefined
+            ? RUNTIME_DISPOSE_GRACE_MS
+            : Math.max(0, this.shutdownDeadlineAt - Date.now());
         let timeout;
         const dispose = runtime.dispose().then(() => "disposed", () => "failed");
         const timeoutPromise = new Promise((resolveTimeout) => {
-            timeout = setTimeout(() => resolveTimeout("timeout"), RUNTIME_DISPOSE_GRACE_MS);
+            timeout = setTimeout(() => resolveTimeout("timeout"), graceMs);
         });
         const result = await Promise.race([dispose, timeoutPromise]);
         if (timeout)
@@ -106,30 +112,42 @@ export class AppTerminalController {
     async stopInternal() {
         if (!this.host.isRunning())
             return;
-        this.clearKeyboardProtocolNegotiationBuffer();
         this.host.setRunning(false);
+        this.host.cancelPendingTabLifecycle();
+        this.clearKeyboardProtocolNegotiationBuffer();
+        this.inputDecoder = new StringDecoder("utf8");
+        process.stdin.off("data", this.onInputData);
+        process.stdin.pause();
+        process.stdout.off("resize", this.onResize);
+        process.off("exit", this.restoreTerminal);
         this.host.closeSdkMenuForStop();
         this.host.clearToastTimers();
         this.host.stopBlinking();
         this.host.stopSubagentsPolling();
         this.host.stopModelUsagePolling();
-        await this.host.stopVoiceInput();
         this.host.stopAutocomplete();
         this.host.stopShellCommand();
-        process.stdin.off("data", this.onInputData);
-        process.stdin.pause();
-        process.stdout.off("resize", this.onResize);
-        process.off("exit", this.restoreTerminal);
         this.host.unsubscribeSession();
         this.host.clearExtensionWidgets();
-        await this.host.saveInputStateForQuit();
         this.restoreTerminal();
+        this.shutdownDeadlineAt = Date.now() + RUNTIME_DISPOSE_GRACE_MS;
         this.scheduleForcedProcessExit();
-        await this.host.disposeInactiveRuntimesForQuit();
+        await this.runBestEffort(() => this.host.stopVoiceInput());
+        await this.runBestEffort(() => this.host.saveInputStateForQuit());
+        await this.runBestEffort(() => this.host.disposeInactiveRuntimesForQuit());
         const runtime = this.host.runtime();
         if (runtime)
             await this.disposeRuntimeForQuit(runtime);
     }
+    async runBestEffort(task) {
+        try {
+            await task();
+        }
+        catch {
+            // Shutdown continues so terminal restoration and runtime disposal are not
+            // skipped when one independent cleanup step fails.
+        }
+    }
     scheduleForcedProcessExit() {
         const exitCode = typeof process.exitCode === "number" ? process.exitCode : 0;
         const timer = setTimeout(() => {
@@ -138,16 +156,24 @@ export class AppTerminalController {
         timer.unref();
     }
     onResize = () => {
+        if (!this.terminalEnabled || this.interactiveSuspended || !this.host.isRunning())
+            return;
         this.host.resetRenderOutputBuffer();
         this.host.render();
     };
     onInputData = (chunk) => {
-        const input = this.filterKeyboardProtocolNegotiationInput(chunk.toString("utf8"));
+        if (!this.terminalEnabled || this.interactiveSuspended || !this.host.isRunning())
+            return;
+        const decoded = this.inputDecoder.write(chunk);
+        if (!decoded)
+            return;
+        const input = this.filterKeyboardProtocolNegotiationInput(decoded);
         if (input)
             this.host.handleInputChunk(Buffer.from(input, "utf8"));
     };
     beginKeyboardProtocolNegotiation() {
         this.clearKeyboardProtocolNegotiationBuffer();
+        this.inputDecoder = new StringDecoder("utf8");
         this.kittyProtocolActive = false;
         this.modifyOtherKeysActive = false;
     }
@@ -198,8 +224,9 @@ export class AppTerminalController {
             this.keyboardProtocolBufferFlushTimer = undefined;
             const buffered = this.keyboardProtocolNegotiationBuffer;
             this.keyboardProtocolNegotiationBuffer = "";
-            if (buffered)
+            if (buffered && this.terminalEnabled && !this.interactiveSuspended && this.host.isRunning()) {
                 this.host.handleInputChunk(Buffer.from(buffered, "utf8"));
+            }
         }, 150);
     }
     clearKeyboardProtocolNegotiationBuffer() {

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

@@ -35,6 +35,8 @@ export declare class AppWorkspaceActionsController {
     forkFromUserMessage(entryId: string): Promise<void>;
     forkFromUserMessageInNewTab(entryId: string): Promise<void>;
     undoChangesFromUserMessage(entryId: string): Promise<void>;
+    private isRuntimeActive;
+    private isSessionActive;
     private workspaceMutationPlanFromSessionEntry;
     private workspaceMutationPlanForSingleEntry;
     private findUserEntryBySessionEntryId;

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

@@ -28,10 +28,13 @@ export class AppWorkspaceActionsController {
         this.host.touchEntry(entry);
     }
     scheduleUserSessionEntryMetadataSync() {
+        const runtime = this.host.runtime();
+        const session = runtime?.session;
         const timer = setTimeout(() => {
+            if (!runtime || !session || !this.isSessionActive(runtime, session))
+                return;
             this.syncUserSessionEntryMetadata();
-            if (this.host.isRunning())
-                this.host.render();
+            this.host.render();
         }, 0);
         timer.unref?.();
     }
@@ -48,13 +51,20 @@ export class AppWorkspaceActionsController {
         });
         if (branchUserEntries.length === 0)
             return;
+        const branchIndexesByEntryId = new Map(branchUserEntries.map((entry, index) => [entry.entryId, index]));
         const loadedEntries = this.host.allEntries?.() ?? this.host.entries;
         let branchIndex = 0;
         for (const entry of loadedEntries) {
             if (entry.kind !== "user")
                 continue;
-            const sessionEntry = branchUserEntries[branchIndex];
-            branchIndex += 1;
+            const existingBranchIndex = entry.sessionEntryId === undefined
+                ? undefined
+                : branchIndexesByEntryId.get(entry.sessionEntryId);
+            const resolvedBranchIndex = existingBranchIndex !== undefined && existingBranchIndex >= branchIndex
+                ? existingBranchIndex
+                : branchIndex;
+            const sessionEntry = branchUserEntries[resolvedBranchIndex];
+            branchIndex = resolvedBranchIndex + 1;
             if (!sessionEntry)
                 break;
             let changed = false;
@@ -76,12 +86,15 @@ export class AppWorkspaceActionsController {
         }
     }
     async copyUserMessage(entryId) {
+        const runtime = this.host.runtime();
         const entry = this.host.findUserEntry(entryId);
         if (!entry)
             throw new Error("User message is no longer available");
         await copyTextToClipboard(entry.text);
+        if (!runtime || !this.isRuntimeActive(runtime))
+            return;
         this.host.showToast("Message copied", "success");
-        this.host.setSessionStatus(this.host.runtime()?.session);
+        this.host.setSessionStatus(runtime.session);
     }
     async forkFromUserMessage(entryId) {
         const runtime = this.getIdleRuntimeForAction("fork");
@@ -96,7 +109,11 @@ export class AppWorkspaceActionsController {
         this.host.setStatus("forking session");
         this.host.render();
         await this.host.awaitCurrentSessionExtensions(runtime);
+        if (!this.isRuntimeActive(runtime))
+            return;
         const result = await runtime.fork(sessionEntryId);
+        if (!this.isRuntimeActive(runtime))
+            return;
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -135,7 +152,10 @@ export class AppWorkspaceActionsController {
         const mutationPlan = this.workspaceMutationPlanFromSessionEntry(sessionEntryId);
         this.host.setStatus("truncating session");
         this.host.render();
-        const result = await runtime.session.navigateTree(sessionEntryId);
+        const session = runtime.session;
+        const result = await session.navigateTree(sessionEntryId);
+        if (!this.isSessionActive(runtime, session))
+            return;
         if (result.aborted) {
             this.host.showToast("Undo cancelled", "info");
             this.host.setSessionStatus(runtime.session);
@@ -146,15 +166,14 @@ export class AppWorkspaceActionsController {
             this.host.setSessionStatus(runtime.session);
             return;
         }
-        this.host.resetSessionView();
-        this.host.loadSessionHistory();
-        this.host.setInput(result.editorText ?? entry.text);
         let revertSummary = "No recorded file mutations were found for the removed branch.";
         let revertToastKind = "success";
         if (mutationPlan.mutations.length > 0) {
             this.host.setStatus("reverting recorded commands");
             this.host.render();
             const reverted = await revertWorkspaceMutations(runtime.cwd, mutationPlan.mutations);
+            if (!this.isSessionActive(runtime, session))
+                return;
             if (reverted.ok) {
                 revertSummary = `Reverted ${reverted.revertedChanges} command${reverted.revertedChanges === 1 ? "" : "s"} across ${reverted.changedFiles} file${reverted.changedFiles === 1 ? "" : "s"}.`;
             }
@@ -167,6 +186,9 @@ export class AppWorkspaceActionsController {
             revertSummary = `No recorded file mutations were available for ${mutationPlan.messagesWithoutLogs} removed message${mutationPlan.messagesWithoutLogs === 1 ? "" : "s"}.`;
             revertToastKind = "warning";
         }
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        this.host.setInput(result.editorText ?? entry.text);
         this.host.addEntry({
             id: createId("system"),
             kind: "system",
@@ -175,6 +197,12 @@ export class AppWorkspaceActionsController {
         this.host.setSessionStatus(runtime.session);
         this.host.showToast(revertToastKind === "success" ? "Changes undone" : "Session rewound with revert warnings", revertToastKind);
     }
+    isRuntimeActive(runtime) {
+        return this.host.isRunning() && this.host.runtime() === runtime;
+    }
+    isSessionActive(runtime, session) {
+        return this.isRuntimeActive(runtime) && runtime.session === session;
+    }
     workspaceMutationPlanFromSessionEntry(entryId) {
         const runtime = this.host.runtime();
         if (!runtime)

package/dist/input-editor.d.ts

@@ -100,6 +100,8 @@ export declare class InputEditor {
     get promptText(): string;
     setText(text: string, cursor?: number): void;
     setDraftState(state: InputEditorDraftState): void;
+    /** Restore a tab-owned draft without carrying undo or paste state across tabs. */
+    restoreDraftState(state: InputEditorDraftState): void;
     clear(): void;
     undo(): boolean;
     redo(): boolean;

package/dist/input-editor.js

@@ -114,6 +114,23 @@ export class InputEditor {
             this.clearSelection();
         });
     }
+    /** Restore a tab-owned draft without carrying undo or paste state across tabs. */
+    restoreDraftState(state) {
+        const before = this.captureHistorySnapshot();
+        this._text = state.text;
+        this._cursor = state.cursor;
+        this._attachments.length = 0;
+        this._attachments.push(...Array.from(state.attachments ?? [], cloneAttachment));
+        this._imageCounter = maxTagCounter(this._attachments, /^\[Image (\d+)/u);
+        this._pasteCounter = maxTagCounter(this._attachments, /^\[Pasted ~?(\d+)/u);
+        this._bracketedPasteDepth = 0;
+        this.clampCursor();
+        this.clearSelection();
+        this.clearScrollOffset();
+        this.clearHistory();
+        if (this.didContentChangeFrom(before))
+            this._contentVersion += 1;
+    }
     clear() {
         const hadContent = this._text.length > 0 || this._attachments.length > 0;
         this._text = "";

package/docs/concurrency.md

@@ -0,0 +1,76 @@
+# Spec: Application concurrency and lifecycle safety
+
+## Type
+
+Change
+
+## Goal
+
+Keep tab, session, editor, extension UI, persistence, and shutdown work bound to
+the state that started it, without blocking normal terminal interaction.
+
+## Scope
+
+- Tab/session activation, replacement, close, fork, restore, and history loading.
+- Input submission, queued messages, paste, voice, prompt enhancement, and editor restoration.
+- Extension UI callbacks, persisted tab snapshots, terminal input decoding, and shutdown.
+
+## Non-goals
+
+- Changing the persisted tabs or session JSONL formats.
+- Making intentionally full-history SDK operations lazy when the SDK exposes only a synchronous API.
+- Changing extension-facing UI semantics beyond preventing inactive scopes from editing the active tab.
+
+## Behavior
+
+- An async continuation may mutate visible state only while its captured tab, runtime, session, and operation generation still own that state.
+- A prompt captured in one tab is submitted or queued only for that tab's captured session. If ownership is lost before dispatch, the prompt is restored instead of rerouted.
+- Deferred paste, voice, and extension UI completion target their originating tab or are discarded after that scope is removed.
+- Restoring a tab draft does not enter another tab's undo history and cannot silently overwrite input typed after activation started.
+- Tab lifecycle mutations are mutually exclusive. Failed activation rolls back or disposes newly created/displaced runtimes.
+- Persisted tab snapshots are written in invocation order with unique temporary files.
+- Replacement/history work is cancelled when runtime, session, tab, or generation changes.
+- Terminal byte chunks preserve split UTF-8 sequences and batch printable-input rendering.
+- Shutdown detaches input before awaiting cleanup and applies one bounded cleanup deadline before forced exit.
+
+## Invariants
+
+- One runtime has at most one owning tab, and replacing that ownership disposes or explicitly transfers the displaced runtime.
+- Only the active tab's scope can mutate the shared editor and visible conversation.
+- Timers and subscriptions verify runtime ownership before mutation.
+- No stale persistence snapshot can replace a newer completed snapshot.
+
+## Edge cases
+
+- Switching tabs while draft persistence, session replacement, history loading, paste, voice, or custom UI is pending.
+- Closing or forking while another tab lifecycle operation is pending.
+- Paste terminators and Enter arriving in the same terminal chunk.
+- Multibyte UTF-8 split across terminal chunks.
+- Quit during startup tab restoration or stalled runtime disposal.
+
+## Related files
+
+- `src/app/session/tabs-controller.ts`
+- `src/app/session/session-lifecycle-controller.ts`
+- `src/app/input/`
+- `src/app/extensions/extension-ui-controller.ts`
+- `src/app/terminal/terminal-controller.ts`
+- `src/input-editor.ts`
+
+## Verification
+
+- Deterministic deferred-promise tests for tab/session identity after every relevant `await`.
+- Regression tests for cross-tab submit/paste/UI completion and non-history draft restoration.
+- Chunked UTF-8 and large printable-input tests.
+- `npm run check`, `npm run build:pix`, and `git diff --check`.
+
+## Risks / unknowns
+
+- SDK session hydration and append APIs are synchronous; eliminating those stalls may require an upstream SDK API or worker/process boundary.
+- Voice model inference may require a dedicated worker to become fully non-blocking.
+
+## Evidence
+
+- Confirmed by the pre-change audit: shared editor/runtime state was read after asynchronous boundaries in the related files.
+- Confirmed by regression tests: audit probes reproduced cross-tab submit, deferred paste, undo leakage, and render amplification before the fixes.
+- Unknown: acceptable upstream design for asynchronous SDK session hydration.

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

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

package/external/pi-tools-suite/src/dcp/state-persistence.ts

@@ -1,4 +1,4 @@
-import { mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises"
+import { mkdir, open, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises"
 import type { Dirent } from "node:fs"
 import { dirname, join } from "node:path"
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent"
@@ -7,6 +7,7 @@ import { hashSerializedState, serializeState, type DcpState, type SerializedDcpS
 const DCP_STATE_DIR = "dcp-state"
 const DCP_STATE_EXT = ".json"
 const DCP_STATE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000
+const MAX_SESSION_HEADER_BYTES = 64 * 1024
 
 let lastPersistedStateHash: string | undefined
 let saveQueue: Promise<void> = Promise.resolve()
@@ -15,6 +16,28 @@ function safeSessionFileName(sessionId: string): string {
 	return sessionId.replace(/[^a-zA-Z0-9._-]/g, "_") + DCP_STATE_EXT
 }
 
+export async function readSessionIdFromFile(sessionPath: string): Promise<string | undefined> {
+	const file = await open(sessionPath, "r")
+	try {
+		const buffer = Buffer.alloc(MAX_SESSION_HEADER_BYTES)
+		const { bytesRead } = await file.read(buffer, 0, buffer.length, 0)
+		if (bytesRead <= 0) return undefined
+
+		const content = buffer.subarray(0, bytesRead)
+		const newlineIndex = content.indexOf(0x0a)
+		if (newlineIndex < 0 && bytesRead === buffer.length) return undefined
+
+		const firstLine = content.subarray(0, newlineIndex >= 0 ? newlineIndex : bytesRead).toString("utf8").trim()
+		if (!firstLine) return undefined
+		const parsed = JSON.parse(firstLine) as { type?: string; id?: unknown }
+		return parsed.type === "session" && typeof parsed.id === "string" && parsed.id.length > 0
+			? parsed.id
+			: undefined
+	} finally {
+		await file.close()
+	}
+}
+
 async function listSessionIds(sessionDir: string): Promise<string[]> {
 	let entries: Dirent[]
 	try {
@@ -30,12 +53,8 @@ async function listSessionIds(sessionDir: string): Promise<string[]> {
 
 		const sessionPath = join(sessionDir, entry.name)
 		try {
-			const firstLine = (await readFile(sessionPath, "utf8")).split("\n", 1)[0]?.trim()
-			if (!firstLine) continue
-			const parsed = JSON.parse(firstLine) as { type?: string; id?: unknown }
-			if (parsed.type === "session" && typeof parsed.id === "string" && parsed.id.length > 0) {
-				sessionIds.add(parsed.id)
-			}
+			const sessionId = await readSessionIdFromFile(sessionPath)
+			if (sessionId) sessionIds.add(sessionId)
 		} catch {
 			// Ignore malformed or transient session files during cleanup.
 		}
@@ -88,14 +107,10 @@ export async function loadDcpStateFromSessionFile(
 	if (!sessionFile) return undefined
 
 	try {
-		const firstLine = (await readFile(sessionFile, "utf8")).split("\n", 1)[0]?.trim()
-		if (!firstLine) return undefined
-		const parsed = JSON.parse(firstLine) as { type?: string; id?: unknown }
-		if (parsed.type !== "session" || typeof parsed.id !== "string" || !parsed.id) {
-			return undefined
-		}
+		const sessionId = await readSessionIdFromFile(sessionFile)
+		if (!sessionId) return undefined
 		const stateDir = join(dirname(sessionFile), DCP_STATE_DIR)
-		const statePath = join(stateDir, safeSessionFileName(parsed.id))
+		const statePath = join(stateDir, safeSessionFileName(sessionId))
 		const text = await readFile(statePath, "utf8")
 		return JSON.parse(text) as SerializedDcpState
 	} catch {

package/external/pi-tools-suite/src/todo/index.ts

@@ -42,10 +42,10 @@ function buildThinkingPromptParts(model: unknown): { promptSnippet?: string; pro
 	const levels = getAvailableTodoThinkingLevels(model);
 	if (levels.length <= 1) return {};
 	return {
-		promptSnippet: `${DEFAULT_PROMPT_SNIPPET} Optional per-item thinking: ${levels.join("|")}.`.trim(),
+		promptSnippet: `${DEFAULT_PROMPT_SNIPPET} Set per-item thinking: ${levels.join("|")}.`.trim(),
 		promptGuidelines: [
 			...DEFAULT_PROMPT_GUIDELINES,
-			`If todoThinking is enabled, assign task \`thinking\` during create/batch_create or update whenever planned items differ in complexity; choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use lower/off for mechanical steps and the final user-facing report. Do not leave all thinking unset for a non-trivial mixed-complexity plan.`,
+			`If todoThinking is enabled, set \`thinking\` on every planned task during create/batch_create (or update); choose from ${levels.join(", ")}. Use higher thinking for investigation, hard debugging, risky edits, or review; use lower/off for mechanical steps and the final report. Never leave it unset in a non-trivial plan.`,
 		],
 	};
 }

package/external/pi-tools-suite/src/todo/state/state-reducer.ts

@@ -266,6 +266,12 @@ export function applyTaskMutation(state: TaskState, action: TaskAction, params:
 
 		case "batch_update": {
 			if (!params.items?.length) return errorResult(state, "items required for batch_update");
+			const seenIds = new Set<number>();
+			for (const item of params.items) {
+				if (item.id === undefined) continue;
+				if (seenIds.has(item.id)) return errorResult(state, `duplicate id in batch_update: #${item.id}`);
+				seenIds.add(item.id);
+			}
 			let working = state;
 			const ids: number[] = [];
 			for (let i = 0; i < params.items.length; i++) {

package/external/pi-tools-suite/src/tool-descriptions.ts

@@ -235,7 +235,7 @@ export const SESSION_NAME_TOOL_DESCRIPTION: ToolDescription = {
 	name: "session_name",
 	label: "Session Name",
 	description: "Show or set the current session name so the agent can retitle the active session without relying on slash-command parsing.",
-	promptSnippet: "Use session_name to rename the current session directly when the task calls for updating the session title.",
+	promptSnippet: "Use session_name only for explicit renames, opaque first prompts (such as image-only or task links) once understood, or when the current name no longer fits the active task; ordinary first prompts are auto-named.",
 	promptGuidelines: [
 		"Pass a short, user-meaningful name to rename; call without a name only to read the current session name.",
 	],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "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.81.0",
-    "@earendil-works/pi-coding-agent": "0.81.0",
-    "@earendil-works/pi-tui": "0.81.0",
+    "@earendil-works/pi-ai": "0.81.1",
+    "@earendil-works/pi-coding-agent": "0.81.1",
+    "@earendil-works/pi-tui": "0.81.1",
     "@mariozechner/clipboard": "^0.3.9",
     "jsonc-parser": "3.3.1",
     "typebox": "1.1.38",