spec-cat 0.1.21 → 0.1.23

package/.output/server/chunks/_/jobQueue.mjs

@@ -0,0 +1,714 @@
+import { existsSync } from 'node:fs';
+import { e as getProjectDir } from '../nitro/nitro.mjs';
+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';
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+class ConversationEventBus {
+  constructor() {
+    __publicField$1(this, "subscribers", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Emit an event to all subscribers of a conversation.
+   */
+  emit(conversationId, event) {
+    const subs = this.subscribers.get(conversationId);
+    if (!subs) return;
+    for (const callback of subs) {
+      try {
+        callback(event);
+      } catch (err) {
+        console.error("[EventBus] Subscriber error:", err);
+      }
+    }
+  }
+  /**
+   * Subscribe to events for a conversation.
+   * Returns an unsubscribe function.
+   */
+  subscribe(conversationId, callback) {
+    let subs = this.subscribers.get(conversationId);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.subscribers.set(conversationId, subs);
+    }
+    subs.add(callback);
+    return () => {
+      subs.delete(callback);
+      if (subs.size === 0) {
+        this.subscribers.delete(conversationId);
+      }
+    };
+  }
+  /**
+   * Check if a conversation has any active subscribers.
+   */
+  hasSubscribers(conversationId) {
+    const subs = this.subscribers.get(conversationId);
+    return !!subs && subs.size > 0;
+  }
+}
+const eventBus = new ConversationEventBus();
+const GLOBAL_CHANNEL = "__global__";
+
+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 };
+  }
+  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}`;
+  }
+  try {
+    await execAsync("git worktree prune", { cwd: projectDir });
+    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);
+    }
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+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 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;
+    }
+    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 generateJobId() {
+  return `job-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+class ChatJobQueue {
+  constructor() {
+    __publicField(this, "jobs", /* @__PURE__ */ new Map());
+    __publicField(this, "jobProcessStates", /* @__PURE__ */ new Map());
+    __publicField(this, "conversationStates", /* @__PURE__ */ new Map());
+  }
+  getConversationState(conversationId) {
+    let state = this.conversationStates.get(conversationId);
+    if (!state) {
+      state = {
+        approvedTools: /* @__PURE__ */ new Set(),
+        providerSessionId: null,
+        activeJobId: null
+      };
+      this.conversationStates.set(conversationId, state);
+    }
+    return state;
+  }
+  emitAndBuffer(job, event) {
+    job.events.push(event);
+    eventBus.emit(job.conversationId, event);
+  }
+  emitGlobal(event) {
+    eventBus.emit(GLOBAL_CHANNEL, event);
+  }
+  setJobStatus(job, status) {
+    const prev = job.status;
+    job.status = status;
+    if (prev !== status && (status === "done" || status === "error")) {
+      this.emitGlobal({
+        type: "notification",
+        notificationEvent: "job_completed",
+        jobId: job.id,
+        conversationId: job.conversationId,
+        source: job.source,
+        status
+      });
+    }
+  }
+  // ── Public API ─────────────────────────────────────
+  /**
+   * Submit a new job for provider execution.
+   * Returns the job ID.
+   */
+  submit(msg, source = "user") {
+    const conversationId = msg.conversationId;
+    const convState = this.getConversationState(conversationId);
+    const speckitCommand = isSpeckitCommand(msg.message);
+    if (convState.activeJobId) {
+      const prevState = this.jobProcessStates.get(convState.activeJobId);
+      if (prevState == null ? void 0 : prevState.proc) {
+        prevState.procGeneration++;
+        killProc(prevState.proc);
+        prevState.proc = null;
+      }
+      const prevJob = this.jobs.get(convState.activeJobId);
+      if (prevJob && (prevJob.status === "running" || prevJob.status === "waiting_permission")) {
+        this.setJobStatus(prevJob, "done");
+      }
+    }
+    if (speckitCommand) {
+      console.log("[JobQueue] Speckit command detected \u2014 auto-resetting context:", conversationId);
+      convState.providerSessionId = null;
+      convState.approvedTools.clear();
+    } else if (msg.sessionId) {
+      convState.providerSessionId = msg.sessionId;
+    } else {
+      convState.approvedTools.clear();
+      convState.providerSessionId = null;
+    }
+    const job = {
+      id: generateJobId(),
+      conversationId,
+      message: msg,
+      source,
+      status: "queued",
+      events: [],
+      createdAt: Date.now()
+    };
+    const procState = {
+      proc: null,
+      procGeneration: 0,
+      pendingTools: []
+    };
+    this.jobs.set(job.id, job);
+    this.jobProcessStates.set(job.id, procState);
+    convState.activeJobId = job.id;
+    console.log("[JobQueue] Job submitted:", {
+      jobId: job.id,
+      conversationId,
+      source,
+      hasSessionId: !!msg.sessionId,
+      sessionId: convState.providerSessionId,
+      approvedTools: Array.from(convState.approvedTools),
+      isSpeckitCommand: speckitCommand
+    });
+    this.emitGlobal({
+      type: "notification",
+      notificationEvent: "job_created",
+      jobId: job.id,
+      conversationId,
+      source,
+      message: msg.message
+    });
+    this.runProvider(job, false, false);
+    return job.id;
+  }
+  /**
+   * Handle permission response for the active job.
+   */
+  respondToPermission(conversationId, allow) {
+    const convState = this.getConversationState(conversationId);
+    if (!convState.activeJobId) return;
+    const job = this.jobs.get(convState.activeJobId);
+    const procState = this.jobProcessStates.get(convState.activeJobId);
+    if (!job || !procState) return;
+    console.log("[JobQueue] Permission response:", {
+      jobId: job.id,
+      allow,
+      pendingTools: procState.pendingTools,
+      approvedTools: Array.from(convState.approvedTools),
+      sessionId: convState.providerSessionId,
+      providerId: job.message.providerId,
+      providerModelKey: job.message.providerModelKey
+    });
+    if (allow) {
+      approveTools(convState.approvedTools, procState.pendingTools);
+      console.log("[JobQueue] Tools approved:", procState.pendingTools, "- Total:", Array.from(convState.approvedTools));
+      procState.pendingTools = [];
+      job.status = "running";
+      const resumeMode = job.message.permissionMode || "ask";
+      job.message = { ...job.message, permissionMode: resumeMode };
+      this.runProvider(job, false, false);
+    } else {
+      procState.pendingTools = [];
+      this.setJobStatus(job, "done");
+      this.emitAndBuffer(job, { type: "done", requestId: "denied", denied: true });
+    }
+  }
+  /**
+   * Abort the active job for a conversation.
+   */
+  abort(conversationId) {
+    const convState = this.conversationStates.get(conversationId);
+    if (!(convState == null ? void 0 : convState.activeJobId)) return;
+    const job = this.jobs.get(convState.activeJobId);
+    const procState = this.jobProcessStates.get(convState.activeJobId);
+    if (!job || !procState) return;
+    console.log("[JobQueue] Abort:", job.id);
+    if (procState.proc) {
+      procState.procGeneration++;
+      killProc(procState.proc);
+      procState.proc = null;
+    }
+    procState.pendingTools = [];
+    this.setJobStatus(job, "done");
+  }
+  /**
+   * Reset provider session state for a conversation.
+   */
+  resetContext(conversationId) {
+    const convState = this.conversationStates.get(conversationId);
+    if (!convState) return;
+    console.log("[JobQueue] Reset context:", conversationId);
+    if (convState.activeJobId) {
+      const procState = this.jobProcessStates.get(convState.activeJobId);
+      if (procState == null ? void 0 : procState.proc) {
+        procState.procGeneration++;
+        killProc(procState.proc);
+        procState.proc = null;
+      }
+    }
+    convState.providerSessionId = null;
+    convState.approvedTools.clear();
+    convState.activeJobId = null;
+  }
+  /**
+   * Clean up on peer disconnect.
+   * Jobs are NOT aborted — they run to completion so that a reconnecting
+   * client (e.g. after browser refresh) can subscribe and replay events.
+   */
+  cleanup(_conversationId) {
+  }
+  getJob(id) {
+    return this.jobs.get(id);
+  }
+  getActiveJob(conversationId) {
+    const convState = this.conversationStates.get(conversationId);
+    if (!(convState == null ? void 0 : convState.activeJobId)) return void 0;
+    return this.jobs.get(convState.activeJobId);
+  }
+  listJobs(conversationId) {
+    return Array.from(this.jobs.values()).filter((j) => j.conversationId === conversationId);
+  }
+  listAllJobs() {
+    return Array.from(this.jobs.values());
+  }
+  // ── Provider Execution ─────────────────────────────
+  async runProvider(job, isRetry, forceEphemeral) {
+    const msg = job.message;
+    const convState = this.getConversationState(job.conversationId);
+    const procState = this.jobProcessStates.get(job.id);
+    if (!procState) return;
+    job.status = "running";
+    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) {
+      this.emitAndBuffer(job, {
+        type: "error",
+        error: `Provider "${selection.providerId}" is not registered`,
+        requestId: msg.requestId
+      });
+      this.setJobStatus(job, "error");
+      return;
+    }
+    const providerGuard = await guardProviderCapability(
+      selection,
+      "streaming",
+      "Choose a provider with streaming capability in Settings."
+    );
+    if ("failure" in providerGuard) {
+      this.emitAndBuffer(job, {
+        type: "error",
+        error: providerGuard.failure.error,
+        requestId: msg.requestId
+      });
+      this.setJobStatus(job, "error");
+      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) {
+        this.emitAndBuffer(job, {
+          type: "error",
+          error: permissionGuard.failure.error,
+          requestId: msg.requestId
+        });
+        this.setJobStatus(job, "error");
+        return;
+      }
+    }
+    if (workingDirectory.startsWith("/tmp/sc-") && !existsSync(workingDirectory)) {
+      const result = await ensureChatWorktree(projectDir, workingDirectory, msg.worktreeBranch);
+      if (result.recovered) {
+        this.emitAndBuffer(job, { type: "worktree_recovered" });
+      } else if (result.error) {
+        this.emitAndBuffer(job, {
+          type: "error",
+          error: `Worktree recovery failed: ${result.error}`,
+          requestId: msg.requestId
+        });
+        this.setJobStatus(job, "error");
+        return;
+      }
+    }
+    const usedResumeFlag = !isRetry && !!convState.providerSessionId;
+    const resumeSessionId = usedResumeFlag ? convState.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("[JobQueue] Failed to load spec context:", error);
+      }
+    }
+    if (speckitCommand && !usedResumeFlag) {
+      systemPrompt = systemPrompt ? `${systemPrompt}
+
+${SPECKIT_AUTONOMY_DIRECTIVE}` : SPECKIT_AUTONOMY_DIRECTIVE;
+    }
+    console.log("[JobQueue] Running provider:", selection.providerId, selection.modelKey, isRetry ? "(retry)" : "");
+    const generation = procState.procGeneration;
+    let permissionRequested = false;
+    let emittedRenderableContent = false;
+    let emittedTerminalErrorEvent = false;
+    const attachments = msg.attachments || [];
+    const providerMessage = buildProviderMessage(msg.message, attachments);
+    try {
+      procState.proc = await streamChatWithProvider(
+        {
+          message: providerMessage,
+          selection,
+          cwd: workingDirectory,
+          permissionMode: mode,
+          approvedTools: Array.from(convState.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) {
+                convState.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,
+                  convState.approvedTools,
+                  selection.providerId,
+                  mode
+                );
+                if (permRequest) {
+                  permissionRequested = true;
+                  procState.pendingTools = permRequest.tools || [permRequest.tool];
+                  job.status = "waiting_permission";
+                  this.emitAndBuffer(job, {
+                    type: "permission_request",
+                    tool: permRequest.tool,
+                    tools: procState.pendingTools,
+                    description: permRequest.description || `Permission required: ${permRequest.tool}`
+                  });
+                  (_a = procState.proc) == null ? void 0 : _a.kill();
+                  return;
+                }
+              }
+              this.emitAndBuffer(job, { type: "ui_event", event });
+            }
+          },
+          onClose: ({ exitCode, signal, nonJsonOutput }) => {
+            if (procState.procGeneration !== generation) {
+              return;
+            }
+            try {
+              if (!permissionRequested) {
+                if (exitCode !== 0 && exitCode !== null) {
+                  console.error("[JobQueue] Provider 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;
+                    procState.pendingTools = inferred.tools || [inferred.tool];
+                    job.status = "waiting_permission";
+                    this.emitAndBuffer(job, {
+                      type: "permission_request",
+                      tool: inferred.tool,
+                      tools: procState.pendingTools,
+                      description: inferred.description
+                    });
+                    procState.proc = null;
+                    return;
+                  }
+                  const hasPermissionError = hasCodexPermissionError(nonJsonOutput);
+                  const missingRolloutPath = hasCodexMissingRolloutPathError(nonJsonOutput);
+                  if (missingRolloutPath && !hasPermissionError && !isRetry) {
+                    this.emitAndBuffer(job, {
+                      type: "session_reset",
+                      reason: "Codex session state was missing rollout data. Retrying with a fresh ephemeral session."
+                    });
+                    convState.providerSessionId = null;
+                    procState.proc = null;
+                    this.runProvider(job, true, true);
+                    return;
+                  }
+                  if (usedResumeFlag && !isRetry) {
+                    const retryWithEphemeral = selection.providerId === "codex";
+                    this.emitAndBuffer(job, {
+                      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.`
+                    });
+                    convState.providerSessionId = null;
+                    procState.proc = null;
+                    this.runProvider(job, true, retryWithEphemeral);
+                    return;
+                  }
+                  const summary = summarizeProviderProcessError(nonJsonOutput, 700);
+                  if (!summary && emittedTerminalErrorEvent && emittedRenderableContent) {
+                    this.emitAndBuffer(job, { type: "done", requestId: msg.requestId });
+                    this.setJobStatus(job, "done");
+                    return;
+                  }
+                  const details = summary ? ` \u2014 ${summary}` : "";
+                  this.emitAndBuffer(job, {
+                    type: "error",
+                    error: `Provider process exited unexpectedly (code: ${exitCode}${signal ? ", signal: " + signal : ""})${details}`,
+                    requestId: msg.requestId
+                  });
+                  this.setJobStatus(job, "error");
+                } else if (exitCode === null && signal) {
+                  const summary = summarizeProviderProcessError(nonJsonOutput, 700);
+                  const details = summary ? ` \u2014 ${summary}` : "";
+                  this.emitAndBuffer(job, {
+                    type: "error",
+                    error: `Provider process was killed by signal ${signal}${details}`,
+                    requestId: msg.requestId
+                  });
+                  this.setJobStatus(job, "error");
+                  console.error("[JobQueue] Provider 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.";
+                    this.emitAssistantText(job, fallbackText, convState.providerSessionId);
+                  }
+                  this.emitAndBuffer(job, { type: "done", requestId: msg.requestId });
+                  this.setJobStatus(job, "done");
+                }
+              }
+            } finally {
+              procState.proc = null;
+            }
+          },
+          onError: (error) => {
+            try {
+              this.emitAndBuffer(job, {
+                type: "error",
+                error: `Provider process error: ${error.message}`,
+                requestId: msg.requestId
+              });
+              this.setJobStatus(job, "error");
+            } finally {
+              procState.pendingTools = [];
+              procState.proc = null;
+            }
+          }
+        }
+      );
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Failed to start provider process";
+      this.emitAndBuffer(job, {
+        type: "error",
+        error: errorMsg,
+        requestId: msg.requestId
+      });
+      this.setJobStatus(job, "error");
+      procState.pendingTools = [];
+      procState.proc = null;
+    }
+  }
+  emitAssistantText(job, text, sessionId) {
+    const blockId = `blk-${Date.now()}`;
+    this.emitAndBuffer(job, {
+      type: "ui_event",
+      event: {
+        type: "block_start",
+        sessionId: sessionId || void 0,
+        blockId,
+        blockType: "text",
+        text
+      }
+    });
+    this.emitAndBuffer(job, {
+      type: "ui_event",
+      event: {
+        type: "block_end",
+        sessionId: sessionId || void 0,
+        blockId: ""
+      }
+    });
+  }
+}
+const jobQueue = new ChatJobQueue();
+
+export { GLOBAL_CHANNEL as G, eventBus as e, jobQueue as j, normalizeImageAttachments as n };
+//# sourceMappingURL=jobQueue.mjs.map