@recombine-ai/bosun 0.16.2 → 0.17.1

package/build/server/chunks/{_layout.svelte-B88WMyk0.js → _layout.svelte-D6rhwm98.js}

@@ -1,25 +1,28 @@
-import { l as derived, k as escape_html, m as attr, n as stringify, o as attr_class, p as ensure_array_like, q as attributes, r as clsx, t as bind_props } from './index-LMsd1ih2.js';
-import { P as Panel } from './Panel-zvjxe036.js';
-import { B as Button } from './Button-DH7gdU0s.js';
-import { D as Dropdown } from './Dropdown-DnARl86Q.js';
-import { I as Icon } from './Icon-DP1YKCRV.js';
-import { T as Tabs, a as Tab } from './Tab-CUkyLqbN.js';
-import { M as Modal } from './Modal-CGJuNpZ0.js';
-import { o as onDestroy, t as tick } from './index-server-BRr5mZEq.js';
-import { g as goto, r as replaceState } from './client-DO-hqMbT.js';
-import { p as page } from './index2-ClgfzZ89.js';
+import { n as derived, k as escape_html, l as attr, o as stringify, m as attr_class, p as ensure_array_like, q as attributes, r as clsx, t as bind_props } from './index-DGtbUu8Y.js';
+import { P as Panel } from './Panel-Cj1mXx9-.js';
+import { B as Button } from './Button-Dc9CR4Wh.js';
+import { D as Dropdown } from './Dropdown-Cgd7pG-k.js';
+import { I as Icon } from './Icon-Bogvl2n9.js';
+import { T as Tabs, a as Tab } from './Tab-bf4ZDs5y.js';
+import { M as Modal } from './Modal-7IIIfFEG.js';
+import { o as onDestroy, t as tick } from './index-server-l8-WsVn4.js';
+import { g as goto, r as replaceState } from './client-P-7bDULt.js';
+import { p as page } from './index2-CtgLiJVO.js';
 import { p as public_env } from './shared-server-DaWdgxVh.js';
-import { t as trpc } from './trpc-client-D8L6vWf4.js';
+import { r as repositoryClientAdmission, t as trpc, g as gitFlushRequestOptions, i as isGitModeMutationBlockedError } from './trpc-client-Cr8RJ4UO.js';
+import { g as getGitModeContext } from './git-mode-context-BpNsAUGF.js';
 import nunjucks from 'nunjucks';
-import { A as AgentSidebar } from './AgentSidebar-BWBnqHnV.js';
-import { g as getAgentsContext } from './agents-context-CbFsZmi5.js';
-import { s as setEditWorkspaceContext, g as getEditWorkspaceContext } from './edit-workspace-context-tyHBPujC.js';
+import { A as AgentSidebar } from './AgentSidebar-BEbSdZdN.js';
+import { g as getAgentsContext } from './agents-context-owgusUPR.js';
+import { s as setEditWorkspaceContext, g as getEditWorkspaceContext } from './edit-workspace-context-hanFnXR3.js';
 import 'js-yaml';
 import { c as clearChatContent, a as clearLogs } from './log-content.svelte-CfQzj-v_.js';
-import './index3-BdRUAffj.js';
-import './root-4q2Pr7ck.js';
-import './state.svelte-Bd1i-u49.js';
+import { G as GitControlsButton } from './GitControlsButton-BLcNzrDt.js';
+import './index3-4hbbCqW0.js';
+import './root-sWPnlpi3.js';
+import './state.svelte-BkvaElc6.js';
 import '@trpc/client';
