@superblocksteam/vite-plugin-file-sync 2.0.114 → 2.0.115-next.1

package/dist/ai-service/index.js

@@ -4,7 +4,9 @@ import path from "node:path";
 import { generateObject, hasToolCall, } from "ai";
 import { z } from "zod";
 import { AiMode, resolveAttachmentFileName, } from "@superblocksteam/library-shared/types";
-import { addTracingToMethods, FactAccessType, FactCreatedSource, FactEntityScope, TracedEventEmitter, } from "@superblocksteam/shared";
+import { addTracingToMethods, classifyAttachmentDelivery, FactAccessType, FactCreatedSource, FactEntityScope, TracedEventEmitter, } from "@superblocksteam/shared";
+import { readMigrationChecklist } from "../migration/migration-checklist.js";
+import { buildTranslationPrompt } from "../migration/translation-prompt.js";
 import { getErrorMeta, getLogger, setDefaultLogger } from "../util/logger.js";
 import { getToolCallArguments, getToolErrorCode, getToolOutput, } from "./agent/tool-message-utils.js";
 import { hasPendingEscalations, flushPendingEscalations, } from "./agent/tools/apis/api-validation-orchestrator.js";
@@ -20,7 +22,6 @@ import { FileSystemInterface } from "./app-interface/file-system-interface.js";
 import { createDefaultVirtualFileSystem, createPathValidator, } from "./app-interface/filesystem/index.js";
 import { AppShell } from "./app-interface/shell.js";
 import { AppSkillsManager } from "./app-skills/manager.js";
-import { BoltArtifactProcessor } from "./artifacts/bolt.js";
 import { isUploadedAttachment, toUploadedAttachmentContentPart, } from "./attachments/uploaded-content-part.js";
 import { ChatSessionStore } from "./chat/chat-session-store.js";
 import { normalizeTextAttachmentForModel } from "./chat/utils.js";
@@ -54,6 +55,7 @@ import { doRuntimeReviewing } from "./state-machine/handlers/runtime-reviewing.j
 import { classificationHelper } from "./state-machine/helpers/classification.js";
 import { getContextId } from "./state-machine/helpers/context-id.js";
 import { sendUserMessageChannel, clearPendingToolPermissionRequest, } from "./state-machine/helpers/peer.js";
+import { StablePeer } from "./state-machine/helpers/stable-peer.js";
 import { transitionFrom } from "./state-machine/helpers/transition.js";
 import { TemplateRenderer } from "./template-renderer.js";
 import { createJsonStreamParser } from "./util/json-stream-parser.js";
