@adhdev/mesh-shared 1.0.60-rc.4 → 1.0.60-rc.41

package/dist/index.mjs

@@ -287,8 +287,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 +299,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 +310,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}`;
@@ -704,7 +704,6 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_record_note",
   "mesh_forget_note",
   "mesh_reconcile_ledger",
-  "mesh_requeue_held_events",
   "mesh_mission_upsert",
   "mesh_mission_list",
   "mesh_review_inbox",
@@ -957,8 +956,54 @@ 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",
+  /** Legacy alias for `monitor:no_progress`, still emitted by older daemons. */
+  "monitor:long_generating"
+];
+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 +1011,29 @@ var DAEMON_TO_SERVER_WS_MSGS = [
   "command_result",
   "error",
   "agent_event",
-  "log",
-  "beacon_vectors"
+  "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 +1044,2411 @@ var SERVER_TO_DAEMON_WS_MSGS = [
   "command",
   "agent_command",
   "resolve_action",
-  "beacon_vectors_result"
+  "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 === "beacon_vectors_result" || raw.type === "daemon_mesh_result") {
+    if (!isNonEmptyString(raw.requestId)) return null;
+    const base = { requestId: raw.requestId, success: raw.success === true };
+    if (raw.type === "beacon_vectors_result") {
+      return {
+        type: "beacon_vectors_result",
+        ...base,
+        ...Array.isArray(raw.reports) ? { reports: raw.reports } : {},
+        ...typeof raw.truncated === "number" ? { truncated: raw.truncated } : {},
+        ...typeof raw.error === "string" ? { error: raw.error } : {}
+      };
+    }
+    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"
 ];
-function isDaemonToServerWsMsg(value) {
-  return typeof value === "string" && DAEMON_TO_SERVER_WS_MSGS.includes(value);
+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) };
 }
-function isServerToDaemonWsMsg(value) {
-  return typeof value === "string" && SERVER_TO_DAEMON_WS_MSGS.includes(value);
+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_report",
+  "status_event",
+  "topic_update",
+  "topic_update_chunk",
+  "session_output",
+  "session_output_chunk",
+  "session_io_error",
+  "command_result",
+  "command_result_chunk",
+  "response"
+];
+var isDaemonToDashboardP2PType = makeTypeGuard(DAEMON_TO_DASHBOARD_P2P_TYPES);
+function decodeDaemonToDashboardP2P(raw) {
+  if (!isRecord(raw)) return null;
+  if (raw.type === void 0 && isNonEmptyString(raw.id) && typeof raw.success === "boolean") {
+    return { ...raw, type: "response" };
+  }
+  if (!isDaemonToDashboardP2PType(raw.type)) return null;
+  switch (raw.type) {
+    case "ping":
+    case "pong":
+    case "p2p_evicted":
+      return raw;
+    case "status_report":
+    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;
+  }
+}
+var DASHBOARD_P2P_MESSAGE_KINDS = [
+  .../* @__PURE__ */ new Set([...DASHBOARD_TO_DAEMON_P2P_TYPES, ...DAEMON_TO_DASHBOARD_P2P_TYPES])
+];
+
+// 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;
+var isDaemonToServerWsMsg = isDaemonToServerType;
+var isServerToDaemonWsMsg = isServerToDaemonControlType;
+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);
+}
+
+// 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 isMeshThinkingLevel = makeGuard(MESH_THINKING_LEVELS);
+var isMeshDeliveryMode = makeGuard(MESH_DELIVERY_MODES);
+var isMeshSessionCleanupMode = makeGuard(MESH_SESSION_CLEANUP_MODES);
+var isWorkerReportOutcome = makeGuard(WORKER_REPORT_OUTCOMES);
+var isWorkerBranchState = makeGuard(WORKER_BRANCH_STATES);
+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) scope.push(`difficulty ${input.difficulty}`);
+  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 (pass its absolute path 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`."
+  );
+  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"];
+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"
+];
+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) },
+  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" },
+    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 isEvidenceSourceId = makeGuard2(EVIDENCE_SOURCE_IDS);
+var isTurnEvidenceKind = makeGuard2(TURN_EVIDENCE_KINDS);
+var isTurnReason = makeGuard2(TURN_REASONS);
+var isNotifyKind = makeGuard2(NOTIFY_KINDS);
+var isHoldReason = makeGuard2(HOLD_REASONS);
+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;
+}
+function isTerminalClassEvidenceKind(kind) {
+  return TERMINAL_CLASS_EVIDENCE_KINDS.includes(kind);
+}
+var TURN_EVIDENCE_FLAGS = ["hollow", "afterFinalizationTimeout", "nativeMarker", "selfAttributing"];
+var MESH_TOPIC_ENTRY_KINDS = ["turn.evidence", "turn.committed", "turn.notify", "mesh.record"];
+var isMeshTopicEntryKind = makeGuard2(MESH_TOPIC_ENTRY_KINDS);
+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 readString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : 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 = readString2(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 = readString2(record.requested);
+  const launchValue = readString2(record.launchValue);
+  const resolvedDefault = readString2(record.resolvedDefault);
+  const current = readString2(record.current);
+  const observed = readString2(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 = readString2(record.sessionId);
+  const providerType = readString2(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 = readString2(record.providerVersion);
+  const workspace = readString2(record.workspace);
+  const autoApproveModeId = readString2(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.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;
+}
+var TURN_IPC_ERROR_CODES = ["daemon_required", "turn_ledger_unavailable", "ledger_not_owner"];
+function makeGuard3(values) {
+  const set = new Set(values);
+  return (value) => typeof value === "string" && set.has(value);
+}
+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_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;
+}
+var MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
+var isMeshMissionStatusValue = makeGuard3(MESH_MISSION_STATUSES);
+var MESH_MISSION_SOURCES = ["magi", "coordinator"];
+var isMeshMissionSourceValue = makeGuard3(MESH_MISSION_SOURCES);
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+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", "source", "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.source !== void 0 && !isMeshMissionSourceValue(value.source)) 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", "source", "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.source !== void 0 && !isMeshMissionSourceValue(value.source)) 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", "includeMagi", "withStats", "limit", "historyIdLimit"])) 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.includeMagi !== void 0 && typeof value.includeMagi !== "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", "source", "tasks", "stats", "brief"];
+  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 (value.source !== void 0 && !isMeshMissionSourceValue(value.source)) 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;
+  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 isOptionalShortString(value, max = 512) {
+  return value === void 0 || typeof value === "string" && value.trim().length > 0 && value.length <= max;
+}
+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;
+}
+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";
+}
+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"])) 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;
+  return isOptionalId2(value.taskId) && isOptionalBoolean(value.view);
+}
+function decodeQueueQueryRequest(value) {
+  return isQueueQueryRequest(value) ? value : null;
+}
+function isQueueQueryResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["entries"]) && Array.isArray(value.entries) && value.entries.every(isQueueEntryWire);
+}
+function decodeQueueQueryResponse(value) {
+  return isQueueQueryResponse(value) ? value : null;
+}
+function isQueueEnqueueRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "message", "options", "decision"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && typeof value.message === "string" && isOptionalRecord(value.options) && isOptionalRecord(value.decision);
+}
+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 isQueueEnqueueGraphRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "mode", "specs", "plan", "audit"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (value.mode === "compat") return isRecordArray(value.specs) && value.plan === void 0 && isOptionalRecord(value.audit);
+  if (value.mode === "graph") return isRecord(value.plan) && value.specs === void 0 && isOptionalRecord(value.audit);
+  return false;
+}
+function decodeQueueEnqueueGraphRequest(value) {
+  return isQueueEnqueueGraphRequest(value) ? value : null;
+}
+function isQueueEnqueueGraphResponse(value) {
+  if (!isRecord(value)) return false;
+  if (value.ok === true) {
+    return hasOnlyKeys2(value, ["ok", "tasks", "graph"]) && Array.isArray(value.tasks) && value.tasks.every(isQueueEntryWire) && isOptionalRecord(value.graph);
+  }
+  if (value.ok === false) {
+    return hasOnlyKeys2(value, ["ok", "refusalCode", "message", "extra"]) && typeof value.message === "string" && isOptionalString(value.refusalCode) && isOptionalRecord(value.extra);
+  }
+  return false;
+}
+function decodeQueueEnqueueGraphResponse(value) {
+  return isQueueEnqueueGraphResponse(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", "decision"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isEvidenceIdentifier(value.taskId) && typeof value.message === "string" && isOptionalRecord(value.task) && isOptionalRecord(value.decision);
+}
+function decodeDirectDispatchRecordRequest(value) {
+  return isDirectDispatchRecordRequest(value) ? value : null;
+}
+function isDirectDispatchRecordResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["taskRecorded", "decisionRecorded"]) && typeof value.taskRecorded === "boolean" && typeof value.decisionRecorded === "boolean";
+}
+function decodeDirectDispatchRecordResponse(value) {
+  return isDirectDispatchRecordResponse(value) ? value : null;
+}
+var GRAPH_AUDIT_EVENTS = ["gate_claimed", "gate_released", "gate_abandoned", "node_patched"];
+var isGraphAuditEvent = makeGuard3(GRAPH_AUDIT_EVENTS);
+function isGraphAuditRecordRequest(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "event", "fields"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isGraphAuditEvent(value.event) && isRecord(value.fields);
+}
+function decodeGraphAuditRecordRequest(value) {
+  return isGraphAuditRecordRequest(value) ? value : null;
+}
+function isGraphAuditRecordResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["recorded"]) && typeof value.recorded === "boolean";
+}
+function decodeGraphAuditRecordResponse(value) {
+  return isGraphAuditRecordResponse(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;
+  if (value.includeSchedulingRuntime === true && !isRecord(value.mesh)) 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) {
+  return isRecord(value) && hasOnlyKeys2(value, ["v", "meshId", "nodeId", "sessionId", "maxRetries"]) && value.v === TURN_IPC_PROTOCOL_VERSION && isEvidenceIdentifier(value.meshId) && isOptionalId2(value.nodeId) && isOptionalId2(value.sessionId) && (value.maxRetries === void 0 || isNonNegativeInt(value.maxRetries)) && (value.nodeId !== void 0 || value.sessionId !== void 0);
+}
+function decodeRecoveryContextQueryRequest(value) {
+  return isRecoveryContextQueryRequest(value) ? value : null;
+}
+function isRecoveryContextQueryResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["context"]) && isRecord(value.context) && typeof value.context.consecutiveNodeFailures === "number";
+}
+function decodeRecoveryContextQueryResponse(value) {
+  return isRecoveryContextQueryResponse(value) ? value : null;
+}
+function isGraphGateClaimRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "gateId", "coordinatorSessionId", "leaseSeconds", "extendDeadlineSeconds", "probeConvergenceEvidence"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId) || !isEvidenceIdentifier(value.gateId) || !isEvidenceIdentifier(value.coordinatorSessionId)) return false;
+  if (value.leaseSeconds !== void 0 && !isFiniteNumber3(value.leaseSeconds)) return false;
+  if (value.extendDeadlineSeconds !== void 0 && !isFiniteNumber3(value.extendDeadlineSeconds)) return false;
+  return isOptionalBoolean(value.probeConvergenceEvidence);
+}
+function decodeGraphGateClaimRequest(value) {
+  return isGraphGateClaimRequest(value) ? value : null;
+}
+function isGraphGateClaimResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["claimed", "reason", "gate", "leaseGeneration", "fencingToken", "leaseExpiresAt", "deadlineAt", "ambiguousExternalOutcome", "previousLeaseOwnerSessionId", "convergenceEvidence"])) return false;
+  if (typeof value.claimed !== "boolean") return false;
+  return isOptionalRecord(value.gate) && isOptionalRecord(value.convergenceEvidence) && isOptionalBoolean(value.ambiguousExternalOutcome);
+}
+function decodeGraphGateClaimResponse(value) {
+  return isGraphGateClaimResponse(value) ? value : null;
+}
+function isGraphGateReleaseRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "gateId", "fencingToken", "leaseGeneration", "idempotencyKey", "outcome", "result", "evidence", "patches"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId) || !isEvidenceIdentifier(value.gateId)) return false;
+  if (typeof value.fencingToken !== "string" || !value.fencingToken) return false;
+  if (!isFiniteNumber3(value.leaseGeneration)) return false;
+  if (typeof value.idempotencyKey !== "string" || !value.idempotencyKey) return false;
+  if (typeof value.outcome !== "string" || !value.outcome) return false;
+  if (value.patches !== void 0) {
+    if (!Array.isArray(value.patches)) return false;
+    for (const p of value.patches) {
+      if (!isRecord(p) || typeof p.node !== "string" || !p.node || !isRecord(p.baseSpecPatch)) return false;
+    }
+  }
+  return true;
+}
+function decodeGraphGateReleaseRequest(value) {
+  return isGraphGateReleaseRequest(value) ? value : null;
+}
+function isGraphGateReleaseResponse(value) {
+  if (!isRecord(value)) return false;
+  if (value.released === true) {
+    if (!hasOnlyKeys2(value, ["released", "duplicate", "gate", "materializedNodeIds", "downstreamNodeCount", "graphCompleted"])) return false;
+    if (typeof value.duplicate !== "boolean") return false;
+    if (!Array.isArray(value.materializedNodeIds) || !value.materializedNodeIds.every((n) => typeof n === "string")) return false;
+    if (value.downstreamNodeCount !== void 0 && !isNonNegativeInt(value.downstreamNodeCount)) return false;
+    return isOptionalRecord(value.gate) && isOptionalBoolean(value.graphCompleted);
+  }
+  if (value.released === false) {
+    return hasOnlyKeys2(value, ["released", "refusalCode", "message"]) && typeof value.message === "string" && isOptionalString(value.refusalCode);
+  }
+  return false;
+}
+function decodeGraphGateReleaseResponse(value) {
+  return isGraphGateReleaseResponse(value) ? value : null;
+}
+function isGraphGateAbandonRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "gateId", "reason", "coordinatorSessionId", "force"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId) || !isEvidenceIdentifier(value.gateId)) return false;
+  if (typeof value.reason !== "string" || !value.reason) return false;
+  if (value.coordinatorSessionId !== void 0 && !isEvidenceIdentifier(value.coordinatorSessionId)) return false;
+  return isOptionalBoolean(value.force);
+}
+function decodeGraphGateAbandonRequest(value) {
+  return isGraphGateAbandonRequest(value) ? value : null;
+}
+function isGraphGateAbandonResponse(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["abandoned", "reason", "gate", "cancelledNodeIds", "cancelledTaskIds", "graphStatus"])) return false;
+  if (typeof value.abandoned !== "boolean") return false;
+  if (!Array.isArray(value.cancelledNodeIds) || !value.cancelledNodeIds.every((n) => typeof n === "string")) return false;
+  if (!Array.isArray(value.cancelledTaskIds) || !value.cancelledTaskIds.every((n) => typeof n === "string")) return false;
+  return isOptionalRecord(value.gate);
+}
+function decodeGraphGateAbandonResponse(value) {
+  return isGraphGateAbandonResponse(value) ? value : null;
+}
+function isGraphNodePatchRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "node", "graphId", "baseSpecPatch"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (typeof value.node !== "string" || !value.node) return false;
+  if (value.graphId !== void 0 && !isEvidenceIdentifier(value.graphId)) return false;
+  return isRecord(value.baseSpecPatch) && Object.keys(value.baseSpecPatch).length > 0;
+}
+function decodeGraphNodePatchRequest(value) {
+  return isGraphNodePatchRequest(value) ? value : null;
+}
+function isGraphNodePatchResponse(value) {
+  if (!isRecord(value)) return false;
+  if (value.patched === true) {
+    if (!hasOnlyKeys2(value, ["patched", "graphId", "nodeId", "ref", "queueTaskId", "materializationVersion", "state", "outcomeKind", "skippedReason", "blockedReason"])) return false;
+    if (!isEvidenceIdentifier(value.graphId) || !isEvidenceIdentifier(value.nodeId)) return false;
+    if (!isNonNegativeInt(value.materializationVersion)) return false;
+    return typeof value.state === "string" && typeof value.outcomeKind === "string";
+  }
+  if (value.patched === false) {
+    return hasOnlyKeys2(value, ["patched", "refusalCode", "message"]) && typeof value.message === "string" && isOptionalString(value.refusalCode);
+  }
+  return false;
+}
+function decodeGraphNodePatchResponse(value) {
+  return isGraphNodePatchResponse(value) ? value : null;
+}
+function isGraphViewQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "graphId", "batchId", "activeOnly", "limit", "probeGateEvidence"])) return false;
+  if (value.v !== TURN_IPC_PROTOCOL_VERSION || !isEvidenceIdentifier(value.meshId)) return false;
+  if (value.graphId !== void 0 && !isEvidenceIdentifier(value.graphId)) return false;
+  if (value.batchId !== void 0 && !isEvidenceIdentifier(value.batchId)) return false;
+  if (value.limit !== void 0 && !isNonNegativeInt(value.limit)) return false;
+  return isOptionalBoolean(value.activeOnly) && isOptionalBoolean(value.probeGateEvidence);
+}
+function decodeGraphViewQueryRequest(value) {
+  return isGraphViewQueryRequest(value) ? value : null;
+}
+function isGraphViewQueryResponse(value) {
+  return isRecord(value) && hasOnlyKeys2(value, ["graphs"]) && isRecordArray(value.graphs);
+}
+function decodeGraphViewQueryResponse(value) {
+  return isGraphViewQueryResponse(value) ? value : null;
+}
+function isTaskStatsQueryRequest(value) {
+  if (!isRecord(value) || !hasOnlyKeys2(value, ["v", "meshId", "taskIds", "missionId", "tail", "rollup"])) 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.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"]) && isRecordArray(value.tasks) && isOptionalRecord(value.mission);
+}
+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;
+}
+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_graph",
+  "queue_cancel",
+  "queue_requeue",
+  "direct_dispatch_record",
+  "graph_audit_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: graph gates/plan/patch, mission reads (MAGI), task/
+  // mission stats, orphaned-pin helpers, one prune audit):
+  "graph_gate_claim",
+  "graph_gate_release",
+  "graph_gate_abandon",
+  "graph_node_patch",
+  "graph_view_query",
+  "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 };
+}
 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_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,
   DEFAULT_DIFFICULTY_BRAINS,
