very-happy-cli 0.2.159 → 0.2.160

package/dist/api-CLMUr-SX.mjs

@@ -0,0 +1,3339 @@
+import axios from 'axios';
+import { l as logger, r as redactLogValue } from './logger-6HYUEXNk.mjs';
+import { EventEmitter } from 'node:events';
+import { io } from 'socket.io-client';
+import { A as AsyncLock, a as MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES, U as UserMessageSchema, F as FileEventMessageSchema } from './attachmentLimits-yba1uHFO.mjs';
+import { h as decrypt, d as decodeBase64, i as decryptBlob, e as encodeBase64, g as encrypt, l as libsodiumEncryptForPublicKey, j as libsodiumPublicKeyFromSecretKey, k as getRandomBytes } from './authRelay-DSAvg1uv.mjs';
+import { p as prepareClipboardText, d as prepareClipboardHistoryText } from './limits-DIo7rEBR.mjs';
+import { b as backoff, d as delay, e as exponentialBackoffDelay } from './time-D0XyHOid.mjs';
+import { R as RpcHandlerManager, a as answerSocketRequest, d as describeSocketAckDrop, s as safeAck, i as isRateQuotaCode, p as pauseForRateQuota, b as shouldReconnect } from './lidState-CeEt442o.mjs';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+import { createHmac, randomUUID } from 'node:crypto';
+import { e as createEnvelope, s as streamKeyOf, R as ReleaseDrainNoticeSchema, m as RelayAssignmentResponseSchema } from './index-qdS1friN.mjs';
+import { r as registerCommonHandlers } from './registerCommonHandlers-Ccvsz7Ou.mjs';
+import { createId } from '@paralleldrive/cuid2';
+import { I as InvalidateSync } from './sync-C8gyQFMc.mjs';
+import { B as BackgroundTaskReporter } from './backgroundTaskActivity-8PdPxrvy.mjs';
+import { h as notifyDaemonTurnEvent, j as notifyDaemonBackgroundTasks } from './controlClient-BGbDcgWS.mjs';
+import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
+import chalk from 'chalk';
+
+async function hmac_sha512(key, data) {
+  const hmac = createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+
+async function deriveSecretKeyTreeRoot(seed, usage) {
+  const I = await hmac_sha512(new TextEncoder().encode(usage + " Master Seed"), seed);
+  return {
+    key: I.slice(0, 32),
+    chainCode: I.slice(32)
+  };
+}
+async function deriveSecretKeyTreeChild(chainCode, index) {
+  const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+  const I = await hmac_sha512(chainCode, data);
+  return {
+    key: I.subarray(0, 32),
+    chainCode: I.subarray(32)
+  };
+}
+async function deriveKey(master, usage, path) {
+  let state = await deriveSecretKeyTreeRoot(master, usage);
+  let remaining = [...path];
+  while (remaining.length > 0) {
+    let index = remaining[0];
+    remaining = remaining.slice(1);
+    state = await deriveSecretKeyTreeChild(state.chainCode, index);
+  }
+  return state.key;
+}
+
+const PRICING = {
+  // --- Claude Fable / Mythos (same tier, same price) ---
+  "claude-fable-5-1": { input: 10, output: 50, cache_write: 12.5, cache_read: 0.25 },
+  "claude-fable-5": { input: 10, output: 50, cache_write: 12.5, cache_read: 1 },
+  "claude-mythos-5-1": { input: 10, output: 50, cache_write: 12.5, cache_read: 0.25 },
+  "claude-mythos-5": { input: 10, output: 50, cache_write: 12.5, cache_read: 1 },
+  // --- Claude 5 ---
+  "claude-opus-5-5": { input: 4, output: 20, cache_write: 5, cache_read: 0.2 },
+  "claude-opus-5": { input: 5, output: 25, cache_write: 6.25, cache_read: 0.5 },
+  "claude-sonnet-5": { input: 2, output: 10, cache_write: 2.5, cache_read: 0.2 },
+  // --- Claude 4.x ---
+  "claude-opus-4-8": { input: 5, output: 25, cache_write: 6.25, cache_read: 0.5 },
+  "claude-opus-4-7": { input: 5, output: 25, cache_write: 6.25, cache_read: 0.5 },
+  "claude-opus-4-6": { input: 5, output: 25, cache_write: 6.25, cache_read: 0.5 },
+  "claude-opus-4-5": { input: 5, output: 25, cache_write: 6.25, cache_read: 0.5 },
+  "claude-opus-4-1": { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
+  "claude-opus-4": { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-sonnet-4": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-haiku-4-5": { input: 1, output: 5, cache_write: 1.25, cache_read: 0.1 },
+  // --- Legacy / Claude 3 ---
+  "claude-3-opus-20240229": { input: 15, output: 75, cache_write: 18.75, cache_read: 1.5 },
+  "claude-3-sonnet-20240229": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-3-5-sonnet-20240620": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-3-7-sonnet-20250219": { input: 3, output: 15, cache_write: 3.75, cache_read: 0.3 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25, cache_write: 0.3125, cache_read: 0.025 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4, cache_write: 1, cache_read: 0.08 }
+};
+const DEFAULT_MODEL = "claude-opus-5-5";
+const FAMILY_DEFAULTS = {
+  fable: "claude-fable-5-1",
+  // Project Glasswing counterpart of Fable: same tier, same published rates.
+  mythos: "claude-mythos-5-1",
+  opus: "claude-opus-5-5",
+  sonnet: "claude-sonnet-5",
+  haiku: "claude-haiku-4-5"
+};
+function resolvePricingKey(modelId) {
+  if (!modelId) return DEFAULT_MODEL;
+  const raw = modelId.trim().toLowerCase();
+  if (raw in PRICING) return raw;
+  const id = raw.replace(/\[1m\]$/, "");
+  if (id in PRICING) return id;
+  const family = ["fable", "mythos", "opus", "sonnet", "haiku"].find((f) => id.includes(f));
+  if (!family) return DEFAULT_MODEL;
+  const version = id.match(/(?:^|[^0-9])(\d)(?:[-._](\d))?(?:[^0-9]|$)/);
+  const major = version ? version[1] : null;
+  const minor = version && version[2] ? version[2] : null;
+  const key = major ? `claude-${family}-${major}${minor ? `-${minor}` : ""}` : null;
+  if (key && key in PRICING) return key;
+  if (major === "3" && family !== "fable" && family !== "mythos") {
+    if (family === "opus") return "claude-3-opus-20240229";
+    if (family === "haiku") return minor === "5" ? "claude-3-5-haiku-20241022" : "claude-3-haiku-20240307";
+    if (minor === "7") return "claude-3-7-sonnet-20250219";
+    return minor === "5" ? "claude-3-5-sonnet-20241022" : "claude-3-sonnet-20240229";
+  }
+  return FAMILY_DEFAULTS[family];
+}
+function calculateCost(usage, modelId) {
+  const pricing = PRICING[resolvePricingKey(modelId)];
+  const inputCost = usage.input_tokens / 1e6 * pricing.input;
+  const outputCost = usage.output_tokens / 1e6 * pricing.output;
+  const cacheWriteCost = (usage.cache_creation_input_tokens || 0) / 1e6 * pricing.cache_write;
+  const cacheReadCost = (usage.cache_read_input_tokens || 0) / 1e6 * pricing.cache_read;
+  const totalInputCost = inputCost + cacheWriteCost + cacheReadCost;
+  return {
+    total: totalInputCost + outputCost,
+    input: totalInputCost,
+    output: outputCost
+  };
+}
+
+const SUBAGENT_RESULT_MAX_CHARS = 16384;
+const SUBAGENT_PROGRESS_MIN_INTERVAL_MS = 5e3;
+function capSubagentText(text, max = SUBAGENT_RESULT_MAX_CHARS) {
+  const trimmed = text.trim();
+  if (trimmed.length <= max) return { text: trimmed };
+  return { text: trimmed.slice(0, max), truncated: true };
+}
+function toolUseResultToText(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return null;
+  const content = toolUseResult.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function toolUseResultStatus(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return "unknown";
+  const status = toolUseResult.status;
+  if (status === "async_launched") return "async_launched";
+  if (status === "completed") return "completed";
+  return "unknown";
+}
+function toolUseResultStats(toolUseResult) {
+  if (!toolUseResult || typeof toolUseResult !== "object") return void 0;
+  const r = toolUseResult;
+  const stats = {};
+  if (typeof r.totalToolUseCount === "number") stats.toolUses = r.totalToolUseCount;
+  if (typeof r.totalTokens === "number") stats.totalTokens = r.totalTokens;
+  if (typeof r.totalDurationMs === "number") stats.durationMs = r.totalDurationMs;
+  if (r.toolStats && typeof r.toolStats === "object") stats.toolStats = r.toolStats;
+  return Object.keys(stats).length > 0 ? stats : void 0;
+}
+function parseTaskNotificationText(text) {
+  if (!/<task-notification>/i.test(text)) return null;
+  const pick = (tag) => text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, "i"))?.[1] ?? null;
+  const rawStatus = pick("status")?.trim().toLowerCase() ?? null;
+  const status = rawStatus === "completed" || rawStatus === "failed" || rawStatus === "stopped" ? rawStatus : null;
+  let resultText = pick("result");
+  let result = null;
+  if (resultText !== null) {
+    resultText = resultText.replace(/^\s*\[harness:[^\]]*\]\s*/i, "").replace(/<usage>[\s\S]*?<\/usage>/gi, "").trim();
+    if (resultText.length > 0) result = capSubagentText(resultText);
+  }
+  return {
+    toolUseId: pick("tool-use-id")?.trim() || null,
+    taskId: pick("task-id")?.trim() || null,
+    status,
+    summary: pick("summary")?.trim() || null,
+    result
+  };
+}
+function shouldEmitProgress(previous, toolUses, now) {
+  if (!previous) return true;
+  if (previous.lastToolUses === toolUses) return false;
+  return now - previous.lastAt >= SUBAGENT_PROGRESS_MIN_INTERVAL_MS;
+}
+
+const SUBAGENT_BUFFER_MAX_MESSAGES = 100;
+function isSubagentTool(name) {
+  return name === "Task" || name === "Agent";
+}
+function shouldHideParentToolCall(name) {
+  return name === "Task";
+}
+function pickProviderSubagent(message) {
+  const raw = message;
+  if (typeof raw.parent_tool_use_id === "string" && raw.parent_tool_use_id.length > 0) {
+    return raw.parent_tool_use_id;
+  }
+  if (typeof raw.parentToolUseId === "string" && raw.parentToolUseId.length > 0) {
+    return raw.parentToolUseId;
+  }
+  return void 0;
+}
+function getUuidToProviderSubagent(state) {
+  if (!state.uuidToProviderSubagent) {
+    state.uuidToProviderSubagent = /* @__PURE__ */ new Map();
+  }
+  return state.uuidToProviderSubagent;
+}
+function getTaskPromptToSubagents(state) {
+  if (!state.taskPromptToSubagents) {
+    state.taskPromptToSubagents = /* @__PURE__ */ new Map();
+  }
+  return state.taskPromptToSubagents;
+}
+function getProviderSubagentToSessionSubagent(state) {
+  if (!state.providerSubagentToSessionSubagent) {
+    state.providerSubagentToSessionSubagent = /* @__PURE__ */ new Map();
+  }
+  return state.providerSubagentToSessionSubagent;
+}
+function getSessionSubagentIdForProviderSubagent(state, providerSubagent) {
+  return getProviderSubagentToSessionSubagent(state).get(providerSubagent);
+}
+function ensureSessionSubagentIdForProviderSubagent(state, providerSubagent) {
+  const existing = getSessionSubagentIdForProviderSubagent(state, providerSubagent);
+  if (existing) {
+    return existing;
+  }
+  const created = createId();
+  getProviderSubagentToSessionSubagent(state).set(providerSubagent, created);
+  return created;
+}
+function getSubagentTitles(state) {
+  if (!state.subagentTitles) {
+    state.subagentTitles = /* @__PURE__ */ new Map();
+  }
+  return state.subagentTitles;
+}
+function getBufferedSubagentMessages(state) {
+  if (!state.bufferedSubagentMessages) {
+    state.bufferedSubagentMessages = /* @__PURE__ */ new Map();
+  }
+  return state.bufferedSubagentMessages;
+}
+function getHiddenParentToolCalls(state) {
+  if (!state.hiddenParentToolCalls) {
+    state.hiddenParentToolCalls = /* @__PURE__ */ new Set();
+  }
+  return state.hiddenParentToolCalls;
+}
+function bufferSubagentMessage(state, subagent, message) {
+  const buffer = getBufferedSubagentMessages(state);
+  const queue = buffer.get(subagent) ?? [];
+  queue.push(message);
+  while (queue.length > SUBAGENT_BUFFER_MAX_MESSAGES) queue.shift();
+  buffer.set(subagent, queue);
+}
+function consumeBufferedSubagentMessages(state, subagent) {
+  const buffer = getBufferedSubagentMessages(state);
+  const queue = buffer.get(subagent) ?? [];
+  buffer.delete(subagent);
+  return queue;
+}
+function getStartedSubagents(state) {
+  if (!state.startedSubagents) {
+    state.startedSubagents = /* @__PURE__ */ new Set();
+  }
+  return state.startedSubagents;
+}
+function getActiveSubagents(state) {
+  if (!state.activeSubagents) {
+    state.activeSubagents = /* @__PURE__ */ new Set();
+  }
+  return state.activeSubagents;
+}
+function getAgentToolCalls(state) {
+  if (!state.agentToolCalls) state.agentToolCalls = /* @__PURE__ */ new Set();
+  return state.agentToolCalls;
+}
+function getSubagentMeta(state) {
+  if (!state.subagentMeta) state.subagentMeta = /* @__PURE__ */ new Map();
+  return state.subagentMeta;
+}
+function getStubSubagents(state) {
+  if (!state.stubSubagents) state.stubSubagents = /* @__PURE__ */ new Set();
+  return state.stubSubagents;
+}
+function getProgressThrottle(state) {
+  if (!state.progressThrottle) state.progressThrottle = /* @__PURE__ */ new Map();
+  return state.progressThrottle;
+}
+function nowOf(state) {
+  return state.now ? state.now() : Date.now();
+}
+function rememberSubagentMeta(state, subagent, meta) {
+  const existing = getSubagentMeta(state).get(subagent) ?? {};
+  const description = typeof meta.description === "string" && meta.description.trim() ? meta.description.trim() : existing.description;
+  const subagentType = typeof meta.subagentType === "string" && meta.subagentType.trim() ? meta.subagentType.trim() : existing.subagentType;
+  getSubagentMeta(state).set(subagent, { ...description ? { description } : {}, ...subagentType ? { subagentType } : {} });
+}
+function pickAssistantUsage(message) {
+  if (message.type !== "assistant") return void 0;
+  const usage = message.message?.usage;
+  if (!usage || typeof usage.input_tokens !== "number" || typeof usage.output_tokens !== "number") return void 0;
+  return {
+    input_tokens: usage.input_tokens,
+    output_tokens: usage.output_tokens,
+    ...typeof usage.cache_creation_input_tokens === "number" ? { cache_creation_input_tokens: usage.cache_creation_input_tokens } : {},
+    ...typeof usage.cache_read_input_tokens === "number" ? { cache_read_input_tokens: usage.cache_read_input_tokens } : {}
+  };
+}
+function pickUuid(message) {
+  const raw = message;
+  if (typeof raw.uuid === "string" && raw.uuid.length > 0) {
+    return raw.uuid;
+  }
+  return void 0;
+}
+function pickParentUuid(message) {
+  const raw = message;
+  if (typeof raw.parentUuid === "string" && raw.parentUuid.length > 0) {
+    return raw.parentUuid;
+  }
+  if (typeof raw.parentUUID === "string" && raw.parentUUID.length > 0) {
+    return raw.parentUUID;
+  }
+  return void 0;
+}
+function isSidechainMessage(message) {
+  const raw = message;
+  return raw.isSidechain === true;
+}
+function normalizePrompt(prompt) {
+  return prompt.trim();
+}
+function queueTaskPromptSubagent(state, prompt, subagent) {
+  const normalized = normalizePrompt(prompt);
+  if (normalized.length === 0) {
+    return;
+  }
+  const promptMap = getTaskPromptToSubagents(state);
+  const queue = promptMap.get(normalized) ?? [];
+  if (!queue.includes(subagent)) {
+    queue.push(subagent);
+  }
+  promptMap.set(normalized, queue);
+}
+function consumeTaskPromptSubagent(state, prompt) {
+  const normalized = normalizePrompt(prompt);
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  const promptMap = getTaskPromptToSubagents(state);
+  const queue = promptMap.get(normalized);
+  if (!queue || queue.length === 0) {
+    return void 0;
+  }
+  const subagent = queue.shift();
+  if (queue.length === 0) {
+    promptMap.delete(normalized);
+  }
+  return subagent;
+}
+function consumeSinglePendingTaskSubagent(state) {
+  const promptMap = getTaskPromptToSubagents(state);
+  let candidateKey = null;
+  let candidateSubagent = null;
+  for (const [prompt, queue2] of promptMap.entries()) {
+    if (queue2.length === 0) {
+      continue;
+    }
+    if (candidateKey !== null) {
+      return void 0;
+    }
+    candidateKey = prompt;
+    candidateSubagent = queue2[0] ?? null;
+  }
+  if (!candidateKey || !candidateSubagent) {
+    return void 0;
+  }
+  const queue = promptMap.get(candidateKey);
+  if (!queue || queue.length === 0) {
+    return void 0;
+  }
+  queue.shift();
+  if (queue.length === 0) {
+    promptMap.delete(candidateKey);
+  }
+  return candidateSubagent;
+}
+function pickSidechainRootPrompt(message) {
+  if (message.type !== "user") {
+    return void 0;
+  }
+  if (typeof message.message?.content === "string") {
+    const normalized = normalizePrompt(message.message.content);
+    return normalized.length > 0 ? normalized : void 0;
+  }
+  return void 0;
+}
+function resolveProviderSubagent(message, state) {
+  const explicitSubagent = pickProviderSubagent(message);
+  if (explicitSubagent) {
+    return explicitSubagent;
+  }
+  const parentUuid = pickParentUuid(message);
+  if (parentUuid) {
+    const inheritedSubagent = getUuidToProviderSubagent(state).get(parentUuid);
+    if (inheritedSubagent) {
+      return inheritedSubagent;
+    }
+  }
+  if (!isSidechainMessage(message)) {
+    return void 0;
+  }
+  const prompt = pickSidechainRootPrompt(message);
+  if (prompt) {
+    const matchedSubagent = consumeTaskPromptSubagent(state, prompt);
+    if (matchedSubagent) {
+      return matchedSubagent;
+    }
+  }
+  if (!parentUuid) {
+    return consumeSinglePendingTaskSubagent(state);
+  }
+  return void 0;
+}
+function rememberSubagentForMessage(message, state, providerSubagent) {
+  if (!providerSubagent) {
+    return;
+  }
+  const uuid = pickUuid(message);
+  if (!uuid) {
+    return;
+  }
+  getUuidToProviderSubagent(state).set(uuid, providerSubagent);
+}
+function pickTaskPrompt(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const prompt = input.prompt;
+  if (typeof prompt !== "string") {
+    return void 0;
+  }
+  const normalized = normalizePrompt(prompt);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function pickTaskTitle(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const candidateKeys = ["description", "title", "subagent_type"];
+  for (const key of candidateKeys) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function setSubagentTitle(state, subagent, title) {
+  if (!title || title.trim().length === 0) {
+    return;
+  }
+  getSubagentTitles(state).set(subagent, title.trim());
+}
+function maybeEmitSubagentStart(state, turn, subagent, envelopes) {
+  if (!subagent) {
+    return;
+  }
+  const started = getStartedSubagents(state);
+  if (started.has(subagent)) {
+    return;
+  }
+  const title = getSubagentTitles(state).get(subagent);
+  const meta = getSubagentMeta(state).get(subagent);
+  envelopes.push(createEnvelope("agent", {
+    t: "start",
+    ...title ? { title } : {},
+    ...meta?.description ? { description: meta.description } : {},
+    ...meta?.subagentType ? { subagentType: meta.subagentType } : {}
+  }, { turn, subagent }));
+  started.add(subagent);
+  getActiveSubagents(state).add(subagent);
+}
+function emitSubagentStopWithStatus(state, turn, subagent, envelopes, payload) {
+  envelopes.push(createEnvelope("agent", {
+    t: "stop",
+    ...payload.status ? { status: payload.status } : {},
+    ...payload.result ? { result: payload.result } : {},
+    ...payload.usage ? { usage: payload.usage } : {}
+  }, { ...turn ? { turn } : {}, subagent }));
+  getActiveSubagents(state).delete(subagent);
+  getStartedSubagents(state).delete(subagent);
+}
+function maybeEmitSubagentStop(state, turn, subagent, envelopes) {
+  const active = getActiveSubagents(state);
+  if (!active.has(subagent)) {
+    return;
+  }
+  envelopes.push(createEnvelope("agent", { t: "stop" }, { turn, subagent }));
+  active.delete(subagent);
+}
+function clearSubagentTracking(state) {
+  getUuidToProviderSubagent(state).clear();
+  getTaskPromptToSubagents(state).clear();
+  getBufferedSubagentMessages(state).clear();
+  getHiddenParentToolCalls(state).clear();
+  getStartedSubagents(state).clear();
+  getActiveSubagents(state).clear();
+}
+function ensureTurn(state, envelopes) {
+  if (state.currentTurnId) {
+    return state.currentTurnId;
+  }
+  const turnId = createId();
+  envelopes.push(createEnvelope("agent", { t: "turn-start" }, { turn: turnId }));
+  state.currentTurnId = turnId;
+  return turnId;
+}
+function closeTurn(state, status, envelopes, meta) {
+  if (!state.currentTurnId) {
+    return;
+  }
+  envelopes.push(createEnvelope("agent", {
+    t: "turn-end",
+    status,
+    ...meta?.error ? { error: meta.error } : {},
+    ...typeof meta?.costUsd === "number" ? { costUsd: meta.costUsd } : {},
+    ...typeof meta?.durationMs === "number" ? { durationMs: meta.durationMs } : {},
+    ...typeof meta?.numTurns === "number" ? { numTurns: meta.numTurns } : {},
+    ...meta?.usage ? { usage: meta.usage } : {}
+  }, { turn: state.currentTurnId }));
+  state.currentTurnId = null;
+  state.pendingAssistantError = void 0;
+  clearSubagentTracking(state);
+}
+function toolTitle(name, input) {
+  if (input && typeof input === "object") {
+    const description = input.description;
+    if (typeof description === "string" && description.trim().length > 0) {
+      return description.length > 80 ? `${description.slice(0, 77)}...` : description;
+    }
+  }
+  return `${name} call`;
+}
+function toToolArgs(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  if (input === void 0) {
+    return {};
+  }
+  return { input };
+}
+function closeClaudeTurnWithStatus(state, status, meta) {
+  const envelopes = [];
+  closeTurn(state, status, envelopes, meta);
+  return {
+    currentTurnId: state.currentTurnId,
+    envelopes
+  };
+}
+function mapClaudeLogMessageToSessionEnvelopes(message, state) {
+  return mapClaudeLogMessageToSessionEnvelopesInternal(message, state);
+}
+function mapTaskLifecycleSystemMessage(message, state, envelopes) {
+  const raw = message;
+  const subtype = typeof raw.subtype === "string" ? raw.subtype : "";
+  if (!subtype.startsWith("task_")) return;
+  if (raw.skip_transcript === true) return;
+  const toolUseId = typeof raw.tool_use_id === "string" && raw.tool_use_id.length > 0 ? raw.tool_use_id : null;
+  if (!toolUseId) return;
+  if (subtype === "task_started" && raw.task_type === "local_bash" && state.bashToolCalls?.has(toolUseId)) {
+    (state.backgroundBashCalls ??= /* @__PURE__ */ new Set()).add(toolUseId);
+  }
+  const backgroundBash = state.backgroundBashCalls?.has(toolUseId) === true;
+  if (!getAgentToolCalls(state).has(toolUseId) && !backgroundBash) return;
+  const subagent = ensureSessionSubagentIdForProviderSubagent(state, toolUseId);
+  const usage = raw.usage && typeof raw.usage === "object" ? {
+    ...typeof raw.usage.tool_uses === "number" ? { toolUses: raw.usage.tool_uses } : {},
+    ...typeof raw.usage.total_tokens === "number" ? { totalTokens: raw.usage.total_tokens } : {},
+    ...typeof raw.usage.duration_ms === "number" ? { durationMs: raw.usage.duration_ms } : {}
+  } : void 0;
+  if (subtype === "task_started") {
+    rememberSubagentMeta(state, subagent, { description: raw.description, subagentType: backgroundBash ? "background-command" : raw.subagent_type });
+    const turn = ensureTurn(state, envelopes);
+    getStartedSubagents(state).delete(subagent);
+    maybeEmitSubagentStart(state, turn, subagent, envelopes);
+    return;
+  }
+  if (subtype === "task_progress") {
+    const toolUses = typeof raw.usage?.tool_uses === "number" ? raw.usage.tool_uses : 0;
+    const throttle = getProgressThrottle(state);
+    const now = nowOf(state);
+    if (!shouldEmitProgress(throttle.get(subagent), toolUses, now)) return;
+    throttle.set(subagent, { lastAt: now, lastToolUses: toolUses });
+    const turn = ensureTurn(state, envelopes);
+    maybeEmitSubagentStart(state, turn, subagent, envelopes);
+    envelopes.push(createEnvelope("agent", {
+      t: "progress",
+      toolUses,
+      ...typeof raw.last_tool_name === "string" && raw.last_tool_name ? { lastTool: raw.last_tool_name } : {},
+      ...usage?.totalTokens !== void 0 ? { totalTokens: usage.totalTokens } : {},
+      ...usage?.durationMs !== void 0 ? { durationMs: usage.durationMs } : {},
+      ...typeof raw.summary === "string" && raw.summary.trim() ? { summary: raw.summary.trim() } : {}
+    }, { turn, subagent }));
+    return;
+  }
+  if (subtype === "task_notification") {
+    const status = raw.status === "completed" || raw.status === "failed" || raw.status === "stopped" ? raw.status : "completed";
+    emitSubagentStopWithStatus(state, state.currentTurnId ?? void 0, subagent, envelopes, {
+      status,
+      ...usage ? { usage } : {}
+    });
+    getStubSubagents(state).delete(subagent);
+    getProgressThrottle(state).delete(subagent);
+    return;
+  }
+  if (subtype === "task_updated" && raw.patch?.is_backgrounded === true) {
+    getStubSubagents(state).add(subagent);
+  }
+}
+function mapClaudeLogMessageToSessionEnvelopesInternal(message, state) {
+  const envelopes = [];
+  const claudeUuid = pickUuid(message);
+  const providerSubagent = resolveProviderSubagent(message, state);
+  const subagent = providerSubagent ? getSessionSubagentIdForProviderSubagent(state, providerSubagent) : void 0;
+  rememberSubagentForMessage(message, state, providerSubagent);
+  if (providerSubagent && !subagent) {
+    bufferSubagentMessage(state, providerSubagent, message);
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes: []
+    };
+  }
+  if (message.type === "summary") {
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes
+    };
+  }
+  if (message.type === "system") {
+    mapTaskLifecycleSystemMessage(message, state, envelopes);
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes
+    };
+  }
+  if (message.isCompactSummary) {
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes
+    };
+  }
+  if (message.type === "assistant") {
+    const assistantError = message.error;
+    if (!message.isSidechain && typeof assistantError === "string" && assistantError.trim()) {
+      state.pendingAssistantError = assistantError.trim();
+    }
+    const turnId = ensureTurn(state, envelopes);
+    maybeEmitSubagentStart(state, turnId, subagent, envelopes);
+    const usage = pickAssistantUsage(message);
+    const blocks = Array.isArray(message.message?.content) ? message.message.content : [];
+    const apiMessageId = !isSidechainMessage(message) && typeof message.message?.id === "string" && message.message.id.length > 0 ? message.message.id : void 0;
+    let blockCursor = 0;
+    if (apiMessageId) {
+      if (state.streamBlockMessageId !== apiMessageId) {
+        state.streamBlockMessageId = apiMessageId;
+        state.streamBlockCursor = 0;
+      }
+      blockCursor = state.streamBlockCursor ?? 0;
+      state.streamBlockCursor = blockCursor + blocks.length;
+    }
+    const actualModel = subagent && typeof message.message?.model === "string" && message.message.model.trim() ? { actualModel: message.message.model.trim() } : {};
+    const draftKey = (index) => apiMessageId ? streamKeyOf(apiMessageId, blockCursor + index) : void 0;
+    for (const [blockIndex, block] of blocks.entries()) {
+      if (block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) {
+        envelopes.push(createEnvelope("agent", { t: "text", text: block.text, ...actualModel }, { turn: turnId, subagent, claudeUuid, usage, streamKey: draftKey(blockIndex) }));
+        continue;
+      }
+      if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim().length > 0) {
+        envelopes.push(createEnvelope("agent", { t: "text", text: block.thinking, thinking: true, ...actualModel }, { turn: turnId, subagent, claudeUuid, usage, streamKey: draftKey(blockIndex) }));
+        continue;
+      }
+      if (block.type === "tool_use") {
+        const call = typeof block.id === "string" && block.id.length > 0 ? block.id : createId();
+        const name = typeof block.name === "string" && block.name.length > 0 ? block.name : "unknown";
+        const baseArgs = toToolArgs(block.input);
+        const title = toolTitle(name, block.input);
+        const sessionSubagentForCall = ensureSessionSubagentIdForProviderSubagent(state, call);
+        if (isSubagentTool(name)) {
+          const prompt = pickTaskPrompt(block.input);
+          if (prompt) {
+            queueTaskPromptSubagent(state, prompt, call);
+          }
+          setSubagentTitle(state, sessionSubagentForCall, pickTaskTitle(block.input) ?? prompt);
+          getAgentToolCalls(state).add(call);
+          const input = block.input ?? {};
+          rememberSubagentMeta(state, sessionSubagentForCall, { description: input.description, subagentType: input.subagent_type });
+        }
+        if (shouldHideParentToolCall(name)) {
+          getHiddenParentToolCalls(state).add(call);
+          const buffered2 = consumeBufferedSubagentMessages(state, call);
+          for (const bufferedMessage of buffered2) {
+            const replay = mapClaudeLogMessageToSessionEnvelopesInternal(bufferedMessage, state);
+            envelopes.push(...replay.envelopes);
+          }
+          continue;
+        }
+        if (name === "Bash") (state.bashToolCalls ??= /* @__PURE__ */ new Set()).add(call);
+        const args = isSubagentTool(name) || name === "Bash" ? { ...baseArgs, sessionSubagent: sessionSubagentForCall } : baseArgs;
+        envelopes.push(createEnvelope("agent", {
+          t: "tool-call-start",
+          call,
+          name,
+          title,
+          description: title,
+          args
+        }, { turn: turnId, subagent, usage }));
+        const buffered = consumeBufferedSubagentMessages(state, call);
+        for (const bufferedMessage of buffered) {
+          const replay = mapClaudeLogMessageToSessionEnvelopesInternal(bufferedMessage, state);
+          envelopes.push(...replay.envelopes);
+        }
+      }
+    }
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes
+    };
+  }
+  if (message.type === "user") {
+    if (message.isMeta) {
+      return {
+        currentTurnId: state.currentTurnId,
+        envelopes
+      };
+    }
+    if (typeof message.message.content === "string") {
+      if (message.isSidechain) {
+        const turnId2 = ensureTurn(state, envelopes);
+        maybeEmitSubagentStart(state, turnId2, subagent, envelopes);
+        envelopes.push(createEnvelope("agent", { t: "text", text: message.message.content }, { turn: turnId2, subagent, claudeUuid }));
+      } else {
+        const origin = message.origin;
+        if (origin?.kind === "task-notification" || /<task-notification>/i.test(message.message.content)) {
+          const fields = parseTaskNotificationText(message.message.content);
+          const providerId = fields?.toolUseId ?? null;
+          const subagentForNotification = providerId && getAgentToolCalls(state).has(providerId) ? getSessionSubagentIdForProviderSubagent(state, providerId) : void 0;
+          if (fields && subagentForNotification && (fields.result || fields.status)) {
+            emitSubagentStopWithStatus(state, state.currentTurnId ?? void 0, subagentForNotification, envelopes, {
+              ...fields.status ? { status: fields.status } : {},
+              ...fields.result ? { result: fields.result } : {}
+            });
+          }
+        }
+        closeTurn(state, "completed", envelopes);
+        envelopes.push(createEnvelope("user", { t: "text", text: message.message.content }, { claudeUuid }));
+      }
+      return {
+        currentTurnId: state.currentTurnId,
+        envelopes
+      };
+    }
+    const blocks = Array.isArray(message.message.content) ? message.message.content : [];
+    if (blocks.length === 0) {
+      return {
+        currentTurnId: state.currentTurnId,
+        envelopes
+      };
+    }
+    const turnId = ensureTurn(state, envelopes);
+    if (message.isSidechain) {
+      maybeEmitSubagentStart(state, turnId, subagent, envelopes);
+    }
+    for (const block of blocks) {
+      if (block.type === "tool_result" && typeof block.tool_use_id === "string" && block.tool_use_id.length > 0) {
+        const sessionSubagentForToolResult = getSessionSubagentIdForProviderSubagent(state, block.tool_use_id);
+        if (!message.isSidechain) {
+          if (getHiddenParentToolCalls(state).has(block.tool_use_id)) {
+            if (sessionSubagentForToolResult) {
+              maybeEmitSubagentStop(state, turnId, sessionSubagentForToolResult, envelopes);
+            }
+            getHiddenParentToolCalls(state).delete(block.tool_use_id);
+            continue;
+          }
+          if (sessionSubagentForToolResult && getAgentToolCalls(state).has(block.tool_use_id)) {
+            const toolUseResult = message.tool_use_result;
+            const resultStatus = toolUseResultStatus(toolUseResult);
+            if (resultStatus === "async_launched") {
+              getStubSubagents(state).add(sessionSubagentForToolResult);
+              envelopes.push(createEnvelope("agent", { t: "tool-call-end", call: block.tool_use_id }, { turn: turnId, subagent }));
+              continue;
+            }
+            if (resultStatus === "completed") {
+              const text = toolUseResultToText(toolUseResult);
+              const stats = toolUseResultStats(toolUseResult);
+              const result = text ? capSubagentText(text) : void 0;
+              emitSubagentStopWithStatus(state, turnId, sessionSubagentForToolResult, envelopes, {
+                status: "completed",
+                ...result ? { result } : {},
+                ...stats ? { usage: { toolUses: stats.toolUses, totalTokens: stats.totalTokens, durationMs: stats.durationMs } } : {}
+              });
+              envelopes.push(createEnvelope("agent", {
+                t: "tool-call-end",
+                call: block.tool_use_id,
+                ...result ? { result: { ...result, ...stats ? { stats } : {} } } : {}
+              }, { turn: turnId, subagent }));
+              continue;
+            }
+          }
+          if (sessionSubagentForToolResult && !state.backgroundBashCalls?.has(block.tool_use_id)) {
+            maybeEmitSubagentStop(state, turnId, sessionSubagentForToolResult, envelopes);
+          }
+        }
+        envelopes.push(createEnvelope("agent", {
+          t: "tool-call-end",
+          call: block.tool_use_id
+        }, { turn: turnId, subagent }));
+        continue;
+      }
+      if (block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) {
+        envelopes.push(createEnvelope("agent", { t: "text", text: block.text }, { turn: turnId, subagent, claudeUuid }));
+      }
+    }
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes
+    };
+  }
+  if (message.type === "result") {
+    const raw = message;
+    const status = raw.interrupted === true ? "cancelled" : raw.is_error === true ? "failed" : "completed";
+    const error = status === "failed" ? raw.errors?.filter((item) => typeof item === "string" && item.trim()).join("\n") || state.pendingAssistantError || raw.subtype || "Claude turn failed" : void 0;
+    if (status === "failed" && !state.currentTurnId) {
+      ensureTurn(state, envelopes);
+    }
+    const usage = raw.usage && typeof raw.usage.input_tokens === "number" && typeof raw.usage.output_tokens === "number" ? {
+      input_tokens: raw.usage.input_tokens,
+      output_tokens: raw.usage.output_tokens,
+      ...typeof raw.usage.cache_creation_input_tokens === "number" ? { cache_creation_input_tokens: raw.usage.cache_creation_input_tokens } : {},
+      ...typeof raw.usage.cache_read_input_tokens === "number" ? { cache_read_input_tokens: raw.usage.cache_read_input_tokens } : {}
+    } : void 0;
+    closeTurn(state, status, envelopes, {
+      error,
+      costUsd: typeof raw.total_cost_usd === "number" ? raw.total_cost_usd : void 0,
+      durationMs: typeof raw.duration_ms === "number" ? raw.duration_ms : void 0,
+      numTurns: typeof raw.num_turns === "number" ? raw.num_turns : void 0,
+      usage
+    });
+    return {
+      currentTurnId: state.currentTurnId,
+      envelopes
+    };
+  }
+  return {
+    currentTurnId: state.currentTurnId,
+    envelopes
+  };
+}
+
+function sessionEnvelopeOf(body) {
+  if (!body || typeof body !== "object") return null;
+  const record = body;
+  if (record.role !== "session" || !record.content || typeof record.content !== "object") return null;
+  const content = record.content;
+  if (content.type === "session" && content.data && typeof content.data === "object") {
+    return content.data;
+  }
+  if (content.ev !== void 0) return content;
+  return null;
+}
+function isQueuedUserText(body) {
+  if (!body || typeof body !== "object") return false;
+  const record = body;
+  return record.role === "user" && record.content?.type === "text" && typeof record.meta?.queuedAt === "number";
+}
+function scanUndeliveredQueuedInputs(records, prior) {
+  const canceled = prior?.canceled ?? /* @__PURE__ */ new Set();
+  const undelivered = [];
+  let reachedBoundary = false;
+  for (const record of records) {
+    const envelope = sessionEnvelopeOf(record.body);
+    if (envelope) {
+      const t = envelope.ev?.t;
+      if (t === "turn-end") {
+        reachedBoundary = true;
+        break;
+      }
+      if (t === "queue-cancel" && Array.isArray(envelope.ev?.targetLocalKeys)) {
+        for (const key of envelope.ev.targetLocalKeys) {
+          if (typeof key === "string") canceled.add(key);
+        }
+      }
+      continue;
+    }
+    if (isQueuedUserText(record.body) && record.localId && !canceled.has(record.localId)) {
+      undelivered.push(record.localId);
+    }
+  }
+  return { undeliveredLocalKeys: undelivered, reachedBoundary, canceled };
+}
+
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function firstNumber(source, keys) {
+  for (const key of keys) {
+    const value = finiteNonNegative(source[key]);
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function normalizeAgentUsage(raw) {
+  const outer = record(raw);
+  if (!outer) return null;
+  const wrapped = record(outer.totalTokenUsage) ?? record(outer.total_token_usage) ?? record(outer.total) ?? record(outer.usage) ?? outer;
+  const input = firstNumber(wrapped, ["inputTokens", "input_tokens", "input"]);
+  const output = firstNumber(wrapped, ["outputTokens", "output_tokens", "output"]);
+  const cacheRead = firstNumber(wrapped, ["cachedInputTokens", "cached_input_tokens", "cachedReadTokens", "cacheReadInputTokens", "cache_read_input_tokens", "cache_read"]);
+  const cacheCreation = firstNumber(wrapped, ["cacheCreationInputTokens", "cache_creation_input_tokens", "cachedWriteTokens", "cacheWriteInputTokens", "cache_write_input_tokens", "cache_creation"]);
+  const reasoning = firstNumber(wrapped, ["reasoningOutputTokens", "reasoning_output_tokens", "thoughtTokens", "reasoning"]);
+  const explicitTotal = firstNumber(wrapped, ["totalTokens", "total_tokens", "total"]);
+  const fallbackTotal = input !== void 0 || output !== void 0 ? (input ?? 0) + (output ?? 0) : void 0;
+  const total = explicitTotal ?? fallbackTotal;
+  if (total === void 0) return null;
+  return {
+    total,
+    ...input !== void 0 ? { input } : {},
+    ...output !== void 0 ? { output } : {},
+    ...cacheCreation !== void 0 ? { cache_creation: cacheCreation } : {},
+    ...cacheRead !== void 0 ? { cache_read: cacheRead } : {},
+    ...reasoning !== void 0 ? { reasoning } : {}
+  };
+}
+function usageAgentKey(agent) {
+  return agent.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+
+const TURN_LEASE_MS = 6e4;
+const TURN_BUSY_TTL_MS = 15e4;
+class TurnActivityTracker {
+  constructor(ttlMs = TURN_BUSY_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  busy = /* @__PURE__ */ new Map();
+  apply(sessionId, event, now = Date.now()) {
+    if (event === "turn_started") this.busy.set(sessionId, now);
+    else this.busy.delete(sessionId);
+  }
+  /** The wrapper is gone: whatever it reported no longer holds. */
+  forget(sessionId) {
+    this.busy.delete(sessionId);
+  }
+  /** Sessions whose last renewal is still inside the TTL. */
+  activeSessions(now = Date.now()) {
+    const out = [];
+    for (const [id, at] of this.busy) {
+      if (now - at <= this.ttlMs) out.push(id);
+      else this.busy.delete(id);
+    }
+    return out;
+  }
+  hasActiveTurn(now = Date.now()) {
+    return this.activeSessions(now).length > 0;
+  }
+}
+class TurnReporter {
+  constructor(send, leaseMs = TURN_LEASE_MS) {
+    this.send = send;
+    this.leaseMs = leaseMs;
+  }
+  thinking = false;
+  lastStartedAt = 0;
+  /** Called on every keepAlive tick; emits only on an edge or a due renewal. */
+  observe(thinking, now = Date.now()) {
+    if (thinking) {
+      const due = !this.thinking || now - this.lastStartedAt >= this.leaseMs;
+      this.thinking = true;
+      if (!due) return null;
+      this.lastStartedAt = now;
+      this.send("turn_started");
+      return "turn_started";
+    }
+    if (!this.thinking) return null;
+    this.thinking = false;
+    this.lastStartedAt = 0;
+    this.send("turn_ended");
+    return "turn_ended";
+  }
+}
+
+const PROMPT_QUEUE_INFLIGHT_TIMEOUT_MS = 2e4;
+const PROMPT_QUEUE_RETRY_MIN_MS = 1e3;
+const PROMPT_QUEUE_RETRY_MAX_MS = 3e4;
+class PromptQueueDrain {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+    this.log = deps.log ?? (() => {
+    });
+    this.schedule = deps.schedule ?? ((fn, delayMs) => {
+      const timer = setTimeout(fn, delayMs);
+      timer.unref?.();
+    });
+    this.inflightTimeoutMs = deps.inflightTimeoutMs ?? PROMPT_QUEUE_INFLIGHT_TIMEOUT_MS;
+  }
+  inflight = null;
+  /**
+   * localIds routed while a dispatch call was still in flight. The server's
+   * `new-message` echo regularly beats the HTTP response (both come off the
+   * same transaction), so `onInbound` can precede the `dispatched` outcome;
+   * without this the guard armed AFTER the message had arrived and sat
+   * until the timeout — observed in the first isolated e2e run.
+   */
+  arrivedDuringDispatch = /* @__PURE__ */ new Set();
+  /** Items the server still holds, from the last snapshot / dispatch response. */
+  pending = 0;
+  disabled = false;
+  closed = false;
+  busy = false;
+  failures = 0;
+  retryAt = 0;
+  retryScheduled = false;
+  now;
+  log;
+  schedule;
+  inflightTimeoutMs;
+  /** The runner is blocked on an empty input queue. */
+  onIdle() {
+    void this.maybeDispatch("idle");
+  }
+  /** A `prompt-queue` snapshot arrived; only a non-empty queue is worth a call. */
+  onQueueChanged(count) {
+    this.pending = Math.max(0, count);
+    if (count > 0) void this.maybeDispatch("queue-changed");
+  }
+  /**
+   * True while the server still holds queued prompts for this session. The
+   * runners fold it into their "idle, waiting for the user" judgement so a
+   * turn that ends with more queue behind it raises no reply_done /
+   * input_needed notification and no daemon `completed` report per item.
+   */
+  hasPending() {
+    return !this.disabled && !this.closed && this.pending > 0;
+  }
+  /** A user message with this localId was routed into the runner's queue. */
+  onInbound(localId) {
+    if (this.inflight?.localId === localId) {
+      this.inflight = null;
+      return;
+    }
+    if (this.busy) {
+      this.arrivedDuringDispatch.add(localId);
+      if (this.arrivedDuringDispatch.size > 64) {
+        const oldest = this.arrivedDuringDispatch.values().next().value;
+        if (oldest !== void 0) this.arrivedDuringDispatch.delete(oldest);
+      }
+    }
+  }
+  close() {
+    this.closed = true;
+  }
+  state() {
+    return { inflight: this.inflight, disabled: this.disabled, busy: this.busy, failures: this.failures, retryAt: this.retryAt, pending: this.pending };
+  }
+  async maybeDispatch(reason) {
+    if (this.closed || this.disabled || this.busy) return false;
+    const now = this.now();
+    if (this.inflight) {
+      if (now - this.inflight.since < this.inflightTimeoutMs) return false;
+      this.log(`[prompt-queue] inflight ${this.inflight.localId} not routed within ${this.inflightTimeoutMs}ms; releasing`);
+      this.inflight = null;
+    }
+    if (now < this.retryAt) {
+      this.scheduleRetry(this.retryAt - now);
+      return false;
+    }
+    if (!this.deps.isIdle()) return false;
+    this.busy = true;
+    this.arrivedDuringDispatch.clear();
+    try {
+      const outcome = await this.deps.dispatch();
+      switch (outcome.kind) {
+        case "dispatched": {
+          this.failures = 0;
+          if (typeof outcome.remaining === "number") this.pending = Math.max(0, outcome.remaining);
+          const alreadyRouted = this.arrivedDuringDispatch.delete(outcome.localId) || outcome.created === false;
+          if (!alreadyRouted) {
+            this.inflight = { localId: outcome.localId, since: this.now() };
+            this.schedule(() => {
+              void this.maybeDispatch("inflight-timeout");
+            }, this.inflightTimeoutMs + 1);
+          }
+          this.log(`[prompt-queue] dispatched ${outcome.localId} (${reason}${alreadyRouted ? ", already routed" : ""})`);
+          return true;
+        }
+        case "empty":
+          this.failures = 0;
+          this.pending = 0;
+          return false;
+        case "unsupported":
+          this.disabled = true;
+          this.log("[prompt-queue] server has no prompt queue; drain disabled for this process");
+          return false;
+        case "error": {
+          this.failures += 1;
+          const delay = Math.min(PROMPT_QUEUE_RETRY_MAX_MS, PROMPT_QUEUE_RETRY_MIN_MS * 2 ** (this.failures - 1));
+          this.retryAt = this.now() + delay;
+          this.log(`[prompt-queue] dispatch failed (${outcome.message}); retry in ${delay}ms`);
+          this.scheduleRetry(delay);
+          return false;
+        }
+      }
+    } finally {
+      this.busy = false;
+      this.arrivedDuringDispatch.clear();
+    }
+  }
+  scheduleRetry(delayMs) {
+    if (this.retryScheduled || this.closed) return;
+    this.retryScheduled = true;
+    this.schedule(() => {
+      this.retryScheduled = false;
+      void this.maybeDispatch("retry");
+    }, delayMs);
+  }
+}
+
+class ApiSessionClient extends EventEmitter {
+  /**
+   * B-512: the session socket now connects before the runner has attached its
+   * `archived` listener (registerKillSessionHandler). An archive signal that
+   * fires in that window must not be lost: remember it and replay it to any
+   * listener attached later.
+   */
+  archiveSignalled = false;
+  emit(event, ...args) {
+    if (event === "archived") this.archiveSignalled = true;
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    super.on(event, listener);
+    if (event === "archived" && this.archiveSignalled) queueMicrotask(() => listener());
+    return this;
+  }
+  token;
+  sessionId;
+  metadata;
+  metadataVersion;
+  agentState;
+  agentStateVersion;
+  socket;
+  relaySocket = null;
+  pendingMessages = [];
+  pendingMessageCallback = null;
+  pendingFileEvents = [];
+  pendingFileEventCallback = null;
+  blobKey = null;
+  /**
+   * In-flight attachment download promises that belong to the *current*
+   * (not-yet-drained) batch. Each promise resolves to the decoded blob (or
+   * null on failure), so per-message ownership is intrinsic — there is no
+   * shared push-array between batches that a late download could leak into.
+   */
+  pendingDownloads = [];
+  rpcHandlerManager;
+  agentStateLock = new AsyncLock();
+  metadataLock = new AsyncLock();
+  encryptionKey;
+  encryptionVariant;
+  reconnectInterval = null;
+  ignoreArchiveSignal = false;
+  skipInitialMessages = false;
+  claudeSessionProtocolState = {
+    currentTurnId: null,
+    uuidToProviderSubagent: /* @__PURE__ */ new Map(),
+    taskPromptToSubagents: /* @__PURE__ */ new Map(),
+    providerSubagentToSessionSubagent: /* @__PURE__ */ new Map(),
+    subagentTitles: /* @__PURE__ */ new Map(),
+    bufferedSubagentMessages: /* @__PURE__ */ new Map(),
+    hiddenParentToolCalls: /* @__PURE__ */ new Set(),
+    startedSubagents: /* @__PURE__ */ new Set(),
+    activeSubagents: /* @__PURE__ */ new Set()
+  };
+  seenClaudeUsageEvents = /* @__PURE__ */ new Set();
+  claudeUsageTotals = {
+    total: 0,
+    input: 0,
+    output: 0,
+    cache_creation: 0,
+    cache_read: 0,
+    costTotal: 0,
+    costInput: 0,
+    costOutput: 0
+  };
+  lastSeq = 0;
+  pendingOutbox = [];
+  sendSync;
+  receiveSync;
+  directInboundLocalIds = /* @__PURE__ */ new Set();
+  routedInboundLocalIds = /* @__PURE__ */ new Set();
+  handoverInFlight = null;
+  /** B-265 reconnect: the message cursor was seeded from the server, so
+   *  nothing before it is history to replay — but socket fast-path routing
+   *  must wait for the first fetch, otherwise a message that lands between
+   *  the seed and the first fetch is routed twice (socket + fetch). */
+  awaitingInitialFetch = false;
+  /** B-509: server-side prompt queue drain, attached by the runner. */
+  promptQueueDrain = null;
+  constructor(token, session, opts) {
+    super();
+    this.token = token;
+    this.sessionId = session.id;
+    if (opts?.initialSeq !== void 0 && opts.initialSeq >= 0) {
+      this.lastSeq = opts.initialSeq;
+      this.awaitingInitialFetch = true;
+    }
+    this.metadata = session.metadata;
+    this.metadataVersion = session.metadataVersion;
+    this.agentState = session.agentState;
+    this.agentStateVersion = session.agentStateVersion;
+    this.encryptionKey = session.encryptionKey;
+    this.encryptionVariant = session.encryptionVariant;
+    this.sendSync = new InvalidateSync(() => this.flushOutbox());
+    this.receiveSync = new InvalidateSync(() => this.fetchMessages());
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.sessionId,
+      encryptionKey: this.encryptionKey,
+      encryptionVariant: this.encryptionVariant,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    registerCommonHandlers(this.rpcHandlerManager, this.metadata.path);
+    this.socket = this.createControlSocket();
+    const controlSocket = this.socket;
+    this.socket.on("connect", () => {
+      logger.debug("Socket connected successfully");
+      if (this.reconnectInterval) {
+        clearInterval(this.reconnectInterval);
+        this.reconnectInterval = null;
+      }
+      this.rpcHandlerManager.onSocketConnect(controlSocket);
+      this.receiveSync.invalidate();
+      void this.connectSessionRelay();
+      void this.promptQueueDrain?.maybeDispatch("connect");
+    });
+    this.socket.on("rpc-request", async (data, callback) => {
+      await answerSocketRequest(
+        callback,
+        () => this.rpcHandlerManager.handleRequest(data),
+        (drop) => logger.debug(`[API] RPC ${data?.method} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+      );
+    });
+    this.socket.on("disconnect", (reason) => {
+      logger.debug(`[API] Socket disconnected: ${reason}`);
+      this.rpcHandlerManager.onSocketDisconnect(controlSocket);
+      this.startSmartReconnect();
+    });
+    this.socket.on("connect_error", (error) => {
+      logger.debug("[API] Socket connection error:", error);
+      this.rpcHandlerManager.onSocketDisconnect(controlSocket);
+      if (error.message === "Session archived") {
+        logger.debug("[API] Archived session rejected during reconnect; exiting");
+        this.emit("archived");
+        return;
+      }
+      this.startSmartReconnect();
+    });
+    this.socket.on("session-archive", ({ sessionId }) => {
+      if (sessionId !== this.sessionId) return;
+      logger.debug("[SOCKET] Server archived this session; exiting...");
+      this.emit("archived");
+    });
+    this.socket.on("update", (data) => {
+      try {
+        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
+        if (!data.body) {
+          logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
+          return;
+        }
+        if (data.body.t === "prompt-queue") {
+          const items = data.body.items;
+          this.promptQueueDrain?.onQueueChanged(Array.isArray(items) ? items.length : 0);
+          return;
+        }
+        if (data.body.t === "new-message") {
+          const messageSeq = data.body.message?.seq;
+          if (this.lastSeq === 0 || this.awaitingInitialFetch) {
+            this.receiveSync.invalidate();
+            return;
+          }
+          if (typeof messageSeq !== "number" || messageSeq !== this.lastSeq + 1 || data.body.message.content.t !== "encrypted") {
+            this.receiveSync.invalidate();
+            return;
+          }
+          const localId = data.body.message.localId;
+          const relayAccepted = !!localId && this.directInboundLocalIds.delete(localId);
+          if (localId && this.routedInboundLocalIds.has(localId)) {
+            this.lastSeq = messageSeq;
+            return;
+          }
+          if (relayAccepted) {
+            logger.debug(`[API] Routing relay-accepted message ${localId} from the central echo (own persist still pending or failed)`);
+          }
+          const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.message.content.c));
+          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          this.routeIncomingMessage(body, localId);
+          if (localId) this.rememberRoutedInbound(localId);
+          this.lastSeq = messageSeq;
+        } else if (data.body.t === "update-session") {
+          if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
+            this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.metadata.value));
+            this.metadataVersion = data.body.metadata.version;
+            const meta = this.metadata;
+            if (meta?.lifecycleState === "archiveRequested" || meta?.lifecycleState === "archived") {
+              if (this.ignoreArchiveSignal) {
+                logger.debug(`[SOCKET] Session archived (${meta.lifecycleState}) but suppressed for reconnect`);
+                this.ignoreArchiveSignal = false;
+              } else {
+                logger.debug(`[SOCKET] Session archived (${meta.lifecycleState}), exiting...`);
+                this.emit("archived");
+              }
+            }
+          }
+          if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+            this.agentState = data.body.agentState.value ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(data.body.agentState.value)) : null;
+            this.agentStateVersion = data.body.agentState.version;
+          }
+        } else if (data.body.t === "update-machine") {
+          logger.debug(`[SOCKET] WARNING: Session client received unexpected machine update - ignoring`);
+        } else {
+          this.emit("message", data.body);
+        }
+      } catch (error) {
+        logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
+      }
+    });
+    this.socket.on("error", (error) => {
+      logger.debug("[API] Socket error:", error);
+    });
+    this.socket.on("server-draining", (data) => {
+      const parsed = ReleaseDrainNoticeSchema.safeParse(data);
+      if (!parsed.success || parsed.data.deadline <= Date.now()) return;
+      void this.startReleaseHandover(parsed.data);
+    });
+    this.socket.connect();
+  }
+  createControlSocket(handover) {
+    return io(configuration.serverUrl, {
+      auth: {
+        token: this.token,
+        clientType: "session-scoped",
+        sessionId: this.sessionId,
+        happyClient: `cli-coding-session/${configuration.currentCliVersion}`,
+        ...handover ? { handoverEpoch: handover.epoch } : {}
+      },
+      ...handover ? { query: { vh_slot: handover.candidateSlot }, forceNew: true } : {},
+      path: "/v1/updates",
+      reconnection: false,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+  }
+  startReleaseHandover(notice) {
+    if (this.handoverInFlight) return this.handoverInFlight;
+    this.handoverInFlight = this.releaseHandover(notice).finally(() => {
+      this.handoverInFlight = null;
+    });
+    return this.handoverInFlight;
+  }
+  async releaseHandover(notice) {
+    const startedAt = Date.now();
+    const previous = this.socket;
+    const candidate = this.createControlSocket(notice);
+    const transferredListeners = /* @__PURE__ */ new Map();
+    for (const listener of previous.listeners("rpc-request")) candidate.on("rpc-request", listener);
+    const timeoutMs = Math.max(1, Math.min(1e4, notice.deadline - Date.now()));
+    try {
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("release handover timeout")), timeoutMs);
+        candidate.once("connect", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        candidate.once("connect_error", (error) => {
+          clearTimeout(timer);
+          reject(error);
+        });
+        candidate.connect();
+      });
+      await this.rpcHandlerManager.onSocketConnectAndWait(candidate, timeoutMs);
+      if (this.socket !== previous) {
+        this.rpcHandlerManager.onSocketDisconnect(candidate);
+        candidate.close();
+        return;
+      }
+      for (const event of ["session-archive", "update", "error", "server-draining"]) {
+        const listeners = previous.listeners(event);
+        previous.removeAllListeners(event);
+        for (const listener of listeners) candidate.on(event, listener);
+        transferredListeners.set(event, listeners);
+      }
+      this.socket = candidate;
+      candidate.on("connect", () => {
+        if (this.reconnectInterval) {
+          clearInterval(this.reconnectInterval);
+          this.reconnectInterval = null;
+        }
+        this.rpcHandlerManager.onSocketConnect(candidate);
+        this.receiveSync.invalidate();
+      });
+      candidate.on("disconnect", () => {
+        this.rpcHandlerManager.onSocketDisconnect(candidate);
+        this.startSmartReconnect();
+      });
+      candidate.on("connect_error", () => {
+        this.rpcHandlerManager.onSocketDisconnect(candidate);
+        this.startSmartReconnect();
+      });
+      this.receiveSync.invalidate();
+      candidate.emit("release-handover-result", { result: "success", durationMs: Date.now() - startedAt });
+      this.rpcHandlerManager.onSocketDisconnect(previous);
+      previous.removeAllListeners("disconnect");
+      previous.close();
+    } catch (error) {
+      if (this.socket === candidate) this.socket = previous;
+      for (const [event, listeners] of transferredListeners) {
+        candidate.removeAllListeners(event);
+        for (const listener of listeners) previous.on(event, listener);
+      }
+      this.rpcHandlerManager.onSocketDisconnect(candidate);
+      candidate.close();
+      if (previous.connected) previous.emit("release-handover-result", { result: "failed", durationMs: Date.now() - startedAt });
+      logger.debug(`[API] Release handover failed: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  onUserMessage(callback) {
+    this.pendingMessageCallback = callback;
+    while (this.pendingMessages.length > 0) {
+      callback(this.pendingMessages.shift());
+    }
+  }
+  onFileEvent(callback) {
+    this.pendingFileEventCallback = callback;
+    while (this.pendingFileEvents.length > 0) {
+      callback(this.pendingFileEvents.shift());
+    }
+  }
+  /**
+   * Derive (and cache) the blob decryption key for this session.
+   * Legacy sessions use deriveKey(masterSecret, 'Happy Blobs', ['master']).
+   * DataKey sessions use deriveKey(dataKey, 'Happy Blobs', ['session']).
+   */
+  async getBlobKey() {
+    if (!this.blobKey) {
+      const path = this.encryptionVariant === "dataKey" ? ["session"] : ["master"];
+      this.blobKey = await deriveKey(this.encryptionKey, "Happy Blobs", path);
+    }
+    return this.blobKey;
+  }
+  /**
+   * Download an encrypted attachment blob via the request-download flow:
+   * POST /request-download → { downloadUrl } → GET downloadUrl. Local mode
+   * downloadUrl points back at our server (Bearer required); S3 mode is a
+   * presigned URL that does not accept extra headers.
+   */
+  async downloadAttachment(ref) {
+    const requestUrl = `${configuration.serverUrl}/v1/sessions/${this.sessionId}/attachments/request-download`;
+    const requestRes = await axios.post(
+      requestUrl,
+      { ref },
+      {
+        headers: { "Authorization": `Bearer ${this.token}`, "Content-Type": "application/json" },
+        timeout: 3e4
+      }
+    );
+    const downloadUrl = requestRes.data?.downloadUrl;
+    if (typeof downloadUrl !== "string") {
+      throw new Error("request-download returned no downloadUrl");
+    }
+    const isServerUrl = downloadUrl.startsWith(configuration.serverUrl);
+    const headers = {};
+    if (isServerUrl) {
+      headers["Authorization"] = `Bearer ${this.token}`;
+    }
+    const response = await axios.get(downloadUrl, {
+      headers,
+      responseType: "arraybuffer",
+      timeout: 6e4,
+      maxRedirects: 5,
+      maxContentLength: MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES,
+      maxBodyLength: MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES
+    });
+    return new Uint8Array(response.data);
+  }
+  /**
+   * Download and decrypt an attachment blob.
+   * Returns the decrypted binary data or null if decryption fails.
+   */
+  async downloadAndDecryptAttachment(ref) {
+    const encrypted = await this.downloadAttachment(ref);
+    const key = await this.getBlobKey();
+    const decrypted = decryptBlob(encrypted, key);
+    return decrypted;
+  }
+  /**
+   * Track an attachment download whose promise resolves to the decoded blob
+   * (or null on failure). The download stays in the current batch until the
+   * next drainAttachmentsForUserMessage call swaps the bucket out — file
+   * events that arrive after the swap go into a fresh bucket bound to the
+   * next user-text message.
+   */
+  trackAttachmentDownload(promise) {
+    this.pendingDownloads.push(promise);
+  }
+  /**
+   * Atomically claim every download started before this call, wait for them
+   * to resolve, and return the successful ones. The swap-then-await order
+   * guarantees that a late-arriving file event cannot leak into this batch.
+   */
+  async drainAttachmentsForUserMessage() {
+    const downloads = this.pendingDownloads;
+    this.pendingDownloads = [];
+    if (downloads.length === 0) return [];
+    const results = await Promise.all(downloads);
+    return results.filter((x) => x !== null);
+  }
+  authHeaders() {
+    return {
+      "Authorization": `Bearer ${this.token}`,
+      "Content-Type": "application/json",
+      "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+    };
+  }
+  /**
+   * B-509: attach the server-side prompt queue drain. `isIdle` is the
+   * runner's own notion (input queue empty + blocked waiting); dispatching is
+   * `POST /v1/sessions/:id/prompt-queue/dispatch`, whose message then comes
+   * back through the ordinary socket / catch-up path and is routed below.
+   */
+  attachPromptQueueDrain(opts) {
+    this.promptQueueDrain?.close();
+    const drain = new PromptQueueDrain({
+      isIdle: opts.isIdle,
+      dispatch: () => this.dispatchPromptQueueHead(),
+      log: (message) => logger.debug(`[API] ${message}`)
+    });
+    this.promptQueueDrain = drain;
+    return drain;
+  }
+  /** B-509: the server still holds queued prompts for this session (see PromptQueueDrain.hasPending). */
+  promptQueueHasPending() {
+    return this.promptQueueDrain?.hasPending() === true;
+  }
+  /** B-509: stop draining before the process winds down (cleanup's first line). */
+  closePromptQueueDrain() {
+    this.promptQueueDrain?.close();
+  }
+  async dispatchPromptQueueHead() {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(this.sessionId)}/prompt-queue/dispatch`,
+        {},
+        { headers: this.authHeaders(), timeout: 3e4, validateStatus: () => true }
+      );
+      if (response.status === 404) return { kind: "unsupported" };
+      if (response.status !== 200) return { kind: "error", message: `HTTP ${response.status}` };
+      const dispatched = response.data?.dispatched;
+      const remaining = typeof response.data?.remaining === "number" ? response.data.remaining : void 0;
+      if (dispatched && typeof dispatched.localId === "string") {
+        return { kind: "dispatched", localId: dispatched.localId, remaining, created: dispatched.created !== false };
+      }
+      return { kind: "empty" };
+    } catch (error) {
+      return { kind: "error", message: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  routeIncomingMessage(message, sourceLocalId) {
+    if (sourceLocalId) this.promptQueueDrain?.onInbound(sourceLocalId);
+    const messageWithSource = sourceLocalId && typeof message === "object" && message !== null ? { ...message, localKey: message.localKey ?? sourceLocalId } : message;
+    const userResult = UserMessageSchema.safeParse(messageWithSource);
+    if (userResult.success) {
+      if (this.pendingMessageCallback) {
+        this.pendingMessageCallback(userResult.data);
+      } else {
+        this.pendingMessages.push(userResult.data);
+      }
+      return;
+    }
+    const fileResult = FileEventMessageSchema.safeParse(message);
+    if (fileResult.success) {
+      logger.debug(`[API] Received file event: ${fileResult.data.content.data.ev.name} (ref: ${fileResult.data.content.data.ev.ref})`);
+      if (this.pendingFileEventCallback) {
+        this.pendingFileEventCallback(fileResult.data);
+      } else {
+        this.pendingFileEvents.push(fileResult.data);
+      }
+      return;
+    }
+    const role = typeof message === "object" && message !== null ? message.role : void 0;
+    if (role === "user") {
+      logger.debug("[API] Inbound user-role message did not match UserMessageSchema; forwarding as generic message", {
+        sourceLocalId: sourceLocalId ?? null,
+        issues: userResult.error.issues.slice(0, 5).map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+      });
+    }
+    this.emit("message", message);
+  }
+  async fetchMessages() {
+    const skipRouting = this.skipInitialMessages;
+    if (skipRouting) {
+      this.skipInitialMessages = false;
+      logger.debug("[API] Reconnect mode: skipping existing messages, advancing lastSeq");
+    }
+    let afterSeq = this.lastSeq;
+    while (true) {
+      const response = await axios.get(
+        `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+        {
+          params: {
+            after_seq: afterSeq,
+            limit: 100
+          },
+          headers: this.authHeaders(),
+          timeout: 6e4
+        }
+      );
+      const messages = Array.isArray(response.data.messages) ? response.data.messages : [];
+      let maxSeq = afterSeq;
+      for (const message of messages) {
+        if (message.seq > maxSeq) {
+          maxSeq = message.seq;
+        }
+        if (skipRouting) continue;
+        const relayAccepted = !!message.localId && this.directInboundLocalIds.delete(message.localId);
+        if (message.localId && this.routedInboundLocalIds.has(message.localId)) {
+          continue;
+        }
+        if (relayAccepted) {
+          logger.debug(`[API] Routing relay-accepted message ${message.localId} from catch-up fetch (own persist still pending or failed)`);
+        }
+        if (message.content?.t !== "encrypted") {
+          continue;
+        }
+        try {
+          const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(message.content.c));
+          this.routeIncomingMessage(body, message.localId);
+          if (message.localId) this.rememberRoutedInbound(message.localId);
+        } catch (error) {
+          logger.debug("[API] Failed to decrypt fetched message", {
+            sessionId: this.sessionId,
+            seq: message.seq,
+            error
+          });
+        }
+      }
+      this.lastSeq = Math.max(this.lastSeq, maxSeq);
+      const hasMore = !!response.data.hasMore;
+      if (hasMore && maxSeq === afterSeq) {
+        logger.debug("[API] fetchMessages pagination stalled, stopping to avoid infinite loop", {
+          sessionId: this.sessionId,
+          afterSeq
+        });
+        break;
+      }
+      afterSeq = maxSeq;
+      if (!hasMore) {
+        break;
+      }
+    }
+    this.awaitingInitialFetch = false;
+  }
+  static MAX_OUTBOX_BATCH_SIZE = 50;
+  async flushOutbox() {
+    while (this.pendingOutbox.length > 0) {
+      const batchSize = Math.min(this.pendingOutbox.length, ApiSessionClient.MAX_OUTBOX_BATCH_SIZE);
+      const batch = this.pendingOutbox.slice(0, batchSize);
+      const response = await axios.post(
+        `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+        {
+          messages: batch
+        },
+        {
+          headers: this.authHeaders(),
+          timeout: 6e4
+        }
+      );
+      const messages = Array.isArray(response.data.messages) ? response.data.messages : [];
+      const maxSeq = messages.reduce((acc, message) => message.seq > acc ? message.seq : acc, this.lastSeq);
+      this.lastSeq = maxSeq;
+      this.pushCommittedMessagesToRelay(batch, messages);
+      this.pendingOutbox.splice(0, batch.length);
+    }
+  }
+  rememberRoutedInbound(localId) {
+    this.routedInboundLocalIds.add(localId);
+    if (this.routedInboundLocalIds.size > 2e3) {
+      const oldest = this.routedInboundLocalIds.values().next().value;
+      if (oldest) this.routedInboundLocalIds.delete(oldest);
+    }
+  }
+  rememberDirectInbound(localId) {
+    this.directInboundLocalIds.add(localId);
+    if (this.directInboundLocalIds.size > 2e3) {
+      const oldest = this.directInboundLocalIds.values().next().value;
+      if (oldest) this.directInboundLocalIds.delete(oldest);
+    }
+  }
+  async connectSessionRelay() {
+    const machineId = this.metadata?.machineId;
+    if (!machineId || this.relaySocket?.connected) return;
+    try {
+      const response = await fetch(
+        `${configuration.serverUrl}/v1/relays/sessions/${encodeURIComponent(this.sessionId)}/machines/${encodeURIComponent(machineId)}`,
+        { headers: this.authHeaders(), cache: "no-store" }
+      );
+      if (!response.ok) return;
+      const assignment = RelayAssignmentResponseSchema.parse(await response.json()).assignment;
+      if (!assignment) return;
+      const relaySocket = io(assignment.url, {
+        path: "/v1/relay",
+        auth: { token: assignment.token },
+        transports: ["websocket"],
+        reconnection: true,
+        reconnectionDelay: 500,
+        reconnectionDelayMax: 5e3
+      });
+      this.relaySocket?.close();
+      this.relaySocket = relaySocket;
+      relaySocket.on("connect", () => {
+        if (this.relaySocket !== relaySocket) return;
+        this.rpcHandlerManager.onSocketConnect(relaySocket);
+        logger.debug(`[API] Session connected to regional relay ${assignment.relayId}`);
+      });
+      relaySocket.on("rpc-request", async (data, callback) => {
+        await answerSocketRequest(
+          callback,
+          () => this.rpcHandlerManager.handleRequest(data),
+          (drop) => logger.debug(`[API] Relay RPC ${data?.method} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+        );
+      });
+      relaySocket.on("session-message-deliver", async (data, rawCallback) => {
+        const callback = safeAck(rawCallback, (drop) => logger.debug(`[API] session-message-deliver unanswered \u2014 ${describeSocketAckDrop(drop)}`));
+        if (data?.sessionId !== this.sessionId || !Array.isArray(data.messages) || data.messages.length === 0 || data.messages.length > 50) {
+          callback({ ok: false, error: "Invalid session message request" });
+          return;
+        }
+        const unique = /* @__PURE__ */ new Map();
+        for (const item of data.messages) {
+          if (typeof item?.localId !== "string" || !item.localId || typeof item.content !== "string") {
+            callback({ ok: false, error: "Invalid session message request" });
+            return;
+          }
+          if (!unique.has(item.localId)) unique.set(item.localId, { localId: item.localId, content: item.content });
+        }
+        const batch = Array.from(unique.values());
+        for (const item of batch) this.rememberDirectInbound(item.localId);
+        try {
+          const persisted = await axios.post(
+            `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+            { messages: batch },
+            { headers: { ...this.authHeaders(), "X-Happy-Message-Origin": "relay-client" }, timeout: 6e4 }
+          );
+          const stored = Array.isArray(persisted.data.messages) ? persisted.data.messages : [];
+          const storedLocalIds = new Set(stored.map((message) => message.localId));
+          if (batch.some((item) => !storedLocalIds.has(item.localId))) {
+            throw new Error("Central persistence response omitted a session message");
+          }
+          this.lastSeq = stored.reduce((max, message) => Math.max(max, message.seq), this.lastSeq);
+          for (const item of batch) {
+            if (this.routedInboundLocalIds.has(item.localId)) continue;
+            const body = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(item.content));
+            this.routeIncomingMessage(body, item.localId);
+            this.rememberRoutedInbound(item.localId);
+          }
+          callback({ ok: true, messages: stored });
+        } catch (error) {
+          const routed = batch.filter((item) => this.routedInboundLocalIds.has(item.localId)).length;
+          logger.debug(`[API] Relay-delivered persist failed for ${batch.length} message(s) (${routed} already routed via central echo): ${error instanceof Error ? error.message : error}`);
+          for (const item of batch) this.directInboundLocalIds.delete(item.localId);
+          callback({ ok: false, error: error instanceof Error ? error.message : "Failed to persist session messages" });
+        }
+      });
+      relaySocket.on("disconnect", () => {
+        if (this.relaySocket === relaySocket) this.rpcHandlerManager.onSocketDisconnect(relaySocket);
+      });
+    } catch (error) {
+      logger.debug(`[API] Session regional relay unavailable: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  pushCommittedMessagesToRelay(batch, messages) {
+    if (!this.relaySocket?.connected || messages.length === 0) return;
+    const contentByLocalId = new Map(batch.map((item) => [item.localId, item.content]));
+    const committed = messages.flatMap((message) => {
+      if (!message.localId) return [];
+      const content = contentByLocalId.get(message.localId);
+      if (!content) return [];
+      return [{ ...message, content }];
+    });
+    if (committed.length > 0) {
+      this.relaySocket.emit("session-message-committed", {
+        sessionId: this.sessionId,
+        messages: committed
+      });
+    }
+  }
+  enqueueMessage(content, invalidate = true, localId) {
+    const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    this.pendingOutbox.push({
+      content: encrypted,
+      // Deterministic localIds (terminal mirror, B-105) ride the server's
+      // @@unique([sessionId, localId]) for replay idempotency; everything
+      // else keeps the fire-once random id.
+      localId: localId ?? randomUUID()
+    });
+    if (invalidate) {
+      this.sendSync.invalidate();
+    }
+  }
+  /** B-332: emit a queue-cancel tombstone, mirroring the web's own signal. */
+  sendQueueCancelReason(localKeys, reason) {
+    if (localKeys.length === 0) return;
+    const envelope = createEnvelope("user", { t: "queue-cancel", targetLocalKeys: localKeys, reason });
+    this.sendSessionProtocolMessage(envelope);
+  }
+  /**
+   * B-332 site ③: find queued user input this wrapper destroyed (it was still
+   * in the previous wrapper's in-memory queue when it died) and tell the web.
+   *
+   * Walks NEWEST → OLDEST via `before_seq`, decrypting each page, and stops at
+   * the first turn-end. The runner calls this on EVERY reconnect (runClaude /
+   * runCodex), seeded or not: a cursor seeded at the server's latest seq skips
+   * the undelivered tail just as thoroughly as skipExistingMessages does —
+   * and the daemon's resume/restart always seeds, so gating on the skip path
+   * would miss the common case. Best-effort: a failed scan must not take a
+   * session down. Needs no socket; POSTs through the same session-message
+   * channel so the web receives it identically to a cancel-button tombstone.
+   */
+  async cancelUndeliveredQueuedInputs() {
+    const MAX_SCAN_PAGES = 10;
+    const canceled = /* @__PURE__ */ new Set();
+    const undelivered = [];
+    let beforeSeq = 2147483647;
+    let reachedBoundary = false;
+    let pages = 0;
+    try {
+      while (!reachedBoundary && pages < MAX_SCAN_PAGES) {
+        pages += 1;
+        const response = await axios.get(
+          `${configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
+          {
+            params: { before_seq: beforeSeq, limit: 100 },
+            headers: this.authHeaders(),
+            timeout: 6e4
+          }
+        );
+        const messages = Array.isArray(response.data.messages) ? response.data.messages : [];
+        if (messages.length === 0) break;
+        const records = messages.map((message) => {
+          let body = null;
+          try {
+            body = message.content?.t === "encrypted" ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(message.content.c)) : null;
+          } catch (error) {
+            logger.debug("[API] Failed to decrypt during undelivered scan:", error);
+          }
+          return { seq: message.seq, localId: message.localId, body };
+        });
+        const scan = scanUndeliveredQueuedInputs(records, { canceled });
+        for (const key of scan.canceled) canceled.add(key);
+        undelivered.push(...scan.undeliveredLocalKeys);
+        reachedBoundary = scan.reachedBoundary;
+        const oldest = records.at(-1)?.seq;
+        if (oldest === void 0 || messages.length < 100) break;
+        beforeSeq = oldest;
+      }
+    } catch (error) {
+      logger.debug("[API] cancelUndeliveredQueuedInputs scan failed:", error);
+      return;
+    }
+    if (!reachedBoundary) {
+      logger.debug("[API] cancelUndeliveredQueuedInputs found no turn boundary; leaving messages as-is");
+      return;
+    }
+    undelivered.reverse();
+    this.sendQueueCancelReason(undelivered, "restarted");
+  }
+  /**
+   * Send a message to session
+   * @param body - Message body (can be MessageContent or raw content for agent messages)
+   */
+  sendClaudeSessionMessage(body, opts) {
+    this.emit("claude-session-message", body);
+    const mapped = mapClaudeLogMessageToSessionEnvelopes(body, this.claudeSessionProtocolState);
+    this.claudeSessionProtocolState.currentTurnId = mapped.currentTurnId;
+    for (const [envelopeIndex, envelope] of mapped.envelopes.entries()) {
+      this.sendSessionProtocolMessage(envelope, opts?.localIdFor?.(envelopeIndex));
+    }
+    if (body.type === "assistant" && body.message?.usage) {
+      try {
+        const eventId = typeof body.uuid === "string" ? body.uuid : typeof body.message.id === "string" ? body.message.id : void 0;
+        this.sendUsageData(body.message.usage, body.message.model, eventId);
+      } catch (error) {
+        logger.debug("[SOCKET] Failed to send usage data:", error);
+      }
+    }
+    if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
+      this.updateMetadata((metadata) => ({
+        ...metadata,
+        summary: {
+          text: body.summary,
+          updatedAt: Date.now()
+        }
+      }));
+    }
+  }
+  closeClaudeSessionTurn(status = "completed", meta) {
+    this.emit("turn-ended", status);
+    const mapped = closeClaudeTurnWithStatus(this.claudeSessionProtocolState, status, meta);
+    this.claudeSessionProtocolState.currentTurnId = mapped.currentTurnId;
+    for (const envelope of mapped.envelopes) {
+      this.sendSessionProtocolMessage(envelope);
+    }
+  }
+  sendCodexMessage(body) {
+    let content = {
+      role: "agent",
+      content: {
+        type: "codex",
+        data: body
+        // This wraps the entire Claude message
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    this.enqueueMessage(content);
+  }
+  enqueueSessionProtocolEnvelope(envelope, invalidate = true, localId) {
+    const content = {
+      role: "session",
+      content: envelope,
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    this.enqueueMessage(content, invalidate, localId);
+  }
+  sendSessionProtocolMessage(envelope, localId) {
+    this.enqueueSessionProtocolEnvelope(envelope, true, localId);
+  }
+  /**
+   * Send a generic agent message to the session using ACP (Agent Communication Protocol) format.
+   * Works for any agent type (Gemini, Codex, Claude, etc.) - CLI normalizes to unified ACP format.
+   * 
+   * @param provider - The agent provider sending the message (e.g., 'gemini', 'codex', 'claude')
+   * @param body - The message payload (type: 'message' | 'reasoning' | 'tool-call' | 'tool-result')
+   */
+  sendAgentMessage(provider, body) {
+    let content = {
+      role: "agent",
+      content: {
+        type: "acp",
+        provider,
+        data: body
+      },
+      meta: {
+        sentFrom: "cli"
+      }
+    };
+    logger.debug(`[SOCKET] Sending ACP message from ${provider}:`, { type: body.type, hasMessage: "message" in body });
+    this.enqueueMessage(content);
+  }
+  sendSessionEvent(event, id) {
+    let content = {
+      role: "agent",
+      content: {
+        id: id ?? randomUUID(),
+        type: "event",
+        data: event
+      }
+    };
+    this.enqueueMessage(content);
+  }
+  /**
+   * Send a ping message to keep the connection alive
+   */
+  /** B-466: turn edges (and a periodic lease) reported to the local daemon so
+   *  auto-update waits for "no turn in flight" instead of "no sessions". */
+  turnReporter = new TurnReporter((event) => void notifyDaemonTurnEvent(this.sessionId, event).catch((error) => logger.debug("[API] Failed to report turn event to daemon:", error)));
+  /** B-507: background tasks in flight, published on change and renewed every
+   *  60s to the daemon (`/session-event background_tasks`) and into agentState
+   *  (`backgroundTasks: { updatedAt, tasks }`) — the two readers that outlive a
+   *  single heartbeat. The heartbeat itself carries only the count. */
+  backgroundTaskReporter = new BackgroundTaskReporter((tasks, now) => {
+    void notifyDaemonBackgroundTasks(this.sessionId, tasks).catch((error) => logger.debug("[API] Failed to report background tasks to daemon:", error));
+    this.updateAgentState((state) => ({
+      ...state,
+      backgroundTasks: tasks.length > 0 ? { updatedAt: now, tasks } : void 0
+    }));
+  });
+  keepAlive(thinking, mode, backgroundTasks) {
+    if (process.env.DEBUG) {
+      logger.debug(`[API] Sending keep alive message: ${thinking}`);
+    }
+    this.turnReporter.observe(thinking);
+    if (backgroundTasks) this.backgroundTaskReporter.observe(backgroundTasks);
+    this.socket.volatile.emit("session-alive", {
+      sid: this.sessionId,
+      time: Date.now(),
+      thinking,
+      mode,
+      ...backgroundTasks ? { backgroundTasks: backgroundTasks.length } : {}
+    });
+  }
+  /**
+   * B-309: push one live stream frame (thinking/text delta or progress) to
+   * this account's web clients.
+   *
+   * Encrypted with the SESSION key and relayed without being stored —
+   * clipboard-push's shape, for clipboard-push's reasons: the relay must not
+   * be able to read thinking text, and the session id is stamped by the
+   * server from the authenticated connection rather than trusted from here.
+   *
+   * `volatile` on purpose. A draft that misses the wire while disconnected
+   * is worth nothing — the persisted message is still coming, and replaying
+   * stale deltas after a reconnect would paint text that has already landed.
+   */
+  sendStreamFrame(frame) {
+    if (!this.socket.connected) return;
+    try {
+      this.socket.volatile.emit("session-stream", {
+        // The frame object, NOT a JSON string: `encrypt` serializes
+        // internally, so pre-stringifying would double-encode and
+        // escape every quote in the streamed text.
+        payload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, frame)),
+        enc: true
+      });
+    } catch (error) {
+      logger.debug(`[API] Failed to relay stream frame: ${error}`);
+    }
+  }
+  /**
+   * Send session death message
+   */
+  sendSessionDeath() {
+    this.socket.emit("session-end", { sid: this.sessionId, time: Date.now() });
+  }
+  /**
+   * Push text to the clipboard of every web client the user has open.
+   * Encrypted with the SESSION key (same primitive the message stream uses,
+   * proven to interop with the web's SessionEncryption.decryptRaw); the
+   * server relays it to the user's web clients without reading it.
+   * Returns delivery info for the MCP tool to report back to the model.
+   */
+  pushClipboard(text) {
+    const prepared = prepareClipboardText(text);
+    const history = prepareClipboardHistoryText(text);
+    if (!this.socket.connected) {
+      return { delivered: false, truncated: prepared.truncated, totalBytes: prepared.totalBytes };
+    }
+    this.socket.emit("clipboard-push", {
+      payload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, prepared.text)),
+      enc: true,
+      historyPayload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, history.text)),
+      historyTruncated: history.truncated,
+      truncated: prepared.truncated,
+      totalBytes: prepared.totalBytes
+    });
+    return { delivered: true, truncated: prepared.truncated, totalBytes: prepared.totalBytes };
+  }
+  /**
+   * B-131: ask every web client the user has open to preview a file.
+   *
+   * Only the PATH travels — encrypted with the session key exactly like
+   * clipboard-push. The web client then reads the file over the existing
+   * machine-level fs-read RPC. Two reasons: it adds no new file access
+   * (fs-read is already exposed) and it keeps the relay payload tiny, so
+   * large files / images / PDFs ride the existing chunked read instead of
+   * the 1MB relay cap.
+   *
+   * The path is encrypted rather than sent in the clear because every other
+   * payload on this channel is (clipboard, fs RPC) — and a path leaks
+   * project/client names and directory structure.
+   */
+  pushFilePreview(path, mode = "file") {
+    if (!this.socket.connected) {
+      return { delivered: false, error: "not connected to the server" };
+    }
+    this.socket.emit("file-preview-push", {
+      payload: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, path)),
+      enc: true,
+      mode
+    });
+    return { delivered: true };
+  }
+  /**
+   * Send usage data to the server
+   */
+  sendUsageData(usage, model, eventId) {
+    if (eventId && this.seenClaudeUsageEvents.has(eventId)) return;
+    if (eventId) this.seenClaudeUsageEvents.add(eventId);
+    const totalTokens = usage.input_tokens + usage.output_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+    const costs = calculateCost(usage, model);
+    this.claudeUsageTotals.total += totalTokens;
+    this.claudeUsageTotals.input += usage.input_tokens;
+    this.claudeUsageTotals.output += usage.output_tokens;
+    this.claudeUsageTotals.cache_creation += usage.cache_creation_input_tokens || 0;
+    this.claudeUsageTotals.cache_read += usage.cache_read_input_tokens || 0;
+    this.claudeUsageTotals.costTotal += costs.total;
+    this.claudeUsageTotals.costInput += costs.input;
+    this.claudeUsageTotals.costOutput += costs.output;
+    const usageReport = {
+      // Keep the legacy key so upgrading replaces the old last-call row
+      // instead of making old + new clients double-count one session.
+      key: "claude-session",
+      sessionId: this.sessionId,
+      tokens: {
+        total: this.claudeUsageTotals.total,
+        input: this.claudeUsageTotals.input,
+        output: this.claudeUsageTotals.output,
+        cache_creation: this.claudeUsageTotals.cache_creation,
+        cache_read: this.claudeUsageTotals.cache_read
+      },
+      cost: {
+        total: this.claudeUsageTotals.costTotal,
+        input: this.claudeUsageTotals.costInput,
+        output: this.claudeUsageTotals.costOutput
+      }
+    };
+    logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
+    this.socket.emit("usage-report", usageReport);
+  }
+  /** Save a provider's cumulative session snapshot under one upsert key. */
+  sendAgentUsageSnapshot(agent, rawUsage) {
+    const tokens = normalizeAgentUsage(rawUsage);
+    if (!tokens) return false;
+    const usageReport = {
+      key: `usage:${usageAgentKey(agent)}:session`,
+      sessionId: this.sessionId,
+      tokens,
+      // Provider token-count events do not expose reliable billed cost.
+      // The Web treats this sentinel as unknown, not as real $0.00.
+      cost: { total: 0 }
+    };
+    logger.debugLargeJson("[SOCKET] Sending agent usage snapshot:", usageReport);
+    this.socket.emit("usage-report", usageReport);
+    return true;
+  }
+  /**
+   * Returns the latest session metadata known to the client.
+   */
+  getMetadata() {
+    return this.metadata;
+  }
+  /**
+   * Returns the latest agent state known to the client (requests,
+   * controlledByUser, etc.). Used by the notification producer to classify
+   * turn-end events.
+   */
+  getAgentState() {
+    return this.agentState;
+  }
+  /**
+   * Update session metadata
+   * @param handler - Handler function that returns the updated metadata
+   */
+  suppressNextArchiveSignal() {
+    this.ignoreArchiveSignal = true;
+  }
+  skipExistingMessages() {
+    this.skipInitialMessages = true;
+  }
+  updateMetadata(handler) {
+    this.metadataLock.inLock(async () => {
+      let rateRefusals = 0;
+      await backoff(async () => {
+        let updated = handler(this.metadata);
+        const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) });
+        if (answer.result === "success") {
+          this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata));
+          this.metadataVersion = answer.version;
+          rateRefusals = 0;
+        } else if (answer.result === "version-mismatch") {
+          if (answer.version > this.metadataVersion) {
+            this.metadataVersion = answer.version;
+            this.metadata = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.metadata));
+          }
+          throw new Error("Metadata version mismatch");
+        } else if (answer.result === "error") {
+          if (isRateQuotaCode(answer.error)) {
+            rateRefusals += 1;
+            await pauseForRateQuota({
+              label: "session metadata",
+              code: answer.error,
+              attempt: rateRefusals,
+              sleep: delay,
+              log: (message) => logger.debug(message)
+            });
+          }
+          throw new Error("Metadata update failed");
+        }
+      });
+    });
+  }
+  /**
+   * Update session agent state
+   * @param handler - Handler function that returns the updated agent state
+   */
+  updateAgentState(handler) {
+    logger.debugLargeJson("Updating agent state", this.agentState);
+    this.agentStateLock.inLock(async () => {
+      let rateRefusals = 0;
+      await backoff(async () => {
+        let updated = handler(this.agentState || {});
+        const answer = await this.socket.emitWithAck("update-state", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, updated)) : null });
+        if (answer.result === "success") {
+          this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
+          this.agentStateVersion = answer.version;
+          rateRefusals = 0;
+          logger.debug("Agent state updated", this.agentState);
+        } else if (answer.result === "version-mismatch") {
+          if (answer.version > this.agentStateVersion) {
+            this.agentStateVersion = answer.version;
+            this.agentState = answer.agentState ? decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(answer.agentState)) : null;
+          }
+          throw new Error("Agent state version mismatch");
+        } else if (answer.result === "error") {
+          if (isRateQuotaCode(answer.error)) {
+            rateRefusals += 1;
+            await pauseForRateQuota({
+              label: "session agent state",
+              code: answer.error,
+              attempt: rateRefusals,
+              sleep: delay,
+              log: (message) => logger.debug(message)
+            });
+          }
+          throw new Error("Agent state update failed");
+        }
+      });
+    });
+  }
+  /**
+   * Wait for socket buffer to flush
+   */
+  async flush() {
+    await Promise.race([
+      this.sendSync.invalidateAndAwait(),
+      delay(1e4)
+    ]);
+    if (!this.socket.connected) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("ping", () => {
+        resolve();
+      });
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+  }
+  async close() {
+    logger.debug("[API] socket.close() called");
+    this.promptQueueDrain?.close();
+    this.sendSync.stop();
+    this.receiveSync.stop();
+    if (this.reconnectInterval) {
+      clearInterval(this.reconnectInterval);
+      this.reconnectInterval = null;
+    }
+    this.socket.close();
+    this.relaySocket?.close();
+    this.relaySocket = null;
+  }
+  startSmartReconnect() {
+    if (this.reconnectInterval) return;
+    this.reconnectInterval = setInterval(() => {
+      if (this.socket.connected) {
+        clearInterval(this.reconnectInterval);
+        this.reconnectInterval = null;
+        return;
+      }
+      if (!shouldReconnect()) {
+        logger.debug("[API] Still not ready to reconnect");
+        return;
+      }
+      logger.debug("[API] Attempting reconnect");
+      this.socket.connect();
+    }, 3e3);
+    if (shouldReconnect()) {
+      logger.debug("[API] Network up + lid open \u2014 reconnecting in 1s");
+      setTimeout(() => {
+        if (!this.socket.connected) this.socket.connect();
+      }, 1e3);
+    }
+  }
+}
+
+function getSessionTitle(metadata) {
+  const summaryText = metadata?.summary?.text?.trim();
+  if (summaryText) {
+    return summaryText;
+  }
+  const path = metadata?.path?.trim();
+  if (!path) {
+    return "Session";
+  }
+  const segments = path.split(/[\\/]/).filter(Boolean);
+  return segments[segments.length - 1] || "Session";
+}
+function getSessionNotificationUrl(data) {
+  const sessionId = data?.sessionId;
+  if (typeof sessionId !== "string") {
+    return null;
+  }
+  const trimmedSessionId = sessionId.trim();
+  if (!trimmedSessionId) {
+    return null;
+  }
+  return `/session/${encodeURIComponent(trimmedSessionId)}`;
+}
+function getSessionNotificationTitle(kind) {
+  switch (kind) {
+    case "done":
+      return "It's ready!";
+    case "permission":
+      return "Permission request";
+    case "question":
+      return "Clarification needed";
+  }
+}
+function getSessionNotificationBody(metadata) {
+  return getSessionTitle(metadata);
+}
+function getSessionNotificationCopy(kind, metadata) {
+  return {
+    title: getSessionNotificationTitle(kind),
+    body: getSessionNotificationBody(metadata)
+  };
+}
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expoLoad = null;
+  constructor(token, baseUrl = "https://api.cluster-fluster.com") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+  }
+  loadExpo() {
+    if (!this.expoLoad) {
+      const load = import('expo-server-sdk').then(({ Expo }) => ({ Expo, expo: new Expo() }));
+      load.catch(() => {
+        if (this.expoLoad === load) this.expoLoad = null;
+      });
+      this.expoLoad = load;
+    }
+    return this.expoLoad;
+  }
+  /**
+   * Fetch all push tokens for the authenticated user.
+   * Retries up to 3 times with exponential backoff on transient errors.
+   */
+  async fetchPushTokens() {
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await axios.get(
+          `${this.baseUrl}/v1/push-tokens`,
+          {
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+            }
+          }
+        );
+        logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+        response.data.tokens.forEach((token, index) => {
+          logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
+        });
+        return response.data.tokens;
+      } catch (error) {
+        logger.debug(`[PUSH] [ERROR] Failed to fetch push tokens (attempt ${attempt}/${maxAttempts}):`, error);
+        if (attempt < maxAttempts) {
+          const delay = 1e3 * Math.pow(2, attempt - 1);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    logger.debug("[PUSH] [ERROR] All push token fetch attempts failed");
+    return [];
+  }
+  /**
+   * Send push notification via Expo Push API with retry
+   * @param messages - Array of push messages to send
+   */
+  async sendPushNotifications(messages) {
+    logger.debug(`Sending ${messages.length} push notifications`);
+    const { Expo, expo } = await this.loadExpo();
+    const validMessages = messages.filter((message) => {
+      if (Array.isArray(message.to)) {
+        return message.to.every((token) => Expo.isExpoPushToken(token));
+      }
+      return Expo.isExpoPushToken(message.to);
+    });
+    if (validMessages.length === 0) {
+      logger.debug("No valid Expo push tokens found");
+      return;
+    }
+    const chunks = expo.chunkPushNotifications(validMessages);
+    for (const chunk of chunks) {
+      const startTime = Date.now();
+      const timeout = 3e5;
+      let attempt = 0;
+      while (true) {
+        try {
+          const ticketChunk = await expo.sendPushNotificationsAsync(chunk);
+          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
+          if (errors.length > 0) {
+            const errorDetails = errors.map((e) => ({ message: e.message, details: e.details }));
+            logger.debug("[PUSH] Some notifications failed:", errorDetails);
+          }
+          if (errors.length === ticketChunk.length) {
+            throw new Error("All push notifications in chunk failed");
+          }
+          break;
+        } catch (error) {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            break;
+          }
+          attempt++;
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          const remainingTime = timeout - elapsed;
+          const waitTime = Math.min(delay, remainingTime);
+          if (waitTime > 0) {
+            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+    }
+    logger.debug(`Push notifications sent successfully`);
+  }
+  /**
+   * Send a push notification to all registered devices for the user
+   * @param title - Notification title
+   * @param body - Notification body
+   * @param data - Additional data to send with the notification
+   */
+  sendToAllDevices(title, body, data) {
+    logger.debug("[PUSH] sendToAllDevices called:", {
+      title: contentLogMetadata(title),
+      body: contentLogMetadata(body),
+      dataKeyCount: data ? Object.keys(data).length : 0
+    });
+    (async () => {
+      try {
+        logger.debug("[PUSH] Fetching push tokens...");
+        const tokens = await this.fetchPushTokens();
+        logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
+        tokens.forEach((token, index) => {
+          logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
+        });
+        if (tokens.length === 0) {
+          logger.debug("No push tokens found for user");
+          return;
+        }
+        const messages = tokens.map((token, index) => {
+          logger.debug(`[PUSH] Creating message ${index + 1} for token`);
+          return {
+            to: token.token,
+            title,
+            body: body && body.length > 0 ? body : void 0,
+            data,
+            // TODO: For brutalist session artwork, attach rich media via a public HTTPS image URL.
+            // Bundled app asset paths / require(...) / local file paths will not work in push payloads.
+            // iOS also needs a Notification Service Extension to render richContent.image reliably.
+            sound: "default",
+            priority: "high"
+          };
+        });
+        logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        await this.sendPushNotifications(messages);
+        logger.debug("[PUSH] Push notifications sent successfully");
+      } catch (error) {
+        logger.debug("[PUSH] Error sending to all devices:", error);
+      }
+    })();
+  }
+  /**
+   * Routes session-event pushes through the server so it can apply
+   * presence-based suppression (active desktop/web, mobile foreground).
+   * Falls back to direct Expo send only when sessionId is missing — that
+   * shouldn't happen for session notifications but guards against regressions.
+   */
+  sendSessionNotification(params) {
+    const { title, body } = getSessionNotificationCopy(params.kind, params.metadata);
+    const sessionTitle = getSessionNotificationBody(params.metadata);
+    const url = getSessionNotificationUrl(params.data);
+    const payloadData = {
+      ...params.data,
+      kind: params.kind,
+      sessionTitle,
+      ...url ? { url } : {}
+    };
+    const sessionId = typeof params.data?.sessionId === "string" ? params.data.sessionId : null;
+    if (!sessionId) {
+      logger.debug("[PUSH] sendSessionNotification: missing sessionId, falling back to direct send");
+      this.sendToAllDevices(title, body, payloadData);
+      return;
+    }
+    void (async () => {
+      try {
+        await axios.post(
+          `${this.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/push-event`,
+          {
+            kind: params.kind,
+            title,
+            body,
+            data: payloadData
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+            },
+            timeout: 15e3
+          }
+        );
+        logger.debug(`[PUSH] sendSessionNotification dispatched via server (kind=${params.kind})`);
+      } catch (error) {
+        logger.debug("[PUSH] sendSessionNotification failed:", error);
+      }
+    })();
+  }
+}
+
+function startOfflineReconnection(config) {
+  let reconnected = false;
+  let session = null;
+  let timeoutId = null;
+  let failureCount = 0;
+  let cancelled = false;
+  const defaultHealthCheck = async () => {
+    await axios.get(`${config.serverUrl}/v1/sessions`, {
+      timeout: 5e3,
+      validateStatus: (status) => status < 500,
+      // 4xx = server is up, 5xx = server error
+      headers: {
+        "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+      }
+    });
+  };
+  const healthCheck = config.healthCheck ?? defaultHealthCheck;
+  const initialDelayMs = config.initialDelayMs ?? 5e3;
+  const retryDelayMs = config.retryDelayMs ?? ((count) => exponentialBackoffDelay(count, 5e3, 6e4, 10));
+  const attemptReconnect = async () => {
+    if (reconnected || cancelled) return;
+    try {
+      await healthCheck();
+      if (cancelled) return;
+      session = await config.onReconnected();
+      if (cancelled) return;
+      reconnected = true;
+      config.onNotify("\u2705 Reconnected! Session syncing in background.");
+      logger.debug("[OfflineReconnection] Successfully reconnected");
+    } catch (e) {
+      if (axios.isAxiosError(e) && e.response?.status === 401) {
+        logger.debug("[OfflineReconnection] Authentication error, stopping retries");
+        config.onNotify("\u274C Authentication failed. Please re-authenticate with `very-happy auth`.");
+        return;
+      }
+      failureCount++;
+      const delay = retryDelayMs(failureCount);
+      logger.debug(`[OfflineReconnection] Attempt ${failureCount} failed, retrying in ${delay}ms`);
+      if (!cancelled) {
+        timeoutId = setTimeout(attemptReconnect, delay);
+      }
+    }
+  };
+  timeoutId = setTimeout(attemptReconnect, initialDelayMs);
+  return {
+    cancel: () => {
+      cancelled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      config.onCleanup?.();
+    },
+    getSession: () => session,
+    isReconnected: () => reconnected
+  };
+}
+const NETWORK_ERROR_CODES = [
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+];
+function isNetworkError(code) {
+  return code !== void 0 && NETWORK_ERROR_CODES.includes(code);
+}
+const ERROR_DESCRIPTIONS = {
+  // Network errors (Node.js)
+  ECONNREFUSED: "server not accepting connections",
+  ENOTFOUND: "server hostname not found",
+  ETIMEDOUT: "connection timed out",
+  ECONNRESET: "connection reset by server",
+  EHOSTUNREACH: "server host unreachable",
+  ENETUNREACH: "network unreachable",
+  // HTTP errors
+  "401": "authentication failed - run `very-happy auth`",
+  "403": "access forbidden",
+  "404": "endpoint not found, check server deployment",
+  "500": "server internal error",
+  "502": "bad gateway",
+  "503": "service unavailable"
+};
+class OfflineState {
+  state = "online";
+  failures = /* @__PURE__ */ new Map();
+  // Dedupe by operation
+  backend = "Claude";
+  /** Report failure - accumulates context, prints once on first offline transition */
+  fail(failure) {
+    this.failures.set(failure.operation, failure);
+    if (this.state === "online") {
+      this.state = "offline";
+      this.print();
+    }
+  }
+  /** Reset on reconnection */
+  recover() {
+    this.state = "online";
+    this.failures.clear();
+  }
+  /** Set backend name before API calls */
+  setBackend(name) {
+    this.backend = name;
+  }
+  /** Check current state */
+  isOffline() {
+    return this.state === "offline";
+  }
+  /** Reset for testing - clears all state */
+  reset() {
+    this.state = "online";
+    this.failures.clear();
+    this.backend = "Claude";
+  }
+  print() {
+    const summary = [...this.failures.values()].map((f) => {
+      const desc = f.errorCode ? `${f.errorCode} - ${ERROR_DESCRIPTIONS[f.errorCode] || "unknown error"}` : "unknown error";
+      const url = f.url ? ` at ${f.url}` : "";
+      return `${f.operation} failed: ${desc}${url}`;
+    }).join("; ");
+    console.log(`\u26A0\uFE0F  Happy server unreachable, offline mode with auto-reconnect enabled - error details: ${summary}`);
+    const allDetails = [...this.failures.values()].flatMap((f) => f.details || []);
+    allDetails.forEach((line) => console.log(chalk.yellow(`   \u2192 ${line}`)));
+  }
+}
+const connectionState = new OfflineState();
+
+function accountBoxPublicKeyFromCredentials(credential) {
+  if (credential.encryption.type === "legacy") {
+    return libsodiumPublicKeyFromSecretKey(credential.encryption.secret);
+  }
+  return credential.encryption.publicKey;
+}
+class NotificationProducer {
+  token;
+  accountBoxPubKey;
+  sessionId;
+  getMetadata;
+  /** Last repeatKey we successfully (or attempted to) emit, used for local dedup. */
+  lastEmittedAt = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.token = opts.credential.token;
+    this.accountBoxPubKey = accountBoxPublicKeyFromCredentials(opts.credential);
+    this.sessionId = opts.sessionId;
+    this.getMetadata = opts.getMetadata;
+  }
+  /**
+   * A new non-empty permission request was added to agentState.requests.
+   */
+  permissionRequest(toolName) {
+    const project = this.projectLabel();
+    this.emit("permission_request", {
+      title: project ? `Permission needed \xB7 ${project}` : "Permission needed",
+      snippet: toolName ? `Claude wants to use ${toolName}` : "Claude is requesting permission"
+    });
+  }
+  /**
+   * A turn finished and Claude produced a reply (had assistant output during
+   * the turn). thinking went true → false with new assistant message.
+   */
+  replyDone(snippet) {
+    const project = this.projectLabel();
+    this.emit("reply_done", {
+      title: project ? `Claude replied \xB7 ${project}` : "Claude replied",
+      snippet: this.clip(snippet) || "Claude finished responding"
+    });
+  }
+  /**
+   * A turn ended with the session idle and waiting for user input:
+   * no pending permission requests, not controlled by user, not thinking.
+   */
+  inputNeeded() {
+    const project = this.projectLabel();
+    this.emit("input_needed", {
+      title: project ? `Waiting for you \xB7 ${project}` : "Waiting for you",
+      snippet: "Claude is idle and waiting for your input"
+    });
+  }
+  /**
+   * The session errored.
+   */
+  error(message) {
+    const project = this.projectLabel();
+    this.emit("error", {
+      title: project ? `Session error \xB7 ${project}` : "Session error",
+      snippet: this.clip(message) || "The session encountered an error"
+    });
+  }
+  /**
+   * Build, encrypt, dedup and POST a notification. Best-effort, fire-and-forget.
+   */
+  emit(notifType, parts) {
+    const repeatKey = `${this.sessionId}:${notifType}`;
+    const now = Date.now();
+    const last = this.lastEmittedAt.get(repeatKey);
+    if (last !== void 0 && now - last < DEDUP_WINDOW_MS) {
+      logger.debug(`[notif] Suppressing duplicate ${notifType} for ${this.sessionId}`);
+      return;
+    }
+    this.lastEmittedAt.set(repeatKey, now);
+    const body = {
+      title: parts.title,
+      snippet: parts.snippet,
+      sessionId: this.sessionId,
+      ts: now
+    };
+    let enc;
+    try {
+      const plaintext = new TextEncoder().encode(JSON.stringify(body));
+      const bundle = libsodiumEncryptForPublicKey(plaintext, this.accountBoxPubKey);
+      enc = encodeBase64(bundle);
+    } catch (err) {
+      logger.debug("[notif] Failed to encrypt notification body:", err);
+      return;
+    }
+    void this.post(notifType, enc, repeatKey);
+  }
+  async post(notifType, enc, repeatKey) {
+    try {
+      await axios.post(
+        `${configuration.serverUrl}/v1/feed`,
+        {
+          notifType,
+          sessionId: this.sessionId,
+          enc,
+          repeatKey
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 5e3
+        }
+      );
+      logger.debug(`[notif] Posted ${notifType} for session ${this.sessionId}`);
+    } catch (err) {
+      logger.debug(`[notif] Failed to post ${notifType}:`, err);
+    }
+  }
+  /** Short, human-friendly label for the project/session for use in titles. */
+  projectLabel() {
+    const meta = this.getMetadata();
+    if (!meta) return void 0;
+    if (meta.name) return meta.name;
+    if (meta.path) {
+      const parts = meta.path.split("/").filter(Boolean);
+      return parts.length ? parts[parts.length - 1] : meta.path;
+    }
+    return void 0;
+  }
+  clip(text, max = 140) {
+    if (!text) return void 0;
+    const trimmed = text.replace(/\s+/g, " ").trim();
+    if (!trimmed) return void 0;
+    return trimmed.length > max ? trimmed.slice(0, max - 1) + "\u2026" : trimmed;
+  }
+}
+const DEDUP_WINDOW_MS = 3e3;
+
+function describeSessionCreateError(error) {
+  const base = error instanceof Error ? error.message : "Unknown error";
+  if (!axios.isAxiosError(error) || !error.response) return base;
+  const data = error.response.data;
+  const code = data && typeof data === "object" && typeof data.error === "string" ? data.error : null;
+  return code ? `${base} (${code})` : base;
+}
+class ApiClient {
+  static async create(credential) {
+    return new ApiClient(credential);
+  }
+  credential;
+  pushClient;
+  constructor(credential) {
+    this.credential = credential;
+    this.pushClient = new PushNotificationClient(credential.token, configuration.serverUrl);
+  }
+  /**
+   * Create a new session or load existing one with the given tag
+   */
+  async getOrCreateSession(opts) {
+    let dataEncryptionKey = null;
+    let encryptionKey;
+    let encryptionVariant;
+    if (this.credential.encryption.type === "dataKey") {
+      encryptionKey = getRandomBytes(32);
+      encryptionVariant = "dataKey";
+      let encryptedDataKey = libsodiumEncryptForPublicKey(encryptionKey, this.credential.encryption.publicKey);
+      dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
+      dataEncryptionKey.set([0], 0);
+      dataEncryptionKey.set(encryptedDataKey, 1);
+    } else {
+      encryptionKey = this.credential.encryption.secret;
+      encryptionVariant = "legacy";
+    }
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions`,
+        {
+          tag: opts.tag,
+          metadata: encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.metadata)),
+          agentState: opts.state ? encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.state)) : null,
+          dataEncryptionKey: dataEncryptionKey ? encodeBase64(dataEncryptionKey) : null
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "Content-Type": "application/json",
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 6e4
+          // 1 minute timeout for very bad network connections
+        }
+      );
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      let raw = response.data.session;
+      let session = {
+        id: raw.id,
+        seq: raw.seq,
+        metadata: decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata)),
+        metadataVersion: raw.metadataVersion,
+        agentState: raw.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.agentState)) : null,
+        agentStateVersion: raw.agentStateVersion,
+        encryptionKey,
+        encryptionVariant
+      };
+      return session;
+    } catch (error) {
+      logger.debug("[API] [ERROR] Failed to get or create session:", error);
+      if (error && typeof error === "object" && "code" in error) {
+        const errorCode = error.code;
+        if (isNetworkError(errorCode)) {
+          connectionState.fail({
+            operation: "Session creation",
+            caller: "api.getOrCreateSession",
+            errorCode,
+            url: `${configuration.serverUrl}/v1/sessions`
+          });
+          return null;
+        }
+      }
+      const is404Error = axios.isAxiosError(error) && error.response?.status === 404 || error && typeof error === "object" && "response" in error && error.response?.status === 404;
+      if (is404Error) {
+        connectionState.fail({
+          operation: "Session creation",
+          errorCode: "404",
+          url: `${configuration.serverUrl}/v1/sessions`
+        });
+        return null;
+      }
+      if (axios.isAxiosError(error) && error.response?.status) {
+        const status = error.response.status;
+        if (status >= 500) {
+          connectionState.fail({
+            operation: "Session creation",
+            errorCode: String(status),
+            url: `${configuration.serverUrl}/v1/sessions`,
+            details: ["Server encountered an error, will retry automatically"]
+          });
+          return null;
+        }
+      }
+      throw new Error(`Failed to get or create session: ${describeSessionCreateError(error)}`);
+    }
+  }
+  /**
+   * Register or update machine with the server
+   * Returns the current machine state from the server with decrypted metadata and daemonState
+   */
+  async getOrCreateMachine(opts) {
+    let dataEncryptionKey = null;
+    let encryptionKey;
+    let encryptionVariant;
+    if (this.credential.encryption.type === "dataKey") {
+      encryptionVariant = "dataKey";
+      encryptionKey = this.credential.encryption.machineKey;
+      let encryptedDataKey = libsodiumEncryptForPublicKey(this.credential.encryption.machineKey, this.credential.encryption.publicKey);
+      dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
+      dataEncryptionKey.set([0], 0);
+      dataEncryptionKey.set(encryptedDataKey, 1);
+    } else {
+      encryptionKey = this.credential.encryption.secret;
+      encryptionVariant = "legacy";
+    }
+    const createMinimalMachine = () => ({
+      id: opts.machineId,
+      encryptionKey,
+      encryptionVariant,
+      metadata: opts.metadata,
+      metadataVersion: 0,
+      daemonState: opts.daemonState || null,
+      daemonStateVersion: 0
+    });
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/machines`,
+        {
+          id: opts.machineId,
+          metadata: encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.metadata)),
+          daemonState: opts.daemonState ? encodeBase64(encrypt(encryptionKey, encryptionVariant, opts.daemonState)) : void 0,
+          dataEncryptionKey: dataEncryptionKey ? encodeBase64(dataEncryptionKey) : void 0
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "Content-Type": "application/json",
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 6e4
+          // 1 minute timeout for very bad network connections
+        }
+      );
+      const raw = response.data.machine;
+      logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
+      const machine = {
+        id: raw.id,
+        encryptionKey,
+        encryptionVariant,
+        metadata: raw.metadata ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.metadata)) : null,
+        metadataVersion: raw.metadataVersion || 0,
+        daemonState: raw.daemonState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(raw.daemonState)) : null,
+        daemonStateVersion: raw.daemonStateVersion || 0
+      };
+      return machine;
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.code && isNetworkError(error.code)) {
+        connectionState.fail({
+          operation: "Machine registration",
+          caller: "api.getOrCreateMachine",
+          errorCode: error.code,
+          url: `${configuration.serverUrl}/v1/machines`
+        });
+        return createMinimalMachine();
+      }
+      if (axios.isAxiosError(error) && error.response?.status) {
+        const status = error.response.status;
+        if (status === 403 || status === 409) {
+          console.log(chalk.yellow(
+            `\u26A0\uFE0F  Machine registration rejected by the server with status ${status}`
+          ));
+          console.log(chalk.yellow(
+            `   \u2192 This machine ID is already registered to another account on the server`
+          ));
+          console.log(chalk.yellow(
+            `   \u2192 This usually happens after re-authenticating with a different account`
+          ));
+          console.log(chalk.yellow(
+            // B-297: `doctor clean` only kills processes — it has never reset local
+            // state or minted a machine id. `auth login --force` is the command
+            // that does (it regenerates machineId, src/ui/auth.ts).
+            `   \u2192 Run 'very-happy auth login --force' to re-authenticate and generate a new machine ID`
+          ));
+          console.log(chalk.yellow(
+            `   \u2192 Open a GitHub issue if this problem persists`
+          ));
+          return createMinimalMachine();
+        }
+        if (status === 429 && error.response?.data?.error === "machine_state_rate_quota_exceeded") {
+          connectionState.fail({
+            operation: "Machine registration",
+            errorCode: "429",
+            url: `${configuration.serverUrl}/v1/machines`,
+            details: ["Relay write quota is cooling down; realtime connection will retry automatically"]
+          });
+          return createMinimalMachine();
+        }
+        if (status >= 500) {
+          connectionState.fail({
+            operation: "Machine registration",
+            errorCode: String(status),
+            url: `${configuration.serverUrl}/v1/machines`,
+            details: ["Server encountered an error, will retry automatically"]
+          });
+          return createMinimalMachine();
+        }
+        if (status === 404) {
+          connectionState.fail({
+            operation: "Machine registration",
+            errorCode: "404",
+            url: `${configuration.serverUrl}/v1/machines`
+          });
+          return createMinimalMachine();
+        }
+      }
+      throw error;
+    }
+  }
+  sessionSyncClient(session, opts) {
+    return new ApiSessionClient(this.credential.token, session, opts);
+  }
+  async machineSyncClient(machine) {
+    const { ApiMachineClient } = await import('./apiMachine-B9dLW_p5.mjs');
+    return new ApiMachineClient(this.credential.token, machine);
+  }
+  push() {
+    return this.pushClient;
+  }
+  /**
+   * Create an account-encrypted notification producer bound to a session.
+   * The producer derives the account box public key from the stored
+   * credentials (no raw secret seed needed for the dataKey credential shape)
+   * and posts encrypted notifications to the server feed. Best-effort:
+   * failures never propagate into the session loop.
+   */
+  notificationProducer(sessionId, getMetadata) {
+    return new NotificationProducer({
+      credential: this.credential,
+      sessionId,
+      getMetadata
+    });
+  }
+  /**
+   * Read a single value from the account KV store (same HTTP endpoint the
+   * web app uses). Returns null when the key does not exist or on ANY
+   * failure — callers (boardAnalyzer) treat KV as best-effort context.
+   */
+  async kvGet(key) {
+    try {
+      const response = await axios.get(
+        `${configuration.serverUrl}/v1/kv/${encodeURIComponent(key)}`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 5e3,
+          validateStatus: (s) => s === 200 || s === 404
+        }
+      );
+      if (response.status === 404) return null;
+      return response.data;
+    } catch (error) {
+      logger.debug(`[API] kvGet(${key}) failed:`, error);
+      return null;
+    }
+  }
+  /**
+   * Register a vendor API token with the server
+   * The token is sent as a JSON string - server handles encryption
+   */
+  async registerVendorToken(vendor, apiKey) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/connect/${vendor}/register`,
+        {
+          token: JSON.stringify(apiKey)
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "Content-Type": "application/json",
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 5e3
+        }
+      );
+      if (response.status !== 200 && response.status !== 201) {
+        throw new Error(`Server returned status ${response.status}`);
+      }
+      logger.debug(`[API] Vendor token for ${vendor} registered successfully`);
+    } catch (error) {
+      logger.debug(`[API] [ERROR] Failed to register vendor token:`, redactLogValue(error));
+      throw new Error(`Failed to register vendor token: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get vendor API token from the server
+   * Returns the token if it exists, null otherwise
+   */
+  async getVendorToken(vendor) {
+    try {
+      const response = await axios.get(
+        `${configuration.serverUrl}/v1/connect/${vendor}/token`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "Content-Type": "application/json",
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 5e3
+        }
+      );
+      if (response.status === 404) {
+        logger.debug(`[API] No vendor token found for ${vendor}`);
+        return null;
+      }
+      if (response.status !== 200) {
+        throw new Error(`Server returned status ${response.status}`);
+      }
+      logger.debug(`[API] Raw vendor token response:`, {
+        status: response.status,
+        dataKeys: Object.keys(response.data || {}),
+        hasToken: "token" in (response.data || {}),
+        tokenType: typeof response.data?.token
+      });
+      let tokenData = null;
+      if (response.data?.token) {
+        if (typeof response.data.token === "string") {
+          try {
+            tokenData = JSON.parse(response.data.token);
+          } catch (parseError) {
+            logger.debug(`[API] Failed to parse token as JSON, using as string:`, parseError);
+            tokenData = response.data.token;
+          }
+        } else if (response.data.token !== null) {
+          tokenData = response.data.token;
+        } else {
+          logger.debug(`[API] Token is null for ${vendor}, treating as not found`);
+          return null;
+        }
+      } else if (response.data && typeof response.data === "object") {
+        if (response.data.token === null && Object.keys(response.data).length === 1) {
+          logger.debug(`[API] Response contains only null token for ${vendor}, treating as not found`);
+          return null;
+        }
+        tokenData = response.data;
+      }
+      if (tokenData === null || tokenData && typeof tokenData === "object" && tokenData.token === null && Object.keys(tokenData).length === 1) {
+        logger.debug(`[API] Token data is null for ${vendor}`);
+        return null;
+      }
+      logger.debug(`[API] Vendor token for ${vendor} retrieved successfully`, {
+        tokenDataType: typeof tokenData,
+        tokenDataKeys: tokenData && typeof tokenData === "object" ? Object.keys(tokenData) : "not an object"
+      });
+      return tokenData;
+    } catch (error) {
+      if (error.response?.status === 404) {
+        logger.debug(`[API] No vendor token found for ${vendor}`);
+        return null;
+      }
+      logger.debug(`[API] [ERROR] Failed to get vendor token:`, redactLogValue(error));
+      return null;
+    }
+  }
+  /**
+   * B-505: mark a session OFFLINE on the server (active=false, `archivedAt`
+   * untouched) — the same row state a missed keepalive produces, so the web
+   * shows it offline and resumable instead of archived.
+   *
+   * Used when the wrapper exits for an infrastructure reason (SIGTERM /
+   * SIGINT: daemon stop, supervisor restart, machine shutdown) as a
+   * synchronous fallback for the socket `session-end` signal: even if the
+   * socket emit doesn't drain before the process exits, the HTTP response
+   * confirms the row went inactive.
+   *
+   * This MUST NOT hit `/archive`: since B-265 that route writes the
+   * server-owned `archivedAt` tombstone (the only thing that distinguishes
+   * "archived" from "offline"), and the server answers it with a
+   * `session-archive` command that makes the wrapper archive itself. That is
+   * exactly how every dev-sg upgrade archived the sessions mid-turn on
+   * 2026-09-25. A server without `/deactivate` returns 404, which is a
+   * compatible no-op: `session-end` already sets active=false there.
+   */
+  async deactivateSession(sessionId) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions/${sessionId}/deactivate`,
+        {},
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 3e3,
+          validateStatus: (status) => status >= 200 && status < 300 || status === 404
+        }
+      );
+      if (response.status === 404) {
+        logger.debug("[API] deactivateSession: server has no /deactivate route; relying on session-end");
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.debug("[API] deactivateSession failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Archive a session on the server: writes the `archivedAt` tombstone and
+   * makes the server tell every wrapper of this session to exit. Only for an
+   * intentional end of life — the user's Archive / kill, a crash the wrapper
+   * cannot recover from, a terminal mirror whose pane went back to a shell.
+   * Never call this from a signal handler; see `deactivateSession`.
+   */
+  async archiveSession(sessionId) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions/${sessionId}/archive`,
+        {},
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 3e3
+        }
+      );
+      return response.status >= 200 && response.status < 300;
+    } catch (error) {
+      logger.debug("[API] archiveSession failed:", error);
+      return false;
+    }
+  }
+  /**
+   * B-265: one session by id — the message cursor (`seq`), metadata and
+   * agent state with their versions, decrypted with the session key the
+   * reconnecting process already holds. `unsupported` = the server has no
+   * such route (or the row is gone): callers fall back to the legacy
+   * skip-all-history reconnect. Transient failures are retried a few times
+   * first, because falling back silently discards the very message a restore
+   * is meant to deliver.
+   */
+  async getSession(sessionId, encryptionKey, encryptionVariant, opts) {
+    const attempts = opts?.attempts ?? 3;
+    const delays = opts?.delaysMs ?? [500, 1500];
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      try {
+        const response = await axios.get(
+          `${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`,
+          {
+            headers: {
+              "Authorization": `Bearer ${this.credential.token}`,
+              "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+            },
+            timeout: opts?.timeoutMs ?? 4e3,
+            validateStatus: () => true
+          }
+        );
+        if (response.status === 404 || response.status === 401 || response.status === 403) {
+          return { ok: false, reason: "unsupported" };
+        }
+        if (response.status >= 200 && response.status < 300) {
+          const row = response.data.session;
+          if (!row || typeof row.seq !== "number" || typeof row.metadata !== "string") {
+            return { ok: false, reason: "unsupported" };
+          }
+          const metadata = decrypt(encryptionKey, encryptionVariant, decodeBase64(row.metadata));
+          if (!metadata) return { ok: false, reason: "unavailable" };
+          const agentState = row.agentState ? decrypt(encryptionKey, encryptionVariant, decodeBase64(row.agentState)) : null;
+          return {
+            ok: true,
+            session: { seq: row.seq, metadata, metadataVersion: row.metadataVersion, agentState, agentStateVersion: row.agentStateVersion }
+          };
+        }
+        logger.debug(`[API] getSession ${sessionId}: status ${response.status} (attempt ${attempt + 1}/${attempts})`);
+      } catch (error) {
+        logger.debug(`[API] getSession ${sessionId} failed (attempt ${attempt + 1}/${attempts}):`, error);
+      }
+      const delayMs = delays[Math.min(attempt, delays.length - 1)];
+      if (attempt < attempts - 1 && delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+    }
+    return { ok: false, reason: "unavailable" };
+  }
+  /** Clear the server-owned archive tombstone before an intentional resume.
+   * Older servers return 404 because the endpoint does not exist; that is a
+   * compatible no-op because those servers also have no durable tombstone. */
+  async reactivateSession(sessionId) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/sessions/${sessionId}/unarchive`,
+        {},
+        {
+          headers: {
+            "Authorization": `Bearer ${this.credential.token}`,
+            "X-Happy-Client": `cli-coding-session/${configuration.currentCliVersion}`
+          },
+          timeout: 3e3,
+          validateStatus: (status) => status >= 200 && status < 300 || status === 404
+        }
+      );
+      return response.status >= 200 && response.status < 300 || response.status === 404;
+    } catch (error) {
+      logger.debug("[API] reactivateSession failed:", error);
+      return false;
+    }
+  }
+}
+
+var api = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ApiClient: ApiClient,
+    describeSessionCreateError: describeSessionCreateError
+});
+
+export { ApiClient as A, TurnActivityTracker as T, ApiSessionClient as a, api as b, connectionState as c, startOfflineReconnection as s };