happy-imou-cloud 2.1.1 → 2.1.2

package/dist/{registerKillSessionHandler-Dg_iRBPm.cjs → registerKillSessionHandler-BapPCRmp.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var index = require('./index-CuuYSKiv.cjs');
-var persistence = require('./persistence-Dzr6sFwD.cjs');
+var index = require('./index-Cuvs0lFS.cjs');
+var persistence = require('./persistence-C8-MtdQK.cjs');
 var os = require('node:os');
 var path = require('node:path');
-var api = require('./api-DId_j3C2.cjs');
+var api = require('./api-DZimmN4C.cjs');
 var node_crypto = require('node:crypto');
 var crypto = require('crypto');
 require('axios');
@@ -302,7 +302,7 @@ function createAbortError() {
   error.name = "AbortError";
   return error;
 }
-async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs = 12e4) {
+async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs = 10 * 6e4) {
   if (!backend.waitForResponseComplete) {
     return;
   }
@@ -356,6 +356,418 @@ async function syncControlledByUserState(sessionClient, controlledByUser) {
   });
 }
 
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeSummaryText(value) {
+  const normalized = normalizeOptionalText(value);
+  return normalized ? normalized.replace(/\s+/g, " ").slice(0, api.HAPPY_ORG_SUMMARY_MAX_LENGTH) : null;
+}
+function cloneHappyOrgMetadata(happyOrg) {
+  return {
+    taskContext: happyOrg?.taskContext ? { ...happyOrg.taskContext } : void 0,
+    runtime: happyOrg?.runtime ? { ...happyOrg.runtime } : void 0,
+    activeOwner: happyOrg?.activeOwner ? { ...happyOrg.activeOwner } : null,
+    repeat: happyOrg?.repeat ? {
+      threshold: happyOrg.repeat.threshold,
+      fingerprints: Object.fromEntries(
+        Object.entries(happyOrg.repeat.fingerprints ?? {}).map(([fingerprint, entry]) => [
+          fingerprint,
+          { ...entry }
+        ])
+      )
+    } : void 0,
+    lastTurnReport: happyOrg?.lastTurnReport ? { ...happyOrg.lastTurnReport } : void 0
+  };
+}
+function normalizeHappyOrgMetadata(metadata) {
+  const happyOrg = cloneHappyOrgMetadata(metadata?.happyOrg);
+  return {
+    ...happyOrg,
+    runtime: happyOrg.runtime ?? {
+      status: "active",
+      reason: null
+    },
+    repeat: happyOrg.repeat ?? {
+      threshold: api.HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function withHappyOrgMetadata(metadata, happyOrg) {
+  return {
+    ...metadata,
+    happyOrg
+  };
+}
+function resetHappyOrgRuntimeForTask(taskContext) {
+  return {
+    taskContext,
+    runtime: {
+      status: "active",
+      reason: null
+    },
+    activeOwner: null,
+    repeat: {
+      threshold: api.HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function buildTerminatedStatusMessage(taskId) {
+  return `Task ${taskId} is terminated. Reopen it with new context, a new decision, or a new resource before continuing.`;
+}
+function buildMemberBusyStatusMessage(memberAgentId, activeTaskId, nextTaskId) {
+  return `Member ${memberAgentId} is already busy with active task ${activeTaskId}. Reject task ${nextTaskId} without continuing token usage.`;
+}
+function buildOwnerConflictStatusMessage(taskId, ownerAgentId) {
+  return `Task ${taskId} is already active under owner ${ownerAgentId}. This turn must exit without continuing token usage.`;
+}
+function inferDraftTurnStatus(draft) {
+  if (draft?.turnStatus === "turn_update" || draft?.turnStatus === "task_complete") {
+    return draft.turnStatus;
+  }
+  return null;
+}
+function inferInterventionType(draft) {
+  if (draft?.interventionType === "none" || draft?.interventionType === "review_needed" || draft?.interventionType === "blocker" || draft?.interventionType === "decision_needed") {
+    return draft.interventionType;
+  }
+  if (normalizeOptionalText(draft?.decisionNeeded)) {
+    return "decision_needed";
+  }
+  if (normalizeOptionalText(draft?.blockerCode)) {
+    return "blocker";
+  }
+  return "none";
+}
+function buildFallbackSummary(text, turnStatus) {
+  const trimmed = text.trim();
+  if (trimmed) {
+    return trimmed.replace(/\s+/g, " ").slice(0, api.HAPPY_ORG_SUMMARY_MAX_LENGTH);
+  }
+  return turnStatus === "turn_aborted" ? "Turn aborted before completion." : "Turn completed without a textual summary.";
+}
+function normalizeTurnReportDraft(draft) {
+  return {
+    turnStatus: inferDraftTurnStatus(draft),
+    summary: normalizeSummaryText(draft?.summary),
+    interventionType: inferInterventionType(draft),
+    blockerCode: normalizeOptionalText(draft?.blockerCode),
+    decisionNeeded: normalizeOptionalText(draft?.decisionNeeded),
+    targetArtifact: normalizeOptionalText(draft?.targetArtifact)
+  };
+}
+function stripCodeFence(text) {
+  return text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+}
+function extractTaggedTurnReport(text) {
+  const matcher = new RegExp(
+    `<${api.HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${api.HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "gi"
+  );
+  let lastMatch = null;
+  for (let match = matcher.exec(text); match; match = matcher.exec(text)) {
+    lastMatch = match;
+  }
+  if (!lastMatch) {
+    return {
+      cleanedText: text.trim(),
+      draft: null
+    };
+  }
+  const rawBlock = stripCodeFence(lastMatch[1] ?? "");
+  let draft = null;
+  try {
+    const parsed = JSON.parse(rawBlock);
+    draft = {
+      turnStatus: normalizeOptionalText(parsed.turnStatus),
+      summary: normalizeSummaryText(parsed.summary),
+      interventionType: normalizeOptionalText(parsed.interventionType),
+      blockerCode: normalizeOptionalText(parsed.blockerCode),
+      decisionNeeded: normalizeOptionalText(parsed.decisionNeeded),
+      targetArtifact: normalizeOptionalText(parsed.targetArtifact)
+    };
+  } catch {
+    draft = null;
+  }
+  const cleanedText = `${text.slice(0, lastMatch.index)}${text.slice(lastMatch.index + lastMatch[0].length)}`.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    cleanedText,
+    draft
+  };
+}
+function buildRepeatFingerprint(context, blockerCode, targetArtifact) {
+  if (!blockerCode) {
+    return null;
+  }
+  return [
+    context.taskId,
+    context.memberAgentId,
+    blockerCode,
+    targetArtifact ?? ""
+  ].join("::");
+}
+function resolveReportedTurnStatus(transportTurnStatus, draft) {
+  if (transportTurnStatus === "turn_aborted") {
+    return "turn_aborted";
+  }
+  return draft.turnStatus === "task_complete" ? "task_complete" : "turn_update";
+}
+function buildRuntimeStateAfterTurn(report) {
+  if (report.turnStatus === "task_complete") {
+    return {
+      status: "waiting_close",
+      reason: "awaiting_ceo_close"
+    };
+  }
+  switch (report.interventionType) {
+    case "decision_needed":
+      return {
+        status: "waiting_decision",
+        reason: "awaiting_user_decision"
+      };
+    case "review_needed":
+      return {
+        status: "waiting_review",
+        reason: "awaiting_ceo_review"
+      };
+    case "blocker":
+      return {
+        status: "waiting_review",
+        reason: "awaiting_ceo_context"
+      };
+    default:
+      return {
+        status: "active",
+        reason: null
+      };
+  }
+}
+function buildHappyOrgTurnPrompt(prompt, turn) {
+  const reopenLines = turn.reopenContext ? [
+    "",
+    "This task was explicitly reopened for this turn with the following new inputs:",
+    turn.reopenContext.newContext ? `- newContext: ${turn.reopenContext.newContext}` : null,
+    turn.reopenContext.newDecision ? `- newDecision: ${turn.reopenContext.newDecision}` : null,
+    turn.reopenContext.newResource ? `- newResource: ${turn.reopenContext.newResource}` : null
+  ].filter(Boolean) : [];
+  const header = [
+    "[HAPPY_ORG_TASK_CONTEXT]",
+    `taskId=${turn.context.taskId}`,
+    `organizationId=${turn.context.organizationId}`,
+    `memberAgentId=${turn.context.memberAgentId}`,
+    `supervisorAgentId=${turn.context.supervisorAgentId}`,
+    "Stay on this exact task for the whole turn.",
+    "End your response with exactly one raw JSON block inside these tags and do not wrap it in a markdown code fence:",
+    `<${api.HAPPY_ORG_TURN_REPORT_TAG}>{"turnStatus":"turn_update","summary":"short task-board summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null}</${api.HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "Allowed turnStatus values in the JSON block: turn_update, task_complete.",
+    "Allowed interventionType values: none, review_needed, blocker, decision_needed.",
+    "Use turnStatus=task_complete only when you believe the assigned task is finished and ready for CEO acceptance.",
+    "If turnStatus=task_complete, the task will wait for CEO close; do not treat it as automatically closed.",
+    "If turnStatus=task_complete, interventionType must be review_needed.",
+    `summary must fit on a one-line CEO card or task-board card: short, actionable, no long process logs, max ${api.HAPPY_ORG_SUMMARY_MAX_LENGTH} characters.`,
+    "Use blocker only for problems the organization may still solve internally.",
+    "Use decision_needed only when a CEO or user decision is required.",
+    "Use review_needed when supervisor review is needed but the work is not blocked.",
+    ...reopenLines,
+    "[/HAPPY_ORG_TASK_CONTEXT]",
+    "",
+    prompt
+  ];
+  return header.join("\n");
+}
+function resolveHappyOrgQueuedTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  if (!metadata) {
+    return {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false
+    };
+  }
+  const currentHappyOrg = normalizeHappyOrgMetadata(metadata);
+  let nextHappyOrg = cloneHappyOrgMetadata(currentHappyOrg);
+  const messageHappyOrg = opts.message.meta?.happyOrg;
+  const now = opts.now?.() ?? Date.now();
+  const createRunId = opts.createRunId ?? ((taskContext2, currentNow) => `${taskContext2.taskId}:${taskContext2.memberAgentId}:${currentNow}`);
+  if (messageHappyOrg?.taskContext) {
+    const currentTaskId = currentHappyOrg.taskContext?.taskId ?? null;
+    if (currentTaskId !== messageHappyOrg.taskContext.taskId) {
+      if (currentHappyOrg.taskContext && currentHappyOrg.runtime?.status === "active") {
+        return {
+          nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+          queuedTurn: null,
+          blocked: true,
+          statusMessage: buildMemberBusyStatusMessage(
+            currentHappyOrg.taskContext.memberAgentId,
+            currentHappyOrg.taskContext.taskId,
+            messageHappyOrg.taskContext.taskId
+          )
+        };
+      }
+      nextHappyOrg = resetHappyOrgRuntimeForTask(messageHappyOrg.taskContext);
+    } else {
+      nextHappyOrg.taskContext = { ...messageHappyOrg.taskContext };
+    }
+  }
+  const taskContext = nextHappyOrg.taskContext ?? null;
+  if (!taskContext) {
+    return {
+      nextMetadata: metadata,
+      queuedTurn: null,
+      blocked: false
+    };
+  }
+  const control = messageHappyOrg?.control;
+  if (control?.action === "terminate") {
+    nextHappyOrg.runtime = {
+      status: "terminated",
+      reason: normalizeOptionalText(control.reason) ?? "terminated_by_supervisor",
+      terminatedAt: now
+    };
+    nextHappyOrg.activeOwner = null;
+    return {
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+    };
+  }
+  const hasReopenInputs = Boolean(
+    normalizeOptionalText(control?.newContext) || normalizeOptionalText(control?.newDecision) || normalizeOptionalText(control?.newResource)
+  );
+  if (nextHappyOrg.runtime?.status === "terminated") {
+    if (control?.action !== "reopen") {
+      return {
+        nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+        queuedTurn: null,
+        blocked: true,
+        statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+      };
+    }
+    if (!hasReopenInputs) {
+      return {
+        nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+        queuedTurn: null,
+        blocked: true,
+        statusMessage: `Task ${taskContext.taskId} can only reopen with new context, a new decision, or a new resource.`
+      };
+    }
+  }
+  const reopenContext = control?.action === "reopen" && hasReopenInputs ? {
+    newContext: normalizeOptionalText(control.newContext),
+    newDecision: normalizeOptionalText(control.newDecision),
+    newResource: normalizeOptionalText(control.newResource)
+  } : void 0;
+  if (reopenContext) {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null,
+      reopenedAt: now
+    };
+  } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "active") {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null
+    };
+  }
+  if (!nextHappyOrg.activeOwner) {
+    nextHappyOrg.activeOwner = {
+      ownerAgentId: taskContext.memberAgentId,
+      ownerRunId: createRunId(taskContext, now),
+      claimedAt: now
+    };
+  } else if (nextHappyOrg.activeOwner.ownerAgentId !== taskContext.memberAgentId) {
+    return {
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildOwnerConflictStatusMessage(
+        taskContext.taskId,
+        nextHappyOrg.activeOwner.ownerAgentId
+      )
+    };
+  }
+  return {
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    queuedTurn: {
+      context: taskContext,
+      ...reopenContext ? { reopenContext } : {}
+    },
+    blocked: false
+  };
+}
+function finalizeHappyOrgTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  const queuedTurn = opts.queuedTurn ?? null;
+  const { cleanedText, draft } = extractTaggedTurnReport(opts.responseText);
+  if (!metadata || !queuedTurn) {
+    return {
+      cleanedText,
+      report: null,
+      nextMetadata: metadata
+    };
+  }
+  const now = opts.now?.() ?? Date.now();
+  const normalizedDraft = normalizeTurnReportDraft(draft);
+  const reportTurnStatus = resolveReportedTurnStatus(opts.turnStatus, normalizedDraft);
+  const report = {
+    ...queuedTurn.context,
+    turnStatus: reportTurnStatus,
+    interventionType: reportTurnStatus === "task_complete" ? "review_needed" : normalizedDraft.interventionType ?? "none",
+    summary: normalizedDraft.summary ?? buildFallbackSummary(cleanedText, reportTurnStatus),
+    blockerCode: normalizedDraft.blockerCode ?? null,
+    decisionNeeded: normalizedDraft.decisionNeeded ?? null,
+    targetArtifact: normalizedDraft.targetArtifact ?? null,
+    repeatFingerprint: buildRepeatFingerprint(
+      queuedTurn.context,
+      normalizedDraft.blockerCode ?? null,
+      normalizedDraft.targetArtifact ?? null
+    )
+  };
+  const nextHappyOrg = normalizeHappyOrgMetadata(metadata);
+  nextHappyOrg.taskContext = { ...queuedTurn.context };
+  nextHappyOrg.lastTurnReport = report;
+  nextHappyOrg.activeOwner = null;
+  nextHappyOrg.repeat = nextHappyOrg.repeat ?? {
+    threshold: api.HAPPY_ORG_REPEAT_THRESHOLD,
+    fingerprints: {}
+  };
+  let terminateMessage;
+  if (report.repeatFingerprint) {
+    const currentEntry = nextHappyOrg.repeat.fingerprints[report.repeatFingerprint] ?? {
+      count: 0};
+    const nextCount = currentEntry.count + 1;
+    nextHappyOrg.repeat.fingerprints[report.repeatFingerprint] = {
+      count: nextCount,
+      lastSeenAt: now
+    };
+    if (nextCount >= nextHappyOrg.repeat.threshold) {
+      nextHappyOrg.runtime = {
+        status: "terminated",
+        reason: `repeat_fingerprint:${report.repeatFingerprint}`,
+        terminatedAt: now
+      };
+      terminateMessage = `Task ${queuedTurn.context.taskId} hit repeat threshold for ${report.repeatFingerprint} and is now terminated until reopen.`;
+    } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+      nextHappyOrg.runtime = buildRuntimeStateAfterTurn(report);
+    }
+  } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+    nextHappyOrg.runtime = buildRuntimeStateAfterTurn(report);
+  }
+  return {
+    cleanedText,
+    report,
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    terminateMessage
+  };
+}
+
 const DEFAULT_MAX_MESSAGES = 200;
 const DEFAULT_MAX_CHARACTERS = 1e5;
 const DEFAULT_MAX_MESSAGE_CHARACTERS = 8e3;