+  DELIVERY_OUTCOMES,
+  DELIVERY_VIAS,
+  DISPATCH_FAILURE_REASONS,
+  EVIDENCE_ENVELOPE_FIELD_SPECS,
+  EVIDENCE_SOURCE_IDS,
+  GRAPH_AUDIT_EVENTS,
+  HOLD_REASONS,
+  LIVENESS_RESULTS,
   MAGI_RAW_ANSWER_CAP,
+  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_SOURCES,
+  MESH_MISSION_STATUSES,
+  MESH_P2P_SIGNAL_TYPES,
+  MESH_RECORD_PAYLOAD_KEYS,
+  MESH_SESSION_CLEANUP_MODES,
   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,
+  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,
+  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,
   compareSemver,
   daemonIdsEquivalent,
+  decodeActiveWorkQueryRequest,
+  decodeActiveWorkQueryResponse,
+  decodeDaemonToDashboardP2P,
+  decodeDaemonToServer,
+  decodeDashboardToDaemonP2P,
+  decodeDashboardToDaemonP2PChunk,
+  decodeDashboardToUserSession,
+  decodeDirectDispatchRecordRequest,
+  decodeDirectDispatchRecordResponse,
+  decodeGraphAuditRecordRequest,
+  decodeGraphAuditRecordResponse,
+  decodeGraphGateAbandonRequest,
+  decodeGraphGateAbandonResponse,
+  decodeGraphGateClaimRequest,
+  decodeGraphGateClaimResponse,
+  decodeGraphGateReleaseRequest,
+  decodeGraphGateReleaseResponse,
+  decodeGraphNodePatchRequest,
+  decodeGraphNodePatchResponse,
+  decodeGraphViewQueryRequest,
+  decodeGraphViewQueryResponse,
+  decodeLedgerQueryRequest,
+  decodeLedgerQueryResponse,
+  decodeMeshIndexQueryRequest,
+  decodeMeshIndexQueryResponse,
+  decodeMeshRecordRequest,
+  decodeMeshRecordResponse,
+  decodeMissionListQueryRequest,
+  decodeMissionListQueryResponse,
+  decodeMissionQueryRequest,
+  decodeMissionQueryResponse,
+  decodeMissionUpsertRequest,
+  decodeMissionUpsertResponse,
+  decodeNoteForgetRequest,
+  decodeNoteForgetResponse,
+  decodeNoteUpsertRequest,
+  decodeNoteUpsertResponse,
+  decodeOperatorStatusRequest,
+  decodeOperatorStatusResponse,
+  decodeOrphanedPinNotifyRequest,
+  decodeOrphanedPinNotifyResponse,
+  decodePruneStaleDirectRequest,
+  decodePruneStaleDirectResponse,
+  decodeQueueCancelRequest,
+  decodeQueueCancelResponse,
+  decodeQueueEnqueueGraphRequest,
+  decodeQueueEnqueueGraphResponse,
+  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,
+  effectiveModelSelectionValue,
+  enumOf,
   expandDaemonIdForms,