+import '@trpc/server/observable';
 
 function Textarea($$renderer, $$props) {
   $$renderer.component(($$renderer2) => {
@@ -48,9 +51,38 @@ function PopoverModal($$renderer, $$props) {
   children($$renderer);
   $$renderer.push(`<!----></div></div>`);
 }
+function assertNever(value) {
+  throw new Error(`Unhandled client WebSocket message: ${JSON.stringify(value)}`);
+}
+function clientWsMessageDisposition(message) {
+  if (message.channel === "chat") return "block";
+  switch (message.event.type) {
+    case "select-agent":
+    case "reload-project":
+    case "step-selected":
+    case "prompt-overrides-updated":
+      return "defer";
+    case "context-updated":
+    case "prompt-updated":
+    case "trigger-action":
+    case "hangup":
+      return "block";
+    default:
+      return assertNever(message.event);
+  }
+}
+function deferredMessageKey(message) {
+  return message.channel === "chat" ? "chat" : message.event.type;
+}
 class WebSocketClient {
-  constructor(wsUrl) {
+  constructor(wsUrl, admission = repositoryClientAdmission) {
     this.wsUrl = wsUrl;
+    this.admission = admission;
+    this.unregisterAdmissionListener = this.admission.onStateChange((state) => {
+      if (state.mode !== "open") return;
+      if (this.wantsConnection) this.init();
+      this.flushDeferredMessages();
+    });
   }
   ws = null;
   openHandler = null;
@@ -62,23 +94,33 @@ class WebSocketClient {
   retryDelay = 500;
   retryTimeout = null;
   isOpen = false;
+  isConnecting = false;
   isDestroyed = false;
+  wantsConnection = false;
   agentsLoaded = false;
+  deferredMessages = /* @__PURE__ */ new Map();
+  pendingGitSyncs = /* @__PURE__ */ new Map();
+  unregisterAdmissionListener;
   init = () => {
-    if (this.isOpen) {
-      return;
-    }
+    this.wantsConnection = true;
+    if (!this.admission.isOpen() || this.isOpen || this.isConnecting) return;
     this.agentsLoaded = false;
     console.log(`Initializing websocket connection with [${this.wsUrl}]`);
     try {
+      this.isConnecting = true;
       this.ws = new WebSocket(this.wsUrl);
     } catch {
+      this.isConnecting = false;
       this.retryConnect();
       return;
     }
     this.isDestroyed = false;
     this.ws.onmessage = (event) => {
       const message = JSON.parse(event.data);
+      if (message.channel === "app-events" && message.event.type === "git-sync-complete") {
+        this.resolveGitSync(message.event.requestId);
+        return;
+      }
       if (message.channel === "error") {
         this.errorHandler?.(message.message);
       } else if (message.channel === "app-events") {
@@ -108,25 +150,41 @@ class WebSocketClient {
     this.ws.onerror = (error) => {
       console.error("Websocket error:", error);
       this.ws?.close();
-      this.retryConnect();
     };
     this.ws.onclose = () => {
       console.log("Websocket closed");
       this.isOpen = false;
+      this.isConnecting = false;
+      this.rejectPendingGitSyncs("The roleplay connection closed before pending writes finished.");
+      this.closeHandler?.();
       this.retryConnect();
     };
     this.ws.onopen = () => {
+      this.isConnecting = false;
+      if (this.isDestroyed || !this.admission.isOpen()) {
+        this.ws?.close();
+        return;
+      }
       this.retries = 0;
       this.isOpen = true;
       if (this.retryTimeout) {
         clearTimeout(this.retryTimeout);
+        this.retryTimeout = null;
       }
       this.openHandler?.();
+      this.flushDeferredMessages();
       console.log("Websocket connected");
     };
   };
   destroy = () => {
+    this.wantsConnection = false;
     this.isDestroyed = true;
+    this.clearDeferredMessages();
+    this.rejectPendingGitSyncs("The roleplay connection closed before pending writes finished.");
+    if (this.retryTimeout) {
+      clearTimeout(this.retryTimeout);
+      this.retryTimeout = null;
+    }
     this.ws?.close();
   };
   onOpen = (handler) => {
@@ -147,22 +205,113 @@ class WebSocketClient {
   onMessage = (handler) => {
     this.messageHandler = handler;
   };
-  sendMessage = (message) => {
+  sendMessage = (message, options) => {
     if (message.channel === "app-events") ;
-    this.ws?.send(JSON.stringify(message));
+    const flushAuthorized = this.admission.isFlushAuthorized(options?.gitFlushOperationId);
+    const state = this.admission.getState();
+    const disposition = clientWsMessageDisposition(message);
+    if (!flushAuthorized && state.mode !== "open") {
+      if (disposition === "defer") {
+        this.deferMessage(message);
+        return "deferred";
+      }
+      this.admission.blockMutation(
+        message.channel === "chat" ? "websocket.chat" : `websocket.${message.event.type}`
+      );
+      return "blocked";
+    }
+    if (!this.isOpen || !this.ws) {
+      if (disposition === "defer") {
+        this.deferMessage(message);
+        this.init();
+        return "deferred";
+      }
+      this.errorHandler?.("The roleplay connection is not ready. Wait for it to reconnect.");
+      return "not-ready";
+    }
+    this.ws.send(JSON.stringify(message));
+    return "sent";
+  };
+  sendGitSyncRequest = (requestId, operationId) => {
+    if (!this.admission.isFlushAuthorized(operationId)) {
+      return Promise.reject(
+        new Error("The Git WebSocket barrier is not authorized for the active refresh.")
+      );
+    }
+    if (!this.isOpen || !this.ws) {
+      return Promise.reject(
+        new Error("The roleplay connection closed before pending writes finished.")
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingGitSyncs.delete(requestId);
+        reject(new Error("Timed out while waiting for pending roleplay writes to finish."));
+      }, 5e3);
+      this.pendingGitSyncs.set(requestId, { resolve, reject, timer });
+      try {
+        this.ws?.send(
+          JSON.stringify({
+            channel: "app-events",
+            event: { type: "git-sync-request", requestId }
+          })
+        );
+      } catch (error) {
+        clearTimeout(timer);
+        this.pendingGitSyncs.delete(requestId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  };
+  clearDeferredMessages = () => {
+    this.deferredMessages.clear();
   };
   isReady = () => this.isOpen && this.agentsLoaded;
   retryConnect = () => {
     if (this.isDestroyed) return;
-    if (!this.isOpen && this.retries < this.maxRetries) {
-      this.retries++;
-      this.init();
-      this.retryTimeout = setTimeout(this.retryConnect, this.retryDelay);
-    } else {
+    if (!this.admission.isOpen()) return;
+    if (this.isOpen || this.isConnecting || this.retryTimeout) return;
+    if (this.retries >= this.maxRetries) {
       this.errorHandler?.("WebSocket Error, please reload the browser");
       this.closeHandler?.();
+      return;
     }
+    this.retryTimeout = setTimeout(() => {
+      this.retryTimeout = null;
+      if (this.isDestroyed || !this.admission.isOpen() || this.isOpen || this.isConnecting) return;
+      this.retries++;
+      this.init();
+    }, this.retryDelay);
   };
+  deferMessage(message) {
+    const key = deferredMessageKey(message);
+    if (message.channel === "app-events" && message.event.type === "select-agent") {
+      this.deferredMessages.delete("step-selected");
+      this.deferredMessages.delete("prompt-overrides-updated");
+    }
+    this.deferredMessages.delete(key);
+    this.deferredMessages.set(key, message);
+  }
+  flushDeferredMessages() {
+    if (!this.admission.isOpen() || !this.isOpen || !this.ws) return;
+    const messages = [...this.deferredMessages.values()];
+    this.deferredMessages.clear();
+    for (const message of messages) this.ws.send(JSON.stringify(message));
+  }
+  resolveGitSync(requestId) {
+    const pending = this.pendingGitSyncs.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingGitSyncs.delete(requestId);
+    pending.resolve();
+  }
+  rejectPendingGitSyncs(message) {
+    for (const pending of this.pendingGitSyncs.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(message));
+    }
+    this.pendingGitSyncs.clear();
+  }
 }
 const wsHost = public_env.PUBLIC_WS_HOST ?? `ws://${public_env.PUBLIC_WS_HOSTNAME ?? "localhost"}:${public_env.PUBLIC_WS_PORT ?? "8080"}`;
 const wsClient = new WebSocketClient(wsHost);
@@ -171,6 +320,7 @@ function SchemaEditor($$renderer, $$props) {
     let editor = null;
     let model = null;
     let disposables = [];
+    getGitModeContext();
     let { class: className } = $$props;
     onDestroy(() => {
       for (const d of disposables) {
@@ -242,12 +392,13 @@ function PromptEditor($$renderer, $$props) {
       showPreviewToggle = true,
       preview = null,
       onPreviewChange,
-      onEditorReady
+      onEditorReady,
+      onReadOnlyEditAttempt
     } = $$props;
     let internalPreview = false;
     const effectivePreview = derived(() => preview !== null ? preview : internalPreview);
     Panel($$renderer2, {
-      class: `relative overflow-hidden ${stringify(className)}`,
+      class: `prompt-editor-frame relative overflow-hidden ${stringify(className)}`,
       children: ($$renderer3) => {
         $$renderer3.push(`<div class="prompt-editor flex h-full flex-col"><div class="relative flex-1"><div class="h-full w-full"></div> `);
         if (showPreviewToggle && !readOnly) {
@@ -283,7 +434,8 @@ function ReadOnlyMonacoDiff($$renderer, $$props) {
     let {
       class: className = ""
     } = $$props;
-    $$renderer2.push(`<div${attr_class(`overflow-hidden rounded-md border border-rc-gray-700 ${className}`)}><div class="h-full w-full"></div></div>`);
+    const frameClass = derived(() => "prompt-editor prompt-editor-frame");
+    $$renderer2.push(`<div${attr_class(`overflow-hidden ${frameClass()} ${className}`)}><div class="h-full w-full"></div></div>`);
   });
 }
 function ModeAsyncPopoverContent($$renderer, $$props) {
@@ -421,6 +573,7 @@ function ContextEditor($$renderer, $$props) {
     let model = null;
     let editorDisposables = [];
     let persistViewStateTimeout = null;
+    getGitModeContext();
     let {
       class: className,
       editorStateKey = "editorState/context/default"
@@ -459,6 +612,7 @@ function ContextEditor($$renderer, $$props) {
     });
     Panel($$renderer2, {
       class: `min-h-0 overflow-hidden ${stringify(
+        // Keep model language in sync without recreating the editor
         // Keep model language in sync without recreating the editor
         // Update value only when actual text differs to avoid caret jumps
         // If the next canonical text equals the last user-emitted serialization,
@@ -474,6 +628,9 @@ function ModeContextPopoverContent($$renderer, $$props) {
   $$renderer.component(($$renderer2) => {
     const tmp = getEditWorkspaceContext(), workspace = tmp.state;
     tmp.actions;
+    const gitMode = getGitModeContext();
+    const unregisterGitBlocker = gitMode.registerBlocker("roleplay-context-draft", () => "The roleplay context editor is open.");
+    onDestroy(unregisterGitBlocker);
     $$renderer2.push(`<div class="min-h-0 flex-1 overflow-hidden p-3">`);
     ContextEditor($$renderer2, {
       class: "h-full min-h-0 border-thin border-rc-gray-650 shadow-inner-white-soft backdrop-blur-3xl focus:outline-none focus:ring-0",
@@ -773,6 +930,7 @@ function _layout($$renderer, $$props) {
   $$renderer.component(($$renderer2) => {
     let { params, children } = $$props;
     const { onError } = getAgentsContext();
+    const gitMode = getGitModeContext();
     let agents = [];
     const dec = (s) => {
       try {
@@ -797,6 +955,7 @@ function _layout($$renderer, $$props) {
       currentStep: null,
       promptDrafts: {},
       promptEdits: {},
+      testHistoryEdits: {},
       context: null,
       promptContext: null,
       agentStates: [],
@@ -814,11 +973,17 @@ function _layout($$renderer, $$props) {
       else url.searchParams.set(key, value);
       replaceState(url.toString());
     }
-    function sendAppEvent(event) {
-      wsClient.sendMessage({ channel: "app-events", event });
+    function sendAppEvent(event, options) {
+      wsClient.sendMessage({ channel: "app-events", event }, options);
+    }
+    function flushWebSocketWrites(context) {
+      if (!wsClient.isReady()) return Promise.resolve();
+      return wsClient.sendGitSyncRequest(crypto.randomUUID(), context.operationId);
     }
+    gitMode.registerFlusher("edit-websocket-writes", flushWebSocketWrites, { final: true });
     const activeStepName = derived(() => workspace.currentStep?.name ?? null);
     const promptEditKey = (agentId, stepName) => `${agentId}\0${stepName}`;
+    const testHistoryEditKey = (agentId, region, testId) => `${agentId}\0${region ?? ""}\0${testId}`;
     const activePromptEdit = derived(() => {
       const stepName = activeStepName();
       if (!stepName) return null;
@@ -831,6 +996,7 @@ function _layout($$renderer, $$props) {
       return typeof draft === "string" ? draft : "";
     });
     const activeRuntimePrompt = derived(() => activePromptEdit()?.suggestedPrompt ?? activePromptDraft());
+    const promptWritesPaused = derived(() => gitMode.isWritePaused());
     function getPromptOverrides(agentId = workspace.agentId) {
       const overrides = {};
       for (const proposal of Object.values(workspace.promptEdits)) {
@@ -838,6 +1004,15 @@ function _layout($$renderer, $$props) {
       }
       return overrides;
     }
+    function getTestHistoryOverrides(agentId = workspace.agentId, region = workspace.region) {
+      const overrides = {};
+      for (const proposal of Object.values(workspace.testHistoryEdits)) {
+        if (proposal.agentId === agentId && proposal.region === region) {
+          overrides[proposal.testId] = { conversation: proposal.suggestedConversation };
+        }
+      }
+      return overrides;
+    }
     function syncRuntimePromptOverrides() {
       if (!workspace.wsLoaded) return;
       sendAppEvent({
@@ -851,16 +1026,23 @@ function _layout($$renderer, $$props) {
     }
     let promptSaveTimer = null;
     let pendingPromptSave = null;
+    let acceptedPromptSaveToSkip = null;
     let promptSaveQueue = Promise.resolve();
+    let promptSaveInFlight = 0;
     const PROMPT_SAVE_DEBOUNCE_MS = 800;
     function clearPromptSaveTimer() {
       if (!promptSaveTimer) return;
       clearTimeout(promptSaveTimer);
       promptSaveTimer = null;
     }
-    async function persistPromptSave(agentId, stepName, prompt) {
+    async function persistPromptSave(agentId, stepName, prompt, flushContext) {
+      promptSaveInFlight += 1;
       try {
-        await trpc.agents.savePrompt.mutate({ agentId, step: stepName, prompt });
+        await trpc.agents.savePrompt.mutate({ agentId, step: stepName, prompt }, flushContext ? gitFlushRequestOptions(flushContext.operationId) : void 0);
+        if (workspace.agentId === agentId) {
+          workspace.steps = workspace.steps.map((step) => step.name === stepName ? { ...step, prompt } : step);
+          workspace.currentStep = workspace.steps.find((step) => step.name === activeStepName()) ?? workspace.currentStep;
+        }
       } catch (error) {
         console.error("Failed to save prompt", error);
         const currentDraft = workspace.promptDrafts[stepName];
@@ -868,23 +1050,29 @@ function _layout($$renderer, $$props) {
           pendingPromptSave = { stepName, prompt };
         }
         throw error;
+      } finally {
+        promptSaveInFlight -= 1;
       }
     }
-    function queuePromptSave(agentId, stepName, prompt) {
+    function queuePromptSave(agentId, stepName, prompt, flushContext) {
       const op = promptSaveQueue.catch(() => {
-      }).then(() => persistPromptSave(agentId, stepName, prompt));
+      }).then(() => persistPromptSave(agentId, stepName, prompt, flushContext));
       promptSaveQueue = op.catch(() => {
       });
       return op;
     }
-    async function flushPromptSave() {
-      if (!pendingPromptSave) return;
-      const agentId = workspace.agentId.trim();
-      if (!agentId) return;
-      const { stepName, prompt } = pendingPromptSave;
-      clearPromptSaveTimer();
-      pendingPromptSave = null;
-      await queuePromptSave(agentId, stepName, prompt);
+    async function flushPromptSave(force = false, flushContext) {
+      if (!force && gitMode.isWritePaused()) return;
+      await promptSaveQueue;
+      while (pendingPromptSave) {
+        const agentId = workspace.agentId.trim();
+        if (!agentId) return;
+        const { stepName, prompt } = pendingPromptSave;
+        clearPromptSaveTimer();
+        pendingPromptSave = null;
+        await queuePromptSave(agentId, stepName, prompt, flushContext);
+        await promptSaveQueue;
+      }
     }
     function schedulePromptSave(stepName, prompt) {
       pendingPromptSave = { stepName, prompt };
@@ -892,19 +1080,33 @@ function _layout($$renderer, $$props) {
       promptSaveTimer = setTimeout(
         () => {
           promptSaveTimer = null;
+          if (gitMode.isWritePaused()) return;
           void flushPromptSave();
         },
         PROMPT_SAVE_DEBOUNCE_MS
       );
     }
+    const unregisterGitPromptFlusher = gitMode.registerFlusher("edit-prompt", (context) => flushPromptSave(true, context));
+    const unregisterGitPromptBlocker = gitMode.registerBlocker("edit-prompt-save", () => {
+      if (promptSaveTimer || pendingPromptSave || promptSaveInFlight > 0) {
+        return "A prompt edit is still being saved.";
+      }
+      return null;
+    });
     function handlePromptChanged(newPrompt) {
       const stepName = activeStepName();
       if (!stepName) return;
       workspace.promptDrafts[stepName] = newPrompt;
+      if (acceptedPromptSaveToSkip?.stepName === stepName && acceptedPromptSaveToSkip.prompt === newPrompt) {
+        acceptedPromptSaveToSkip = null;
+        return;
+      }
+      acceptedPromptSaveToSkip = null;
       schedulePromptSave(stepName, newPrompt);
     }
     let aiEditModalOpen = false;
     let aiEditRequest = "";
+    let aiEditTarget = null;
     let aiEditGenerating = false;
     let aiEditProgress = null;
     function formatAiEditStatus(summary) {
@@ -916,10 +1118,37 @@ function _layout($$renderer, $$props) {
     let aiEditResolutionError = null;
     let aiEditResolving = false;
     let noChangesModalOpen = false;
+    let aiEditGenerationInFlight = 0;
     let aiEditRequestId = 0;
-    function openAiEditModal() {
-      if (!workspace.currentStep || activePromptEdit()) return;
-      aiEditRequest = "";
+    let editShellDestroyed = false;
+    const unregisterGitAiEditBlocker = gitMode.registerBlocker("ai-prompt-edit", () => {
+      if (aiEditGenerationInFlight > 0 || aiEditGenerating) {
+        return "An AI edit is still being generated.";
+      }
+      if (aiEditResolving) return "An AI edit is still being accepted.";
+      if (Object.keys(workspace.promptEdits).length > 0) {
+        return "Accept or reject the pending AI prompt edit before refreshing.";
+      }
+      if (Object.keys(workspace.testHistoryEdits).length > 0) {
+        return "Accept or reject the pending AI test history edit before refreshing.";
+      }
+      if (aiEditModalOpen && aiEditRequest.trim()) {
+        return "Finish or cancel the open AI edit before refreshing.";
+      }
+      return null;
+    });
+    function aiEditStartIsBlocked() {
+      if (!gitMode.isWritePaused() && !gitMode.isActivationStarting()) return false;
+      gitMode.requestBlockedOperationNotice();
+      return true;
+    }
+    function openAiEditModal(request = "", target) {
+      if (!workspace.currentStep) return;
+      const targetPromptEdit = target ? activePromptEditFor(workspace.agentId, target.step) : activePromptEdit();
+      if ((!target || target.kind === "test-fix") && targetPromptEdit) return;
+      if (aiEditStartIsBlocked()) return;
+      aiEditRequest = request;
+      aiEditTarget = target ?? null;
       aiEditError = null;
       noChangesModalOpen = false;
       aiEditModalOpen = true;
@@ -928,6 +1157,7 @@ function _layout($$renderer, $$props) {
       aiEditRequestId += 1;
       aiEditGenerating = false;
       aiEditModalOpen = false;
+      aiEditTarget = null;
       noChangesModalOpen = false;
     }
     async function pollAiEditProgress(progressId, requestId) {
@@ -952,34 +1182,88 @@ function _layout($$renderer, $$props) {
     }
     async function requestAiEdit() {
       const request = aiEditRequest.trim();
-      const stepName = activeStepName();
+      const target = aiEditTarget;
+      const stepName = target?.step ?? activeStepName();
       const agentId = workspace.agentId.trim();
       if (!request || !stepName || !agentId || aiEditGenerating) return;
+      if (aiEditStartIsBlocked()) return;
       const requestId = ++aiEditRequestId;
       const progressId = crypto.randomUUID();
       aiEditGenerating = true;
+      aiEditGenerationInFlight += 1;
       aiEditProgress = null;
       aiEditError = null;
       void pollAiEditProgress(progressId, requestId);
       try {
-        await flushPromptSave();
-        const result = await trpc.agents.suggestPromptEdit.mutate({ agentId, step: stepName, request, progressId });
+        if (!target) {
+          await flushPromptSave();
+          if (editShellDestroyed || requestId !== aiEditRequestId) return;
+          if (gitMode.isWritePaused()) {
+            gitMode.requestBlockedOperationNotice();
+            return;
+          }
+        }
+        let historyProposal = null;
+        let historyResult = null;
+        let result = null;
+        if (target?.kind === "test-fix") {
+          const fixResult = await trpc.agents.suggestTestFix.mutate({
+            agentId,
+            region: workspace.region,
+            testId: target.testId,
+            step: stepName,
+            request,
+            prompt: target.prompt,
+            basePrompt: target.basePrompt,
+            currentIncorrectOutcome: target.currentIncorrectOutcome ?? "",
+            progressId
+          });
+          historyResult = fixResult.history;
+          result = fixResult.prompt;
+        } else if (target) {
+          historyResult = await trpc.tests.suggestHistoryEdit.mutate({
+            agent: agentId,
+            region: workspace.region,
+            testId: target.testId,
+            step: stepName,
+            request,
+            prompt: target.prompt,
+            basePrompt: target.basePrompt,
+            progressId
+          });
+        } else {
+          result = await trpc.agents.suggestPromptEdit.mutate({ agentId, step: stepName, request, progressId });
+        }
         if (requestId !== aiEditRequestId) return;
-        if (result.status === "unchanged") {
+        if (target && historyResult?.status === "changed") {
+          historyProposal = historyResult.proposal;
+        }
+        if (!historyProposal && (!result || result.status === "unchanged")) {
           noChangesModalOpen = true;
           return;
         }
-        const proposal = result.proposal;
-        workspace.promptEdits[promptEditKey(proposal.agentId, proposal.step)] = proposal;
-        setQueryParam("promptEdit", proposal.id);
+        if (historyProposal) {
+          workspace.testHistoryEdits[testHistoryEditKey(historyProposal.agentId, historyProposal.region, historyProposal.testId)] = historyProposal;
+        }
+        if (result?.status === "changed") {
+          const proposal = result.proposal;
+          workspace.promptEdits[promptEditKey(proposal.agentId, proposal.step)] = proposal;
+          setQueryParam("promptEdit", proposal.id);
+          previewEnabled = false;
+          syncRuntimePromptOverrides();
+        }
         aiEditModalOpen = false;
-        previewEnabled = false;
-        syncRuntimePromptOverrides();
+        aiEditTarget = null;
       } catch (error) {
         if (requestId !== aiEditRequestId) return;
+        if (isGitModeMutationBlockedError(error)) {
+          gitMode.requestBlockedOperationNotice();
+          return;
+        }
         console.error("Failed to suggest prompt edits", error);
         aiEditError = error instanceof Error ? error.message : "Failed to suggest edits";
       } finally {
+        aiEditGenerationInFlight -= 1;
         if (requestId === aiEditRequestId) {
           aiEditGenerating = false;
           aiEditProgress = null;
@@ -992,9 +1276,39 @@ function _layout($$renderer, $$props) {
       }
       if (page.url.searchParams.get("promptEdit") === proposalId) setQueryParam("promptEdit", null);
     }
+    function captureAiEditScroll() {
+      const editor = inspectionPromptEditor ?? pendingDiffModifiedEditor;
+      const viewState = editor?.saveViewState() ?? null;
+      if (!editor || !viewState) return null;
+      const topLine = editor.getVisibleRanges()[0]?.startLineNumber ?? null;
+      return {
+        viewState,
+        topLine,
+        topLineOffset: topLine ? editor.getTopForLineNumber(topLine) - editor.getScrollTop() : 0
+      };
+    }
+    function restoreAiEditScroll(snapshot) {
+      if (!snapshot || !basePromptEditor) return;
+      const editor = basePromptEditor;
+      const apply = () => {
+        if (basePromptEditor !== editor) return;
+        try {
+          editor.restoreViewState(snapshot.viewState);
+          if (snapshot.topLine) {
+            editor.setScrollTop(editor.getTopForLineNumber(snapshot.topLine) - snapshot.topLineOffset);
+          }
+        } catch (error) {
+          console.warn("Failed to preserve prompt scroll position", error);
+        }
+      };
+      apply();
+      requestAnimationFrame(apply);
+    }
     function rejectAiEdit() {
       const proposal = activePromptEdit();
       if (!proposal || aiEditResolving) return;
+      const scrollSnapshot = captureAiEditScroll();
+      restoreAiEditScroll(scrollSnapshot);
       closeModePopover();
       aiEditResolutionError = null;
       removePromptEditFromWorkspace(proposal.id);
@@ -1003,21 +1317,55 @@ function _layout($$renderer, $$props) {
         console.error("Failed to release rejected prompt edit", error);
       });
     }
+    function applyAcceptedPromptToUndoHistory(stepName, prompt) {
+      if (activeStepName() !== stepName || !basePromptEditor) return false;
+      const model = basePromptEditor.getModel();
+      if (!model) return false;
+      if (model.getValue() === prompt) return true;
+      try {
+        acceptedPromptSaveToSkip = { stepName, prompt };
+        model.pushStackElement();
+        model.pushEditOperations(
+          basePromptEditor.getSelections(),
+          [
+            {
+              range: model.getFullModelRange(),
+              text: prompt,
+              forceMoveMarkers: true
+            }
+          ],
+          () => null
+        );
+        model.pushStackElement();
+        return model.getValue() === prompt;
+      } catch (error) {
+        console.warn("Failed to add the accepted prompt edit to Monaco undo history", error);
+        return false;
+      } finally {
+        acceptedPromptSaveToSkip = null;
+      }
+    }
     async function acceptAiEdit() {
       const proposal = activePromptEdit();
       if (!proposal || aiEditResolving) return;
+      const scrollSnapshot = captureAiEditScroll();
       closeModePopover();
       aiEditResolving = true;
       aiEditResolutionError = null;
       try {
         const result = await trpc.agents.acceptPromptEdit.mutate({ id: proposal.id });
+        if (editShellDestroyed) return;
+        applyAcceptedPromptToUndoHistory(proposal.step, result.prompt);
         workspace.promptDrafts[proposal.step] = result.prompt;
         workspace.steps = workspace.steps.map((step) => step.name === proposal.step ? { ...step, prompt: result.prompt } : step);
         workspace.currentStep = workspace.steps.find((step) => step.name === activeStepName()) ?? workspace.currentStep;
         await tick();
+        if (editShellDestroyed) return;
+        restoreAiEditScroll(scrollSnapshot);
         removePromptEditFromWorkspace(proposal.id);
         syncRuntimePromptOverrides();
       } catch (error) {
+        if (editShellDestroyed) return;
         console.error("Failed to accept prompt edit", error);
         aiEditResolutionError = error instanceof Error ? error.message : "Failed to save prompt";
       } finally {
@@ -1032,6 +1380,11 @@ function _layout($$renderer, $$props) {
     let schemaSaveError = null;
     let schemaSaveNotice = null;
     const schemaDirty = derived(() => schemaDraft !== (schemaValue() ?? ""));
+    const unregisterGitSchemaBlocker = gitMode.registerBlocker("schema-draft", () => {
+      if (schemaSaving) return "The schema is still being saved.";
+      if (schemaModalOpen && schemaDirty()) return "An unsaved schema draft is open.";
+      return null;
+    });
     function openSchemaModal() {
       if (!schemaValue()) return;
       schemaDraft = schemaValue();
@@ -1133,6 +1486,9 @@ function _layout($$renderer, $$props) {
     }
     let basePromptHighlighter = null;
     let inspectionPromptHighlighter = null;
+    let basePromptEditor = null;
+    let inspectionPromptEditor = null;
+    let pendingDiffModifiedEditor = null;
     let previewEnabled = false;
     function renderPromptPreview(prompt) {
       try {
@@ -1154,11 +1510,13 @@ function _layout($$renderer, $$props) {
       return previewEnabled ? renderPromptPreview(proposal.suggestedPrompt) : proposal.suggestedPrompt;
     });
     function handleBasePromptEditorReady(editor, monaco) {
+      basePromptEditor = editor;
       basePromptHighlighter?.dispose();
       basePromptHighlighter = createPromptHighlighter(editor, monaco);
       basePromptHighlighter.setHighlights(workspace.edit.highlights);
     }
     function handleInspectionPromptEditorReady(editor, monaco) {
+      inspectionPromptEditor = editor;
       inspectionPromptHighlighter?.dispose();
       inspectionPromptHighlighter = createPromptHighlighter(editor, monaco);
       inspectionPromptHighlighter.setHighlights(workspace.edit.highlights);
@@ -1252,17 +1610,19 @@ function _layout($$renderer, $$props) {
         openContextPopover,
         closeContextPopover,
         toggleContextPopover,
+        openAiEdit: (request, target) => openAiEditModal(request, target),
         sendAppEvent,
         sendChatMessage: (message) => {
           if (!workspace.wsLoaded || !workspace.chatReady) {
             console.warn("[roleplay] Ignoring chat message while websocket session is reconnecting");
-            return;
+            return false;
           }
           syncRuntimePromptOverrides();
-          wsClient.sendMessage({ channel: "chat", message });
+          return wsClient.sendMessage({ channel: "chat", message }) === "sent";
         },
         flushPromptSave,
         getPromptOverrides: () => getPromptOverrides(),
+        getTestHistoryOverrides: () => getTestHistoryOverrides(),
         getActivePromptEditId: () => activePromptEdit()?.id ?? null,
         selectState: (stateId) => {
           void flushPromptSave();
@@ -1288,12 +1648,23 @@ function _layout($$renderer, $$props) {
       }
     });
     onDestroy(() => {
+      editShellDestroyed = true;
+      aiEditRequestId += 1;
+      aiEditGenerating = false;
+      unregisterGitPromptFlusher();
+      unregisterGitPromptBlocker();
+      unregisterGitAiEditBlocker();
+      unregisterGitSchemaBlocker();
+      wsClient.clearDeferredMessages();
       void flushPromptSave();
       clearPromptSaveTimer();
       basePromptHighlighter?.dispose();
       basePromptHighlighter = null;
+      basePromptEditor = null;
       inspectionPromptHighlighter?.dispose();
       inspectionPromptHighlighter = null;
+      inspectionPromptEditor = null;
+      pendingDiffModifiedEditor = null;
     });
     let $$settled = true;
     let $$inner_renderer;
@@ -1400,7 +1771,9 @@ function _layout($$renderer, $$props) {
       } else {
         $$renderer3.push("<!--[-1-->");
       }
-      $$renderer3.push(`<!--]--></div></nav> <div class="flex-1 overflow-hidden"><div class="grid h-full w-full grid-cols-[minmax(140px,2fr)_minmax(0,10fr)_minmax(0,11fr)]">`);
+      $$renderer3.push(`<!--]--> `);
+      GitControlsButton($$renderer3);
+      $$renderer3.push(`<!----></div></nav> <div class="flex-1 overflow-hidden"><div class="grid h-full w-full grid-cols-[minmax(140px,2fr)_minmax(0,10fr)_minmax(0,11fr)]">`);
       Panel($$renderer3, {
         class: "flex h-full min-w-0 flex-col !rounded-none p-0",
         children: ($$renderer4) => {
@@ -1438,7 +1811,7 @@ function _layout($$renderer, $$props) {
       Button($$renderer3, {
         variant: "secondary",
         disabled: !workspace.currentStep || !!activePromptEdit() || aiEditGenerating,
-        onclick: openAiEditModal,
+        onclick: () => openAiEditModal(),
         children: ($$renderer4) => {
           $$renderer4.push(`<!---->Edit with AI`);
         },
@@ -1450,18 +1823,19 @@ function _layout($$renderer, $$props) {
         $$renderer3.push(`<div class="relative h-full min-w-0"><!---->`);
         {
           PromptEditor($$renderer3, {
-            class: "h-full min-w-0 border-thin border-rc-gray-650 bg-rc-gray-800 shadow-inner-white-soft backdrop-blur-3xl focus:outline-none focus:ring-0",
+            class: "h-full min-w-0 focus:outline-none focus:ring-0",
             initialPrompt: activePromptDraft(),
             agentId: workspace.agentId,
             stepName: workspace.currentStep.name,
             onPromptChanged: handlePromptChanged,
             showSchemaButton: hasSchema() && !activePromptEdit(),
             onSchemaClick: openSchemaModal,
-            readOnly: !!activePromptEdit(),
-            readOnlyMessage: activePromptEdit() ? "Accept or reject the AI suggestion before editing." : "",
+            readOnly: !!activePromptEdit() || promptWritesPaused(),
+            readOnlyMessage: activePromptEdit() ? "Accept or reject the AI suggestion before editing." : promptWritesPaused() ? "Bosun is refreshing the project." : "",
             showPreviewToggle: false,
             preview: activePromptEdit() ? false : previewEnabled,
-            onEditorReady: handleBasePromptEditorReady
+            onEditorReady: handleBasePromptEditorReady,
+            onReadOnlyEditAttempt: gitMode.requestBlockedOperationNotice
           });
         }
         $$renderer3.push(`<!----> `);
@@ -1471,7 +1845,7 @@ function _layout($$renderer, $$props) {
           if (workspace.edit.popover) {
             $$renderer3.push("<!--[0-->");
             PromptEditor($$renderer3, {
-              class: "h-full min-w-0 border-thin border-rc-gray-650 bg-rc-gray-800 shadow-inner-white-soft backdrop-blur-3xl focus:outline-none focus:ring-0",
+              class: "h-full min-w-0 focus:outline-none focus:ring-0",
               initialPrompt: activePromptEdit().suggestedPrompt,
               agentId: workspace.agentId,
               stepName: workspace.currentStep.name,
@@ -1482,12 +1856,13 @@ function _layout($$renderer, $$props) {
               readOnlyMessage: "Accept or reject the AI suggestion before editing.",
               bottomPadding: 56,
               showPreviewToggle: false,
-              onEditorReady: handleInspectionPromptEditorReady
+              onEditorReady: handleInspectionPromptEditorReady,
+              onReadOnlyEditAttempt: gitMode.requestBlockedOperationNotice
             });
           } else {
             $$renderer3.push("<!--[-1-->");
             ReadOnlyMonacoDiff($$renderer3, {
-              class: "h-full min-w-0 !rounded-none",
+              class: "h-full min-w-0",
               original: pendingDiffOriginal(),
               modified: pendingDiffModified()
             });
@@ -1790,4 +2165,4 @@ function _layout($$renderer, $$props) {
 }
 
 export { _layout as default };
-//# sourceMappingURL=_layout.svelte-B88WMyk0.js.map
+//# sourceMappingURL=_layout.svelte-D6rhwm98.js.map