spec-cat 0.1.21 → 0.1.23

package/.output/server/chunks/routes/_ws.mjs

@@ -1,12 +1,6 @@
-import { n as defineWebSocketHandler, e as getProjectDir } from '../nitro/nitro.mjs';
-import { existsSync } from 'node:fs';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { join } from 'node:path';
-import { r as resolveServerProviderSelection, a as guardProviderCapability } from '../_/aiProviderSelection.mjs';
-import { s as streamChatWithProvider, h as hasCodexPermissionError, a as hasCodexMissingRolloutPathError, b as summarizeProviderProcessError } from '../_/providerProcessError.mjs';
-import { g as getProvider } from '../_/aiProviderRegistry.mjs';
-import { n as normalizeToolName, e as extractPermissionRequestFromProcessOutput, a as normalizeTools, c as checkForPermissionRequest, i as isRenderableEvent } from '../_/uiAdapter.mjs';
+import { n as defineWebSocketHandler } from '../nitro/nitro.mjs';
+import { e as eventBus, G as GLOBAL_CHANNEL, n as normalizeImageAttachments, j as jobQueue } from '../_/jobQueue.mjs';
+import { s as startPersisting } from '../_/jobPersister.mjs';
 import 'node:http';
 import 'node:https';
 import 'node:crypto';
@@ -22,212 +16,69 @@ import 'tls';
 import 'url';
 import 'node:events';
 import 'node:buffer';
+import 'node:fs';
+import 'node:path';
 import 'node:os';
 import 'node:module';
 import 'node:fs/promises';
 import 'node:url';
+import 'node:child_process';
+import 'node:util';
+import '../_/aiProviderSelection.mjs';
+import '../_/aiProviderRegistry.mjs';
+import '../_/providerProcessError.mjs';
+import '../_/uiAdapter.mjs';
+import '../_/conversationStore.mjs';
 
