@adhdev/mesh-shared 1.0.60-rc.8 → 1.0.60

package/dist/index.mjs

@@ -2,6 +2,9 @@
 function readRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function readOptionalRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
 function readString(...values) {
   for (const value of values) {
     if (typeof value !== "string") continue;
@@ -10,6 +13,9 @@ function readString(...values) {
   }
   return void 0;
 }
+function readText(...values) {
+  return readString(...values) ?? "";
+}
 function readNumber(...values) {
   for (const value of values) {
     if (typeof value === "number" && Number.isFinite(value)) return value;
@@ -287,8 +293,8 @@ function meshWorkspacesEquivalent(a, b) {
 
 // src/daemon-normalize.ts
 var DAEMON_ID_PREFIXES = ["daemon_", "standalone_"];
-function isRawDaemonDoId(id) {
-  const trimmed = readString(id);
+function isRawDaemonDoId(id2) {
+  const trimmed = readString(id2);
   return !!trimmed && /^[0-9a-f]{64}$/i.test(trimmed);
 }
 function isPhantomDaemonEntry(entry) {
@@ -299,8 +305,8 @@ function isPhantomDaemonEntry(entry) {
   );
   return !hasMachineEvidence;
 }
-function machineCoreFromDaemonId(id) {
-  const trimmed = readString(id);
+function machineCoreFromDaemonId(id2) {
+  const trimmed = readString(id2);
   if (!trimmed) return void 0;
   for (const prefix of DAEMON_ID_PREFIXES) {
     if (trimmed.startsWith(prefix)) {
@@ -310,8 +316,8 @@ function machineCoreFromDaemonId(id) {
   }
   return trimmed;
 }
-function canonicalDaemonId(id) {
-  const core = machineCoreFromDaemonId(id);
+function canonicalDaemonId(id2) {
+  const core = machineCoreFromDaemonId(id2);
   if (!core) return void 0;
   if (!core.startsWith("mach_")) return core;
   return `daemon_${core}`;
@@ -377,8 +383,29 @@ function summarizeGitShape(status) {
   };
 }
 
-// src/magi.ts
-var MAGI_RAW_ANSWER_CAP = 4e3;
+// src/git-diff.ts
+function truncateDiffText(text, maxLines) {
+  const lines = text.split("\n");
+  const truncated = lines.length > maxLines;
+  return {
+    diff: truncated ? lines.slice(0, maxLines).join("\n") + "\n... (truncated)" : text,
+    truncated
+  };
+}
+function projectFileDiffRow(file, rawResult, maxLines) {
+  const raw = readRecord(rawResult);
+  const d = readRecord(raw.diff ?? rawResult);
+  const text = typeof d.diff === "string" ? d.diff : "";
+  const { diff, truncated } = truncateDiffText(text, maxLines);
+  return {
+    path: file.path,
+    old_path: file.oldPath ?? null,
+    status: file.status ?? "M",
+    diff,
+    truncated,
+    binary: typeof d.binary === "boolean" ? d.binary : false
+  };
+}
 
 // src/brain-routing.ts
 var MESH_TASK_DIFFICULTIES = ["easy", "medium", "difficult", "freeform"];
@@ -619,32 +646,8 @@ function buildSlotProposal(detected, currentSlots = []) {
     destructive: droppedSlots.length > 0
   };
 }
-function buildMagiPanelProposal(detected, opts = {}) {
-  const providers = dedupeDetected(detected ?? []);
-  const tableOrder = Object.keys(CLI_SLOT_RECIPES);
-  const rank = (type) => {
-    const i = tableOrder.indexOf(type);
-    return i === -1 ? Number.MAX_SAFE_INTEGER : i;
-  };
-  const ordered = [...providers].sort((a, b) => rank(a.type) - rank(b.type));
-  const limit = Number.isFinite(opts.maxSlots) && opts.maxSlots > 0 ? Math.floor(opts.maxSlots) : ordered.length;
-  return ordered.slice(0, limit).map((p) => ({
-    ...opts.nodeId ? { nodeId: opts.nodeId } : {},
-    provider: p.type
-    // A model is intentionally NOT pinned: the panel's job is cross-provider
-    // independence, and pinning models here would silently couple the panel
-    // to this table's cost assumptions rather than to review quality.
-  }));
-}
 
 // src/interpolation.ts
-function interpolateArgs(args, context) {
-  const result = {};
-  for (const [k, v] of Object.entries(args)) {
-    result[k] = typeof v === "string" ? interpolateString(v, context) : v;
-  }
-  return result;
-}
 function interpolateString(template, ctx) {
   return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
     const val = ctx[key];
@@ -657,16 +660,10 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_status",
   "mesh_route_preview",
   "mesh_list_nodes",
-  // GRAPH-ORCHESTRATION Phase F — batch before task, mirroring ALL_MESH_TOOLS.
+  // Batch before task, mirroring ALL_MESH_TOOLS.
   "mesh_enqueue_batch",
   "mesh_enqueue_task",
   "mesh_view_queue",
-  // GRAPH-ORCHESTRATION Phase E — the coordinator gate + graph view surface.
-  "mesh_graph_view",
-  "mesh_graph_gate_claim",
-  "mesh_graph_gate_release",
-  "mesh_graph_gate_abandon",
-  "mesh_graph_node_patch",
   "mesh_queue_cancel",
   "mesh_queue_requeue",
   "mesh_send_task",
@@ -683,7 +680,6 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_approve",
   "mesh_answer_question",
   "mesh_list_pending_approvals",
-  "mesh_plan_onboarding",
   "mesh_create",
   "mesh_add_node",
   "mesh_clone_node",
@@ -691,34 +687,52 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_cleanup_worktree_nodes",
   "mesh_refine_node",
   "mesh_refine_batch",
-  "mesh_refine_config",
-  "mesh_change_impact_config",
+  "mesh_config",
   "mesh_init",
-  "mesh_reinit",
-  "mesh_write_mesh_json_config",
   "mesh_refine_plan",
   "mesh_cleanup_sessions",
-  "mesh_prune_stale_direct",
   "mesh_task_history",
   "mesh_ledger_query",
-  "mesh_record_note",
-  "mesh_forget_note",
+  "mesh_note",
   "mesh_reconcile_ledger",
-  "mesh_requeue_held_events",
   "mesh_mission_upsert",
   "mesh_mission_list",
   "mesh_review_inbox",
-  "mesh_magi_review",
-  "mesh_magi_collect",
-  "mesh_magi_kind_panel_set",
-  "mesh_magi_kind_panel_list",
-  "mesh_node_slots_set",
-  "mesh_node_slots_list",
-  "mesh_node_slots_propose",
-  "mesh_coordinator_prompt_append_get",
-  "mesh_coordinator_prompt_append_set"
+  "mesh_node_slots",
+  "mesh_coordinator_prompt_append"
 ];
 var CANONICAL_MESH_TOOL_COUNT = CANONICAL_MESH_TOOL_NAMES.length;
+var RETIRED_MESH_TOOLS = {
+  mesh_node_slots_set: { tool: "mesh_node_slots", args: { action: "set" } },
+  mesh_node_slots_list: { tool: "mesh_node_slots", args: { action: "list" } },
+  mesh_node_slots_propose: { tool: "mesh_node_slots", args: { action: "propose" } },
+  mesh_coordinator_prompt_append_get: { tool: "mesh_coordinator_prompt_append", args: { action: "get" } },
+  mesh_coordinator_prompt_append_set: { tool: "mesh_coordinator_prompt_append", args: { action: "set" } },
+  mesh_record_note: { tool: "mesh_note", args: { action: "record" } },
+  mesh_forget_note: { tool: "mesh_note", args: { action: "forget" } },
+  mesh_reinit: { tool: "mesh_init", args: { mode: "reinit" } },
+  mesh_refine_config: { tool: "mesh_config", args: { kind: "refine" } },
+  mesh_change_impact_config: { tool: "mesh_config", args: { kind: "change_impact" } },
+  mesh_write_mesh_json_config: { tool: "mesh_config", args: { kind: "mesh_json" } },
+  mesh_plan_onboarding: { tool: "mesh_create", args: { mode: "plan" } },
+  mesh_prune_stale_direct: { tool: "mesh_cleanup_sessions", args: { mode: "prune_stale_direct" } }
+};
+var REMOVED_MESH_TOOLS = {
+  mesh_magi_review: "For a multi-perspective review, send the same question to 2-3 workers on different providers with mesh_send_task, wait for their report_completion, then synthesize the answers yourself.",
+  mesh_magi_collect: "Worker answers arrive as report_completion events; synthesize them yourself.",
+  mesh_magi_kind_panel: "There are no review panels any more; pick the workers per review with mesh_send_task.",
+  mesh_magi_kind_panel_set: "There are no review panels any more; pick the workers per review with mesh_send_task.",
+  mesh_magi_kind_panel_list: "There are no review panels any more; pick the workers per review with mesh_send_task."
+};
+function retiredMeshToolError(name) {
+  if (Object.prototype.hasOwnProperty.call(REMOVED_MESH_TOOLS, name)) {
+    return `Tool "${name}" was removed. ${REMOVED_MESH_TOOLS[name]}`;
+  }
+  const entry = Object.prototype.hasOwnProperty.call(RETIRED_MESH_TOOLS, name) ? RETIRED_MESH_TOOLS[name] : void 0;
+  if (!entry) return null;
+  const discriminator = Object.entries(entry.args).map(([k, v]) => `${k}: "${v}"`).join(", ");
+  return `Tool "${name}" was retired (merged into ${entry.tool}). Call ${entry.tool} with ${discriminator} and the same other arguments.` + (entry.note ? ` ${entry.note}` : "");
+}
 
 // src/mesh-status-probe.ts
 var STATUS_PROBE_ARG_KEY = "_statusProbe";
@@ -957,8 +971,52 @@ function isDowngrade(current, target) {
   return direction < 0;
 }
 
-// src/ws-protocol.ts
-var DAEMON_TO_SERVER_WS_MSGS = [
+// src/protocol/envelope.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function makeTypeGuard(names) {
+  const set = new Set(names);
+  return (value) => typeof value === "string" && set.has(value);
+}
+function decodeTypeField(raw, isType) {
+  if (!isRecord(raw)) return null;
+  if (!isType(raw.type)) return null;
+  return { type: raw.type, frame: raw };
+}
+function readEnvelopeFields(frame) {
+  return {
+    ...isNonEmptyString(frame.id) ? { id: frame.id } : {},
+    ...isFiniteNumber(frame.timestamp) ? { timestamp: frame.timestamp } : {}
+  };
+}
+
+// src/protocol/daemon-server.ts
+var DAEMON_STATUS_EVENT_NAMES = [
+  "agent:generating_started",
+  "agent:waiting_approval",
+  "agent:waiting_choice",
+  "agent:generating_completed",
+  "agent:stopped",
+  "monitor:no_progress"
+];
+var isDaemonStatusEventName = makeTypeGuard(DAEMON_STATUS_EVENT_NAMES);
+var RELEASE_CHANNELS = ["stable", "preview"];
+var NPM_UPDATE_TAGS = ["latest", "next"];
+var VERSION_UPDATE_REASONS = ["force_update_below", "major_minor_mismatch", "patch_mismatch", "daemon_ahead"];
+var P2P_SIGNAL_TYPES = ["p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice"];
+var isP2PSignalType = makeTypeGuard(P2P_SIGNAL_TYPES);
+var DAEMON_P2P_SIGNAL_TYPES = ["p2p_offer", "p2p_ice"];
+var isDaemonP2PSignalType = makeTypeGuard(DAEMON_P2P_SIGNAL_TYPES);
+var MESH_P2P_SIGNAL_TYPES = ["mesh_p2p_ready", "mesh_p2p_offer", "mesh_p2p_answer", "mesh_p2p_ice"];
+var isMeshP2PSignalType = makeTypeGuard(MESH_P2P_SIGNAL_TYPES);
+var DAEMON_TO_SERVER_TYPES = [
   "auth",
   "status_report",
   "status_heartbeat",
@@ -966,10 +1024,28 @@ var DAEMON_TO_SERVER_WS_MSGS = [
   "command_result",
   "error",
   "agent_event",
-  "log",
-  "beacon_vectors"
+  "daemon_mesh_command",
+  "p2p_offer",
+  "p2p_ice"
 ];
-var SERVER_TO_DAEMON_WS_MSGS = [
+var isDaemonToServerType = makeTypeGuard(DAEMON_TO_SERVER_TYPES);
+function decodeDaemonToServer(raw) {
+  if (!isRecord(raw) || !isDaemonToServerType(raw.type)) return null;
+  if (raw.type === "daemon_mesh_command") {
+    return {
+      type: "daemon_mesh_command",
+      requestId: typeof raw.requestId === "string" ? raw.requestId : String(raw.requestId ?? ""),
+      targetDaemonId: typeof raw.targetDaemonId === "string" ? raw.targetDaemonId : "",
+      command: raw.command,
+      args: isRecord(raw.args) ? raw.args : {},
+      timestamp: typeof raw.timestamp === "number" ? raw.timestamp : Date.now()
+    };
+  }
+  if (!isRecord(raw.payload)) return null;
+  if (raw.type === "auth" && !isNonEmptyString(raw.payload.token)) return null;
+  return { type: raw.type, payload: raw.payload, ...readEnvelopeFields(raw) };
+}
+var SERVER_TO_DAEMON_CONTROL_TYPES = [
   "auth_ok",
   "auth_error",
   "machine_evicted",
@@ -980,65 +1056,2523 @@ var SERVER_TO_DAEMON_WS_MSGS = [
   "command",
   "agent_command",
   "resolve_action",
-  "beacon_vectors_result"
+  "daemon_mesh_result",
+  "p2p_ready",
+  "p2p_offer",
+  "p2p_answer",
+  "p2p_ice",
+  "mesh_p2p_ready",
+  "mesh_p2p_offer",
+  "mesh_p2p_answer",
+  "mesh_p2p_ice"
+];
+var isServerToDaemonControlType = makeTypeGuard(SERVER_TO_DAEMON_CONTROL_TYPES);
+function isServerDirectCommandMsg(msg) {
+  return !isServerToDaemonControlType(msg.type);
+}
+var DIRECT_COMMAND_TYPE_PATTERN = /^[a-z][a-z0-9_:.-]{0,63}$/;
+function isDaemonDirectCommandType(value) {
+  return typeof value === "string" && DIRECT_COMMAND_TYPE_PATTERN.test(value) && !isServerToDaemonControlType(value);
+}
+function decodeServerToDaemon(raw) {
+  if (!isRecord(raw) || typeof raw.type !== "string") return null;
+  const relay = {
+    ...readEnvelopeFields(raw),
+    ...isNonEmptyString(raw.source) ? { source: raw.source } : {}
+  };
+  if (raw.type === "daemon_mesh_result") {
+    if (!isNonEmptyString(raw.requestId)) return null;
+    const base = { requestId: raw.requestId, success: raw.success === true };
+    return {
+      type: "daemon_mesh_result",
+      ...base,
+      ..."result" in raw ? { result: raw.result } : {},
+      ...typeof raw.error === "string" ? { error: raw.error } : {}
+    };
+  }
+  if (!isRecord(raw.payload)) return null;
+  if (isServerToDaemonControlType(raw.type)) {
+    return { type: raw.type, payload: raw.payload, ...relay };
+  }
+  if (!isDaemonDirectCommandType(raw.type)) return null;
+  return { type: raw.type, payload: raw.payload, ...relay };
+}
+
+// src/protocol/dashboard-server.ts
+var SERVER_STATUS_EVENT_NAMES = [
+  "daemon:disconnect",
+  "team:session_viewed",
+  "team:view_request",
+  "team:view_request_approved",
+  "team:view_request_rejected"
+];
+var DASHBOARD_STATUS_EVENT_NAMES = [...DAEMON_STATUS_EVENT_NAMES, ...SERVER_STATUS_EVENT_NAMES];
+var isDashboardStatusEventName = makeTypeGuard(DASHBOARD_STATUS_EVENT_NAMES);
+var SYSTEM_ANNOUNCEMENT_TYPES = ["info", "warning", "critical"];
+var USER_SESSION_TO_DASHBOARD_TYPES = [
+  "connected",
+  "initial_state",
+  "daemon_status",
+  "status_event",
+  "system_announcement",
+  "auth_error",
+  "heartbeat",
+  "p2p_offer",
+  "p2p_ice"
+];
+var isUserSessionToDashboardType = makeTypeGuard(USER_SESSION_TO_DASHBOARD_TYPES);
+function decodeUserSessionToDashboard(raw) {
+  if (!isRecord(raw) || !isUserSessionToDashboardType(raw.type)) return null;
+  if (raw.type === "heartbeat") {
+    return { type: "heartbeat", payload: isRecord(raw.payload) ? raw.payload : {}, ...readEnvelopeFields(raw) };
+  }
+  if (!isRecord(raw.payload)) return null;
+  return { type: raw.type, payload: raw.payload, ...readEnvelopeFields(raw) };
+}
+var DASHBOARD_TO_USER_SESSION_TYPES = ["heartbeat", "refresh", "p2p_ready", "p2p_answer", "p2p_ice"];
+var isDashboardToUserSessionType = makeTypeGuard(DASHBOARD_TO_USER_SESSION_TYPES);
+var DASHBOARD_P2P_SIGNAL_TYPES = ["p2p_ready", "p2p_answer", "p2p_ice"];
+var isDashboardP2PSignalType = makeTypeGuard(DASHBOARD_P2P_SIGNAL_TYPES);
+function decodeDashboardToUserSession(raw) {
+  if (!isRecord(raw) || !isDashboardToUserSessionType(raw.type)) return null;
+  if (raw.type === "heartbeat") return { type: "heartbeat", ...readEnvelopeFields(raw) };
+  if (raw.type === "refresh") return { type: "refresh" };
+  if (!isRecord(raw.payload) || typeof raw.payload.daemonId !== "string") return null;
+  return { type: raw.type, payload: raw.payload, ...readEnvelopeFields(raw) };
+}
+var SHARED_SESSION_TO_VIEWER_TYPES = [
+  "share:connected",
+  "share:revoked",
+  "share:expired",
+  "share:error",
+  "share:viewer_count",
+  "p2p_offer",
+  "p2p_ice"
+];
+var isSharedSessionToViewerType = makeTypeGuard(SHARED_SESSION_TO_VIEWER_TYPES);
+var VIEWER_TO_SHARED_SESSION_TYPES = ["p2p_ready", "p2p_offer", "p2p_answer", "p2p_ice"];
+var isViewerToSharedSessionType = makeTypeGuard(VIEWER_TO_SHARED_SESSION_TYPES);
+function decodeViewerToSharedSession(raw) {
+  if (!isRecord(raw) || !isViewerToSharedSessionType(raw.type)) return null;
+  const payload = isRecord(raw.payload) ? raw.payload : {};
+  return { type: raw.type, payload, ...readEnvelopeFields(raw) };
+}
+
+// src/protocol/dashboard-daemon-p2p.ts
+function isChunkType(value) {
+  return typeof value === "string" && value.endsWith("_chunk") && value.length > "_chunk".length;
+}
+function readChunkFields(frame) {
+  if (!isNonEmptyString(frame.chunkId)) return null;
+  if (!Number.isInteger(frame.index) || !Number.isInteger(frame.total)) return null;
+  if (typeof frame.data !== "string") return null;
+  return {
+    ...isNonEmptyString(frame.id) ? { id: frame.id } : {},
+    chunkId: frame.chunkId,
+    index: frame.index,
+    total: frame.total,
+    data: frame.data
+  };
+}
+var DASHBOARD_TO_DAEMON_P2P_TYPES = [
+  "ping",
+  "pong",
+  "command",
+  "input",
+  "pty_input",
+  "pty_resize",
+  "screenshot_start",
+  "screenshot_stop",
+  "subscribe",
+  "unsubscribe",
+  "seqscribe_session_interest",
+  "read",
+  "write",
+  "list"
+];
+var isDashboardToDaemonP2PType = makeTypeGuard(DASHBOARD_TO_DAEMON_P2P_TYPES);
+function isDashboardToDaemonChunkType(value) {
+  return isChunkType(value) && isDashboardToDaemonP2PType(value.slice(0, -"_chunk".length));
+}
+var DASHBOARD_REQUEST_TYPES = /* @__PURE__ */ new Set(["command", "input", "read", "write", "list"]);
+function decodeDashboardToDaemonP2PChunk(raw) {
+  if (!isRecord(raw) || !isDashboardToDaemonChunkType(raw.type)) return null;
+  const fields = readChunkFields(raw);
+  return fields ? { type: raw.type, ...fields } : null;
+}
+function decodeDashboardToDaemonP2P(raw) {
+  if (!isRecord(raw) || !isDashboardToDaemonP2PType(raw.type)) return null;
+  if (DASHBOARD_REQUEST_TYPES.has(raw.type) && !isNonEmptyString(raw.id)) return null;
+  return raw;
+}
+var DAEMON_TO_DASHBOARD_P2P_TYPES = [
+  "ping",
+  "pong",
+  "p2p_evicted",
+  "status_event",
+  "topic_update",
+  "topic_update_chunk",
+  "session_output",
+  "session_output_chunk",
+  "session_io_error",
+  "command_result",
+  "command_result_chunk",
+  "response",
+  "transcript_topics_available"
 ];
-function isDaemonToServerWsMsg(value) {
-  return typeof value === "string" && DAEMON_TO_SERVER_WS_MSGS.includes(value);
+var isDaemonToDashboardP2PType = makeTypeGuard(DAEMON_TO_DASHBOARD_P2P_TYPES);
+function decodeDaemonToDashboardP2P(raw) {
+  if (!isRecord(raw)) return null;
+  if (!isDaemonToDashboardP2PType(raw.type)) return null;
+  switch (raw.type) {
+    case "ping":
+    case "pong":
+    case "p2p_evicted":
+      return raw;
+    case "status_event":
+      return isRecord(raw.payload) ? raw : null;
+    case "topic_update":
+      return isRecord(raw.update) ? raw : null;
+    case "topic_update_chunk":
+    case "command_result_chunk":
+    case "session_output_chunk": {
+      const fields = readChunkFields(raw);
+      if (!fields) return null;
+      if (raw.type === "session_output_chunk") {
+        return isNonEmptyString(raw.sessionId) ? { type: raw.type, sessionId: raw.sessionId, ...fields } : null;
+      }
+      return { type: raw.type, ...fields };
+    }
+    case "session_output":
+      return isNonEmptyString(raw.sessionId) && typeof raw.data === "string" ? raw : null;
+    case "session_io_error":
+      return isNonEmptyString(raw.sessionId) ? raw : null;
+    case "command_result":
+    case "response":
+      return isNonEmptyString(raw.id) ? raw : null;
+    case "transcript_topics_available":
+      return Array.isArray(raw.topics) && raw.topics.every((topic) => typeof topic === "string") ? { type: raw.type, topics: raw.topics } : null;
+  }
 }
-function isServerToDaemonWsMsg(value) {
-  return typeof value === "string" && SERVER_TO_DAEMON_WS_MSGS.includes(value);
+var DASHBOARD_P2P_MESSAGE_KINDS = [
+  .../* @__PURE__ */ new Set([...DASHBOARD_TO_DAEMON_P2P_TYPES, ...DAEMON_TO_DASHBOARD_P2P_TYPES])
+];
+
+// src/protocol/dashboard-wire-version.ts
+var DASHBOARD_WIRE_VERSION = 2;
+function compareDashboardWireVersion(pageVersion, daemonVersion) {
+  const daemon = typeof daemonVersion === "number" && Number.isFinite(daemonVersion) ? daemonVersion : 1;
+  if (daemon === pageVersion) return "ok";
+  return daemon > pageVersion ? "reload_required" : "daemon_update_required";
+}
+
+// src/ws-protocol.ts
+var DAEMON_TO_SERVER_WS_MSGS = DAEMON_TO_SERVER_TYPES;
+var SERVER_TO_DAEMON_WS_MSGS = SERVER_TO_DAEMON_CONTROL_TYPES;
+function normalizeAuthOkLimits(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const src = raw;
+  const num = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
+  return {
+    maxP2Pconnections: num(
+      src.maxP2Pconnections !== void 0 ? src.maxP2Pconnections : src.maxP2PConnections,
+      -1
+    ),
+    screenshotIntervalSeconds: num(src.screenshotIntervalSeconds, 0),
+    dailyScreenshotMinutes: num(src.dailyScreenshotMinutes, -1),
+    maxMachines: num(src.maxMachines, -1)
+  };
 }
 
 // src/interactive-prompt-constants.ts
 var CLAUDE_TUI_REVIEW_PAGE_NOT_FOCUSED_PREFIX = "Claude TUI review page is not focused";
 var CLAUDE_TUI_REVIEW_UNCONFIRMED_PREFIX = "Claude TUI answer delivered but not confirmed";
+
+// src/session-status.ts
+var SESSION_STATUSES = [
+  "idle",
+  "generating",
+  "waiting_approval",
+  "waiting_choice",
+  "finalizing",
+  "error",
+  "stopped",
+  "starting",
+  "panel_hidden",
+  "not_monitored",
+  "disconnected"
+];
+var RECENT_SESSION_BUCKETS = ["needs_attention", "working", "task_complete", "idle"];
+var SESSION_STATUS_CLASS = {
+  generating: "working",
+  finalizing: "working",
+  starting: "working",
+  waiting_approval: "blocked",
+  waiting_choice: "blocked",
+  idle: "ready",
+  panel_hidden: "ready",
+  not_monitored: "ready",
+  error: "dead",
+  stopped: "dead",
+  disconnected: "dead"
+};
+var SESSION_STATUS_ALIASES = {
+  running: "generating",
+  streaming: "generating",
+  busy: "generating",
+  working: "generating",
+  loading: "generating",
+  loading_reference: "generating",
+  thinking: "generating",
+  active: "generating",
+  // Status-lane refinements of a turn that is still owned by the agent.
+  no_progress: "generating",
+  long_generating: "generating",
+  initializing: "starting",
+  waiting: "waiting_approval"
+};
+var SESSION_STATUS_SET = new Set(SESSION_STATUSES);
+function isSessionStatus(value) {
+  return typeof value === "string" && SESSION_STATUS_SET.has(value);
+}
+function normalizeSessionStatus(raw) {
+  if (typeof raw !== "string") return null;
+  const value = raw.trim().toLowerCase();
+  if (SESSION_STATUS_SET.has(value)) return value;
+  return SESSION_STATUS_ALIASES[value] ?? null;
+}
+function classifySessionStatus(raw) {
+  const status = normalizeSessionStatus(raw);
+  return status ? SESSION_STATUS_CLASS[status] : "unknown";
+}
+function isWorkingStatus(raw) {
+  return classifySessionStatus(raw) === "working";
+}
+function isBlockedStatus(raw) {
+  return classifySessionStatus(raw) === "blocked";
+}
+function isReadyStatus(raw) {
+  return classifySessionStatus(raw) === "ready";
+}
+function isDeadStatus(raw) {
+  return classifySessionStatus(raw) === "dead";
+}
+function isBusyStatus(raw) {
+  const cls = classifySessionStatus(raw);
+  return cls === "working" || cls === "blocked";
+}
+function statusesOfClass(cls) {
+  return SESSION_STATUSES.filter((status) => SESSION_STATUS_CLASS[status] === cls);
+}
+var TERMINAL_SESSION_RECORD_STATUSES = ["stopped", "failed", "terminated", "exited", "closed"];
+function isTerminalSessionRecordStatus(raw) {
+  return typeof raw === "string" && TERMINAL_SESSION_RECORD_STATUSES.includes(raw.trim().toLowerCase());
+}
+function isIdleSessionState(state) {
+  const record = state && typeof state === "object" ? state : {};
+  const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
+  if (isTerminalSessionRecordStatus(status) || isDeadStatus(status)) return false;
+  return isReadyStatus(status) || record.activeChat?.status === "waiting_input";
+}
+
+// src/mesh-vocabulary.ts
+var MESH_TASK_STATUSES = ["pending", "assigned", "completed", "failed", "cancelled"];
+var MESH_TERMINAL_TASK_STATUSES = ["completed", "failed", "cancelled"];
+var MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
+var MESH_TASK_PRIORITIES = ["low", "normal", "high"];
+var MESH_THINKING_LEVELS = ["low", "medium", "high"];
+var MESH_DELIVERY_MODES = ["when_idle", "interrupt"];
+var MESH_SESSION_CLEANUP_MODES = ["preserve", "stop", "delete_stopped", "stop_and_delete"];
+var WORKER_REPORT_OUTCOMES = ["completed", "blocked", "failed"];
+var WORKER_BRANCH_STATES = [
+  "merged_to_main",
+  "pushed_feature_branch_needs_merge",
+  "blocked_review",
+  "cleanup_candidate",
+  "not_mergeable"
+];
+function makeGuard(values) {
+  const set = new Set(values);
+  return (value) => typeof value === "string" && set.has(value);
+}
+var isMeshTaskStatus = makeGuard(MESH_TASK_STATUSES);
+var isMeshTerminalTaskStatus = makeGuard(MESH_TERMINAL_TASK_STATUSES);
+var isMeshTaskMode = makeGuard(MESH_TASK_MODES);
+var isMeshTaskPriority = makeGuard(MESH_TASK_PRIORITIES);
+var isMeshDeliveryMode = makeGuard(MESH_DELIVERY_MODES);
+var isWorkerReportOutcome = makeGuard(WORKER_REPORT_OUTCOMES);
+function enumOf(values, description) {
+  return {
+    type: "string",
+    enum: [...values],
+    ...description ? { description } : {}
+  };
+}
+
+// src/outbound-message.ts
+var outboundMessageIdCounter = 0;
+function mintMessageId(now = Date.now()) {
+  try {
+    const cryptoRef = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+    if (typeof cryptoRef?.randomUUID === "function") return `msg_${cryptoRef.randomUUID()}`;
+  } catch {
+  }
+  outboundMessageIdCounter += 1;
+  return `msg_${now}_${outboundMessageIdCounter}`;
+}
+var MESSAGE_ID_PREFIX = "msg_";
+function isMessageId(value) {
+  return typeof value === "string" && value.length > MESSAGE_ID_PREFIX.length && value.startsWith(MESSAGE_ID_PREFIX);
+}
+var OUTBOUND_MESSAGE_ORIGINS = ["dashboard", "mcp", "mesh", "api", "cli"];
+function isOutboundMessageOrigin(value) {
+  return typeof value === "string" && OUTBOUND_MESSAGE_ORIGINS.includes(value);
+}
+var SEND_POLICY_MODES = ["queue", "send_now", "interrupt"];
+function isSendPolicyMode(value) {
+  return typeof value === "string" && SEND_POLICY_MODES.includes(value);
+}
+function isSendPolicy(value) {
+  return !!value && typeof value === "object" && isSendPolicyMode(value.mode);
+}
+var SEND_REFUSAL_REASONS = [
+  "not_ready",
+  "send_in_flight",
+  "not_generating",
+  "not_supported",
+  "platform_unsupported",
+  "modal_parked",
+  "interrupt_not_implemented",
+  "interrupt_refused",
+  "idle_timeout",
+  "session_exited",
+  "unsupported_input",
+  "no_target",
+  "bootstrap_pending",
+  "duplicate_dispatch",
+  "internal_error"
+];
+function isSendRefusal(value) {
+  return typeof value === "string" && SEND_REFUSAL_REASONS.includes(value);
+}
+var SUBMIT_OUTCOME_KINDS = ["delivered", "queued", "duplicate", "refused"];
+function isSubmitOutcome(value) {
+  if (!value || typeof value !== "object") return false;
+  const kind = value.kind;
+  if (typeof kind !== "string" || !SUBMIT_OUTCOME_KINDS.includes(kind)) return false;
+  if (kind === "queued") return typeof value.position === "number";
+  if (kind === "duplicate") return typeof value.of === "string";
+  if (kind === "refused") return isSendRefusal(value.reason);
+  return true;
+}
+function isInputPartWire(value) {
+  if (!value || typeof value !== "object") return false;
+  const type = value.type;
+  return type === "text" || type === "image" || type === "audio" || type === "video" || type === "resource" || type === "resource_link";
+}
+function isInputEnvelopeWire(value) {
+  if (!value || typeof value !== "object") return false;
+  const parts = value.parts;
+  const textFallback = value.textFallback;
+  return Array.isArray(parts) && parts.every(isInputPartWire) && typeof textFallback === "string";
+}
+function isOutboundMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return isMessageId(candidate.messageId) && typeof candidate.sessionId === "string" && candidate.sessionId.length > 0 && isInputEnvelopeWire(candidate.input) && isOutboundMessageOrigin(candidate.origin) && isSendPolicy(candidate.policy) && typeof candidate.createdAt === "number";
+}
+
+// src/mission-brief.ts
+var GOAL_MAX = 500;
+var LIST_ITEM_MAX = 200;
+var LIST_MAX_ITEMS = 12;
+var MISSION_BRIEF_RENDER_MAX_CHARS = 1200;
+function truncateString(value, max) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max - 1).trimEnd()}\u2026`;
+}
+function normalizeStringList(value, field, truncated) {
+  if (value === void 0 || value === null) return void 0;
+  if (!Array.isArray(value)) return void 0;
+  const items = [];
+  let itemTruncated = false;
+  for (const raw of value) {
+    if (typeof raw !== "string") continue;
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (trimmed.length > LIST_ITEM_MAX) itemTruncated = true;
+    items.push(truncateString(trimmed, LIST_ITEM_MAX));
+  }
+  if (itemTruncated) truncated.push({ field, reason: "item_too_long" });
+  if (items.length > LIST_MAX_ITEMS) {
+    truncated.push({ field, reason: "list_too_long" });
+    return items.slice(0, LIST_MAX_ITEMS);
+  }
+  return items.length > 0 ? items : void 0;
+}
+function normalizeMissionBrief(input) {
+  const truncated = [];
+  if (!input || typeof input !== "object") {
+    return { brief: null, truncated };
+  }
+  const raw = input;
+  const rawGoal = typeof raw.goal === "string" ? raw.goal.trim() : "";
+  if (!rawGoal) {
+    return { brief: null, truncated };
+  }
+  if (rawGoal.length > GOAL_MAX) truncated.push({ field: "goal", reason: "field_too_long" });
+  const goal = truncateString(rawGoal, GOAL_MAX);
+  const constraints = normalizeStringList(raw.constraints, "constraints", truncated);
+  const doneCriteria = normalizeStringList(raw.doneCriteria ?? raw.done_criteria, "doneCriteria", truncated);
+  const handoffNotes = normalizeStringList(raw.handoffNotes ?? raw.handoff_notes, "handoffNotes", truncated);
+  const ownedPaths = normalizeStringList(raw.ownedPaths ?? raw.owned_paths, "ownedPaths", truncated);
+  const brief = { goal };
+  if (constraints) brief.constraints = constraints;
+  if (doneCriteria) brief.doneCriteria = doneCriteria;
+  if (handoffNotes) brief.handoffNotes = handoffNotes;
+  if (ownedPaths) brief.ownedPaths = ownedPaths;
+  return { brief, truncated };
+}
+function renderList(heading, items) {
+  if (!items || items.length === 0) return [];
+  return [`${heading}:`, ...items.map((item) => `- ${item}`)];
+}
+function renderMissionBriefBlock(brief) {
+  const sections = [`Mission goal: ${brief.goal}`];
+  sections.push(...renderList("Constraints", brief.constraints));
+  sections.push(...renderList("Done when", brief.doneCriteria));
+  sections.push(...renderList("Owned paths", brief.ownedPaths));
+  sections.push(...renderList("Handoff notes", brief.handoffNotes));
+  const full = sections.join("\n");
+  if (full.length <= MISSION_BRIEF_RENDER_MAX_CHARS) return full;
+  const marker = "\n(brief truncated)";
+  const budget = MISSION_BRIEF_RENDER_MAX_CHARS - marker.length;
+  const lines = full.split("\n");
+  let acc = "";
+  for (const line of lines) {
+    const next = acc ? `${acc}
+${line}` : line;
+    if (next.length > budget) break;
+    acc = next;
+  }
+  if (!acc) acc = truncateString(lines[0] ?? "", Math.max(budget, 0));
+  return `${acc}${marker}`;
+}
+
+// src/worker-protocol.ts
+var WORKER_TOOLS = [
+  "report_completion",
+  "progress_update",
+  "peer_context_pull",
+  "git_status",
+  "git_log",
+  "git_diff"
+];
+var WORKER_TOOL_SET = new Set(WORKER_TOOLS);
+function isWorkerTool(value) {
+  return typeof value === "string" && WORKER_TOOL_SET.has(value);
+}
+var WORKER_PROTOCOL_FOOTER_MARKER = "--- adhdev worker protocol ---";
+function hasWorkerProtocolFooter(body) {
+  return typeof body === "string" && body.includes(WORKER_PROTOCOL_FOOTER_MARKER);
+}
+function renderWorkerProtocolFooter(input = {}) {
+  const briefBlock = input.missionBrief ? renderMissionBriefBlock(input.missionBrief) : null;
+  const lines = briefBlock ? [briefBlock, "", WORKER_PROTOCOL_FOOTER_MARKER] : [WORKER_PROTOCOL_FOOTER_MARKER];
+  const scope = [];
+  if (input.taskId) scope.push(`task ${input.taskId}`);
+  if (input.taskMode) scope.push(`mode ${input.taskMode}`);
+  if (input.difficulty) {
+    if (isMeshTaskDifficulty(input.difficulty)) {
+      scope.push(`difficulty ${input.difficulty}`);
+    } else {
+      console.warn(
+        `[worker-protocol] task ${input.taskId ?? "(unknown)"}: dropping invalid difficulty '${input.difficulty}' from the worker footer (expected one of easy, medium, difficult, freeform)`
+      );
+    }
+  }
+  if (input.readonly) scope.push("read-only");
+  if (scope.length) lines.push(`You are a delegated worker (${scope.join(", ")}).`);
+  else lines.push("You are a delegated worker.");
+  lines.push(
+    "When your work is finished, blocked, or has failed, call `report_completion` exactly once. Its `summary` is recorded verbatim as the authoritative record of this task \u2014 your terminal is not scraped for it \u2014 so state what you did, what you found, and where you left the branch.",
+    "For work that runs longer than a few minutes, call `progress_update` at natural checkpoints so the coordinator can see you are alive without polling.",
+    "`peer_context_pull` shows what sibling tasks in this mission have reported; `git_status` / `git_diff` / `git_log` inspect your own workspace \u2014 all three REQUIRE the absolute path to it as `workspace`.",
+    "You have no coordinator tools (no `mesh_*`) by design: do not enqueue, dispatch, or restart anything. If you need a decision from the coordinator, finish with `report_completion` and outcome `blocked`, listing what you need in `blockers`.",
+    "On a code-changing task, `report_completion` with outcome `completed` requires `touched_files` \u2014 send `[]` if you changed nothing, omitting the field is what gets refused. `blocked`/`failed` never need it, and a read-only task should omit it or send `[]`.",
+    "If `report_completion` is refused, the response carries `validationErrors` (or a `hint`) naming exactly what to fix \u2014 correct that field and call it again; a refusal records nothing."
+  );
+  if (input.enclosedHandoffNotes && input.enclosedHandoffNotes > 0) {
+    lines.push(
+      `The ${input.enclosedHandoffNotes} handoff note(s) above were written by agents who touched this code before you; honour their conflict guidance and add your own in \`handoff_notes\` when you report.`
+    );
+  }
+  return lines.join("\n");
+}
+function stripWorkerProtocolFooter(body) {
+  if (typeof body !== "string") return body;
+  const at = body.indexOf(WORKER_PROTOCOL_FOOTER_MARKER);
+  if (at < 0) return body;
+  return body.slice(0, at).replace(/\s+$/, "");
+}
+function appendWorkerProtocolFooter(body, input = {}) {
+  if (hasWorkerProtocolFooter(body)) return body;
+  const trimmed = body.replace(/\s+$/, "");
+  return `${trimmed}
+
+${renderWorkerProtocolFooter(input)}`;
+}
+function renderCoordinatorWorkerSection() {
+  return [
+    "## Workers",
+    "",
+    `Every task you dispatch is delivered with a worker protocol footer. Workers hold exactly these tools: ${WORKER_TOOLS.map((tool) => `\`${tool}\``).join(", ")} \u2014 and no \`mesh_*\` tools.`,
+    "- A worker finishes by calling `report_completion`; its structured report (outcome, summary, touched files, branch state, handoff notes) is what reaches you as the completion event. Read that report \u2014 do not re-derive the outcome from `mesh_read_chat` or the terminal unless the report is missing.",
+    "- `progress_update` from a worker arrives as a lightweight progress note. Do NOT poll `mesh_status`, `mesh_view_queue` or `mesh_read_chat` to check on a running worker; completion, progress, blocked and failure all arrive as events.",
+    "- To reach a busy worker mid-task use `mesh_notify_worker`: the memo is delivered on the worker's next tool call (or when it becomes idle). A worker that reports `blocked` is asking you for a decision \u2014 answer it with `mesh_send_task` to the same session.",
+    "- `mesh_status` is for node health and capacity before delegating, never for progress.",
+    "- A `code_change` task's declared `owned_paths` (H1) is enforced at claim time: a second `code_change` task whose `owned_paths` overlaps an already-claimed task's is refused rather than silently racing it. A worker's `report_completion.touched_files` is compared against its own task's declaration afterward and any mismatch is surfaced back to you as evidence \u2014 it is never a validation failure, since a worker often cannot know its exact final file list at enqueue time."
+  ].join("\n");
+}
+
+// src/turn-evidence.ts
+var MESH_TOPIC_PROTOCOL_VERSION = 2;
+var EVIDENCE_SOURCE_IDS = [
+  "fsm_edge",
+  "short_gen_inline",
+  "completion_flush_genuine",
+  "completion_flush_weak",
+  "monitor_final_summary",
+  "pre_cleanup_transcript",
+  "stall_transcript",
+  "startup_grace_collapse",
+  "acp_prompt_response",
+  "cdp_state",
+  "approval_gate",
+  "modal_button",
+  "mesh_stall_watchdog",
+  "status_monitor",
+  "pty_exit",
+  "provider_error",
+  "coordinator_probe",
+  "mcp_probe",
+  "worker_tool",
+  "dispatch",
+  "input_service",
+  "operator",
+  "intentional_cleanup",
+  "scheduler",
+  "git_probe",
+  "session_registry"
+];
+var TURN_SCOPES = ["mesh_queue", "mesh_direct", "plain"];
+var RECLAIMING_SEND_REFUSALS = ["session_exited", "no_target", "unsupported_input"];
+var DELIVERY_OUTCOMES = ["delivered", "queued"];
+var DELIVERY_VIAS = ["local", "p2p"];
+var DISPATCH_FAILURE_REASONS = ["worker_absent", "transport_error", "spawn_failed", "rejected_by_worker", "timeout"];
+function sanitizeRefusalCode(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase().replace(/[^a-z_]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  if (!normalized) return void 0;
+  return normalized.slice(0, 64);
+}
+var CONSUME_PROFILES = ["default", "native_source"];
+var SESSION_REBOUND_REASONS = ["restart", "live_holder"];
+var SUSPENSION_MODALS = ["approval", "choice"];
+var SUSPENSION_RESOLUTIONS = ["approved", "rejected", "answered"];
+var SUSPENSION_RESOLUTION_VIAS = ["modal_button", "auto_approve", "prompt_answer"];
+var TURN_END_STRENGTHS = ["genuine", "weak"];
+var TURN_END_BLOCK_REASONS = [
+  "missing_final_assistant",
+  "finalization_timeout",
+  "terminal_block_hard_cap",
+  "decoupled_completion"
+];
+var NATIVE_TURN_OUTCOMES = ["completed", "aborted"];
+var LIVENESS_RESULTS = ["alive", "unknown", "read_failed", "dead"];
+var PROVIDER_FAILURES = ["auth_failed", "billing_failed"];
+var SESSION_ERROR_REASONS = ["provider_error", "adapter_error", "spawn_failed", "auth_failed", "billing_failed", "unknown", "daemon_restart"];
+var CANCEL_REASONS = ["operator_cancel", "intentional_cleanup", "task_removed", "mission_abandoned", "superseded"];
+var OPERATOR_STATUSES = ["completed", "failed"];
+var OPERATOR_STATUS_REASONS = ["operator_update", "refine_terminal", "validation_terminal"];
+var COORDINATOR_ACK_OUTCOMES = ["delivered", "queued", "duplicate"];
+var NO_PROGRESS_OBSERVED_STATUSES = [...SESSION_STATUSES, "unknown"];
+var HOLD_REASONS = [
+  "await_delivery",
+  "await_consume",
+  "await_turn",
+  "liveness",
+  "hard_ceiling",
+  "live_pending",
+  "transcript_quiet",
+  "weak_candidate",
+  "suspension_before_consumed",
+  // A genuine FSM end of a mesh turn whose worker holds a live worker-MCP bind:
+  // the structured report is the primary evidence (design §F2), so the idle edge
+  // only opens this hold (R9r) — a report commits (R17), a new busy edge cancels
+  // it as a false idle (R12r), expiry commits weak (R13r).
+  "await_report",
+  // A worker report recorded while the session is still generating (R17g):
+  // the report is the verdict, the idle edge is only awaited as corroboration
+  // — a turn_end commits the report (R9t), expiry commits it anyway (R13t) so
+  // a session whose FSM never shows the idle edge again does not wait for
+  // liveness / hard_ceiling.
+  "await_end"
+];
+var TURN_OUTCOMES = ["completed", "failed", "cancelled"];
+var COMMIT_STRENGTHS = ["genuine", "weak", "tool_report", "operator"];
+var TURN_REASONS = [
+  // commits
+  "turn_end",
+  "weak_end_confirmed",
+  "transcript_final",
+  "worker_reported",
+  "finalization_timeout_no_response",
+  "session_error",
+  "provider_auth_failed",
+  "provider_billing_failed",
+  "operator_cancel",
+  "intentional_cleanup",
+  "task_removed",
+  "mission_abandoned",
+  "superseded",
+  "operator_update",
+  "refine_terminal",
+  "validation_terminal",
+  "hard_ceiling",
+  "reclaim_budget_exhausted",
+  "hollow_max_retries",
+  "migration_orphan",
+  // reclaims (generation + 1)
+  "dispatch_refused_session_exited",
+  "dispatch_refused_no_target",
+  "dispatch_refused_unsupported_input",
+  "dispatch_failed",
+  "session_exit",
+  "session_exit_before_turn",
+  "session_dead",
+  "hollow_completion",
+  "assigned_stranded_dispatch_unconfirmed",
+  "delivered_not_consumed_redrive",
+  "delivered_no_turn_deadline"
+];
+var NOTIFY_KINDS = [
+  "completed",
+  "failed",
+  "cancelled",
+  "stopped",
+  "approval",
+  "choice",
+  "approval_resolved",
+  "candidate",
+  "no_progress",
+  "progress",
+  "late_completion",
+  "mesh_event"
+];
+var id = { t: "id" };
+var idOpt = { t: "id", optional: true };
+var bool = { t: "bool" };
+var boolOpt = { t: "bool", optional: true };
+var ms = { t: "ms" };
+var msOpt = { t: "ms", optional: true };
+var intOpt = { t: "int", optional: true };
+var en = (values) => ({ t: "enum", values });
+var enOpt = (values) => ({ t: "enum", values, optional: true });
+var EVIDENCE_ENVELOPE_FIELD_SPECS = {
+  eventId: id,
+  at: ms,
+  source: en(EVIDENCE_SOURCE_IDS),
+  sessionId: id,
+  attemptRef: { t: "attempt_ref", optional: true },
+  taskId: idOpt,
+  observedBy: id
+};
+var TURN_EVIDENCE_FIELD_SPECS = {
+  dispatch_accepted: {
+    scope: en(TURN_SCOPES),
+    messageId: id,
+    meshId: idOpt,
+    nodeId: idOpt,
+    providerType: idOpt,
+    attemptNo: intOpt,
+    dispatchNonce: intOpt,
+    consumeProfile: enOpt(CONSUME_PROFILES),
+    maxTaskRetries: intOpt,
+    coordinator: { t: "coordinator", optional: true }
+  },
+  delivered: { messageId: id, outcome: en(DELIVERY_OUTCOMES), via: en(DELIVERY_VIAS) },
+  delivery_refused: { messageId: id, reason: en(SEND_REFUSAL_REASONS) },
+  dispatch_failed: { workerAbsent: bool, reason: en(DISPATCH_FAILURE_REASONS), refusalCode: idOpt },
+  duplicate_dispatch_refusal: { holderSessionId: id, holderAttemptId: idOpt },
+  session_rebound: { toSessionId: id, reason: en(SESSION_REBOUND_REASONS) },
+  turn_started: { retro: bool },
+  suspension: { modal: en(SUSPENSION_MODALS), modalKey: idOpt },
+  suspension_resolved: { resolution: en(SUSPENSION_RESOLUTIONS), via: en(SUSPENSION_RESOLUTION_VIAS) },
+  turn_end: {
+    strength: en(TURN_END_STRENGTHS),
+    afterFinalizationTimeout: boolOpt,
+    hollow: boolOpt,
+    summary: { t: "summary_ref", optional: true },
+    blockReason: enOpt(TURN_END_BLOCK_REASONS),
+    releasedByHardCap: boolOpt,
+    nativeOutcome: enOpt(NATIVE_TURN_OUTCOMES),
+    live: { t: "live", optional: true },
+    reportExpected: boolOpt
+  },
+  transcript_final: {
+    selfAttributing: bool,
+    nativeRead: bool,
+    nativeMarker: { t: "native_marker", optional: true },
+    live: { t: "live" },
+    summary: { t: "summary_ref", optional: true },
+    messageAt: msOpt
+  },
+  transcript_activity: { newestActivityAt: ms },
+  no_progress: { stalledMs: ms, observedStatus: en(NO_PROGRESS_OBSERVED_STATUSES), finalAssistantPresent: bool },
+  liveness: { result: en(LIVENESS_RESULTS) },
+  process_exit: { exitCode: { t: "int", nullable: true }, providerFailure: enOpt(PROVIDER_FAILURES) },
+  session_error: { reason: en(SESSION_ERROR_REASONS) },
+  worker_report: {
+    outcome: en(WORKER_REPORT_OUTCOMES),
+    summary: { t: "summary_ref", optional: true },
+    hasHandoffNotes: bool,
+    branchState: enOpt(WORKER_BRANCH_STATES),
+    touchedFileCount: intOpt
+  },
+  worker_progress: { note: { t: "summary_ref", optional: true } },
+  git_side_effect: { dirty: bool, commitsSinceDispatch: { t: "int" }, attributable: bool },
+  cancel: { reason: en(CANCEL_REASONS) },
+  operator_status: { status: en(OPERATOR_STATUSES), reason: en(OPERATOR_STATUS_REASONS) },
+  coordinator_ack: { notify: en(NOTIFY_KINDS), outcome: en(COORDINATOR_ACK_OUTCOMES) },
+  hold_expired: { holdId: id, reason: en(HOLD_REASONS) }
+};
+var TURN_EVIDENCE_KINDS = Object.keys(TURN_EVIDENCE_FIELD_SPECS);
+var TERMINAL_CLASS_EVIDENCE_KINDS = [
+  "turn_end",
+  "transcript_final",
+  "no_progress",
+  "worker_report",
+  "session_error",
+  "process_exit",
+  "cancel",
+  "operator_status"
+];
+var IDENTIFIER_RE = /^[^\s\u0000-\u001f\u007f]{1,256}$/;
+function makeGuard2(values) {
+  const set = new Set(values);
+  return (value) => typeof value === "string" && set.has(value);
+}
+var isTurnEvidenceKind = makeGuard2(TURN_EVIDENCE_KINDS);
+var isTurnReason = makeGuard2(TURN_REASONS);
+var isNotifyKind = makeGuard2(NOTIFY_KINDS);
+var isTurnOutcome = makeGuard2(TURN_OUTCOMES);
+var isCommitStrength = makeGuard2(COMMIT_STRENGTHS);
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEvidenceIdentifier(value) {
+  return typeof value === "string" && IDENTIFIER_RE.test(value);
+}
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isSummaryRef(value) {
+  return isRecord2(value) && hasOnlyKeys(value, ["topic", "writer", "seq"]) && isEvidenceIdentifier(value.topic) && isEvidenceIdentifier(value.writer) && Number.isSafeInteger(value.seq) && value.seq >= 0;
+}
+function isTurnAttemptRef(value) {
+  return isRecord2(value) && hasOnlyKeys(value, ["attemptId", "generation"]) && isEvidenceIdentifier(value.attemptId) && Number.isSafeInteger(value.generation) && value.generation >= 0;
+}
+function isLiveTurnPending(value) {
+  return isRecord2(value) && hasOnlyKeys(value, ["modal", "adapterPending", "trailingTool", "newestActivityAt"]) && typeof value.modal === "boolean" && typeof value.adapterPending === "boolean" && typeof value.trailingTool === "boolean" && (value.newestActivityAt === void 0 || isFiniteNumber2(value.newestActivityAt));
+}
+function isNativeMarkerRef(value) {
+  return isRecord2(value) && hasOnlyKeys(value, ["outcome", "turnId"]) && NATIVE_TURN_OUTCOMES.includes(value.outcome) && (value.turnId === void 0 || isEvidenceIdentifier(value.turnId));
+}
+function isCoordinatorIdentity(value) {
+  return isRecord2(value) && hasOnlyKeys(value, ["daemonId", "coordinatorRunId", "sessionId"]) && isEvidenceIdentifier(value.daemonId) && isEvidenceIdentifier(value.coordinatorRunId) && (value.sessionId === void 0 || isEvidenceIdentifier(value.sessionId));
+}
+function hasOnlyKeys(value, allowed) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key)) return false;
+  }
+  return true;
+}
+function fieldMatches(spec, value) {
+  if (value === void 0) return spec.optional === true;
+  switch (spec.t) {
+    case "id":
+      return isEvidenceIdentifier(value);
+    case "enum":
+      return typeof value === "string" && spec.values.includes(value);
+    case "bool":
+      return typeof value === "boolean";
+    case "int":
+      return value === null && spec.nullable === true || Number.isSafeInteger(value);
+    case "ms":
+      return isFiniteNumber2(value) && value >= 0;
+    case "summary_ref":
+      return isSummaryRef(value);
+    case "attempt_ref":
+      return isTurnAttemptRef(value);
+    case "live":
+      return isLiveTurnPending(value);
+    case "native_marker":
+      return isNativeMarkerRef(value);
+    case "coordinator":
+      return isCoordinatorIdentity(value);
+  }
+}
+function isTurnEvidence(value) {
+  if (!isRecord2(value) || !isTurnEvidenceKind(value.kind)) return false;
+  const bodySpecs = TURN_EVIDENCE_FIELD_SPECS[value.kind];
+  const envelopeSpecs = EVIDENCE_ENVELOPE_FIELD_SPECS;
+  for (const key of Object.keys(value)) {
+    if (key === "kind") continue;
+    if (!(key in bodySpecs) && !(key in envelopeSpecs)) return false;
+  }
+  for (const [key, spec] of Object.entries(envelopeSpecs)) {
+    if (!fieldMatches(spec, value[key])) return false;
+  }
+  for (const [key, spec] of Object.entries(bodySpecs)) {
+    if (!fieldMatches(spec, value[key])) return false;
+  }
+  return true;
+}
+var TURN_EVIDENCE_FLAGS = ["hollow", "afterFinalizationTimeout", "nativeMarker", "selfAttributing"];
+var MESH_TOPIC_ENTRY_KINDS = ["turn.evidence", "turn.committed", "turn.notify", "mesh.record"];
+function isOptionalId(value) {
+  return value === void 0 || isEvidenceIdentifier(value);
+}
+function isGeneration(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isProjectedScalars(value) {
+  if (!isRecord2(value)) return false;
+  for (const v of Object.values(value)) {
+    if (!(v === null || typeof v === "number" || typeof v === "boolean" || typeof v === "string")) return false;
+  }
+  return true;
+}
+function isMeshTopicEntry(value) {
+  if (!isRecord2(value)) return false;
+  if (value.v !== MESH_TOPIC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.eventId) || !isFiniteNumber2(value.at)) return false;
+  switch (value.k) {
+    case "turn.evidence": {
+      if (!isEvidenceIdentifier(value.attemptId) || !isGeneration(value.generation)) return false;
+      if (!isEvidenceIdentifier(value.ownerDaemonId) || !isEvidenceIdentifier(value.sessionId) || !isOptionalId(value.taskId)) return false;
+      if (!isTurnEvidenceKind(value.ev)) return false;
+      if (value.strength !== void 0 && !TURN_END_STRENGTHS.includes(value.strength)) return false;
+      if (value.flags !== void 0) {
+        if (!isRecord2(value.flags)) return false;
+        for (const [flag, on] of Object.entries(value.flags)) {
+          if (!TURN_EVIDENCE_FLAGS.includes(flag) || typeof on !== "boolean") return false;
+        }
+      }
+      if (value.evidence !== void 0 && !(isTurnEvidence(value.evidence) && value.evidence.kind === value.ev)) return false;
+      return true;
+    }
+    case "turn.committed":
+      return isEvidenceIdentifier(value.attemptId) && isGeneration(value.generation) && isOptionalId(value.taskId) && isTurnOutcome(value.outcome) && isCommitStrength(value.strength) && isTurnReason(value.reason);
+    case "turn.notify":
+      return isOptionalId(value.attemptId) && isNotifyKind(value.notify) && isEvidenceIdentifier(value.targetDaemonId) && isOptionalId(value.targetSessionId) && isOptionalId(value.taskId);
+    case "mesh.record":
+      return isEvidenceIdentifier(value.ledgerKind) && isOptionalId(value.nodeId) && isOptionalId(value.sessionId) && isOptionalId(value.taskId) && isProjectedScalars(value.payload);
+    default:
+      return false;
+  }
+}
+function projectTurnEvidenceEntry(evidence, attempt) {
+  const flags = {};
+  if (evidence.kind === "turn_end") {
+    if (evidence.hollow) flags.hollow = true;
+    if (evidence.afterFinalizationTimeout) flags.afterFinalizationTimeout = true;
+  }
+  if (evidence.kind === "transcript_final") {
+    if (evidence.nativeMarker) flags.nativeMarker = true;
+    if (evidence.selfAttributing) flags.selfAttributing = true;
+  }
+  const taskId = evidence.taskId;
+  return {
+    v: MESH_TOPIC_PROTOCOL_VERSION,
+    eventId: evidence.eventId,
+    at: evidence.at,
+    k: "turn.evidence",
+    attemptId: attempt.attemptId,
+    generation: attempt.generation,
+    ownerDaemonId: attempt.ownerDaemonId,
+    ...taskId ? { taskId } : {},
+    sessionId: evidence.sessionId,
+    ev: evidence.kind,
+    ...evidence.kind === "turn_end" ? { strength: evidence.strength } : {},
+    ...Object.keys(flags).length > 0 ? { flags } : {},
+    evidence
+  };
+}
+
+// src/session-launch.ts
+var MODEL_AXIS_SOURCES = [
+  /** Picked explicitly for this launch (dashboard dropdown, coordinator dialog). */
+  "user",
+  /** The dashboard dialog restored it from the last launch (browser-local memory). */
+  "remembered",
+  /** A mesh capability slot supplied it (or a difficulty preset the slot outranked). */
+  "mesh_slot",
+  /** An explicit per-task model / thinking level on a mesh queue task. */
+  "task_override",
+  /** Nothing was requested; the provider's default is known (discovery / manifest). */
+  "provider_default",
+  /** A value was requested without saying where it came from, or nothing is known. */
+  "unspecified"
+];
+function isModelAxisSource(value) {
+  return typeof value === "string" && MODEL_AXIS_SOURCES.includes(value);
+}
+var SESSION_LAUNCHED_BY = ["dashboard", "mesh", "cli", "api", "restore"];
+function isSessionLaunchedBy(value) {
+  return typeof value === "string" && SESSION_LAUNCHED_BY.includes(value);
+}
+var MODEL_SELECTION_HISTORY_LIMIT = 20;
+function effectiveModelSelectionValue(selection) {
+  if (!selection) return void 0;
+  const last = Array.isArray(selection.history) ? selection.history[selection.history.length - 1] : void 0;
+  return last?.value ?? selection.current ?? selection.observed ?? launchModelSelectionValue(selection);
+}
+function launchModelSelectionValue(selection) {
+  if (!selection) return void 0;
+  const launch = Array.isArray(selection.history) ? selection.history.find((entry) => entry.via === "launch") : void 0;
+  return launch?.value ?? selection.launchValue ?? selection.requested ?? selection.resolvedDefault;
+}
+function describeModelSelection(selection) {
+  const value = effectiveModelSelectionValue(selection);
+  if (!selection || !value) return void 0;
+  const launched = launchModelSelectionValue(selection);
+  return {
+    value,
+    ...launched && launched !== value ? { changedFrom: launched } : {},
+    source: isModelAxisSource(selection.source) ? selection.source : "unspecified"
+  };
+}
+var MODEL_IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/@[\]+-]{0,95}$/;
+function sanitizeModelIdentifier(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return MODEL_IDENTIFIER_PATTERN.test(trimmed) ? trimmed : void 0;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseModelSelection(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const record = raw;
+  const history = [];
+  if (Array.isArray(record.history)) {
+    for (const entry of record.history) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const value = readString(e.value);
+      const at = readFiniteNumber(e.at);
+      const via = e.via === "launch" || e.via === "change_model" || e.via === "observed" ? e.via : void 0;
+      if (value && at !== void 0 && via) history.push({ at, value, via });
+    }
+  }
+  const requested = readString(record.requested);
+  const launchValue = readString(record.launchValue);
+  const resolvedDefault = readString(record.resolvedDefault);
+  const current = readString(record.current);
+  const observed = readString(record.observed);
+  const observedAt = readFiniteNumber(record.observedAt);
+  return {
+    source: isModelAxisSource(record.source) ? record.source : "unspecified",
+    ...requested ? { requested } : {},
+    ...launchValue ? { launchValue } : {},
+    ...resolvedDefault ? { resolvedDefault } : {},
+    ...current ? { current } : {},
+    ...observed ? { observed } : {},
+    ...observedAt !== void 0 ? { observedAt } : {},
+    history: history.slice(-MODEL_SELECTION_HISTORY_LIMIT)
+  };
+}
+function parseSessionLaunchRecord(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const record = raw;
+  const sessionId = readString(record.sessionId);
+  const providerType = readString(record.providerType);
+  const launchedAt = readFiniteNumber(record.launchedAt);
+  const model = parseModelSelection(record.model);
+  const thinkingLevel = parseModelSelection(record.thinkingLevel);
+  if (!sessionId || !providerType || launchedAt === void 0 || !model || !thinkingLevel) return void 0;
+  const providerVersion = readString(record.providerVersion);
+  const workspace = readString(record.workspace);
+  const autoApproveModeId = readString(record.autoApproveModeId);
+  return {
+    sessionId,
+    providerType,
+    ...providerVersion ? { providerVersion } : {},
+    ...record.providerChannel === "stable" || record.providerChannel === "preview" ? { providerChannel: record.providerChannel } : {},
+    launchedBy: isSessionLaunchedBy(record.launchedBy) ? record.launchedBy : "api",
+    launchedAt,
+    ...workspace ? { workspace } : {},
+    model,
+    thinkingLevel,
+    ...autoApproveModeId ? { autoApproveModeId } : {}
+  };
+}
+
+// src/turn-ipc-guards.ts
+var TURN_IPC_PROTOCOL_VERSION = 1;
+function isFiniteNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isNonNegativeInt(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function isOptionalId2(value) {
+  return value === void 0 || isEvidenceIdentifier(value);
+}
+function hasOnlyKeys2(value, allowed) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.includes(key)) return false;
+  }
+  return true;
+}
+function makeGuard3(values) {
+  const set = new Set(values);
+  return (value) => typeof value === "string" && set.has(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isOptionalShortString(value, max = 512) {
+  return value === void 0 || typeof value === "string" && value.trim().length > 0 && value.length <= max;
+}
+function isRecordArray(value) {
+  return Array.isArray(value) && value.every(isRecord);
+}
+function isOptionalRecord(value) {
+  return value === void 0 || isRecord(value);
+}
+function isOptionalBoolean(value) {
+  return value === void 0 || typeof value === "boolean";
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+
+// src/turn-ipc-turn.ts
+var TURN_OBSERVE_VERDICTS = ["applied", "recorded", "rejected"];
+var isTurnObserveVerdict = makeGuard3(TURN_OBSERVE_VERDICTS);
+function isTurnObserveRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "evidence"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isTurnEvidence(value.evidence);
+}
+function decodeTurnObserveRequest(value) {
+  return isTurnObserveRequest(value) ? value : null;
+}
+function isTurnAttemptRefValue(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["attemptId", "generation"]) && isEvidenceIdentifier(value.attemptId) && isNonNegativeInt(value.generation);
+}
+function isTurnObserveResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["verdict", "attemptRef", "outcome"]) && isTurnObserveVerdict(value.verdict) && isTurnAttemptRefValue(value.attemptRef) && (value.outcome === void 0 || isTurnOutcomeValue(value.outcome));
+}
+var TURN_OUTCOMES_LOCAL = ["completed", "failed", "cancelled"];
+function isTurnOutcomeValue(value) {
+  return typeof value === "string" && TURN_OUTCOMES_LOCAL.includes(value);
+}
+function decodeTurnObserveResponse(value) {
+  return isTurnObserveResponse(value) ? value : null;
+}
+var MESH_RECORD_PAYLOAD_KEYS = [
+  // Identifiers
+  "taskId",
+  "deliveryId",
+  "attemptId",
+  "missionId",
+  "checkpointId",
+  "promptId",
+  "providerSessionId",
+  "targetNoteId",
+  // Routing / addressing
+  "nodeId",
+  "sessionId",
+  "providerType",
+  "transport",
+  "attemptedSessionId",
+  "holderSessionId",
+  // Outcome enums
+  "reason",
+  "status",
+  "outcome",
+  "terminalKind",
+  "event",
+  "source",
+  "intentionalStopReason",
+  // Booleans
+  "retryable",
+  "rebound",
+  "forced",
+  "fallback",
+  "membershipRemoved",
+  "requestedForce",
+  "removedByRemoteDaemon",
+  "completedViaReady",
+  "intentional",
+  "weak",
+  // Counters
+  "attempt",
+  "attemptCount",
+  "count"
+];
+var MESH_RECORD_PAYLOAD_KEY_SET = new Set(MESH_RECORD_PAYLOAD_KEYS);
+var MAX_MESH_RECORD_STRING = 200;
+function isProjectedScalarsValue(value) {
+  if (!isRecord(value)) return false;
+  for (const v of Object.values(value)) {
+    if (v === null) continue;
+    if (typeof v === "boolean" || typeof v === "number") continue;
+    if (typeof v === "string") {
+      if (v.length > MAX_MESH_RECORD_STRING) return false;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isMeshRecordPayload(value) {
+  if (!isProjectedScalarsValue(value)) return false;
+  for (const key of Object.keys(value)) {
+    if (!MESH_RECORD_PAYLOAD_KEY_SET.has(key)) return false;
+  }
+  return true;
+}
+function isMeshRecordRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "ledgerKind", "nodeId", "sessionId", "taskId", "payload"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.ledgerKind) && isOptionalId2(value.nodeId) && isOptionalId2(value.sessionId) && isOptionalId2(value.taskId) && isMeshRecordPayload(value.payload);
+}
+function decodeMeshRecordRequest(value) {
+  return isMeshRecordRequest(value) ? value : null;
+}
+function isMeshRecordResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["eventId", "seq"]) && isEvidenceIdentifier(value.eventId) && isNonNegativeInt(value.seq);
+}
+function decodeMeshRecordResponse(value) {
+  return isMeshRecordResponse(value) ? value : null;
+}
+function isTurnCancelRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "attemptId", "taskId", "reason"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  const hasAttempt = value.attemptId !== void 0;
+  const hasTask = value.taskId !== void 0;
+  if (hasAttempt === hasTask) return false;
+  if (hasAttempt && !isEvidenceIdentifier(value.attemptId)) return false;
+  if (hasTask && !isEvidenceIdentifier(value.taskId)) return false;
+  return isTurnReason(value.reason);
+}
+function decodeTurnCancelRequest(value) {
+  return isTurnCancelRequest(value) ? value : null;
+}
+function isTurnCancelResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["attemptRef", "verdict"]) && isTurnAttemptRefValue(value.attemptRef) && isTurnObserveVerdict(value.verdict);
+}
+function decodeTurnCancelResponse(value) {
+  return isTurnCancelResponse(value) ? value : null;
+}
+var OPERATOR_STATUS_VALUES = ["completed", "failed"];
+var isOperatorStatusValue = makeGuard3(OPERATOR_STATUS_VALUES);
+var OPERATOR_STATUS_REASON_VALUES = ["operator_update", "refine_terminal", "validation_terminal"];
+var isOperatorStatusReasonValue = makeGuard3(OPERATOR_STATUS_REASON_VALUES);
+function isOperatorStatusRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "taskId", "status", "reason"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.taskId) && isOperatorStatusValue(value.status) && isOperatorStatusReasonValue(value.reason);
+}
+function decodeOperatorStatusRequest(value) {
+  return isOperatorStatusRequest(value) ? value : null;
+}
+function isOperatorStatusResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["accepted"]) && value.accepted === true;
+}
+function decodeOperatorStatusResponse(value) {
+  return isOperatorStatusResponse(value) ? value : null;
+}
+function isTurnQueryRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "taskId", "attemptId", "sessionId", "state", "since", "tail"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isOptionalId2(value.taskId) && isOptionalId2(value.attemptId) && isOptionalId2(value.sessionId) && (value.state === void 0 || isEvidenceIdentifier(value.state)) && (value.since === void 0 || isFiniteNumber3(value.since)) && (value.tail === void 0 || isNonNegativeInt(value.tail));
+}
+function decodeTurnQueryRequest(value) {
+  return isTurnQueryRequest(value) ? value : null;
+}
+var TURN_QUERY_ATTEMPT_ROW_KEYS = [
+  "attemptId",
+  "generation",
+  "meshId",
+  "taskId",
+  "sessionId",
+  "nodeId",
+  "providerType",
+  "state",
+  "terminalOutcome",
+  "terminalReason",
+  "acceptedAt",
+  "terminalAt"
+];
+function isTurnQueryAttemptRow(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, TURN_QUERY_ATTEMPT_ROW_KEYS)) return false;
+  if (!isEvidenceIdentifier(value.attemptId) || !isNonNegativeInt(value.generation)) return false;
+  if (!isOptionalId2(value.meshId) || !isOptionalId2(value.taskId)) return false;
+  if (!isEvidenceIdentifier(value.sessionId)) return false;
+  if (!isOptionalId2(value.nodeId) || !isOptionalId2(value.providerType)) return false;
+  if (typeof value.state !== "string") return false;
+  if (value.terminalOutcome !== void 0 && !isTurnOutcomeValue(value.terminalOutcome)) return false;
+  if (value.terminalReason !== void 0 && !isTurnReason(value.terminalReason)) return false;
+  if (!isFiniteNumber3(value.acceptedAt)) return false;
+  if (value.terminalAt !== void 0 && !isFiniteNumber3(value.terminalAt)) return false;
+  return true;
+}
+var TURN_QUERY_EVENT_VERDICTS = ["applied", "recorded", "rejected", "forwarded"];
+var TURN_QUERY_EVENT_ROW_KEYS = ["eventId", "attemptId", "generation", "sessionId", "kind", "source", "verdict", "atMs"];
+function isTurnQueryEventRow(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, TURN_QUERY_EVENT_ROW_KEYS)) return false;
+  if (!isEvidenceIdentifier(value.eventId)) return false;
+  if (!isOptionalId2(value.attemptId)) return false;
+  if (value.generation !== void 0 && !isNonNegativeInt(value.generation)) return false;
+  if (!isEvidenceIdentifier(value.sessionId)) return false;
+  if (typeof value.kind !== "string") return false;
+  if (typeof value.source !== "string") return false;
+  if (!TURN_QUERY_EVENT_VERDICTS.includes(value.verdict)) return false;
+  if (!isFiniteNumber3(value.atMs)) return false;
+  return true;
+}
+function isTurnQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["attempts", "events", "replicationPending"])) return false;
+  if (!Array.isArray(value.attempts) || !value.attempts.every(isTurnQueryAttemptRow)) return false;
+  if (!Array.isArray(value.events) || !value.events.every(isTurnQueryEventRow)) return false;
+  if (value.replicationPending !== void 0 && typeof value.replicationPending !== "boolean") return false;
+  return true;
+}
+function decodeTurnQueryResponse(value) {
+  return isTurnQueryResponse(value) ? value : null;
+}
+var MESH_INDEX_QUERY_WRITER_SCOPES = ["own", "fleet"];
+var isMeshIndexQueryWriterScope = makeGuard3(MESH_INDEX_QUERY_WRITER_SCOPES);
+function isMeshIndexQueryRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "ledgerKind", "sessionId", "taskId", "writer", "since", "tail"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isOptionalId2(value.ledgerKind) && isOptionalId2(value.sessionId) && isOptionalId2(value.taskId) && (value.writer === void 0 || isMeshIndexQueryWriterScope(value.writer)) && (value.since === void 0 || isFiniteNumber3(value.since)) && (value.tail === void 0 || isNonNegativeInt(value.tail));
+}
+function decodeMeshIndexQueryRequest(value) {
+  return isMeshIndexQueryRequest(value) ? value : null;
+}
+var MESH_TOPIC_INDEX_ROW_KEYS = [
+  "writer",
+  "seq",
+  "meshId",
+  "eventId",
+  "kind",
+  "ledgerKind",
+  "taskId",
+  "sessionId",
+  "nodeId",
+  "atMs",
+  "payload"
+];
+function isMeshTopicIndexRow(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, MESH_TOPIC_INDEX_ROW_KEYS)) return false;
+  if (!isEvidenceIdentifier(value.writer) || !isNonNegativeInt(value.seq)) return false;
+  if (!isEvidenceIdentifier(value.meshId) || !isEvidenceIdentifier(value.eventId)) return false;
+  if (typeof value.kind !== "string") return false;
+  if (!isOptionalId2(value.ledgerKind) || !isOptionalId2(value.taskId) || !isOptionalId2(value.sessionId) || !isOptionalId2(value.nodeId)) return false;
+  if (!isFiniteNumber3(value.atMs)) return false;
+  if (!isMeshRecordPayload(value.payload)) return false;
+  return true;
+}
+function isMeshIndexQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["rows", "replicationPending"])) return false;
+  if (!Array.isArray(value.rows) || !value.rows.every(isMeshTopicIndexRow)) return false;
+  if (value.replicationPending !== void 0 && typeof value.replicationPending !== "boolean") return false;
+  return true;
+}
+function decodeMeshIndexQueryResponse(value) {
+  return isMeshIndexQueryResponse(value) ? value : null;
+}
+
+// src/turn-ipc-mission.ts
+var MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
+var isMeshMissionStatusValue = makeGuard3(MESH_MISSION_STATUSES);
+function isMissionBriefWire(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["goal", "constraints", "doneCriteria", "handoffNotes", "ownedPaths"])) return false;
+  if (typeof value.goal !== "string" || value.goal.trim().length === 0) return false;
+  for (const k of ["constraints", "doneCriteria", "handoffNotes", "ownedPaths"]) {
+    if (value[k] !== void 0 && !isStringArray(value[k])) return false;
+  }
+  return true;
+}
+function isMeshMissionRecordWire(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["id", "meshId", "title", "goal", "status", "brief"])) return false;
+  if (!isEvidenceIdentifier(value.id) || !isEvidenceIdentifier(value.meshId)) return false;
+  if (typeof value.title !== "string" || typeof value.goal !== "string") return false;
+  if (!isMeshMissionStatusValue(value.status)) return false;
+  if (value.brief !== void 0 && !isMissionBriefWire(value.brief)) return false;
+  return true;
+}
+function isMissionUpsertRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "id", "title", "goal", "status", "brief"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  if (value.id !== void 0 && !isEvidenceIdentifier(value.id)) return false;
+  if (typeof value.title !== "string" || value.title.trim().length === 0) return false;
+  if (value.goal !== void 0 && typeof value.goal !== "string") return false;
+  if (value.status !== void 0 && !isMeshMissionStatusValue(value.status)) return false;
+  if (value.brief !== void 0 && value.brief !== null && !isMissionBriefWire(value.brief)) return false;
+  return true;
+}
+function decodeMissionUpsertRequest(value) {
+  return isMissionUpsertRequest(value) ? value : null;
+}
+function isMissionUpsertResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["mission"]) && isMeshMissionRecordWire(value.mission);
+}
+function decodeMissionUpsertResponse(value) {
+  return isMissionUpsertResponse(value) ? value : null;
+}
+function isMissionQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "statuses", "id"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  if (value.id !== void 0 && !isEvidenceIdentifier(value.id)) return false;
+  if (value.statuses !== void 0) {
+    if (!Array.isArray(value.statuses) || value.statuses.length === 0) return false;
+    if (!value.statuses.every(isMeshMissionStatusValue)) return false;
+  }
+  return true;
+}
+function decodeMissionQueryRequest(value) {
+  return isMissionQueryRequest(value) ? value : null;
+}
+function isMissionQueryResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["missions"]) && Array.isArray(value.missions) && value.missions.every(isMeshMissionRecordWire);
+}
+function decodeMissionQueryResponse(value) {
+  return isMissionQueryResponse(value) ? value : null;
+}
+function isMissionListQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "statuses", "verbose", "withStats", "limit", "historyIdLimit", "meshStatusView"])) return false;
+  if (value.meshStatusView !== void 0 && value.meshStatusView !== "compact" && value.meshStatusView !== "verbose") return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  if (value.statuses !== void 0) {
+    if (!Array.isArray(value.statuses) || value.statuses.length === 0) return false;
+    if (!value.statuses.every(isMeshMissionStatusValue)) return false;
+  }
+  if (value.verbose !== void 0 && typeof value.verbose !== "boolean") return false;
+  if (value.withStats !== void 0 && typeof value.withStats !== "boolean") return false;
+  if (value.limit !== void 0 && !isNonNegativeInt(value.limit)) return false;
+  if (value.historyIdLimit !== void 0 && !isNonNegativeInt(value.historyIdLimit)) return false;
+  return true;
+}
+function decodeMissionListQueryRequest(value) {
+  return isMissionListQueryRequest(value) ? value : null;
+}
+function isMeshMissionTaskAggregateWire(value) {
+  const keys = ["total", "pending", "assigned", "completed", "failed", "cancelled", "blocked", "lastActivityAt"];
+  if (!isRecord(value) || !hasOnlyKeys2(value, keys)) return false;
+  for (const k of ["total", "pending", "assigned", "completed", "failed", "cancelled", "blocked"]) {
+    if (!isNonNegativeInt(value[k])) return false;
+  }
+  return value.lastActivityAt === null || typeof value.lastActivityAt === "string";
+}
+function isMeshMissionStatsWire(value) {
+  const keys = ["missionId", "taskCount", "completed", "failed", "totalDurationMs", "wallClockMs", "retries", "incompleteTaskIds"];
+  if (!isRecord(value) || !hasOnlyKeys2(value, keys)) return false;
+  if (!isEvidenceIdentifier(value.missionId)) return false;
+  for (const k of ["taskCount", "completed", "failed", "totalDurationMs", "retries"]) {
+    if (!isNonNegativeInt(value[k])) return false;
+  }
+  if (value.wallClockMs !== null && !isNonNegativeInt(value.wallClockMs)) return false;
+  if (!Array.isArray(value.incompleteTaskIds) || !value.incompleteTaskIds.every(isEvidenceIdentifier)) return false;
+  return true;
+}
+function isMissionListSummaryWire(value) {
+  if (!isRecord(value)) return false;
+  const hasGoal = "goal" in value;
+  const hasPreview = "goalPreview" in value && "goalTruncated" in value;
+  if (hasGoal === hasPreview) return false;
+  const baseKeys = ["id", "meshId", "title", "status", "tasks", "stats", "brief", "createdAt", "updatedAt", "closeCandidateEmittedAt"];
+  const allowed = hasGoal ? [...baseKeys, "goal"] : [...baseKeys, "goalPreview", "goalTruncated"];
+  if (!hasOnlyKeys2(value, allowed)) return false;
+  if (!isEvidenceIdentifier(value.id) || !isEvidenceIdentifier(value.meshId)) return false;
+  if (typeof value.title !== "string") return false;
+  if (!isMeshMissionStatusValue(value.status)) return false;
+  if (!isMeshMissionTaskAggregateWire(value.tasks)) return false;
+  if (value.stats !== void 0 && !isMeshMissionStatsWire(value.stats)) return false;
+  if (value.brief !== void 0 && !isMissionBriefWire(value.brief)) return false;
+  if (hasGoal && typeof value.goal !== "string") return false;
+  if (hasPreview && (typeof value.goalPreview !== "string" || typeof value.goalTruncated !== "boolean")) return false;
+  if (value.createdAt !== void 0 && typeof value.createdAt !== "string") return false;
+  if (value.updatedAt !== void 0 && typeof value.updatedAt !== "string") return false;
+  if (value.closeCandidateEmittedAt !== void 0 && value.closeCandidateEmittedAt !== null && typeof value.closeCandidateEmittedAt !== "string") return false;
+  return true;
+}
+function isMeshMissionHistoryFoldWire(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["count", "byStatus", "missionIds", "note"])) return false;
+  if (!isNonNegativeInt(value.count)) return false;
+  if (!isRecord(value.byStatus) || !Object.values(value.byStatus).every((n) => isNonNegativeInt(n))) return false;
+  if (!Array.isArray(value.missionIds) || !value.missionIds.every(isEvidenceIdentifier)) return false;
+  return typeof value.note === "string";
+}
+function isMissionListQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["missions", "historyFold", "truncated", "matched", "overflowIds"])) return false;
+  if (!Array.isArray(value.missions) || !value.missions.every(isMissionListSummaryWire)) return false;
+  if (value.historyFold !== null && !isMeshMissionHistoryFoldWire(value.historyFold)) return false;
+  if (typeof value.truncated !== "boolean") return false;
+  if (!isNonNegativeInt(value.matched)) return false;
+  if (value.overflowIds !== void 0 && (!Array.isArray(value.overflowIds) || !value.overflowIds.every(isEvidenceIdentifier))) return false;
+  return true;
+}
+function decodeMissionListQueryResponse(value) {
+  return isMissionListQueryResponse(value) ? value : null;
+}
+var OPERATING_NOTE_CATEGORIES = ["provider_quirk", "pattern_to_avoid", "recovery_lesson"];
+var isOperatingNoteCategory = makeGuard3(OPERATING_NOTE_CATEGORIES);
+function isNoteUpsertRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "text", "category", "pinned", "expiresAt", "supersedes", "subjectKey", "sourceCoordinator"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  if (typeof value.text !== "string" || value.text.trim().length === 0) return false;
+  if (value.category !== void 0 && !isOperatingNoteCategory(value.category)) return false;
+  if (value.pinned !== void 0 && typeof value.pinned !== "boolean") return false;
+  if (value.expiresAt !== void 0 && (typeof value.expiresAt !== "string" || Number.isNaN(Date.parse(value.expiresAt)))) return false;
+  return isOptionalShortString(value.supersedes) && isOptionalShortString(value.subjectKey) && isOptionalShortString(value.sourceCoordinator);
+}
+function decodeNoteUpsertRequest(value) {
+  return isNoteUpsertRequest(value) ? value : null;
+}
+function isNoteUpsertResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["noteId", "deduped", "createdAt"]) && isEvidenceIdentifier(value.noteId) && typeof value.deduped === "boolean" && typeof value.createdAt === "string";
+}
+function decodeNoteUpsertResponse(value) {
+  return isNoteUpsertResponse(value) ? value : null;
+}
+function isNoteForgetRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "noteId", "text", "reason"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  if (value.noteId !== void 0 && !isEvidenceIdentifier(value.noteId)) return false;
+  if (value.text !== void 0 && (typeof value.text !== "string" || value.text.trim().length === 0)) return false;
+  if (value.noteId === void 0 && value.text === void 0) return false;
+  return value.reason === void 0 || typeof value.reason === "string";
+}
+function decodeNoteForgetRequest(value) {
+  return isNoteForgetRequest(value) ? value : null;
+}
+function isNoteForgetResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["matched", "tombstoneId"]) && typeof value.matched === "number" && Number.isInteger(value.matched) && value.matched >= 0 && isEvidenceIdentifier(value.tombstoneId);
+}
+function decodeNoteForgetResponse(value) {
+  return isNoteForgetResponse(value) ? value : null;
+}
+var TOOL_CALLER_ROLES = ["coordinator", "unknown"];
+var isToolCallerRole = makeGuard3(TOOL_CALLER_ROLES);
+function isToolCallRecordRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "tool", "sessionId", "callerRole"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.tool) && isOptionalId2(value.sessionId) && isToolCallerRole(value.callerRole);
+}
+function decodeToolCallRecordRequest(value) {
+  return isToolCallRecordRequest(value) ? value : null;
+}
+function isToolCallRecordResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["rateLimitExceeded", "callsInWindow", "advisory"]) && typeof value.rateLimitExceeded === "boolean" && isNonNegativeInt(value.callsInWindow) && (value.advisory === null || typeof value.advisory === "string");
+}
+function decodeToolCallRecordResponse(value) {
+  return isToolCallRecordResponse(value) ? value : null;
+}
+function isLedgerQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "kind", "since", "node", "tail", "includeSummary"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  if (value.kind !== void 0 && (!Array.isArray(value.kind) || value.kind.length === 0 || !value.kind.every(isEvidenceIdentifier))) return false;
+  if (value.since !== void 0 && typeof value.since !== "string") return false;
+  if (!isOptionalId2(value.node)) return false;
+  if (value.tail !== void 0 && !isNonNegativeInt(value.tail)) return false;
+  if (value.includeSummary !== void 0 && typeof value.includeSummary !== "boolean") return false;
+  return true;
+}
+function decodeLedgerQueryRequest(value) {
+  return isLedgerQueryRequest(value) ? value : null;
+}
+var LEDGER_QUERY_ENTRY_KEYS = ["id", "meshId", "timestamp", "kind", "nodeId", "sessionId", "providerType", "taskId", "payload"];
+function isLedgerQueryEntryWire(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, LEDGER_QUERY_ENTRY_KEYS)) return false;
+  if (!isEvidenceIdentifier(value.id) || !isEvidenceIdentifier(value.meshId)) return false;
+  if (typeof value.timestamp !== "string" || typeof value.kind !== "string") return false;
+  if (!isOptionalId2(value.nodeId) || !isOptionalId2(value.sessionId) || !isOptionalId2(value.providerType) || !isOptionalId2(value.taskId)) return false;
+  if (!isRecord(value.payload)) return false;
+  return true;
+}
+function isLedgerQuerySummaryWire(value) {
+  const keys = ["meshId", "totalEntries", "taskDispatched", "taskCompleted", "taskFailed", "taskStalled", "sessionLaunched", "checkpointCreated", "lastActivityAt", "recentFailures"];
+  if (!isRecord(value) || !hasOnlyKeys2(value, keys)) return false;
+  if (!isEvidenceIdentifier(value.meshId)) return false;
+  for (const k of ["totalEntries", "taskDispatched", "taskCompleted", "taskFailed", "taskStalled", "sessionLaunched", "checkpointCreated", "recentFailures"]) {
+    if (!isNonNegativeInt(value[k])) return false;
+  }
+  if (value.lastActivityAt !== null && typeof value.lastActivityAt !== "string") return false;
+  return true;
+}
+function isLedgerQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["entries", "summary"])) return false;
+  if (!Array.isArray(value.entries) || !value.entries.every(isLedgerQueryEntryWire)) return false;
+  if (value.summary !== void 0 && !isLedgerQuerySummaryWire(value.summary)) return false;
+  return true;
+}
+function decodeLedgerQueryResponse(value) {
+  return isLedgerQueryResponse(value) ? value : null;
+}
+
+// src/turn-ipc-queue.ts
+function isQueueEntryWire(value) {
+  return isRecord(value) && isEvidenceIdentifier(value.id) && typeof value.status === "string";
+}
+function isRecordLocalRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "kind", "nodeId", "sessionId", "providerType", "taskId", "payload"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.kind) && isOptionalId2(value.nodeId) && isOptionalId2(value.sessionId) && isOptionalId2(value.providerType) && isOptionalId2(value.taskId) && isRecord(value.payload);
+}
+function decodeRecordLocalRequest(value) {
+  return isRecordLocalRequest(value) ? value : null;
+}
+function isRecordLocalResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["eventId", "timestamp", "storedLocally", "published"]) && isEvidenceIdentifier(value.eventId) && typeof value.timestamp === "string" && typeof value.storedLocally === "boolean" && typeof value.published === "boolean";
+}
+function decodeRecordLocalResponse(value) {
+  return isRecordLocalResponse(value) ? value : null;
+}
+function isQueueQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "statuses", "taskId", "view", "withCounts", "historicalOlderThanMs", "withDependencyHeads"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (value.statuses !== void 0 && (!Array.isArray(value.statuses) || !value.statuses.every(isEvidenceIdentifier))) return false;
+  if (value.historicalOlderThanMs !== void 0 && !isNonNegativeInt(value.historicalOlderThanMs)) return false;
+  return isOptionalId2(value.taskId) && isOptionalBoolean(value.view) && isOptionalBoolean(value.withCounts) && isOptionalBoolean(value.withDependencyHeads);
+}
+function decodeQueueQueryRequest(value) {
+  return isQueueQueryRequest(value) ? value : null;
+}
+function isQueueDependencyHeadWire(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["id", "status", "cancelReason"]) && typeof value.id === "string" && typeof value.status === "string" && (value.cancelReason === void 0 || typeof value.cancelReason === "string");
+}
+function isQueueQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["entries", "counts", "oldHistoricalCount", "dependencyHeads"])) return false;
+  if (!Array.isArray(value.entries) || !value.entries.every(isQueueEntryWire)) return false;
+  if (value.counts !== void 0 && (!isRecord(value.counts) || !Object.values(value.counts).every(isNonNegativeInt))) return false;
+  if (value.oldHistoricalCount !== void 0 && !isNonNegativeInt(value.oldHistoricalCount)) return false;
+  if (value.dependencyHeads !== void 0 && (!Array.isArray(value.dependencyHeads) || !value.dependencyHeads.every(isQueueDependencyHeadWire))) return false;
+  return true;
+}
+function decodeQueueQueryResponse(value) {
+  return isQueueQueryResponse(value) ? value : null;
+}
+function isQueueEnqueueRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "message", "options"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && typeof value.message === "string" && isOptionalRecord(value.options);
+}
+function decodeQueueEnqueueRequest(value) {
+  return isQueueEnqueueRequest(value) ? value : null;
+}
+function isQueueEnqueueResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["entry"]) && isQueueEntryWire(value.entry);
+}
+function decodeQueueEnqueueResponse(value) {
+  return isQueueEnqueueResponse(value) ? value : null;
+}
+function isQueueEnqueueBatchRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "specs"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isRecordArray(value.specs);
+}
+function decodeQueueEnqueueBatchRequest(value) {
+  return isQueueEnqueueBatchRequest(value) ? value : null;
+}
+function isQueueEnqueueBatchResponse(value) {
+  if (!isRecord(value)) return false;
+  if (value.ok === true) {
+    return hasOnlyKeys2(value, ["ok", "tasks"]) && Array.isArray(value.tasks) && value.tasks.every(isQueueEntryWire);
+  }
+  if (value.ok === false) {
+    return hasOnlyKeys2(value, ["ok", "refusalCode", "message", "extra"]) && typeof value.message === "string" && isOptionalString(value.refusalCode) && isOptionalRecord(value.extra);
+  }
+  return false;
+}
+function decodeQueueEnqueueBatchResponse(value) {
+  return isQueueEnqueueBatchResponse(value) ? value : null;
+}
+function isQueueCancelRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "taskId", "reason"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.taskId) && isOptionalString(value.reason);
+}
+function decodeQueueCancelRequest(value) {
+  return isQueueCancelRequest(value) ? value : null;
+}
+function isQueueCancelResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["task", "before"]) && (value.task === null || isQueueEntryWire(value.task)) && (value.before === null || isQueueEntryWire(value.before));
+}
+function decodeQueueCancelResponse(value) {
+  return isQueueCancelResponse(value) ? value : null;
+}
+function isQueueRequeueRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "taskId", "options"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.taskId) && isOptionalRecord(value.options);
+}
+function decodeQueueRequeueRequest(value) {
+  return isQueueRequeueRequest(value) ? value : null;
+}
+function isQueueRequeueResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["task"]) && (value.task === null || isQueueEntryWire(value.task));
+}
+function decodeQueueRequeueResponse(value) {
+  return isQueueRequeueResponse(value) ? value : null;
+}
+function isDirectDispatchRecordRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "taskId", "message", "task"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.taskId) && typeof value.message === "string" && isOptionalRecord(value.task);
+}
+function decodeDirectDispatchRecordRequest(value) {
+  return isDirectDispatchRecordRequest(value) ? value : null;
+}
+function isDirectDispatchRecordResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["taskRecorded"]) && typeof value.taskRecorded === "boolean";
+}
+function decodeDirectDispatchRecordResponse(value) {
+  return isDirectDispatchRecordResponse(value) ? value : null;
+}
+function isActiveWorkQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "nodes", "queue", "recordTail", "includeTerminalDirect", "compute", "includeInputs", "includeSummary", "includeSchedulingRuntime", "mesh"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (value.nodes !== void 0 && !isRecordArray(value.nodes)) return false;
+  if (value.queue !== void 0 && !isRecordArray(value.queue)) return false;
+  if (value.recordTail !== void 0 && !isNonNegativeInt(value.recordTail)) return false;
+  return isOptionalBoolean(value.includeTerminalDirect) && isOptionalBoolean(value.compute) && isOptionalBoolean(value.includeInputs) && isOptionalBoolean(value.includeSummary) && isOptionalBoolean(value.includeSchedulingRuntime) && isOptionalRecord(value.mesh);
+}
+function decodeActiveWorkQueryRequest(value) {
+  return isActiveWorkQueryRequest(value) ? value : null;
+}
+function isActiveWorkQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["activeWork", "records", "directDispatches", "summary", "schedulingRuntime"])) return false;
+  if (value.records !== void 0 && !isRecordArray(value.records)) return false;
+  if (value.directDispatches !== void 0 && !isRecordArray(value.directDispatches)) return false;
+  return isOptionalRecord(value.activeWork) && isOptionalRecord(value.summary) && isOptionalRecord(value.schedulingRuntime);
+}
+function decodeActiveWorkQueryResponse(value) {
+  return isActiveWorkQueryResponse(value) ? value : null;
+}
+function isRecoveryContextQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "nodeId", "sessionId", "maxRetries", "nodeIds"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (!isOptionalId2(value.nodeId) || !isOptionalId2(value.sessionId)) return false;
+  if (value.maxRetries !== void 0 && !isNonNegativeInt(value.maxRetries)) return false;
+  if (value.nodeIds !== void 0) {
+    if (!Array.isArray(value.nodeIds) || value.nodeIds.length === 0 || !value.nodeIds.every(isEvidenceIdentifier)) return false;
+    return value.nodeId === void 0 && value.sessionId === void 0;
+  }
+  return value.nodeId !== void 0 || value.sessionId !== void 0;
+}
+function decodeRecoveryContextQueryRequest(value) {
+  return isRecoveryContextQueryRequest(value) ? value : null;
+}
+function isRecoveryContextWire(value) {
+  return isRecord(value) && typeof value.consecutiveNodeFailures === "number";
+}
+function isRecoveryContextQueryResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["context", "contexts"])) return false;
+  if (value.context === void 0 && value.contexts === void 0) return false;
+  if (value.context !== void 0 && !isRecoveryContextWire(value.context)) return false;
+  if (value.contexts !== void 0 && (!isRecord(value.contexts) || !Object.values(value.contexts).every(isRecoveryContextWire))) return false;
+  return true;
+}
+function decodeRecoveryContextQueryResponse(value) {
+  return isRecoveryContextQueryResponse(value) ? value : null;
+}
+
+// src/turn-ipc-stats.ts
+function isTaskStatsQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "taskIds", "missionId", "tail", "rollup", "missionIds"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (value.taskIds !== void 0) {
+    if (!Array.isArray(value.taskIds) || value.taskIds.length === 0 || !value.taskIds.every(isEvidenceIdentifier)) return false;
+  }
+  if (value.missionId !== void 0 && !isEvidenceIdentifier(value.missionId)) return false;
+  if (value.tail !== void 0 && !isNonNegativeInt(value.tail)) return false;
+  if (value.missionIds !== void 0) {
+    if (!Array.isArray(value.missionIds) || value.missionIds.length === 0 || !value.missionIds.every(isEvidenceIdentifier)) return false;
+    if (value.taskIds !== void 0 || value.missionId !== void 0) return false;
+  }
+  if (value.rollup === true && value.missionId === void 0) return false;
+  return isOptionalBoolean(value.rollup);
+}
+function decodeTaskStatsQueryRequest(value) {
+  return isTaskStatsQueryRequest(value) ? value : null;
+}
+function isTaskStatsQueryResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["tasks", "mission", "missions"]) && isRecordArray(value.tasks) && isOptionalRecord(value.mission) && (value.missions === void 0 || isRecord(value.missions) && Object.values(value.missions).every(isRecord));
+}
+function decodeTaskStatsQueryResponse(value) {
+  return isTaskStatsQueryResponse(value) ? value : null;
+}
+function isPruneStaleDirectRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "execute", "includeTerminal", "source"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (value.source !== void 0 && typeof value.source !== "string") return false;
+  return isOptionalBoolean(value.execute) && isOptionalBoolean(value.includeTerminal);
+}
+function decodePruneStaleDirectRequest(value) {
+  return isPruneStaleDirectRequest(value) ? value : null;
+}
+function isPruneStaleDirectResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["mode", "includeTerminal", "candidateCount", "prunable", "prunedCount", "preservedUnacknowledged", "preservedLedgerOnly", "preservedNotOrphan"])) return false;
+  if (value.mode !== "execute" && value.mode !== "dry_run") return false;
+  if (typeof value.includeTerminal !== "boolean") return false;
+  if (!isNonNegativeInt(value.candidateCount) || !isNonNegativeInt(value.prunedCount)) return false;
+  return isRecordArray(value.prunable) && isRecordArray(value.preservedUnacknowledged) && isRecordArray(value.preservedLedgerOnly) && isRecordArray(value.preservedNotOrphan);
+}
+function decodePruneStaleDirectResponse(value) {
+  return isPruneStaleDirectResponse(value) ? value : null;
+}
+function isOrphanedPinnedTaskWire(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["taskId", "title", "targetSessionId", "targetNodeId", "missionId"])) return false;
+  if (!isEvidenceIdentifier(value.taskId) || !isEvidenceIdentifier(value.targetSessionId)) return false;
+  if (typeof value.title !== "string") return false;
+  if (value.targetNodeId !== void 0 && !isEvidenceIdentifier(value.targetNodeId)) return false;
+  return value.missionId === void 0 || isEvidenceIdentifier(value.missionId);
+}
+function isOrphanedPinNotifyRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "stoppedSessionId", "excludeTaskId", "cause", "nodeId", "coordinatorSessionId"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId) || !isEvidenceIdentifier(value.stoppedSessionId)) return false;
+  if (value.excludeTaskId !== void 0 && !isEvidenceIdentifier(value.excludeTaskId)) return false;
+  if (value.cause !== void 0 && typeof value.cause !== "string") return false;
+  if (value.nodeId !== void 0 && !isEvidenceIdentifier(value.nodeId)) return false;
+  return value.coordinatorSessionId === void 0 || isEvidenceIdentifier(value.coordinatorSessionId);
+}
+function decodeOrphanedPinNotifyRequest(value) {
+  return isOrphanedPinNotifyRequest(value) ? value : null;
+}
+function isOrphanedPinNotifyResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["orphans"]) && Array.isArray(value.orphans) && value.orphans.every(isOrphanedPinnedTaskWire);
+}
+function decodeOrphanedPinNotifyResponse(value) {
+  return isOrphanedPinNotifyResponse(value) ? value : null;
+}
+
+// src/turn-ipc.ts
+var TURN_IPC_ERROR_CODES = ["daemon_required", "turn_ledger_unavailable", "ledger_not_owner"];
+var isTurnIpcErrorCode = makeGuard3(TURN_IPC_ERROR_CODES);
+function isTurnIpcError(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["code", "detail"]) && isTurnIpcErrorCode(value.code) && (value.detail === void 0 || typeof value.detail === "string");
+}
+var TURN_IPC_COMMANDS = [
+  "turn_observe",
+  "mesh_record",
+  "turn_cancel",
+  "operator_status",
+  "turn_query",
+  "mesh_index_query",
+  "mission_upsert",
+  "mission_query",
+  "note_upsert",
+  "note_forget",
+  // C-W9b additions (2026-09-24 14:00 stamp "C-W9"):
+  "tool_call_record",
+  "ledger_query",
+  "mission_list_query",
+  // C-W9a additions (the event ledger retired; the queue behind IPC):
+  "record_local",
+  "queue_query",
+  "queue_enqueue",
+  "queue_enqueue_batch",
+  "queue_cancel",
+  "queue_requeue",
+  "direct_dispatch_record",
+  "active_work_query",
+  "recovery_context_query",
+  // C-W9c additions (2026-09-24 19:00 stamp — the last mcp-server in-process
+  // daemon-core paths: mission reads, task/mission stats, orphaned-pin
+  // helpers, one prune audit):
+  "task_stats_query",
+  "prune_stale_direct",
+  "orphaned_pin_notify"
+];
+var isTurnIpcCommand = makeGuard3(TURN_IPC_COMMANDS);
+
+// src/path-ownership.ts
+var MAX_OWNED_PATHS = 64;
+function toPosix(raw) {
+  return raw.replace(/\\/g, "/");
+}
+function normalizeOne(raw, rejected) {
+  if (typeof raw !== "string") {
+    rejected.push({ input: String(raw), reason: "not_a_string" });
+    return null;
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    rejected.push({ input: raw, reason: "empty" });
+    return null;
+  }
+  let posix = toPosix(trimmed);
+  if (posix.startsWith("/") || /^[a-zA-Z]:\//.test(posix) || posix.startsWith("~")) {
+    rejected.push({ input: raw, reason: "absolute_path" });
+    return null;
+  }
+  posix = posix.replace(/^\.\/+/, "");
+  const segments = posix.split("/").filter(Boolean);
+  if (segments.some((seg) => seg === "..")) {
+    rejected.push({ input: raw, reason: "parent_traversal" });
+    return null;
+  }
+  if (segments.length === 0) {
+    rejected.push({ input: raw, reason: "empty" });
+    return null;
+  }
+  let subtree = false;
+  if (segments[segments.length - 1] === "**") {
+    subtree = true;
+    segments.pop();
+    if (segments.length === 0) {
+    }
+  }
+  if (segments.some((seg) => seg.includes("*") || seg.includes("?"))) {
+    rejected.push({ input: raw, reason: "unsupported_glob" });
+    return null;
+  }
+  return { path: segments.join("/"), subtree };
+}
+function normalizeOwnedPaths(input) {
+  const rejected = [];
+  if (input === void 0 || input === null) {
+    return { declaration: { paths: [] }, rejected };
+  }
+  if (!Array.isArray(input)) {
+    return { declaration: { paths: [] }, rejected: [{ input: String(input), reason: "not_an_array" }] };
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const raw of input) {
+    const entry = normalizeOne(raw, rejected);
+    if (!entry) continue;
+    const existing = byPath.get(entry.path);
+    if (!existing) {
+      byPath.set(entry.path, entry);
+    } else if (entry.subtree && !existing.subtree) {
+      byPath.set(entry.path, entry);
+    }
+  }
+  const all = [...byPath.values()];
+  const kept = all.slice(0, MAX_OWNED_PATHS);
+  for (const dropped of all.slice(MAX_OWNED_PATHS)) {
+    rejected.push({ input: dropped.path, reason: "over_cap" });
+  }
+  return { declaration: { paths: kept }, rejected };
+}
+function entryContains(base, path) {
+  if (path === base.path) return true;
+  if (base.subtree && (path === base.path || path.startsWith(`${base.path}/`))) return true;
+  return false;
+}
+function entriesOverlap(a, b) {
+  if (a.path === b.path) return true;
+  if (a.subtree && (b.path === a.path || b.path.startsWith(`${a.path}/`))) return true;
+  if (b.subtree && (a.path === b.path || a.path.startsWith(`${b.path}/`))) return true;
+  return false;
+}
+function pathsOverlap(a, b) {
+  if (a.paths.length === 0 || b.paths.length === 0) return false;
+  for (const pa of a.paths) {
+    for (const pb of b.paths) {
+      if (entriesOverlap(pa, pb)) return true;
+    }
+  }
+  return false;
+}
+function findOwnershipConflicts(candidate, inFlight) {
+  if (candidate.paths.length === 0) return [];
+  const conflicts = [];
+  for (const other of inFlight) {
+    if (other.paths.paths.length === 0) continue;
+    const overlappingPaths = [];
+    for (const pa of candidate.paths) {
+      for (const pb of other.paths.paths) {
+        if (entriesOverlap(pa, pb)) {
+          const narrower = pa.path.length >= pb.path.length ? pa.path : pb.path;
+          if (!overlappingPaths.includes(narrower)) overlappingPaths.push(narrower);
+        }
+      }
+    }
+    if (overlappingPaths.length > 0) {
+      conflicts.push({ taskId: other.taskId, overlappingPaths });
+    }
+  }
+  return conflicts;
+}
+function touchedFilesOutsideOwnership(touched, owned) {
+  const undeclaredTouched = [];
+  const usedDeclarations = /* @__PURE__ */ new Set();
+  for (const raw of touched ?? []) {
+    const rejectedSink = [];
+    const entry = normalizeOne(raw, rejectedSink);
+    if (!entry) {
+      undeclaredTouched.push(raw);
+      continue;
+    }
+    const matches = owned.paths.filter((base) => entryContains(base, entry.path));
+    if (matches.length === 0) {
+      undeclaredTouched.push(entry.path);
+    } else {
+      for (const m of matches) usedDeclarations.add(m.path);
+    }
+  }
+  const unusedDeclarations = owned.paths.map((p) => p.path).filter((p) => !usedDeclarations.has(p));
+  return { undeclaredTouched, unusedDeclarations };
+}
+
+// src/keyed-doc-delta.ts
+function sig(value) {
+  if (value === void 0) return void 0;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readPath(doc, path) {
+  const [head, tail] = splitPath(path);
+  if (!tail) return doc[head];
+  const parent = doc[head];
+  return isRecord3(parent) ? parent[tail] : void 0;
+}
+function splitPath(path) {
+  const dot = path.indexOf(".");
+  return dot < 0 ? [path, void 0] : [path.slice(0, dot), path.slice(dot + 1)];
+}
+function stripCollections(doc, spec) {
+  const out = { ...doc };
+  for (const path of Object.keys(spec.collections)) {
+    const [head, tail] = splitPath(path);
+    if (!tail) {
+      delete out[head];
+      continue;
+    }
+    const parent = out[head];
+    if (!isRecord3(parent) || !(tail in parent)) continue;
+    const copy = { ...parent };
+    delete copy[tail];
+    out[head] = copy;
+  }
+  return out;
+}
+function fieldSigsOf(digest) {
+  if (!digest.fieldSigs) {
+    const sigs = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(digest.stable)) {
+      const s = sig(value);
+      if (s !== void 0) sigs.set(key, s);
+    }
+    digest.fieldSigs = sigs;
+  }
+  return digest.fieldSigs;
+}
+function digestKeyedDoc(doc, spec) {
+  const top = /* @__PURE__ */ new Map();
+  const topValues = {};
+  const ignore = new Set(spec.ignore ?? []);
+  const split = new Set(spec.splitObjects ?? []);
+  const add = (path, value) => {
+    if (ignore.has(path)) return;
+    const s = sig(value);
+    if (s === void 0) return;
+    top.set(path, s);
+    topValues[path] = value;
+  };
+  for (const [key, value] of Object.entries(stripCollections(doc, spec))) {
+    if (split.has(key) && isRecord3(value)) {
+      for (const [field, fieldValue] of Object.entries(value)) add(`${key}.${field}`, fieldValue);
+      continue;
+    }
+    add(key, value);
+  }
+  const collections = /* @__PURE__ */ new Map();
+  for (const [path, idField] of Object.entries(spec.collections)) {
+    const list = readPath(doc, path);
+    if (!Array.isArray(list)) continue;
+    const rows = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const row of list) {
+      if (!isRecord3(row)) continue;
+      const id2 = row[idField];
+      if (typeof id2 !== "string" || !id2 || rows.has(id2)) continue;
+      const stable = spec.stableRow ? spec.stableRow(path, row) : row;
+      rows.set(id2, { value: row, stable, sig: sig(stable) ?? "" });
+      order.push(id2);
+    }
+    collections.set(path, { rows, order });
+  }
+  return { top, topValues, collections, volatile: new Set(spec.volatileTopLevel ?? []) };
+}
+function sameOrder(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+  return true;
+}
+function diffCollection(prev, next, idField) {
+  if (!next) return prev ? { absent: true } : null;
+  const delta = {};
+  const prevRows = prev?.rows ?? /* @__PURE__ */ new Map();
+  const nextRows = next?.rows ?? /* @__PURE__ */ new Map();
+  for (const [id2, nextRow] of nextRows) {
+    const prevRow = prevRows.get(id2);
+    if (!prevRow) {
+      ;
+      (delta.upsert ??= []).push(nextRow.value);
+      continue;
+    }
+    if (prevRow.sig === nextRow.sig) continue;
+    const prevSigs = fieldSigsOf(prevRow);
+    const nextSigs = fieldSigsOf(nextRow);
+    const change = { [idField]: id2 };
+    let changed = false;
+    for (const [key, s] of nextSigs) {
+      if (key === idField || prevSigs.get(key) === s) continue;
+      change[key] = nextRow.value[key];
+      changed = true;
+    }
+    if (changed) {
+      for (const [key, value] of Object.entries(nextRow.value)) {
+        if (key in nextRow.stable || key in change) continue;
+        if (sig(prevRow.value[key]) !== sig(value)) change[key] = value;
+      }
+    }
+    const gone = [];
+    for (const key of prevSigs.keys()) if (!nextSigs.has(key) && !(key in nextRow.value)) gone.push(key);
+    if (changed) (delta.upsert ??= []).push(change);
+    if (gone.length > 0) (delta.unsetFields ??= {})[id2] = gone;
+  }
+  for (const id2 of prevRows.keys()) {
+    if (!nextRows.has(id2)) (delta.removed ??= []).push(id2);
+  }
+  if (!sameOrder(prev?.order ?? [], next?.order ?? [])) delta.order = [...next?.order ?? []];
+  return Object.keys(delta).length > 0 ? delta : null;
+}
+function diffKeyedDoc(prev, next, spec) {
+  const delta = {};
+  let meaningful = false;
+  let set;
+  let unset;
+  const split = spec.splitObjects ?? [];
+  const objectOf = (path) => {
+    for (const object of split) {
+      if (path.startsWith(`${object}.`)) return [object, path.slice(object.length + 1)];
+    }
+    return null;
+  };
+  const objects = {};
+  for (const [path, s] of next.top) {
+    if (prev.top.get(path) === s) continue;
+    const inObject = objectOf(path);
+    if (inObject) ((objects[inObject[0]] ??= {}).set ??= {})[inObject[1]] = next.topValues[path];
+    else (set ??= {})[path] = next.topValues[path];
+    if (!next.volatile.has(path)) meaningful = true;
+  }
+  for (const path of prev.top.keys()) {
+    if (next.top.has(path)) continue;
+    const inObject = objectOf(path);
+    if (inObject) ((objects[inObject[0]] ??= {}).unset ??= []).push(inObject[1]);
+    else (unset ??= []).push(path);
+    if (!next.volatile.has(path)) meaningful = true;
+  }
+  for (const [path, idField] of Object.entries(spec.collections)) {
+    const change = diffCollection(prev.collections.get(path), next.collections.get(path), idField);
+    if (!change) continue;
+    (delta.collections ??= {})[path] = change;
+    meaningful = true;
+  }
+  if (!meaningful) return null;
+  if (set) delta.set = set;
+  if (unset) delta.unset = unset;
+  if (Object.keys(objects).length > 0) delta.objects = objects;
+  return delta;
+}
+function foldCollection(held, change, idField) {
+  const byId = /* @__PURE__ */ new Map();
+  const heldOrder = [];
+  for (const row of Array.isArray(held) ? held : []) {
+    if (!isRecord3(row) || typeof row[idField] !== "string") continue;
+    byId.set(row[idField], row);
+    heldOrder.push(row[idField]);
+  }
+  for (const id2 of change.removed ?? []) byId.delete(id2);
+  for (const row of change.upsert ?? []) {
+    const id2 = row[idField];
+    if (typeof id2 !== "string") continue;
+    const base = byId.get(id2);
+    byId.set(id2, base ? { ...base, ...row } : { ...row });
+  }
+  for (const [id2, keys] of Object.entries(change.unsetFields ?? {})) {
+    const base = byId.get(id2);
+    if (!base) continue;
+    const trimmed = { ...base };
+    for (const key of keys) delete trimmed[key];
+    byId.set(id2, trimmed);
+  }
+  const order = change.order ?? heldOrder;
+  const out = [];
+  const placed = /* @__PURE__ */ new Set();
+  for (const id2 of order) {
+    const row = byId.get(id2);
+    if (!row || placed.has(id2)) continue;
+    out.push(row);
+    placed.add(id2);
+  }
+  for (const [id2, row] of byId) if (!placed.has(id2)) out.push(row);
+  return out;
+}
+function foldKeyedDoc(held, delta, spec) {
+  const heldCollections = /* @__PURE__ */ new Map();
+  for (const path of Object.keys(spec.collections)) heldCollections.set(path, readPath(held, path));
+  const next = stripCollections(held, spec);
+  for (const key of delta.unset ?? []) delete next[key];
+  Object.assign(next, delta.set ?? {});
+  for (const [object, change] of Object.entries(delta.objects ?? {})) {
+    const folded = isRecord3(next[object]) ? { ...next[object] } : {};
+    for (const key of change.unset ?? []) delete folded[key];
+    Object.assign(folded, change.set ?? {});
+    next[object] = folded;
+  }
+  for (const [path, idField] of Object.entries(spec.collections)) {
+    const change = delta.collections?.[path];
+    const heldList = heldCollections.get(path);
+    if (change?.absent) {
+      const [head2, tail2] = splitPath(path);
+      if (!tail2) delete next[head2];
+      continue;
+    }
+    if (!change && heldList === void 0) continue;
+    const list = change ? foldCollection(heldList, change, idField) : heldList;
+    const [head, tail] = splitPath(path);
+    if (!tail) {
+      next[head] = list;
+      continue;
+    }
+    const parent = isRecord3(next[head]) ? { ...next[head] } : {};
+    parent[tail] = list;
+    next[head] = parent;
+  }
+  return next;
+}
+var DAEMON_METADATA_DOC_SPEC = {
+  collections: { "status.sessions": "id" },
+  splitObjects: ["status"],
+  ignore: ["daemonId", "status.timestamp"],
+  stableRow: (_collection, row) => {
+    if (!("lastUpdated" in row)) return row;
+    const { lastUpdated: _stamp, ...stable } = row;
+    return stable;
+  }
+};
+var MESH_STATUS_DOC_SPEC = {
+  collections: { nodes: "nodeId", "queue.tasks": "id", missions: "id" },
+  volatileTopLevel: [
+    "refreshedAt",
+    "sourceOfTruth",
+    "turnPresentationCounters",
+    "meshProtocolV2Counters",
+    "pendingRetentionCounters",
+    "meshProtocolMetrics"
+  ],
+  stableRow: (collection, row) => collection === "nodes" ? stableMeshNodeRow(row) : row
+};
+function without(value, keys) {
+  if (!isRecord3(value)) return value;
+  const out = { ...value };
+  for (const key of keys) delete out[key];
+  return out;
+}
+function stableMeshNodeRow(row) {
+  const out = { ...row };
+  delete out.lastSeenAt;
+  delete out.updatedAt;
+  delete out.last_seen_at;
+  delete out.updated_at;
+  if ("dataFreshness" in out) out.dataFreshness = without(out.dataFreshness, ["ageMs", "lastProbeAt", "staleness"]);
+  if ("connection" in out) out.connection = without(out.connection, ["lastStateChangeAt"]);
+  if ("git" in out) {
+    const git = without(out.git, ["lastCheckedAt"]);
+    if (isRecord3(git) && Array.isArray(git.submodules) && git.submodules.length === 0) delete git.submodules;
+    out.git = git;
+  }
+  if ("nodeFacts" in out) out.nodeFacts = without(out.nodeFacts, ["reportedAt"]);
+  const observation = out.gitObservation;
+  if (isRecord3(observation) && (observation.source === "self" || observation.source === "local")) {
+    out.gitObservation = without(observation, ["observedAt"]);
+  }
+  return out;
+}
 export {
+  CANCEL_REASONS,
   CANONICAL_MESH_TOOL_COUNT,
   CANONICAL_MESH_TOOL_NAMES,
   CLAUDE_TUI_REVIEW_PAGE_NOT_FOCUSED_PREFIX,
   CLAUDE_TUI_REVIEW_UNCONFIRMED_PREFIX,
   CLI_SLOT_RECIPES,
+  COMMIT_STRENGTHS,
+  CONSUME_PROFILES,
+  COORDINATOR_ACK_OUTCOMES,
+  DAEMON_METADATA_DOC_SPEC,
+  DAEMON_P2P_SIGNAL_TYPES,
+  DAEMON_STATUS_EVENT_NAMES,
+  DAEMON_TO_DASHBOARD_P2P_TYPES,
+  DAEMON_TO_SERVER_TYPES,
   DAEMON_TO_SERVER_WS_MSGS,
+  DASHBOARD_P2P_MESSAGE_KINDS,
+  DASHBOARD_P2P_SIGNAL_TYPES,
+  DASHBOARD_STATUS_EVENT_NAMES,
+  DASHBOARD_TO_DAEMON_P2P_TYPES,
+  DASHBOARD_TO_USER_SESSION_TYPES,
+  DASHBOARD_WIRE_VERSION,
   DEFAULT_DIFFICULTY_BRAINS,
-  MAGI_RAW_ANSWER_CAP,
+  DELIVERY_OUTCOMES,
+  DELIVERY_VIAS,
+  DISPATCH_FAILURE_REASONS,
+  EVIDENCE_ENVELOPE_FIELD_SPECS,
+  EVIDENCE_SOURCE_IDS,
+  HOLD_REASONS,
+  LIVENESS_RESULTS,
+  MAX_MESH_RECORD_STRING,
+  MAX_OWNED_PATHS,
   MESH_CHUNK_KIND,
   MESH_CHUNK_PAYLOAD_CHARS,
   MESH_CHUNK_TTL_MS,
+  MESH_DELIVERY_MODES,
+  MESH_INDEX_QUERY_WRITER_SCOPES,
   MESH_MAX_CHUNKS,
   MESH_MAX_INLINE_FRAME_BYTES,
   MESH_MAX_REASSEMBLED_BYTES,
+  MESH_MISSION_STATUSES,
+  MESH_P2P_SIGNAL_TYPES,
+  MESH_RECORD_PAYLOAD_KEYS,
+  MESH_SESSION_CLEANUP_MODES,
+  MESH_STATUS_DOC_SPEC,
   MESH_TASK_DIFFICULTIES,
+  MESH_TASK_MODES,
+  MESH_TASK_PRIORITIES,
+  MESH_TASK_STATUSES,
+  MESH_TERMINAL_TASK_STATUSES,
+  MESH_THINKING_LEVELS,
+  MESH_TOPIC_ENTRY_KINDS,
+  MESH_TOPIC_PROTOCOL_VERSION,
+  MISSION_BRIEF_RENDER_MAX_CHARS,
+  MODEL_AXIS_SOURCES,
+  MODEL_SELECTION_HISTORY_LIMIT,
   MeshChunkAssembler,
+  NATIVE_TURN_OUTCOMES,
+  NOTIFY_KINDS,
+  NO_PROGRESS_OBSERVED_STATUSES,
+  NPM_UPDATE_TAGS,
+  OPERATING_NOTE_CATEGORIES,
+  OPERATOR_STATUSES,
+  OPERATOR_STATUS_REASONS,
+  OPERATOR_STATUS_REASON_VALUES,
+  OPERATOR_STATUS_VALUES,
+  OUTBOUND_MESSAGE_ORIGINS,
+  P2P_SIGNAL_TYPES,
+  PROVIDER_FAILURES,
   QUOTA_SUPPORTED_PROVIDERS,
+  RECENT_SESSION_BUCKETS,
+  RECLAIMING_SEND_REFUSALS,
+  RELEASE_CHANNELS,
+  REMOVED_MESH_TOOLS,
+  RETIRED_MESH_TOOLS,
+  SEND_POLICY_MODES,
+  SEND_REFUSAL_REASONS,
+  SERVER_STATUS_EVENT_NAMES,
+  SERVER_TO_DAEMON_CONTROL_TYPES,
   SERVER_TO_DAEMON_WS_MSGS,
+  SESSION_ERROR_REASONS,
+  SESSION_LAUNCHED_BY,
+  SESSION_REBOUND_REASONS,
+  SESSION_STATUSES,
+  SESSION_STATUS_ALIASES,
+  SESSION_STATUS_CLASS,
+  SHARED_SESSION_TO_VIEWER_TYPES,
   STATUS_PROBE_ARG_KEY,
+  SUSPENSION_MODALS,
+  SUSPENSION_RESOLUTIONS,
+  SUSPENSION_RESOLUTION_VIAS,
+  SYSTEM_ANNOUNCEMENT_TYPES,
+  TERMINAL_CLASS_EVIDENCE_KINDS,
+  TERMINAL_SESSION_RECORD_STATUSES,
+  TOOL_CALLER_ROLES,
+  TURN_END_BLOCK_REASONS,
+  TURN_END_STRENGTHS,
+  TURN_EVIDENCE_FIELD_SPECS,
+  TURN_EVIDENCE_FLAGS,
+  TURN_EVIDENCE_KINDS,
+  TURN_IPC_COMMANDS,
+  TURN_IPC_ERROR_CODES,
+  TURN_IPC_PROTOCOL_VERSION,
+  TURN_OBSERVE_VERDICTS,
+  TURN_OUTCOMES,
+  TURN_REASONS,
+  TURN_SCOPES,
   UNKNOWN_CLI_SLOT_RECIPE,
+  USER_SESSION_TO_DASHBOARD_TYPES,
+  VERSION_UPDATE_REASONS,
+  VIEWER_TO_SHARED_SESSION_TYPES,
+  WORKER_BRANCH_STATES,
+  WORKER_PROTOCOL_FOOTER_MARKER,
+  WORKER_REPORT_OUTCOMES,
+  WORKER_TOOLS,
+  appendWorkerProtocolFooter,
   argsCarryStatusProbeMarker,
-  buildMagiPanelProposal,
   buildSlotProposal,
   canonicalDaemonId,
+  classifySessionStatus,
+  compareDashboardWireVersion,
   compareSemver,
   daemonIdsEquivalent,
+  decodeActiveWorkQueryRequest,
+  decodeActiveWorkQueryResponse,
+  decodeDaemonToDashboardP2P,
+  decodeDaemonToServer,
+  decodeDashboardToDaemonP2P,
+  decodeDashboardToDaemonP2PChunk,
+  decodeDashboardToUserSession,
+  decodeDirectDispatchRecordRequest,
+  decodeDirectDispatchRecordResponse,
+  decodeLedgerQueryRequest,
+  decodeLedgerQueryResponse,
+  decodeMeshIndexQueryRequest,
+  decodeMeshIndexQueryResponse,
+  decodeMeshRecordRequest,
+  decodeMeshRecordResponse,
+  decodeMissionListQueryRequest,
+  decodeMissionListQueryResponse,
+  decodeMissionQueryRequest,
+  decodeMissionQueryResponse,
+  decodeMissionUpsertRequest,
+  decodeMissionUpsertResponse,
+  decodeNoteForgetRequest,
+  decodeNoteForgetResponse,
+  decodeNoteUpsertRequest,
+  decodeNoteUpsertResponse,
+  decodeOperatorStatusRequest,
+  decodeOperatorStatusResponse,
+  decodeOrphanedPinNotifyRequest,
+  decodeOrphanedPinNotifyResponse,
+  decodePruneStaleDirectRequest,
+  decodePruneStaleDirectResponse,
+  decodeQueueCancelRequest,
+  decodeQueueCancelResponse,
+  decodeQueueEnqueueBatchRequest,
+  decodeQueueEnqueueBatchResponse,
+  decodeQueueEnqueueRequest,
+  decodeQueueEnqueueResponse,
+  decodeQueueQueryRequest,
+  decodeQueueQueryResponse,
+  decodeQueueRequeueRequest,
+  decodeQueueRequeueResponse,
+  decodeRecordLocalRequest,
+  decodeRecordLocalResponse,
+  decodeRecoveryContextQueryRequest,
+  decodeRecoveryContextQueryResponse,
+  decodeServerToDaemon,
+  decodeTaskStatsQueryRequest,
+  decodeTaskStatsQueryResponse,
+  decodeToolCallRecordRequest,
+  decodeToolCallRecordResponse,
+  decodeTurnCancelRequest,
+  decodeTurnCancelResponse,
+  decodeTurnObserveRequest,
+  decodeTurnObserveResponse,
+  decodeTurnQueryRequest,
+  decodeTurnQueryResponse,
+  decodeTypeField,
+  decodeUserSessionToDashboard,
+  decodeViewerToSharedSession,
   deriveProviderPriorityFromSlots,
   deriveSlotsFromLegacy,
+  describeModelSelection,
+  diffKeyedDoc,
+  digestKeyedDoc,
+  effectiveModelSelectionValue,
+  enumOf,
   expandDaemonIdForms,
+  findOwnershipConflicts,
+  foldKeyedDoc,
   formatQuotaAccount,
   hasGitStatusEvidence,
-  interpolateArgs,
+  hasWorkerProtocolFooter,
   interpolateString,
-  isDaemonToServerWsMsg,
+  isBlockedStatus,
+  isBusyStatus,
+  isChunkType,
+  isCommitStrength,
+  isDaemonDirectCommandType,
+  isDaemonP2PSignalType,
+  isDaemonStatusEventName,
+  isDaemonToDashboardP2PType,
+  isDaemonToServerType,
+  isDashboardP2PSignalType,
+  isDashboardStatusEventName,
+  isDashboardToDaemonChunkType,
+  isDashboardToDaemonP2PType,
+  isDashboardToUserSessionType,
+  isDeadStatus,
   isDowngrade,
+  isEvidenceIdentifier,
+  isFiniteNumber,
+  isIdleSessionState,
+  isInputEnvelopeWire,
+  isMeshDeliveryMode,
+  isMeshIndexQueryResponse,
+  isMeshMissionStatusValue,
+  isMeshP2PSignalType,
+  isMeshRecordPayload,
   isMeshTaskDifficulty,
+  isMeshTaskMode,
+  isMeshTaskPriority,
+  isMeshTaskStatus,
+  isMeshTerminalTaskStatus,
+  isMeshTopicEntry,
+  isMessageId,
+  isMissionUpsertResponse,
+  isModelAxisSource,
+  isNonEmptyString,
+  isNotifyKind,
+  isOutboundMessage,
+  isOutboundMessageOrigin,
+  isP2PSignalType,
   isPhantomDaemonEntry,
   isRawDaemonDoId,
-  isServerToDaemonWsMsg,
+  isReadyStatus,
+  isRecord,
+  isSendPolicy,
+  isSendPolicyMode,
+  isSendRefusal,
+  isServerDirectCommandMsg,
+  isServerToDaemonControlType,
+  isSessionLaunchedBy,
+  isSessionStatus,
+  isSharedSessionToViewerType,
+  isSubmitOutcome,
+  isSummaryRef,
+  isTerminalSessionRecordStatus,
+  isTurnAttemptRef,
+  isTurnEvidence,
+  isTurnEvidenceKind,
+  isTurnIpcCommand,
+  isTurnIpcError,
+  isTurnIpcErrorCode,
+  isTurnOutcome,
+  isTurnReason,
+  isUserSessionToDashboardType,
+  isViewerToSharedSessionType,
+  isWorkerReportOutcome,
+  isWorkerTool,
+  isWorkingStatus,
   joinRepoPath,
+  launchModelSelectionValue,
   machineCoreFromDaemonId,
+  makeTypeGuard,
   measureWorstCaseChunkEnvelopeBytes,
   meshFrameNeedsChunking,
   meshNodeIdMatches,
   meshUtf8ByteLength,
   meshWorkspacesEquivalent,
+  mintMessageId,
+  normalizeAuthOkLimits,
   normalizeBrainSlot,
   normalizeDifficultyBrainMap,
   normalizeGitStatus,
@@ -1046,25 +3580,44 @@ export {
   normalizeMeshNodeId,
   normalizeMeshSessionRecord,
   normalizeMeshWorkspaceForCompare,
+  normalizeMissionBrief,
   normalizeNodeCapabilitySlot,
   normalizeNodeCapabilitySlots,
+  normalizeOwnedPaths,
+  normalizeSessionStatus,
   normalizeThinkingLevel,
   parseJsonRecord,
   parseSemver,
+  parseSessionLaunchRecord,
+  pathsOverlap,
   pickBestTransitGitStatus,
+  projectFileDiffRow,
+  projectTurnEvidenceEntry,
   readBoolean,
+  readEnvelopeFields,
   readGitSubmodules,
   readNumber,
+  readOptionalRecord,
   readRecord,
   readString,
   readStringArray,
+  readText,
+  renderCoordinatorWorkerSection,
+  renderMissionBriefBlock,
+  renderWorkerProtocolFooter,
+  retiredMeshToolError,
+  sanitizeModelIdentifier,
+  sanitizeRefusalCode,
   scoreGitStatusCandidate,
   scoreGitUpstreamFreshness,
   sessionIdsEquivalent,
   splitMeshFrame,
+  statusesOfClass,
   stripStatusProbeMarker,
+  stripWorkerProtocolFooter,
   summarizeGitShape,
   supportsQuota,
+  touchedFilesOutsideOwnership,
   withStatusProbeMarker
 };
 //# sourceMappingURL=index.mjs.map