happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{registerKillSessionHandler-DLDg2EES.mjs → sessionControl-1bT_7OI6.mjs}

@@ -1,10 +1,11 @@
-import { m as initialMachineMetadata, R as RuntimeShell, f as formatDisplayMessage, n as resolveCanonicalToolNameV2, o as isTerminalReferenceOnlyPayload, t as truncateDisplayMessage } from './index-7Z93BoVn.mjs';
-import { r as readSettings, H as HeadTailPreviewBuffer, e as HAPPY_ORG_REPLY_ACK_VERSION, f as HAPPY_ORG_TURN_REPORT_TAG, g as HAPPY_ORG_SUMMARY_MAX_LENGTH, j as HAPPY_ORG_REPEAT_THRESHOLD, l as logger, n as normalizePreviewableArtifactTarget } from './api-DnqaNvyV.mjs';
+import { o as initialMachineMetadata, q as resolveCanonicalToolNameV2 } from './index-CX-F_fuk.mjs';
+import { r as readSettings, H as HeadTailPreviewBuffer, l as logger, f as HAPPY_ORG_REPLY_ACK_VERSION, g as HAPPY_ORG_TURN_REPORT_TAG, j as HAPPY_ORG_SUMMARY_MAX_LENGTH, k as HAPPY_ORG_REPEAT_THRESHOLD, n as normalizePreviewableArtifactTarget } from './types-B5vtxa38.mjs';
 import { randomUUID } from 'node:crypto';
-import { basename } from 'node:path';
+import { f as formatDisplayMessage, i as isTerminalReferenceOnlyPayload } from './RuntimeShell-BDt42io_.mjs';
 import 'axios';
 import 'node:events';
 import 'node:fs/promises';
+import { basename } from 'node:path';
 import 'socket.io-client';
 import 'tweetnacl';
 import 'fs/promises';
@@ -13,7 +14,6 @@ import 'path';
 import 'node:child_process';
 import 'chalk';
 import 'expo-server-sdk';
