@jmfederico/pi-web 1.202609.1 → 1.202610.0

package/dist/server/sessions/piSessionService.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createEventBus, createEditToolDefinition, defineTool, hasTrustRequiringProjectResources, ProjectTrustStore, readStoredCredential, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { projectBrowserMessage } from "../browserMessageProjection.js";
+import { isSessionMediaId } from "../../shared/sessionMedia.js";
 import { pageMessagesAtSafeBoundary } from "./messagePaging.js";
 import { clientSessionFirstMessagePreview } from "./clientSessionPreview.js";
 import { BUILTIN_COMMANDS } from "./builtinCommands.js";
@@ -535,6 +536,8 @@ export class PiSessionService {
         this.unpersistedTreeBranchLeaves = new WeakMap();
         /** Counts async operations that may append an entry before they settle. */
         this.sessionEntryMutationCounts = new WeakMap();
+        this.pendingPromptEchoes = new WeakMap();
+        this.publishedAssistantPartials = new WeakMap();
         /** Settings-wide queue preventing enabled-model read/modify/write races across sessions. */
         this.modelScopeMutationQueue = Promise.resolve();
         /** Global and workspace-owned enabled-model states; live session scopes project one entry lazily. */
@@ -563,8 +566,8 @@ export class PiSessionService {
         this.subsessionHydratedParents = new Set();
         /**
          * Tracked subsession id -> whether a completion notification is armed.
-         * Armed when the child starts working; firing on completion disarms it so a
-         * child that works again (and stops again) notifies the parent each time.
+         * Armed when the child's agent starts a run or a prompt fails before starting
+         * one (not for standalone commands or compaction); completion disarms it.
          */
         this.subsessionNotifyArmed = new Map();
         this.notificationGenerationBySession = new WeakMap();
@@ -637,6 +640,9 @@ export class PiSessionService {
     notificationCatalog() {
         return this.notificationStore.catalogSnapshot();
     }
+    async reconcileUnreadWorkspaces(cwds) {
+        await this.publishUnreadMutations(this.unreadStore.reconcileWorkspaces(cwds));
+    }
     async unreadCatalog() {
         await this.publishUnreadMutations([]);
         return this.unreadStore.durableCatalogSnapshot();
@@ -744,7 +750,10 @@ export class PiSessionService {
             finally {
                 await active.runtime.dispose();
             }
-        })).finally(() => this.activityMarker.dispose());
+        })).finally(async () => {
+            this.events.mediaIndex.clear();
+            await this.activityMarker.dispose();
+        });
         await this.publishUnreadMutations([]);
     }
     async list(cwd) {
@@ -1518,31 +1527,34 @@ export class PiSessionService {
         });
     }
     /**
-     * Drive parent notifications from a tracked child's status. Arms a pending
-     * notification while the child is working, and when it stops fires a single
-     * follow-up message to the parent via {@link prompt} (which queues if the
-     * parent is busy and delivers immediately when it is idle).
+     * Arm on a tracked child's agent_start, then notify the parent once it stops
+     * working. Prompt failures before agent_start explicitly arm the same latch.
+     * Standalone commands and compactions must not arm a completion notice.
      */