@@ -125,7 +127,6 @@ const mergePlanContexts = (existing, incoming) => {
 };
 export class AiService extends TracedEventEmitter {
     config;
-    artifactProcessor;
     templateRenderer;
     appShell;
     fileSystemInterface;
@@ -139,6 +140,7 @@ export class AiService extends TracedEventEmitter {
     chatSessionStore;
     contextManagerV2;
     llmClient;
+    stablePeer = new StablePeer();
     toolRegistry = new ToolRegistry();
     entityPermissionStore = new SessionEntityPermissionStore();
     _onGenerationCompleteCallback;
@@ -245,10 +247,12 @@ export class AiService extends TracedEventEmitter {
         return this.config.features.aiFileUploadEnabled === true;
     }
     /**
-     * Checks if there is a connected peer (user is connected via socket)
+     * Checks if there is a live editor socket behind the StablePeer proxy.
+     * `clark.context.peer` is always present (it's the proxy); inner liveness
+     * is tracked on the proxy itself via `peerId`.
      */
     hasConnectedPeer() {
-        return !!this.clark?.context?.peer;
+        return this.stablePeer?.peerId != null;
     }
     constructor(config) {
         super(config.tracer);
@@ -259,8 +263,6 @@ export class AiService extends TracedEventEmitter {
         this._logger = getLogger();
         // Prevent traced functions from creating traces when called outside of a Clark context
         llmobs.setDefaultRootPolicy("drop-if-no-parent");
-        // todo: move to state handlers
-        this.artifactProcessor = new BoltArtifactProcessor();
         this.llmProviderSettings = {
             anthropic: {
                 baseURL: config.superblocksBaseUrl,
@@ -298,13 +300,13 @@ export class AiService extends TracedEventEmitter {
             enableDeletingLockfiles: config.features.enableDeletingLockfiles ?? false,
             messageSender: async (message) => {
                 // Send checklist messages through the peer connection
-                if (this.clark.context.peer &&
-                    (message.type === "checklist_item_added" ||
-                        message.type === "checklist_item_updated")) {
+                if (message.type === "checklist_item_added" ||
+                    message.type === "checklist_item_updated") {
                     const sendUserMessage = sendUserMessageChannel(this.clark, this.chatSessionStore);
                     await sendUserMessage({
-                        type: "text",
-                        text: "",
+                        role: "assistant",
+                        type: "tool",
+                        content: "",
                         group: "checklist",
                         status: "ready",
                         checklistData: message,
@@ -375,6 +377,7 @@ export class AiService extends TracedEventEmitter {
         this.clark = new Clark({
             initialContext: {
                 abortController: new AbortController(),
+                peer: this.stablePeer,
             },
             createTransitionHandler: this.createClarkTransitionHandler(),
             createTagProvider: this.createClarkTagProviderFactory(),
@@ -405,6 +408,7 @@ export class AiService extends TracedEventEmitter {
         });
         const handlerMethods = [
             "handleAiGenerate",
+            "handleAiTriggerMigrationTurn",
             "handleAiRespondToToolPermission",
             "handleUserAcceptedDraft",
             "handleUserRejectedDraft",
@@ -428,6 +432,7 @@ export class AiService extends TracedEventEmitter {
      */
     async initialize() {
         await this.integrationStore.initialize();
+        await this.hydrateMigrationChecklistFromDisk();
         // Start recording with initial commit ID from chat history (if enabled)
         if (this.config.features.sessionRecordingEnabled === true) {
             const initialCommitId = await this.chatSessionStore.getLatestCommitId();
@@ -438,6 +443,44 @@ export class AiService extends TracedEventEmitter {
         });
         this.getLogger().info("[ai-service] Initialized");
     }
+    async hydrateMigrationChecklistFromDisk() {
+        const migrationChecklist = await readMigrationChecklist(this.appRootDirPath);
+        if (!migrationChecklist) {
+            return;
+        }
+        const hasPendingSeedApi = migrationChecklist.items.some((item) => item.origin === "seed_api" &&
+            (item.status === "pending" || item.status === "in_progress"));
+        if (hasPendingSeedApi) {
+            this.appShell.setApiHandlerEnabled(false);
+            this.getLogger().info("[ai-service] Migration in progress on disk — disabled API VFS projection so Clark reads raw YAML");
+        }
+        await this.chatSessionStore.recordAssistant({
+            role: "assistant",
+            type: "tool",
+            content: "",
+            group: "checklist",
+            checklistData: {
+                type: "checklist_cleared",
+                payload: {},
+            },
+        });
+        const totalItems = migrationChecklist.items.length;
+        for (const item of migrationChecklist.items) {
+            await this.chatSessionStore.recordAssistant({
+                role: "assistant",
+                type: "tool",
+                content: "",
+                group: "checklist",
+                checklistData: {
+                    type: "checklist_item_added",
+                    payload: {
+                        item,
+                        totalItems,
+                    },
+                },
+            });
+        }
+    }
     /**
      * Remove the integration metadata cache for this session.
      * Cleans up the session cache directory.
@@ -468,7 +511,6 @@ export class AiService extends TracedEventEmitter {
                     ...this.config,
                     logger: this.getLogger(),
                     templateRenderer: this.templateRenderer,
-                    artifactProcessor: this.artifactProcessor,
                     appShell: this.appShell,
                     signals: this,
                     fileSystemInterface: this.fileSystemInterface,
@@ -597,8 +639,113 @@ export class AiService extends TracedEventEmitter {
             this.getLogger().warn("[ai-service] Quota check failed, allowing request", getErrorMeta(error));
         }
     }
-    async handleAiGenerate(request, peer, peerId) {
-        this.getLogger().info(`[ai-service] handleAiGenerate: peerId=${peerId}`);
+    /**
+     * Fires the internal, UI-invisible migration turn if the app is post-flip
+     * and still has `seed_api` checklist items pending. Safe to call multiple
+     * times — the `migrationTurnTriggered` guard ensures one-shot semantics
+     * per ai-service lifetime. The disk checklist is the recovery source of
+     * truth across process restarts.
+     *
+     * Expected caller: the UI issues a dedicated RPC (see
+     * v1.ai.triggerMigrationTurn) once it observes the post-flip state via
+     * /sb-migration-status. jwt + llmConfig come from the UI's normal auth
+     * flow.
+     */
+    async handleAiTriggerMigrationTurn(request) {
+        // User-initiated "Fix with Clark" retries bypass the one-shot
+        // guard. The HTTP route that flips the items has already landed,
+        // so if we refused here the user would be stuck.
+        if (request.retryMode === "focused-debug") {
+            this.migrationTurnTriggered = false;
+        }
+        if (this.migrationTurnTriggered) {
+            return { dispatched: false, reason: "already-triggered" };
+        }
+        if (this.clark.state === ClarkStateNames.Dead) {
+            return { dispatched: false, reason: "dead" };
+        }
+        if (this.clark.state !== ClarkStateNames.Idle &&
+            this.clark.state !== ClarkStateNames.AwaitingUser) {
+            return { dispatched: false, reason: `busy:${this.clark.state}` };
+        }
+        const checklist = await readMigrationChecklist(this.appRootDirPath);
+        if (!checklist) {
+            this.getLogger().warn("[ai-service] Migration checklist not found or unreadable; skipping translation turn");
+            return { dispatched: false, reason: "checklist-unavailable" };
+        }
+        const pendingSeedApiItems = checklist.items.filter((item) => item.origin === "seed_api" && item.status === "pending");
+        const pendingSeedApiCount = pendingSeedApiItems.length;
+        if (pendingSeedApiCount === 0) {
+            return { dispatched: false, reason: "no-pending-items" };
+        }
+        this.migrationTurnTriggered = true;
+        this.appShell.setApiHandlerEnabled(false);
+        this.getLogger().info(`[ai-service] Dispatching internal v2→v3 migration turn for ${pendingSeedApiCount} API(s) (API VFS projection disabled, retryMode=${request.retryMode ?? "none"})`);
+        const prompt = buildTranslationPrompt({
+            focusedDebug: request.retryMode === "focused-debug",
+        });
+        const migrationLlmConfig = this.getMigrationSafeLlmConfig(request.llmConfig);
+        const generateRequest = {
+            prompt,
+            jwt: request.jwt,
+            llmConfig: migrationLlmConfig,
+            mode: AiMode.BUILD,
+        };
+        this.clark.updateContext((context) => ({
+            ...context,
+            promptId: randomUUID(),
+            llmConfig: migrationLlmConfig,
+        }));
+        const transitionTo = transitionFrom(this.clark);
+        // Promise is intentionally not awaited — the translation turn runs in the
+        // background. We reset the guard + re-enable the API handler when the
+        // turn *settles* (success or failure) so any remaining pending items
+        // (from auto-retry budget flips or genuine agent exits) can trigger
+        // another sweep without a dev-server restart.
+        transitionTo({
+            type: USER_SENT_PROMPT,
+            request: generateRequest,
+            internal: true,
+        })
+            .catch((error) => {
+            this.getLogger().error("[ai-service] Migration translation turn failed", getErrorMeta(error));
+        })
+            .finally(() => {
+            this.migrationTurnTriggered = false;
+            this.appShell.setApiHandlerEnabled(true);
+        });
+        return { dispatched: true };
+    }
+    getMigrationSafeLlmConfig(llmConfig) {
+        const requiredMigrationTools = new Set([
+            "build_manageChecklist",
+            "build_manage_checklist",
+            // Focused-debug retries instruct the agent to ask the user via
+            // askMultiChoice when the blocker is informational (e.g. the
+            // original SQL was stubbed before backup). If the caller
+            // disabled that tool, we'd loop on the ZERO-judgment rule.
+            "askMultiChoice",
+        ]);
+        const disabledTools = Array.isArray(llmConfig.disabledTools)
+            ? llmConfig.disabledTools
+            : [];
+        if (disabledTools.length === 0) {
+            return llmConfig;
+        }
+        const filteredDisabledTools = disabledTools.filter((tool) => !requiredMigrationTools.has(tool));
+        if (filteredDisabledTools.length !== disabledTools.length) {
+            this.getLogger().warn("[ai-service] Migration turn overrides disabledTools to keep checklist tool available", {
+                removedTools: disabledTools.filter((tool) => requiredMigrationTools.has(tool)),
+            });
+        }
+        return {
+            ...llmConfig,
+            disabledTools: filteredDisabledTools,
+        };
+    }
+    migrationTurnTriggered = false;
+    async handleAiGenerate(request) {
+        this.getLogger().info(`[ai-service] handleAiGenerate: peerId=${this.stablePeer.peerId ?? "unknown"}`);
         if (this.clark.state === ClarkStateNames.Dead) {
             throw new Error("Service is unavailable");
         }
@@ -648,11 +795,9 @@ export class AiService extends TracedEventEmitter {
         void transitionTo({
             type: USER_SENT_PROMPT,
             request,
-            peer,
-            peerId,
         });
     }
-    async handleAiExplainCode(request, peer) {
+    async handleAiExplainCode(request) {
         if (this.clark.state === ClarkStateNames.Dead) {
             throw new Error("Service is unavailable");
         }
@@ -660,6 +805,7 @@ export class AiService extends TracedEventEmitter {
             this.getLogger().warn("[ai-service] Service is busy. State:", this.clark.state);
             throw new Error("Service is busy");
         }
+        const peer = this.clark.context.peer;
         this.clarkProfiler.startSession();
         getLogger().info(`[ai-service] Explaining code (${request.codeType}): ${request.itemId}.${request.propertyName}`);
         try {
@@ -795,10 +941,11 @@ export class AiService extends TracedEventEmitter {
             });
         }
     }
-    async handleAiSummarizeApiUsage(request, peer) {
+    async handleAiSummarizeApiUsage(request) {
         if (this.clark.state === ClarkStateNames.Dead) {
             throw new Error("Service is unavailable");
         }
+        const peer = this.clark.context.peer;
         getLogger().info(`[ai-service] Summarizing API usage for: ${request.apiName}`);
         try {
             // Read the API source file and extract integration info
@@ -929,10 +1076,11 @@ export class AiService extends TracedEventEmitter {
             });
         }
     }
-    async handleAiSummarizeError(request, peer) {
+    async handleAiSummarizeError(request) {
         if (this.clark.state === ClarkStateNames.Dead) {
             throw new Error("Service is unavailable");
         }
+        const peer = this.clark.context.peer;
         try {
             let apiSourceCode;
             if (request.apiName) {
@@ -1052,6 +1200,28 @@ export class AiService extends TracedEventEmitter {
             fileName: attachment.fileName,
             type: attachment.type,
         });
+        const attachmentMimeType = attachment.type === "uploaded"
+            ? attachment.mediaType
+            : attachment.type === "pdf"
+                ? (attachment.data.match(/^data:([^;]+);base64,/)?.[1] ??
+                    "application/pdf")
+                : attachment.type === "archive"
+                    ? (attachment.data.match(/^data:([^;]+);base64,/)?.[1] ??
+                        "application/octet-stream")
+                    : attachment.type === "image"
+                        ? (attachment.image.match(/^data:([^;]+);base64,/)?.[1] ??
+                            "image/png")
+                        : attachment.mimeType;
+        const delivery = classifyAttachmentDelivery({
+            fileName: attachment.fileName,
+            mimeType: attachmentMimeType,
+        });
+        if (delivery === "reference_only") {
+            return {
+                label: "Reference attachment",
+                insight: "This file is processed as a downloadable reference and is not labeled inline.",
+            };
+        }
         const llmConfig = request.llmConfig
             ? {
                 ...request.llmConfig,
@@ -1128,11 +1298,14 @@ export class AiService extends TracedEventEmitter {
                 image: attachment.image,
             };
         }
-        else if (attachment.type === "pdf") {
+        else if (attachment.type === "pdf" || attachment.type === "archive") {
             // Parse data URL to extract base64 data
             const match = attachment.data.match(/^data:([^;]+);base64,(.+)$/);
             const data = match?.[2] ?? attachment.data;
-            const mediaType = match?.[1] ?? "application/pdf";
+            const defaultMediaType = attachment.type === "pdf"
+                ? "application/pdf"
+                : "application/octet-stream";
+            const mediaType = match?.[1] ?? defaultMediaType;
             return {
                 type: "file",
                 data,
@@ -1140,7 +1313,7 @@ export class AiService extends TracedEventEmitter {
                 filename: resolveAttachmentFileName({
                     fileName: attachment.fileName,
                     mediaType,
-                    type: "pdf",
+                    type: attachment.type,
                 }),
             };
         }
@@ -1185,35 +1358,21 @@ export class AiService extends TracedEventEmitter {
             this.getLogger().warn(`[ai-service] Failed to submit feedback to Datadog: ${error}`, JSON.stringify(getErrorMeta(error), null, 2));
         }
     }
-    async handleUserAcceptedDraft(peer, silently) {
+    async handleUserAcceptedDraft(silently) {
         this.getLogger().info(`[ai-service] handleUserAcceptedDraft`);
         this.submitAcceptanceEvaluation(true);
         if (this.clark.state !== ClarkStateNames.AwaitingUser) {
             throw new Error("Service is not awaiting user input");
         }
-        if (!this.clark.context.peer) {
-            // peer can be null if service was started with a draft
-            this.getLogger().info(`[ai-service] Setting peer from RPC caller`);
-            this.clark.updateContext({
-                peer,
-            });
-        }
         const transitionTo = transitionFrom(this.clark);
         void transitionTo({ type: USER_ACCEPTED_DRAFT, silently });
     }
-    async handleUserRejectedDraft(peer, silently) {
+    async handleUserRejectedDraft(silently) {
         this.getLogger().info(`[ai-service] handleUserRejectedDraft`);
         this.submitAcceptanceEvaluation(false);
         if (this.clark.state !== ClarkStateNames.AwaitingUser) {
             throw new Error("Service is not awaiting user input");
         }
-        if (!this.clark.context.peer) {
-            // peer can be null if service was started with a draft
-            this.getLogger().info(`[ai-service] Setting peer from RPC caller`);
-            this.clark.updateContext({
-                peer,
-            });
-        }
         const transitionTo = transitionFrom(this.clark);
         void transitionTo({
             type: USER_REJECTED_DRAFT,
@@ -1237,7 +1396,7 @@ export class AiService extends TracedEventEmitter {
             contextManagerV2: this.contextManagerV2,
             applicationId: this.config.applicationId,
         };
-        await this.clark.recordSystemMessage(params, "Environment event", "User closed the integration setup form. The integration setup might not have been completed successfully.", { role: "user" });
+        await this.clark.recordSystemMessage(params, "Environment event", "User closed the integration setup form. The integration setup might not have been completed successfully.");
     }
     async handleUserCanceled() {
         if (!this.isBusy()) {
@@ -1255,23 +1414,23 @@ export class AiService extends TracedEventEmitter {
      * Submit a prompt with interrupt behavior.
      * If not busy, starts immediately. Otherwise interrupts and continues.
      */
-    async handleAiGenerateWithQueue(request, peer, peerId, mode) {
-        this.getLogger().info(`[ai-service] handleAiGenerateWithQueue: peerId=${peerId}, mode=${mode}`);
+    async handleAiGenerateWithQueue(request, mode) {
+        this.getLogger().info(`[ai-service] handleAiGenerateWithQueue: peerId=${this.stablePeer.peerId ?? "unknown"}, mode=${mode}`);
         if (this.clark.state === ClarkStateNames.Dead) {
             throw new Error("Service is unavailable");
         }
         if (!this.isBusy()) {
-            await this.handleAiGenerate(request, peer, peerId);
+            await this.handleAiGenerate(request);
             return { status: "started" };
         }
-        await this.interruptAndContinue(request, peer, peerId);
+        await this.interruptAndContinue(request);
         return { status: "interrupted" };
     }
     /**
      * Interrupt current generation and continue with new prompt.
      * The partial response is preserved in chat history for context.
      */
-    async interruptAndContinue(request, peer, peerId) {
+    async interruptAndContinue(request) {
         await this.ensureAiQuotaAvailable(request.jwt);
         const partialResponse = this.clark.context.partialResponse?.text ?? "";
         const preservedContext = {
@@ -1284,8 +1443,6 @@ export class AiService extends TracedEventEmitter {
         this.clark.context.abortController?.abort();
         await this.waitForAbortComplete();
         this.clark.updateContext({
-            peer,
-            peerId,
             jwt: preservedContext.jwt,
             llmConfig: preservedContext.llmConfig,
             availableIntegrations: preservedContext.availableIntegrations,
@@ -1296,7 +1453,8 @@ export class AiService extends TracedEventEmitter {
         });
         if (partialResponse.trim().length > 10) {
             await this.chatSessionStore.recordAssistant({
-                text: partialResponse,
+                role: "assistant",
+                content: partialResponse,
                 type: "text",
             });
         }
@@ -1305,7 +1463,7 @@ export class AiService extends TracedEventEmitter {
             ...request,
             prompt: enhancedPrompt,
         };
-        await this.handleAiGenerate(enhancedRequest, peer, peerId);
+        await this.handleAiGenerate(enhancedRequest);
     }
     /**
      * Wait for the FSM to transition out of busy state after abort.
@@ -1390,7 +1548,7 @@ export class AiService extends TracedEventEmitter {
      *
      * If denied, injects a tool error into the context and restarts the LLM.
      */
-    async handleAiRespondToToolPermission(request, peer, peerId) {
+    async handleAiRespondToToolPermission(request) {
         const logger = this.getLogger();
         logger.info(`[ai-service] handleAiRespondToToolPermission: messageId=${request.messageId}, approved=${request.approved}`);
         const pendingRequest = this.clark.context.pendingToolPermissionRequest;
@@ -1465,6 +1623,8 @@ export class AiService extends TracedEventEmitter {
                     // Use getToolOutput for consistent formatting with processStreamChunk
                     const output = getToolOutput(toolName, result.data);
                     void sendUserMessage({
+                        role: "assistant",
+                        content: "",
                         type: "tool-result",
                         toolCallId,
                         toolName,
@@ -1491,6 +1651,8 @@ export class AiService extends TracedEventEmitter {
                     // Use getToolErrorCode for consistent formatting with processStreamChunk
                     const errorCode = getToolErrorCode(result.error);
                     void sendUserMessage({
+                        role: "assistant",
+                        content: "",
                         type: "tool-error",
                         toolCallId,
                         toolName,
@@ -1520,6 +1682,8 @@ export class AiService extends TracedEventEmitter {
                 // Use getToolErrorCode for consistent formatting with processStreamChunk
                 const errorCode = getToolErrorCode(error);
                 void sendUserMessage({
+                    role: "assistant",
+                    content: "",
                     type: "tool-error",
                     toolCallId,
                     toolName,
@@ -1628,8 +1792,6 @@ export class AiService extends TracedEventEmitter {
         void transitionTo({
             type: USER_SENT_PROMPT,
             request: continueRequest,
-            peer,
-            peerId,
         });
     }
     /**
@@ -1655,24 +1817,23 @@ export class AiService extends TracedEventEmitter {
         return `Continue with the task using alternative approaches. The tool ${toolName} was denied permission.`;
     }
     handleUserConnected(peer, peerId) {
-        const existingPeerId = this.clark.context.peerId;
+        const existingPeerId = this.stablePeer.peerId;
         this.getLogger().info(`[ai-service] handleUserConnected: peerId=${peerId}`);
-        if (this.clark.context.peer) {
+        if (existingPeerId) {
             if (existingPeerId === peerId) {
                 this.getLogger().info(`[ai-service] Existing peer ${peerId} reconnected; refreshing reference`);
             }
             else {
-                this.getLogger().warn(`[ai-service] Replacing stale peer ${existingPeerId ?? "unknown"} with ${peerId}`);
+                this.getLogger().warn(`[ai-service] Replacing stale peer ${existingPeerId} with ${peerId}`);
             }
         }
         else {
             this.getLogger().info(`[ai-service] peer connecting: ${peerId}`);
         }
-        this.clark.updateContext((context) => ({
-            ...context,
-            peer,
-            peerId,
-        }));
+        // `clark.context.peer` is a permanent StablePeer proxy; we swap its
+        // inner (and peerId) here. Any queued calls accumulated while
+        // disconnected flush in order as part of setInner.
+        this.stablePeer.setInner({ peer, peerId });
         this.getLogger().info(`[ai-service] Peer set: ${peerId}`);
         // 1. Sync generation state if generation is in progress
         if (this.clark.context.lastGenerationState) {
@@ -1709,7 +1870,7 @@ export class AiService extends TracedEventEmitter {
         }
     }
     handleUserDisconnected(peerId) {
-        const currentPeerId = this.clark.context.peerId;
+        const currentPeerId = this.stablePeer.peerId;
         this.getLogger().info(`[ai-service] handleUserDisconnected: peerId=${peerId}`);
         if (!currentPeerId) {
             return;
@@ -1727,11 +1888,10 @@ export class AiService extends TracedEventEmitter {
     }
     clearPeerConnection() {
         this.getLogger().info(`[ai-service] Clearing peer connection`);
-        this.clark.updateContext((context) => ({
-            ...context,
-            peer: undefined,
-            peerId: undefined,
-        }));
+        // The StablePeer reference on `clark.context.peer` stays — we only mark
+        // the underlying socket as gone. Calls made during the disconnect window
+        // are queued and flushed when the next peer connects.
+        this.stablePeer.setInner({ peer: undefined });
     }
     handleBuildSystemError(error) {
         // Explicitly copy error properties since they're not enumerable
@@ -1892,8 +2052,8 @@ export class AiService extends TracedEventEmitter {
         // Invalidate context errors cache since build system errors changed
         debugCache.invalidateContextErrors();
     }
-    async handlePromptInterpretation(request, peer) {
-        void peer.call.aiPushPromptInterpretation({
+    async handlePromptInterpretation(request) {
+        void this.clark.context.peer.call.aiPushPromptInterpretation({
             prompt: request.prompt,
             classification: "full_app_gen",
             entities: [], // this is not used yet. It should send any additional inferred entities.