@@ -1188,14 +1600,17 @@ exports.INTERACTION_TIMED_OUT_ERROR = INTERACTION_TIMED_OUT_ERROR;
 exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
 exports.MissingMachineIdError = MissingMachineIdError;
+exports.buildHappyOrgTurnPrompt = buildHappyOrgTurnPrompt;
 exports.closeProviderSession = closeProviderSession;
 exports.createSessionMetadata = createSessionMetadata;
 exports.ensureManagedProviderMachine = ensureManagedProviderMachine;
+exports.finalizeHappyOrgTurn = finalizeHappyOrgTurn;
 exports.forwardAgentMessageToProviderSession = forwardAgentMessageToProviderSession;
 exports.getPendingInteractionTimeoutMs = getPendingInteractionTimeoutMs;
 exports.hashObject = hashObject;
 exports.inferToolResultError = inferToolResultError;
 exports.launchRuntimeHandleWithFactoryResult = launchRuntimeHandleWithFactoryResult;
 exports.registerKillSessionHandler = registerKillSessionHandler;
+exports.resolveHappyOrgQueuedTurn = resolveHappyOrgQueuedTurn;
 exports.syncControlledByUserState = syncControlledByUserState;
 exports.waitForResponseCompleteWithAbort = waitForResponseCompleteWithAbort;