-const execAsync = promisify(exec);
-const WORKTREE_PREFIX = "/tmp/sc-";
-async function ensureChatWorktree(projectDir, worktreePath, knownBranch) {
-  if (!worktreePath.startsWith(WORKTREE_PREFIX)) {
-    return { recovered: false };
-  }
-  if (existsSync(worktreePath)) {
-    return { recovered: false };
+const peerConnections = /* @__PURE__ */ new Map();
+function getPeerConnection(peerId) {
+  let conn = peerConnections.get(peerId);
+  if (!conn) {
+    conn = { conversationId: null, unsubscribe: null, unsubscribeGlobal: null };
+    peerConnections.set(peerId, conn);
+  }
+  return conn;
+}
+function subscribePeerToConversation(peer, conversationId) {
+  const conn = getPeerConnection(peer.id);
+  if (conn.conversationId === conversationId && conn.unsubscribe) {
+    return;
   }
-  let branchName;
-  if (knownBranch) {
-    branchName = knownBranch;
-  } else {
-    const convId = worktreePath.slice(WORKTREE_PREFIX.length);
-    if (!convId) {
-      return { recovered: false, error: `Cannot derive branch name from worktree path: ${worktreePath}` };
-    }
-    branchName = `sc/${convId}`;
+  if (conn.unsubscribe) {
+    conn.unsubscribe();
   }
-  try {
-    await execAsync("git worktree prune", { cwd: projectDir });
+  conn.conversationId = conversationId;
+  conn.unsubscribe = eventBus.subscribe(conversationId, (event) => {
     try {
-      await execAsync(`git rev-parse --verify "${branchName}"`, { cwd: projectDir });
-    } catch {
-      return { recovered: false, error: `Branch "${branchName}" no longer exists` };
-    }
-    await execAsync(`git worktree add "${worktreePath}" "${branchName}"`, { cwd: projectDir });
-    console.log(`[ensureChatWorktree] Recovered worktree: ${worktreePath} \u2192 ${branchName}`);
-    return { recovered: true };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[ensureChatWorktree] Recovery failed for ${worktreePath}:`, message);
-    return { recovered: false, error: `Worktree recovery failed: ${message}` };
-  }
-}
-
-async function loadSpecContext(projectDir, featureId) {
-  const featurePath = join(projectDir, "specs", featureId);
-  const specPath = join(featurePath, "spec.md");
-  if (!existsSync(specPath)) {
-    return null;
-  }
-  const sections = [];
-  sections.push(`# Feature Context: ${featureId}`);
-  sections.push("");
-  sections.push("You are working on the feature described in the following specification files.");
-  sections.push("You MUST read these files first to understand the feature requirements:");
-  sections.push("");
-  sections.push(`- specs/${featureId}/spec.md`);
-  const planPath = join(featurePath, "plan.md");
-  if (existsSync(planPath)) {
-    sections.push(`- specs/${featureId}/plan.md`);
-  }
-  const tasksPath = join(featurePath, "tasks.md");
-  if (existsSync(tasksPath)) {
-    sections.push(`- specs/${featureId}/tasks.md`);
-  }
-  sections.push("");
-  sections.push("## Spec-Driven Workflow (MANDATORY)");
-  sections.push("");
-  sections.push("This chat is linked to a feature spec. You MUST follow the spec-driven workflow:");
-  sections.push("");
-  sections.push("1. **Read the spec files above** before doing anything else.");
-  sections.push("2. **When the user requests changes or new functionality:**");
-  sections.push("   - First, update the relevant spec file(s) (spec.md, plan.md, tasks.md) to reflect the new requirements.");
-  sections.push("   - Then, implement the code changes according to the updated spec.");
-  sections.push("   - Never skip the spec update step. The spec is the source of truth.");
-  sections.push("3. **When the user requests a bug fix:**");
-  sections.push("   - Check if the bug contradicts the spec. If so, fix the code to match the spec.");
-  sections.push("   - If the spec itself is wrong, update the spec first, then fix the code.");
-  sections.push("4. **FR Traceability:** Every change must be traceable from spec \u2192 plan \u2192 task \u2192 implementation.");
-  return sections.join("\n");
-}
-
-function isApprovalMode(mode) {
-  return mode === "ask" || mode === "plan";
-}
-function deriveApprovalRequestFromEvent(event, approvedTools, providerId, mode) {
-  if (!isApprovalMode(mode)) return null;
-  return checkForPermissionRequest(event, approvedTools, providerId);
-}
-function deriveApprovalRequestFromProcessOutput(nonJsonOutput, mode) {
-  if (!isApprovalMode(mode)) return null;
-  const inferred = extractPermissionRequestFromProcessOutput(nonJsonOutput);
-  if (!inferred) return null;
-  const tools = normalizeTools(inferred.tools);
-  return {
-    type: "permission_request",
-    tool: tools[0] || "Permission",
-    tools,
-    description: inferred.description
-  };
-}
-function approveTools(approvedTools, tools) {
-  for (const tool of tools) {
-    const normalized = normalizeToolName(tool);
-    if (normalized) {
-      approvedTools.add(normalized);
-    }
-  }
-}
-
-const peerStates = /* @__PURE__ */ new Map();
-const MAX_ATTACHMENT_COUNT = 4;
-const MAX_ATTACHMENT_SIZE_BYTES = 5 * 1024 * 1024;
-const SPECKIT_AUTONOMY_DIRECTIVE = [
-  "Speckit Execution Mode (MANDATORY):",
-  "- Do not ask the user for confirmation, follow-up, or permission to proceed.",
-  '- Do not end with questions like "Would you like me to..." or "Shall I...".',
-  "- For remediation and traceability gaps, directly edit the relevant spec files now (spec.md, plan.md, tasks.md) when writable.",
-  "- Prefer concrete file edits over recommendations; provide a brief change summary after edits are complete.",
-  "- Only stop without edits if blocked by a hard constraint (missing files, permission failure), and report the blocker explicitly."
-].join("\n");
-function getPeerState(peerId) {
-  let state = peerStates.get(peerId);
-  if (!state) {
-    state = {
-      proc: null,
-      procGeneration: 0,
-      pendingMessage: null,
-      approvedTools: /* @__PURE__ */ new Set(),
-      pendingTools: [],
-      providerSessionId: null
-    };
-    peerStates.set(peerId, state);
-  }
-  return state;
-}
-function isSpeckitCommand(message) {
-  return message.trim().startsWith("/speckit.");
-}
-function killProc(proc) {
-  try {
-    proc.kill();
-  } catch {
-  }
-}
-function normalizeImageAttachments(attachments) {
-  if (!Array.isArray(attachments)) return [];
-  return attachments.slice(0, MAX_ATTACHMENT_COUNT).map((item) => {
-    if (!item || typeof item !== "object") return null;
-    const record = item;
-    const id = typeof record.id === "string" ? record.id : "";
-    const name = typeof record.name === "string" ? record.name : "image";
-    const mimeType = typeof record.mimeType === "string" ? record.mimeType : "";
-    const size = typeof record.size === "number" ? record.size : 0;
-    const dataUrl = typeof record.dataUrl === "string" ? record.dataUrl : "";
-    if (!id || !mimeType.startsWith("image/") || size <= 0 || size > MAX_ATTACHMENT_SIZE_BYTES || !dataUrl.startsWith("data:image/")) {
-      return null;
+      peer.send(JSON.stringify(event));
+    } catch (err) {
+      console.error("[WS] Failed to send event to peer:", err);
     }
-    return { id, name, mimeType, size, dataUrl };
-  }).filter((entry) => entry !== null);
-}
-function buildProviderMessage(baseMessage, attachments) {
-  if (attachments.length === 0) return baseMessage;
-  const lines = [];
-  if (baseMessage.trim().length > 0) {
-    lines.push(baseMessage);
-    lines.push("");
-  } else {
-    lines.push("User sent image attachments without additional text.");
-    lines.push("");
-  }
-  lines.push("Attached images (data URLs):");
-  attachments.forEach((attachment, index) => {
-    lines.push(`${index + 1}. ${attachment.name} (${attachment.mimeType}, ${attachment.size} bytes)`);
-    lines.push(attachment.dataUrl);
-    lines.push("");
   });
-  lines.push("Use the attached images as part of your answer.");
-  return lines.join("\n");
-}
-function sendAssistantText(peer, text, sessionId) {
-  peer.send(JSON.stringify({
-    type: "ui_event",
-    event: {
-      type: "block_start",
-      sessionId: sessionId || void 0,
-      blockId: `blk-${Date.now()}`,
-      blockType: "text",
-      text
-    }
-  }));
-  peer.send(JSON.stringify({
-    type: "ui_event",
-    event: {
-      type: "block_end",
-      sessionId: sessionId || void 0,
-      blockId: ""
-    }
-  }));
 }
 const _ws = defineWebSocketHandler({
-  open(_peer) {
+  open(peer) {
+    console.log("[WS] Peer connected:", peer.id);
+    const conn = getPeerConnection(peer.id);
+    conn.unsubscribeGlobal = eventBus.subscribe(GLOBAL_CHANNEL, (event) => {
+      try {
+        const payload = JSON.stringify(event);
+        if (event.type === "notification") {
+          console.log("[WS] Forwarding global notification to peer", peer.id, ":", event.notificationEvent);
+        }
+        peer.send(payload);
+      } catch (err) {
+        console.error("[WS] Failed to send global event to peer:", err);
+      }
+    });
   },
   close(peer) {
-    const state = peerStates.get(peer.id);
-    if (state == null ? void 0 : state.proc) {
-      killProc(state.proc);
+    const conn = peerConnections.get(peer.id);
+    if (conn) {
+      if (conn.unsubscribe) conn.unsubscribe();
+      if (conn.unsubscribeGlobal) conn.unsubscribeGlobal();
     }
-    peerStates.delete(peer.id);
+    peerConnections.delete(peer.id);
   },
   error(peer, error) {
     console.error("[WS] Error for peer", peer.id, ":", error);
@@ -260,67 +111,13 @@ const _ws = defineWebSocketHandler({
       handleResetContext(peer);
       return;
     }
+    if (msg.type === "subscribe") {
+      handleSubscribe(peer, msg);
+      return;
+    }
   }
 });
-function handlePermissionResponse(peer, msg) {
-  var _a, _b;
-  const state = getPeerState(peer.id);
-  console.log("[WS] Permission response:", {
-    allow: msg.allow,
-    pendingTools: state.pendingTools,
-    approvedTools: Array.from(state.approvedTools),
-    sessionId: state.providerSessionId,
-    providerId: (_a = state.pendingMessage) == null ? void 0 : _a.providerId,
-    providerModelKey: (_b = state.pendingMessage) == null ? void 0 : _b.providerModelKey
-  });
-  if (msg.allow && state.pendingMessage) {
-    approveTools(state.approvedTools, state.pendingTools);
-    console.log("[WS] Tools approved:", state.pendingTools, "- Total approved:", Array.from(state.approvedTools));
-    state.pendingTools = [];
-    const resumeMode = state.pendingMessage.permissionMode || "ask";
-    runProvider(peer, state, {
-      ...state.pendingMessage,
-      permissionMode: resumeMode
-    });
-  } else {
-    state.pendingTools = [];
-    state.pendingMessage = null;
-    peer.send(JSON.stringify({ type: "done", requestId: "denied", denied: true }));
-  }
-}
-function handleAbort(peer) {
-  const state = getPeerState(peer.id);
-  console.log("[WS] Abort requested for peer:", peer.id);
-  if (state.proc) {
-    state.procGeneration++;
-    killProc(state.proc);
-    state.proc = null;
-  }
-  state.pendingMessage = null;
-  state.pendingTools = [];
-  peer.send(JSON.stringify({ type: "aborted" }));
-  console.log("[WS] Abort completed for peer:", peer.id);
-}
-function clearProviderSession(state) {
-  if (state.proc) {
-    state.procGeneration++;
-    killProc(state.proc);
-    state.proc = null;
-  }
-  state.providerSessionId = null;
-  state.approvedTools.clear();
-  state.pendingMessage = null;
-  state.pendingTools = [];
-}
-function handleResetContext(peer) {
-  const state = getPeerState(peer.id);
-  console.log("[WS] Reset context requested for peer:", peer.id);
-  clearProviderSession(state);
-  peer.send(JSON.stringify({ type: "context_reset" }));
-  console.log("[WS] Context reset completed for peer:", peer.id);
-}
-async function handleChatMessage(peer, msg) {
-  const state = getPeerState(peer.id);
+function handleChatMessage(peer, msg) {
   const attachments = normalizeImageAttachments(msg.attachments);
   if (typeof msg.message !== "string") {
     console.error("[WS] Invalid chat message - missing or invalid message property:", msg);
@@ -339,291 +136,100 @@ async function handleChatMessage(peer, msg) {
     }));
     return;
   }
-  const speckitCommand = isSpeckitCommand(msg.message);
-  if (speckitCommand) {
-    console.log("[WS] Speckit command detected - auto-resetting context for peer:", peer.id);
-    clearProviderSession(state);
-  } else {
-    if (state.proc) {
-      state.procGeneration++;
-      killProc(state.proc);
-      state.proc = null;
-    }
-  }
-  state.pendingMessage = msg;
-  state.pendingTools = [];
-  if (!speckitCommand && msg.sessionId) {
-    state.providerSessionId = msg.sessionId;
-  } else if (!speckitCommand) {
-    state.approvedTools.clear();
-    state.providerSessionId = null;
-  }
-  console.log("[WS] Chat message received:", {
-    hasSessionId: !!msg.sessionId,
-    sessionId: state.providerSessionId,
-    approvedTools: Array.from(state.approvedTools),
-    attachmentCount: attachments.length,
-    providerId: msg.providerId,
-    providerModelKey: msg.providerModelKey,
-    isSpeckitCommand: speckitCommand
-  });
-  runProvider(peer, state, msg);
-}
-async function runProvider(peer, state, msg, isRetry = false, forceEphemeral = false) {
-  const requestedSelection = msg.providerId ? { providerId: msg.providerId, modelKey: msg.providerModelKey || "" } : { providerId: "claude", modelKey: msg.providerModelKey || "" };
-  const selection = await resolveServerProviderSelection(requestedSelection);
-  const provider = getProvider(selection.providerId);
-  if (!provider) {
+  if (!msg.conversationId) {
     peer.send(JSON.stringify({
       type: "error",
-      error: `Provider "${selection.providerId}" is not registered`,
+      error: "Invalid message: conversationId is required",
       requestId: msg.requestId
     }));
     return;
   }
-  const providerGuard = await guardProviderCapability(
-    selection,
-    "streaming",
-    "Choose a provider with streaming capability in Settings."
-  );
-  if ("failure" in providerGuard) {
-    peer.send(JSON.stringify({
-      type: "error",
-      error: providerGuard.failure.error,
-      requestId: msg.requestId
-    }));
+  subscribePeerToConversation(peer, msg.conversationId);
+  const jobMessage = {
+    message: msg.message,
+    conversationId: msg.conversationId,
+    attachments: attachments.length > 0 ? attachments : void 0,
+    requestId: msg.requestId,
+    sessionId: msg.sessionId,
+    permissionMode: msg.permissionMode,
+    cwd: msg.cwd,
+    worktreeBranch: msg.worktreeBranch,
+    featureId: msg.featureId,
+    providerId: msg.providerId,
+    providerModelKey: msg.providerModelKey
+  };
+  startPersisting(msg.conversationId, msg.message);
+  jobQueue.submit(jobMessage);
+}
+function handlePermissionResponse(peer, msg) {
+  const conn = getPeerConnection(peer.id);
+  if (!conn.conversationId) return;
+  console.log("[WS] Permission response:", { allow: msg.allow, conversationId: conn.conversationId });
+  jobQueue.respondToPermission(conn.conversationId, msg.allow);
+}
+function handleAbort(peer) {
+  const conn = getPeerConnection(peer.id);
+  console.log("[WS] Abort requested for peer:", peer.id);
+  if (conn.conversationId) {
+    jobQueue.abort(conn.conversationId);
+  }
+  peer.send(JSON.stringify({ type: "aborted" }));
+  console.log("[WS] Abort completed for peer:", peer.id);
+}
+function handleSubscribe(peer, msg) {
+  if (!msg.conversationId) {
+    peer.send(JSON.stringify({ type: "error", error: "conversationId is required for subscribe" }));
     return;
   }
-  const projectDir = getProjectDir();
-  const workingDirectory = msg.cwd || projectDir;
-  const mode = msg.permissionMode || "ask";
-  if (mode === "ask" || mode === "plan") {
-    const permissionGuard = await guardProviderCapability(
-      selection,
-      "permissions",
-      "Use auto/bypass permission mode or choose a provider that supports permission prompts."
-    );
-    if ("failure" in permissionGuard) {
+  subscribePeerToConversation(peer, msg.conversationId);
+  const activeJob = jobQueue.getActiveJob(msg.conversationId);
+  if (activeJob) {
+    const cursor = typeof msg.cursor === "number" && msg.cursor >= 0 ? msg.cursor : 0;
+    const bufferedEvents = activeJob.events.slice(cursor);
+    if (bufferedEvents.length > 0) {
       peer.send(JSON.stringify({
-        type: "error",
-        error: permissionGuard.failure.error,
-        requestId: msg.requestId
+        type: "replay_start",
+        jobId: activeJob.id,
+        jobStatus: activeJob.status,
+        eventCount: bufferedEvents.length,
+        cursor
       }));
-      return;
-    }
-  }
-  if (workingDirectory.startsWith("/tmp/sc-") && !existsSync(workingDirectory)) {
-    const result = await ensureChatWorktree(projectDir, workingDirectory, msg.worktreeBranch);
-    if (result.recovered) {
-      peer.send(JSON.stringify({ type: "worktree_recovered" }));
-    } else if (result.error) {
+      for (const event of bufferedEvents) {
+        try {
+          peer.send(JSON.stringify(event));
+        } catch {
+          break;
+        }
+      }
       peer.send(JSON.stringify({
-        type: "error",
-        error: `Worktree recovery failed: ${result.error}`,
-        requestId: msg.requestId
+        type: "replay_end",
+        jobId: activeJob.id,
+        nextCursor: activeJob.events.length
+      }));
+    } else {
+      peer.send(JSON.stringify({
+        type: "subscribed",
+        conversationId: msg.conversationId,
+        jobId: activeJob.id,
+        jobStatus: activeJob.status
       }));
-      return;
-    }
-  }
-  const usedResumeFlag = !isRetry && !!state.providerSessionId;
-  const resumeSessionId = usedResumeFlag ? state.providerSessionId : void 0;
-  let systemPrompt;
-  const speckitCommand = isSpeckitCommand(msg.message);
-  if (msg.featureId && !usedResumeFlag) {
-    try {
-      const specContext = await loadSpecContext(projectDir, msg.featureId);
-      if (specContext) {
-        systemPrompt = specContext;
-      }
-    } catch (error) {
-      console.error("[WS] Failed to load spec context:", error);
     }
-  }
-  if (speckitCommand && !usedResumeFlag) {
-    systemPrompt = systemPrompt ? `${systemPrompt}
-
-${SPECKIT_AUTONOMY_DIRECTIVE}` : SPECKIT_AUTONOMY_DIRECTIVE;
-  }
-  console.log("[WS] Running provider stream:", selection.providerId, selection.modelKey, isRetry ? "(retry)" : "");
-  const generation = state.procGeneration;
-  let permissionRequested = false;
-  let emittedRenderableContent = false;
-  let emittedTerminalErrorEvent = false;
-  const attachments = normalizeImageAttachments(msg.attachments);
-  const providerMessage = buildProviderMessage(msg.message, attachments);
-  try {
-    state.proc = await streamChatWithProvider(
-      {
-        message: providerMessage,
-        selection,
-        cwd: workingDirectory,
-        permissionMode: mode,
-        approvedTools: Array.from(state.approvedTools),
-        resumeSessionId,
-        systemPrompt,
-        ephemeral: forceEphemeral && selection.providerId === "codex"
-      },
-      {
-        onProviderJson(parsed) {
-          var _a;
-          const events = provider.toCanonicalEvents(parsed);
-          for (const event of events) {
-            if (event.sessionId) {
-              state.providerSessionId = event.sessionId;
-            }
-            if (isRenderableEvent(event)) {
-              emittedRenderableContent = true;
-            }
-            if (event.type === "error" || event.type === "turn_result" && event.subtype !== "success") {
-              emittedTerminalErrorEvent = true;
-            }
-            if ((mode === "ask" || mode === "plan") && !permissionRequested) {
-              const permRequest = deriveApprovalRequestFromEvent(
-                event,
-                state.approvedTools,
-                selection.providerId,
-                mode
-              );
-              if (permRequest) {
-                permissionRequested = true;
-                state.pendingTools = permRequest.tools || [permRequest.tool];
-                peer.send(JSON.stringify({
-                  type: "permission_request",
-                  tool: permRequest.tool,
-                  tools: state.pendingTools,
-                  description: permRequest.description || `Permission required: ${permRequest.tool}`
-                }));
-                (_a = state.proc) == null ? void 0 : _a.kill();
-                return;
-              }
-            }
-            peer.send(JSON.stringify({ type: "ui_event", event }));
-          }
-        },
-        onClose({ exitCode, signal, nonJsonOutput }) {
-          if (state.procGeneration !== generation) {
-            return;
-          }
-          try {
-            if (!permissionRequested) {
-              if (exitCode !== 0 && exitCode !== null) {
-                console.error("[WS] Provider process exited unexpectedly", {
-                  providerId: selection.providerId,
-                  modelKey: selection.modelKey,
-                  permissionMode: mode,
-                  requestId: msg.requestId,
-                  exitCode,
-                  signal,
-                  nonJsonOutput: nonJsonOutput.slice(-25)
-                });
-                const inferred = deriveApprovalRequestFromProcessOutput(nonJsonOutput, mode);
-                if (inferred) {
-                  permissionRequested = true;
-                  state.pendingTools = inferred.tools || [inferred.tool];
-                  peer.send(JSON.stringify({
-                    type: "permission_request",
-                    tool: inferred.tool,
-                    tools: state.pendingTools,
-                    description: inferred.description
-                  }));
-                  state.proc = null;
-                  return;
-                }
-                const hasPermissionError = hasCodexPermissionError(nonJsonOutput);
-                const missingRolloutPath = hasCodexMissingRolloutPathError(nonJsonOutput);
-                if (missingRolloutPath && !hasPermissionError && !isRetry) {
-                  peer.send(JSON.stringify({
-                    type: "session_reset",
-                    reason: "Codex session state was missing rollout data. Retrying with a fresh ephemeral session."
-                  }));
-                  state.providerSessionId = null;
-                  state.proc = null;
-                  runProvider(peer, state, msg, true, true);
-                  return;
-                }
-                if (usedResumeFlag && !isRetry) {
-                  const retryWithEphemeral = selection.providerId === "codex";
-                  peer.send(JSON.stringify({
-                    type: "session_reset",
-                    reason: retryWithEphemeral ? `Session resume failed (exit code ${exitCode}). Retrying with a fresh ephemeral session.` : `Session resume failed (exit code ${exitCode}). Retrying with a fresh session.`
-                  }));
-                  state.providerSessionId = null;
-                  state.proc = null;
-                  runProvider(peer, state, msg, true, retryWithEphemeral);
-                  return;
-                }
-                const summary = summarizeProviderProcessError(nonJsonOutput, 700);
-                if (!summary && emittedTerminalErrorEvent && emittedRenderableContent) {
-                  peer.send(JSON.stringify({ type: "done", requestId: msg.requestId }));
-                  state.pendingMessage = null;
-                  return;
-                }
-                const details = summary ? ` \u2014 ${summary}` : "";
-                peer.send(JSON.stringify({
-                  type: "error",
-                  error: `Provider process exited unexpectedly (code: ${exitCode}${signal ? ", signal: " + signal : ""})${details}`,
-                  requestId: msg.requestId
-                }));
-              } else if (exitCode === null && signal) {
-                const summary = summarizeProviderProcessError(nonJsonOutput, 700);
-                const details = summary ? ` \u2014 ${summary}` : "";
-                peer.send(JSON.stringify({
-                  type: "error",
-                  error: `Provider process was killed by signal ${signal}${details}`,
-                  requestId: msg.requestId
-                }));
-                console.error("[WS] Provider process killed by signal", {
-                  providerId: selection.providerId,
-                  modelKey: selection.modelKey,
-                  permissionMode: mode,
-                  requestId: msg.requestId,
-                  signal,
-                  nonJsonOutput: nonJsonOutput.slice(-25)
-                });
-              } else {
-                if (!emittedRenderableContent) {
-                  const summary = summarizeProviderProcessError(nonJsonOutput, 700);
-                  const fallbackText = summary ? `Provider returned no structured response.
-
-Raw output:
-${summary}` : "Provider completed without returning visible response content.";
-                  sendAssistantText(peer, fallbackText, state.providerSessionId);
-                }
-                peer.send(JSON.stringify({ type: "done", requestId: msg.requestId }));
-              }
-              state.pendingMessage = null;
-            }
-          } finally {
-            state.proc = null;
-          }
-        },
-        onError(error) {
-          try {
-            peer.send(JSON.stringify({
-              type: "error",
-              error: `Provider process error: ${error.message}`,
-              requestId: msg.requestId
-            }));
-          } finally {
-            state.pendingMessage = null;
-            state.pendingTools = [];
-            state.proc = null;
-          }
-        }
-      }
-    );
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : "Failed to start provider process";
+  } else {
     peer.send(JSON.stringify({
-      type: "error",
-      error: errorMsg,
-      requestId: msg.requestId
+      type: "subscribed",
+      conversationId: msg.conversationId
     }));
-    state.pendingMessage = null;
-    state.pendingTools = [];
-    state.proc = null;
   }
 }
+function handleResetContext(peer) {
+  const conn = getPeerConnection(peer.id);
+  console.log("[WS] Reset context requested for peer:", peer.id);
+  if (conn.conversationId) {
+    jobQueue.resetContext(conn.conversationId);
+  }
+  peer.send(JSON.stringify({ type: "context_reset" }));
+  console.log("[WS] Context reset completed for peer:", peer.id);
+}
 
 export { _ws as default };
 //# sourceMappingURL=_ws.mjs.map