happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{registerKillSessionHandler-CfCya6si.cjs → sessionControl-flKnQrx0.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var index = require('./index-xa1kwZoj.cjs');
-var persistence = require('./api-D7nAeZi7.cjs');
+var index = require('./index-B_JYgMUS.cjs');
+var persistence = require('./types-CttABk32.cjs');
 var node_crypto = require('node:crypto');
-var path = require('node:path');
+var RuntimeShell = require('./RuntimeShell-D_Te12wq.cjs');
 require('axios');
 require('node:events');
 require('node:fs/promises');
+var path = require('node:path');
 require('socket.io-client');
 require('tweetnacl');
 require('fs/promises');
@@ -15,7 +16,6 @@ require('path');
 require('node:child_process');
 require('chalk');
 require('expo-server-sdk');
-require('./types-DVk3crez.cjs');
 
 class MissingMachineIdError extends Error {
   constructor(message) {
@@ -36,27 +36,6 @@ async function ensureManagedProviderMachine(opts) {
   return machineId;
 }
 
-async function launchRuntimeHandleWithFactoryResult(opts) {
-  const shell = opts.shell ?? new index.RuntimeShell();
-  let factoryResult;
-  const session = await shell.launch({
-    provider: opts.provider,
-    cwd: opts.cwd,
-    env: opts.env,
-    createBackend: (factoryOpts) => {
-      factoryResult = opts.createBackendResult(factoryOpts);
-      return factoryResult.backend;
-    }
-  });
-  if (factoryResult === void 0) {
-    throw new Error(`Runtime provider "${opts.provider}" did not create a backend result`);
-  }
-  return {
-    session,
-    factoryResult
-  };
-}
-
 function inferToolResultError(result) {
   if (!result || typeof result !== "object") {
     return false;
@@ -102,11 +81,11 @@ function renderOutputPreview(value, label, opts) {
     DEFAULT_OUTPUT_PREVIEW_HEAD_BYTES,
     DEFAULT_OUTPUT_PREVIEW_TAIL_BYTES
   );
-  buffer.append(index.formatDisplayMessage(value));
+  buffer.append(RuntimeShell.formatDisplayMessage(value));
   return buffer.render(label);
 }
 function sanitizeTerminalOutputForDisplay(value) {
-  return index.formatDisplayMessage(value).replace(ANSI_OSC_PATTERN, "").replace(ANSI_CSI_PATTERN, "").replace(ANSI_SINGLE_ESCAPE_PATTERN, "").replace(/\r/g, "").replace(NON_DISPLAY_CONTROL_PATTERN, "");
+  return RuntimeShell.formatDisplayMessage(value).replace(ANSI_OSC_PATTERN, "").replace(ANSI_CSI_PATTERN, "").replace(ANSI_SINGLE_ESCAPE_PATTERN, "").replace(/\r/g, "").replace(NON_DISPLAY_CONTROL_PATTERN, "");
 }
 function renderTerminalOutputPreview(value, opts) {
   const sanitized = sanitizeTerminalOutputForDisplay(value);
@@ -121,11 +100,11 @@ function prepareTerminalOutputForForwarding(value) {
 }
 
 const DISPLAY_FRIENDLY_TOOL_FIELDS = ["stdout", "stderr", "output", "text", "message", "detail", "reason", "data"];
-function isRecord$2(value) {
+function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function stripInternalToolMeta(value) {
-  if (!isRecord$2(value)) {
+  if (!isRecord(value)) {
     return value;
   }
   const {
@@ -136,7 +115,7 @@ function stripInternalToolMeta(value) {
   return rest;
 }
 function extractNestedTextContent(value) {
-  if (index.isTerminalReferenceOnlyPayload(value)) {
+  if (RuntimeShell.isTerminalReferenceOnlyPayload(value)) {
     return null;
   }
   if (typeof value === "string") {
@@ -146,7 +125,7 @@ function extractNestedTextContent(value) {
     const parts = value.map((item) => extractNestedTextContent(item)).filter((item) => typeof item === "string" && item.length > 0);
     return parts.length > 0 ? parts.join("\n") : null;
   }
-  if (!isRecord$2(value)) {
+  if (!isRecord(value)) {
     return null;
   }
   if (typeof value.text === "string" && value.text.trim().length > 0) {
@@ -166,7 +145,7 @@ function humanizeToolLabel(rawToolName) {
   return spaced.charAt(0).toUpperCase() + spaced.slice(1).toLowerCase();
 }
 function isToolLifecycleResult(value) {
-  if (!isRecord$2(value)) {
+  if (!isRecord(value)) {
     return false;
   }
   return typeof value.state === "string" && ("messages" in value || "description" in value || "createdAt" in value || "startedAt" in value || "completedAt" in value);
@@ -212,10 +191,10 @@ function normalizeCodexToolInput(value) {
 function normalizeCodexToolOutput(rawToolName, value) {
   const sanitized = stripInternalToolMeta(value);
   const normalizedLifecyclePayload = normalizeCodexLifecyclePayload(rawToolName, sanitized);
-  if (index.isTerminalReferenceOnlyPayload(normalizedLifecyclePayload)) {
+  if (RuntimeShell.isTerminalReferenceOnlyPayload(normalizedLifecyclePayload)) {
     return void 0;
   }
-  if (!isRecord$2(normalizedLifecyclePayload)) {
+  if (!isRecord(normalizedLifecyclePayload)) {
     return normalizedLifecyclePayload;
   }
   const hasDisplayFriendlyField = DISPLAY_FRIENDLY_TOOL_FIELDS.some((field) => field in normalizedLifecyclePayload);
@@ -242,7 +221,7 @@ function truncateProviderOutputValue(value, label, seen = /* @__PURE__ */ new We
   if (Array.isArray(value)) {
     return renderOutputPreview(value, label);
   }
-  if (!isRecord$2(value)) {
+  if (!isRecord(value)) {
     return value;
   }
   if (seen.has(value)) {
@@ -266,6 +245,8 @@ function getDefaultExecToolName(provider) {
       return "ClaudeBash";
     case "codex":
       return "CodexBash";
+    case "cursor":
+      return "CursorBash";
     case "gemini":
       return "GeminiBash";
   }
@@ -276,6 +257,8 @@ function getDefaultPatchToolName(provider) {
       return "ClaudePatch";
     case "codex":
       return "CodexPatch";
+    case "cursor":
+      return "CursorPatch";
     case "gemini":
       return "GeminiPatch";
   }
@@ -301,7 +284,7 @@ function prepareToolOutput(provider, rawToolName, value) {
 }
 function hasDisplayPayload(value) {
   const sanitized = stripInternalToolMeta(value);
-  if (index.isTerminalReferenceOnlyPayload(sanitized)) {
+  if (RuntimeShell.isTerminalReferenceOnlyPayload(sanitized)) {
     return false;
   }
   if (sanitized === void 0 || sanitized === null) {
@@ -313,7 +296,7 @@ function hasDisplayPayload(value) {
   if (Array.isArray(sanitized)) {
     return sanitized.length > 0;
   }
-  if (isRecord$2(sanitized)) {
+  if (isRecord(sanitized)) {
     return Object.keys(sanitized).length > 0;
   }
   return true;
@@ -472,2579 +455,1826 @@ async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs) {
   });
 }
 
-function supportsAgentStateUpdateEvents(sessionClient) {
-  return typeof sessionClient.once === "function" && typeof sessionClient.off === "function";
-}
-async function syncControlledByUserState(sessionClient, controlledByUser) {
-  if (!supportsAgentStateUpdateEvents(sessionClient)) {
-    sessionClient.updateAgentState((currentState) => ({
-      ...currentState,
-      controlledByUser
-    }));
-    return;
-  }
-  await new Promise((resolve) => {
-    let settled = false;
-    const handleUpdated = () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      sessionClient.off("agent-state-updated", handleUpdated);
-      resolve();
-    };
-    const timeout = setTimeout(() => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      sessionClient.off("agent-state-updated", handleUpdated);
-      resolve();
-    }, 1500);
-    sessionClient.once("agent-state-updated", handleUpdated);
-    sessionClient.updateAgentState((currentState) => ({
-      ...currentState,
-      controlledByUser
-    }));
-  });
-}
-
-const SESSION_LABEL_MAX_LENGTH = 60;
-const TITLE_MAX_LENGTH = 80;
-const BODY_MAX_LENGTH = 140;
-function isRecord$1(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeText(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const normalized = value.replace(/\s+/g, " ").trim();
-  return normalized.length > 0 ? normalized : null;
-}
-function truncateText(value, maxLength) {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return `${value.slice(0, maxLength - 1).trimEnd()}\u2026`;
-}
-function toProviderKey(providerLabel) {
-  const normalized = normalizeText(providerLabel)?.toLowerCase();
-  if (!normalized) {
-    return "unknown";
-  }
-  if (normalized === "claude" || normalized === "claude code" || normalized === "cloud code") {
-    return "claude";
-  }
-  if (normalized === "codex") {
-    return "codex";
-  }
-  if (normalized === "gemini") {
-    return "gemini";
+const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
+const INTERACTION_TIMED_OUT_ERROR = "Interaction timed out waiting for user response";
+const DEFAULT_INTERACTION_TIMEOUT_MS = 2 * 60 * 1e3;
+function getPendingInteractionTimeoutMs() {
+  const raw = Number(process.env.HAPPY_INTERACTION_TIMEOUT_MS);
+  if (Number.isFinite(raw) && raw > 0) {
+    return raw;
   }
-  return normalized.replace(/\s+/g, "-");
+  return DEFAULT_INTERACTION_TIMEOUT_MS;
 }
-function deriveNotificationProviderLabel(providerLabel) {
-  const normalized = normalizeText(providerLabel)?.toLowerCase();
-  if (!normalized) {
-    return "Agent";
+class BasePermissionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  isResetting = false;
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
   }
-  if (normalized === "claude" || normalized === "claude code" || normalized === "cloud code") {
-    return "Claude";
+  /**
+   * Update the session reference (used after offline reconnection swaps sessions).
+   * This is critical for avoiding stale session references after onSessionSwap.
+   */
+  updateSession(newSession) {
+    persistence.logger.debug(`${this.getLogPrefix()} Session reference updated`);
+    this.session = newSession;
+    this.setupRpcHandler();
   }
-  if (normalized === "codex") {
-    return "Codex";
+  /**
+   * Setup RPC handler for permission responses.
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+          persistence.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
+          return;
+        }
+        this.pendingRequests.delete(response.id);
+        this.clearPendingRequestTimeout(pending);
+        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const request = currentState.requests?.[response.id];
+          if (!request) return currentState;
+          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+          let res = {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [response.id]: {
+                ...request,
+                completedAt: Date.now(),
+                status: response.approved ? "approved" : "denied",
+                decision: result.decision
+              }
+            }
+          };
+          return res;
+        });
+        persistence.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
+      }
+    );
   }
-  if (normalized === "gemini") {
-    return "Gemini";
+  /**
+   * Add a pending request to the agent state.
+   */
+  addPendingRequestToState(toolCallId, toolName, input) {
+    this.session.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [toolCallId]: {
+          tool: toolName,
+          arguments: input,
+          createdAt: Date.now()
+        }
+      }
+    }));
   }
-  return normalizeText(providerLabel) ?? "Agent";
-}
-function buildNotificationTitle(sessionLabel, providerLabel, actionLabel) {
-  const providerDisplayLabel = deriveNotificationProviderLabel(providerLabel);
-  const suffix = ` \xB7 ${providerDisplayLabel} \xB7 ${actionLabel}`;
-  const maxSessionLength = Math.max(12, TITLE_MAX_LENGTH - suffix.length);
-  return `${truncateText(sessionLabel, maxSessionLength)}${suffix}`;
-}
-function derivePathLabel(path) {
-  const normalized = normalizeText(path);
-  if (!normalized) {
-    return null;
+  registerPendingRequest(toolCallId, toolName, input, logSuffix = "") {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        toolName,
+        input
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handlePendingRequestTimeout(toolCallId, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(toolCallId, pending);
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      persistence.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})${logSuffix}`);
+    });
   }
-  const segments = normalized.split(/[\\/]+/).filter(Boolean);
-  return segments[segments.length - 1] ?? normalized;
-}
-function deriveHomeLabel(homeSlug) {
-  const normalized = normalizeText(homeSlug);
-  if (!normalized) {
-    return null;
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
   }
-  return normalized.replace(/[_-]+/g, " ");
-}
-function deriveNotificationSessionLabel(metadata, providerLabel) {
-  const label = normalizeText(metadata?.name) ?? normalizeText(metadata?.summary?.text) ?? deriveHomeLabel(metadata?.happyOrg?.specialistHome?.homeSlug) ?? derivePathLabel(metadata?.path) ?? normalizeText(providerLabel) ?? "Session";
-  return truncateText(label, SESSION_LABEL_MAX_LENGTH);
-}
-function deriveNotificationSummary(candidates, fallback, sessionLabel) {
-  for (const candidate of candidates) {
-    const normalized = normalizeText(candidate);
-    if (!normalized) {
-      continue;
+  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
     }
-    const truncated = truncateText(normalized, BODY_MAX_LENGTH);
-    if (truncated.toLowerCase() !== sessionLabel.toLowerCase()) {
-      return truncated;
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.resolve({ decision: "abort" });
     }
-  }
-  return truncateText(fallback, BODY_MAX_LENGTH);
-}
-function cleanExtraData(extraData) {
-  return Object.fromEntries(
-    Object.entries(extraData).filter(([, value]) => {
-      if (value === null || value === void 0) {
-        return false;
-      }
-      if (typeof value === "string") {
-        return value.trim().length > 0;
-      }
-      return true;
-    })
-  );
-}
-function buildRouteData(opts) {
-  const taskContext = opts.metadata?.happyOrg?.taskContext ?? null;
-  const routeTaskId = opts.report?.taskId ?? taskContext?.taskId ?? null;
-  const routePositionId = opts.report?.positionId ?? taskContext?.positionId ?? null;
-  const routeSessionId = normalizeText(opts.sessionId);
-  const data = {
-    notificationKind: opts.notificationKind,
-    provider: toProviderKey(opts.providerLabel)
-  };
-  if (opts.routePreference === "session" && routeSessionId) {
-    data.sessionId = routeSessionId;
-  } else if (routeTaskId) {
-    data.taskId = routeTaskId;
-  } else if (routeSessionId) {
-    data.sessionId = routeSessionId;
-  } else if (routePositionId) {
-    data.positionId = routePositionId;
-  }
-  Object.assign(data, cleanExtraData({
-    contextTaskId: data.taskId ? null : routeTaskId,
-    contextPositionId: data.positionId ? null : routePositionId,
-    memberAgentId: opts.report?.memberAgentId ?? taskContext?.memberAgentId ?? null,
-    supervisorAgentId: opts.report?.supervisorAgentId ?? taskContext?.supervisorAgentId ?? null
-  }));
-  if (opts.extraData) {
-    Object.assign(data, cleanExtraData(opts.extraData));
-  }
-  return data;
-}
-function humanizeToolName(toolName) {
-  const normalized = normalizeText(toolName);
-  if (!normalized) {
-    return "continue";
-  }
-  const replacements = {
-    bash: "run a command",
-    execute: "run a command",
-    read: "read a file",
-    write: "write a file",
-    edit: "edit a file",
-    multiedit: "edit files",
-    patch: "apply a patch",
-    fetch: "fetch a page",
-    search: "search the web"
-  };
-  const replacement = replacements[normalized.toLowerCase()];
-  if (replacement) {
-    return replacement;
-  }
-  return normalized.replace(/[_-]+/g, " ");
-}
-function extractPermissionRequestPushContext(message) {
-  const payload = isRecord$1(message.payload) ? message.payload : null;
-  const toolName = normalizeText(payload?.toolName) ?? normalizeText(message.reason);
-  const payloadDescription = normalizeText(payload?.description);
-  const reasonDescription = normalizeText(message.reason);
-  let description = payloadDescription;
-  if (!description && reasonDescription && reasonDescription.toLowerCase() !== (toolName ?? "").toLowerCase()) {
-    description = reasonDescription;
-  }
-  if (description && toolName && description.toLowerCase() === toolName.toLowerCase()) {
-    description = null;
-  }
-  return {
-    requestId: message.id,
-    toolName,
-    description
-  };
-}
-function buildReadyPushNotification(opts) {
-  const sessionLabel = deriveNotificationSessionLabel(opts.metadata, opts.providerLabel);
-  const providerDisplayLabel = deriveNotificationProviderLabel(opts.providerLabel);
-  return {
-    title: buildNotificationTitle(sessionLabel, opts.providerLabel, "Ready"),
-    body: truncateText(`${providerDisplayLabel} is waiting for your next message`, BODY_MAX_LENGTH),
-    data: buildRouteData({
-      ...opts,
-      notificationKind: "ready",
-      routePreference: "session"
-    })
-  };
-}
-function buildPermissionPushNotification(opts) {
-  const sessionLabel = deriveNotificationSessionLabel(opts.metadata, opts.providerLabel);
-  const providerDisplayLabel = deriveNotificationProviderLabel(opts.providerLabel);
-  const fallback = `${providerDisplayLabel} needs your approval to ${humanizeToolName(opts.toolName)}`;
-  const body = deriveNotificationSummary([opts.description], fallback, sessionLabel);
-  return {
-    title: buildNotificationTitle(sessionLabel, opts.providerLabel, "Permission needed"),
-    body,
-    data: buildRouteData({
-      ...opts,
-      notificationKind: "permission_request",
-      routePreference: "session",
-      extraData: {
-        requestId: opts.requestId,
-        tool: opts.toolName ?? null,
-        ...opts.extraData
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind === "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "denied",
+          reason,
+          decision: "abort",
+          requestKind: request.requestKind || "permission"
+        };
+        delete requests[id];
       }
-    })
-  };
-}
-function buildTurnResultPushNotification(opts) {
-  const sessionLabel = deriveNotificationSessionLabel(opts.metadata, opts.providerLabel);
-  const providerDisplayLabel = deriveNotificationProviderLabel(opts.providerLabel);
-  const report = opts.report ?? null;
-  const explicitSummary = normalizeText(report?.summary) ?? normalizeText(opts.responseText);
-  if (!explicitSummary) {
-    return null;
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    persistence.logger.debug(`${this.getLogPrefix()} Superseded ${pendingSnapshot.length} pending permission request(s)`);
+    return pendingSnapshot.length;
   }
-  const fallback = `${providerDisplayLabel} has a new result ready`;
-  const body = deriveNotificationSummary(
-    [
-      explicitSummary
-    ],
-    fallback,
-    sessionLabel
-  );
-  const action = report?.turnStatus === "task_complete" ? "Task complete" : "New result";
-  return {
-    title: buildNotificationTitle(sessionLabel, opts.providerLabel, action),
-    body,
-    data: buildRouteData({
-      ...opts,
-      report,
-      notificationKind: "turn_result",
-      routePreference: "session",
-      extraData: {
-        turnStatus: report?.turnStatus ?? "turn_update"
+  /**
+   * Reset state for new sessions.
+   * This method is idempotent - safe to call multiple times.
+   */
+  reset() {
+    if (this.isResetting) {
+      persistence.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
+      return;
+    }
+    this.isResetting = true;
+    try {
+      const pendingSnapshot = Array.from(this.pendingRequests.entries());
+      this.pendingRequests.clear();
+      for (const [id, pending] of pendingSnapshot) {
+        try {
+          this.clearPendingRequestTimeout(pending);
+          pending.reject(new Error("Session reset"));
+        } catch (err) {
+          persistence.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
+        }
       }
-    })
-  };
-}
-
-const STRUCTURED_FIELD_PATTERN = /^\s*([a-z_]+)\s*=\s*(.*?)\s*$/;
-const KEY_VALUE_LINE_PATTERN = /^([A-Za-z0-9_]+)=(.*)$/;
-const HAPPY_ORG_READ_ACK = "yes";
-const DISPATCH_ID_ALIASES = ["dispatch_id", "dispatchId"];
-const ACK_VERSION_ALIASES = ["ack_version", "ackVersion"];
-const ORGANIZATION_ID_ALIASES = ["organization_id", "organizationId"];
-const TASK_ID_ALIASES = ["task_id", "taskId"];
-const MEMBER_AGENT_ID_ALIASES = ["member_agent_id", "memberAgentId", "agent_id", "agentId"];
-const SESSION_ID_ALIASES = ["session_id", "sessionId"];
-const POSITION_ID_ALIASES = ["position_id", "positionId"];
-const RESPONSIBILITY_ID_ALIASES = ["responsibility_id", "responsibilityId"];
-const ROUTE_TYPE_ALIASES = ["route_type", "routeType"];
-const ACK_TYPE_ALIASES = ["ack_type", "ackType"];
-const REPLY_MODE_ALIASES = ["reply_mode", "replyMode"];
-const PLAN_INTENT_ALIASES = ["plan_intent", "planIntent"];
-const ROUTER_REASON_ALIASES = ["router_reason", "routerReason"];
-const GOLDEN_ROUTE_ID_ALIASES = ["golden_route_id", "goldenRouteId"];
-const TASK_ACK_ALIASES = ["task_ack", "taskAck", "task_id", "taskId"];
-const SCOPE_ALIASES = ["scope"];
-const READ_ACK_ALIASES = ["read_ack", "readAck"];
-const STATUS_ALIASES = ["status"];
-const NOTE_ALIASES = ["note"];
-const REPLY_TO_ALIASES = ["reply_to", "replyTo"];
-const POSITION_STATUS_ALIASES = ["position_status", "positionStatus"];
-const LATEST_USER_VISIBLE_RESULT_ALIASES = ["latest_user_visible_result", "latestUserVisibleResult"];
-const BLOCKER_SUMMARY_ALIASES = ["blocker_summary", "blockerSummary"];
-const ACCEPTANCE_STATE_ALIASES = ["acceptance_state", "acceptanceState"];
-const CEO_WRITE_NEXT_STEP_ALIASES = ["ceo_write_next_step", "ceoWriteNextStep"];
-function normalizeOptionalText(value) {
-  if (typeof value !== "string") {
-    return null;
+      this.session.updateAgentState((currentState) => {
+        const pendingRequests = currentState.requests || {};
+        const completedRequests = { ...currentState.completedRequests };
+        for (const [id, request] of Object.entries(pendingRequests)) {
+          completedRequests[id] = {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: "Session reset"
+          };
+        }
+        return {
+          ...currentState,
+          requests: {},
+          completedRequests
+        };
+      });
+      persistence.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
+    } finally {
+      this.isResetting = false;
+    }
   }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeAccessChannelState(value) {
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (normalized === "ok" || normalized === "reattach_required" || normalized === "runtime_replaced") {
-    return normalized;
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
   }
-  return null;
-}
-function normalizeSummaryText(value) {
-  const normalized = normalizeOptionalText(value);
-  return normalized ? normalized.replace(/\s+/g, " ").slice(0, persistence.HAPPY_ORG_SUMMARY_MAX_LENGTH) : null;
-}
-function normalizeSingleLineText(value) {
-  const normalized = normalizeOptionalText(value);
-  if (!normalized || normalized.includes("\n") || normalized.includes("\r")) {
-    return null;
+  handlePendingRequestTimeout(toolCallId, pending) {
+    const active = this.pendingRequests.get(toolCallId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(toolCallId);
+    this.clearPendingRequestTimeout(active);
+    active.resolve({ decision: "abort" });
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[toolCallId] || {
+        tool: active.toolName,
+        arguments: active.input,
+        createdAt: Date.now(),
+        requestKind: "permission"
+      };
+      const { [toolCallId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            decision: "abort",
+            requestKind: request.requestKind || "permission"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    persistence.logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
   }
-  return normalized;
-}
-function cloneHappyOrgReplyContext(replyContext) {
-  return replyContext ? { ...replyContext } : null;
-}
-function cloneHappyOrgSpecialistHomeIdentity(specialistHome) {
-  return specialistHome ? { ...specialistHome } : null;
 }
-function cloneHappyOrgAcceptanceHandoff(handoff) {
-  if (handoff === void 0) {
-    return void 0;
+
+class MessageQueue2 {
+  queue = [];
+  // Made public for testing
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  modeHasher;
+  constructor(modeHasher, onMessageHandler = null) {
+    this.modeHasher = modeHasher;
+    this.onMessageHandler = onMessageHandler;
+    persistence.logger.debug(`[MessageQueue2] Initialized`);
   }
-  return handoff ? { ...handoff } : null;
-}
-function cloneHappyOrgTurnReport(report) {
-  if (!report) {
-    return void 0;
+  /**
+   * Set a handler that will be called when a message arrives
+   */
+  setOnMessage(handler) {
+    this.onMessageHandler = handler;
   }
-  const acceptanceHandoff = cloneHappyOrgAcceptanceHandoff(report.acceptanceHandoff);
-  return {
-    ...report,
-    replyContext: cloneHappyOrgReplyContext(report.replyContext),
-    specialistHome: cloneHappyOrgSpecialistHomeIdentity(report.specialistHome),
-    ...acceptanceHandoff !== void 0 ? { acceptanceHandoff } : {}
-  };
-}
-function cloneHappyOrgMetadata(happyOrg) {
-  return {
-    taskContext: happyOrg?.taskContext ? { ...happyOrg.taskContext } : void 0,
-    runtime: happyOrg?.runtime ? { ...happyOrg.runtime } : void 0,
-    activeOwner: happyOrg?.activeOwner ? { ...happyOrg.activeOwner } : null,
-    replyContext: cloneHappyOrgReplyContext(happyOrg?.replyContext),
-    dispatchAcks: happyOrg?.dispatchAcks ? Object.fromEntries(
-      Object.entries(happyOrg.dispatchAcks).map(([dispatchId, entry]) => [
-        dispatchId,
-        { ...entry }
-      ])
-    ) : void 0,
-    specialistHome: cloneHappyOrgSpecialistHomeIdentity(happyOrg?.specialistHome),
-    repeat: happyOrg?.repeat ? {
-      threshold: happyOrg.repeat.threshold,
-      fingerprints: Object.fromEntries(
-        Object.entries(happyOrg.repeat.fingerprints ?? {}).map(([fingerprint, entry]) => [
-          fingerprint,
-          { ...entry }
-        ])
-      )
-    } : void 0,
-    lastTurnReport: cloneHappyOrgTurnReport(happyOrg?.lastTurnReport)
-  };
-}
-function normalizeHappyOrgMetadata(metadata) {
-  const happyOrg = cloneHappyOrgMetadata(metadata?.happyOrg);
-  return {
-    ...happyOrg,
-    runtime: happyOrg.runtime ?? {
-      status: "active",
-      reason: null
-    },
-    dispatchAcks: happyOrg.dispatchAcks ?? {},
-    repeat: happyOrg.repeat ?? {
-      threshold: persistence.HAPPY_ORG_REPEAT_THRESHOLD,
-      fingerprints: {}
-    }
-  };
-}
-function withHappyOrgMetadata(metadata, happyOrg) {
-  return {
-    ...metadata,
-    happyOrg
-  };
-}
-function resetHappyOrgRuntimeForTask(taskContext, specialistHome) {
-  return {
-    taskContext,
-    runtime: {
-      status: "active",
-      reason: null
-    },
-    activeOwner: null,
-    replyContext: null,
-    dispatchAcks: {},
-    specialistHome: cloneHappyOrgSpecialistHomeIdentity(specialistHome),
-    repeat: {
-      threshold: persistence.HAPPY_ORG_REPEAT_THRESHOLD,
-      fingerprints: {}
+  /**
+   * Push a message to the queue with a mode.
+   */
+  push(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
     }
-  };
-}
-function parseStructuredFields(text) {
-  const fields = {};
-  for (const rawLine of text.split(/\r?\n/)) {
-    const match = rawLine.match(STRUCTURED_FIELD_PATTERN);
-    if (!match) {
-      continue;
+    const modeHash = this.modeHasher(mode);
+    persistence.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
     }
-    const [, key, value] = match;
-    if (!key) {
-      continue;
+    if (this.waiter) {
+      persistence.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
     }
-    fields[key] = value.trim();
-  }
-  return fields;
-}
-function parseJsonEnvelopeFields(text) {
-  const trimmed = text.trim();
-  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
-    return null;
+    persistence.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
   }
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null;
-    }
-    const record = parsed;
-    const fields = {};
-    for (const key of [
-      "ack_version",
-      "dispatch_id",
-      "organization_id",
-      "task_id",
-      "scope",
-      "member_agent_id",
-      "agent_id",
-      "session_id",
-      "position_id",
-      "responsibility_id",
-      "reply_to",
-      "route_type",
-      "ack_type",
-      "reply_mode",
-      "plan_intent",
-      "router_reason",
-      "golden_route_id",
-      "task_ack",
-      "read_ack",
-      "status",
-      "note"
-    ]) {
-      const value = normalizeOptionalText(record[key]);
-      if (value) {
-        fields[key] = value;
-      }
+  /**
+   * Push a message immediately without batching delay.
+   * Does not clear the queue or enforce isolation.
+   */
+  pushImmediate(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
     }
-    return fields;
-  } catch {
-    return null;
-  }
-}
-function parseHappyOrgEnvelopeFields(text) {
-  return parseJsonEnvelopeFields(text) ?? parseStructuredFields(text);
-}
-function getFirstDefined(record, aliases) {
-  for (const alias of aliases) {
-    if (Object.prototype.hasOwnProperty.call(record, alias)) {
-      return record[alias];
+    const modeHash = this.modeHasher(mode);
+    persistence.logger.debug(`[MessageQueue2] pushImmediate() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
     }
+    if (this.waiter) {
+      persistence.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    persistence.logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
   }
-  return void 0;
-}
-function normalizeDispatchAckStatus(value) {
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (normalized === "accepted" || normalized === "standby" || normalized === "blocked") {
-    return normalized;
-  }
-  return null;
-}
-function normalizeDispatchReadAck(value) {
-  if (value === true) {
-    return HAPPY_ORG_READ_ACK;
-  }
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (!normalized) {
-    return null;
+  /**
+   * Push a message that must be processed in complete isolation.
+   * Clears any pending messages and ensures this message is never batched with others.
+   * Used for special commands that require dedicated processing.
+   */
+  pushIsolateAndClear(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    persistence.logger.debug(`[MessageQueue2] pushIsolateAndClear() called with mode hash: ${modeHash} - clearing ${this.queue.length} pending messages`);
+    this.queue = [];
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: true
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      persistence.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    persistence.logger.debug(`[MessageQueue2] pushIsolateAndClear() completed. Queue size: ${this.queue.length}`);
   }
-  return normalized === "yes" || normalized === "true" ? HAPPY_ORG_READ_ACK : null;
-}
-function normalizeRouteType(value) {
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (normalized === "direct_reply" || normalized === "version_planning_reply" || normalized === "analysis_task" || normalized === "implementation_task" || normalized === "ack_plus_reply") {
-    return normalized;
+  /**
+   * Push a message to the beginning of the queue with a mode.
+   */
+  unshift(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot unshift to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    persistence.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    this.queue.unshift({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      persistence.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    persistence.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
   }
-  return null;
-}
-function normalizeAckType(value) {
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (normalized === "none" || normalized === "read_ack" || normalized === "dispatch_ack" || normalized === "route_ack" || normalized === "progress_ack") {
-    return normalized;
+  /**
+   * Reset the queue - clears all messages and resets to empty state
+   */
+  reset() {
+    persistence.logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
+    this.queue = [];
+    this.closed = false;
+    this.waiter = null;
   }
-  return null;
-}
-function normalizeReplyMode(value) {
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (normalized === "reply-first" || normalized === "analysis-first") {
-    return normalized;
+  /**
+   * Close the queue - no more messages can be pushed
+   */
+  close() {
+    persistence.logger.debug(`[MessageQueue2] close() called`);
+    this.closed = true;
+    if (this.waiter) {
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(false);
+    }
   }
-  return null;
-}
-function normalizeAcceptanceState(value) {
-  const normalized = normalizeSingleLineText(value)?.toLowerCase();
-  if (normalized === "not_ready" || normalized === "awaiting_acceptance" || normalized === "closed") {
-    return normalized;
+  /**
+   * Check if the queue is closed
+   */
+  isClosed() {
+    return this.closed;
   }
-  return null;
-}
-function normalizeBlockerSummary(value) {
-  const normalized = normalizeSingleLineText(value);
-  if (!normalized) {
-    return null;
+  /**
+   * Get the current queue size
+   */
+  size() {
+    return this.queue.length;
   }
-  const lowered = normalized.toLowerCase();
-  if (lowered === "none" || lowered === "null" || lowered === "no blocker") {
-    return null;
+  /**
+   * Wait for messages and return all messages with the same mode as a single string
+   * Returns { message: string, mode: T } or null if aborted/closed
+   */
+  async waitForMessagesAndGetAsString(abortSignal) {
+    if (this.queue.length > 0) {
+      return this.collectBatch();
+    }
+    if (this.closed || abortSignal?.aborted) {
+      return null;
+    }
+    const hasMessages = await this.waitForMessages(abortSignal);
+    if (!hasMessages) {
+      return null;
+    }
+    return this.collectBatch();
   }
-  return normalized;
-}
-function normalizeHappyOrgAcceptanceHandoffRecord(record) {
-  const dispatchId = normalizeSingleLineText(getFirstDefined(record, DISPATCH_ID_ALIASES));
-  const replyTo = normalizeSingleLineText(getFirstDefined(record, REPLY_TO_ALIASES));
-  const taskId = normalizeSingleLineText(getFirstDefined(record, TASK_ID_ALIASES));
-  const positionStatus = normalizeSingleLineText(getFirstDefined(record, POSITION_STATUS_ALIASES));
-  const latestUserVisibleResult = normalizeSingleLineText(getFirstDefined(record, LATEST_USER_VISIBLE_RESULT_ALIASES));
-  const acceptanceState = normalizeAcceptanceState(getFirstDefined(record, ACCEPTANCE_STATE_ALIASES));
-  const ceoWriteNextStep = normalizeSingleLineText(getFirstDefined(record, CEO_WRITE_NEXT_STEP_ALIASES));
-  if (!dispatchId || !replyTo || !taskId || !positionStatus || !latestUserVisibleResult || !acceptanceState || !ceoWriteNextStep) {
-    return null;
+  /**
+   * Collect a batch of messages with the same mode, respecting isolation requirements
+   */
+  collectBatch() {
+    if (this.queue.length === 0) {
+      return null;
+    }
+    const firstItem = this.queue[0];
+    const sameModeMessages = [];
+    let mode = firstItem.mode;
+    let isolate = firstItem.isolate ?? false;
+    const targetModeHash = firstItem.modeHash;
+    if (firstItem.isolate) {
+      const item = this.queue.shift();
+      sameModeMessages.push(item.message);
+      persistence.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
+    } else {
+      while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash && !this.queue[0].isolate) {
+        const item = this.queue.shift();
+        sameModeMessages.push(item.message);
+      }
+      persistence.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+    }
+    const combinedMessage = sameModeMessages.join("\n");
+    return {
+      message: combinedMessage,
+      mode,
+      hash: targetModeHash,
+      isolate
+    };
+  }
+  /**
+   * Wait for messages to arrive
+   */
+  waitForMessages(abortSignal) {
+    return new Promise((resolve) => {
+      let abortHandler = null;
+      if (abortSignal) {
+        abortHandler = () => {
+          persistence.logger.debug("[MessageQueue2] Wait aborted");
+          if (this.waiter === waiterFunc) {
+            this.waiter = null;
+          }
+          resolve(false);
+        };
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      const waiterFunc = (hasMessages) => {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(hasMessages);
+      };
+      if (this.queue.length > 0) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(true);
+        return;
+      }
+      if (this.closed || abortSignal?.aborted) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(false);
+        return;
+      }
+      this.waiter = waiterFunc;
+      persistence.logger.debug("[MessageQueue2] Waiting for messages...");
+    });
   }
-  return {
-    dispatchId,
-    replyTo,
-    taskId,
-    positionId: normalizeSingleLineText(getFirstDefined(record, POSITION_ID_ALIASES)),
-    responsibilityId: normalizeSingleLineText(getFirstDefined(record, RESPONSIBILITY_ID_ALIASES)),
-    positionStatus,
-    latestUserVisibleResult,
-    blockerSummary: normalizeBlockerSummary(getFirstDefined(record, BLOCKER_SUMMARY_ALIASES)),
-    acceptanceState,
-    ceoWriteNextStep
-  };
 }
-function normalizeHappyOrgDispatchAckRecord(record) {
-  const ackVersion = normalizeSingleLineText(getFirstDefined(record, ACK_VERSION_ALIASES));
-  const dispatchId = normalizeSingleLineText(getFirstDefined(record, DISPATCH_ID_ALIASES));
-  const organizationId = normalizeSingleLineText(getFirstDefined(record, ORGANIZATION_ID_ALIASES));
-  const taskId = normalizeSingleLineText(getFirstDefined(record, TASK_ID_ALIASES));
-  const scope = normalizeSingleLineText(getFirstDefined(record, SCOPE_ALIASES));
-  const memberAgentId = normalizeSingleLineText(getFirstDefined(record, MEMBER_AGENT_ID_ALIASES));
-  const sessionId = normalizeSingleLineText(getFirstDefined(record, SESSION_ID_ALIASES));
-  const positionId = normalizeSingleLineText(getFirstDefined(record, POSITION_ID_ALIASES));
-  const responsibilityId = normalizeSingleLineText(getFirstDefined(record, RESPONSIBILITY_ID_ALIASES));
-  const routeType = normalizeRouteType(getFirstDefined(record, ROUTE_TYPE_ALIASES));
-  const ackType = normalizeAckType(getFirstDefined(record, ACK_TYPE_ALIASES));
-  const replyMode = normalizeReplyMode(getFirstDefined(record, REPLY_MODE_ALIASES));
-  const planIntent = normalizeSingleLineText(getFirstDefined(record, PLAN_INTENT_ALIASES));
-  const routerReason = normalizeSingleLineText(getFirstDefined(record, ROUTER_REASON_ALIASES));
-  const goldenRouteId = normalizeSingleLineText(getFirstDefined(record, GOLDEN_ROUTE_ID_ALIASES));
-  const taskAck = normalizeSingleLineText(getFirstDefined(record, TASK_ACK_ALIASES));
-  const readAck = normalizeDispatchReadAck(getFirstDefined(record, READ_ACK_ALIASES));
-  const status = normalizeDispatchAckStatus(getFirstDefined(record, STATUS_ALIASES));
-  const note = normalizeSingleLineText(getFirstDefined(record, NOTE_ALIASES));
-  if (!dispatchId || !scope || !taskAck || !readAck || !status || !note) {
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    persistence.logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
+const STRUCTURED_FIELD_PATTERN = /^\s*([a-z_]+)\s*=\s*(.*?)\s*$/;
+const KEY_VALUE_LINE_PATTERN = /^([A-Za-z0-9_]+)=(.*)$/;
+const HAPPY_ORG_READ_ACK = "yes";
+const DISPATCH_ID_ALIASES = ["dispatch_id", "dispatchId"];
+const ACK_VERSION_ALIASES = ["ack_version", "ackVersion"];
+const ORGANIZATION_ID_ALIASES = ["organization_id", "organizationId"];
+const TASK_ID_ALIASES = ["task_id", "taskId"];
+const MEMBER_AGENT_ID_ALIASES = ["member_agent_id", "memberAgentId", "agent_id", "agentId"];
+const SESSION_ID_ALIASES = ["session_id", "sessionId"];
+const POSITION_ID_ALIASES = ["position_id", "positionId"];
+const RESPONSIBILITY_ID_ALIASES = ["responsibility_id", "responsibilityId"];
+const ROUTE_TYPE_ALIASES = ["route_type", "routeType"];
+const ACK_TYPE_ALIASES = ["ack_type", "ackType"];
+const REPLY_MODE_ALIASES = ["reply_mode", "replyMode"];
+const PLAN_INTENT_ALIASES = ["plan_intent", "planIntent"];
+const ROUTER_REASON_ALIASES = ["router_reason", "routerReason"];
+const GOLDEN_ROUTE_ID_ALIASES = ["golden_route_id", "goldenRouteId"];
+const TASK_ACK_ALIASES = ["task_ack", "taskAck", "task_id", "taskId"];
+const SCOPE_ALIASES = ["scope"];
+const READ_ACK_ALIASES = ["read_ack", "readAck"];
+const STATUS_ALIASES = ["status"];
+const NOTE_ALIASES = ["note"];
+const REPLY_TO_ALIASES = ["reply_to", "replyTo"];
+const POSITION_STATUS_ALIASES = ["position_status", "positionStatus"];
+const LATEST_USER_VISIBLE_RESULT_ALIASES = ["latest_user_visible_result", "latestUserVisibleResult"];
+const BLOCKER_SUMMARY_ALIASES = ["blocker_summary", "blockerSummary"];
+const ACCEPTANCE_STATE_ALIASES = ["acceptance_state", "acceptanceState"];
+const CEO_WRITE_NEXT_STEP_ALIASES = ["ceo_write_next_step", "ceoWriteNextStep"];
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
     return null;
   }
-  return {
-    ackVersion,
-    dispatchId,
-    organizationId,
-    taskId,
-    scope,
-    memberAgentId,
-    sessionId,
-    positionId,
-    responsibilityId,
-    routeType,
-    ackType,
-    replyMode,
-    planIntent,
-    routerReason,
-    goldenRouteId,
-    taskAck,
-    readAck,
-    status,
-    note
-  };
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
 }
-function isHappyOrgDispatchAckCandidateRecord(record) {
-  return [
-    ...DISPATCH_ID_ALIASES,
-    ...ACK_VERSION_ALIASES,
-    ...ORGANIZATION_ID_ALIASES,
-    ...TASK_ID_ALIASES,
-    ...MEMBER_AGENT_ID_ALIASES,
-    ...SESSION_ID_ALIASES,
-    ...POSITION_ID_ALIASES,
-    ...RESPONSIBILITY_ID_ALIASES,
-    ...ROUTE_TYPE_ALIASES,
-    ...ACK_TYPE_ALIASES,
-    ...REPLY_MODE_ALIASES,
-    ...PLAN_INTENT_ALIASES,
-    ...ROUTER_REASON_ALIASES,
-    ...GOLDEN_ROUTE_ID_ALIASES,
-    ...TASK_ACK_ALIASES,
-    ...SCOPE_ALIASES,
-    ...READ_ACK_ALIASES,
-    ...STATUS_ALIASES,
-    ...NOTE_ALIASES
-  ].some((key) => Object.prototype.hasOwnProperty.call(record, key));
+function normalizeAccessChannelState(value) {
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (normalized === "ok" || normalized === "reattach_required" || normalized === "runtime_replaced") {
+    return normalized;
+  }
+  return null;
 }
-function isHappyOrgAcceptanceHandoffCandidateRecord(record) {
-  return [
-    ...DISPATCH_ID_ALIASES,
-    ...REPLY_TO_ALIASES,
-    ...TASK_ID_ALIASES,
-    ...POSITION_ID_ALIASES,
-    ...RESPONSIBILITY_ID_ALIASES,
-    ...POSITION_STATUS_ALIASES,
-    ...LATEST_USER_VISIBLE_RESULT_ALIASES,
-    ...BLOCKER_SUMMARY_ALIASES,
-    ...ACCEPTANCE_STATE_ALIASES,
-    ...CEO_WRITE_NEXT_STEP_ALIASES
-  ].some((key) => Object.prototype.hasOwnProperty.call(record, key));
+function normalizeSummaryText(value) {
+  const normalized = normalizeOptionalText(value);
+  return normalized ? normalized.replace(/\s+/g, " ").slice(0, persistence.HAPPY_ORG_SUMMARY_MAX_LENGTH) : null;
 }
-function extractKeyValueBlocks(text) {
-  const blocks = [];
-  let currentBlock = null;
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    const match = KEY_VALUE_LINE_PATTERN.exec(line);
-    if (match) {
-      currentBlock ??= {};
-      currentBlock[match[1]] = match[2].trim();
-      continue;
-    }
-    if (currentBlock && Object.keys(currentBlock).length > 0) {
-      blocks.push(currentBlock);
-      currentBlock = null;
-    }
-  }
-  if (currentBlock && Object.keys(currentBlock).length > 0) {
-    blocks.push(currentBlock);
+function normalizeSingleLineText(value) {
+  const normalized = normalizeOptionalText(value);
+  if (!normalized || normalized.includes("\n") || normalized.includes("\r")) {
+    return null;
   }
-  return blocks;
+  return normalized;
 }
-function resolveHappyOrgDispatchAckEnvelopeCandidate(text) {
-  const trimmed = stripCodeFence(text).trim();
-  if (!trimmed) {
-    return { outcome: "absent" };
-  }
-  let sawCandidate = false;
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        const record = parsed;
-        if (isHappyOrgDispatchAckCandidateRecord(record)) {
-          const envelope = normalizeHappyOrgDispatchAckRecord(record);
-          if (envelope) {
-            return {
-              outcome: "valid",
-              envelope
-            };
-          }
-          sawCandidate = true;
-        }
-      }
-    } catch {
-    }
-  }
-  for (const block of extractKeyValueBlocks(text)) {
-    if (!isHappyOrgDispatchAckCandidateRecord(block)) {
-      continue;
-    }
-    const envelope = normalizeHappyOrgDispatchAckRecord(block);
-    if (envelope) {
-      return {
-        outcome: "valid",
-        envelope
-      };
-    }
-    sawCandidate = true;
-  }
-  return sawCandidate ? {
-    outcome: "invalid",
-    diagnostic: "Happy Org dispatch ack ignored: malformed envelope. Required fields are dispatch_id, scope, task_ack, read_ack=yes, status, and note."
-  } : {
-    outcome: "absent"
-  };
+function cloneHappyOrgReplyContext(replyContext) {
+  return replyContext ? { ...replyContext } : null;
 }
-function resolveHappyOrgAcceptanceHandoffCandidate(text) {
-  const trimmed = stripCodeFence(text).trim();
-  if (!trimmed) {
-    return { outcome: "absent" };
+function cloneHappyOrgSpecialistHomeIdentity(specialistHome) {
+  return specialistHome ? { ...specialistHome } : null;
+}
+function cloneHappyOrgAcceptanceHandoff(handoff) {
+  if (handoff === void 0) {
+    return void 0;
   }
-  let sawCandidate = false;
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-        const record = parsed;
-        if (isHappyOrgAcceptanceHandoffCandidateRecord(record)) {
-          const handoff = normalizeHappyOrgAcceptanceHandoffRecord(record);
-          if (handoff) {
-            return {
-              outcome: "valid",
-              handoff
-            };
-          }
-          sawCandidate = true;
-        }
-      }
-    } catch {
-    }
+  return handoff ? { ...handoff } : null;
+}
+function cloneHappyOrgTurnReport(report) {
+  if (!report) {
+    return void 0;
   }
-  for (const block of extractKeyValueBlocks(text)) {
-    if (!isHappyOrgAcceptanceHandoffCandidateRecord(block)) {
-      continue;
-    }
-    const handoff = normalizeHappyOrgAcceptanceHandoffRecord(block);
-    if (handoff) {
-      return {
-        outcome: "valid",
-        handoff
-      };
+  const acceptanceHandoff = cloneHappyOrgAcceptanceHandoff(report.acceptanceHandoff);
+  return {
+    ...report,
+    replyContext: cloneHappyOrgReplyContext(report.replyContext),
+    specialistHome: cloneHappyOrgSpecialistHomeIdentity(report.specialistHome),
+    ...acceptanceHandoff !== void 0 ? { acceptanceHandoff } : {}
+  };
+}
+function cloneHappyOrgMetadata(happyOrg) {
+  return {
+    taskContext: happyOrg?.taskContext ? { ...happyOrg.taskContext } : void 0,
+    runtime: happyOrg?.runtime ? { ...happyOrg.runtime } : void 0,
+    activeOwner: happyOrg?.activeOwner ? { ...happyOrg.activeOwner } : null,
+    replyContext: cloneHappyOrgReplyContext(happyOrg?.replyContext),
+    dispatchAcks: happyOrg?.dispatchAcks ? Object.fromEntries(
+      Object.entries(happyOrg.dispatchAcks).map(([dispatchId, entry]) => [
+        dispatchId,
+        { ...entry }
+      ])
+    ) : void 0,
+    specialistHome: cloneHappyOrgSpecialistHomeIdentity(happyOrg?.specialistHome),
+    repeat: happyOrg?.repeat ? {
+      threshold: happyOrg.repeat.threshold,
+      fingerprints: Object.fromEntries(
+        Object.entries(happyOrg.repeat.fingerprints ?? {}).map(([fingerprint, entry]) => [
+          fingerprint,
+          { ...entry }
+        ])
+      )
+    } : void 0,
+    lastTurnReport: cloneHappyOrgTurnReport(happyOrg?.lastTurnReport)
+  };
+}
+function normalizeHappyOrgMetadata(metadata) {
+  const happyOrg = cloneHappyOrgMetadata(metadata?.happyOrg);
+  return {
+    ...happyOrg,
+    runtime: happyOrg.runtime ?? {
+      status: "active",
+      reason: null
+    },
+    dispatchAcks: happyOrg.dispatchAcks ?? {},
+    repeat: happyOrg.repeat ?? {
+      threshold: persistence.HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
     }
-    sawCandidate = true;
-  }
-  return sawCandidate ? {
-    outcome: "invalid",
-    diagnostic: "Happy Org acceptance handoff ignored: malformed mini-pack. Required fields are dispatch_id, reply_to, task_id, position_status, latest_user_visible_result, acceptance_state, and ceo_write_next_step."
-  } : {
-    outcome: "absent"
   };
 }
-function recordHappyOrgDispatchAck(metadata, ack, acknowledgedAt) {
-  const nextHappyOrg = normalizeHappyOrgMetadata(metadata);
-  nextHappyOrg.dispatchAcks = nextHappyOrg.dispatchAcks ?? {};
-  nextHappyOrg.dispatchAcks[ack.dispatchId] = {
-    dispatchId: ack.dispatchId,
-    ackVersion: ack.ackVersion,
-    scope: ack.scope,
-    taskAck: ack.taskAck,
-    readAck: ack.readAck,
-    status: ack.status,
-    note: ack.note,
-    taskId: ack.taskId,
-    organizationId: ack.organizationId,
-    memberAgentId: ack.memberAgentId,
-    sessionId: ack.sessionId,
-    positionId: ack.positionId,
-    responsibilityId: ack.responsibilityId,
-    routeType: ack.routeType,
-    ackType: ack.ackType,
-    replyMode: ack.replyMode,
-    planIntent: ack.planIntent,
-    routerReason: ack.routerReason,
-    goldenRouteId: ack.goldenRouteId,
-    acknowledgedAt
+function withHappyOrgMetadata(metadata, happyOrg) {
+  return {
+    ...metadata,
+    happyOrg
   };
-  return withHappyOrgMetadata(metadata, nextHappyOrg);
 }
-function normalizeDispatchAckError(error) {
-  if (error instanceof Error) {
-    return error.message.trim() || "Unknown error";
-  }
-  if (typeof error === "string") {
-    return error.trim() || "Unknown error";
+function resetHappyOrgRuntimeForTask(taskContext, specialistHome) {
+  return {
+    taskContext,
+    runtime: {
+      status: "active",
+      reason: null
+    },
+    activeOwner: null,
+    replyContext: null,
+    dispatchAcks: {},
+    specialistHome: cloneHappyOrgSpecialistHomeIdentity(specialistHome),
+    repeat: {
+      threshold: persistence.HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function parseStructuredFields(text) {
+  const fields = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const match = rawLine.match(STRUCTURED_FIELD_PATTERN);
+    if (!match) {
+      continue;
+    }
+    const [, key, value] = match;
+    if (!key) {
+      continue;
+    }
+    fields[key] = value.trim();
   }
-  return "Unknown error";
+  return fields;
 }
-async function maybeSubmitHappyOrgDispatchBusinessAck(opts) {
-  const metadata = opts.metadata ?? null;
-  const candidate = resolveHappyOrgDispatchAckEnvelopeCandidate(opts.responseText);
-  if (candidate.outcome === "absent") {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "none",
-        reason: "no_envelope",
-        diagnostic: null
-      }
-    };
+function parseJsonEnvelopeFields(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return null;
   }
-  if (candidate.outcome === "invalid") {
-    persistence.logger.debug("[HappyOrg] Dispatch ack candidate rejected as malformed");
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "malformed_envelope",
-        diagnostic: candidate.diagnostic
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const record = parsed;
+    const fields = {};
+    for (const key of [
+      "ack_version",
+      "dispatch_id",
+      "organization_id",
+      "task_id",
+      "scope",
+      "member_agent_id",
+      "agent_id",
+      "session_id",
+      "position_id",
+      "responsibility_id",
+      "reply_to",
+      "route_type",
+      "ack_type",
+      "reply_mode",
+      "plan_intent",
+      "router_reason",
+      "golden_route_id",
+      "task_ack",
+      "read_ack",
+      "status",
+      "note"
+    ]) {
+      const value = normalizeOptionalText(record[key]);
+      if (value) {
+        fields[key] = value;
       }
-    };
+    }
+    return fields;
+  } catch {
+    return null;
   }
-  if (!metadata) {
-    return {
-      nextMetadata: null,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "missing_metadata",
-        diagnostic: "Happy Org dispatch ack ignored: session metadata is unavailable."
-      }
-    };
+}
+function parseHappyOrgEnvelopeFields(text) {
+  return parseJsonEnvelopeFields(text) ?? parseStructuredFields(text);
+}
+function getFirstDefined(record, aliases) {
+  for (const alias of aliases) {
+    if (Object.prototype.hasOwnProperty.call(record, alias)) {
+      return record[alias];
+    }
   }
-  const envelope = candidate.envelope;
-  const currentHappyOrg = normalizeHappyOrgMetadata(metadata);
-  const replyContext = cloneHappyOrgReplyContext(opts.queuedTurn?.replyContext) ?? cloneHappyOrgReplyContext(currentHappyOrg.replyContext);
-  if (!replyContext) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "missing_reply_context",
-        diagnostic: `Happy Org dispatch ack ignored: no active reply context matches dispatch ${envelope.dispatchId}.`
-      }
-    };
+  return void 0;
+}
+function normalizeDispatchAckStatus(value) {
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (normalized === "accepted" || normalized === "standby" || normalized === "blocked") {
+    return normalized;
   }
-  const taskContext = opts.queuedTurn?.context ?? currentHappyOrg.taskContext ?? null;
-  if (!taskContext) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "missing_task_context",
-        diagnostic: `Happy Org dispatch ack ignored: no active task context matches dispatch ${envelope.dispatchId}.`
-      }
-    };
-  }
-  if (envelope.dispatchId !== replyContext.dispatchId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "dispatch_id_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: dispatch_id ${envelope.dispatchId} does not match active dispatch ${replyContext.dispatchId}.`
-      }
-    };
-  }
-  if (envelope.scope !== replyContext.scope) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "scope_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: scope ${envelope.scope} does not match active scope ${replyContext.scope}.`
-      }
-    };
-  }
-  if (envelope.taskAck !== taskContext.taskId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "task_ack_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: task_ack ${envelope.taskAck} does not match active task ${taskContext.taskId}.`
-      }
-    };
-  }
-  if (envelope.organizationId && envelope.organizationId !== taskContext.organizationId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "organization_id_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: organization_id ${envelope.organizationId} does not match active organization ${taskContext.organizationId}.`
-      }
-    };
-  }
-  if (envelope.taskId && envelope.taskId !== taskContext.taskId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "task_id_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: task_id ${envelope.taskId} does not match active task ${taskContext.taskId}.`
-      }
-    };
-  }
-  if (envelope.memberAgentId && envelope.memberAgentId !== taskContext.memberAgentId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "member_agent_id_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: member_agent_id ${envelope.memberAgentId} does not match active member ${taskContext.memberAgentId}.`
-      }
-    };
-  }
-  if (replyContext.positionId && envelope.positionId && envelope.positionId !== replyContext.positionId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "position_id_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: position_id ${envelope.positionId} does not match active position ${replyContext.positionId}.`
-      }
-    };
-  }
-  if (replyContext.responsibilityId && envelope.responsibilityId && envelope.responsibilityId !== replyContext.responsibilityId) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "responsibility_id_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: responsibility_id ${envelope.responsibilityId} does not match active responsibility ${replyContext.responsibilityId}.`
-      }
-    };
-  }
-  if (replyContext.routeType && envelope.routeType && envelope.routeType !== replyContext.routeType) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "route_type_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: route_type ${envelope.routeType} does not match active route ${replyContext.routeType}.`
-      }
-    };
+  return null;
+}
+function normalizeDispatchReadAck(value) {
+  if (value === true) {
+    return HAPPY_ORG_READ_ACK;
   }
-  if (replyContext.ackType && envelope.ackType && envelope.ackType !== replyContext.ackType) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "ack_type_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: ack_type ${envelope.ackType} does not match active ack_type ${replyContext.ackType}.`
-      }
-    };
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (!normalized) {
+    return null;
   }
-  if (replyContext.replyMode && envelope.replyMode && envelope.replyMode !== replyContext.replyMode) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "invalid",
-        reason: "reply_mode_mismatch",
-        diagnostic: `Happy Org dispatch ack ignored: reply_mode ${envelope.replyMode} does not match active reply_mode ${replyContext.replyMode}.`
-      }
-    };
+  return normalized === "yes" || normalized === "true" ? HAPPY_ORG_READ_ACK : null;
+}
+function normalizeRouteType(value) {
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (normalized === "direct_reply" || normalized === "version_planning_reply" || normalized === "analysis_task" || normalized === "implementation_task" || normalized === "ack_plus_reply") {
+    return normalized;
   }
-  const existingAck = currentHappyOrg.dispatchAcks?.[envelope.dispatchId];
-  if (existingAck) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "duplicate",
-        reason: "already_submitted",
-        diagnostic: `Happy Org dispatch ack skipped: dispatch ${envelope.dispatchId} was already acknowledged as ${existingAck.status}.`
-      }
-    };
+  return null;
+}
+function normalizeAckType(value) {
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (normalized === "none" || normalized === "read_ack" || normalized === "dispatch_ack" || normalized === "route_ack" || normalized === "progress_ack") {
+    return normalized;
   }
-  if (!opts.submitDispatchAck) {
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "error",
-        reason: "submit_callback_unavailable",
-        diagnostic: `Happy Org dispatch ack could not be submitted for ${envelope.dispatchId}: no submit callback is available.`
-      }
-    };
+  return null;
+}
+function normalizeReplyMode(value) {
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (normalized === "reply-first" || normalized === "analysis-first") {
+    return normalized;
   }
-  try {
-    await opts.submitDispatchAck({
-      organizationId: taskContext.organizationId,
-      dispatchId: envelope.dispatchId,
-      memberAgentId: taskContext.memberAgentId,
-      scope: envelope.scope,
-      readAck: envelope.readAck,
-      taskAck: envelope.taskAck,
-      status: envelope.status,
-      note: envelope.note
-    });
-    return {
-      nextMetadata: recordHappyOrgDispatchAck(
-        metadata,
-        envelope,
-        opts.now?.() ?? Date.now()
-      ),
-      dispatchAck: {
-        outcome: "submitted",
-        reason: "submitted",
-        diagnostic: null
-      }
-    };
-  } catch (error) {
-    const diagnostic = `Happy Org dispatch ack failed for ${envelope.dispatchId}: ${normalizeDispatchAckError(error)}.`;
-    persistence.logger.debug("[HappyOrg] Dispatch ack submission failed", {
-      dispatchId: envelope.dispatchId,
-      error
-    });
-    return {
-      nextMetadata: metadata,
-      dispatchAck: {
-        outcome: "error",
-        reason: "submit_failed",
-        diagnostic
-      }
-    };
+  return null;
+}
+function normalizeAcceptanceState(value) {
+  const normalized = normalizeSingleLineText(value)?.toLowerCase();
+  if (normalized === "not_ready" || normalized === "awaiting_acceptance" || normalized === "closed") {
+    return normalized;
   }
+  return null;
 }
-function deriveHomeSlug(path$1) {
-  if (!path$1) {
+function normalizeBlockerSummary(value) {
+  const normalized = normalizeSingleLineText(value);
+  if (!normalized) {
     return null;
   }
-  const trimmedPath = path$1.trim().replace(/[\\/]+$/, "");
-  if (!trimmedPath) {
+  const lowered = normalized.toLowerCase();
+  if (lowered === "none" || lowered === "null" || lowered === "no blocker") {
     return null;
   }
-  return path.basename(trimmedPath) || trimmedPath;
+  return normalized;
 }
-function buildSpecialistHomeIdentity(opts) {
-  const metadata = opts.metadata ?? null;
-  const fallback = opts.fallback ?? null;
-  const path = normalizeOptionalText(metadata?.path) ?? fallback?.path ?? null;
-  const homeSlug = deriveHomeSlug(path) ?? fallback?.homeSlug ?? null;
-  if (!homeSlug) {
-    return fallback ? { ...fallback } : null;
+function normalizeHappyOrgAcceptanceHandoffRecord(record) {
+  const dispatchId = normalizeSingleLineText(getFirstDefined(record, DISPATCH_ID_ALIASES));
+  const replyTo = normalizeSingleLineText(getFirstDefined(record, REPLY_TO_ALIASES));
+  const taskId = normalizeSingleLineText(getFirstDefined(record, TASK_ID_ALIASES));
+  const positionStatus = normalizeSingleLineText(getFirstDefined(record, POSITION_STATUS_ALIASES));
+  const latestUserVisibleResult = normalizeSingleLineText(getFirstDefined(record, LATEST_USER_VISIBLE_RESULT_ALIASES));
+  const acceptanceState = normalizeAcceptanceState(getFirstDefined(record, ACCEPTANCE_STATE_ALIASES));
+  const ceoWriteNextStep = normalizeSingleLineText(getFirstDefined(record, CEO_WRITE_NEXT_STEP_ALIASES));
+  if (!dispatchId || !replyTo || !taskId || !positionStatus || !latestUserVisibleResult || !acceptanceState || !ceoWriteNextStep) {
+    return null;
   }
   return {
-    homeSlug,
-    path,
-    happySessionId: normalizeOptionalText(opts.sessionId) ?? fallback?.happySessionId ?? null,
-    machineId: normalizeOptionalText(metadata?.machineId) ?? fallback?.machineId ?? null,
-    startedBy: metadata?.startedBy ?? fallback?.startedBy ?? null,
-    flavor: normalizeOptionalText(metadata?.flavor) ?? fallback?.flavor ?? null
-  };
-}
-function withDefaultReplyRouting(replyContext) {
-  return {
-    ...replyContext,
-    routeType: replyContext.routeType ?? "ack_plus_reply",
-    ackType: replyContext.ackType ?? "dispatch_ack",
-    replyMode: replyContext.replyMode ?? "reply-first"
+    dispatchId,
+    replyTo,
+    taskId,
+    positionId: normalizeSingleLineText(getFirstDefined(record, POSITION_ID_ALIASES)),
+    responsibilityId: normalizeSingleLineText(getFirstDefined(record, RESPONSIBILITY_ID_ALIASES)),
+    positionStatus,
+    latestUserVisibleResult,
+    blockerSummary: normalizeBlockerSummary(getFirstDefined(record, BLOCKER_SUMMARY_ALIASES)),
+    acceptanceState,
+    ceoWriteNextStep
   };
 }
-function resolveReplyContextFromMessage(message, taskContext) {
-  const metaReplyContext = message.meta?.happyOrg?.replyContext;
-  if (metaReplyContext?.dispatchId && metaReplyContext.scope && metaReplyContext.replyTo) {
-    return withDefaultReplyRouting({
-      dispatchId: metaReplyContext.dispatchId,
-      taskId: metaReplyContext.taskId ?? taskContext?.taskId ?? null,
-      organizationId: metaReplyContext.organizationId ?? taskContext?.organizationId ?? null,
-      scope: metaReplyContext.scope,
-      replyTo: metaReplyContext.replyTo,
-      memberAgentId: metaReplyContext.memberAgentId ?? taskContext?.memberAgentId ?? null,
-      sessionId: metaReplyContext.sessionId ?? null,
-      positionId: metaReplyContext.positionId ?? taskContext?.positionId ?? null,
-      responsibilityId: metaReplyContext.responsibilityId ?? taskContext?.responsibilityId ?? null,
-      routeType: metaReplyContext.routeType ?? null,
-      ackType: metaReplyContext.ackType ?? null,
-      replyMode: metaReplyContext.replyMode ?? null,
-      planIntent: metaReplyContext.planIntent ?? null,
-      routerReason: metaReplyContext.routerReason ?? null,
-      goldenRouteId: metaReplyContext.goldenRouteId ?? null
-    });
-  }
-  const fields = parseHappyOrgEnvelopeFields(message.content.text);
-  const dispatchId = normalizeOptionalText(fields.dispatch_id);
-  const scope = normalizeOptionalText(fields.scope);
-  const replyTo = normalizeOptionalText(fields.reply_to);
-  const taskId = normalizeOptionalText(fields.task_id);
-  if (!dispatchId || !scope || !replyTo) {
-    return null;
-  }
-  if (taskId && taskContext?.taskId && taskId !== taskContext.taskId) {
+function normalizeHappyOrgDispatchAckRecord(record) {
+  const ackVersion = normalizeSingleLineText(getFirstDefined(record, ACK_VERSION_ALIASES));
+  const dispatchId = normalizeSingleLineText(getFirstDefined(record, DISPATCH_ID_ALIASES));
+  const organizationId = normalizeSingleLineText(getFirstDefined(record, ORGANIZATION_ID_ALIASES));
+  const taskId = normalizeSingleLineText(getFirstDefined(record, TASK_ID_ALIASES));
+  const scope = normalizeSingleLineText(getFirstDefined(record, SCOPE_ALIASES));
+  const memberAgentId = normalizeSingleLineText(getFirstDefined(record, MEMBER_AGENT_ID_ALIASES));
+  const sessionId = normalizeSingleLineText(getFirstDefined(record, SESSION_ID_ALIASES));
+  const positionId = normalizeSingleLineText(getFirstDefined(record, POSITION_ID_ALIASES));
+  const responsibilityId = normalizeSingleLineText(getFirstDefined(record, RESPONSIBILITY_ID_ALIASES));
+  const routeType = normalizeRouteType(getFirstDefined(record, ROUTE_TYPE_ALIASES));
+  const ackType = normalizeAckType(getFirstDefined(record, ACK_TYPE_ALIASES));
+  const replyMode = normalizeReplyMode(getFirstDefined(record, REPLY_MODE_ALIASES));
+  const planIntent = normalizeSingleLineText(getFirstDefined(record, PLAN_INTENT_ALIASES));
+  const routerReason = normalizeSingleLineText(getFirstDefined(record, ROUTER_REASON_ALIASES));
+  const goldenRouteId = normalizeSingleLineText(getFirstDefined(record, GOLDEN_ROUTE_ID_ALIASES));
+  const taskAck = normalizeSingleLineText(getFirstDefined(record, TASK_ACK_ALIASES));
+  const readAck = normalizeDispatchReadAck(getFirstDefined(record, READ_ACK_ALIASES));
+  const status = normalizeDispatchAckStatus(getFirstDefined(record, STATUS_ALIASES));
+  const note = normalizeSingleLineText(getFirstDefined(record, NOTE_ALIASES));
+  if (!dispatchId || !scope || !taskAck || !readAck || !status || !note) {
     return null;
   }
-  return withDefaultReplyRouting({
+  return {
+    ackVersion,
     dispatchId,
-    taskId: taskId ?? taskContext?.taskId ?? null,
-    organizationId: normalizeOptionalText(fields.organization_id) ?? taskContext?.organizationId ?? null,
+    organizationId,
+    taskId,
     scope,
-    replyTo,
-    memberAgentId: normalizeOptionalText(fields.member_agent_id) ?? normalizeOptionalText(fields.agent_id) ?? taskContext?.memberAgentId ?? null,
-    sessionId: normalizeOptionalText(fields.session_id),
-    positionId: normalizeOptionalText(fields.position_id) ?? taskContext?.positionId ?? null,
-    responsibilityId: normalizeOptionalText(fields.responsibility_id) ?? taskContext?.responsibilityId ?? null,
-    routeType: normalizeRouteType(fields.route_type),
-    ackType: normalizeAckType(fields.ack_type),
-    replyMode: normalizeReplyMode(fields.reply_mode),
-    planIntent: normalizeOptionalText(fields.plan_intent),
-    routerReason: normalizeOptionalText(fields.router_reason),
-    goldenRouteId: normalizeOptionalText(fields.golden_route_id)
-  });
-}
-function buildTerminatedStatusMessage(taskId) {
-  return `Task ${taskId} is terminated. Reopen it with new context, a new decision, or a new resource before continuing.`;
+    memberAgentId,
+    sessionId,
+    positionId,
+    responsibilityId,
+    routeType,
+    ackType,
+    replyMode,
+    planIntent,
+    routerReason,
+    goldenRouteId,
+    taskAck,
+    readAck,
+    status,
+    note
+  };
 }
-function buildMemberBusyStatusMessage(memberAgentId, activeTaskId, nextTaskId) {
-  return `Member ${memberAgentId} is already busy with active task ${activeTaskId}. Reject task ${nextTaskId} without continuing token usage.`;
+function isHappyOrgDispatchAckCandidateRecord(record) {
+  return [
+    ...DISPATCH_ID_ALIASES,
+    ...ACK_VERSION_ALIASES,
+    ...ORGANIZATION_ID_ALIASES,
+    ...TASK_ID_ALIASES,
+    ...MEMBER_AGENT_ID_ALIASES,
+    ...SESSION_ID_ALIASES,
+    ...POSITION_ID_ALIASES,
+    ...RESPONSIBILITY_ID_ALIASES,
+    ...ROUTE_TYPE_ALIASES,
+    ...ACK_TYPE_ALIASES,
+    ...REPLY_MODE_ALIASES,
+    ...PLAN_INTENT_ALIASES,
+    ...ROUTER_REASON_ALIASES,
+    ...GOLDEN_ROUTE_ID_ALIASES,
+    ...TASK_ACK_ALIASES,
+    ...SCOPE_ALIASES,
+    ...READ_ACK_ALIASES,
+    ...STATUS_ALIASES,
+    ...NOTE_ALIASES
+  ].some((key) => Object.prototype.hasOwnProperty.call(record, key));
 }
-function buildOwnerConflictStatusMessage(taskId, ownerAgentId) {
-  return `Task ${taskId} is already active under owner ${ownerAgentId}. This turn must exit without continuing token usage.`;
+function isHappyOrgAcceptanceHandoffCandidateRecord(record) {
+  return [
+    ...DISPATCH_ID_ALIASES,
+    ...REPLY_TO_ALIASES,
+    ...TASK_ID_ALIASES,
+    ...POSITION_ID_ALIASES,
+    ...RESPONSIBILITY_ID_ALIASES,
+    ...POSITION_STATUS_ALIASES,
+    ...LATEST_USER_VISIBLE_RESULT_ALIASES,
+    ...BLOCKER_SUMMARY_ALIASES,
+    ...ACCEPTANCE_STATE_ALIASES,
+    ...CEO_WRITE_NEXT_STEP_ALIASES
+  ].some((key) => Object.prototype.hasOwnProperty.call(record, key));
 }
-function inferDraftTurnStatus(draft) {
-  if (draft?.turnStatus === "turn_update" || draft?.turnStatus === "task_complete") {
-    return draft.turnStatus;
+function extractKeyValueBlocks(text) {
+  const blocks = [];
+  let currentBlock = null;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const match = KEY_VALUE_LINE_PATTERN.exec(line);
+    if (match) {
+      currentBlock ??= {};
+      currentBlock[match[1]] = match[2].trim();
+      continue;
+    }
+    if (currentBlock && Object.keys(currentBlock).length > 0) {
+      blocks.push(currentBlock);
+      currentBlock = null;
+    }
   }
-  return null;
-}
-function inferInterventionType(draft) {
-  if (draft?.interventionType === "none" || draft?.interventionType === "review_needed" || draft?.interventionType === "blocker" || draft?.interventionType === "decision_needed") {
-    return draft.interventionType;
+  if (currentBlock && Object.keys(currentBlock).length > 0) {
+    blocks.push(currentBlock);
   }
-  if (normalizeOptionalText(draft?.decisionNeeded)) {
-    return "decision_needed";
+  return blocks;
+}
+function resolveHappyOrgDispatchAckEnvelopeCandidate(text) {
+  const trimmed = stripCodeFence(text).trim();
+  if (!trimmed) {
+    return { outcome: "absent" };
   }
-  if (normalizeOptionalText(draft?.blockerCode)) {
-    return "blocker";
+  let sawCandidate = false;
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const record = parsed;
+        if (isHappyOrgDispatchAckCandidateRecord(record)) {
+          const envelope = normalizeHappyOrgDispatchAckRecord(record);
+          if (envelope) {
+            return {
+              outcome: "valid",
+              envelope
+            };
+          }
+          sawCandidate = true;
+        }
+      }
+    } catch {
+    }
   }
-  return "none";
-}
-function buildFallbackSummary(text, turnStatus) {
-  const trimmed = text.trim();
-  if (trimmed) {
-    return trimmed.replace(/\s+/g, " ").slice(0, persistence.HAPPY_ORG_SUMMARY_MAX_LENGTH);
+  for (const block of extractKeyValueBlocks(text)) {
+    if (!isHappyOrgDispatchAckCandidateRecord(block)) {
+      continue;
+    }
+    const envelope = normalizeHappyOrgDispatchAckRecord(block);
+    if (envelope) {
+      return {
+        outcome: "valid",
+        envelope
+      };
+    }
+    sawCandidate = true;
   }
-  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: persistence.normalizePreviewableArtifactTarget(draft?.targetArtifact),
-    accessChannelState: normalizeAccessChannelState(draft?.accessChannelState)
+  return sawCandidate ? {
+    outcome: "invalid",
+    diagnostic: "Happy Org dispatch ack ignored: malformed envelope. Required fields are dispatch_id, scope, task_ack, read_ack=yes, status, and note."
+  } : {
+    outcome: "absent"
   };
 }
-function stripCodeFence(text) {
-  return text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
-}
-function extractTaggedTurnReport(text) {
-  const matcher = new RegExp(
-    `<${persistence.HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${persistence.HAPPY_ORG_TURN_REPORT_TAG}>`,
-    "gi"
-  );
-  let lastMatch = null;
-  for (let match = matcher.exec(text); match; match = matcher.exec(text)) {
-    lastMatch = match;
+function resolveHappyOrgAcceptanceHandoffCandidate(text) {
+  const trimmed = stripCodeFence(text).trim();
+  if (!trimmed) {
+    return { outcome: "absent" };
   }
-  if (!lastMatch) {
-    return {
-      cleanedText: text.trim(),
-      draft: null
-    };
+  let sawCandidate = false;
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const record = parsed;
+        if (isHappyOrgAcceptanceHandoffCandidateRecord(record)) {
+          const handoff = normalizeHappyOrgAcceptanceHandoffRecord(record);
+          if (handoff) {
+            return {
+              outcome: "valid",
+              handoff
+            };
+          }
+          sawCandidate = true;
+        }
+      }
+    } catch {
+    }
   }
-  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: persistence.normalizePreviewableArtifactTarget(parsed.targetArtifact),
-      accessChannelState: normalizeAccessChannelState(parsed.accessChannelState)
-    };
-  } catch {
-    draft = null;
+  for (const block of extractKeyValueBlocks(text)) {
+    if (!isHappyOrgAcceptanceHandoffCandidateRecord(block)) {
+      continue;
+    }
+    const handoff = normalizeHappyOrgAcceptanceHandoffRecord(block);
+    if (handoff) {
+      return {
+        outcome: "valid",
+        handoff
+      };
+    }
+    sawCandidate = true;
   }
-  const cleanedText = `${text.slice(0, lastMatch.index)}${text.slice(lastMatch.index + lastMatch[0].length)}`.replace(/\n{3,}/g, "\n\n").trim();
-  return {
-    cleanedText,
-    draft
+  return sawCandidate ? {
+    outcome: "invalid",
+    diagnostic: "Happy Org acceptance handoff ignored: malformed mini-pack. Required fields are dispatch_id, reply_to, task_id, position_status, latest_user_visible_result, acceptance_state, and ceo_write_next_step."
+  } : {
+    outcome: "absent"
   };
 }
-function buildRepeatFingerprint(context, blockerCode, targetArtifact) {
-  if (!blockerCode) {
-    return null;
-  }
-  return [
-    context.taskId,
-    context.memberAgentId,
-    blockerCode,
-    targetArtifact ?? ""
-  ].join("::");
+function recordHappyOrgDispatchAck(metadata, ack, acknowledgedAt) {
+  const nextHappyOrg = normalizeHappyOrgMetadata(metadata);
+  nextHappyOrg.dispatchAcks = nextHappyOrg.dispatchAcks ?? {};
+  nextHappyOrg.dispatchAcks[ack.dispatchId] = {
+    dispatchId: ack.dispatchId,
+    ackVersion: ack.ackVersion,
+    scope: ack.scope,
+    taskAck: ack.taskAck,
+    readAck: ack.readAck,
+    status: ack.status,
+    note: ack.note,
+    taskId: ack.taskId,
+    organizationId: ack.organizationId,
+    memberAgentId: ack.memberAgentId,
+    sessionId: ack.sessionId,
+    positionId: ack.positionId,
+    responsibilityId: ack.responsibilityId,
+    routeType: ack.routeType,
+    ackType: ack.ackType,
+    replyMode: ack.replyMode,
+    planIntent: ack.planIntent,
+    routerReason: ack.routerReason,
+    goldenRouteId: ack.goldenRouteId,
+    acknowledgedAt
+  };
+  return withHappyOrgMetadata(metadata, nextHappyOrg);
 }
-function resolveReportedTurnStatus(transportTurnStatus, draft) {
-  if (transportTurnStatus === "turn_aborted") {
-    return "turn_aborted";
+function normalizeDispatchAckError(error) {
+  if (error instanceof Error) {
+    return error.message.trim() || "Unknown error";
   }
-  return draft.turnStatus === "task_complete" ? "task_complete" : "turn_update";
+  if (typeof error === "string") {
+    return error.trim() || "Unknown error";
+  }
+  return "Unknown error";
 }
-function buildRuntimeStateAfterTurn(report) {
-  if (report.turnStatus === "task_complete") {
+async function maybeSubmitHappyOrgDispatchBusinessAck(opts) {
+  const metadata = opts.metadata ?? null;
+  const candidate = resolveHappyOrgDispatchAckEnvelopeCandidate(opts.responseText);
+  if (candidate.outcome === "absent") {
     return {
-      status: "waiting_close",
-      reason: "awaiting_ceo_close"
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "none",
+        reason: "no_envelope",
+        diagnostic: null
+      }
     };
   }
-  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
-      };
+  if (candidate.outcome === "invalid") {
+    persistence.logger.debug("[HappyOrg] Dispatch ack candidate rejected as malformed");
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "malformed_envelope",
+        diagnostic: candidate.diagnostic
+      }
+    };
   }
-}
-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 replyContextLines = turn.replyContext ? [
-    "",
-    "This turn also carries a formal dispatch reply context. If you acknowledge or update that dispatch, keep these values stable:",
-    `dispatch_id=${turn.replyContext.dispatchId}`,
-    turn.replyContext.organizationId ? `organization_id=${turn.replyContext.organizationId}` : null,
-    turn.replyContext.taskId ? `task_id=${turn.replyContext.taskId}` : null,
-    `scope=${turn.replyContext.scope}`,
-    `reply_to=${turn.replyContext.replyTo}`,
-    turn.replyContext.memberAgentId ? `member_agent_id=${turn.replyContext.memberAgentId}` : null,
-    turn.replyContext.sessionId ? `session_id=${turn.replyContext.sessionId}` : null,
-    turn.replyContext.positionId ? `position_id=${turn.replyContext.positionId}` : null,
-    turn.replyContext.responsibilityId ? `responsibility_id=${turn.replyContext.responsibilityId}` : null,
-    turn.replyContext.routeType ? `route_type=${turn.replyContext.routeType}` : null,
-    turn.replyContext.ackType ? `ack_type=${turn.replyContext.ackType}` : null,
-    turn.replyContext.replyMode ? `reply_mode=${turn.replyContext.replyMode}` : null,
-    "If the route feels ambiguous or a routing skill misses, stay reply-first / ack_plus_reply and do not start repo or code analysis by default.",
-    "When you send the formal dispatch business ack in your visible response, include exactly one raw key=value block (no markdown code fence) using this shape:",
-    `ack_version=${persistence.HAPPY_ORG_REPLY_ACK_VERSION}`,
-    `dispatch_id=${turn.replyContext.dispatchId}`,
-    turn.replyContext.organizationId ? `organization_id=${turn.replyContext.organizationId}` : null,
-    turn.replyContext.taskId ? `task_id=${turn.replyContext.taskId}` : null,
-    `scope=${turn.replyContext.scope}`,
-    `member_agent_id=${turn.replyContext.memberAgentId ?? turn.context.memberAgentId}`,
-    turn.replyContext.sessionId ? `session_id=${turn.replyContext.sessionId}` : null,
-    turn.replyContext.positionId ? `position_id=${turn.replyContext.positionId}` : null,
-    turn.replyContext.responsibilityId ? `responsibility_id=${turn.replyContext.responsibilityId}` : null,
-    `route_type=${turn.replyContext.routeType ?? "ack_plus_reply"}`,
-    `ack_type=${turn.replyContext.ackType ?? "dispatch_ack"}`,
-    `reply_mode=${turn.replyContext.replyMode ?? "reply-first"}`,
-    `task_ack=${turn.context.taskId}`,
-    "read_ack=yes",
-    "status=accepted | standby | blocked",
-    "note=<short note>",
-    "Keep dispatch_id / task_id / position_id / responsibility_id stable across the visible ack, visible reply, and final turn report.",
-    "When turnStatus=task_complete and reply context exists, include a short source reply for the original requester at reply_to before the final JSON block.",
-    "That source reply / acceptance handoff mini-pack should explicitly mention position_status, latest_user_visible_result, blocker_summary, and acceptance_state=awaiting_acceptance.",
-    "Use acceptance_state=closed only after CEO or the original requester actually confirms close; do not self-mark closed."
-  ].filter(Boolean) : [];
-  const specialistHomeLines = turn.specialistHome ? [
-    "",
-    "Reply from this specialist home identity when applicable:",
-    `home_slug=${turn.specialistHome.homeSlug}`,
-    turn.specialistHome.happySessionId ? `happy_session_id=${turn.specialistHome.happySessionId}` : null,
-    turn.specialistHome.machineId ? `machine_id=${turn.specialistHome.machineId}` : null
-  ].filter(Boolean) : [];
-  const header = [
-    "[HAPPY_ORG_TASK_CONTEXT]",
-    `taskId=${turn.context.taskId}`,
-    `organizationId=${turn.context.organizationId}`,
-    turn.context.organizationRootPath ? `organizationRootPath=${turn.context.organizationRootPath}` : null,
-    `memberAgentId=${turn.context.memberAgentId}`,
-    `supervisorAgentId=${turn.context.supervisorAgentId}`,
-    turn.context.positionId ? `positionId=${turn.context.positionId}` : null,
-    turn.context.responsibilityId ? `responsibilityId=${turn.context.responsibilityId}` : null,
-    "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:",
-    `<${persistence.HAPPY_ORG_TURN_REPORT_TAG}>{"turnStatus":"turn_update","summary":"short task-board summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null,"accessChannelState":"ok"}</${persistence.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.",
-    "Allowed accessChannelState values: ok, reattach_required, runtime_replaced.",
-    "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.",
-    "targetArtifact must be null or a concrete previewable file target. Use a repo-relative path, absolute path, file:// URL, or https:// URL when you actually produced a material or artifact the client should open directly.",
-    "Do not use abstract labels like release-checklist-template or completion-board-template in targetArtifact.",
-    `summary must fit on a one-line CEO card or task-board card: short, actionable, no long process logs, max ${persistence.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,
-    ...replyContextLines,
-    ...specialistHomeLines,
-    "[/HAPPY_ORG_TASK_CONTEXT]",
-    "",
-    prompt
-  ].filter(Boolean);
-  return header.join("\n");
-}
-function resolveHappyOrgQueuedTurn(opts) {
-  const metadata = opts.metadata ?? null;
   if (!metadata) {
     return {
       nextMetadata: null,
-      queuedTurn: null,
-      blocked: false
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "missing_metadata",
+        diagnostic: "Happy Org dispatch ack ignored: session metadata is unavailable."
+      }
     };
   }
+  const envelope = candidate.envelope;
   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}`);
-  const specialistHome = buildSpecialistHomeIdentity({
-    metadata,
-    sessionId: opts.sessionId,
-    fallback: currentHappyOrg.specialistHome
-  });
-  nextHappyOrg.specialistHome = cloneHappyOrgSpecialistHomeIdentity(specialistHome);
-  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
-          )
-        };
+  const replyContext = cloneHappyOrgReplyContext(opts.queuedTurn?.replyContext) ?? cloneHappyOrgReplyContext(currentHappyOrg.replyContext);
+  if (!replyContext) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "missing_reply_context",
+        diagnostic: `Happy Org dispatch ack ignored: no active reply context matches dispatch ${envelope.dispatchId}.`
       }
-      nextHappyOrg = resetHappyOrgRuntimeForTask(messageHappyOrg.taskContext, specialistHome);
-    } else {
-      nextHappyOrg.taskContext = { ...messageHappyOrg.taskContext };
-    }
-  }
-  const taskContext = nextHappyOrg.taskContext ?? null;
-  const replyContext = resolveReplyContextFromMessage(opts.message, taskContext);
-  if (replyContext) {
-    nextHappyOrg.replyContext = replyContext;
-  } else if (!taskContext || currentHappyOrg.taskContext?.taskId !== taskContext.taskId) {
-    nextHappyOrg.replyContext = null;
+    };
   }
+  const taskContext = opts.queuedTurn?.context ?? currentHappyOrg.taskContext ?? null;
   if (!taskContext) {
     return {
       nextMetadata: metadata,
-      queuedTurn: null,
-      blocked: false
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "missing_task_context",
+        diagnostic: `Happy Org dispatch ack ignored: no active task context matches dispatch ${envelope.dispatchId}.`
+      }
     };
   }
-  const control = messageHappyOrg?.control;
-  if (control?.action === "terminate") {
-    nextHappyOrg.runtime = {
-      status: "terminated",
-      reason: normalizeOptionalText(control.reason) ?? "terminated_by_supervisor",
-      terminatedAt: now
-    };
-    nextHappyOrg.activeOwner = null;
+  if (envelope.dispatchId !== replyContext.dispatchId) {
     return {
-      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
-      queuedTurn: null,
-      blocked: true,
-      statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "dispatch_id_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: dispatch_id ${envelope.dispatchId} does not match active dispatch ${replyContext.dispatchId}.`
+      }
     };
   }
-  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 (envelope.scope !== replyContext.scope) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "scope_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: scope ${envelope.scope} does not match active scope ${replyContext.scope}.`
+      }
     };
   }
-  if (!nextHappyOrg.activeOwner) {
-    nextHappyOrg.activeOwner = {
-      ownerAgentId: taskContext.memberAgentId,
-      ownerRunId: createRunId(taskContext, now),
-      claimedAt: now
-    };
-  } else if (nextHappyOrg.activeOwner.ownerAgentId !== taskContext.memberAgentId) {
+  if (envelope.taskAck !== taskContext.taskId) {
     return {
-      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
-      queuedTurn: null,
-      blocked: true,
-      statusMessage: buildOwnerConflictStatusMessage(
-        taskContext.taskId,
-        nextHappyOrg.activeOwner.ownerAgentId
-      )
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "task_ack_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: task_ack ${envelope.taskAck} does not match active task ${taskContext.taskId}.`
+      }
     };
   }
-  return {
-    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
-    queuedTurn: {
-      context: taskContext,
-      ...reopenContext ? { reopenContext } : {},
-      replyContext: cloneHappyOrgReplyContext(nextHappyOrg.replyContext),
-      specialistHome: cloneHappyOrgSpecialistHomeIdentity(nextHappyOrg.specialistHome)
-    },
-    blocked: false
-  };
-}
-function finalizeHappyOrgTurn(opts) {
-  const metadata = opts.metadata ?? null;
-  const queuedTurn = opts.queuedTurn ?? null;
-  const { cleanedText, draft } = extractTaggedTurnReport(opts.responseText);
-  if (!metadata || !queuedTurn) {
+  if (envelope.organizationId && envelope.organizationId !== taskContext.organizationId) {
     return {
-      cleanedText,
-      report: null,
-      nextMetadata: metadata
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "organization_id_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: organization_id ${envelope.organizationId} does not match active organization ${taskContext.organizationId}.`
+      }
     };
   }
-  const now = opts.now?.() ?? Date.now();
-  const normalizedDraft = normalizeTurnReportDraft(draft);
-  const reportTurnStatus = resolveReportedTurnStatus(opts.turnStatus, normalizedDraft);
-  const currentHappyOrg = normalizeHappyOrgMetadata(metadata);
-  const resolvedReplyContext = cloneHappyOrgReplyContext(queuedTurn.replyContext) ?? cloneHappyOrgReplyContext(currentHappyOrg.replyContext);
-  const resolvedSpecialistHome = cloneHappyOrgSpecialistHomeIdentity(queuedTurn.specialistHome) ?? cloneHappyOrgSpecialistHomeIdentity(currentHappyOrg.specialistHome);
-  const acceptanceHandoffCandidate = resolveHappyOrgAcceptanceHandoffCandidate(cleanedText);
-  const acceptanceHandoff = acceptanceHandoffCandidate.outcome === "valid" && acceptanceHandoffCandidate.handoff.taskId === queuedTurn.context.taskId && (!resolvedReplyContext || acceptanceHandoffCandidate.handoff.dispatchId === resolvedReplyContext.dispatchId) ? acceptanceHandoffCandidate.handoff : null;
-  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,
-    accessChannelState: normalizedDraft.accessChannelState ?? "ok",
-    repeatFingerprint: buildRepeatFingerprint(
-      queuedTurn.context,
-      normalizedDraft.blockerCode ?? null,
-      normalizedDraft.targetArtifact ?? null
-    ),
-    replyContext: resolvedReplyContext,
-    specialistHome: resolvedSpecialistHome,
-    ...acceptanceHandoff ? { acceptanceHandoff } : {}
-  };
-  const nextHappyOrg = currentHappyOrg;
-  nextHappyOrg.taskContext = { ...queuedTurn.context };
-  nextHappyOrg.lastTurnReport = report;
-  nextHappyOrg.activeOwner = null;
-  nextHappyOrg.replyContext = resolvedReplyContext;
-  nextHappyOrg.specialistHome = resolvedSpecialistHome;
-  nextHappyOrg.repeat = nextHappyOrg.repeat ?? {
-    threshold: persistence.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 (envelope.taskId && envelope.taskId !== taskContext.taskId) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "task_id_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: task_id ${envelope.taskId} does not match active task ${taskContext.taskId}.`
+      }
     };
-    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
-  };
-}
-async function finalizeHappyOrgTurnWithBusinessAck(opts) {
-  const finalizedTurn = finalizeHappyOrgTurn({
-    metadata: opts.metadata,
-    queuedTurn: opts.queuedTurn,
-    responseText: opts.responseText,
-    turnStatus: opts.turnStatus,
-    now: opts.now
-  });
-  const dispatchAckResult = await maybeSubmitHappyOrgDispatchBusinessAck({
-    metadata: finalizedTurn.nextMetadata,
-    queuedTurn: opts.queuedTurn,
-    responseText: finalizedTurn.cleanedText,
-    now: opts.now,
-    submitDispatchAck: opts.submitDispatchAck
-  });
-  return {
-    ...finalizedTurn,
-    nextMetadata: dispatchAckResult.nextMetadata,
-    dispatchAck: dispatchAckResult.dispatchAck
-  };
-}
-
-const DEFAULT_MAX_MESSAGES = 200;
-const DEFAULT_MAX_CHARACTERS = 1e5;
-const DEFAULT_MAX_MESSAGE_CHARACTERS = 8e3;
-const TRUNCATION_PREFIX = "...\n";
-class MessageBuffer {
-  messages = [];
-  listeners = [];
-  nextId = 1;
-  enabled;
-  maxMessages;
-  maxCharacters;
-  maxMessageCharacters;
-  constructor(options = {}) {
-    this.enabled = options.enabled ?? true;
-    this.maxMessages = Math.max(1, options.maxMessages ?? DEFAULT_MAX_MESSAGES);
-    this.maxCharacters = Math.max(1, options.maxCharacters ?? DEFAULT_MAX_CHARACTERS);
-    this.maxMessageCharacters = Math.max(1, options.maxMessageCharacters ?? DEFAULT_MAX_MESSAGE_CHARACTERS);
-  }
-  addMessage(content, type = "assistant") {
-    const id = `msg-${this.nextId++}`;
-    if (!this.enabled) {
-      return id;
-    }
-    const message = {
-      id,
-      timestamp: /* @__PURE__ */ new Date(),
-      content: this.normalizeContent(content),
-      type
+  if (envelope.memberAgentId && envelope.memberAgentId !== taskContext.memberAgentId) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "member_agent_id_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: member_agent_id ${envelope.memberAgentId} does not match active member ${taskContext.memberAgentId}.`
+      }
     };
-    this.messages.push(message);
-    this.trimMessages();
-    this.notifyListeners();
-    return message.id;
   }
-  updateMessage(id, content, options = {}) {
-    if (!this.enabled) {
-      return false;
-    }
-    const index = this.messages.findIndex((message) => message.id === id);
-    if (index === -1) {
-      return false;
-    }
-    const normalizedContent = this.normalizeContent(content);
-    const previous = this.messages[index];
-    this.messages[index] = {
-      ...previous,
-      content: this.truncateContent(options.mode === "replace" ? normalizedContent : previous.content + normalizedContent)
+  if (replyContext.positionId && envelope.positionId && envelope.positionId !== replyContext.positionId) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "position_id_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: position_id ${envelope.positionId} does not match active position ${replyContext.positionId}.`
+      }
     };
-    this.trimMessages();
-    this.notifyListeners();
-    return true;
   }
-  removeMessage(id) {
-    if (!this.enabled) {
-      return false;
-    }
-    const index = this.messages.findIndex((message) => message.id === id);
-    if (index === -1) {
-      return false;
-    }
-    this.messages.splice(index, 1);
-    this.notifyListeners();
-    return true;
+  if (replyContext.responsibilityId && envelope.responsibilityId && envelope.responsibilityId !== replyContext.responsibilityId) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "responsibility_id_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: responsibility_id ${envelope.responsibilityId} does not match active responsibility ${replyContext.responsibilityId}.`
+      }
+    };
   }
-  /**
-   * Update the last message of a specific type by appending content to it
-   * Useful for streaming responses where deltas should accumulate in one message
-   */
-  updateLastMessage(contentDelta, type = "assistant") {
-    if (!this.enabled) {
-      return;
-    }
-    const normalizedDelta = this.normalizeContent(contentDelta);
-    for (let i = this.messages.length - 1; i >= 0; i--) {
-      if (this.messages[i].type === type) {
-        const oldMessage = this.messages[i];
-        const updatedMessage = {
-          ...oldMessage,
-          content: this.truncateContent(oldMessage.content + normalizedDelta)
-        };
-        this.messages[i] = updatedMessage;
-        this.trimMessages();
-        this.notifyListeners();
-        return;
+  if (replyContext.routeType && envelope.routeType && envelope.routeType !== replyContext.routeType) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "route_type_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: route_type ${envelope.routeType} does not match active route ${replyContext.routeType}.`
       }
-    }
-    this.addMessage(normalizedDelta, type);
+    };
   }
-  /**
-   * Remove the last message of a specific type
-   * Useful for removing placeholder messages like "Thinking..." when actual response starts
-   */
-  removeLastMessage(type) {
-    if (!this.enabled) {
-      return false;
-    }
-    for (let i = this.messages.length - 1; i >= 0; i--) {
-      if (this.messages[i].type === type) {
-        this.messages.splice(i, 1);
-        this.notifyListeners();
-        return true;
+  if (replyContext.ackType && envelope.ackType && envelope.ackType !== replyContext.ackType) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "ack_type_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: ack_type ${envelope.ackType} does not match active ack_type ${replyContext.ackType}.`
       }
-    }
-    return false;
+    };
   }
-  getMessages() {
-    return [...this.messages];
+  if (replyContext.replyMode && envelope.replyMode && envelope.replyMode !== replyContext.replyMode) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "invalid",
+        reason: "reply_mode_mismatch",
+        diagnostic: `Happy Org dispatch ack ignored: reply_mode ${envelope.replyMode} does not match active reply_mode ${replyContext.replyMode}.`
+      }
+    };
   }
-  clear() {
-    this.messages = [];
-    this.nextId = 1;
-    if (!this.enabled) {
-      return;
-    }
-    this.notifyListeners();
+  const existingAck = currentHappyOrg.dispatchAcks?.[envelope.dispatchId];
+  if (existingAck) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "duplicate",
+        reason: "already_submitted",
+        diagnostic: `Happy Org dispatch ack skipped: dispatch ${envelope.dispatchId} was already acknowledged as ${existingAck.status}.`
+      }
+    };
   }
