chatroom-cli 1.65.2 → 1.65.4

package/dist/index.js

@@ -32368,6 +32368,13 @@ async function withTimeout(p, ms, label) {
 }
 
 // src/infrastructure/services/remote-agents/claude-sdk/claude-sdk-package.ts
+var exports_claude_sdk_package = {};
+__export(exports_claude_sdk_package, {
+  resolvePathToClaudeCodeExecutable: () => resolvePathToClaudeCodeExecutable,
+  importBundledClaudeSdk: () => importBundledClaudeSdk,
+  getBundledClaudeSdkVersion: () => getBundledClaudeSdkVersion,
+  formatClaudeSdkLoadError: () => formatClaudeSdkLoadError
+});
 import { existsSync, readFileSync as readFileSync3 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname2, join as join7 } from "node:path";
@@ -33522,6 +33529,8 @@ var init_cursor_sdk_stream_adapter = __esm(() => {
         case "task":
           this.writeLine(formatAgentLogLine(this.logPrefix, "task", [message.status, message.text].filter(Boolean).join(": ")));
           break;
+        case "usage":
+          break;
         default: {
           const unknown = message;
           if (unknown.type) {
@@ -36100,9 +36109,6 @@ function selectAgent(agents) {
 }
 
 // src/domain/agent-lifecycle/policies/terminal-provider-error.ts
-function isProviderRateLimitHarnessMarker(line) {
-  return PROVIDER_RATE_LIMIT_AGENT_END_MARKER.test(line);
-}
 function matchesQuotaPhrase(blob) {
   const text = blob.toLowerCase();
   return QUOTA_PHRASES.some((phrase) => text.includes(phrase));
@@ -36137,30 +36143,6 @@ function isTerminalProviderError(error) {
   const message = extractMessage(e);
   return matchesQuotaPhrase(message) || matchesQuotaPhrase(`${name} ${message}`) || matchesFatalHarnessErrorText(message) || matchesFatalHarnessErrorText(`${name} ${message}`);
 }
-function isTerminalProviderFailureInLogs(logLines) {
-  for (const line of logLines) {
-    if (!isClassifiableHarnessLogLine(line))
-      continue;
-    if (isProviderRateLimitHarnessMarker(line))
-      return true;
-    if (isNonRetryableHarnessFailureText(line))
-      return true;
-  }
-  return false;
-}
-function isClassifiableHarnessLogLine(line) {
-  if (/\b(?:text|thinking)\]/.test(line))
-    return false;
-  if (line.includes("agent_end]"))
-    return true;
-  if (line.includes("spawn-error]"))
-    return true;
-  if (line.includes(" error]"))
-    return true;
-  if (line.includes(" run-error]"))
-    return true;
-  return false;
-}
 function extractName(e) {
   const name = e.name;
   if (typeof name === "string")
@@ -36191,12 +36173,7 @@ function messageFromData(data) {
   const msg = data.message;
   return typeof msg === "string" ? msg.toLowerCase() : undefined;
 }
-function formatTerminalProviderFailureMessage(logLines) {
-  const blob = logLines.join(`
-`).trim();
-  return blob ? `Fatal harness error (non-retryable): ${blob.slice(-500)}` : "Fatal harness error (non-retryable)";
-}
-var FATAL_HARNESS_PHRASES, QUOTA_PHRASES, PROVIDER_ERROR_NAMES, PROVIDER_RATE_LIMIT_AGENT_END_MARKER;
+var FATAL_HARNESS_PHRASES, QUOTA_PHRASES, PROVIDER_ERROR_NAMES;
 var init_terminal_provider_error = __esm(() => {
   FATAL_HARNESS_PHRASES = [
     "failed to load model",
@@ -36217,7 +36194,6 @@ var init_terminal_provider_error = __esm(() => {
     "exceeded your weekly"
   ];
   PROVIDER_ERROR_NAMES = ["ai_apicallerror", "ai_retryerror"];
-  PROVIDER_RATE_LIMIT_AGENT_END_MARKER = /\bagent_end]\s*reason:\s*provider_rate_limit\b/;
 });
 
 // src/infrastructure/services/remote-agents/opencode-sdk/session-event-forwarder.ts
@@ -36269,10 +36245,12 @@ function startSessionEventForwarder(client4, options) {
   let doneResolve;
   let sessionStarted = false;
   let terminalAbortRequested = false;
+  let agentEndEmitted = false;
   const seenToolStates = new Map;
   let lastStatus;
   const agentEndCallbacks = [];
   const recentLogLines = [];
+  let retryIdleTimeout;
   const donePromise = new Promise((resolve2) => {
     doneResolve = resolve2;
   });
@@ -36295,7 +36273,26 @@ function startSessionEventForwarder(client4, options) {
       options.onActivity?.();
     }
   }
+  function clearRetryIdleTimeout() {
+    if (retryIdleTimeout !== undefined) {
+      clearTimeout(retryIdleTimeout);
+      retryIdleTimeout = undefined;
+    }
+  }
+  function scheduleRetryIdleTimeout() {
+    clearRetryIdleTimeout();
+    const timeoutMs = options.sessionRetryIdleTimeoutMs ?? DEFAULT_SESSION_RETRY_IDLE_TIMEOUT_MS;
+    retryIdleTimeout = setTimeout(() => {
+      if (cancelled || terminalAbortRequested)
+        return;
+      logLine(target, "status", "retry_timeout");
+      emitAgentEnd();
+    }, timeoutMs);
+  }
   function emitAgentEnd(reason) {
+    if (agentEndEmitted)
+      return;
+    agentEndEmitted = true;
     logLine(target, "agent_end", reason ? `reason: ${reason}` : undefined);
     for (const cb of agentEndCallbacks)
       cb();
@@ -36338,11 +36335,6 @@ function startSessionEventForwarder(client4, options) {
     if (chunk2)
       logLine(target, "thinking", chunk2);
   }
-  async function handleToolPartUpdate(part, props, toolStates) {
-    if (!part.tool)
-      return;
-    await handleToolPart(part, props, toolStates);
-  }
   async function handlePartUpdated(props) {
     const part = props.part;
     const partType = part?.type;
@@ -36351,7 +36343,7 @@ function startSessionEventForwarder(client4, options) {
     const dispatch = {
       text: () => handleTextPartUpdate(props, part),
       reasoning: () => handleReasoningPartUpdate(props, part),
-      tool: () => handleToolPartUpdate(part, props, seenToolStates)
+      tool: () => part.tool ? handleToolPart(part, props, seenToolStates) : Promise.resolve()
     };
     await dispatch[partType]?.();
   }
@@ -36385,6 +36377,7 @@ function startSessionEventForwarder(client4, options) {
     logLine(target, "file", formatFilePayload(props));
   }
   async function handleSessionIdle() {
+    clearRetryIdleTimeout();
     if (terminalAbortRequested)
       return;
     emitAgentEnd();
@@ -36397,9 +36390,15 @@ function startSessionEventForwarder(client4, options) {
     if (currentStatus !== lastStatus) {
       lastStatus = currentStatus;
       logLine(target, "status", currentStatus);
-      if (currentStatus === "retry" && (terminalAbortRequested || isTerminalProviderFailureInLogs(recentLogLines))) {
-        abortTerminalProviderError();
+      if (currentStatus === "retry") {
+        if (terminalAbortRequested) {
+          abortTerminalProviderError();
+          return;
+        }
+        scheduleRetryIdleTimeout();
+        return;
       }
+      clearRetryIdleTimeout();
     }
   }
   async function handleSessionError(props) {
@@ -36484,6 +36483,7 @@ function startSessionEventForwarder(client4, options) {
   return {
     stop: () => {
       cancelled = true;
+      clearRetryIdleTimeout();
     },
     done: donePromise,
     onAgentEnd: (cb) => {
@@ -36492,9 +36492,10 @@ function startSessionEventForwarder(client4, options) {
     abortTerminalProviderError
   };
 }
-var RECENT_LOG_LINE_CAP = 20;
+var RECENT_LOG_LINE_CAP = 20, DEFAULT_SESSION_RETRY_IDLE_TIMEOUT_MS;
 var init_session_event_forwarder = __esm(() => {
   init_terminal_provider_error();
+  DEFAULT_SESSION_RETRY_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
 // src/infrastructure/services/remote-agents/opencode-sdk/session-metadata-store.ts
@@ -36594,7 +36595,6 @@ var init_opencode_sdk_agent_service = __esm(() => {
   init_parse_listening_url();
   init_session_event_forwarder();
   init_session_metadata_store();
-  init_terminal_provider_error();
   OpenCodeSdkAgentService = class OpenCodeSdkAgentService extends OpenCodeBinaryAgentService {
     agentEndCallbacksByPid = new Map;
     assistantTextCallbacksByPid = new Map;
@@ -36678,10 +36678,6 @@ var init_opencode_sdk_agent_service = __esm(() => {
       if (childProcess.stderr) {
         const stderrBuffer = new StderrLineBuffer((line) => {
           emitLogLine(line);
-          const activeForwarder = this.forwarders.get(pid);
-          if (activeForwarder && isNonRetryableHarnessFailureText(line)) {
-            activeForwarder.abortTerminalProviderError();
-          }
         });
         childProcess.stderr.on("data", (chunk2) => {
           entry.lastOutputAt = Date.now();
@@ -36694,6 +36690,18 @@ var init_opencode_sdk_agent_service = __esm(() => {
         });
       }
     }
+    createSessionForwarder(client4, sessionId, context5, emitLogLine, emitAssistantText, outputCallbacks) {
+      return startSessionEventForwarder(client4, {
+        sessionId,
+        role: context5.role,
+        onLogLine: emitLogLine,
+        onAssistantText: emitAssistantText,
+        onActivity: () => {
+          for (const cb of outputCallbacks)
+            cb();
+        }
+      });
+    }
     registerRunningSession(args2) {
       const {
         childProcess,
@@ -36884,16 +36892,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
         if (!sessionInfo.data?.id) {
           throw new Error(`OpenCode session ${sessionId} not found (sessions may not survive serve restart)`);
         }
-        forwarder = startSessionEventForwarder(client4, {
-          sessionId,
-          role: context5.role,
-          onLogLine: emitLogLine,
-          onAssistantText: emitAssistantText,
-          onActivity: () => {
-            for (const cb of outputCallbacks)
-              cb();
-          }
-        });
+        forwarder = this.createSessionForwarder(client4, sessionId, context5, emitLogLine, emitAssistantText, outputCallbacks);
         const availableAgents = await this.listAvailableAgents(client4);
         const agentDef = availableAgents.find((a) => a.name === agentName);
         const composedSystem = composeSystemPrompt(agentDef?.prompt, systemPrompt);
@@ -36941,16 +36940,7 @@ var init_opencode_sdk_agent_service = __esm(() => {
           throw new Error("Failed to create session");
         }
         sessionId = sessionCreateResult.data.id;
-        forwarder = startSessionEventForwarder(client4, {
-          sessionId,
-          role: context5.role,
-          onLogLine: emitLogLine,
-          onAssistantText: emitAssistantText,
-          onActivity: () => {
-            for (const cb of outputCallbacks)
-              cb();
-          }
-        });
+        forwarder = this.createSessionForwarder(client4, sessionId, context5, emitLogLine, emitAssistantText, outputCallbacks);
         const availableAgents = await this.listAvailableAgents(client4);
         const selected = selectAgent(availableAgents);
         agentName = selected.name;
@@ -37772,10 +37762,17 @@ var init_detection = __esm(() => {
 var MACHINE_CONFIG_VERSION = "1";
 
 // src/infrastructure/machine/storage.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
 import * as fs4 from "node:fs/promises";
 import { homedir as homedir3, hostname as hostname2 } from "node:os";
 import { join as join11 } from "node:path";
+function enqueueMachineConfigSave(task) {
+  const run3 = saveChain.then(task, task);
+  saveChain = run3.catch(() => {
+    return;
+  });
+  return run3;
+}
 function chatroomConfigDir() {
   return join11(homedir3(), ".chatroom");
 }
@@ -37801,13 +37798,20 @@ async function loadConfigFile() {
     return null;
   }
 }
-async function saveConfigFile(configFile) {
+async function writeConfigFileAtomically(configFile) {
   await ensureConfigDir2();
   const configPath = getMachineConfigPath();
-  const tempPath = `${configPath}.tmp`;
+  const tempPath = `${configPath}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
   const content = JSON.stringify(configFile, null, 2);
   await fs4.writeFile(tempPath, content, { mode: 384 });
-  await fs4.rename(tempPath, configPath);
+  try {
+    await fs4.rename(tempPath, configPath);
+  } catch (error) {
+    await fs4.unlink(tempPath).catch(() => {
+      return;
+    });
+    throw error;
+  }
 }
 async function loadMachineConfig() {
   const configFile = await loadConfigFile();
@@ -37817,13 +37821,15 @@ async function loadMachineConfig() {
   return configFile.machines[convexUrl] ?? null;
 }
 async function saveMachineConfig(config2) {
-  const configFile = await loadConfigFile() ?? {
-    version: MACHINE_CONFIG_VERSION,
-    machines: {}
-  };
-  const convexUrl = getConvexUrl();
-  configFile.machines[convexUrl] = config2;
-  await saveConfigFile(configFile);
+  await enqueueMachineConfigSave(async () => {
+    const configFile = await loadConfigFile() ?? {
+      version: MACHINE_CONFIG_VERSION,
+      machines: {}
+    };
+    const convexUrl = getConvexUrl();
+    configFile.machines[convexUrl] = config2;
+    await writeConfigFileAtomically(configFile);
+  });
 }
 async function createNewEndpointConfig() {
   const now = new Date().toISOString();
@@ -37867,10 +37873,11 @@ async function getMachineId() {
   const config2 = await loadMachineConfig();
   return config2?.machineId ?? null;
 }
-var MACHINE_FILE = "machine.json";
+var MACHINE_FILE = "machine.json", saveChain;
 var init_storage2 = __esm(() => {
   init_detection();
   init_client2();
+  saveChain = Promise.resolve();
 });
 
 // src/infrastructure/machine/daemon-state.ts
@@ -80480,6 +80487,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 <!-- Demonstrate adherence to:
 - Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
 - Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
+- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
+- Leave It Better: leave the code in a slightly better state than before when touching files.
 -->
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
@@ -80641,6 +80650,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 <!-- Demonstrate adherence to:
 - Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
 - Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
+- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
+- Leave It Better: leave the code in a slightly better state than before when touching files.
 -->
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
@@ -80741,6 +80752,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 <!-- Demonstrate adherence to:
 - Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
 - Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
+- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
+- Leave It Better: leave the code in a slightly better state than before when touching files.
 -->
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
@@ -84686,6 +84699,7 @@ var DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succ
   recover: () => exports_Effect.promise(() => mgr.recover()),
   getSlot: (chatroomId, role) => mgr.getSlot(chatroomId, role),
   listActive: () => mgr.listActive(),
+  clearStuckStoppingSlot: (chatroomId, role) => exports_Effect.promise(() => mgr.clearStuckStoppingSlot(chatroomId, role)),
   whenTurnEndsIdle: () => exports_Effect.promise(() => mgr.whenTurnEndsIdle()),
   resumeTurnForSlot: (args2) => exports_Effect.promise(() => mgr.resumeTurnForSlot(args2)),
   setLastInFlightTask: (chatroomId, role, taskId) => exports_Effect.sync(() => mgr.setLastInFlightTask(chatroomId, role, taskId))
@@ -86028,9 +86042,369 @@ var init_pid = __esm(() => {
   CHATROOM_DIR4 = join17(homedir6(), ".chatroom");
 });
 
-// src/infrastructure/harnesses/cursor-sdk/cursor-session.ts
+// src/infrastructure/harnesses/claude-sdk/claude-session.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 
+class ClaudeSdkSession {
+  opencodeSessionId;
+  _sessionTitle;
+  get sessionTitle() {
+    return this._sessionTitle;
+  }
+  cwd;
+  executablePath;
+  query;
+  defaultModel;
+  storedSystemPrompt;
+  onClose;
+  listeners = new Set;
+  closed = false;
+  providerSessionId;
+  resumeOnFirstQuery;
+  isFirstQuery = true;
+  activeQuery;
+  sawTextDelta = false;
+  sawThinkingDelta = false;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.executablePath = options.executablePath;
+    this.query = options.query;
+    this.opencodeSessionId = options.opencodeSessionId;
+    this._sessionTitle = options.sessionTitle;
+    this.defaultModel = options.defaultModel;
+    this.storedSystemPrompt = options.systemPrompt;
+    this.providerSessionId = options.providerSessionId;
+    this.resumeOnFirstQuery = options.resumeOnFirstQuery ?? false;
+    this.onClose = options.onClose;
+  }
+  setTitle(title) {
+    this._sessionTitle = title;
+  }
+  async prompt(input) {
+    if (this.closed)
+      throw new Error("Session is closed");
+    const text = input.parts.map((p) => p.text).join(`
+`);
+    const messageId = randomUUID4();
+    const model = resolveClaudeModel(this.defaultModel, input.model);
+    const useResume = Boolean(this.providerSessionId) && (!this.isFirstQuery || this.resumeOnFirstQuery);
+    this.sawTextDelta = false;
+    this.sawThinkingDelta = false;
+    const queryInstance = this.query({
+      prompt: text,
+      options: {
+        cwd: this.cwd,
+        model,
+        maxTurns: DEFAULT_MAX_TURNS3,
+        pathToClaudeCodeExecutable: this.executablePath,
+        includePartialMessages: true,
+        systemPrompt: this.isFirstQuery && !this.resumeOnFirstQuery ? this.storedSystemPrompt : undefined,
+        resume: useResume ? this.providerSessionId : undefined,
+        settingSources: [],
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        effort: DEFAULT_EFFORT2,
+        canUseTool: async (_toolName, toolInput) => ({
+          behavior: "allow",
+          updatedInput: toolInput
+        })
+      }
+    });
+    this.activeQuery = queryInstance;
+    if (this.resumeOnFirstQuery) {
+      this.resumeOnFirstQuery = false;
+    }
+    this.isFirstQuery = false;
+    try {
+      await withTimeout((async () => {
+        for await (const message of queryInstance) {
+          if (this.closed)
+            break;
+          this.captureProviderSessionId(message);
+          this.emitFromSdkMessage(message, messageId);
+          if (message.type === "result") {
+            if (message.is_error) {
+              const errors2 = "errors" in message && Array.isArray(message.errors) ? message.errors.join("; ") : "turn failed";
+              throw new Error(errors2);
+            }
+            break;
+          }
+        }
+      })(), QUERY_TIMEOUT_MS, "query");
+    } finally {
+      this.activeQuery = undefined;
+    }
+    this.emit({ type: "session.idle", payload: {}, timestamp: Date.now() });
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    try {
+      await this.activeQuery?.interrupt();
+    } catch {}
+    this.activeQuery = undefined;
+    this.onClose?.(this.opencodeSessionId);
+    this.listeners.clear();
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  emitDelta(messageId, delta, partType) {
+    if (!delta)
+      return;
+    this.emit({
+      type: "message.part.delta",
+      payload: { messageID: messageId, delta, partType },
+      timestamp: Date.now()
+    });
+  }
+  captureProviderSessionId(message) {
+    if (!("session_id" in message) || typeof message.session_id !== "string") {
+      return;
+    }
+    const sessionId = message.session_id;
+    if (this.providerSessionId === sessionId) {
+      return;
+    }
+    const isFirstAllocation = !this.providerSessionId;
+    this.providerSessionId = sessionId;
+    if (isFirstAllocation) {
+      this.emit({
+        type: "session.provider_id",
+        payload: { sessionId },
+        timestamp: Date.now()
+      });
+    }
+  }
+  emitFromSdkMessage(message, messageId) {
+    switch (message.type) {
+      case "stream_event": {
+        const event = message.event;
+        if (event.type === "content_block_delta") {
+          const delta = event.delta;
+          if (delta.type === "text_delta") {
+            this.sawTextDelta = true;
+            this.emitDelta(messageId, delta.text, "text");
+          } else if (delta.type === "thinking_delta") {
+            this.sawThinkingDelta = true;
+            this.emitDelta(messageId, delta.thinking, "reasoning");
+          }
+        }
+        break;
+      }
+      case "assistant":
+        for (const block of message.message.content) {
+          if (block.type === "text" && block.text) {
+            if (!this.sawTextDelta) {
+              this.emitDelta(messageId, block.text, "text");
+            }
+          } else if (block.type === "thinking" && block.thinking) {
+            if (!this.sawThinkingDelta) {
+              this.emitDelta(messageId, block.thinking, "reasoning");
+            }
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
+function resolveClaudeModel(defaultModel, promptModel) {
+  if (promptModel) {
+    if (promptModel.providerID === "anthropic")
+      return promptModel.modelID;
+    return promptModel.modelID;
+  }
+  if (defaultModel) {
+    const slash = defaultModel.indexOf("/");
+    if (slash === -1)
+      return defaultModel;
+    const provider = defaultModel.slice(0, slash);
+    const modelId = defaultModel.slice(slash + 1);
+    if (provider === "anthropic")
+      return modelId;
+    return modelId;
+  }
+  return "sonnet";
+}
+var DEFAULT_MAX_TURNS3 = 200, DEFAULT_EFFORT2 = "medium", QUERY_TIMEOUT_MS = 3600000;
+var init_claude_session = () => {};
+
+// src/infrastructure/harnesses/claude-sdk/claude-harness.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function loadSdk4() {
+  if (_sdkCache4)
+    return _sdkCache4;
+  if (_sdkLoadError4)
+    throw _sdkLoadError4;
+  try {
+    _sdkCache4 = await importBundledClaudeSdk();
+    return _sdkCache4;
+  } catch (err) {
+    _sdkLoadError4 = err;
+    throw err;
+  }
+}
+async function loadExecutablePath() {
+  if (_executablePathCache)
+    return _executablePathCache;
+  _executablePathCache = await resolvePathToClaudeCodeExecutable();
+  return _executablePathCache;
+}
+
+class ClaudeSdkHarness {
+  type = "claude-sdk";
+  displayName = "Claude (SDK)";
+  cwd;
+  query;
+  executablePath;
+  closed = false;
+  sessions = new Map;
+  constructor(cwd, sdk, executablePath) {
+    this.cwd = cwd;
+    this.query = sdk.query;
+    this.executablePath = executablePath;
+  }
+  async models() {
+    const providers = await this.listProviders();
+    const models = [];
+    for (const provider of providers) {
+      for (const model of provider.models) {
+        models.push({
+          id: `${provider.providerID}/${model.modelID}`,
+          name: model.name,
+          provider: provider.name
+        });
+      }
+    }
+    return models;
+  }
+  async listAgents() {
+    return [{ name: "builder", mode: "primary" }];
+  }
+  async listProviders() {
+    const dynamic = await fetchClaudeModels();
+    const modelIds = dynamic ?? [...CLAUDE_FALLBACK_MODELS];
+    return [
+      {
+        providerID: "anthropic",
+        name: "Anthropic",
+        models: modelIds.map((modelID) => ({ modelID, name: modelID }))
+      }
+    ];
+  }
+  async newSession(config3) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const opencodeSessionId = randomUUID5();
+    const session2 = new ClaudeSdkSession({
+      cwd: this.cwd,
+      executablePath: this.executablePath,
+      query: this.query,
+      opencodeSessionId,
+      sessionTitle: config3.title ?? "",
+      defaultModel: config3.model ?? DEFAULT_MODEL2,
+      systemPrompt: config3.systemPrompt,
+      onClose: (id3) => this.sessions.delete(id3)
+    });
+    this.sessions.set(opencodeSessionId, session2);
+    return session2;
+  }
+  async resumeSession(sessionId, _options) {
+    if (this.closed)
+      throw new Error("Harness is closed");
+    const existing = this.sessions.get(sessionId);
+    if (existing)
+      return existing;
+    const session2 = new ClaudeSdkSession({
+      cwd: this.cwd,
+      executablePath: this.executablePath,
+      query: this.query,
+      opencodeSessionId: sessionId,
+      sessionTitle: "",
+      providerSessionId: sessionId,
+      resumeOnFirstQuery: true,
+      onClose: (id3) => this.sessions.delete(id3)
+    });
+    this.sessions.set(sessionId, session2);
+    return session2;
+  }
+  async fetchSessionTitle(_opencodeSessionId) {
+    return;
+  }
+  isAlive() {
+    return !this.closed;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const closing = [...this.sessions.values()].map((s) => s.close().catch(() => {}));
+    await Promise.all(closing);
+    this.sessions.clear();
+  }
+}
+var DEFAULT_MODEL2 = "anthropic/sonnet", _sdkCache4, _sdkLoadError4, _executablePathCache, startClaudeSdkHarness = async (config3) => {
+  try {
+    const sdk = await loadSdk4();
+    const executablePath = await loadExecutablePath();
+    return new ClaudeSdkHarness(config3.workingDir, sdk, executablePath);
+  } catch (err) {
+    throw new Error(`claude-sdk unavailable: ${formatClaudeSdkLoadError(err)}`);
+  }
+};
+var init_claude_harness = __esm(() => {
+  init_claude_session();
+  init_claude_models();
+  init_claude_sdk_package();
+});
+
+// src/infrastructure/harnesses/shared-chunk-extractor.ts
+function createStandardSdkChunkExtractor() {
+  return function extract(event) {
+    if (event.type !== "message.part.delta")
+      return null;
+    const payload = event.payload;
+    const delta = payload?.delta;
+    if (!delta || delta.length === 0)
+      return null;
+    const messageId = payload?.messageID;
+    if (!messageId)
+      return null;
+    return {
+      content: delta,
+      messageId,
+      partType: payload?.partType ?? "text"
+    };
+  };
+}
+
+// src/infrastructure/harnesses/claude-sdk/event-extractor.ts
+function createClaudeSdkChunkExtractor() {
+  return createStandardSdkChunkExtractor();
+}
+var init_event_extractor = () => {};
+
+// src/infrastructure/harnesses/claude-sdk/index.ts
+var init_claude_sdk2 = __esm(() => {
+  init_claude_harness();
+  init_claude_session();
+  init_event_extractor();
+});
+
+// src/infrastructure/harnesses/cursor-sdk/cursor-session.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+
 class CursorSdkSession {
   opencodeSessionId;
   _sessionTitle;
@@ -86056,13 +86430,13 @@ class CursorSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID4();
+    const messageId = randomUUID6();
     const isFirstTurn = this.turnCount === 0;
     this.turnCount += 1;
     const modelId = input.model ? resolveModelFromPrompt(input.model.providerID, input.model.modelID) : undefined;
     const run3 = await withTimeout(this.agent.send(text, {
       local: { force: isFirstTurn },
-      idempotencyKey: randomUUID4(),
+      idempotencyKey: randomUUID6(),
       ...modelId ? { model: { id: modelId } } : {}
     }), SEND_TIMEOUT_MS2, "agent.send");
     for await (const message of run3.stream()) {
@@ -86135,16 +86509,16 @@ var SEND_TIMEOUT_MS2 = 60000, RUN_WAIT_TIMEOUT_MS2 = 3600000;
 var init_cursor_session = () => {};
 
 // src/infrastructure/harnesses/cursor-sdk/cursor-harness.ts
-async function loadSdk4() {
-  if (_sdkCache4)
-    return _sdkCache4;
-  if (_sdkLoadError4)
-    throw _sdkLoadError4;
+async function loadSdk5() {
+  if (_sdkCache5)
+    return _sdkCache5;
+  if (_sdkLoadError5)
+    throw _sdkLoadError5;
   try {
-    _sdkCache4 = await importBundledCursorSdk();
-    return _sdkCache4;
+    _sdkCache5 = await importBundledCursorSdk();
+    return _sdkCache5;
   } catch (err) {
-    _sdkLoadError4 = err;
+    _sdkLoadError5 = err;
     throw err;
   }
 }
@@ -86179,7 +86553,7 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       return [];
-    const { Cursor } = await loadSdk4();
+    const { Cursor } = await loadSdk5();
     const listed = await withTimeout(Cursor.models.list({ apiKey }), MODELS_LIST_TIMEOUT_MS2, "Cursor.models.list");
     const modelIds = normalizeCursorSdkListedModels(listed.map((m) => m.id).filter((id3) => id3.length > 0));
     return [
@@ -86196,8 +86570,8 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
-    const modelId = resolveCursorSdkModel(config3.model ?? DEFAULT_MODEL2);
-    const { Agent } = await loadSdk4();
+    const modelId = resolveCursorSdkModel(config3.model ?? DEFAULT_MODEL3);
+    const { Agent } = await loadSdk5();
     const agent = await withTimeout(Agent.create({
       apiKey,
       model: { id: modelId },
@@ -86221,10 +86595,10 @@ class CursorSdkHarness {
     const apiKey = process.env.CURSOR_API_KEY?.trim();
     if (!apiKey)
       throw new Error("CURSOR_API_KEY is not set");
-    const { Agent } = await loadSdk4();
+    const { Agent } = await loadSdk5();
     const agent = await withTimeout(Agent.resume(sessionId, {
       apiKey,
-      model: { id: DEFAULT_MODEL2 },
+      model: { id: DEFAULT_MODEL3 },
       local: { cwd: this.cwd, settingSources: [] }
     }), AGENT_CREATE_TIMEOUT_MS2, "Agent.resume");
     const session2 = new CursorSdkSession({
@@ -86251,9 +86625,9 @@ class CursorSdkHarness {
     this.sessions.clear();
   }
 }
-var DEFAULT_MODEL2 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache4, _sdkLoadError4, startCursorSdkHarness = async (config3) => {
+var DEFAULT_MODEL3 = "composer-2.5", MODELS_LIST_TIMEOUT_MS2 = 60000, AGENT_CREATE_TIMEOUT_MS2 = 60000, _sdkCache5, _sdkLoadError5, startCursorSdkHarness = async (config3) => {
   try {
-    await loadSdk4();
+    await loadSdk5();
   } catch (err) {
     throw new Error(`cursor-sdk unavailable: ${formatCursorSdkLoadError(err)}`);
   }
@@ -86267,37 +86641,17 @@ var init_cursor_harness = __esm(() => {
   init_cursor_sdk_package();
 });
 
-// src/infrastructure/harnesses/shared-chunk-extractor.ts
-function createStandardSdkChunkExtractor() {
-  return function extract(event) {
-    if (event.type !== "message.part.delta")
-      return null;
-    const payload = event.payload;
-    const delta = payload?.delta;
-    if (!delta || delta.length === 0)
-      return null;
-    const messageId = payload?.messageID;
-    if (!messageId)
-      return null;
-    return {
-      content: delta,
-      messageId,
-      partType: payload?.partType ?? "text"
-    };
-  };
-}
-
 // src/infrastructure/harnesses/cursor-sdk/event-extractor.ts
 function createCursorSdkChunkExtractor() {
   return createStandardSdkChunkExtractor();
 }
-var init_event_extractor = () => {};
+var init_event_extractor2 = () => {};
 
 // src/infrastructure/harnesses/cursor-sdk/index.ts
 var init_cursor_sdk2 = __esm(() => {
   init_cursor_harness();
   init_cursor_session();
-  init_event_extractor();
+  init_event_extractor2();
 });
 
 // src/infrastructure/harnesses/opencode-sdk/event-extractor.ts
@@ -86831,7 +87185,7 @@ var init_opencode_harness = __esm(() => {
 });
 
 // src/infrastructure/harnesses/pi-sdk/pi-session.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 
 class PiSdkSession {
   opencodeSessionId;
@@ -86858,7 +87212,7 @@ class PiSdkSession {
       throw new Error("Session is closed");
     const text = input.parts.map((p) => p.text).join(`
 `);
-    const messageId = randomUUID5();
+    const messageId = randomUUID7();
     const onSessionEvent = (event) => {
       if (this.closed)
         return;
@@ -86918,16 +87272,16 @@ var PROMPT_TIMEOUT_MS2 = 3600000;
 var init_pi_session = () => {};
 
 // src/infrastructure/harnesses/pi-sdk/pi-harness.ts
-async function loadSdk5() {
-  if (_sdkCache5)
-    return _sdkCache5;
-  if (_sdkLoadError5)
-    throw _sdkLoadError5;
+async function loadSdk6() {
+  if (_sdkCache6)
+    return _sdkCache6;
+  if (_sdkLoadError6)
+    throw _sdkLoadError6;
   try {
-    _sdkCache5 = await importBundledPiSdk();
-    return _sdkCache5;
+    _sdkCache6 = await importBundledPiSdk();
+    return _sdkCache6;
   } catch (err) {
-    _sdkLoadError5 = err;
+    _sdkLoadError6 = err;
     throw err;
   }
 }
@@ -86999,7 +87353,7 @@ class PiSdkHarness {
     const existing = this.sessions.get(sessionId);
     if (existing)
       return existing;
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk5();
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk6();
     const sessions = await SessionManager.list(this.cwd, getPiSessionDir(this.cwd));
     const match17 = sessions.find((s) => s.id === sessionId);
     if (!match17) {
@@ -87047,8 +87401,8 @@ class PiSdkHarness {
     this.sessions.clear();
   }
   async createAgentSession(systemPrompt, model) {
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk5();
-    const resolvedModel = resolveModel2(this.modelRegistry, model ?? DEFAULT_MODEL3);
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } = await loadSdk6();
+    const resolvedModel = resolveModel2(this.modelRegistry, model ?? DEFAULT_MODEL4);
     if (!resolvedModel) {
       throw new Error("No Pi model available — configure provider credentials in ~/.pi/agent/auth.json");
     }
@@ -87069,9 +87423,9 @@ class PiSdkHarness {
     return session2;
   }
 }
-var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL3 = "opencode/big-pickle", _sdkCache5, _sdkLoadError5, startPiSdkHarness = async (config3) => {
+var SESSION_CREATE_TIMEOUT_MS3 = 60000, DEFAULT_MODEL4 = "opencode/big-pickle", _sdkCache6, _sdkLoadError6, startPiSdkHarness = async (config3) => {
   try {
-    const { AuthStorage, ModelRegistry } = await loadSdk5();
+    const { AuthStorage, ModelRegistry } = await loadSdk6();
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
     if (modelRegistry.getAvailable().length === 0) {
@@ -87092,13 +87446,13 @@ var init_pi_harness = __esm(() => {
 function createPiSdkChunkExtractor() {
   return createStandardSdkChunkExtractor();
 }
-var init_event_extractor2 = () => {};
+var init_event_extractor3 = () => {};
 
 // src/infrastructure/harnesses/pi-sdk/index.ts
 var init_pi_sdk2 = __esm(() => {
   init_pi_harness();
   init_pi_session();
-  init_event_extractor2();
+  init_event_extractor3();
 });
 
 // src/infrastructure/harnesses/registry.ts
@@ -87111,6 +87465,8 @@ async function startBoundHarness(config3) {
       return startCursorSdkHarness(config3);
     case "pi-sdk":
       return startPiSdkHarness(config3);
+    case "claude-sdk":
+      return startClaudeSdkHarness(config3);
     default: {
       const _exhaustive = config3.harnessName;
       throw new Error(`Unsupported direct harness: ${String(_exhaustive)}`);
@@ -87125,6 +87481,8 @@ function createChunkExtractor(harnessName) {
       return createCursorSdkChunkExtractor();
     case "pi-sdk":
       return createPiSdkChunkExtractor();
+    case "claude-sdk":
+      return createClaudeSdkChunkExtractor();
     default:
       return createStandardSdkChunkExtractor();
   }
@@ -87159,6 +87517,16 @@ async function isPiSdkInstalled() {
     return false;
   }
 }
+async function isClaudeSdkInstalled() {
+  try {
+    const { importBundledClaudeSdk: importBundledClaudeSdk2, resolvePathToClaudeCodeExecutable: resolvePathToClaudeCodeExecutable2 } = await Promise.resolve().then(() => (init_claude_sdk_package(), exports_claude_sdk_package));
+    await importBundledClaudeSdk2();
+    await resolvePathToClaudeCodeExecutable2();
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function listInstalledNativeDirectHarnesses() {
   const installed2 = [];
   if (opencodeOnPath())
@@ -87167,9 +87535,12 @@ async function listInstalledNativeDirectHarnesses() {
     installed2.push("cursor-sdk");
   if (await isPiSdkInstalled())
     installed2.push("pi-sdk");
+  if (await isClaudeSdkInstalled())
+    installed2.push("claude-sdk");
   return installed2;
 }
 var init_registry4 = __esm(() => {
+  init_claude_sdk2();
   init_cursor_sdk2();
   init_opencode_harness();
   init_pi_sdk2();
@@ -87808,6 +88179,14 @@ function recordLiveSessionChunk(event, handle, journal, extractChunk, deps) {
     deps.sessionRepository.bindTurnMessageId(handle.currentTurn.turnId, chunk2.messageId).catch((err) => console.warn("[direct-harness] bindTurnMessageId error:", err));
   }
 }
+function handleLiveSessionProviderId(event, deps, rowId, handle, liveSession) {
+  if (event.type !== "session.provider_id")
+    return;
+  const sessionId = event.payload.sessionId;
+  if (!sessionId || sessionId === handle.opencodeSessionId)
+    return;
+  deps.sessionRepository.associateOpenCodeSessionId(rowId, sessionId, liveSession.sessionTitle ?? "").catch((err) => console.warn("[direct-harness] associateOpenCodeSessionId (provider id) error:", err));
+}
 function handleLiveSessionTitleUpdate(event, deps, rowId, liveSession) {
   if (event.type !== "session.updated") {
     return;
@@ -87827,6 +88206,7 @@ function handleLiveSessionEvent(event, ctx) {
     handleSessionIdle(handle, journal, idleConfig, deps.sessionRepository).catch((err) => console.warn("[direct-harness] idle handler error:", err));
   }
   handleLiveSessionTitleUpdate(event, deps, rowId, liveSession);
+  handleLiveSessionProviderId(event, deps, rowId, handle, liveSession);
 }
 async function processOne(daemonSession, deps, session2) {
   const rowId = session2._id;
@@ -90962,7 +91342,7 @@ function diffPathIndexes(previous, next4) {
 }
 
 // src/infrastructure/services/workspace/workspace-sync-state.ts
-import { createHash as createHash6, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 import { join as join20 } from "node:path";
@@ -91024,7 +91404,7 @@ function createManifestFromTree(args2) {
     version: SYNC_STATE_VERSION,
     machineId: args2.machineId,
     workingDir: normalizeWorkingDirForLookup(args2.workingDir),
-    syncGeneration: randomUUID6(),
+    syncGeneration: randomUUID8(),
     completedAt: Date.now(),
     scanner: args2.scanner,
     dataHash: args2.dataHash,
@@ -91046,7 +91426,7 @@ var init_workspace_sync_state = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import path6 from "node:path";
 function deltaEntry(paths, pathValue) {
   const type = paths[pathValue];
@@ -91073,7 +91453,7 @@ function buildPendingDeltas(previous, next4) {
   const result = [];
   for (let offset = 0;offset < operations.length; offset += MAX_DELTA_OPERATIONS) {
     const delta = {
-      operationId: randomUUID7(),
+      operationId: randomUUID9(),
       added: [],
       removed: [],
       typeChanged: [],
@@ -91297,7 +91677,7 @@ var init_workspace_file_tree_coordinator = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/file-tree-subscription.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { gzipSync as gzipSync4 } from "node:zlib";
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage2(err)}`);
@@ -91339,7 +91719,7 @@ function toDeltaOperations(delta) {
 }
 async function publishCheckpoint(session2, normalizedWorkingDir, tree, revision) {
   const dataHash = computeFileTreeDataHash(tree);
-  const syncGeneration = randomUUID8();
+  const syncGeneration = randomUUID10();
   const snapshot = await syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, syncGeneration);
   let checkpointRevision = revision;
   let result = await session2.backend.mutation(api.workspaceFiles.publishFileTreeCheckpoint, {
@@ -91868,6 +92248,8 @@ async function pushAvailableGitState(ctx, workingDir, stateKey, branchResult) {
       ...pipeline2.toMutationArgs(values3, false)
     });
     ctx.lastPushedGitState.set(stateKey, stateHash);
+    lastPushedBranch.set(stateKey, branch);
+    lastFullPushMs.set(stateKey, Date.now());
     console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${values3.get("isDirty") ? ", dirty" : ", clean"})`);
   }
   if (ctx.lastPushedGitState.get(commitsKey) !== commitsHash) {
@@ -91919,6 +92301,7 @@ function pushObservedBranchErrorEffect(session2, lastPushedGitState, stateKey, w
 function pushObservedFullGitStateEffect(session2, lastPushedGitState, stateKey, workingDir, branch, reason) {
   return exports_Effect.gen(function* () {
     yield* exports_Effect.promise(() => pushSingleWorkspaceGitStateImpl(buildGitStateDeps(session2, lastPushedGitState), workingDir));
+    lastPushedBranch.set(stateKey, branch);
     lastFullPushMs.set(stateKey, Date.now());
     console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed full git state pushed: ${workingDir} (${branch})${reason === "refresh" ? " [refresh]" : ""}`);
   });
@@ -91948,7 +92331,7 @@ function pushObservedSlimGitSummaryEffect(session2, lastPushedGitState, stateKey
     console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed git summary pushed: ${workingDir} (${branch}${values3.get("isDirty") ? ", dirty" : ", clean"})${reason === "refresh" ? " [refresh]" : ""}`);
   });
 }
-var lastFullPushMs, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummaryForObservedEffect = (workingDir, reason = "safety-poll") => exports_Effect.gen(function* pushObservedGitSummaryForObserved() {
+var lastFullPushMs, lastPushedBranch, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummaryForObservedEffect = (workingDir, reason = "safety-poll") => exports_Effect.gen(function* pushObservedGitSummaryForObserved() {
   const session2 = yield* DaemonSessionService;
   const mutable2 = yield* DaemonMutableStateService;
   const lastPushedGitState = yield* exports_Ref.get(mutable2.lastPushedGitState);
@@ -91969,7 +92352,10 @@ var lastFullPushMs, branchField, GIT_STATE_FIELDS, pushSingleWorkspaceGitSummary
   const branch = branchResult.branch;
   const now = Date.now();
   const lastFull = lastFullPushMs.get(stateKey) ?? 0;
-  if (now - lastFull >= OBSERVED_FULL_PUSH_INTERVAL_MS) {
+  const previousBranch = lastPushedBranch.get(stateKey);
+  const branchChanged = previousBranch !== undefined && previousBranch !== branch;
+  const needsFullPush = reason === "refresh" || branchChanged || now - lastFull >= OBSERVED_FULL_PUSH_INTERVAL_MS;
+  if (needsFullPush) {
     yield* pushObservedFullGitStateEffect(session2, lastPushedGitState, stateKey, workingDir, branch, reason);
     return;
   }
@@ -91990,6 +92376,7 @@ var init_git_heartbeat = __esm(() => {
   init_git_state_pipeline();
   init_convex_error();
   lastFullPushMs = new Map;
+  lastPushedBranch = new Map;
   branchField = {
     key: "branch",
     includeInSlim: true,
@@ -93171,7 +93558,8 @@ var init_decide_resume_path = __esm(() => {
     "platform.team_switch",
     "platform.resume_storm",
     "daemon.shutdown",
-    "daemon.respawn"
+    "daemon.respawn",
+    "daemon.stop_timeout"
   ]);
 });
 
@@ -93338,21 +93726,14 @@ function classifyResumeStormReason(logLines) {
   }
   return "unknown";
 }
-function isPermanentHarnessFailure(logLines) {
-  if (isTerminalProviderFailureInLogs(logLines)) {
-    return true;
-  }
-  return PERMANENT_FAILURE_REASONS.has(classifyResumeStormReason(logLines));
-}
 function formatPermanentHarnessFailureMessage(logLines) {
   const reason = classifyResumeStormReason(logLines);
   const blob = logLines.join(`
 `).trim();
-  return blob ? `Permanent harness error (${reason}): ${blob.slice(-500)}` : `Permanent harness error (${reason})`;
+  return blob ? `Crash recovery limit (${reason}): ${blob.slice(-500)}` : `Crash recovery limit (${reason})`;
 }
 var CLASSIFICATION_RULES, PERMANENT_FAILURE_REASONS;
 var init_classify_resume_storm_reason = __esm(() => {
-  init_terminal_provider_error();
   CLASSIFICATION_RULES = [
     {
       reason: "rate_limit",
@@ -93456,27 +93837,11 @@ async function handleTurnCompleted(deps, input, slot) {
   if (await tryAbortResumeStorm(deps, input, slot)) {
     return { outcome: "storm_aborted" };
   }
-  if (isTerminalProviderFailureInLogs(slot?.recentLogLines ?? [])) {
-    if (slot) {
-      slot.terminalProviderFailureHandled = true;
-    }
-    const error = formatTerminalProviderFailureMessage(slot?.recentLogLines ?? []);
-    try {
-      await deps.backend.emitAgentStartFailed({
-        chatroomId: input.chatroomId,
-        role: input.role,
-        error
-      });
-    } catch {}
-    deps.killProcess(input.pid);
-    return { outcome: "killed_terminal_provider_error" };
-  }
   deps.killProcess(input.pid);
   return { outcome: "killed" };
 }
 var init_handle_turn_completed = __esm(() => {
   init_abort_resume_storm();
-  init_terminal_provider_error();
 });
 
 // src/infrastructure/deps/process.ts
@@ -93894,19 +94259,30 @@ class AgentProcessManager {
   whenTurnEndsIdle() {
     return this.turnEndQueue.whenIdle();
   }
+  clearSlotRuntimeState(slot) {
+    slot.state = "idle";
+    slot.pid = undefined;
+    slot.harness = undefined;
+    slot.harnessSessionId = undefined;
+    slot.resumableHarnessSessionId = undefined;
+    slot.model = undefined;
+    slot.workingDir = undefined;
+    slot.startedAt = undefined;
+    slot.pendingOperation = undefined;
+    slot.stoppingSince = undefined;
+  }
+  bumpStopGeneration(slot) {
+    slot.stopGeneration = (slot.stopGeneration ?? 0) + 1;
+    return slot.stopGeneration;
+  }
   async ensureRunning(opts) {
     const key = agentKey3(opts.chatroomId, opts.role);
     const slot = this.getOrCreateSlot(key);
     if (slot.state === "running" && slot.pid && !isProcessAlive(this.deps.processes.kill, slot.pid)) {
-      slot.state = "idle";
-      slot.pid = undefined;
-      slot.harness = undefined;
-      slot.harnessSessionId = undefined;
-      slot.resumableHarnessSessionId = undefined;
-      slot.model = undefined;
-      slot.workingDir = undefined;
-      slot.startedAt = undefined;
-      slot.pendingOperation = undefined;
+      this.clearSlotRuntimeState(slot);
+    }
+    if (slot.state === "stopping" && (slot.stoppingSince === undefined || this.deps.clock.now() - slot.stoppingSince >= STOPPING_TIMEOUT_MS)) {
+      await this.forceClearStuckStoppingSlot(key, slot, opts.chatroomId, opts.role, "daemon.stop_timeout");
     }
     if (slot.pendingOperation) {
       if (slot.state === "stopping") {
@@ -93970,7 +94346,9 @@ class AgentProcessManager {
       return { success: true };
     }
     slot.state = "stopping";
-    const operation = this.doStop(key, slot, pid, opts);
+    const stopGeneration = this.bumpStopGeneration(slot);
+    slot.stoppingSince = this.deps.clock.now();
+    const operation = this.doStop(key, slot, pid, opts, stopGeneration);
     slot.pendingOperation = operation;
     return null;
   }
@@ -94053,24 +94431,6 @@ class AgentProcessManager {
       console.log(`[AgentProcessManager] ✅ Handled rapid resume storm for ${opts.role}`);
       return;
     }
-    if (isTerminalProviderFailureInLogs(slot?.recentLogLines ?? [])) {
-      if (slot) {
-        slot.terminalProviderFailureHandled = true;
-      }
-      const error = formatTerminalProviderFailureMessage(slot?.recentLogLines ?? []);
-      try {
-        await createTurnCompletedBackend(this.deps).emitAgentStartFailed({
-          chatroomId: opts.chatroomId,
-          role: opts.role,
-          error
-        });
-      } catch {}
-      try {
-        this.deps.processes.kill(-opts.pid, "SIGTERM");
-      } catch {}
-      console.log(`[AgentProcessManager] ⛔ Terminal provider error for ${opts.role} — emitted agent.startFailed`);
-      return;
-    }
     try {
       const result = await this.deps.backend.mutation(api.participants.handleNativeAgentEnd, {
         sessionId: this.deps.sessionId,
@@ -94217,16 +94577,12 @@ class AgentProcessManager {
       console.log(`[AgentProcessManager] ⚠️  Cannot restart — missing harness or workingDir ` + `(role: ${opts.role}, harness: ${harness ?? "none"}, workingDir: ${workingDir ?? "none"})`);
       return;
     }
-    if (isPermanentHarnessFailure(logs)) {
-      this.handlePermanentFailureForRestart(opts, recentLogLines, ctx.terminalProviderFailureHandled);
-      return;
-    }
     const hadRunError = this.hasCursorSdkRunErrorInContext(logs);
     if (harness === "cursor-sdk") {
       this.retryCursorSdkSessionReopen(opts, ctx, hadRunError);
       return;
     }
-    this.ensureRunning({
+    this.attemptCrashRecoveryRestart(opts, ctx, {
       chatroomId: opts.chatroomId,
       role: opts.role,
       agentHarness: harness,
@@ -94234,15 +94590,54 @@ class AgentProcessManager {
       workingDir,
       reason: "platform.crash_recovery",
       wantResume: hadRunError ? false : ctx.wantResume ?? true
-    }).then((result) => {
-      if (!result.success) {
-        console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${opts.role}: ${result.error ?? "unknown"}`);
-      }
-    }).catch((err) => {
-      console.log(`   ⚠️  Failed to restart agent: ${err.message}`);
-      this.emitStartFailedEvent(opts.role, opts.chatroomId, err.message);
     });
   }
+  async attemptCrashRecoveryRestart(exitOpts, ctx, ensureOpts) {
+    try {
+      const result = await this.ensureRunning(ensureOpts);
+      if (result.success)
+        return;
+      if (result.error === "backoff") {
+        await this.retryCrashRecoveryAfterBackoff(exitOpts, ctx, ensureOpts, result.retryAfterMs);
+        return;
+      }
+      if (result.error === "crash_loop") {
+        this.handleCrashLoopLimitReached(exitOpts, ctx.recentLogLines);
+        return;
+      }
+      console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${exitOpts.role}: ${result.error ?? "unknown"}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`   ⚠️  Failed to restart agent: ${message}`);
+      this.emitStartFailedEvent(exitOpts.role, exitOpts.chatroomId, message);
+    }
+  }
+  async retryCrashRecoveryAfterBackoff(exitOpts, ctx, ensureOpts, retryAfterMs) {
+    if (retryAfterMs === undefined || retryAfterMs <= 0) {
+      return;
+    }
+    const classified = classifyResumeStormReason(ctx.recentLogLines ?? []);
+    console.log(`[AgentProcessManager] ⏳ Crash recovery backoff for ${exitOpts.role} (${classified}): waiting ${retryAfterMs}ms`);
+    await this.deps.clock.delay(retryAfterMs);
+    const retry4 = await this.ensureRunning(ensureOpts);
+    if (retry4.success)
+      return;
+    if (retry4.error === "crash_loop") {
+      this.handleCrashLoopLimitReached(exitOpts, ctx.recentLogLines);
+      return;
+    }
+    if (!retry4.success) {
+      console.log(`[AgentProcessManager] ⚠️  Agent restart did not complete for ${exitOpts.role}: ${retry4.error ?? "unknown"}`);
+    }
+  }
+  handleCrashLoopLimitReached(opts, recentLogLines) {
+    const error = formatPermanentHarnessFailureMessage(recentLogLines ?? []);
+    console.log(`[AgentProcessManager] ⛔ Crash recovery limit reached — ${error}`);
+    this.deps.crashLoop.clear(opts.chatroomId, opts.role);
+    const key = agentKey3(opts.chatroomId, opts.role);
+    this.clearLastHarnessSession(key);
+    this.emitStartFailedEvent(opts.role, opts.chatroomId, error);
+  }
   clearHarnessSessionAfterResumePhaseFailure(key, opts) {
     const stored = this.lastHarnessSessions.get(key);
     this.clearLastHarnessSession(key);
@@ -94310,25 +94705,6 @@ class AgentProcessManager {
       this.sessionReopenRetryInFlight.delete(key);
     }
   }
-  handlePermanentFailureForRestart(opts, recentLogLines, startFailedAlreadyEmitted) {
-    const error = isTerminalProviderFailureInLogs(recentLogLines ?? []) ? formatTerminalProviderFailureMessage(recentLogLines ?? []) : formatPermanentHarnessFailureMessage(recentLogLines ?? []);
-    console.log(`[AgentProcessManager] ⛔ Skipping restart — ${error}`);
-    this.deps.crashLoop.clear(opts.chatroomId, opts.role);
-    const key = agentKey3(opts.chatroomId, opts.role);
-    this.clearLastHarnessSession(key);
-    if (startFailedAlreadyEmitted) {
-      return;
-    }
-    this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
-      sessionId: this.deps.sessionId,
-      machineId: this.deps.machineId,
-      chatroomId: opts.chatroomId,
-      role: opts.role,
-      error
-    }).catch((emitErr) => {
-      console.log(`   ⚠️  Failed to emit startFailed event: ${emitErr.message}`);
-    });
-  }
   emitStartFailedEvent(role, chatroomId, error) {
     this.deps.backend.mutation(api.machines.emitAgentStartFailed, {
       sessionId: this.deps.sessionId,
@@ -94355,6 +94731,37 @@ class AgentProcessManager {
     }
     return result;
   }
+  listAllSlots() {
+    const result = [];
+    for (const [key, slot] of this.slots) {
+      const [chatroomId, role] = key.split(":");
+      result.push({ chatroomId, role, slot });
+    }
+    return result;
+  }
+  async clearStuckStoppingSlot(chatroomId, role) {
+    const key = agentKey3(chatroomId, role);
+    const slot = this.slots.get(key);
+    if (!slot || slot.state !== "stopping") {
+      return false;
+    }
+    const elapsed3 = slot.stoppingSince ? this.deps.clock.now() - slot.stoppingSince : STOPPING_TIMEOUT_MS;
+    if (elapsed3 < STOPPING_TIMEOUT_MS) {
+      return false;
+    }
+    await this.forceClearStuckStoppingSlot(key, slot, chatroomId, role, "daemon.stop_timeout");
+    console.warn(`[AgentProcessManager] ⚠️ Cleared stuck stopping slot for ${role}@${chatroomId}`);
+    return true;
+  }
+  async clearAllStuckStoppingSlots() {
+    let cleared = 0;
+    for (const { chatroomId, role } of this.listAllSlots()) {
+      if (await this.clearStuckStoppingSlot(chatroomId, role)) {
+        cleared++;
+      }
+    }
+    return cleared;
+  }
   async recover() {
     let entries2 = [];
     try {
@@ -94387,6 +94794,10 @@ class AgentProcessManager {
       }
     }
     console.log(`[AgentProcessManager] Recovery: ${killed} killed, ${cleaned} cleaned up`);
+    const clearedCount = await this.clearAllStuckStoppingSlots();
+    if (clearedCount > 0) {
+      console.log(`[AgentProcessManager] Recovery: cleared ${clearedCount} stuck stopping slot(s)`);
+    }
   }
   getOrCreateSlot(key) {
     let slot = this.slots.get(key);
@@ -94423,7 +94834,9 @@ class AgentProcessManager {
     if (slot?.pid && isProcessAlive(this.deps.processes.kill, slot.pid) && (slot.state === "running" || slot.state === "spawning")) {
       const pid = slot.pid;
       slot.state = "stopping";
-      await this.doStop(key, slot, pid, { chatroomId, role, reason: "daemon.respawn" });
+      const stopGeneration = this.bumpStopGeneration(slot);
+      slot.stoppingSince = this.deps.clock.now();
+      await this.doStop(key, slot, pid, { chatroomId, role, reason: "daemon.respawn" }, stopGeneration);
     }
   }
   async killPersistedProcessIfAlive(chatroomId, role) {
@@ -94693,7 +95106,7 @@ class AgentProcessManager {
     if (loopCheck.waitMs !== undefined && loopCheck.waitMs > 0) {
       console.log(`   ⏳ Agent restart backoff: waiting ${loopCheck.waitMs}ms before retry`);
       this.resetSlotIdle(slot);
-      return { success: false, error: "backoff" };
+      return { success: false, error: "backoff", retryAfterMs: loopCheck.waitMs };
     }
     this.deps.backend.mutation(api.machines.emitRestartLimitReached, {
       sessionId: this.deps.sessionId,
@@ -95018,6 +95431,42 @@ class AgentProcessManager {
     slot.pid = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
+    slot.stoppingSince = undefined;
+  }
+  async forceClearStuckStoppingSlot(key, slot, chatroomId, role, reason) {
+    const pid = slot.pid;
+    const harness = slot.harness;
+    const durationMs = slot.stoppingSince ? this.deps.clock.now() - slot.stoppingSince : STOPPING_TIMEOUT_MS;
+    this.bumpStopGeneration(slot);
+    this.clearSlotRuntimeState(slot);
+    this.deps.backend.mutation(api.machines.emitAgentStopTimeout, {
+      sessionId: this.deps.sessionId,
+      machineId: this.deps.machineId,
+      chatroomId,
+      role,
+      pid,
+      durationMs
+    }).catch((err) => {
+      console.log(`   ⚠️  Failed to emit agent.stopTimeout event: ${err.message}`);
+    });
+    if (pid) {
+      try {
+        this.deps.processes.kill(-pid, "SIGKILL");
+      } catch {}
+      const exitArgs = {
+        sessionId: this.deps.sessionId,
+        machineId: this.deps.machineId,
+        chatroomId,
+        role,
+        pid,
+        stopReason: reason,
+        exitCode: undefined,
+        signal: "SIGKILL",
+        agentHarness: harness
+      };
+      this.recordAgentExitedOrQueueRetry(role, exitArgs, "Failed to record stop-timeout exit");
+    }
+    await this.clearAgentPidQuietly(chatroomId, role);
   }
   recordStopExit(slot, pid, opts) {
     const exitArgs3 = {
@@ -95036,7 +95485,7 @@ class AgentProcessManager {
       this.queueExitRetry({ role: opts.role, args: exitArgs3 });
     });
   }
-  async doStop(key, slot, pid, opts) {
+  async doStop(key, slot, pid, opts, stopGeneration) {
     try {
       const harness = slot.harness;
       const service3 = harness ? this.deps.agentServices.get(harness) : undefined;
@@ -95048,6 +95497,9 @@ class AgentProcessManager {
         await this.killProcessWithFallback(pid);
       }
     } catch {}
+    if (slot.stopGeneration !== stopGeneration) {
+      return { success: true };
+    }
     this.resetSlotAfterStop(slot);
     this.recordStopExit(slot, pid, opts);
     try {
@@ -95056,7 +95508,7 @@ class AgentProcessManager {
     return { success: true };
   }
 }
-var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4;
+var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4, STOPPING_TIMEOUT_MS = 30000;
 var init_agent_process_manager = __esm(() => {
   init_types();
   init_participant();
@@ -95069,7 +95521,6 @@ var init_agent_process_manager = __esm(() => {
   init_agent_lifecycle();
   init_abort_resume_storm();
   init_classify_resume_storm_reason();
-  init_terminal_provider_error();
   init_handle_turn_completed();
   init_spawn_policy();
   init_agent_lifecycle_runtime();
@@ -108577,10 +109028,19 @@ function isPendingAliveRunningTask(task) {
   const { agentConfig, status: status3 } = task;
   return status3 === "pending" && agentConfig.spawnedAgentPid != null && agentConfig.desiredState === "running";
 }
-function isSlotUnavailableForPid(slot, pid, isPidAlive) {
-  if (!slot || slot.state === "idle" || slot.state === "stopping") {
+function isSlotUnavailableForPid(slot, pid, isPidAlive, now = Date.now()) {
+  if (!slot) {
+    return true;
+  }
+  if (slot.state === "idle") {
     return true;
   }
+  if (slot.state === "stopping") {
+    if (!slot.stoppingSince || now - slot.stoppingSince >= STOPPING_TIMEOUT_MS) {
+      return true;
+    }
+    return false;
+  }
   if (slot.pid !== pid) {
     return true;
   }
@@ -108596,7 +109056,7 @@ function isNativeRevivableTaskStatus(task) {
   }
   return false;
 }
-function isNativeAgentSlotDown(task, health) {
+function isNativeAgentSlotDown(task, health, now = Date.now()) {
   const slot = health.getSlot(task.chatroomId, task.agentConfig.role);
   if (slot?.state === "spawning")
     return false;
@@ -108604,20 +109064,20 @@ function isNativeAgentSlotDown(task, health) {
   if (pid == null) {
     return slot?.state !== "running";
   }
-  return isSlotUnavailableForPid(slot, pid, health.isPidAlive);
+  return isSlotUnavailableForPid(slot, pid, health.isPidAlive, now);
 }
-function isNativeActiveTaskAgentDown(task, health) {
+function isNativeActiveTaskAgentDown(task, health, now) {
   if (!isNativeHarness(task.agentConfig.agentHarness))
     return false;
   if (task.agentConfig.desiredState !== "running")
     return false;
   if (!isNativeRevivableTaskStatus(task))
     return false;
-  return isNativeAgentSlotDown(task, health);
+  return isNativeAgentSlotDown(task, health, now);
 }
 function listNativeTasksNeedingRevive(tasks, health, now, cooldown) {
   return tasks.filter((task) => {
-    if (!isNativeActiveTaskAgentDown(task, health))
+    if (!isNativeActiveTaskAgentDown(task, health, now))
       return false;
     const { chatroomId, agentConfig } = task;
     if (!agentConfig.workingDir)
@@ -108677,6 +109137,7 @@ var PENDING_IDLE_NUDGE_MS = 15000, NUDGE_COOLDOWN_MS = 60000;
 var init_task_monitor_logic = __esm(() => {
   init_native_task_injector_logic();
   init_predicates();
+  init_agent_process_manager();
 });
 // ../../services/backend/src/domain/usecase/machine/assigned-task-monitor-row.ts
 function applyAssignedTaskSignal(existing, signal) {
@@ -109319,8 +109780,15 @@ function runCliNudgeEffect(task, runtime4, effectContext2, agentMgr, sessionDeps
   console.log(buildCliNudgeLogLine(task));
   executeCliNudge(task, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
 }
+async function clearStuckStoppingSlotIfNeeded(agentMgr, chatroomId, role) {
+  const cleared = await agentMgr.clearStuckStoppingSlot(chatroomId, role);
+  if (cleared) {
+    console.log(`[TaskMonitor] cleared stuck stopping slot for ${role}@${chatroomId}`);
+  }
+}
 async function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   for (const row of listTasksReadyForNudge(tasks, now, cooldown)) {
+    await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
@@ -109329,6 +109797,7 @@ async function nudgeStuckTasks(tasks, now, cooldown, runtime4, effectContext2, a
 }
 async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   for (const row of listNativeTasksNeedingRevive(tasks, localHealth, now, cooldown)) {
+    await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
@@ -109579,7 +110048,7 @@ function handleGitRefreshCommandEffect(event, tracker) {
     const lastPushedGitState = yield* exports_Ref.get(mutable2.lastPushedGitState);
     lastPushedGitState.delete(makeGitStateKey(session2.machineId, typedEvent.workingDir));
     console.log(`[${formatTimestamp()}] \uD83D\uDD04 Git refresh requested for ${typedEvent.workingDir}`);
-    yield* pushGitStateEffect;
+    yield* pushSingleWorkspaceGitStateEffect(typedEvent.workingDir);
     tracker.gitRefreshIds.set(eventId, Date.now());
   });
 }
@@ -110988,4 +111457,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D9A06559C6AC810C64756E2164756E21
+//# debugId=B0C2AFBAB3CD49E664756E2164756E21