+  findOwnershipConflicts,
   formatQuotaAccount,
   hasGitStatusEvidence,
+  hasWorkerProtocolFooter,
   interpolateArgs,
   interpolateString,
+  isActiveWorkQueryRequest,
+  isActiveWorkQueryResponse,
+  isBlockedStatus,
+  isBusyStatus,
+  isChunkType,
+  isCommitStrength,
+  isDaemonDirectCommandType,
+  isDaemonP2PSignalType,
+  isDaemonStatusEventName,
+  isDaemonToDashboardP2PType,
+  isDaemonToServerType,
   isDaemonToServerWsMsg,
+  isDashboardP2PSignalType,
+  isDashboardStatusEventName,
+  isDashboardToDaemonChunkType,
+  isDashboardToDaemonP2PType,
+  isDashboardToUserSessionType,
+  isDeadStatus,
+  isDirectDispatchRecordRequest,
+  isDirectDispatchRecordResponse,
   isDowngrade,
+  isEvidenceIdentifier,
+  isEvidenceSourceId,
+  isFiniteNumber,
+  isGraphAuditEvent,
+  isGraphAuditRecordRequest,
+  isGraphAuditRecordResponse,
+  isGraphGateAbandonRequest,
+  isGraphGateAbandonResponse,
+  isGraphGateClaimRequest,
+  isGraphGateClaimResponse,
+  isGraphGateReleaseRequest,
+  isGraphGateReleaseResponse,
+  isGraphNodePatchRequest,
+  isGraphNodePatchResponse,
+  isGraphViewQueryRequest,
+  isGraphViewQueryResponse,
+  isHoldReason,
+  isInputEnvelopeWire,
+  isLedgerQueryRequest,
+  isLedgerQueryResponse,
+  isMeshDeliveryMode,
+  isMeshIndexQueryRequest,
+  isMeshIndexQueryResponse,
+  isMeshIndexQueryWriterScope,
+  isMeshMissionSourceValue,
+  isMeshMissionStatusValue,
+  isMeshP2PSignalType,
+  isMeshRecordPayload,
+  isMeshRecordRequest,
+  isMeshRecordResponse,
+  isMeshSessionCleanupMode,
   isMeshTaskDifficulty,
