spec-cat 0.1.62 → 0.1.64

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

@@ -1,14 +1,13 @@
-import { existsSync } from 'node:fs';
+import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { e as eventBus, G as GLOBAL_CHANNEL } from './eventBus.mjs';
-import { e as getProjectDir } from '../nitro/nitro.mjs';
+import { q as readConversationFromStorage, a as getProjectDir, s as updateConversationProviderSessionInStorage } from '../nitro/nitro.mjs';
 import { exec } from 'node:child_process';
 import { promisify } from 'node:util';
 import { i as isSpecCatWorktreePath, b as getChatWorktreeIdFromPath } from './worktreePaths.mjs';
 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 { r as resolveServerProviderSelection } from './aiProviderSelection.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 { g as getCliHookSpoolPath, p as parseCliHookRecord, d as disposeTerminalSession, b as buildTerminalSessionId, s as subscribeTerminalSession, w as writeTerminalInput, a as getOrCreateTerminalSession } from './terminalSessions.mjs';
 
 const execAsync = promisify(exec);
 async function ensureChatWorktree(projectDir, worktreePath, knownBranch) {
@@ -83,62 +82,179 @@ async function loadSpecContext(projectDir, featureId) {
   return sections.join("\n");
 }
 
-function toolStreamKey(event) {
-  if (typeof event.index === "number") return `index:${event.index}`;
-  if (event.blockId) return `block:${event.blockId}`;
-  return null;
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function isUserInputToolName(name) {
-  const compact = normalizeToolName(name).toLowerCase().replace(/[^a-z0-9]/g, "");
-  return compact === "askuserquestion" || compact === "requestuserinput";
+function pickString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
 }
-function trackStreamingToolInput(event, activeTools) {
-  const key = toolStreamKey(event);
-  if (event.type === "block_start") {
-    if (key && event.blockType === "tool_use" && event.name) {
-      activeTools.set(key, { name: event.name, inputJson: "" });
-    }
-    return null;
+function extractPrompt(payload) {
+  const direct = pickString(payload, ["prompt", "message", "user_prompt", "userPrompt", "input"]);
+  if (direct) return direct;
+  const nestedKeys = ["tool_input", "toolInput", "request", "data"];
+  for (const key of nestedKeys) {
+    const nested = asRecord(payload[key]);
+    const nestedPrompt = pickString(nested, ["prompt", "message", "input"]);
+    if (nestedPrompt) return nestedPrompt;
   }
-  if (!key) return null;
-  const tool = activeTools.get(key);
-  if (!tool) return null;
-  if (event.type === "block_delta") {
-    if (event.partialJson) {
-      tool.inputJson += event.partialJson;
+  return void 0;
+}
+function extractToolName(payload) {
+  const direct = pickString(payload, ["tool_name", "toolName", "name"]);
+  if (direct) return direct;
+  const tool = asRecord(payload.tool);
+  return pickString(tool, ["name", "tool_name", "toolName"]);
+}
+function isToolFailure(eventName) {
+  return eventName === "PostToolUseFailure" || eventName === "PermissionDenied";
+}
+function toEvents(record) {
+  const payload = asRecord(record.payload);
+  const eventName = record.hookEventName || pickString(payload, ["hook_event_name", "hookEventName"]) || "unknown";
+  const base = {
+    providerId: record.providerId,
+    jobId: record.jobId,
+    requestId: record.requestId,
+    hookEventName: eventName,
+    sessionId: record.sessionId,
+    turnId: record.turnId,
+    cwd: record.cwd,
+    timestamp: record.timestamp
+  };
+  const events = [
+    {
+      type: "cli_hook",
+      ...base,
+      payload: record.payload
     }
-    return null;
+  ];
+  if (eventName === "UserPromptSubmit") {
+    events.push({
+      type: "cli_prompt_submitted",
+      ...base,
+      prompt: extractPrompt(payload)
+    });
   }
-  activeTools.delete(key);
-  return tool;
+  if (eventName === "PostToolUse" || eventName === "PostToolUseFailure") {
+    events.push({
+      type: "cli_tool_completed",
+      ...base,
+      toolName: extractToolName(payload),
+      failed: isToolFailure(eventName)
+    });
+  }
+  if (eventName === "Stop" || eventName === "SubagentStop") {
+    events.push({
+      type: eventName === "Stop" ? "cli_turn_stop" : "cli_subagent_stop",
+      ...base,
+      stopHookActive: payload.stop_hook_active,
+      lastAssistantMessage: pickString(payload, ["last_assistant_message", "lastAssistantMessage"])
+    });
+  }
+  return events;
 }
-function parseToolInputJson(inputJson) {
+function startCliHookMonitor(options) {
+  const spoolPath = getCliHookSpoolPath(options.conversationId);
+  let offset = 0;
+  let tail = Buffer.alloc(0);
+  let stopped = false;
+  let sawStopHook = false;
+  let sawArmedPrompt = false;
   try {
-    const parsed = JSON.parse(inputJson);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    offset = existsSync(spoolPath) ? statSync(spoolPath).size : 0;
   } catch {
-    return {};
+    offset = 0;
   }
-}
-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);
+  const readAppendedBytes = (size) => {
+    const length = size - offset;
+    if (length <= 0) return null;
+    let fd = null;
+    try {
+      fd = openSync(spoolPath, "r");
+      const buffer = Buffer.alloc(length);
+      const bytesRead = readSync(fd, buffer, 0, length, offset);
+      offset += bytesRead;
+      return buffer.subarray(0, bytesRead);
+    } catch {
+      return null;
+    } finally {
+      if (fd !== null) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+    }
+  };
+  const poll = () => {
+    if (stopped || !existsSync(spoolPath)) return;
+    let size = 0;
+    try {
+      size = statSync(spoolPath).size;
+    } catch {
+      return;
+    }
+    if (size < offset) {
+      offset = 0;
+      tail = Buffer.alloc(0);
+    }
+    const chunk = readAppendedBytes(size);
+    if (!chunk || chunk.length === 0) return;
+    const combined = tail.length > 0 ? Buffer.concat([tail, chunk]) : chunk;
+    const lines = [];
+    let lineStart = 0;
+    for (let i = 0; i < combined.length; i++) {
+      if (combined[i] === 10) {
+        lines.push(combined.toString("utf-8", lineStart, i));
+        lineStart = i + 1;
+      }
+    }
+    tail = lineStart < combined.length ? Buffer.from(combined.subarray(lineStart)) : Buffer.alloc(0);
+    for (const line of lines) {
+      const record = parseCliHookRecord(line);
+      if (!record) continue;
+      if (options.jobId !== void 0 && record.jobId !== options.jobId) continue;
+      const armed = options.isArmed ? options.isArmed() : true;
+      if (armed && record.hookEventName === "UserPromptSubmit") {
+        sawArmedPrompt = true;
+      }
+      const isStop = record.hookEventName === "Stop";
+      const promptGateOpen = sawArmedPrompt;
+      const firstStop = isStop && armed && promptGateOpen && !sawStopHook;
+      if (firstStop) {
+        sawStopHook = true;
+      }
+      for (const event of toEvents(record)) {
+        options.emit(event);
+      }
+      if (firstStop && options.onStop) {
+        const payload = asRecord(record.payload);
+        options.onStop(pickString(payload, ["last_assistant_message", "lastAssistantMessage"]));
+      }
+    }
+  };
+  const interval = setInterval(poll, 100);
   return {
-    type: "permission_request",
-    tool: tools[0] || "Permission",
-    tools,
-    description: inferred.description
+    stop: () => {
+      poll();
+      stopped = true;
+      clearInterval(interval);
+    },
+    sawStop: () => sawStopHook
   };
 }
+
+function normalizeToolName(tool) {
+  if (!tool) return "";
+  const trimmed = tool.trim();
+  if (!trimmed) return "";
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1);
+}
+
 function approveTools(approvedTools, tools) {
   for (const tool of tools) {
     const normalized = normalizeToolName(tool);
@@ -153,6 +269,8 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 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 PTY_TURN_TIMEOUT_MS = 30 * 6e4;
+const PTY_IDLE_FINALIZE_MS = 8e3;
 const SPECKIT_AUTONOMY_DIRECTIVE = [
   "Speckit Execution Mode (MANDATORY):",
   "- Do not ask the user for confirmation, follow-up, or permission to proceed.",
@@ -208,6 +326,24 @@ function buildProviderMessage(baseMessage, attachments) {
 function generateJobId() {
   return `job-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
 }
+function getStoredProviderSessionId(conversation) {
+  var _a;
+  if (!conversation || typeof conversation !== "object") return null;
+  const record = conversation;
+  const value = (_a = record.providerSessionId) != null ? _a : record.claudeSessionId;
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getStoredProviderSelection(conversation) {
+  if (!conversation || typeof conversation !== "object") return null;
+  const record = conversation;
+  const providerId = record.providerId;
+  if (typeof providerId !== "string" || providerId.length === 0) return null;
+  const providerModelKey = record.providerModelKey;
+  return {
+    providerId,
+    providerModelKey: typeof providerModelKey === "string" ? providerModelKey : ""
+  };
+}
 class ChatJobQueue {
   constructor() {
     __publicField(this, "jobs", /* @__PURE__ */ new Map());
@@ -312,7 +448,7 @@ class ChatJobQueue {
       source,
       message: msg.message
     });
-    this.runProvider(job, false, false);
+    this.runProvider(job, false);
     return job.id;
   }
   /**
@@ -340,7 +476,7 @@ class ChatJobQueue {
       job.status = "running";
       const resumeMode = job.message.permissionMode || "ask";
       job.message = { ...job.message, permissionMode: resumeMode };
-      this.runProvider(job, false, false);
+      this.runProvider(job, false);
     } else {
       procState.pendingTools = [];
       this.setJobStatus(job, "done");
@@ -374,6 +510,35 @@ class ChatJobQueue {
     this.setJobStatus(job, "done");
     console.log("[JobQueue] Abort: job status set to done for", job.id);
   }
+  /**
+   * Terminate any provider process associated with a conversation that has
+   * been finalized. Unlike abort(), this is cleanup for a read-only
+   * conversation, so it must not emit a stopped assistant turn.
+   */
+  finalizeConversation(conversationId) {
+    disposeTerminalSession(buildTerminalSessionId(conversationId));
+    const convState = this.conversationStates.get(conversationId);
+    if (!convState) return;
+    if (convState.activeJobId) {
+      const job = this.jobs.get(convState.activeJobId);
+      const procState = this.jobProcessStates.get(convState.activeJobId);
+      if (procState == null ? void 0 : procState.proc) {
+        procState.procGeneration++;
+        killProc(procState.proc);
+        procState.proc = null;
+        console.log("[JobQueue] Finalize: process killed for", convState.activeJobId);
+      }
+      if (procState) {
+        procState.pendingTools = [];
+      }
+      if (job && job.status !== "done" && job.status !== "error") {
+        this.setJobStatus(job, "done");
+      }
+    }
+    convState.providerSessionId = null;
+    convState.approvedTools.clear();
+    convState.activeJobId = null;
+  }
   /**
    * Reset provider session state for a conversation.
    */
@@ -415,13 +580,90 @@ class ChatJobQueue {
     return Array.from(this.jobs.values());
   }
   // ── Provider Execution ─────────────────────────────
-  async runProvider(job, isRetry, forceEphemeral) {
+  /**
+   * Execute a job through the provider's interactive PTY session. Turn
+   * completion is detected via the CLI Stop hook.
+   */
+  async runProvider(job, isRetry) {
+    return this.runProviderViaPty(job, isRetry);
+  }
+  /**
+   * Inject a prompt into a (possibly freshly-spawned) PTY session once its TUI
+   * composer is ready, then submit it. The prompt is bracketed-pasted so
+   * embedded newlines don't submit line-by-line. Server-side and
+   * client-independent — runs whether or not a terminal-ws viewer is attached.
+   */
+  injectMessage(session, sessionId, text, stillValid, onSubmitted) {
+    const READY_IDLE_MS = 1200;
+    const REUSED_READY_MS = 800;
+    const READY_MAX_MS = 15e3;
+    const SUBMIT_IDLE_MS = 600;
+    const SUBMIT_MAX_MS = 4e3;
+    const reused = session.buffer.length > 0;
+    const safeText = text.replace(/\x1b\[20[01]~/g, "");
+    const startedAt = Date.now();
+    let firstDataAt = reused ? startedAt : 0;
+    let lastDataAt = Date.now();
+    let injected = false;
+    let injectedAt = 0;
+    let submitted = false;
+    const unsubscribe = subscribeTerminalSession(session, {
+      onData: () => {
+        const now = Date.now();
+        if (!firstDataAt) firstDataAt = now;
+        lastDataAt = now;
+      },
+      onExit: () => {
+      }
+    });
+    const timer = setInterval(() => {
+      if (!stillValid()) {
+        clearInterval(timer);
+        unsubscribe();
+        return;
+      }
+      const now = Date.now();
+      if (!injected) {
+        const idleMs = reused ? REUSED_READY_MS : READY_IDLE_MS;
+        const ready = firstDataAt > 0 && now - lastDataAt >= idleMs;
+        const forced = now - startedAt >= READY_MAX_MS;
+        if (ready || forced) {
+          injected = true;
+          injectedAt = now;
+          lastDataAt = now;
+          writeTerminalInput(sessionId, `\x1B[200~${safeText}\x1B[201~`);
+        }
+        return;
+      }
+      if (!submitted) {
+        const echoSettled = now - lastDataAt >= SUBMIT_IDLE_MS;
+        const submitForced = now - injectedAt >= SUBMIT_MAX_MS;
+        if (echoSettled || submitForced) {
+          submitted = true;
+          writeTerminalInput(sessionId, "\r");
+          onSubmitted();
+          clearInterval(timer);
+          unsubscribe();
+        }
+        return;
+      }
+    }, 250);
+  }
+  async runProviderViaPty(job, isRetry) {
     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 || "" };
+    let requestedSelection;
+    if (msg.providerId) {
+      requestedSelection = { providerId: msg.providerId, modelKey: msg.providerModelKey || "" };
+    } else {
+      const storedSelection = getStoredProviderSelection(
+        await readConversationFromStorage(job.conversationId)
+      );
+      requestedSelection = storedSelection ? { providerId: storedSelection.providerId, modelKey: msg.providerModelKey || storedSelection.providerModelKey } : { providerId: "claude", modelKey: msg.providerModelKey || "" };
+    }
     const selection = await resolveServerProviderSelection(requestedSelection);
     const provider = getProvider(selection.providerId);
     if (!provider) {
@@ -433,39 +675,8 @@ class ChatJobQueue {
       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 (isSpecCatWorktreePath(workingDirectory) && !existsSync(workingDirectory)) {
       const result = await ensureChatWorktree(projectDir, workingDirectory, msg.worktreeBranch);
       if (result.recovered) {
@@ -480,224 +691,165 @@ class ChatJobQueue {
         return;
       }
     }
+    const speckitCommand = isSpeckitCommand(msg.message);
+    if (!isRetry && !speckitCommand && !convState.providerSessionId) {
+      const storedSessionId = getStoredProviderSessionId(await readConversationFromStorage(job.conversationId));
+      if (storedSessionId) convState.providerSessionId = storedSessionId;
+    }
     const usedResumeFlag = !isRetry && !!convState.providerSessionId;
     const resumeSessionId = usedResumeFlag ? convState.providerSessionId : void 0;
-    let systemPrompt;
-    const speckitCommand = isSpeckitCommand(msg.message);
+    let preface = "";
     if (msg.featureId && !usedResumeFlag) {
       try {
         const specContext = await loadSpecContext(projectDir, msg.featureId);
-        if (specContext) {
-          systemPrompt = specContext;
-        }
+        if (specContext) preface = specContext;
       } catch (error) {
         console.error("[JobQueue] Failed to load spec context:", error);
       }
     }
     if (speckitCommand && !usedResumeFlag) {
-      systemPrompt = systemPrompt ? `${systemPrompt}
+      preface = preface ? `${preface}
 
 ${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 activeToolInputs = /* @__PURE__ */ new Map();
     const attachments = msg.attachments || [];
-    const providerMessage = buildProviderMessage(msg.message, attachments);
+    const baseMessage = buildProviderMessage(msg.message, attachments);
+    const fullMessage = preface ? `${preface}
+
+${baseMessage}` : baseMessage;
+    console.log("[JobQueue] Running provider via PTY:", selection.providerId, selection.modelKey, isRetry ? "(retry)" : "");
+    const generation = procState.procGeneration;
+    const sessionId = buildTerminalSessionId(job.conversationId);
+    let session;
     try {
-      procState.proc = await streamChatWithProvider(
-        {
-          message: providerMessage,
-          selection,
-          cwd: workingDirectory,
-          permissionMode: mode,
-          approvedTools: Array.from(convState.approvedTools),
-          resumeSessionId,
-          systemPrompt,
-          ephemeral: forceEphemeral && selection.providerId === "codex"
+      session = getOrCreateTerminalSession({
+        sessionId,
+        cwd: workingDirectory,
+        providerId: selection.providerId,
+        modelKey: selection.modelKey,
+        resumeSessionId,
+        hookContext: {
+          enabled: true,
+          providerId: selection.providerId,
+          conversationId: job.conversationId,
+          jobId: job.id,
+          requestId: msg.requestId
         },
-        {
-          onProviderJson: (parsed) => {
-            var _a, _b;
-            const events = provider.toCanonicalEvents(parsed);
-            for (const event of events) {
-              const completedToolInput = event.type === "block_start" || event.type === "block_delta" || event.type === "block_end" ? trackStreamingToolInput(event, activeToolInputs) : null;
-              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 (completedToolInput && isUserInputToolName(completedToolInput.name)) {
-                permissionRequested = true;
-                this.setJobStatus(job, "done");
-                this.emitAndBuffer(job, { type: "ui_event", event });
-                this.emitAndBuffer(job, {
-                  type: "done",
-                  requestId: msg.requestId,
-                  awaitingUserInput: true,
-                  tool: completedToolInput.name,
-                  input: parseToolInputJson(completedToolInput.inputJson)
-                });
-                (_a = procState.proc) == null ? void 0 : _a.kill();
-                return;
-              }
-              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}`
-                  });
-                  (_b = procState.proc) == null ? void 0 : _b.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;
-            }
-          }
+        onProviderSessionId: (providerSessionId) => {
+          convState.providerSessionId = providerSessionId;
+          updateConversationProviderSessionInStorage(job.conversationId, providerSessionId).catch((error) => {
+            console.warn("[JobQueue] Failed to persist provider session id:", error);
+          });
         }
-      );
+      });
     } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : "Failed to start provider process";
       this.emitAndBuffer(job, {
         type: "error",
-        error: errorMsg,
+        error: error instanceof Error ? error.message : "Failed to start provider terminal",
         requestId: msg.requestId
       });
       this.setJobStatus(job, "error");
-      procState.pendingTools = [];
-      procState.proc = null;
+      return;
     }
+    let finished = false;
+    let submitted = false;
+    let watchdog;
+    let idleCheck;
+    let unsubscribeExit;
+    let lastDataAt = Date.now();
+    let sawPostSubmitData = false;
+    const cleanup = () => {
+      monitor.stop();
+      if (watchdog) clearTimeout(watchdog);
+      if (idleCheck) clearInterval(idleCheck);
+      unsubscribeExit == null ? void 0 : unsubscribeExit();
+    };
+    const finalize = (lastAssistantMessage) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      if (procState.procGeneration !== generation) return;
+      const text = lastAssistantMessage == null ? void 0 : lastAssistantMessage.trim();
+      if (text) this.emitAssistantText(job, text, convState.providerSessionId);
+      this.emitAndBuffer(job, { type: "cli_turn_stop_confirmed", requestId: msg.requestId });
+      this.emitAndBuffer(job, { type: "done", requestId: msg.requestId });
+      this.setJobStatus(job, "done");
+      procState.proc = null;
+    };
+    const finalizeError = (reason) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      if (procState.procGeneration !== generation) return;
+      this.emitAndBuffer(job, { type: "error", error: reason, requestId: msg.requestId });
+      this.setJobStatus(job, "error");
+      procState.proc = null;
+    };
+    const monitor = startCliHookMonitor({
+      conversationId: job.conversationId,
+      emit: (event) => this.emitAndBuffer(job, event),
+      onStop: (lastAssistantMessage) => finalize(lastAssistantMessage),
+      isArmed: () => submitted,
+      // Only finalize on a Stop that follows this turn's own (post-submit)
+      // UserPromptSubmit, so a stray Stop from a superseded turn in the reused
+      // PTY can never be mistaken for completion. The output-idle watchdog below
+      // remains the guaranteed fallback if the prompt hook never lands.
+      requireArmedPromptSubmit: true
+    });
+    const handleExit = () => {
+      if (finished) return;
+      if (usedResumeFlag && !isRetry) {
+        finished = true;
+        cleanup();
+        if (procState.procGeneration !== generation) return;
+        convState.providerSessionId = null;
+        this.emitAndBuffer(job, { type: "session_reset", reason: "Resume failed; starting a fresh session" });
+        this.runProviderViaPty(job, true).catch((error) => {
+          this.emitAndBuffer(job, {
+            type: "error",
+            error: error instanceof Error ? error.message : "Provider retry failed",
+            requestId: msg.requestId
+          });
+          this.setJobStatus(job, "error");
+        });
+        return;
+      }
+      finalizeError("Provider terminal exited before the turn completed");
+    };
+    unsubscribeExit = subscribeTerminalSession(session, {
+      onData: () => {
+        lastDataAt = Date.now();
+        if (submitted) sawPostSubmitData = true;
+      },
+      onExit: () => handleExit()
+    });
+    idleCheck = setInterval(() => {
+      if (finished) return;
+      if (!submitted || !sawPostSubmitData) return;
+      if (Date.now() - lastDataAt >= PTY_IDLE_FINALIZE_MS) {
+        console.warn("[JobQueue] PTY turn completed via output-idle fallback (no Stop hook).");
+        finalize();
+      }
+    }, 500);
+    watchdog = setTimeout(() => finalizeError("Provider turn timed out"), PTY_TURN_TIMEOUT_MS);
+    procState.proc = {
+      kill: () => {
+        try {
+          writeTerminalInput(sessionId, "");
+        } catch {
+        }
+        cleanup();
+      }
+    };
+    this.injectMessage(
+      session,
+      sessionId,
+      fullMessage,
+      () => procState.procGeneration === generation && !finished,
+      () => {
+        submitted = true;
+      }
+    );
   }
   emitAssistantText(job, text, sessionId) {
     const blockId = `blk-${Date.now()}`;