package/dist/{runClaude-B74dHAnQ.mjs → runClaude-CPV5Uap2.mjs}

@@ -1,8 +1,8 @@
 import { randomUUID } from 'node:crypto';
-import { l as logger, g as backoff, h as delay, j as AsyncLock, c as configuration, s as startOfflineReconnection, f as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-DBy5lPZw.mjs';
+import { l as logger, g as backoff, h as delay, j as AsyncLock, c as configuration, s as startOfflineReconnection, b as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-Cxifhw5r.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
-import { j as getProjectPath, F as Future, k as claudeLocal, E as ExitCodeError, l as trimIdent, m as createClaudeBackend, f as formatDisplayMessage, t as truncateDisplayMessage, n as claudeCheckSession, e as projectPath, o as mapToClaudeMode, P as PushableAsyncIterable, q as query, A as AbortError, b as stopCaffeinate, p as publishSessionRegistration, u as getEnvironmentInfo, w as startCaffeinate } from './index-66vjECEd.mjs';
+import { j as getProjectPath, F as Future, k as claudeLocal, E as ExitCodeError, l as trimIdent, m as createClaudeBackend, f as formatDisplayMessage, t as truncateDisplayMessage, n as claudeCheckSession, e as projectPath, o as mapToClaudeMode, P as PushableAsyncIterable, q as query, A as AbortError, b as stopCaffeinate, p as publishSessionRegistration, u as getEnvironmentInfo, w as startCaffeinate } from './index-Des7I5WX.mjs';
 import 'ps-list';
 import 'fs';
 import 'path';
@@ -13,7 +13,7 @@ import { dirname, basename, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import 'node:readline';
-import './persistence-BOWh1NER.mjs';
+import './persistence-6d4U4Sh8.mjs';
 import { readFile } from 'node:fs/promises';
 import { stat, watch, access } from 'fs/promises';
 import 'crypto';
@@ -24,9 +24,9 @@ import 'tweetnacl';
 import 'open';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { c as createKeepAliveController, P as ProviderSelectionHandler, b as buildHappyOrgTurnPrompt, f as finalizeHappyOrgTurn, r as runModeLoop, a as resolveHappyOrgQueuedTurn } from './ProviderSelectionHandler-CMaQThYO.mjs';
+import { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-Q8pl7e-d.mjs';
 import { R as RawJSONLinesSchema } from './types-CiliQpqS.mjs';
-import { B as BasePermissionHandler, d as MessageBuffer, C as ConversationHistory$1, w as waitForResponseCompleteWithAbort, l as launchRuntimeHandleWithFactoryResult, j as forwardAgentMessageToProviderSession, s as syncControlledByUserState, e as ensureManagedProviderMachine, M as MissingMachineIdError, c as createSessionMetadata, b as MessageQueue2, h as hashObject, r as registerKillSessionHandler, f as closeProviderSession } from './registerKillSessionHandler-D4_wpN18.mjs';
+import { B as BasePermissionHandler, f as MessageBuffer, C as ConversationHistory$1, i as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, j as finalizeHappyOrgTurn, l as launchRuntimeHandleWithFactoryResult, n as forwardAgentMessageToProviderSession, s as syncControlledByUserState, r as resolveHappyOrgQueuedTurn, e as ensureManagedProviderMachine, M as MissingMachineIdError, c as createSessionMetadata, b as MessageQueue2, h as hashObject, d as registerKillSessionHandler, k as closeProviderSession } from './registerKillSessionHandler-BFBkz_XT.mjs';
 import 'socket.io-client';
 import 'expo-server-sdk';
 import { isDeepStrictEqual } from 'node:util';
@@ -993,6 +993,7 @@ async function claudeAcpRemoteLauncher(session) {
   let inkInstance = null;
   let shouldExit = false;
   let abortController = new AbortController();
+  let turnInFlight = false;
   let runtimeHandle = null;
   let unsubscribeRuntimeMessages = null;
   let currentModeHash = null;
@@ -1003,6 +1004,7 @@ async function claudeAcpRemoteLauncher(session) {
   let currentAssistantMessageId = null;
   let currentThinkingMessageId = null;
   let shouldInjectHistoryOnNextSession = false;
+  let unexpectedRuntimeStopRecovery = null;
   let readyAlreadySent = false;
   const permissionHandler = new ClaudeAcpPermissionHandler(session.client);
   const selectionHandler = new ProviderSelectionHandler(session.client, "Claude");
@@ -1111,6 +1113,28 @@ async function claudeAcpRemoteLauncher(session) {
     }
     emitStatusMessage(reason);
   };
+  const recoverUnexpectedRuntimeStop = async (detail) => {
+    if (shouldExit || session.queue.isClosed() || unexpectedRuntimeStopRecovery) {
+      return;
+    }
+    const errorMessage = normalizeClaudeBackendError(detail);
+    unexpectedRuntimeStopRecovery = (async () => {
+      queueHistoryInjectionForRestart(
+        `Claude runtime stopped unexpectedly (${errorMessage}). Starting a new Claude ACP session on the next message...`
+      );
+      await disposeRuntimeHandle();
+      session.clearSessionId();
+      currentModeHash = null;
+      permissionHandler.reset();
+      selectionHandler.reset();
+      resetTurnState();
+    })();
+    try {
+      await unexpectedRuntimeStopRecovery;
+    } finally {
+      unexpectedRuntimeStopRecovery = null;
+    }
+  };
   const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
     const forwardAgentMessage = (agentMessage) => {
       forwardAgentMessageToProviderSession(agentMessage, {
@@ -1159,6 +1183,9 @@ async function claudeAcpRemoteLauncher(session) {
           }
           if (msg.status === "idle" || msg.status === "stopped") {
             session.onThinkingChange(false);
+            if (msg.status === "stopped" && !turnInFlight) {
+              void recoverUnexpectedRuntimeStop(msg.detail);
+            }
             return;
           }
           if (msg.status === "error") {
@@ -1376,6 +1403,7 @@ ${systemPrompt}` : systemPrompt,
       let shouldClearHistoryAfterTurn = false;
       let turnStatus = "task_complete";
       try {
+        turnInFlight = true;
         const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
         let promptToSend = message.message;
         if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
@@ -1418,6 +1446,7 @@ ${systemPrompt}` : systemPrompt,
           currentModeHash = null;
         }
       } finally {
+        turnInFlight = false;
         const finalizedTurn = finalizeHappyOrgTurn({
           metadata: session.client.getMetadataSnapshot?.() ?? null,
           queuedTurn: message.mode.happyOrg,

package/dist/{runClaude-oIFzkfuU.cjs → runClaude-DVnqKa1q.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
 var node_crypto = require('node:crypto');
-var api = require('./api-DId_j3C2.cjs');
+var api = require('./api-DZimmN4C.cjs');
 require('cross-spawn');
 require('@agentclientprotocol/sdk');
-var index = require('./index-CuuYSKiv.cjs');
+var index = require('./index-Cuvs0lFS.cjs');
 require('ps-list');
 require('fs');
 require('path');
@@ -15,7 +15,7 @@ var path = require('node:path');
 var os = require('node:os');
 var node_child_process = require('node:child_process');
 require('node:readline');
-require('./persistence-Dzr6sFwD.cjs');
+require('./persistence-C8-MtdQK.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 require('crypto');
@@ -26,9 +26,9 @@ require('tweetnacl');
 require('open');
 var React = require('react');
 var ink = require('ink');
-var ProviderSelectionHandler = require('./ProviderSelectionHandler-BuXk-8ji.cjs');
+var ProviderSelectionHandler = require('./ProviderSelectionHandler-wwbfeK_s.cjs');
 var types = require('./types-DVk3crez.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-Dg_iRBPm.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BapPCRmp.cjs');
 require('socket.io-client');
 require('expo-server-sdk');
 var node_util = require('node:util');
@@ -995,6 +995,7 @@ async function claudeAcpRemoteLauncher(session) {
   let inkInstance = null;
   let shouldExit = false;
   let abortController = new AbortController();
+  let turnInFlight = false;
   let runtimeHandle = null;
   let unsubscribeRuntimeMessages = null;
   let currentModeHash = null;
@@ -1005,6 +1006,7 @@ async function claudeAcpRemoteLauncher(session) {
   let currentAssistantMessageId = null;
   let currentThinkingMessageId = null;
   let shouldInjectHistoryOnNextSession = false;
+  let unexpectedRuntimeStopRecovery = null;
   let readyAlreadySent = false;
   const permissionHandler = new ClaudeAcpPermissionHandler(session.client);
   const selectionHandler = new ProviderSelectionHandler.ProviderSelectionHandler(session.client, "Claude");
@@ -1113,6 +1115,28 @@ async function claudeAcpRemoteLauncher(session) {
     }
     emitStatusMessage(reason);
   };
+  const recoverUnexpectedRuntimeStop = async (detail) => {
+    if (shouldExit || session.queue.isClosed() || unexpectedRuntimeStopRecovery) {
+      return;
+    }
+    const errorMessage = normalizeClaudeBackendError(detail);
+    unexpectedRuntimeStopRecovery = (async () => {
+      queueHistoryInjectionForRestart(
+        `Claude runtime stopped unexpectedly (${errorMessage}). Starting a new Claude ACP session on the next message...`
+      );
+      await disposeRuntimeHandle();
+      session.clearSessionId();
+      currentModeHash = null;
+      permissionHandler.reset();
+      selectionHandler.reset();
+      resetTurnState();
+    })();
+    try {
+      await unexpectedRuntimeStopRecovery;
+    } finally {
+      unexpectedRuntimeStopRecovery = null;
+    }
+  };
   const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
     const forwardAgentMessage = (agentMessage) => {
       registerKillSessionHandler.forwardAgentMessageToProviderSession(agentMessage, {
@@ -1161,6 +1185,9 @@ async function claudeAcpRemoteLauncher(session) {
           }
           if (msg.status === "idle" || msg.status === "stopped") {
             session.onThinkingChange(false);
+            if (msg.status === "stopped" && !turnInFlight) {
+              void recoverUnexpectedRuntimeStop(msg.detail);
+            }
             return;
           }
           if (msg.status === "error") {
@@ -1378,6 +1405,7 @@ ${systemPrompt}` : systemPrompt,
       let shouldClearHistoryAfterTurn = false;
       let turnStatus = "task_complete";
       try {
+        turnInFlight = true;
         const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
         let promptToSend = message.message;
         if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
@@ -1388,7 +1416,7 @@ ${systemPrompt}` : systemPrompt,
           api.logger.debug(`[ClaudeACP] Injected conversation history context (${historyContext.length} chars)`);
         }
         if (message.mode.happyOrg) {
-          promptToSend = ProviderSelectionHandler.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
+          promptToSend = registerKillSessionHandler.buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
         }
         if (specialCommand.type === "compact") {
           emitStatusMessage("Compaction started");
@@ -1420,7 +1448,8 @@ ${systemPrompt}` : systemPrompt,
           currentModeHash = null;
         }
       } finally {
-        const finalizedTurn = ProviderSelectionHandler.finalizeHappyOrgTurn({
+        turnInFlight = false;
+        const finalizedTurn = registerKillSessionHandler.finalizeHappyOrgTurn({
           metadata: session.client.getMetadataSnapshot?.() ?? null,
           queuedTurn: message.mode.happyOrg,
           responseText: accumulatedResponse,
@@ -3161,7 +3190,7 @@ function resolveClaudeQueuedMessage(message, currentState) {
 function bindClaudeUserMessageQueue(opts) {
   let currentState = { ...opts.initialState };
   opts.session.onUserMessage((message) => {
-    const happyOrgResult = opts.happyOrg ? ProviderSelectionHandler.resolveHappyOrgQueuedTurn({
+    const happyOrgResult = opts.happyOrg ? registerKillSessionHandler.resolveHappyOrgQueuedTurn({
       metadata: opts.happyOrg.getMetadata(),
       message
     }) : {