+  isMeshTaskMode,
+  isMeshTaskPriority,
+  isMeshTaskStatus,
+  isMeshTerminalTaskStatus,
+  isMeshThinkingLevel,
+  isMeshTopicEntry,
+  isMeshTopicEntryKind,
+  isMessageId,
+  isMissionListQueryRequest,
+  isMissionListQueryResponse,
+  isMissionQueryRequest,
+  isMissionQueryResponse,
+  isMissionUpsertRequest,
+  isMissionUpsertResponse,
+  isModelAxisSource,
+  isNonEmptyString,
+  isNoteForgetRequest,
+  isNoteForgetResponse,
+  isNoteUpsertRequest,
+  isNoteUpsertResponse,
+  isNotifyKind,
+  isOperatingNoteCategory,
+  isOperatorStatusReasonValue,
+  isOperatorStatusRequest,
+  isOperatorStatusResponse,
+  isOperatorStatusValue,
+  isOrphanedPinNotifyRequest,
+  isOrphanedPinNotifyResponse,
+  isOutboundMessage,
+  isOutboundMessageOrigin,
+  isP2PSignalType,
   isPhantomDaemonEntry,
+  isPruneStaleDirectRequest,
+  isPruneStaleDirectResponse,
+  isQueueCancelRequest,
+  isQueueCancelResponse,
+  isQueueEnqueueGraphRequest,
+  isQueueEnqueueGraphResponse,
+  isQueueEnqueueRequest,
+  isQueueEnqueueResponse,
+  isQueueQueryRequest,
+  isQueueQueryResponse,
+  isQueueRequeueRequest,
+  isQueueRequeueResponse,
   isRawDaemonDoId,