-import './types-CiliQpqS.mjs';
 
 class MissingMachineIdError extends Error {
   constructor(message) {
@@ -34,27 +34,6 @@ async function ensureManagedProviderMachine(opts) {
   return machineId;
 }
 
-async function launchRuntimeHandleWithFactoryResult(opts) {
-  const shell = opts.shell ?? new 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;
@@ -119,11 +98,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 {
@@ -144,7 +123,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) {
@@ -164,7 +143,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);
@@ -213,7 +192,7 @@ function normalizeCodexToolOutput(rawToolName, value) {
   if (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);
@@ -240,7 +219,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)) {
@@ -264,6 +243,8 @@ function getDefaultExecToolName(provider) {
       return "ClaudeBash";
     case "codex":
       return "CodexBash";
+    case "cursor":
+      return "CursorBash";
     case "gemini":
       return "GeminiBash";
   }
@@ -274,6 +255,8 @@ function getDefaultPatchToolName(provider) {
       return "ClaudePatch";
     case "codex":
       return "CodexPatch";
+    case "cursor":
+      return "CursorPatch";
     case "gemini":
       return "GeminiPatch";
   }
@@ -311,7 +294,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;
@@ -470,2558 +453,1813 @@ 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) {
+    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) {
+          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;
+        });
+        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);
+      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
+      };
+    });
+    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) {
+      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) {
+          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
+        };
+      });
+      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, 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."
+    });
+    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;
+    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: 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: 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);
+    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) {
+      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;
+    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);
+    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) {
+      logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    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);
+    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) {
+      logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    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);
+    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) {
+      logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    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() {
+    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() {
+    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);
+      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);
+      }
+      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 = () => {
+          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;
+      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 () => {
+    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, 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: 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: 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") {
-    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)}.`;
-    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) {
-  if (!path) {
+function normalizeBlockerSummary(value) {
+  const normalized = normalizeSingleLineText(value);
+  if (!normalized) {
     return null;
   }
-  const trimmedPath = path.trim().replace(/[\\/]+$/, "");
-  if (!trimmedPath) {
+  const lowered = normalized.toLowerCase();
+  if (lowered === "none" || lowered === "null" || lowered === "no blocker") {
     return null;
   }
-  return 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, 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: 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(
-    `<${HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${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: 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") {
+    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=${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:",
-    `<${HAPPY_ORG_TURN_REPORT_TAG}>{"turnStatus":"turn_update","summary":"short task-board summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null,"accessChannelState":"ok"}</${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 ${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: 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(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)}.`;
+    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) {
+  if (!path) {
+    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.trim().replace(/[\\/]+$/, "");
+  if (!trimmedPath) {
+    return null;
   }
-  notifyListeners() {
-    const messages = this.getMessages();
-    this.listeners.forEach((listener) => listener(messages));
+  return 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 = 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 = 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 ? truncateDisplayMessage(payload.stderr, 200) || "Patch failed" : 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 = 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(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, 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: 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 = [];
-    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)) {
-      logger.debug(`[ConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
-      return;
-    }
-    this.messages.push({
-      role,
-      content: trimmedContent,
-      timestamp: Date.now()
-    });
-    this.trimHistory();
-    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(
+    `<${HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${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: 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) {
-    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) {
-          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;
-        });
-        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);
-      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
-      };
-    });
-    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=${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:",
+    `<${HAPPY_ORG_TURN_REPORT_TAG}>{"turnStatus":"turn_update","summary":"short task-board summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null,"accessChannelState":"ok"}</${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 ${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) {
-      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) {
-          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
+          )
         };
-      });
-      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."
-    });
-    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;
-    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);
-    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) {
-      logger.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    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);
-    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) {
-      logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    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);
-    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) {
-      logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
-    }
-    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);
-    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) {
-      logger.debug(`[MessageQueue2] Notifying waiter`);
-      const waiter = this.waiter;
-      this.waiter = null;
-      waiter(true);
+      }
+      nextHappyOrg = resetHappyOrgRuntimeForTask(messageHappyOrg.taskContext, specialistHome);
+    } else {
+      nextHappyOrg.taskContext = { ...messageHappyOrg.taskContext };
     }
-    logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
   }
-  /**
-   * Reset the queue - clears all messages and resets to empty state
-   */
-  reset() {
-    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() {
-    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);
-      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);
-      }
-      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 = () => {
-          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: 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;
-      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 () => {
-    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
+    }));
   });
 }
 
-export { BasePermissionHandler as B, ConversationHistory$1 as C, INTERACTION_SUPERSEDED_ERROR as I, MissingMachineIdError as M, INTERACTION_TIMED_OUT_ERROR as a, MessageQueue2 as b, registerKillSessionHandler as c, MessageBuffer as d, ensureManagedProviderMachine as e, buildHappyOrgTurnPrompt as f, getPendingInteractionTimeoutMs as g, finalizeHappyOrgTurnWithBusinessAck as h, buildTurnResultPushNotification as i, buildReadyPushNotification as j, extractPermissionRequestPushContext as k, launchRuntimeHandleWithFactoryResult as l, buildPermissionPushNotification as m, renderTerminalOutputPreview as n, inferToolResultError as o, prepareTerminalOutputForForwarding as p, forwardAgentMessageToProviderSession as q, resolveHappyOrgQueuedTurn as r, syncControlledByUserState as s, createSessionTranscriptInkRenderer as t, waitForResponseCompleteWithAbort as w };
+export { BasePermissionHandler as B, INTERACTION_SUPERSEDED_ERROR as I, MissingMachineIdError as M, INTERACTION_TIMED_OUT_ERROR as a, MessageQueue2 as b, resolveHappyOrgQueuedTurn as c, buildHappyOrgTurnPrompt as d, ensureManagedProviderMachine as e, finalizeHappyOrgTurnWithBusinessAck as f, getPendingInteractionTimeoutMs as g, forwardAgentMessageToProviderSession as h, renderTerminalOutputPreview as i, inferToolResultError as j, prepareTerminalOutputForForwarding as p, registerKillSessionHandler as r, syncControlledByUserState as s, waitForResponseCompleteWithAbort as w };