-    updateSubsessionTracking(session) {
+    updateSubsessionTracking(session, agentStarted = false) {
         const link = this.subsessionLinkForActiveChild(session);
         if (link === undefined)
             return;
         const childId = link.childSessionId;
-        if (this.hasActiveWork(session)) {
+        if (agentStarted) {
             this.subsessionNotifyArmed.set(childId, true);
             return;
         }
+        if (this.hasActiveWork(session))
+            return;
         if (this.subsessionNotifyArmed.get(childId) !== true)
             return;
         this.subsessionNotifyArmed.set(childId, false);
-        const status = this.activities.get(childId)?.phase === "error" ? "error" : "idle";
+        const activity = this.activities.get(childId);
+        const status = activity?.phase === "error" ? "error" : "idle";
+        const errorSection = status === "error" && activity?.detail !== undefined ? `Error: ${activity.detail}\n\n` : "";
         const finalText = finalAssistantText(historyMessages(session));
         const outputSection = formatSubsessionNotificationOutput(childId, finalText);
         const workingIds = this.workingSubsessionIds(link.parentSessionId);
         const next = workingIds.length === 0
             ? "No other tracked subsessions are working."
             : `Still working: ${workingIds.join(", ")}. Continue working, or call yield_to_subsessions alone and last at the next join point. Further completion notices arrive automatically; do not poll.`;
-        const text = `Subsession ${childId} stopped working (${status}).\n${next}\n\n${outputSection}`;
+        const text = `Subsession ${childId} stopped working (${status}).\n${next}\n\n${errorSection}${outputSection}`;
         void this.notifyParentOfSubsession(link.parentSessionId, childId, text);
     }
     async getOrOpenParentForSubsession(parentSessionId, childSessionId) {
@@ -1590,10 +1602,69 @@ export class PiSessionService {
     logSubsessionNotificationFailure(parentId, childId, error) {
         this.logger.info({ parentSessionId: parentId, sessionId: childId, error: error instanceof Error ? error.message : String(error) }, "failed to notify parent of subsession completion");
     }
+    async transcriptSnapshot(ref, page) {
+        const session = await this.getOrOpen(ref);
+        const seqBeforeRead = this.events.currentSeq(session.sessionId);
+        const activeAtCapture = this.hasActiveWork(session);
+        const diskBranch = activeAtCapture ? undefined : await this.readableSessionBranch(ref, session);
+        // Disk reads yield, even if a whole turn starts AND ends while they run.
+        // From the final runtime read through the watermark capture nothing may yield.
+        const branch = diskBranch === undefined || this.hasActiveWork(session) || this.events.currentSeq(session.sessionId) !== seqBeforeRead
+            ? session.sessionManager.getBranch()
+            : diskBranch;
+        const messages = historyMessagesFromEntries(branch);
+        const userCount = messages.filter((message) => isRecord(message) && message["role"] === "user").length;
+        const echoes = (this.pendingPromptEchoes.get(session) ?? []).filter((echo) => echo.userIndex >= userCount);
+        messages.push(...echoes.map((echo) => echo.message));
+        return {
+            page: pageMessagesAtSafeBoundary(messages, page),
+            status: this.statusFromSession(session, transcriptMessageCount(branch) + echoes.length),
+            seq: this.events.currentSeq(session.sessionId),
+            partial: this.publishedAssistantPartials.get(session) ?? null,
+        };
+    }
     async messages(ref, page) {
         const session = await this.getOrOpen(ref);
         return pageMessagesAtSafeBoundary(historyMessagesFromEntries(await this.readableSessionBranch(ref, session)), page);
     }
+    async media(ref, mediaId) {
+        if (!isSessionMediaId(mediaId))
+            throw new Error("Invalid media id");
+        const index = this.events.mediaIndex;
+        const session = this.activeForRef(ref)?.runtime.session ?? this.startupSessionForRef(ref);
+        // Verify session/cwd ownership before consulting the session-scoped cache.
+        // Cold binary reads do not construct an SDK runtime (which can migrate files).
+        const archived = session === undefined ? await this.getArchived(ref) : undefined;
+        const resolved = session === undefined && archived?.archivePath === undefined
+            ? await this.sessionManager.resolveSessionFile(ref.cwd, ref.id)
+            : undefined;
+        const sessionId = session?.sessionId ?? archived?.sessionId ?? resolved?.id;
+        if (sessionId === undefined || (resolved !== undefined && !cwdPathsEqual(resolved.cwd, ref.cwd)))
+            throw new Error("Session not found");
+        const scope = { id: sessionId, cwd: canonicalizeStoredCwd(session?.sessionManager.getCwd() ?? archived?.cwd ?? resolved?.cwd ?? ref.cwd) };
+        const cached = index.get(scope, mediaId);
+        if (cached !== undefined)
+            return cached;
+        if (session !== undefined) {
+            const live = index.find(scope, mediaId, [
+                session.sessionManager.getEntries?.() ?? session.sessionManager.getBranch(),
+                session.messages,
+                session.state.streamingMessage,
+                this.publishedAssistantPartials.get(session),
+                ...(this.pendingPromptEchoes.get(session) ?? []).map((echo) => echo.message),
+            ]);
+            if (live !== undefined)
+                return live;
+        }
+        // Read disk on misses even for a cached idle runtime: other processes can
+        // append images on any branch without emitting events through this daemon.
+        const path = session?.sessionFile ?? session?.sessionManager.getSessionFile() ?? archived?.archivePath ?? resolved?.path
+            ?? (session === undefined ? undefined : (await this.sessionManager.resolveSessionFile(ref.cwd, sessionId))?.path);
+        if (path === undefined)
+            return undefined;
+        const entries = await this.sessionManager.readEntries?.(path);
+        return entries === undefined ? undefined : index.find(scope, mediaId, entries);
+    }
     async status(ref) {
         const session = await this.sessionForStatusOrDialogClose(ref);
         await this.activityMarker.refresh(session.sessionFile, this.hasActiveWork(session));
@@ -1844,14 +1915,49 @@ export class PiSessionService {
     }
     beginPromptSubmission(session, text, behavior, images = [], echoUserMessage = true) {
         this.publishActivity(session, behavior === "steer" ? "steering queued" : behavior === "followUp" ? "message queued" : "prompt accepted", "active");
-        if (behavior === undefined && echoUserMessage)
-            this.events.publish(session.sessionId, { type: "message.append", message: userMessage(text, images) });
+        const echoes = this.pendingPromptEchoes.get(session) ?? [];
+        const userCount = historyMessagesFromEntries(session.sessionManager.getBranch()).filter((message) => isRecord(message) && message["role"] === "user").length;
+        const echo = behavior === undefined && echoUserMessage
+            ? { userIndex: Math.max(userCount, ...echoes.map((pending) => pending.userIndex + 1)), message: userMessage(text, images) }
+            : undefined;
+        if (echo !== undefined) {
+            // SDK input hooks may await before appending the user message. Keep the
+            // already-published echo visible in snapshots until that append occurs.
+            this.pendingPromptEchoes.set(session, [...echoes, echo]);
+            this.events.publish(session.sessionId, { type: "message.append", message: echo.message }, { id: session.sessionId, cwd: session.sessionManager.getCwd() });
+        }
         const promptOptions = buildPromptOptions(behavior, images);
-        const promptPromise = this.runSessionEntryMutation(session, "send a prompt", () => session.prompt(text, promptOptions));
+        const commandName = text.startsWith("/") ? text.slice(1).split(" ")[0] : undefined;
+        const trackEarlyFailure = behavior === undefined
+            && this.subsessionLinkForActiveChild(session) !== undefined
+            && !session.extensionRunner.getRegisteredCommands().some((command) => command.invocationName === commandName);
+        let agentStarted = false;
+        const unsubscribe = !trackEarlyFailure ? undefined : session.subscribe((event) => {
+            if (getString(event, "type") === "agent_start")
+                agentStarted = true;
+        });
+        const promptPromise = this.runSessionEntryMutation(session, "send a prompt", () => session.prompt(text, promptOptions)).finally(() => {
+            unsubscribe?.();
+            if (echo !== undefined) {
+                const remaining = (this.pendingPromptEchoes.get(session) ?? []).filter((pending) => pending !== echo);
+                if (remaining.length === 0)
+                    this.pendingPromptEchoes.delete(session);
+                else
+                    this.pendingPromptEchoes.set(session, remaining);
+            }
+        });
         void promptPromise.catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
             this.publishActivity(session, "error", "error", message);
             this.events.publish(session.sessionId, { type: "session.error", message });
+            if (this.isCurrentActiveSession(session)) {
+                const link = this.subsessionLinkForActiveChild(session);
+                // Model/auth validation can reject without any agent event. Wake the
+                // parent, but do not re-arm a run that already emitted agent_start.
+                if (trackEarlyFailure && !agentStarted && link !== undefined)
+                    this.subsessionNotifyArmed.set(link.childSessionId, true);
+                this.updateSubsessionTracking(session);
+            }
         });
         return promptPromise;
     }
@@ -2617,6 +2723,7 @@ export class PiSessionService {
         // Promises inside the dying runtime: settle them rather than dropping them.
         this.endSessionExtensionDialogs(sessionId);
         this.active.delete(sessionId);
+        this.events.mediaIndex.forgetSession({ id: sessionId, cwd: active.runtime.session.sessionManager.getCwd() });
         this.activities.delete(sessionId);
         this.workspaceActivity?.removeSession(sessionId, active.runtime.session.sessionManager.getCwd());
         this.clearAuthLossWarningsForSession(sessionId);
@@ -3085,7 +3192,7 @@ export class PiSessionService {
         // now rather than after the durable flush: it reads in-memory unread state
         // and must not lag behind the rows the browser is about to see.
         if (mutations.length > 0)
-            this.onUnreadChanged?.();
+            this.onUnreadChanged?.(mutations.some(({ event }) => event.unread !== null));
         this.enqueueUnreadMutations(mutations);
         this.unreadPublicationFlushRequested = true;
         if (this.unreadPublication === undefined && this.unreadPublicationRetryTimer !== undefined) {
@@ -3185,9 +3292,27 @@ export class PiSessionService {
             }
         }
         const unsubscribe = session.subscribe((event) => {
-            this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel));
-            this.publishActivityForEvent(session, event);
             const eventType = getString(event, "type");
+            const message = getProperty(event, "message");
+            if ((eventType === "message_start" || eventType === "message_update") && getString(message, "role") === "assistant") {
+                // SDK state advances before async extension hooks finish. Capture only
+                // published messages, detaching even blocks left intact by projection.
+                this.publishedAssistantPartials.set(session, structuredClone(annotateAssistantThinkingLevel(projectBrowserMessage(message), session.thinkingLevel)));
+            }
+            else if (eventType === "message_start" || eventType === "message_end" || eventType === "agent_end") {
+                this.publishedAssistantPartials.delete(session);
+            }
+            this.events.publish(session.sessionId, toClientEvent(event, session.thinkingLevel), { id: session.sessionId, cwd: session.sessionManager.getCwd() });
+            this.publishActivityForEvent(session, event);
+            // Queued messages can reach the model after an ask opened, even though
+            // there was no ask to dismiss when the user originally submitted them.
+            if (eventType === "message_start" && isRecord(event) && getString(event["message"], "role") === "user") {
+                void this.voidOpenAskForUserMessage(session).catch((error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.publishActivity(session, "error", "error", message);
+                    this.events.publish(session.sessionId, { type: "session.error", message });
+                });
+            }
             if (eventType === "agent_end")
                 this.abortRunScopedExtensionDialogs(session.sessionId);
             if (eventType === "compaction_end")
@@ -3195,11 +3320,12 @@ export class PiSessionService {
             if (eventType === "agent_start" || eventType === "agent_end")
                 this.scheduleCompactionQueueDrain(session.sessionId);
             this.publishStatus(session);
-            this.updateSubsessionTracking(session);
+            this.updateSubsessionTracking(session, eventType === "agent_start");
         });
         active.unsubscribe = () => {
             this.sessionEvents.close(session);
             unsubscribe();
+            this.publishedAssistantPartials.delete(session);
         };
         this.active.set(session.sessionId, active);
     }