+  isReadyStatus,
+  isRecord,
+  isRecordLocalRequest,
+  isRecordLocalResponse,
+  isRecoveryContextQueryRequest,
+  isRecoveryContextQueryResponse,
+  isSendPolicy,
+  isSendPolicyMode,
+  isSendRefusal,
+  isServerDirectCommandMsg,
+  isServerToDaemonControlType,
   isServerToDaemonWsMsg,
+  isSessionLaunchedBy,
+  isSessionStatus,
+  isSharedSessionToViewerType,
+  isSubmitOutcome,
+  isSummaryRef,
+  isTaskStatsQueryRequest,
+  isTaskStatsQueryResponse,
+  isTerminalClassEvidenceKind,
+  isToolCallRecordRequest,
+  isToolCallRecordResponse,
+  isToolCallerRole,
+  isTurnAttemptRef,
+  isTurnCancelRequest,
+  isTurnCancelResponse,
+  isTurnEvidence,
+  isTurnEvidenceKind,
+  isTurnIpcCommand,
+  isTurnIpcError,
+  isTurnIpcErrorCode,
+  isTurnObserveRequest,
+  isTurnObserveResponse,
+  isTurnObserveVerdict,
+  isTurnOutcome,
+  isTurnQueryRequest,
+  isTurnQueryResponse,
+  isTurnReason,
+  isUserSessionToDashboardType,
+  isViewerToSharedSessionType,
+  isWorkerBranchState,
+  isWorkerReportOutcome,
+  isWorkerTool,
+  isWorkingStatus,
   joinRepoPath,