-  onUpdate(listener) {
-    if (!this.enabled) {
-      return () => {
-      };
-    }
-    this.listeners.push(listener);
-    return () => {
-      const index = this.listeners.indexOf(listener);
-      if (index > -1) {
-        this.listeners.splice(index, 1);
+  if (!opts.submitDispatchAck) {
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "error",
+        reason: "submit_callback_unavailable",
+        diagnostic: `Happy Org dispatch ack could not be submitted for ${envelope.dispatchId}: no submit callback is available.`
       }
     };
   }
-  normalizeContent(content) {
-    return this.truncateContent(index.formatDisplayMessage(content));
+  try {
+    await opts.submitDispatchAck({
+      organizationId: taskContext.organizationId,
+      dispatchId: envelope.dispatchId,
+      memberAgentId: taskContext.memberAgentId,
+      scope: envelope.scope,
+      readAck: envelope.readAck,
+      taskAck: envelope.taskAck,
+      status: envelope.status,
+      note: envelope.note
+    });
+    return {
+      nextMetadata: recordHappyOrgDispatchAck(
+        metadata,
+        envelope,
+        opts.now?.() ?? Date.now()
+      ),
+      dispatchAck: {
+        outcome: "submitted",
+        reason: "submitted",
+        diagnostic: null
+      }
+    };
+  } catch (error) {
+    const diagnostic = `Happy Org dispatch ack failed for ${envelope.dispatchId}: ${normalizeDispatchAckError(error)}.`;
+    persistence.logger.debug("[HappyOrg] Dispatch ack submission failed", {
+      dispatchId: envelope.dispatchId,
+      error
+    });
+    return {
+      nextMetadata: metadata,
+      dispatchAck: {
+        outcome: "error",
+        reason: "submit_failed",
+        diagnostic
+      }
+    };
   }
-  truncateContent(content) {
-    if (content.length <= this.maxMessageCharacters) {
-      return content;
-    }
-    const tailLength = Math.max(0, this.maxMessageCharacters - TRUNCATION_PREFIX.length);
-    return `${TRUNCATION_PREFIX}${content.slice(content.length - tailLength)}`;
+}
+function deriveHomeSlug(path$1) {
+  if (!path$1) {
+    return null;
   }
-  trimMessages() {
-    while (this.messages.length > this.maxMessages) {
-      this.messages.shift();
-    }
-    let totalCharacters = this.messages.reduce((sum, message) => sum + message.content.length, 0);
-    while (totalCharacters > this.maxCharacters && this.messages.length > 1) {
-      const removed = this.messages.shift();
-      if (removed) {
-        totalCharacters -= removed.content.length;
-      }
-    }
+  const trimmedPath = path$1.trim().replace(/[\\/]+$/, "");
+  if (!trimmedPath) {
+    return null;
   }
-  notifyListeners() {
-    const messages = this.getMessages();
-    this.listeners.forEach((listener) => listener(messages));
+  return path.basename(trimmedPath) || trimmedPath;
+}
+function buildSpecialistHomeIdentity(opts) {
+  const metadata = opts.metadata ?? null;
+  const fallback = opts.fallback ?? null;
+  const path = normalizeOptionalText(metadata?.path) ?? fallback?.path ?? null;
+  const homeSlug = deriveHomeSlug(path) ?? fallback?.homeSlug ?? null;
+  if (!homeSlug) {
+    return fallback ? { ...fallback } : null;
   }
+  return {
+    homeSlug,
+    path,
+    happySessionId: normalizeOptionalText(opts.sessionId) ?? fallback?.happySessionId ?? null,
+    machineId: normalizeOptionalText(metadata?.machineId) ?? fallback?.machineId ?? null,
+    startedBy: metadata?.startedBy ?? fallback?.startedBy ?? null,
+    flavor: normalizeOptionalText(metadata?.flavor) ?? fallback?.flavor ?? null
+  };
 }
-
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function withDefaultReplyRouting(replyContext) {
+  return {
+    ...replyContext,
+    routeType: replyContext.routeType ?? "ack_plus_reply",
+    ackType: replyContext.ackType ?? "dispatch_ack",
+    replyMode: replyContext.replyMode ?? "reply-first"
+  };
 }
-function hasClaudeCompatibilityShadow(value) {
-  if (!isRecord(value)) {
-    return false;
+function resolveReplyContextFromMessage(message, taskContext) {
+  const metaReplyContext = message.meta?.happyOrg?.replyContext;
+  if (metaReplyContext?.dispatchId && metaReplyContext.scope && metaReplyContext.replyTo) {
+    return withDefaultReplyRouting({
+      dispatchId: metaReplyContext.dispatchId,
+      taskId: metaReplyContext.taskId ?? taskContext?.taskId ?? null,
+      organizationId: metaReplyContext.organizationId ?? taskContext?.organizationId ?? null,
+      scope: metaReplyContext.scope,
+      replyTo: metaReplyContext.replyTo,
+      memberAgentId: metaReplyContext.memberAgentId ?? taskContext?.memberAgentId ?? null,
+      sessionId: metaReplyContext.sessionId ?? null,
+      positionId: metaReplyContext.positionId ?? taskContext?.positionId ?? null,
+      responsibilityId: metaReplyContext.responsibilityId ?? taskContext?.responsibilityId ?? null,
+      routeType: metaReplyContext.routeType ?? null,
+      ackType: metaReplyContext.ackType ?? null,
+      replyMode: metaReplyContext.replyMode ?? null,
+      planIntent: metaReplyContext.planIntent ?? null,
+      routerReason: metaReplyContext.routerReason ?? null,
+      goldenRouteId: metaReplyContext.goldenRouteId ?? null
+    });
   }
-  if (typeof value.happyCompatibilityShadow === "string" && value.happyCompatibilityShadow.trim()) {
-    return true;
+  const fields = parseHappyOrgEnvelopeFields(message.content.text);
+  const dispatchId = normalizeOptionalText(fields.dispatch_id);
+  const scope = normalizeOptionalText(fields.scope);
+  const replyTo = normalizeOptionalText(fields.reply_to);
+  const taskId = normalizeOptionalText(fields.task_id);
+  if (!dispatchId || !scope || !replyTo) {
+    return null;
   }
-  const message = value.message;
-  if (!isRecord(message) || !Array.isArray(message.content)) {
-    return false;
+  if (taskId && taskContext?.taskId && taskId !== taskContext.taskId) {
+    return null;
   }
-  return message.content.some((block) => isRecord(block) && typeof block.happyCompatibilityShadow === "string" && block.happyCompatibilityShadow.trim().length > 0);
+  return withDefaultReplyRouting({
+    dispatchId,
+    taskId: taskId ?? taskContext?.taskId ?? null,
+    organizationId: normalizeOptionalText(fields.organization_id) ?? taskContext?.organizationId ?? null,
+    scope,
+    replyTo,
+    memberAgentId: normalizeOptionalText(fields.member_agent_id) ?? normalizeOptionalText(fields.agent_id) ?? taskContext?.memberAgentId ?? null,
+    sessionId: normalizeOptionalText(fields.session_id),
+    positionId: normalizeOptionalText(fields.position_id) ?? taskContext?.positionId ?? null,
+    responsibilityId: normalizeOptionalText(fields.responsibility_id) ?? taskContext?.responsibilityId ?? null,
+    routeType: normalizeRouteType(fields.route_type),
+    ackType: normalizeAckType(fields.ack_type),
+    replyMode: normalizeReplyMode(fields.reply_mode),
+    planIntent: normalizeOptionalText(fields.plan_intent),
+    routerReason: normalizeOptionalText(fields.router_reason),
+    goldenRouteId: normalizeOptionalText(fields.golden_route_id)
+  });
 }
-function createSessionTranscriptInkRenderer(opts) {
-  const streamedAssistantMessages = /* @__PURE__ */ new Map();
-  const renderBufferedText = (text, type, streamMetadata) => {
-    const normalizedText = text.trim();
-    if (!normalizedText) {
-      return;
-    }
-    const streamKey = typeof streamMetadata?.messageId === "string" ? streamMetadata.messageId : typeof streamMetadata?.id === "string" ? streamMetadata.id : null;
-    const phase = typeof streamMetadata?.phase === "string" ? streamMetadata.phase : null;
-    const updateMode = streamMetadata?.mode === "replace" || phase === "commit" ? "replace" : "append";
-    if (phase === "abort") {
-      if (streamKey) {
-        const bufferedId = streamedAssistantMessages.get(streamKey);
-        if (bufferedId) {
-          opts.messageBuffer.removeMessage(bufferedId);
-          streamedAssistantMessages.delete(streamKey);
-        }
-      }
-      return;
-    }
-    if (!streamKey) {
-      opts.messageBuffer.addMessage(normalizedText, type);
-      return;
-    }
-    const existingBufferedId = streamedAssistantMessages.get(streamKey);
-    if (!existingBufferedId) {
-      const nextBufferedId = opts.messageBuffer.addMessage(normalizedText, type);
-      if (phase !== "commit") {
-        streamedAssistantMessages.set(streamKey, nextBufferedId);
-      }
-      return;
-    }
-    const updated = opts.messageBuffer.updateMessage(existingBufferedId, normalizedText, {
-      mode: updateMode
-    });
-    if (!updated) {
-      const nextBufferedId = opts.messageBuffer.addMessage(normalizedText, type);
-      if (phase !== "commit") {
-        streamedAssistantMessages.set(streamKey, nextBufferedId);
-      }
-      return;
-    }
-    if (phase === "commit") {
-      streamedAssistantMessages.delete(streamKey);
-    }
-  };
-  const renderStructuredAgentPayload = (payload) => {
-    if (!isRecord(payload) || typeof payload.type !== "string") {
-      return;
-    }
-    switch (payload.type) {
-      case "message":
-      case "reasoning": {
-        if (typeof payload.message !== "string") {
-          return;
-        }
-        renderBufferedText(
-          payload.message,
-          payload.type === "reasoning" ? "status" : "assistant",
-          payload
-        );
-        return;
-      }
-      case "thinking": {
-        if (typeof payload.text === "string" && payload.text.trim()) {
-          opts.messageBuffer.addMessage(`[Thinking] ${payload.text.trim()}`, "status");
-        }
-        return;
-      }
-      case "tool-call": {
-        const name = typeof payload.name === "string" ? payload.name : typeof payload.toolName === "string" ? payload.toolName : "tool";
-        const inputPreview = index.truncateDisplayMessage(
-          isRecord(payload.input) || Array.isArray(payload.input) ? JSON.stringify(payload.input) : payload.input,
-          120
-        );
-        opts.messageBuffer.addMessage(
-          `Executing: ${name}${inputPreview ? ` ${inputPreview}` : ""}`,
-          "tool"
-        );
-        return;
-      }
-      case "tool-result":
-      case "tool-call-result": {
-        const resultValue = Object.prototype.hasOwnProperty.call(payload, "output") ? payload.output : payload.result;
-        const resultPreview = index.truncateDisplayMessage(resultValue, 200);
-        const prefix = payload.isError ? "Error:" : "Result:";
-        opts.messageBuffer.addMessage(
-          resultPreview ? `${prefix} ${resultPreview}` : "Tool completed",
-          payload.isError ? "status" : "result"
-        );
-        return;
-      }
-      case "file-edit":
-      case "fs-edit": {
-        const description = typeof payload.description === "string" ? payload.description : "File edit";
-        opts.messageBuffer.addMessage(`File edit: ${description}`, "tool");
-        return;
-      }
-      case "terminal-output": {
-        if (typeof payload.data !== "string") {
-          return;
-        }
-        const preview = renderTerminalOutputPreview(payload.data);
-        if (preview) {
-          opts.messageBuffer.addMessage(preview, "result");
-        }
-        return;
-      }
-      case "permission-request": {
-        const toolName = typeof payload.toolName === "string" ? payload.toolName : "tool";
-        opts.messageBuffer.addMessage(`Permission requested: ${toolName}`, "status");
-        return;
-      }
-      case "exec-approval-request": {
-        opts.messageBuffer.addMessage("Exec approval requested", "status");
-        return;
-      }
-      case "patch-apply-begin": {
-        opts.messageBuffer.addMessage("Applying patch...", "tool");
-        return;
-      }
-      case "patch-apply-end": {
-        const completionMessage = payload.success === false ? index.truncateDisplayMessage(payload.stderr, 200) || "Patch failed" : index.truncateDisplayMessage(payload.stdout, 200) || "Patch applied";
-        opts.messageBuffer.addMessage(completionMessage, payload.success === false ? "status" : "result");
-        return;
-      }
-      case "event": {
-        if (payload.name === "thinking" && isRecord(payload.payload) && typeof payload.payload.text === "string" && payload.payload.text.trim()) {
-          opts.messageBuffer.addMessage(`[Thinking] ${payload.payload.text.trim()}`, "status");
-        }
-        return;
-      }
-      case "task_started":
-      case "task_complete":
-      case "turn_aborted":
-      case "turn-report":
-      case "token_count":
-      case "token-count":
-        return;
-      default:
-        return;
-    }
-  };
-  const renderLegacyClaudeOutput = (payload) => {
-    if (!isRecord(payload) || hasClaudeCompatibilityShadow(payload)) {
-      return;
-    }
-    if (payload.type === "summary" && typeof payload.summary === "string" && payload.summary.trim()) {
-      opts.messageBuffer.addMessage(payload.summary.trim(), "result");
-      return;
-    }
-    if (payload.type !== "assistant") {
-      return;
-    }
-    const message = isRecord(payload.message) ? payload.message : null;
-    const content = message?.content;
-    if (typeof content === "string" && content.trim()) {
-      opts.messageBuffer.addMessage(content.trim(), "assistant");
-      return;
-    }
-    if (!Array.isArray(content)) {
-      return;
-    }
-    for (const block of content) {
-      if (!isRecord(block) || typeof block.type !== "string") {
-        continue;
-      }
-      if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim()) {
-        opts.messageBuffer.addMessage(`[Thinking] ${block.thinking.trim()}`, "status");
-        continue;
-      }
-      if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
-        opts.messageBuffer.addMessage(block.text.trim(), "assistant");
-        continue;
-      }
-      if (block.type === "tool_use") {
-        const toolName = typeof block.name === "string" ? block.name : "tool";
-        const inputPreview = index.truncateDisplayMessage(
-          isRecord(block.input) || Array.isArray(block.input) ? JSON.stringify(block.input) : block.input,
-          120
-        );
-        opts.messageBuffer.addMessage(
-          `Executing: ${toolName}${inputPreview ? ` ${inputPreview}` : ""}`,
-          "tool"
-        );
-      }
-    }
-  };
-  const renderSessionEvent = (payload) => {
-    if (!isRecord(payload) || typeof payload.type !== "string") {
-      return;
-    }
-    switch (payload.type) {
-      case "message":
-        if (typeof payload.message === "string" && payload.message.trim()) {
-          opts.messageBuffer.addMessage(payload.message.trim(), "status");
-        }
-        return;
-      case "switch":
-        if (payload.mode === "local" || payload.mode === "remote") {
-          opts.messageBuffer.addMessage(`Mode switched to ${payload.mode}`, "status");
-        }
-        return;
-      case "permission-mode-changed":
-        if (typeof payload.mode === "string" && payload.mode.trim()) {
-          opts.messageBuffer.addMessage(`Permission mode: ${payload.mode}`, "status");
-        }
-        return;
-      case "ready":
-        return;
-      default:
-        return;
-    }
-  };
-  return (transcriptMessage) => {
-    if (transcriptMessage.message.role === "user") {
-      const text = transcriptMessage.message.content.text.trim();
-      if (text) {
-        opts.messageBuffer.addMessage(text, "user");
-      }
-      return;
-    }
-    switch (transcriptMessage.message.content.type) {
-      case "output":
-        renderLegacyClaudeOutput(transcriptMessage.message.content.data);
-        return;
-      case "codex":
-        renderStructuredAgentPayload(transcriptMessage.message.content.data);
-        return;
-      case "acp":
-        renderStructuredAgentPayload(transcriptMessage.message.content.data);
-        return;
-      case "event":
-        renderSessionEvent(transcriptMessage.message.content.data);
-        return;
-      default:
-        opts.messageBuffer.addMessage(index.formatDisplayMessage(transcriptMessage.message), "status");
-    }
+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, persistence.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: persistence.normalizePreviewableArtifactTarget(draft?.targetArtifact),
+    accessChannelState: normalizeAccessChannelState(draft?.accessChannelState)
   };
 }
-
-let ConversationHistory$1 = class ConversationHistory {
-  messages = [];
-  maxMessages;
-  maxCharacters;
-  constructor(options = {}) {
-    this.maxMessages = options.maxMessages ?? 20;
-    this.maxCharacters = options.maxCharacters ?? 5e4;
-  }
-  isDuplicate(role, content) {
-    if (this.messages.length === 0) {
-      return false;
-    }
-    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
-      const message = this.messages[index];
-      if (message.role !== role) {
-        continue;
-      }
-      const normalizedIncoming = content.trim().replace(/\s+/g, " ");
-      const normalizedExisting = message.content.replace(/\s+/g, " ");
-      return normalizedIncoming === normalizedExisting;
-    }
-    return false;
-  }
-  addUserMessage(content) {
-    this.addMessage("user", content);
-  }
-  addAssistantMessage(content) {
-    this.addMessage("assistant", content);
-  }
-  hasHistory() {
-    return this.messages.length > 0;
-  }
-  size() {
-    return this.messages.length;
-  }
-  clear() {
-    this.messages = [];
-    persistence.logger.debug("[ConversationHistory] History cleared");
-  }
-  getContextForNewSession(prefixMessage = "Continue from the prior session using the conversation below as context.") {
-    if (this.messages.length === 0) {
-      return "";
-    }
-    const formattedMessages = this.messages.map((message) => {
-      const role = message.role === "user" ? "User" : "Assistant";
-      const content = message.content.length > 2e3 ? `${message.content.slice(0, 2e3)}... [truncated]` : message.content;
-      return `${role}: ${content}`;
-    }).join("\n\n");
-    return [
-      "[PREVIOUS CONVERSATION CONTEXT]",
-      prefixMessage,
-      "",
-      formattedMessages,
-      "",
-      "[END OF PREVIOUS CONTEXT]",
-      ""
-    ].join("\n");
-  }
-  getSummary() {
-    const totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
-    const userCount = this.messages.filter((message) => message.role === "user").length;
-    const assistantCount = this.messages.filter((message) => message.role === "assistant").length;
-    return `${this.messages.length} messages (${userCount} user, ${assistantCount} assistant), ${totalChars} chars`;
-  }
-  addMessage(role, content) {
-    const trimmedContent = content.trim();
-    if (!trimmedContent) {
-      return;
-    }
-    if (this.isDuplicate(role, trimmedContent)) {
-      persistence.logger.debug(`[ConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
-      return;
-    }
-    this.messages.push({
-      role,
-      content: trimmedContent,
-      timestamp: Date.now()
-    });
-    this.trimHistory();
-    persistence.logger.debug(`[ConversationHistory] Added ${role} message (${trimmedContent.length} chars), total: ${this.messages.length}`);
+function stripCodeFence(text) {
+  return text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+}
+function extractTaggedTurnReport(text) {
+  const matcher = new RegExp(
+    `<${persistence.HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${persistence.HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "gi"
+  );
+  let lastMatch = null;
+  for (let match = matcher.exec(text); match; match = matcher.exec(text)) {
+    lastMatch = match;
   }
-  trimHistory() {
-    while (this.messages.length > this.maxMessages) {
-      this.messages.shift();
-    }
-    let totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
-    while (totalChars > this.maxCharacters && this.messages.length > 1) {
-      const removed = this.messages.shift();
-      if (removed) {
-        totalChars -= removed.content.length;
-      }
-    }
+  if (!lastMatch) {
+    return {
+      cleanedText: text.trim(),
+      draft: null
+    };
   }
-};
-
-const INTERACTION_SUPERSEDED_ERROR = "Interaction superseded by new user message";
-const INTERACTION_TIMED_OUT_ERROR = "Interaction timed out waiting for user response";
-const DEFAULT_INTERACTION_TIMEOUT_MS = 2 * 60 * 1e3;
-function getPendingInteractionTimeoutMs() {
-  const raw = Number(process.env.HAPPY_INTERACTION_TIMEOUT_MS);
-  if (Number.isFinite(raw) && raw > 0) {
-    return raw;
+  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: persistence.normalizePreviewableArtifactTarget(parsed.targetArtifact),
+      accessChannelState: normalizeAccessChannelState(parsed.accessChannelState)
+    };
+  } catch {
+    draft = null;
   }
-  return DEFAULT_INTERACTION_TIMEOUT_MS;
+  const cleanedText = `${text.slice(0, lastMatch.index)}${text.slice(lastMatch.index + lastMatch[0].length)}`.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    cleanedText,
+    draft
+  };
 }
-class BasePermissionHandler {
-  pendingRequests = /* @__PURE__ */ new Map();
-  session;
-  isResetting = false;
-  constructor(session) {
-    this.session = session;
-    this.setupRpcHandler();
-  }
-  /**
-   * Update the session reference (used after offline reconnection swaps sessions).
-   * This is critical for avoiding stale session references after onSessionSwap.
-   */
-  updateSession(newSession) {
-    persistence.logger.debug(`${this.getLogPrefix()} Session reference updated`);
-    this.session = newSession;
-    this.setupRpcHandler();
+function buildRepeatFingerprint(context, blockerCode, targetArtifact) {
+  if (!blockerCode) {
+    return null;
   }
-  /**
-   * Setup RPC handler for permission responses.
-   */
-  setupRpcHandler() {
-    this.session.rpcHandlerManager.registerHandler(
-      "permission",
-      async (response) => {
-        const pending = this.pendingRequests.get(response.id);
-        if (!pending) {
-          persistence.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
-          return;
-        }
-        this.pendingRequests.delete(response.id);
-        this.clearPendingRequestTimeout(pending);
-        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
-        pending.resolve(result);
-        this.session.updateAgentState((currentState) => {
-          const request = currentState.requests?.[response.id];
-          if (!request) return currentState;
-          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
-          let res = {
-            ...currentState,
-            requests: remainingRequests,
-            completedRequests: {
-              ...currentState.completedRequests,
-              [response.id]: {
-                ...request,
-                completedAt: Date.now(),
-                status: response.approved ? "approved" : "denied",
-                decision: result.decision
-              }
-            }
-          };
-          return res;
-        });
-        persistence.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
-      }
-    );
+  return [
+    context.taskId,
+    context.memberAgentId,
+    blockerCode,
+    targetArtifact ?? ""
+  ].join("::");
+}
+function resolveReportedTurnStatus(transportTurnStatus, draft) {
+  if (transportTurnStatus === "turn_aborted") {
+    return "turn_aborted";
   }
-  /**
-   * Add a pending request to the agent state.
-   */
-  addPendingRequestToState(toolCallId, toolName, input) {
-    this.session.updateAgentState((currentState) => ({
-      ...currentState,
-      requests: {
-        ...currentState.requests,
-        [toolCallId]: {
-          tool: toolName,
-          arguments: input,
-          createdAt: Date.now()
-        }
-      }
-    }));
+  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"
+    };
   }
-  registerPendingRequest(toolCallId, toolName, input, logSuffix = "") {
-    return new Promise((resolve, reject) => {
-      const pending = {
-        resolve,
-        reject,
-        toolName,
-        input
+  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
       };
-      pending.timeoutHandle = setTimeout(() => {
-        this.handlePendingRequestTimeout(toolCallId, pending);
-      }, getPendingInteractionTimeoutMs());
-      this.pendingRequests.set(toolCallId, pending);
-      this.addPendingRequestToState(toolCallId, toolName, input);
-      persistence.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})${logSuffix}`);
-    });
-  }
-  hasPendingRequests() {
-    return this.pendingRequests.size > 0;
   }
-  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
-    const pendingSnapshot = Array.from(this.pendingRequests.entries());
-    if (pendingSnapshot.length === 0) {
-      return 0;
-    }
-    this.pendingRequests.clear();
-    const completedAt = Date.now();
-    for (const [, pending] of pendingSnapshot) {
-      this.clearPendingRequestTimeout(pending);
-      pending.resolve({ decision: "abort" });
-    }
-    this.session.updateAgentState((currentState) => {
-      const requests = { ...currentState.requests || {} };
-      const completedRequests = { ...currentState.completedRequests || {} };
-      for (const [id, request] of Object.entries(requests)) {
-        if (request.requestKind === "selection") {
-          continue;
-        }
-        completedRequests[id] = {
-          ...request,
-          completedAt,
-          status: "denied",
-          reason,
-          decision: "abort",
-          requestKind: request.requestKind || "permission"
-        };
-        delete requests[id];
-      }
-      return {
-        ...currentState,
-        requests,
-        completedRequests
-      };
-    });
-    persistence.logger.debug(`${this.getLogPrefix()} Superseded ${pendingSnapshot.length} pending permission request(s)`);
-    return pendingSnapshot.length;
+}
+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 replyContextLines = turn.replyContext ? [
+    "",
+    "This turn also carries a formal dispatch reply context. If you acknowledge or update that dispatch, keep these values stable:",
+    `dispatch_id=${turn.replyContext.dispatchId}`,
+    turn.replyContext.organizationId ? `organization_id=${turn.replyContext.organizationId}` : null,
+    turn.replyContext.taskId ? `task_id=${turn.replyContext.taskId}` : null,
+    `scope=${turn.replyContext.scope}`,
+    `reply_to=${turn.replyContext.replyTo}`,
+    turn.replyContext.memberAgentId ? `member_agent_id=${turn.replyContext.memberAgentId}` : null,
+    turn.replyContext.sessionId ? `session_id=${turn.replyContext.sessionId}` : null,
+    turn.replyContext.positionId ? `position_id=${turn.replyContext.positionId}` : null,
+    turn.replyContext.responsibilityId ? `responsibility_id=${turn.replyContext.responsibilityId}` : null,
+    turn.replyContext.routeType ? `route_type=${turn.replyContext.routeType}` : null,
+    turn.replyContext.ackType ? `ack_type=${turn.replyContext.ackType}` : null,
+    turn.replyContext.replyMode ? `reply_mode=${turn.replyContext.replyMode}` : null,
+    "If the route feels ambiguous or a routing skill misses, stay reply-first / ack_plus_reply and do not start repo or code analysis by default.",
+    "When you send the formal dispatch business ack in your visible response, include exactly one raw key=value block (no markdown code fence) using this shape:",
+    `ack_version=${persistence.HAPPY_ORG_REPLY_ACK_VERSION}`,
+    `dispatch_id=${turn.replyContext.dispatchId}`,
+    turn.replyContext.organizationId ? `organization_id=${turn.replyContext.organizationId}` : null,
+    turn.replyContext.taskId ? `task_id=${turn.replyContext.taskId}` : null,
+    `scope=${turn.replyContext.scope}`,
+    `member_agent_id=${turn.replyContext.memberAgentId ?? turn.context.memberAgentId}`,
+    turn.replyContext.sessionId ? `session_id=${turn.replyContext.sessionId}` : null,
+    turn.replyContext.positionId ? `position_id=${turn.replyContext.positionId}` : null,
+    turn.replyContext.responsibilityId ? `responsibility_id=${turn.replyContext.responsibilityId}` : null,
+    `route_type=${turn.replyContext.routeType ?? "ack_plus_reply"}`,
+    `ack_type=${turn.replyContext.ackType ?? "dispatch_ack"}`,
+    `reply_mode=${turn.replyContext.replyMode ?? "reply-first"}`,
+    `task_ack=${turn.context.taskId}`,
+    "read_ack=yes",
+    "status=accepted | standby | blocked",
+    "note=<short note>",
+    "Keep dispatch_id / task_id / position_id / responsibility_id stable across the visible ack, visible reply, and final turn report.",
+    "When turnStatus=task_complete and reply context exists, include a short source reply for the original requester at reply_to before the final JSON block.",
+    "That source reply / acceptance handoff mini-pack should explicitly mention position_status, latest_user_visible_result, blocker_summary, and acceptance_state=awaiting_acceptance.",
+    "Use acceptance_state=closed only after CEO or the original requester actually confirms close; do not self-mark closed."
+  ].filter(Boolean) : [];
+  const specialistHomeLines = turn.specialistHome ? [
+    "",
+    "Reply from this specialist home identity when applicable:",
+    `home_slug=${turn.specialistHome.homeSlug}`,
+    turn.specialistHome.happySessionId ? `happy_session_id=${turn.specialistHome.happySessionId}` : null,
+    turn.specialistHome.machineId ? `machine_id=${turn.specialistHome.machineId}` : null
+  ].filter(Boolean) : [];
+  const header = [
+    "[HAPPY_ORG_TASK_CONTEXT]",
+    `taskId=${turn.context.taskId}`,
+    `organizationId=${turn.context.organizationId}`,
+    turn.context.organizationRootPath ? `organizationRootPath=${turn.context.organizationRootPath}` : null,
+    `memberAgentId=${turn.context.memberAgentId}`,
+    `supervisorAgentId=${turn.context.supervisorAgentId}`,
+    turn.context.positionId ? `positionId=${turn.context.positionId}` : null,
+    turn.context.responsibilityId ? `responsibilityId=${turn.context.responsibilityId}` : null,
+    "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:",
+    `<${persistence.HAPPY_ORG_TURN_REPORT_TAG}>{"turnStatus":"turn_update","summary":"short task-board summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null,"accessChannelState":"ok"}</${persistence.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.",
+    "Allowed accessChannelState values: ok, reattach_required, runtime_replaced.",
+    "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.",
+    "targetArtifact must be null or a concrete previewable file target. Use a repo-relative path, absolute path, file:// URL, or https:// URL when you actually produced a material or artifact the client should open directly.",
+    "Do not use abstract labels like release-checklist-template or completion-board-template in targetArtifact.",
+    `summary must fit on a one-line CEO card or task-board card: short, actionable, no long process logs, max ${persistence.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,
+    ...replyContextLines,
+    ...specialistHomeLines,
+    "[/HAPPY_ORG_TASK_CONTEXT]",
+    "",
+    prompt
+  ].filter(Boolean);
+  return header.join("\n");
+}
+function resolveHappyOrgQueuedTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  if (!metadata) {
+    return {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false
+    };
   }
-  /**
-   * Reset state for new sessions.
-   * This method is idempotent - safe to call multiple times.
-   */
-  reset() {
-    if (this.isResetting) {
-      persistence.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
-      return;
-    }
-    this.isResetting = true;
-    try {
-      const pendingSnapshot = Array.from(this.pendingRequests.entries());
-      this.pendingRequests.clear();
-      for (const [id, pending] of pendingSnapshot) {
-        try {
-          this.clearPendingRequestTimeout(pending);
-          pending.reject(new Error("Session reset"));
-        } catch (err) {
-          persistence.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
-        }
-      }
-      this.session.updateAgentState((currentState) => {
-        const pendingRequests = currentState.requests || {};
-        const completedRequests = { ...currentState.completedRequests };
-        for (const [id, request] of Object.entries(pendingRequests)) {
-          completedRequests[id] = {
-            ...request,
-            completedAt: Date.now(),
-            status: "canceled",
-            reason: "Session reset"
-          };
-        }
+  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}`);
+  const specialistHome = buildSpecialistHomeIdentity({
+    metadata,
+    sessionId: opts.sessionId,
+    fallback: currentHappyOrg.specialistHome
+  });
+  nextHappyOrg.specialistHome = cloneHappyOrgSpecialistHomeIdentity(specialistHome);
+  if (messageHappyOrg?.taskContext) {
+    const currentTaskId = currentHappyOrg.taskContext?.taskId ?? null;
+    if (currentTaskId !== messageHappyOrg.taskContext.taskId) {
+      if (currentHappyOrg.taskContext && currentHappyOrg.runtime?.status === "active") {
         return {
-          ...currentState,
-          requests: {},
-          completedRequests
+          nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+          queuedTurn: null,
+          blocked: true,
+          statusMessage: buildMemberBusyStatusMessage(
+            currentHappyOrg.taskContext.memberAgentId,
+            currentHappyOrg.taskContext.taskId,
+            messageHappyOrg.taskContext.taskId
+          )
         };
-      });
-      persistence.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
-    } finally {
-      this.isResetting = false;
-    }
-  }
-  clearPendingRequestTimeout(pending) {
-    if (pending?.timeoutHandle) {
-      clearTimeout(pending.timeoutHandle);
-      pending.timeoutHandle = void 0;
-    }
-  }
-  handlePendingRequestTimeout(toolCallId, pending) {
-    const active = this.pendingRequests.get(toolCallId);
-    if (!active || active !== pending) {
-      return;
-    }
-    this.pendingRequests.delete(toolCallId);
-    this.clearPendingRequestTimeout(active);
-    active.resolve({ decision: "abort" });
-    this.session.updateAgentState((currentState) => {
-      const request = currentState.requests?.[toolCallId] || {
-        tool: active.toolName,
-        arguments: active.input,
-        createdAt: Date.now(),
-        requestKind: "permission"
-      };
-      const { [toolCallId]: _, ...remainingRequests } = currentState.requests || {};
-      return {
-        ...currentState,
-        requests: remainingRequests,
-        completedRequests: {
-          ...currentState.completedRequests,
-          [toolCallId]: {
-            ...request,
-            completedAt: Date.now(),
-            status: "canceled",
-            reason: INTERACTION_TIMED_OUT_ERROR,
-            decision: "abort",
-            requestKind: request.requestKind || "permission"
-          }
-        }
-      };
-    });
-    this.session.sendSessionEvent({
-      type: "message",
-      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
-    });
-    persistence.logger.debug(`${this.getLogPrefix()} Permission request timed out for ${active.toolName} (${toolCallId})`);
-  }
-}
-
-class MessageQueue2 {
-  queue = [];
-  // Made public for testing
-  waiter = null;
-  closed = false;
-  onMessageHandler = null;
-  modeHasher;
-  constructor(modeHasher, onMessageHandler = null) {
-    this.modeHasher = modeHasher;
-    this.onMessageHandler = onMessageHandler;
-    persistence.logger.debug(`[MessageQueue2] Initialized`);
-  }
-  /**
-   * Set a handler that will be called when a message arrives
-   */
-  setOnMessage(handler) {
-    this.onMessageHandler = handler;
-  }
-  /**
-   * Push a message to the queue with a mode.
-   */
-  push(message, mode) {
-    if (this.closed) {
-      throw new Error("Cannot push to closed queue");
-    }
-    const modeHash = this.modeHasher(mode);
-    persistence.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
-    this.queue.push({
-      message,
-      mode,
-      modeHash,
-      isolate: false
-    });
-    if (this.onMessageHandler) {
-      this.onMessageHandler(message, mode);
-    }
-    if (this.waiter) {
-      persistence.logger.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    persistence.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
-  }
-  /**
-   * Push a message immediately without batching delay.
-   * Does not clear the queue or enforce isolation.
-   */
-  pushImmediate(message, mode) {
-    if (this.closed) {
-      throw new Error("Cannot push to closed queue");
-    }
-    const modeHash = this.modeHasher(mode);
-    persistence.logger.debug(`[MessageQueue2] pushImmediate() called with mode hash: ${modeHash}`);
-    this.queue.push({
-      message,
-      mode,
-      modeHash,
-      isolate: false
-    });
-    if (this.onMessageHandler) {
-      this.onMessageHandler(message, mode);
-    }
-    if (this.waiter) {
-      persistence.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    persistence.logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
-  }
-  /**
-   * Push a message that must be processed in complete isolation.
-   * Clears any pending messages and ensures this message is never batched with others.
-   * Used for special commands that require dedicated processing.
-   */
-  pushIsolateAndClear(message, mode) {
-    if (this.closed) {
-      throw new Error("Cannot push to closed queue");
-    }
-    const modeHash = this.modeHasher(mode);
-    persistence.logger.debug(`[MessageQueue2] pushIsolateAndClear() called with mode hash: ${modeHash} - clearing ${this.queue.length} pending messages`);
-    this.queue = [];
-    this.queue.push({
-      message,
-      mode,
-      modeHash,
-      isolate: true
-    });
-    if (this.onMessageHandler) {
-      this.onMessageHandler(message, mode);
-    }
-    if (this.waiter) {
-      persistence.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    persistence.logger.debug(`[MessageQueue2] pushIsolateAndClear() completed. Queue size: ${this.queue.length}`);
-  }
-  /**
-   * Push a message to the beginning of the queue with a mode.
-   */
-  unshift(message, mode) {
-    if (this.closed) {
-      throw new Error("Cannot unshift to closed queue");
-    }
-    const modeHash = this.modeHasher(mode);
-    persistence.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
-    this.queue.unshift({
-      message,
-      mode,
-      modeHash,
-      isolate: false
-    });
-    if (this.onMessageHandler) {
-      this.onMessageHandler(message, mode);
-    }
-    if (this.waiter) {
-      persistence.logger.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
+      }
+      nextHappyOrg = resetHappyOrgRuntimeForTask(messageHappyOrg.taskContext, specialistHome);
+    } else {
+      nextHappyOrg.taskContext = { ...messageHappyOrg.taskContext };
     }
-    persistence.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
   }
-  /**
-   * Reset the queue - clears all messages and resets to empty state
-   */
-  reset() {
-    persistence.logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
-    this.queue = [];
-    this.closed = false;
-    this.waiter = null;
-  }
-  /**
-   * Close the queue - no more messages can be pushed
-   */
-  close() {
-    persistence.logger.debug(`[MessageQueue2] close() called`);
-    this.closed = true;
-    if (this.waiter) {
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(false);
-    }
+  const taskContext = nextHappyOrg.taskContext ?? null;
+  const replyContext = resolveReplyContextFromMessage(opts.message, taskContext);
+  if (replyContext) {
+    nextHappyOrg.replyContext = replyContext;
+  } else if (!taskContext || currentHappyOrg.taskContext?.taskId !== taskContext.taskId) {
+    nextHappyOrg.replyContext = null;
   }
-  /**
-   * Check if the queue is closed
-   */
-  isClosed() {
-    return this.closed;
+  if (!taskContext) {
+    return {
+      nextMetadata: metadata,
+      queuedTurn: null,
+      blocked: false
+    };
   }
-  /**
-   * Get the current queue size
-   */
-  size() {
-    return this.queue.length;
+  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)
+    };
   }
-  /**
-   * Wait for messages and return all messages with the same mode as a single string
-   * Returns { message: string, mode: T } or null if aborted/closed
-   */
-  async waitForMessagesAndGetAsString(abortSignal) {
-    if (this.queue.length > 0) {
-      return this.collectBatch();
-    }
-    if (this.closed || abortSignal?.aborted) {
-      return null;
+  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)
+      };
     }
-    const hasMessages = await this.waitForMessages(abortSignal);
-    if (!hasMessages) {
-      return null;
+    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.`
+      };
     }
-    return this.collectBatch();
   }
-  /**
-   * Collect a batch of messages with the same mode, respecting isolation requirements
-   */
-  collectBatch() {
-    if (this.queue.length === 0) {
-      return null;
-    }
-    const firstItem = this.queue[0];
-    const sameModeMessages = [];
-    let mode = firstItem.mode;
-    let isolate = firstItem.isolate ?? false;
-    const targetModeHash = firstItem.modeHash;
-    if (firstItem.isolate) {
-      const item = this.queue.shift();
-      sameModeMessages.push(item.message);
-      persistence.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
-    } else {
-      while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash && !this.queue[0].isolate) {
-        const item = this.queue.shift();
-        sameModeMessages.push(item.message);
-      }
-      persistence.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
-    }
-    const combinedMessage = sameModeMessages.join("\n");
+  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 {
-      message: combinedMessage,
-      mode,
-      hash: targetModeHash,
-      isolate
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildOwnerConflictStatusMessage(
+        taskContext.taskId,
+        nextHappyOrg.activeOwner.ownerAgentId
+      )
     };
   }
-  /**
-   * Wait for messages to arrive
-   */
-  waitForMessages(abortSignal) {
-    return new Promise((resolve) => {
-      let abortHandler = null;
-      if (abortSignal) {
-        abortHandler = () => {
-          persistence.logger.debug("[MessageQueue2] Wait aborted");
-          if (this.waiter === waiterFunc) {
-            this.waiter = null;
-          }
-          resolve(false);
-        };
-        abortSignal.addEventListener("abort", abortHandler);
-      }
-      const waiterFunc = (hasMessages) => {
-        if (abortHandler && abortSignal) {
-          abortSignal.removeEventListener("abort", abortHandler);
-        }
-        resolve(hasMessages);
+  return {
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    queuedTurn: {
+      context: taskContext,
+      ...reopenContext ? { reopenContext } : {},
+      replyContext: cloneHappyOrgReplyContext(nextHappyOrg.replyContext),
+      specialistHome: cloneHappyOrgSpecialistHomeIdentity(nextHappyOrg.specialistHome)
+    },
+    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 currentHappyOrg = normalizeHappyOrgMetadata(metadata);
+  const resolvedReplyContext = cloneHappyOrgReplyContext(queuedTurn.replyContext) ?? cloneHappyOrgReplyContext(currentHappyOrg.replyContext);
+  const resolvedSpecialistHome = cloneHappyOrgSpecialistHomeIdentity(queuedTurn.specialistHome) ?? cloneHappyOrgSpecialistHomeIdentity(currentHappyOrg.specialistHome);
+  const acceptanceHandoffCandidate = resolveHappyOrgAcceptanceHandoffCandidate(cleanedText);
+  const acceptanceHandoff = acceptanceHandoffCandidate.outcome === "valid" && acceptanceHandoffCandidate.handoff.taskId === queuedTurn.context.taskId && (!resolvedReplyContext || acceptanceHandoffCandidate.handoff.dispatchId === resolvedReplyContext.dispatchId) ? acceptanceHandoffCandidate.handoff : null;
+  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,
+    accessChannelState: normalizedDraft.accessChannelState ?? "ok",
+    repeatFingerprint: buildRepeatFingerprint(
+      queuedTurn.context,
+      normalizedDraft.blockerCode ?? null,
+      normalizedDraft.targetArtifact ?? null
+    ),
+    replyContext: resolvedReplyContext,
+    specialistHome: resolvedSpecialistHome,
+    ...acceptanceHandoff ? { acceptanceHandoff } : {}
+  };
+  const nextHappyOrg = currentHappyOrg;
+  nextHappyOrg.taskContext = { ...queuedTurn.context };
+  nextHappyOrg.lastTurnReport = report;
+  nextHappyOrg.activeOwner = null;
+  nextHappyOrg.replyContext = resolvedReplyContext;
+  nextHappyOrg.specialistHome = resolvedSpecialistHome;
+  nextHappyOrg.repeat = nextHappyOrg.repeat ?? {
+    threshold: persistence.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
       };
-      if (this.queue.length > 0) {
-        if (abortHandler && abortSignal) {
-          abortSignal.removeEventListener("abort", abortHandler);
-        }
-        resolve(true);
-        return;
-      }
-      if (this.closed || abortSignal?.aborted) {
-        if (abortHandler && abortSignal) {
-          abortSignal.removeEventListener("abort", abortHandler);
-        }
-        resolve(false);
-        return;
-      }
-      this.waiter = waiterFunc;
-      persistence.logger.debug("[MessageQueue2] Waiting for messages...");
-    });
+      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
+  };
+}
+async function finalizeHappyOrgTurnWithBusinessAck(opts) {
+  const finalizedTurn = finalizeHappyOrgTurn({
+    metadata: opts.metadata,
+    queuedTurn: opts.queuedTurn,
+    responseText: opts.responseText,
+    turnStatus: opts.turnStatus,
+    now: opts.now
+  });
+  const dispatchAckResult = await maybeSubmitHappyOrgDispatchBusinessAck({
+    metadata: finalizedTurn.nextMetadata,
+    queuedTurn: opts.queuedTurn,
+    responseText: finalizedTurn.cleanedText,
+    now: opts.now,
+    submitDispatchAck: opts.submitDispatchAck
+  });
+  return {
+    ...finalizedTurn,
+    nextMetadata: dispatchAckResult.nextMetadata,
+    dispatchAck: dispatchAckResult.dispatchAck
+  };
 }
 
-function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
-  rpcHandlerManager.registerHandler("killSession", async () => {
-    persistence.logger.debug("Kill session request received");
-    void killThisHappy();
-    return {
-      success: true,
-      message: "Killing happy-cli process"
+function supportsAgentStateUpdateEvents(sessionClient) {
+  return typeof sessionClient.once === "function" && typeof sessionClient.off === "function";
+}
+async function syncControlledByUserState(sessionClient, controlledByUser) {
+  if (!supportsAgentStateUpdateEvents(sessionClient)) {
+    sessionClient.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser
+    }));
+    return;
+  }
+  await new Promise((resolve) => {
+    let settled = false;
+    const handleUpdated = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      sessionClient.off("agent-state-updated", handleUpdated);
+      resolve();
     };
+    const timeout = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      sessionClient.off("agent-state-updated", handleUpdated);
+      resolve();
+    }, 1500);
+    sessionClient.once("agent-state-updated", handleUpdated);
+    sessionClient.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser
+    }));
   });
 }
 
 exports.BasePermissionHandler = BasePermissionHandler;
-exports.ConversationHistory = ConversationHistory$1;
 exports.INTERACTION_SUPERSEDED_ERROR = INTERACTION_SUPERSEDED_ERROR;
 exports.INTERACTION_TIMED_OUT_ERROR = INTERACTION_TIMED_OUT_ERROR;
-exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
 exports.MissingMachineIdError = MissingMachineIdError;
 exports.buildHappyOrgTurnPrompt = buildHappyOrgTurnPrompt;
-exports.buildPermissionPushNotification = buildPermissionPushNotification;
-exports.buildReadyPushNotification = buildReadyPushNotification;
-exports.buildTurnResultPushNotification = buildTurnResultPushNotification;
-exports.createSessionTranscriptInkRenderer = createSessionTranscriptInkRenderer;
 exports.ensureManagedProviderMachine = ensureManagedProviderMachine;
-exports.extractPermissionRequestPushContext = extractPermissionRequestPushContext;
 exports.finalizeHappyOrgTurnWithBusinessAck = finalizeHappyOrgTurnWithBusinessAck;
 exports.forwardAgentMessageToProviderSession = forwardAgentMessageToProviderSession;
 exports.getPendingInteractionTimeoutMs = getPendingInteractionTimeoutMs;
 exports.inferToolResultError = inferToolResultError;
-exports.launchRuntimeHandleWithFactoryResult = launchRuntimeHandleWithFactoryResult;
 exports.prepareTerminalOutputForForwarding = prepareTerminalOutputForForwarding;
 exports.registerKillSessionHandler = registerKillSessionHandler;
 exports.renderTerminalOutputPreview = renderTerminalOutputPreview;