+  launchModelSelectionValue,
   machineCoreFromDaemonId,
+  makeTypeGuard,
   measureWorstCaseChunkEnvelopeBytes,
   meshFrameNeedsChunking,
   meshNodeIdMatches,
   meshUtf8ByteLength,
   meshWorkspacesEquivalent,
+  mintMessageId,
+  normalizeAuthOkLimits,
   normalizeBrainSlot,
   normalizeDifficultyBrainMap,
   normalizeGitStatus,
@@ -1046,25 +3456,39 @@ export {
   normalizeMeshNodeId,
   normalizeMeshSessionRecord,
   normalizeMeshWorkspaceForCompare,
+  normalizeMissionBrief,
   normalizeNodeCapabilitySlot,
   normalizeNodeCapabilitySlots,
+  normalizeOwnedPaths,
+  normalizeSessionStatus,
   normalizeThinkingLevel,
   parseJsonRecord,
   parseSemver,
+  parseSessionLaunchRecord,
+  pathsOverlap,
   pickBestTransitGitStatus,
+  projectTurnEvidenceEntry,
   readBoolean,
+  readEnvelopeFields,
   readGitSubmodules,
   readNumber,
   readRecord,
   readString,
   readStringArray,
+  renderCoordinatorWorkerSection,
+  renderMissionBriefBlock,
+  renderWorkerProtocolFooter,
+  sanitizeModelIdentifier,
   scoreGitStatusCandidate,
   scoreGitUpstreamFreshness,
   sessionIdsEquivalent,
   splitMeshFrame,
+  statusesOfClass,
   stripStatusProbeMarker,
+  stripWorkerProtocolFooter,
   summarizeGitShape,
   supportsQuota,
+  touchedFilesOutsideOwnership,
   withStatusProbeMarker
 };
 //# sourceMappingURL=index.mjs.map