@fml-inc/fml 0.7.0 → 0.8.0-rc.1

package/dist/chunk-DEMVOVVY.js

@@ -0,0 +1,4442 @@
+import {
+  FML_HOOK_INBOX_DIR
+} from "./chunk-7DR5X7XI.js";
+
+// ../../packages/panopticon/src/observer/auth.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+function readObserverAuthToken(tokenFile) {
+  try {
+    const token = fs.readFileSync(tokenFile, "utf8").trim();
+    return token.length > 0 ? token : null;
+  } catch {
+    return null;
+  }
+}
+function getOrCreateObserverAuthToken(tokenFile) {
+  const existing = readObserverAuthToken(tokenFile);
+  if (existing) return existing;
+  fs.mkdirSync(path.dirname(tokenFile), { recursive: true, mode: 448 });
+  const token = crypto.randomBytes(32).toString("hex");
+  try {
+    fs.writeFileSync(tokenFile, `${token}
+`, { flag: "wx", mode: 384 });
+    return token;
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      const raced = readObserverAuthToken(tokenFile);
+      if (raced) return raced;
+      try {
+        if (fs.readFileSync(tokenFile, "utf8").trim().length === 0) {
+          fs.rmSync(tokenFile);
+          return getOrCreateObserverAuthToken(tokenFile);
+        }
+      } catch (repairError) {
+        if (repairError.code === "ENOENT") {
+          return getOrCreateObserverAuthToken(tokenFile);
+        }
+      }
+    }
+    throw error;
+  }
+}
+function isObserverAuthToken(presented, expected) {
+  const leftBytes = Buffer.from(presented, "utf8");
+  const rightBytes = Buffer.from(expected, "utf8");
+  return leftBytes.length === rightBytes.length && crypto.timingSafeEqual(leftBytes, rightBytes);
+}
+function hasObserverBearerToken(req, expected) {
+  const authorization = req.headers.authorization;
+  if (typeof authorization !== "string" || !authorization.startsWith("Bearer ")) {
+    return false;
+  }
+  return isObserverAuthToken(
+    authorization.slice("Bearer ".length).trim(),
+    expected
+  );
+}
+function requireObserverBearerToken(req, res, expected) {
+  if (hasObserverBearerToken(req, expected)) return true;
+  res.writeHead(401, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "unauthorized" }));
+  return false;
+}
+
+// ../../packages/agent-targets/src/hooks/normalize.ts
+import { createHash } from "crypto";
+
+// ../../packages/agent-targets/src/hooks/types.ts
+var HOOK_TARGETS = Object.freeze([
+  "claude",
+  "codex",
+  "gemini",
+  "grok"
+]);
+function isHookTarget(value) {
+  return typeof value === "string" && HOOK_TARGETS.some((targetId) => targetId === value);
+}
+
+// ../../packages/agent-targets/src/catalog/hook-events.json
+var hook_events_default = {
+  claude: [
+    "SessionStart",
+    "Setup",
+    "InstructionsLoaded",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "PermissionDenied",
+    "Notification",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCreated",
+    "TaskCompleted",
+    "Stop",
+    "StopFailure",
+    "TeammateIdle",
+    "ConfigChange",
+    "CwdChanged",
+    "PreCompact",
+    "PostCompact",
+    "SessionEnd",
+    "Elicitation",
+    "ElicitationResult"
+  ],
+  codex: [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "Stop"
+  ],
+  gemini: [
+    "SessionStart",
+    "BeforeAgent",
+    "BeforeTool",
+    "AfterTool",
+    "AfterAgent"
+  ],
+  grok: [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionDenied",
+    "Stop",
+    "StopFailure",
+    "Notification",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact",
+    "SessionEnd"
+  ]
+};
+
+// ../../packages/agent-targets/src/catalog/hook-events.ts
+var CLAUDE_HOOK_EVENTS = Object.freeze([
+  ...hook_events_default.claude
+]);
+var CODEX_HOOK_EVENTS = Object.freeze([
+  ...hook_events_default.codex
+]);
+var GEMINI_HOOK_EVENTS = Object.freeze([
+  ...hook_events_default.gemini
+]);
+var GROK_HOOK_EVENTS = Object.freeze([
+  ...hook_events_default.grok
+]);
+
+// ../../packages/agent-targets/src/hooks/normalize.ts
+var MAX_EXTRACTED_TEXT_BYTES = 64 * 1024;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function firstString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function extractedText(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return void 0;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+function firstText(record, keys) {
+  for (const key of keys) {
+    const value = extractedText(record[key]);
+    if (value !== void 0 && value.length > 0) return value;
+  }
+  return void 0;
+}
+function utf8Prefix(value, maxBytes) {
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= maxBytes) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  let end = low;
+  if (end > 0 && end < value.length && value.charCodeAt(end - 1) >= 55296 && value.charCodeAt(end - 1) <= 56319 && value.charCodeAt(end) >= 56320 && value.charCodeAt(end) <= 57343) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+function boundedExtractedText(value, field) {
+  if (value === void 0) return void 0;
+  const originalBytes = Buffer.byteLength(value, "utf8");
+  if (originalBytes <= MAX_EXTRACTED_TEXT_BYTES) return value;
+  const digest = createHash("sha256").update(value).digest("hex");
+  const marker = `
+[fml:${field}:truncated originalBytes=${originalBytes} sha256=${digest}]`;
+  return `${utf8Prefix(
+    value,
+    MAX_EXTRACTED_TEXT_BYTES - Buffer.byteLength(marker, "utf8")
+  )}${marker}`;
+}
+function nestedRecord(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (isRecord(value)) return value;
+  }
+  return void 0;
+}
+function timestampMs(payload, fallback) {
+  for (const key of ["timestamp_ms", "timestampMs", "timestamp"]) {
+    const value = payload[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+      const milliseconds = Math.round(
+        value < 1e10 ? value * 1e3 : value
+      );
+      if (Number.isSafeInteger(milliseconds) && milliseconds > 0) {
+        return milliseconds;
+      }
+    }
+    if (typeof value === "string") {
+      const parsed = Date.parse(value);
+      if (Number.isSafeInteger(parsed) && parsed >= 0) return parsed;
+    }
+  }
+  return fallback;
+}
+function geminiEventType(eventType) {
+  switch (eventType) {
+    case "BeforeAgent":
+    case "BeforeModel":
+      return "UserPromptSubmit";
+    case "BeforeTool":
+      return "PreToolUse";
+    case "AfterTool":
+      return "PostToolUse";
+    case "AfterAgent":
+      return "Stop";
+    default:
+      return eventType;
+  }
+}
+var GROK_EVENT_TYPES = Object.freeze({
+  session_start: "SessionStart",
+  user_prompt_submit: "UserPromptSubmit",
+  pre_tool_use: "PreToolUse",
+  post_tool_use: "PostToolUse",
+  post_tool_use_failure: "PostToolUseFailure",
+  permission_denied: "PermissionDenied",
+  stop: "Stop",
+  stop_failure: "StopFailure",
+  notification: "Notification",
+  subagent_start: "SubagentStart",
+  subagent_stop: "SubagentStop",
+  pre_compact: "PreCompact",
+  post_compact: "PostCompact",
+  session_end: "SessionEnd"
+});
+function grokEventType(eventType) {
+  return Object.hasOwn(GROK_EVENT_TYPES, eventType) ? GROK_EVENT_TYPES[eventType] ?? eventType : eventType;
+}
+function geminiUserPrompt(payload) {
+  const request = payload.llm_request;
+  if (!isRecord(request) || !Array.isArray(request.messages)) return void 0;
+  const userMessage = [...request.messages].reverse().find(
+    (message) => isRecord(message) && message.role === "user"
+  );
+  if (!userMessage) return void 0;
+  if (typeof userMessage.content === "string") {
+    return userMessage.content || void 0;
+  }
+  if (!Array.isArray(userMessage.content)) return void 0;
+  const text = userMessage.content.filter(
+    (part) => isRecord(part) && part.type === "text" && typeof part.text === "string"
+  ).map((part) => part.text).join("\n");
+  return text || void 0;
+}
+function normalizedEvent(target, payload, context) {
+  const sessionId = firstString(payload, [
+    "session_id",
+    "sessionId",
+    "conversation_id",
+    "conversationId"
+  ]);
+  const rawEventType = firstString(payload, [
+    "hook_event_name",
+    "hookEventName",
+    "event_name",
+    "eventName",
+    "event"
+  ]);
+  if (!sessionId || !rawEventType) return null;
+  const eventType = target === "gemini" ? geminiEventType(rawEventType) : target === "grok" ? grokEventType(rawEventType) : rawEventType;
+  const toolInput = nestedRecord(payload, ["tool_input", "toolInput"]);
+  const cwd = firstString(payload, [
+    "cwd",
+    "working_directory",
+    "workingDirectory",
+    "workspaceRoot"
+  ]) ?? context.cwd;
+  const filePath = firstString(payload, ["file_path", "filePath", "path"]) ?? (toolInput ? firstString(toolInput, ["file_path", "filePath", "path"]) : void 0);
+  const command = boundedExtractedText(
+    firstText(payload, ["command"]) ?? (toolInput ? firstText(toolInput, ["command", "cmd"]) : void 0),
+    "command"
+  );
+  const toolName = firstString(payload, ["tool_name", "toolName", "name"]);
+  const userPrompt = boundedExtractedText(
+    firstText(payload, ["prompt", "user_prompt", "userPrompt"]) ?? (target === "gemini" ? geminiUserPrompt(payload) : void 0),
+    "user_prompt"
+  );
+  const plan = boundedExtractedText(firstText(payload, ["plan"]), "plan");
+  const allowedPrompts = boundedExtractedText(
+    firstText(payload, ["allowed_prompts", "allowedPrompts"]),
+    "allowed_prompts"
+  );
+  const toolResult = boundedExtractedText(
+    firstText(payload, [
+      "tool_result",
+      "toolResult",
+      "tool_response",
+      "toolResponse"
+    ]),
+    "tool_result"
+  );
+  const nativeEventId = firstString(payload, [
+    "hook_id",
+    "hookId",
+    "event_id",
+    "eventId",
+    "tool_use_id",
+    "toolUseId",
+    "tool_call_id",
+    "toolCallId",
+    "prompt_id",
+    "promptId"
+  ]) ?? (eventType === "UserPromptSubmit" || eventType === "Stop" ? firstString(payload, ["turn_id", "turnId"]) : void 0);
+  return {
+    sessionId,
+    eventType,
+    timestampMs: timestampMs(payload, context.nowMs),
+    ...nativeEventId ? { nativeEventId } : {},
+    ...cwd ? { cwd } : {},
+    ...toolName ? { toolName } : {},
+    ...userPrompt ? { userPrompt } : {},
+    ...filePath ? { filePath } : {},
+    ...command ? { command } : {},
+    ...plan ? { plan } : {},
+    ...allowedPrompts ? { allowedPrompts } : {},
+    ...toolResult ? { toolResult } : {}
+  };
+}
+function capability(targetId, nativeEvents) {
+  return Object.freeze({
+    targetId,
+    nativeEvents,
+    normalize: (payload, context) => normalizedEvent(targetId, payload, context)
+  });
+}
+var HOOK_NORMALIZATION_CAPABILITIES = Object.freeze([
+  capability("claude", CLAUDE_HOOK_EVENTS),
+  capability("codex", CODEX_HOOK_EVENTS),
+  capability("gemini", GEMINI_HOOK_EVENTS),
+  capability("grok", GROK_HOOK_EVENTS)
+]);
+function parseHookCaptureRequest(value) {
+  if (!isRecord(value) || !isHookTarget(value.target)) return null;
+  if (!isRecord(value.payload)) return null;
+  return {
+    target: value.target,
+    payload: value.payload,
+    ...typeof value.cwd === "string" && value.cwd.length > 0 ? { cwd: value.cwd } : {}
+  };
+}
+function normalizeTargetHookCapture(request, context) {
+  const capability2 = HOOK_NORMALIZATION_CAPABILITIES.find(
+    (candidate) => candidate.targetId === request.target
+  );
+  return capability2?.normalize(request.payload, {
+    ...context,
+    cwd: context.cwd ?? request.cwd
+  }) ?? null;
+}
+
+// ../../packages/panopticon/src/observer/capture.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+function hookSyncId(request, sessionId, eventType, nativeEventId) {
+  const identity = nativeEventId ?? `delivery:${randomUUID()}`;
+  const digest = createHash2("sha256").update(`${request.target}\0${sessionId}\0${eventType}\0${identity}`).digest("hex");
+  return `hook|${request.target}|${digest}`;
+}
+function normalizeObserverHookCapture(request, options = {}) {
+  const now = (options.nowMs ?? Date.now)();
+  const normalized = normalizeTargetHookCapture(request, {
+    nowMs: now,
+    cwd: request.cwd
+  });
+  if (!normalized) return null;
+  return {
+    syncId: options.syncId?.() ?? hookSyncId(
+      request,
+      normalized.sessionId,
+      normalized.eventType,
+      normalized.nativeEventId
+    ),
+    sessionId: normalized.sessionId,
+    eventType: normalized.eventType,
+    timestampMs: normalized.timestampMs,
+    target: request.target,
+    payload: request.payload,
+    ...normalized.cwd ? { cwd: normalized.cwd } : {},
+    ...options.repository ? { repository: options.repository } : {},
+    ...normalized.toolName ? { toolName: normalized.toolName } : {},
+    ...normalized.userPrompt ? { userPrompt: normalized.userPrompt } : {},
+    ...normalized.filePath ? { filePath: normalized.filePath } : {},
+    ...normalized.command ? { command: normalized.command } : {},
+    ...normalized.plan ? { plan: normalized.plan } : {},
+    ...normalized.allowedPrompts ? { allowedPrompts: normalized.allowedPrompts } : {},
+    ...normalized.toolResult ? { toolResult: normalized.toolResult } : {},
+    capturedAtMs: now
+  };
+}
+
+// ../../packages/panopticon/src/observer/database.ts
+import crypto2 from "crypto";
+import fs2 from "fs";
+import path2 from "path";
+var ObserverHookSpoolEntryTooLargeError = class extends Error {
+  constructor(logicalBytes, maxBytes) {
+    super(
+      `Hook event requires ${logicalBytes} logical bytes, exceeding the configured ${maxBytes}-byte spool maximum`
+    );
+    this.logicalBytes = logicalBytes;
+    this.maxBytes = maxBytes;
+    this.name = "ObserverHookSpoolEntryTooLargeError";
+  }
+};
+var SCHEMA_VERSION = 10;
+var MAX_SYNC_RUN_RECORDS = 1e4;
+var DEFAULT_HOOK_OUTBOX_BATCH_SIZE = 100;
+var MAX_HOOK_OUTBOX_BATCH_SIZE = 100;
+var MAX_HOOK_PAYLOAD_BYTES = 16 * 1024 * 1024;
+var MAX_HOOK_EXTRACTED_FIELD_BYTES = 16 * 1024 * 1024;
+var MAX_HOOK_SYNC_ID_BYTES = 1024;
+var MAX_HOOK_SESSION_ID_BYTES = 4096;
+var MAX_HOOK_EVENT_TYPE_BYTES = 1024;
+var MAX_HOOK_TARGET_BYTES = 256;
+var MAX_HOOK_REJECTION_REASON_BYTES = 4 * 1024;
+var MAX_HOOK_DESTINATION_URL_BYTES = 4 * 1024;
+var MAX_HOOK_DESTINATION_IDENTITY_BYTES = 4 * 1024;
+var DEFAULT_OTLP_OUTBOX_BATCH_SIZE = 100;
+var MAX_OTLP_OUTBOX_BATCH_SIZE = 100;
+var MAX_OTLP_ENVELOPE_BYTES = 16 * 1024 * 1024;
+var DEFAULT_OTLP_SPOOL_MAX_BYTES = 1024 * 1024 * 1024;
+var MAX_OTLP_ENVELOPE_ID_BYTES = 1024;
+var MAX_OTLP_OBSERVER_INSTANCE_ID_BYTES = 4 * 1024;
+var MAX_OTLP_OBSERVER_VERSION_BYTES = 4 * 1024;
+var MAX_OTLP_DROP_REASON_BYTES = 4 * 1024;
+var MAX_OTLP_DESTINATION_ORGANIZATION_ID_BYTES = 128;
+var MAX_OTLP_DESTINATION_ORGANIZATION_SLUG_BYTES = 4 * 1024;
+var OWNERLESS_OTLP_DROP_REASON = "ownerless";
+var OTLP_CAPACITY_DROP_REASON = "spool_capacity";
+var OTLP_ENTRY_TOO_LARGE_DROP_REASON = "spool_entry_too_large";
+var OTLP_ROW_FIXED_LOGICAL_BYTES = 256;
+var MAX_TIMESTAMP_MS = 864e13;
+var QUARANTINE_PRUNE_INTERVAL_MS = 5 * 60 * 1e3;
+var HOOK_OUTBOX_LOGICAL_BYTES_SQL = `
+  length(CAST(sync_id AS BLOB)) +
+  length(CAST(session_id AS BLOB)) +
+  length(CAST(event_type AS BLOB)) +
+  length(CAST(target AS BLOB)) +
+  length(CAST(payload_json AS BLOB)) +
+  length(CAST(COALESCE(cwd, '') AS BLOB)) +
+  length(CAST(COALESCE(repository, '') AS BLOB)) +
+  length(CAST(COALESCE(tool_name, '') AS BLOB)) +
+  length(CAST(COALESCE(user_prompt, '') AS BLOB)) +
+  length(CAST(COALESCE(file_path, '') AS BLOB)) +
+  length(CAST(COALESCE(command, '') AS BLOB)) +
+  length(CAST(COALESCE(plan, '') AS BLOB)) +
+  length(CAST(COALESCE(allowed_prompts, '') AS BLOB)) +
+  length(CAST(COALESCE(tool_result, '') AS BLOB)) +
+  length(CAST(COALESCE(destination_url, '') AS BLOB)) +
+  length(CAST(COALESCE(destination_identity, '') AS BLOB))
+`;
+var OTLP_LOGICAL_BYTES_SQL = `
+  ${OTLP_ROW_FIXED_LOGICAL_BYTES} +
+  length(CAST(envelope_id AS BLOB)) +
+  length(CAST(observer_instance_id AS BLOB)) +
+  length(CAST(observer_version AS BLOB)) +
+  length(CAST(signal AS BLOB)) +
+  length(CAST(content_type AS BLOB)) +
+  length(CAST(content_encoding AS BLOB)) +
+  length(body) +
+  length(CAST(sha256 AS BLOB)) +
+  length(CAST(COALESCE(destination_url, '') AS BLOB)) +
+  length(CAST(COALESCE(destination_identity, '') AS BLOB)) +
+  CASE
+    WHEN destination_url IS NOT NULL AND destination_organization_id IS NULL
+      THEN ${MAX_OTLP_DESTINATION_ORGANIZATION_ID_BYTES}
+    ELSE length(CAST(COALESCE(destination_organization_id, '') AS BLOB))
+  END +
+  CASE
+    WHEN destination_url IS NOT NULL AND destination_organization_slug IS NULL
+      THEN ${MAX_OTLP_DESTINATION_ORGANIZATION_SLUG_BYTES}
+    ELSE length(CAST(COALESCE(destination_organization_slug, '') AS BLOB))
+  END
+`;
+var RECONCILE_HOOK_SPOOL_STATE_SQL = `
+  INSERT INTO hook_spool_state (
+    singleton,
+    logical_bytes,
+    evicted_records,
+    evicted_bytes,
+    evicted_pending_records,
+    evicted_quarantined_records,
+    last_evicted_at_ms
+  )
+  SELECT
+    1,
+    (SELECT COALESCE(SUM(logical_bytes), 0) FROM hook_event_outbox) +
+      (SELECT COALESCE(SUM(logical_bytes), 0) FROM hook_event_quarantine),
+    0,
+    0,
+    0,
+    0,
+    NULL
+  ON CONFLICT(singleton) DO UPDATE SET
+    logical_bytes = excluded.logical_bytes,
+    evicted_records = CASE
+      WHEN typeof(hook_spool_state.evicted_records) = 'integer'
+        AND hook_spool_state.evicted_records >= 0
+        AND hook_spool_state.evicted_records <= 9007199254740991
+      THEN hook_spool_state.evicted_records ELSE 0 END,
+    evicted_bytes = CASE
+      WHEN typeof(hook_spool_state.evicted_bytes) = 'integer'
+        AND hook_spool_state.evicted_bytes >= 0
+        AND hook_spool_state.evicted_bytes <= 9007199254740991
+      THEN hook_spool_state.evicted_bytes ELSE 0 END,
+    evicted_pending_records = CASE
+      WHEN typeof(hook_spool_state.evicted_pending_records) = 'integer'
+        AND hook_spool_state.evicted_pending_records >= 0
+        AND hook_spool_state.evicted_pending_records <= 9007199254740991
+      THEN hook_spool_state.evicted_pending_records ELSE 0 END,
+    evicted_quarantined_records = CASE
+      WHEN typeof(hook_spool_state.evicted_quarantined_records) = 'integer'
+        AND hook_spool_state.evicted_quarantined_records >= 0
+        AND hook_spool_state.evicted_quarantined_records <= 9007199254740991
+      THEN hook_spool_state.evicted_quarantined_records ELSE 0 END,
+    last_evicted_at_ms = CASE
+      WHEN hook_spool_state.last_evicted_at_ms IS NULL THEN NULL
+      WHEN typeof(hook_spool_state.last_evicted_at_ms) = 'integer'
+        AND hook_spool_state.last_evicted_at_ms >= 0
+        AND hook_spool_state.last_evicted_at_ms <= 8640000000000000
+      THEN hook_spool_state.last_evicted_at_ms ELSE NULL END
+`;
+var ObserverHookSpoolStateInvariantError = class extends Error {
+};
+function jsonStringify(value, description) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value);
+  } catch (error) {
+    throw new Error(`${description} must be JSON-serializable`, {
+      cause: error
+    });
+  }
+  if (serialized === void 0) {
+    throw new Error(`${description} must be JSON-serializable`);
+  }
+  return serialized;
+}
+function requireBoundedString(value, description, maxBytes) {
+  if (value.length === 0) {
+    throw new Error(`${description} must not be empty`);
+  }
+  if (Buffer.byteLength(value, "utf8") > maxBytes) {
+    throw new Error(`${description} exceeds ${maxBytes} bytes`);
+  }
+}
+function validateOptionalHookField(value, description) {
+  if (value !== void 0 && Buffer.byteLength(value, "utf8") > MAX_HOOK_EXTRACTED_FIELD_BYTES) {
+    throw new Error(
+      `${description} exceeds ${MAX_HOOK_EXTRACTED_FIELD_BYTES} bytes`
+    );
+  }
+}
+function requireTimestamp(value, description) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${description} must be a non-negative safe integer`);
+  }
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function validateHookDestination(destination) {
+  requireBoundedString(
+    destination.targetUrl,
+    "Hook destination URL",
+    MAX_HOOK_DESTINATION_URL_BYTES
+  );
+  requireBoundedString(
+    destination.destinationIdentity,
+    "Hook destination identity",
+    MAX_HOOK_DESTINATION_IDENTITY_BYTES
+  );
+}
+function validateOtlpDestination(destination) {
+  validateHookDestination(destination);
+  if (destination.organizationId === void 0 !== (destination.organizationSlug === void 0)) {
+    throw new Error(
+      "OTLP destination organization ID and slug must be provided together"
+    );
+  }
+  if (destination.organizationId !== void 0) {
+    requireBoundedString(
+      destination.organizationId,
+      "OTLP destination organization ID",
+      MAX_OTLP_DESTINATION_ORGANIZATION_ID_BYTES
+    );
+  }
+  if (destination.organizationSlug !== void 0) {
+    requireBoundedString(
+      destination.organizationSlug,
+      "OTLP destination organization slug",
+      MAX_OTLP_DESTINATION_ORGANIZATION_SLUG_BYTES
+    );
+  }
+}
+function hookDestinationFromRow(row) {
+  const targetUrl = optionalString(row.destination_url);
+  const destinationIdentity = optionalString(row.destination_identity);
+  if (targetUrl === void 0 && destinationIdentity === void 0) {
+    return void 0;
+  }
+  if (targetUrl === void 0 || destinationIdentity === void 0) {
+    throw new Error(
+      "FML observer hook outbox has a partial destination binding"
+    );
+  }
+  return {
+    targetUrl,
+    destinationIdentity
+  };
+}
+function otlpDestinationFromRow(row) {
+  const destination = hookDestinationFromRow(row);
+  if (destination === void 0) return void 0;
+  const organizationId = optionalString(row.destination_organization_id);
+  const organizationSlug = optionalString(row.destination_organization_slug);
+  if (organizationId === void 0 !== (organizationSlug === void 0)) {
+    throw new Error(
+      "FML observer OTLP outbox has a partial organization binding"
+    );
+  }
+  return {
+    ...destination,
+    ...organizationId === void 0 ? {} : { organizationId },
+    ...organizationSlug === void 0 ? {} : { organizationSlug }
+  };
+}
+function hookOutboxRecordFromRow(row) {
+  const destination = hookDestinationFromRow(row);
+  return {
+    id: row.id,
+    syncId: row.sync_id,
+    sessionId: row.session_id,
+    eventType: row.event_type,
+    timestampMs: row.timestamp_ms,
+    target: row.target,
+    payload: JSON.parse(row.payload_json),
+    cwd: optionalString(row.cwd),
+    repository: optionalString(row.repository),
+    toolName: optionalString(row.tool_name),
+    userPrompt: optionalString(row.user_prompt),
+    filePath: optionalString(row.file_path),
+    command: optionalString(row.command),
+    plan: optionalString(row.plan),
+    allowedPrompts: optionalString(row.allowed_prompts),
+    toolResult: optionalString(row.tool_result),
+    capturedAtMs: row.captured_at_ms,
+    retryCount: row.retry_count,
+    nextAttemptAtMs: row.next_attempt_at_ms,
+    ...destination === void 0 ? {} : { destination }
+  };
+}
+function utf8Bytes(value) {
+  return value === void 0 ? 0 : Buffer.byteLength(value, "utf8");
+}
+function hookOutboxLogicalBytes(envelope, payloadJson) {
+  return utf8Bytes(envelope.syncId) + utf8Bytes(envelope.sessionId) + utf8Bytes(envelope.eventType) + utf8Bytes(envelope.target) + utf8Bytes(payloadJson) + utf8Bytes(envelope.cwd) + utf8Bytes(envelope.repository) + utf8Bytes(envelope.toolName) + utf8Bytes(envelope.userPrompt) + utf8Bytes(envelope.filePath) + utf8Bytes(envelope.command) + utf8Bytes(envelope.plan) + utf8Bytes(envelope.allowedPrompts) + utf8Bytes(envelope.toolResult) + utf8Bytes(envelope.destination?.targetUrl) + utf8Bytes(envelope.destination?.destinationIdentity);
+}
+function otlpEnvelopeLogicalBytes(envelope, envelopeId) {
+  return OTLP_ROW_FIXED_LOGICAL_BYTES + envelope.body.byteLength + utf8Bytes(envelopeId) + utf8Bytes(envelope.observerInstanceId) + utf8Bytes(envelope.observerVersion) + utf8Bytes(envelope.signal) + utf8Bytes(envelope.contentType) + utf8Bytes(envelope.contentEncoding) + // The persisted digest is always lowercase hexadecimal SHA-256.
+  64 + utf8Bytes(envelope.destination?.targetUrl) + utf8Bytes(envelope.destination?.destinationIdentity) + (envelope.destination && envelope.destination.organizationId === void 0 ? MAX_OTLP_DESTINATION_ORGANIZATION_ID_BYTES : utf8Bytes(envelope.destination?.organizationId)) + (envelope.destination && envelope.destination.organizationSlug === void 0 ? MAX_OTLP_DESTINATION_ORGANIZATION_SLUG_BYTES : utf8Bytes(envelope.destination?.organizationSlug));
+}
+function requireOtlpSignal(value) {
+  if (value === "logs" || value === "metrics" || value === "traces") {
+    return value;
+  }
+  throw new Error("OTLP envelope signal must be logs, metrics, or traces");
+}
+function requireOtlpContentType(value) {
+  if (value === "application/json" || value === "application/x-protobuf") {
+    return value;
+  }
+  throw new Error(
+    "OTLP envelope content type must be application/json or application/x-protobuf"
+  );
+}
+function requireOtlpContentEncoding(value) {
+  if (value === "identity" || value === "gzip") return value;
+  throw new Error("OTLP envelope content encoding must be identity or gzip");
+}
+function otlpOutboxRecordFromRow(row) {
+  const rawBody = row.body;
+  if (!(rawBody instanceof Uint8Array)) {
+    throw new Error("FML observer OTLP outbox body is not a BLOB");
+  }
+  const destination = otlpDestinationFromRow(row);
+  return {
+    id: row.id,
+    envelopeId: row.envelope_id,
+    observerInstanceId: row.observer_instance_id,
+    observerVersion: row.observer_version,
+    signal: requireOtlpSignal(row.signal),
+    contentType: requireOtlpContentType(row.content_type),
+    contentEncoding: requireOtlpContentEncoding(row.content_encoding),
+    body: Buffer.from(rawBody),
+    sha256: row.sha256,
+    capturedAtMs: row.captured_at_ms,
+    retryCount: row.retry_count,
+    nextAttemptAtMs: row.next_attempt_at_ms,
+    ...destination === void 0 ? {} : { destination }
+  };
+}
+function validateHookBatchLimit(limit) {
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_HOOK_OUTBOX_BATCH_SIZE) {
+    throw new Error(
+      `Hook outbox batch limit must be an integer from 1 to ${MAX_HOOK_OUTBOX_BATCH_SIZE}`
+    );
+  }
+}
+function validateOtlpBatchLimit(limit) {
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_OTLP_OUTBOX_BATCH_SIZE) {
+    throw new Error(
+      `OTLP outbox batch limit must be an integer from 1 to ${MAX_OTLP_OUTBOX_BATCH_SIZE}`
+    );
+  }
+}
+function enforceOwnerOnlyMode(filePath, mode) {
+  if (process.platform === "win32") return;
+  try {
+    fs2.chmodSync(filePath, mode);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+function openObserverDatabase(databaseFile, options = {}) {
+  const maxHookSpoolBytes = options.maxHookSpoolBytes;
+  const maxOtlpSpoolBytes = options.maxOtlpSpoolBytes ?? DEFAULT_OTLP_SPOOL_MAX_BYTES;
+  const maxHookQuarantineAgeMs = options.maxHookQuarantineAgeMs;
+  if (maxHookSpoolBytes !== void 0 && (!Number.isSafeInteger(maxHookSpoolBytes) || maxHookSpoolBytes < 1)) {
+    throw new Error(
+      "Hook spool maximum must be a positive safe integer number of bytes"
+    );
+  }
+  if (!Number.isSafeInteger(maxOtlpSpoolBytes) || maxOtlpSpoolBytes < 1) {
+    throw new Error(
+      "OTLP spool maximum must be a positive safe integer number of bytes"
+    );
+  }
+  if (maxHookQuarantineAgeMs !== void 0 && (!Number.isSafeInteger(maxHookQuarantineAgeMs) || maxHookQuarantineAgeMs < 1)) {
+    throw new Error(
+      "Hook quarantine maximum age must be a positive safe integer number of milliseconds"
+    );
+  }
+  const getBuiltinModule = process.getBuiltinModule;
+  const sqlite = getBuiltinModule?.("node:sqlite");
+  if (!sqlite?.DatabaseSync) {
+    throw new Error("FML observer requires the Node.js built-in SQLite module");
+  }
+  const databaseDirectory = path2.dirname(databaseFile);
+  fs2.mkdirSync(databaseDirectory, { recursive: true, mode: 448 });
+  if (options.restrictDatabaseDirectory !== false) {
+    enforceOwnerOnlyMode(databaseDirectory, 448);
+  }
+  const database = new sqlite.DatabaseSync(databaseFile);
+  enforceOwnerOnlyMode(databaseFile, 384);
+  try {
+    database.exec(`
+      PRAGMA busy_timeout = 5000;
+      PRAGMA journal_mode = WAL;
+      -- Inbox files and OTLP requests are acknowledged immediately after a
+      -- database commit. FULL syncs each WAL commit before it can become the
+      -- sole durable copy.
+      PRAGMA synchronous = FULL;
+    `);
+    const readSchemaVersion = () => {
+      const version2 = database.prepare("PRAGMA user_version").get()?.user_version;
+      if (typeof version2 !== "number" || !Number.isInteger(version2)) {
+        throw new Error("FML observer database has an invalid schema version");
+      }
+      return version2;
+    };
+    const version = readSchemaVersion();
+    if (version > SCHEMA_VERSION) {
+      throw new Error(
+        `FML observer database schema ${version} is newer than supported schema ${SCHEMA_VERSION}`
+      );
+    }
+    const runMigration = (targetVersion, sql) => {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        const lockedVersion = readSchemaVersion();
+        if (lockedVersion > SCHEMA_VERSION) {
+          throw new Error(
+            `FML observer database schema ${lockedVersion} is newer than supported schema ${SCHEMA_VERSION}`
+          );
+        }
+        if (lockedVersion < targetVersion) {
+          database.exec(typeof sql === "string" ? sql : sql());
+          database.exec(`PRAGMA user_version = ${targetVersion}`);
+        }
+        database.exec("COMMIT");
+      } catch (error) {
+        try {
+          database.exec("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      }
+    };
+    if (version < 1) {
+      runMigration(
+        1,
+        `
+        CREATE TABLE IF NOT EXISTS runtime_state (
+          key TEXT PRIMARY KEY,
+          value_json TEXT NOT NULL,
+          updated_at_ms INTEGER NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS sync_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          started_at_ms INTEGER NOT NULL,
+          completed_at_ms INTEGER NOT NULL,
+          environment TEXT,
+          outcome TEXT NOT NULL,
+          uploaded_bytes INTEGER NOT NULL,
+          failed INTEGER NOT NULL,
+          error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS sync_runs_completed_at
+          ON sync_runs(completed_at_ms DESC);
+      `
+      );
+    }
+    if (version < 2) {
+      runMigration(
+        2,
+        `
+        CREATE TABLE hook_event_outbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          sync_id TEXT NOT NULL UNIQUE,
+          session_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          timestamp_ms INTEGER NOT NULL,
+          target TEXT NOT NULL,
+          payload_json TEXT NOT NULL,
+          cwd TEXT,
+          repository TEXT,
+          tool_name TEXT,
+          user_prompt TEXT,
+          file_path TEXT,
+          command TEXT,
+          plan TEXT,
+          allowed_prompts TEXT,
+          tool_result TEXT,
+          captured_at_ms INTEGER NOT NULL
+        );
+        CREATE INDEX hook_event_outbox_captured_at
+          ON hook_event_outbox(captured_at_ms, id);
+      `
+      );
+    }
+    if (version < 3) {
+      runMigration(
+        3,
+        `
+        CREATE TABLE hook_event_quarantine (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          outbox_id INTEGER NOT NULL,
+          sync_id TEXT NOT NULL UNIQUE,
+          session_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          timestamp_ms INTEGER NOT NULL,
+          target TEXT NOT NULL,
+          payload_json TEXT NOT NULL,
+          cwd TEXT,
+          repository TEXT,
+          tool_name TEXT,
+          user_prompt TEXT,
+          file_path TEXT,
+          command TEXT,
+          plan TEXT,
+          allowed_prompts TEXT,
+          tool_result TEXT,
+          captured_at_ms INTEGER NOT NULL,
+          rejection_reason TEXT NOT NULL,
+          quarantined_at_ms INTEGER NOT NULL
+        );
+        CREATE INDEX hook_event_quarantine_quarantined_at
+          ON hook_event_quarantine(quarantined_at_ms DESC, id DESC);
+      `
+      );
+    }
+    if (version < 4) {
+      runMigration(
+        4,
+        `
+        ALTER TABLE hook_event_outbox ADD COLUMN destination_url TEXT;
+        ALTER TABLE hook_event_outbox ADD COLUMN destination_organization TEXT;
+        ALTER TABLE hook_event_outbox ADD COLUMN destination_identity TEXT;
+        CREATE INDEX hook_event_outbox_destination
+          ON hook_event_outbox(
+            destination_identity,
+            destination_url,
+            destination_organization,
+            id
+          );
+        ALTER TABLE hook_event_quarantine ADD COLUMN destination_url TEXT;
+        ALTER TABLE hook_event_quarantine ADD COLUMN destination_organization TEXT;
+        ALTER TABLE hook_event_quarantine ADD COLUMN destination_identity TEXT;
+      `
+      );
+    }
+    if (version < 5) {
+      runMigration(
+        5,
+        `
+        DROP INDEX hook_event_outbox_destination;
+        ALTER TABLE hook_event_outbox DROP COLUMN destination_organization;
+        ALTER TABLE hook_event_quarantine DROP COLUMN destination_organization;
+        CREATE INDEX hook_event_outbox_destination
+          ON hook_event_outbox(destination_identity, destination_url, id);
+      `
+      );
+    }
+    if (version < 6) {
+      runMigration(
+        6,
+        `
+        ALTER TABLE hook_event_outbox
+          ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE hook_event_outbox
+          ADD COLUMN next_attempt_at_ms INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE hook_event_outbox
+          ADD COLUMN logical_bytes INTEGER NOT NULL DEFAULT 0;
+        UPDATE hook_event_outbox
+        SET logical_bytes = ${HOOK_OUTBOX_LOGICAL_BYTES_SQL};
+        CREATE INDEX IF NOT EXISTS hook_event_outbox_attempt
+          ON hook_event_outbox(next_attempt_at_ms, id);
+
+        ALTER TABLE hook_event_quarantine
+          ADD COLUMN logical_bytes INTEGER NOT NULL DEFAULT 0;
+        UPDATE hook_event_quarantine
+        SET logical_bytes =
+          ${HOOK_OUTBOX_LOGICAL_BYTES_SQL} +
+          length(CAST(rejection_reason AS BLOB));
+
+        CREATE TABLE IF NOT EXISTS hook_spool_state (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          logical_bytes INTEGER NOT NULL,
+          evicted_records INTEGER NOT NULL,
+          evicted_bytes INTEGER NOT NULL,
+          evicted_pending_records INTEGER NOT NULL,
+          evicted_quarantined_records INTEGER NOT NULL,
+          last_evicted_at_ms INTEGER
+        );
+        INSERT OR IGNORE INTO hook_spool_state (
+          singleton,
+          logical_bytes,
+          evicted_records,
+          evicted_bytes,
+          evicted_pending_records,
+          evicted_quarantined_records,
+          last_evicted_at_ms
+        )
+        SELECT
+          1,
+          (SELECT COALESCE(SUM(logical_bytes), 0) FROM hook_event_outbox) +
+            (SELECT COALESCE(SUM(logical_bytes), 0) FROM hook_event_quarantine),
+          0,
+          0,
+          0,
+          0,
+          NULL;
+      `
+      );
+    }
+    if (version < 7) {
+      runMigration(
+        7,
+        `
+        CREATE INDEX IF NOT EXISTS hook_event_outbox_destination_session
+          ON hook_event_outbox(
+            destination_identity,
+            destination_url,
+            session_id,
+            id
+          );
+      `
+      );
+    }
+    if (version < 9) {
+      runMigration(9, () => {
+        database.exec(`
+        CREATE INDEX IF NOT EXISTS hook_event_outbox_destination_session
+          ON hook_event_outbox(
+            destination_identity,
+            destination_url,
+            session_id,
+            id
+          );
+
+        CREATE TABLE IF NOT EXISTS otlp_envelope_outbox (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          envelope_id TEXT NOT NULL UNIQUE,
+          observer_instance_id TEXT NOT NULL,
+          observer_version TEXT NOT NULL,
+          signal TEXT NOT NULL CHECK (signal IN ('logs', 'metrics', 'traces')),
+          content_type TEXT NOT NULL CHECK (
+            content_type IN ('application/json', 'application/x-protobuf')
+          ),
+          content_encoding TEXT NOT NULL CHECK (
+            content_encoding IN ('identity', 'gzip')
+          ),
+          body BLOB NOT NULL,
+          sha256 TEXT NOT NULL,
+          captured_at_ms INTEGER NOT NULL,
+          destination_url TEXT,
+          destination_identity TEXT,
+          destination_organization_id TEXT,
+          destination_organization_slug TEXT,
+          CHECK (
+            (
+              destination_url IS NULL
+              AND destination_identity IS NULL
+              AND destination_organization_id IS NULL
+              AND destination_organization_slug IS NULL
+            )
+            OR
+            (
+              destination_url IS NOT NULL
+              AND destination_identity IS NOT NULL
+              AND (
+                (
+                  destination_organization_id IS NULL
+                  AND destination_organization_slug IS NULL
+                )
+                OR
+                (
+                  destination_organization_id IS NOT NULL
+                  AND destination_organization_slug IS NOT NULL
+                )
+              )
+            )
+          )
+        );
+        CREATE INDEX IF NOT EXISTS otlp_envelope_outbox_destination
+          ON otlp_envelope_outbox(
+            destination_identity,
+            destination_url,
+            destination_organization_id,
+            id
+          );
+        CREATE INDEX IF NOT EXISTS otlp_envelope_outbox_captured_at
+          ON otlp_envelope_outbox(captured_at_ms, id);
+        CREATE TABLE IF NOT EXISTS otlp_envelope_quarantine (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          outbox_id INTEGER NOT NULL,
+          envelope_id TEXT NOT NULL UNIQUE,
+          observer_instance_id TEXT NOT NULL,
+          observer_version TEXT NOT NULL,
+          signal TEXT NOT NULL CHECK (signal IN ('logs', 'metrics', 'traces')),
+          content_type TEXT NOT NULL CHECK (
+            content_type IN ('application/json', 'application/x-protobuf')
+          ),
+          content_encoding TEXT NOT NULL CHECK (
+            content_encoding IN ('identity', 'gzip')
+          ),
+          body BLOB NOT NULL,
+          sha256 TEXT NOT NULL,
+          captured_at_ms INTEGER NOT NULL,
+          destination_url TEXT,
+          destination_identity TEXT,
+          destination_organization_id TEXT,
+          destination_organization_slug TEXT,
+          rejection_reason TEXT NOT NULL,
+          quarantined_at_ms INTEGER NOT NULL,
+          CHECK (
+            (
+              destination_url IS NULL
+              AND destination_identity IS NULL
+              AND destination_organization_id IS NULL
+              AND destination_organization_slug IS NULL
+            )
+            OR
+            (
+              destination_url IS NOT NULL
+              AND destination_identity IS NOT NULL
+              AND (
+                (
+                  destination_organization_id IS NULL
+                  AND destination_organization_slug IS NULL
+                )
+                OR
+                (
+                  destination_organization_id IS NOT NULL
+                  AND destination_organization_slug IS NOT NULL
+                )
+              )
+            )
+          )
+        );
+        CREATE INDEX IF NOT EXISTS otlp_envelope_quarantine_quarantined_at
+          ON otlp_envelope_quarantine(quarantined_at_ms DESC, id DESC);
+        `);
+        const otlpOutboxColumns = new Set(
+          database.prepare("PRAGMA table_info(otlp_envelope_outbox)").all().flatMap((row) => typeof row.name === "string" ? [row.name] : [])
+        );
+        const otlpQuarantineColumns = new Set(
+          database.prepare("PRAGMA table_info(otlp_envelope_quarantine)").all().flatMap((row) => typeof row.name === "string" ? [row.name] : [])
+        );
+        return `
+        ${otlpOutboxColumns.has("retry_count") ? "" : `ALTER TABLE otlp_envelope_outbox
+                ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0;`}
+        ${otlpOutboxColumns.has("next_attempt_at_ms") ? "" : `ALTER TABLE otlp_envelope_outbox
+                ADD COLUMN next_attempt_at_ms INTEGER NOT NULL DEFAULT 0;`}
+        ${otlpOutboxColumns.has("logical_bytes") ? "" : `ALTER TABLE otlp_envelope_outbox
+                ADD COLUMN logical_bytes INTEGER NOT NULL DEFAULT 0;`}
+        UPDATE otlp_envelope_outbox
+        SET logical_bytes = ${OTLP_LOGICAL_BYTES_SQL};
+        CREATE INDEX IF NOT EXISTS otlp_envelope_outbox_attempt
+          ON otlp_envelope_outbox(
+            destination_identity,
+            destination_url,
+            destination_organization_id,
+            next_attempt_at_ms,
+            id
+          );
+        ${otlpQuarantineColumns.has("logical_bytes") ? "" : `ALTER TABLE otlp_envelope_quarantine
+                ADD COLUMN logical_bytes INTEGER NOT NULL DEFAULT 0;`}
+        UPDATE otlp_envelope_quarantine
+        SET logical_bytes = ${OTLP_LOGICAL_BYTES_SQL};
+
+        CREATE TABLE IF NOT EXISTS otlp_spool_state (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          logical_bytes INTEGER NOT NULL CHECK (logical_bytes >= 0),
+          body_bytes INTEGER NOT NULL CHECK (body_bytes >= 0),
+          quarantined_ownerless_records INTEGER NOT NULL,
+          quarantined_ownerless_logical_bytes INTEGER NOT NULL,
+          quarantined_ownerless_body_bytes INTEGER NOT NULL,
+          last_quarantined_ownerless_at_ms INTEGER
+        );
+        INSERT OR IGNORE INTO otlp_spool_state (
+          singleton,
+          logical_bytes,
+          body_bytes,
+          quarantined_ownerless_records,
+          quarantined_ownerless_logical_bytes,
+          quarantined_ownerless_body_bytes,
+          last_quarantined_ownerless_at_ms
+        ) VALUES (
+          1,
+          (SELECT COALESCE(SUM(logical_bytes), 0) FROM otlp_envelope_outbox) +
+            (SELECT COALESCE(SUM(logical_bytes), 0) FROM otlp_envelope_quarantine),
+          (SELECT COALESCE(SUM(length(body)), 0) FROM otlp_envelope_outbox) +
+            (SELECT COALESCE(SUM(length(body)), 0) FROM otlp_envelope_quarantine),
+          0,
+          0,
+          0,
+          NULL
+        );
+
+        DROP TRIGGER IF EXISTS otlp_outbox_body_bytes_insert;
+        DROP TRIGGER IF EXISTS otlp_outbox_body_bytes_delete;
+        DROP TRIGGER IF EXISTS otlp_quarantine_body_bytes_insert;
+        DROP TRIGGER IF EXISTS otlp_quarantine_body_bytes_delete;
+
+        CREATE TRIGGER otlp_outbox_body_bytes_insert
+        AFTER INSERT ON otlp_envelope_outbox
+        BEGIN
+          UPDATE otlp_spool_state
+          SET
+            logical_bytes = logical_bytes + NEW.logical_bytes,
+            body_bytes = body_bytes + length(NEW.body)
+          WHERE singleton = 1;
+        END;
+        CREATE TRIGGER otlp_outbox_body_bytes_delete
+        AFTER DELETE ON otlp_envelope_outbox
+        BEGIN
+          UPDATE otlp_spool_state
+          SET
+            logical_bytes = logical_bytes - OLD.logical_bytes,
+            body_bytes = body_bytes - length(OLD.body)
+          WHERE singleton = 1;
+        END;
+        CREATE TRIGGER otlp_quarantine_body_bytes_insert
+        AFTER INSERT ON otlp_envelope_quarantine
+        BEGIN
+          UPDATE otlp_spool_state
+          SET
+            logical_bytes = logical_bytes + NEW.logical_bytes,
+            body_bytes = body_bytes + length(NEW.body)
+          WHERE singleton = 1;
+        END;
+        CREATE TRIGGER otlp_quarantine_body_bytes_delete
+        AFTER DELETE ON otlp_envelope_quarantine
+        BEGIN
+          UPDATE otlp_spool_state
+          SET
+            logical_bytes = logical_bytes - OLD.logical_bytes,
+            body_bytes = body_bytes - length(OLD.body)
+          WHERE singleton = 1;
+        END;
+
+      `;
+      });
+    }
+    if (version < 10) {
+      runMigration(
+        10,
+        `
+        -- OTLP is operational telemetry, not a lossless artifact. Collapse the
+        -- prototype quarantine into durable drop accounting and retain only a
+        -- bounded pending spool.
+        DROP TRIGGER IF EXISTS otlp_outbox_body_bytes_insert;
+        DROP TRIGGER IF EXISTS otlp_outbox_body_bytes_delete;
+        DROP TRIGGER IF EXISTS otlp_quarantine_body_bytes_insert;
+        DROP TRIGGER IF EXISTS otlp_quarantine_body_bytes_delete;
+
+        UPDATE otlp_envelope_outbox
+        SET logical_bytes = ${OTLP_LOGICAL_BYTES_SQL};
+
+        CREATE TABLE otlp_spool_state_v10 (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          logical_bytes INTEGER NOT NULL CHECK (logical_bytes >= 0),
+          body_bytes INTEGER NOT NULL CHECK (body_bytes >= 0),
+          dropped_records INTEGER NOT NULL CHECK (dropped_records >= 0),
+          dropped_logical_bytes INTEGER NOT NULL CHECK (dropped_logical_bytes >= 0),
+          dropped_body_bytes INTEGER NOT NULL CHECK (dropped_body_bytes >= 0),
+          last_dropped_at_ms INTEGER,
+          last_drop_reason TEXT
+        );
+        INSERT INTO otlp_spool_state_v10 (
+          singleton,
+          logical_bytes,
+          body_bytes,
+          dropped_records,
+          dropped_logical_bytes,
+          dropped_body_bytes,
+          last_dropped_at_ms,
+          last_drop_reason
+        )
+        SELECT
+          1,
+          COALESCE((
+            SELECT SUM(logical_bytes)
+            FROM otlp_envelope_outbox
+            WHERE destination_url IS NOT NULL
+          ), 0),
+          COALESCE((
+            SELECT SUM(length(body))
+            FROM otlp_envelope_outbox
+            WHERE destination_url IS NOT NULL
+          ), 0),
+          quarantined_ownerless_records +
+            (SELECT COUNT(*) FROM otlp_envelope_quarantine
+              WHERE rejection_reason <> 'ownerless_ttl_expired') +
+            (SELECT COUNT(*) FROM otlp_envelope_outbox
+              WHERE destination_url IS NULL),
+          quarantined_ownerless_logical_bytes +
+            COALESCE((SELECT SUM(logical_bytes) FROM otlp_envelope_quarantine
+              WHERE rejection_reason <> 'ownerless_ttl_expired'), 0) +
+            COALESCE((SELECT SUM(logical_bytes) FROM otlp_envelope_outbox
+              WHERE destination_url IS NULL), 0),
+          quarantined_ownerless_body_bytes +
+            COALESCE((SELECT SUM(length(body)) FROM otlp_envelope_quarantine
+              WHERE rejection_reason <> 'ownerless_ttl_expired'), 0) +
+            COALESCE((SELECT SUM(length(body)) FROM otlp_envelope_outbox
+              WHERE destination_url IS NULL), 0),
+          (
+            SELECT MAX(timestamp_ms)
+            FROM (
+              SELECT last_quarantined_ownerless_at_ms AS timestamp_ms
+              UNION ALL
+              SELECT MAX(quarantined_at_ms) FROM otlp_envelope_quarantine
+              UNION ALL
+              SELECT MAX(captured_at_ms) FROM otlp_envelope_outbox
+                WHERE destination_url IS NULL
+            )
+          ),
+          CASE
+            WHEN quarantined_ownerless_records > 0
+              OR EXISTS (SELECT 1 FROM otlp_envelope_quarantine)
+              OR EXISTS (SELECT 1 FROM otlp_envelope_outbox
+                WHERE destination_url IS NULL)
+            THEN 'migration_cleanup'
+            ELSE NULL
+          END
+        FROM otlp_spool_state
+        WHERE singleton = 1;
+
+        DROP TABLE otlp_spool_state;
+        ALTER TABLE otlp_spool_state_v10 RENAME TO otlp_spool_state;
+        DELETE FROM otlp_envelope_outbox WHERE destination_url IS NULL;
+        DROP TABLE otlp_envelope_quarantine;
+
+        CREATE TRIGGER otlp_outbox_body_bytes_insert
+        AFTER INSERT ON otlp_envelope_outbox
+        BEGIN
+          UPDATE otlp_spool_state
+          SET
+            logical_bytes = logical_bytes + NEW.logical_bytes,
+            body_bytes = body_bytes + length(NEW.body)
+          WHERE singleton = 1;
+        END;
+        CREATE TRIGGER otlp_outbox_body_bytes_delete
+        AFTER DELETE ON otlp_envelope_outbox
+        BEGIN
+          UPDATE otlp_spool_state
+          SET
+            logical_bytes = logical_bytes - OLD.logical_bytes,
+            body_bytes = body_bytes - length(OLD.body)
+          WHERE singleton = 1;
+        END;
+        `
+      );
+    }
+    database.exec(`
+      BEGIN IMMEDIATE;
+      ${RECONCILE_HOOK_SPOOL_STATE_SQL};
+      INSERT OR IGNORE INTO otlp_spool_state (
+        singleton,
+        logical_bytes,
+        body_bytes,
+        dropped_records,
+        dropped_logical_bytes,
+        dropped_body_bytes,
+        last_dropped_at_ms,
+        last_drop_reason
+      ) VALUES (1, 0, 0, 0, 0, 0, NULL, NULL);
+      UPDATE otlp_spool_state
+      SET
+        logical_bytes =
+          (SELECT COALESCE(SUM(logical_bytes), 0) FROM otlp_envelope_outbox),
+        body_bytes =
+          (SELECT COALESCE(SUM(length(body)), 0) FROM otlp_envelope_outbox)
+      WHERE singleton = 1;
+      COMMIT;
+    `);
+    const setRuntimeState = database.prepare(`
+      INSERT INTO runtime_state (key, value_json, updated_at_ms)
+      VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET
+        value_json = excluded.value_json,
+        updated_at_ms = excluded.updated_at_ms
+    `);
+    const recordSyncRun = database.prepare(`
+      INSERT INTO sync_runs (
+        started_at_ms,
+        completed_at_ms,
+        environment,
+        outcome,
+        uploaded_bytes,
+        failed,
+        error
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const trimSyncRuns = database.prepare(`
+      DELETE FROM sync_runs
+      WHERE id <= (SELECT COALESCE(MAX(id), 0) - ? FROM sync_runs)
+    `);
+    const findPendingHookEvent = database.prepare(`
+      SELECT 1 AS present
+      FROM hook_event_outbox
+      WHERE sync_id = ?
+    `);
+    const findQuarantinedHookEvent = database.prepare(`
+      SELECT 1 AS present
+      FROM hook_event_quarantine
+      WHERE sync_id = ?
+    `);
+    const countPendingHookEvents = database.prepare(`
+      SELECT COUNT(*) AS count
+      FROM hook_event_outbox
+    `);
+    const countQuarantinedHookEvents = database.prepare(`
+      SELECT COUNT(*) AS count
+      FROM hook_event_quarantine
+    `);
+    const captureHookEvent = database.prepare(`
+      INSERT INTO hook_event_outbox (
+        sync_id,
+        session_id,
+        event_type,
+        timestamp_ms,
+        target,
+        payload_json,
+        cwd,
+        repository,
+        tool_name,
+        user_prompt,
+        file_path,
+        command,
+        plan,
+        allowed_prompts,
+        tool_result,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        logical_bytes
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const listPendingHookEvents = database.prepare(`
+      SELECT
+        id,
+        sync_id,
+        session_id,
+        event_type,
+        timestamp_ms,
+        target,
+        payload_json,
+        cwd,
+        repository,
+        tool_name,
+        user_prompt,
+        file_path,
+        command,
+        plan,
+        allowed_prompts,
+        tool_result,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        retry_count,
+        next_attempt_at_ms
+      FROM hook_event_outbox
+      ORDER BY id ASC
+      LIMIT ?
+    `);
+    const claimUnboundHookEvents = database.prepare(`
+      UPDATE hook_event_outbox
+      SET
+        destination_url = ?,
+        destination_identity = ?,
+        logical_bytes = logical_bytes + ?
+      WHERE destination_url IS NULL
+        AND destination_identity IS NULL
+    `);
+    const listDestinationPendingHookEvents = database.prepare(`
+      SELECT
+        id,
+        sync_id,
+        session_id,
+        event_type,
+        timestamp_ms,
+        target,
+        payload_json,
+        cwd,
+        repository,
+        tool_name,
+        user_prompt,
+        file_path,
+        command,
+        plan,
+        allowed_prompts,
+        tool_result,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        retry_count,
+        next_attempt_at_ms
+      FROM hook_event_outbox AS candidate
+      WHERE candidate.destination_url = ?
+        AND candidate.destination_identity = ?
+        AND candidate.next_attempt_at_ms <= ?
+        AND NOT EXISTS (
+          SELECT 1
+          FROM hook_event_outbox AS predecessor
+          WHERE predecessor.destination_url = candidate.destination_url
+            AND predecessor.destination_identity = candidate.destination_identity
+            AND predecessor.session_id = candidate.session_id
+            AND predecessor.id < candidate.id
+            AND predecessor.next_attempt_at_ms > ?
+        )
+      -- Once a deferred row is eligible again, restore durable FIFO order so
+      -- a steady stream of new captures cannot starve it indefinitely.
+      ORDER BY id ASC
+      LIMIT ?
+    `);
+    const nextDestinationHookAttempt = database.prepare(`
+      SELECT MIN(candidate.next_attempt_at_ms) AS next_attempt_at_ms
+      FROM hook_event_outbox AS candidate
+      WHERE candidate.destination_url = ?
+        AND candidate.destination_identity = ?
+        AND NOT EXISTS (
+          SELECT 1
+          FROM hook_event_outbox AS predecessor
+          WHERE predecessor.destination_url = candidate.destination_url
+            AND predecessor.destination_identity = candidate.destination_identity
+            AND predecessor.session_id = candidate.session_id
+            AND predecessor.id < candidate.id
+        )
+    `);
+    const quarantineHookEvent = database.prepare(`
+      INSERT INTO hook_event_quarantine (
+        outbox_id,
+        sync_id,
+        session_id,
+        event_type,
+        timestamp_ms,
+        target,
+        payload_json,
+        cwd,
+        repository,
+        tool_name,
+        user_prompt,
+        file_path,
+        command,
+        plan,
+        allowed_prompts,
+        tool_result,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        rejection_reason,
+        quarantined_at_ms,
+        logical_bytes
+      )
+      SELECT
+        id,
+        sync_id,
+        session_id,
+        event_type,
+        timestamp_ms,
+        target,
+        payload_json,
+        cwd,
+        repository,
+        tool_name,
+        user_prompt,
+        file_path,
+        command,
+        plan,
+        allowed_prompts,
+        tool_result,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        ?,
+        ?,
+        logical_bytes + ?
+      FROM hook_event_outbox
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND sync_id = ?
+      ON CONFLICT(sync_id) DO NOTHING
+    `);
+    const hookSpoolState = database.prepare(`
+      SELECT
+        logical_bytes,
+        evicted_records,
+        evicted_bytes,
+        evicted_pending_records,
+        evicted_quarantined_records,
+        last_evicted_at_ms
+      FROM hook_spool_state
+      WHERE singleton = 1
+    `);
+    const reconcileHookSpoolState = database.prepare(
+      RECONCILE_HOOK_SPOOL_STATE_SQL
+    );
+    const adjustHookSpoolBytes = database.prepare(`
+      UPDATE hook_spool_state
+      SET logical_bytes = logical_bytes + ?
+      WHERE singleton = 1
+    `);
+    const recordHookSpoolEviction = database.prepare(`
+      UPDATE hook_spool_state
+      SET
+        logical_bytes = logical_bytes - ?,
+        evicted_records = evicted_records + ?,
+        evicted_bytes = evicted_bytes + ?,
+        evicted_pending_records = evicted_pending_records + ?,
+        evicted_quarantined_records = evicted_quarantined_records + ?,
+        last_evicted_at_ms = ?
+      WHERE singleton = 1
+    `);
+    const recordOversizedHookCapture = database.prepare(`
+      UPDATE hook_spool_state
+      SET
+        evicted_records = evicted_records + 1,
+        evicted_bytes = evicted_bytes + ?,
+        evicted_pending_records = evicted_pending_records + 1,
+        last_evicted_at_ms = ?
+      WHERE singleton = 1
+    `);
+    const quarantineEvictionPlan = database.prepare(`
+      WITH ordered AS (
+        SELECT
+          logical_bytes,
+          SUM(logical_bytes) OVER (ORDER BY id ASC) - logical_bytes
+            AS preceding_bytes
+        FROM hook_event_quarantine
+      )
+      SELECT
+        COUNT(*) AS record_count,
+        COALESCE(SUM(logical_bytes), 0) AS logical_bytes
+      FROM ordered
+      WHERE preceding_bytes < ?
+    `);
+    const pendingEvictionPlan = database.prepare(`
+      WITH ordered AS (
+        SELECT
+          logical_bytes,
+          SUM(logical_bytes) OVER (ORDER BY id ASC) - logical_bytes
+            AS preceding_bytes
+        FROM hook_event_outbox
+      )
+      SELECT
+        COUNT(*) AS record_count,
+        COALESCE(SUM(logical_bytes), 0) AS logical_bytes
+      FROM ordered
+      WHERE preceding_bytes < ?
+    `);
+    const evictOldestQuarantinedHookEvents = database.prepare(`
+      DELETE FROM hook_event_quarantine
+      WHERE id IN (
+        SELECT id FROM hook_event_quarantine ORDER BY id ASC LIMIT ?
+      )
+    `);
+    const evictOldestPendingHookEvents = database.prepare(`
+      DELETE FROM hook_event_outbox
+      WHERE id IN (
+        SELECT id FROM hook_event_outbox ORDER BY id ASC LIMIT ?
+      )
+    `);
+    const expiredQuarantinePlan = database.prepare(`
+      SELECT
+        COUNT(*) AS record_count,
+        COALESCE(SUM(logical_bytes), 0) AS logical_bytes
+      FROM hook_event_quarantine
+      WHERE quarantined_at_ms <= ?
+    `);
+    const pruneExpiredQuarantine = database.prepare(`
+      DELETE FROM hook_event_quarantine
+      WHERE quarantined_at_ms <= ?
+    `);
+    const deletePendingHookEvent = database.prepare(`
+      DELETE FROM hook_event_outbox
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND sync_id = ?
+    `);
+    const findPendingOtlpEnvelope = database.prepare(`
+      SELECT 1 AS present
+      FROM otlp_envelope_outbox
+      WHERE envelope_id = ?
+    `);
+    const countPendingOtlpEnvelopes = database.prepare(`
+      SELECT COUNT(*) AS count
+      FROM otlp_envelope_outbox
+    `);
+    const captureOtlpEnvelope = database.prepare(`
+      INSERT INTO otlp_envelope_outbox (
+        envelope_id,
+        observer_instance_id,
+        observer_version,
+        signal,
+        content_type,
+        content_encoding,
+        body,
+        sha256,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        destination_organization_id,
+        destination_organization_slug,
+        logical_bytes
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const listPendingOtlpEnvelopes = database.prepare(`
+      SELECT
+        id,
+        envelope_id,
+        observer_instance_id,
+        observer_version,
+        signal,
+        content_type,
+        content_encoding,
+        body,
+        sha256,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        destination_organization_id,
+        destination_organization_slug,
+        retry_count,
+        next_attempt_at_ms
+      FROM otlp_envelope_outbox
+      ORDER BY id ASC
+      LIMIT ?
+    `);
+    const claimOrganizationForOtlpEnvelopes = database.prepare(`
+      UPDATE otlp_envelope_outbox
+      SET
+        destination_organization_id = ?,
+        destination_organization_slug = ?
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND destination_organization_id IS NULL
+        AND destination_organization_slug IS NULL
+    `);
+    const listDestinationPendingOtlpEnvelopes = database.prepare(`
+      SELECT
+        id,
+        envelope_id,
+        observer_instance_id,
+        observer_version,
+        signal,
+        content_type,
+        content_encoding,
+        body,
+        sha256,
+        captured_at_ms,
+        destination_url,
+        destination_identity,
+        destination_organization_id,
+        destination_organization_slug,
+        retry_count,
+        next_attempt_at_ms
+      FROM otlp_envelope_outbox
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND destination_organization_id IS ?
+        AND next_attempt_at_ms <= ?
+      ORDER BY id ASC
+      LIMIT ?
+    `);
+    const deferDestinationPendingOtlpEnvelope = database.prepare(`
+      UPDATE otlp_envelope_outbox
+      SET
+        retry_count = retry_count + 1,
+        next_attempt_at_ms = ?
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND destination_organization_id IS ?
+        AND envelope_id = ?
+    `);
+    const nextDestinationPendingOtlpAttempt = database.prepare(`
+      SELECT MIN(next_attempt_at_ms) AS next_attempt_at_ms
+      FROM otlp_envelope_outbox
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND destination_organization_id IS ?
+    `);
+    const getOtlpSpoolState = database.prepare(`
+      SELECT
+        logical_bytes,
+        body_bytes,
+        dropped_records,
+        dropped_logical_bytes,
+        dropped_body_bytes,
+        last_dropped_at_ms,
+        last_drop_reason
+      FROM otlp_spool_state
+      WHERE singleton = 1
+    `);
+    const recordOtlpDrops = database.prepare(`
+      UPDATE otlp_spool_state
+      SET
+        dropped_records = dropped_records + ?,
+        dropped_logical_bytes = dropped_logical_bytes + ?,
+        dropped_body_bytes = dropped_body_bytes + ?,
+        last_dropped_at_ms = ?,
+        last_drop_reason = ?
+      WHERE singleton = 1
+    `);
+    const otlpCapacityEvictionPlan = database.prepare(`
+      WITH ordered AS (
+        SELECT
+          logical_bytes,
+          length(body) AS body_bytes,
+          SUM(logical_bytes) OVER (ORDER BY id ASC) - logical_bytes
+            AS preceding_bytes
+        FROM otlp_envelope_outbox
+      )
+      SELECT
+        COUNT(*) AS record_count,
+        COALESCE(SUM(logical_bytes), 0) AS logical_bytes,
+        COALESCE(SUM(body_bytes), 0) AS body_bytes
+      FROM ordered
+      WHERE preceding_bytes < ?
+    `);
+    const evictOldestPendingOtlpEnvelopes = database.prepare(`
+      DELETE FROM otlp_envelope_outbox
+      WHERE id IN (
+        SELECT id FROM otlp_envelope_outbox ORDER BY id ASC LIMIT ?
+      )
+    `);
+    const getDestinationPendingOtlpEnvelopeAccounting = database.prepare(`
+      SELECT logical_bytes, length(body) AS body_bytes
+      FROM otlp_envelope_outbox
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND destination_organization_id IS ?
+        AND envelope_id = ?
+    `);
+    const deleteDestinationPendingOtlpEnvelope = database.prepare(`
+      DELETE FROM otlp_envelope_outbox
+      WHERE destination_url = ?
+        AND destination_identity = ?
+        AND destination_organization_id IS ?
+        AND envelope_id = ?
+    `);
+    const runImmediateTransaction = (operation) => {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        const result = operation();
+        database.exec("COMMIT");
+        return result;
+      } catch (error) {
+        try {
+          database.exec("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      }
+    };
+    const requireSpoolInteger = (row, key) => {
+      const value = row?.[key];
+      if (!Number.isSafeInteger(value) || value < 0) {
+        throw new ObserverHookSpoolStateInvariantError(
+          `FML observer spool ${key} is invalid`
+        );
+      }
+      return value;
+    };
+    const recordOtlpDrop = (records, logicalBytes, bodyBytes, droppedAtMs, reason) => {
+      if (records === 0) return;
+      requireTimestamp(droppedAtMs, "OTLP drop timestamp");
+      requireBoundedString(
+        reason,
+        "OTLP drop reason",
+        MAX_OTLP_DROP_REASON_BYTES
+      );
+      const updated = recordOtlpDrops.run(
+        records,
+        logicalBytes,
+        bodyBytes,
+        droppedAtMs,
+        reason
+      ).changes;
+      if (updated !== 1) {
+        throw new Error("FML observer OTLP drop accounting was incomplete");
+      }
+    };
+    const readHookSpoolState = () => {
+      try {
+        return hookSpoolState.get();
+      } catch (error) {
+        if (error instanceof RangeError) {
+          throw new ObserverHookSpoolStateInvariantError(
+            "FML observer hook spool contains an unsafe integer"
+          );
+        }
+        throw error;
+      }
+    };
+    const readHookSpoolLogicalBytes = () => {
+      try {
+        return requireSpoolInteger(readHookSpoolState(), "logical_bytes");
+      } catch (error) {
+        if (!(error instanceof ObserverHookSpoolStateInvariantError)) {
+          throw error;
+        }
+        reconcileHookSpoolState.run();
+        return requireSpoolInteger(readHookSpoolState(), "logical_bytes");
+      }
+    };
+    const runImmediateWithSpoolRepair = (operation) => {
+      try {
+        return runImmediateTransaction(operation);
+      } catch (error) {
+        if (!(error instanceof ObserverHookSpoolStateInvariantError)) {
+          throw error;
+        }
+        runImmediateTransaction(() => reconcileHookSpoolState.run());
+        return runImmediateTransaction(operation);
+      }
+    };
+    const evictionPlan = (statement, bytesToFree) => {
+      if (bytesToFree <= 0) return { records: 0, bytes: 0 };
+      const row = statement.get(bytesToFree);
+      return {
+        records: requireSpoolInteger(row, "record_count"),
+        bytes: requireSpoolInteger(row, "logical_bytes")
+      };
+    };
+    let nextQuarantinePruneAtMs = 0;
+    const enforceHookQuarantineAge = (nowMs, force = false) => {
+      if (maxHookQuarantineAgeMs === void 0) return;
+      requireTimestamp(nowMs, "Hook quarantine prune timestamp");
+      if (!force && nowMs < nextQuarantinePruneAtMs) return;
+      nextQuarantinePruneAtMs = Math.min(
+        Number.MAX_SAFE_INTEGER,
+        nowMs + Math.min(maxHookQuarantineAgeMs, QUARANTINE_PRUNE_INTERVAL_MS)
+      );
+      const cutoffMs = Math.max(0, nowMs - maxHookQuarantineAgeMs);
+      const expiredRow = expiredQuarantinePlan.get(cutoffMs);
+      const expired = {
+        records: requireSpoolInteger(expiredRow, "record_count"),
+        bytes: requireSpoolInteger(expiredRow, "logical_bytes")
+      };
+      if (expired.records === 0) return;
+      const changes = pruneExpiredQuarantine.run(cutoffMs).changes;
+      if (changes !== expired.records) {
+        throw new Error("FML observer hook quarantine pruning was incomplete");
+      }
+      recordHookSpoolEviction.run(
+        expired.bytes,
+        expired.records,
+        expired.bytes,
+        0,
+        expired.records,
+        nowMs
+      );
+    };
+    const enforceHookSpoolLimit = (evictedAtMs, additionalBytes = 0) => {
+      if (maxHookSpoolBytes === void 0) return;
+      requireTimestamp(evictedAtMs, "Hook spool eviction timestamp");
+      if (!Number.isSafeInteger(additionalBytes) || additionalBytes < 0) {
+        throw new Error("FML observer hook spool additional bytes are invalid");
+      }
+      const currentBytes = readHookSpoolLogicalBytes();
+      let bytesToFree = currentBytes + additionalBytes - maxHookSpoolBytes;
+      if (bytesToFree <= 0) return;
+      const requiredBytes = bytesToFree;
+      const quarantined = evictionPlan(quarantineEvictionPlan, bytesToFree);
+      if (quarantined.records > 0) {
+        const changes = evictOldestQuarantinedHookEvents.run(
+          quarantined.records
+        ).changes;
+        if (changes !== quarantined.records) {
+          throw new Error(
+            "FML observer hook quarantine eviction was incomplete"
+          );
+        }
+        bytesToFree -= quarantined.bytes;
+      }
+      const pending = evictionPlan(pendingEvictionPlan, bytesToFree);
+      if (pending.records > 0) {
+        const changes = evictOldestPendingHookEvents.run(
+          pending.records
+        ).changes;
+        if (changes !== pending.records) {
+          throw new Error("FML observer hook outbox eviction was incomplete");
+        }
+      }
+      const evictedRecords = quarantined.records + pending.records;
+      const evictedBytes = quarantined.bytes + pending.bytes;
+      if (evictedRecords === 0 || evictedBytes === 0 || evictedBytes < requiredBytes) {
+        throw new ObserverHookSpoolStateInvariantError(
+          "FML observer hook spool accounting could not enforce its limit"
+        );
+      }
+      recordHookSpoolEviction.run(
+        evictedBytes,
+        evictedRecords,
+        evictedBytes,
+        pending.records,
+        quarantined.records,
+        evictedAtMs
+      );
+    };
+    if (maxHookSpoolBytes !== void 0 || maxHookQuarantineAgeMs !== void 0) {
+      runImmediateTransaction(() => {
+        const nowMs = Date.now();
+        enforceHookQuarantineAge(nowMs, true);
+        enforceHookSpoolLimit(nowMs);
+      });
+    }
+    enforceOwnerOnlyMode(databaseFile, 384);
+    enforceOwnerOnlyMode(`${databaseFile}-wal`, 384);
+    enforceOwnerOnlyMode(`${databaseFile}-shm`, 384);
+    return {
+      setRuntimeState: (key, value, updatedAtMs = Date.now()) => {
+        setRuntimeState.run(key, JSON.stringify(value), updatedAtMs);
+      },
+      recordSyncRun: (record) => {
+        recordSyncRun.run(
+          record.startedAtMs,
+          record.completedAtMs,
+          record.environment ?? null,
+          record.outcome,
+          record.uploadedBytes,
+          record.failed,
+          record.error ?? null
+        );
+        trimSyncRuns.run(MAX_SYNC_RUN_RECORDS);
+      },
+      captureHookEvent: (envelope) => {
+        requireBoundedString(
+          envelope.syncId,
+          "Hook event sync ID",
+          MAX_HOOK_SYNC_ID_BYTES
+        );
+        requireBoundedString(
+          envelope.sessionId,
+          "Hook event session ID",
+          MAX_HOOK_SESSION_ID_BYTES
+        );
+        requireBoundedString(
+          envelope.eventType,
+          "Hook event type",
+          MAX_HOOK_EVENT_TYPE_BYTES
+        );
+        requireBoundedString(
+          envelope.target,
+          "Hook event target",
+          MAX_HOOK_TARGET_BYTES
+        );
+        requireTimestamp(envelope.timestampMs, "Hook event timestamp");
+        const capturedAtMs = envelope.capturedAtMs ?? Date.now();
+        requireTimestamp(capturedAtMs, "Hook event capture timestamp");
+        const payloadJson = jsonStringify(
+          envelope.payload,
+          "Hook event payload"
+        );
+        if (Buffer.byteLength(payloadJson, "utf8") > MAX_HOOK_PAYLOAD_BYTES) {
+          throw new Error(
+            `Hook event payload exceeds ${MAX_HOOK_PAYLOAD_BYTES} bytes`
+          );
+        }
+        validateOptionalHookField(envelope.cwd, "Hook event cwd");
+        validateOptionalHookField(envelope.repository, "Hook event repository");
+        validateOptionalHookField(envelope.toolName, "Hook event tool name");
+        validateOptionalHookField(
+          envelope.userPrompt,
+          "Hook event user prompt"
+        );
+        validateOptionalHookField(envelope.filePath, "Hook event file path");
+        validateOptionalHookField(envelope.command, "Hook event command");
+        validateOptionalHookField(envelope.plan, "Hook event plan");
+        validateOptionalHookField(
+          envelope.allowedPrompts,
+          "Hook event allowed prompts"
+        );
+        validateOptionalHookField(
+          envelope.toolResult,
+          "Hook event tool result"
+        );
+        if (envelope.destination) {
+          validateHookDestination(envelope.destination);
+        }
+        const logicalBytes = hookOutboxLogicalBytes(envelope, payloadJson);
+        const captureResult = runImmediateWithSpoolRepair(() => {
+          enforceHookQuarantineAge(Date.now());
+          if (findPendingHookEvent.get(envelope.syncId) || findQuarantinedHookEvent.get(envelope.syncId)) {
+            return "duplicate";
+          }
+          const evictedAtMs = Date.now();
+          if (maxHookSpoolBytes !== void 0 && logicalBytes > maxHookSpoolBytes) {
+            recordOversizedHookCapture.run(logicalBytes, evictedAtMs);
+            return "too_large";
+          }
+          enforceHookSpoolLimit(evictedAtMs, logicalBytes);
+          captureHookEvent.run(
+            envelope.syncId,
+            envelope.sessionId,
+            envelope.eventType,
+            envelope.timestampMs,
+            envelope.target,
+            payloadJson,
+            envelope.cwd ?? null,
+            envelope.repository ?? null,
+            envelope.toolName ?? null,
+            envelope.userPrompt ?? null,
+            envelope.filePath ?? null,
+            envelope.command ?? null,
+            envelope.plan ?? null,
+            envelope.allowedPrompts ?? null,
+            envelope.toolResult ?? null,
+            capturedAtMs,
+            envelope.destination?.targetUrl ?? null,
+            envelope.destination?.destinationIdentity ?? null,
+            logicalBytes
+          );
+          adjustHookSpoolBytes.run(logicalBytes);
+          return "captured";
+        });
+        if (captureResult === "too_large" && maxHookSpoolBytes !== void 0) {
+          throw new ObserverHookSpoolEntryTooLargeError(
+            logicalBytes,
+            maxHookSpoolBytes
+          );
+        }
+        return captureResult === "captured";
+      },
+      listPendingHookEvents: (limit = DEFAULT_HOOK_OUTBOX_BATCH_SIZE) => {
+        validateHookBatchLimit(limit);
+        return listPendingHookEvents.all(limit).map(hookOutboxRecordFromRow);
+      },
+      claimPendingHookEvents: (destination, limit = DEFAULT_HOOK_OUTBOX_BATCH_SIZE, eligibleAtMs = Date.now()) => {
+        validateHookDestination(destination);
+        validateHookBatchLimit(limit);
+        requireTimestamp(eligibleAtMs, "Hook event eligibility timestamp");
+        return runImmediateWithSpoolRepair(() => {
+          const destinationBytes = utf8Bytes(destination.targetUrl) + utf8Bytes(destination.destinationIdentity);
+          const claimed = claimUnboundHookEvents.run(
+            destination.targetUrl,
+            destination.destinationIdentity,
+            destinationBytes
+          ).changes;
+          if (claimed > 0) {
+            adjustHookSpoolBytes.run(destinationBytes * claimed);
+            enforceHookSpoolLimit(eligibleAtMs);
+          }
+          return listDestinationPendingHookEvents.all(
+            destination.targetUrl,
+            destination.destinationIdentity,
+            eligibleAtMs,
+            eligibleAtMs,
+            limit
+          ).map(hookOutboxRecordFromRow);
+        });
+      },
+      deferHookEvents: (destination, syncIds, nextAttemptAtMs) => {
+        validateHookDestination(destination);
+        requireTimestamp(nextAttemptAtMs, "Hook event next-attempt timestamp");
+        const uniqueSyncIds = [...new Set(syncIds)];
+        if (uniqueSyncIds.length === 0) return 0;
+        if (uniqueSyncIds.length > MAX_HOOK_OUTBOX_BATCH_SIZE) {
+          throw new Error(
+            `Cannot defer more than ${MAX_HOOK_OUTBOX_BATCH_SIZE} hook events at once`
+          );
+        }
+        for (const syncId of uniqueSyncIds) {
+          requireBoundedString(
+            syncId,
+            "Hook event sync ID",
+            MAX_HOOK_SYNC_ID_BYTES
+          );
+        }
+        const placeholders = uniqueSyncIds.map(() => "?").join(", ");
+        const defer = database.prepare(`
+          UPDATE hook_event_outbox
+          SET
+            retry_count = retry_count + 1,
+            next_attempt_at_ms = ?
+          WHERE destination_url = ?
+            AND destination_identity = ?
+            AND sync_id IN (${placeholders})
+        `);
+        return runImmediateTransaction(
+          () => defer.run(
+            nextAttemptAtMs,
+            destination.targetUrl,
+            destination.destinationIdentity,
+            ...uniqueSyncIds
+          ).changes
+        );
+      },
+      nextPendingHookAttemptAtMs: (destination) => {
+        validateHookDestination(destination);
+        const value = nextDestinationHookAttempt.get(
+          destination.targetUrl,
+          destination.destinationIdentity
+        )?.next_attempt_at_ms;
+        if (value === null || value === void 0) return void 0;
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+          throw new Error(
+            "FML observer hook next-attempt timestamp is invalid"
+          );
+        }
+        return value;
+      },
+      countPendingHookEvents: () => {
+        const count = countPendingHookEvents.get()?.count;
+        if (typeof count !== "number" || !Number.isSafeInteger(count)) {
+          throw new Error("FML observer hook outbox count is invalid");
+        }
+        return count;
+      },
+      acknowledgeHookEvents: (destination, syncIds) => {
+        validateHookDestination(destination);
+        const uniqueSyncIds = [...new Set(syncIds)];
+        if (uniqueSyncIds.length === 0) return 0;
+        if (uniqueSyncIds.length > MAX_HOOK_OUTBOX_BATCH_SIZE) {
+          throw new Error(
+            `Cannot acknowledge more than ${MAX_HOOK_OUTBOX_BATCH_SIZE} hook events at once`
+          );
+        }
+        for (const syncId of uniqueSyncIds) {
+          requireBoundedString(
+            syncId,
+            "Hook event sync ID",
+            MAX_HOOK_SYNC_ID_BYTES
+          );
+        }
+        const placeholders = uniqueSyncIds.map(() => "?").join(", ");
+        const acknowledge = database.prepare(`
+          DELETE FROM hook_event_outbox
+          WHERE destination_url = ?
+            AND destination_identity = ?
+            AND sync_id IN (${placeholders})
+        `);
+        const acknowledgedBytes = database.prepare(`
+          SELECT COALESCE(SUM(logical_bytes), 0) AS logical_bytes
+          FROM hook_event_outbox
+          WHERE destination_url = ?
+            AND destination_identity = ?
+            AND sync_id IN (${placeholders})
+        `);
+        return runImmediateWithSpoolRepair(() => {
+          const values = [
+            destination.targetUrl,
+            destination.destinationIdentity,
+            ...uniqueSyncIds
+          ];
+          const logicalBytes = requireSpoolInteger(
+            acknowledgedBytes.get(...values),
+            "logical_bytes"
+          );
+          const changes = acknowledge.run(...values).changes;
+          if (changes > 0) adjustHookSpoolBytes.run(-logicalBytes);
+          return changes;
+        });
+      },
+      quarantineHookEvents: (destination, rejections, quarantinedAtMs = Date.now()) => {
+        validateHookDestination(destination);
+        const uniqueRejections = [
+          ...new Map(
+            rejections.map((rejection) => [rejection.syncId, rejection])
+          ).values()
+        ];
+        if (uniqueRejections.length === 0) return 0;
+        if (uniqueRejections.length > MAX_HOOK_OUTBOX_BATCH_SIZE) {
+          throw new Error(
+            `Cannot quarantine more than ${MAX_HOOK_OUTBOX_BATCH_SIZE} hook events at once`
+          );
+        }
+        requireTimestamp(quarantinedAtMs, "Hook event quarantine timestamp");
+        for (const rejection of uniqueRejections) {
+          requireBoundedString(
+            rejection.syncId,
+            "Hook event sync ID",
+            MAX_HOOK_SYNC_ID_BYTES
+          );
+          requireBoundedString(
+            rejection.reason,
+            "Hook event rejection reason",
+            MAX_HOOK_REJECTION_REASON_BYTES
+          );
+        }
+        return runImmediateWithSpoolRepair(() => {
+          let quarantined = 0;
+          for (const rejection of uniqueRejections) {
+            const reasonBytes = utf8Bytes(rejection.reason);
+            const inserted = quarantineHookEvent.run(
+              rejection.reason,
+              quarantinedAtMs,
+              reasonBytes,
+              destination.targetUrl,
+              destination.destinationIdentity,
+              rejection.syncId
+            ).changes;
+            if (inserted === 0) continue;
+            quarantined += deletePendingHookEvent.run(
+              destination.targetUrl,
+              destination.destinationIdentity,
+              rejection.syncId
+            ).changes;
+            adjustHookSpoolBytes.run(reasonBytes);
+          }
+          enforceHookQuarantineAge(Date.now(), true);
+          enforceHookSpoolLimit(quarantinedAtMs);
+          return quarantined;
+        });
+      },
+      countQuarantinedHookEvents: () => {
+        if (maxHookQuarantineAgeMs !== void 0) {
+          runImmediateTransaction(() => enforceHookQuarantineAge(Date.now()));
+        }
+        const count = countQuarantinedHookEvents.get()?.count;
+        if (typeof count !== "number" || !Number.isSafeInteger(count)) {
+          throw new Error("FML observer hook quarantine count is invalid");
+        }
+        return count;
+      },
+      getHookSpoolStatus: () => {
+        const readStatus = () => {
+          const row = readHookSpoolState();
+          const lastEvictedAtMs = row?.last_evicted_at_ms;
+          if (lastEvictedAtMs !== null && lastEvictedAtMs !== void 0 && (typeof lastEvictedAtMs !== "number" || !Number.isSafeInteger(lastEvictedAtMs) || lastEvictedAtMs < 0 || lastEvictedAtMs > MAX_TIMESTAMP_MS)) {
+            throw new ObserverHookSpoolStateInvariantError(
+              "FML observer hook spool eviction timestamp is invalid"
+            );
+          }
+          return {
+            unit: "logical_bytes",
+            maxBytes: maxHookSpoolBytes ?? null,
+            quarantineMaxAgeMs: maxHookQuarantineAgeMs ?? null,
+            logicalBytes: requireSpoolInteger(row, "logical_bytes"),
+            evictedRecords: requireSpoolInteger(row, "evicted_records"),
+            evictedBytes: requireSpoolInteger(row, "evicted_bytes"),
+            evictedPendingRecords: requireSpoolInteger(
+              row,
+              "evicted_pending_records"
+            ),
+            evictedQuarantinedRecords: requireSpoolInteger(
+              row,
+              "evicted_quarantined_records"
+            ),
+            ...typeof lastEvictedAtMs === "number" ? { lastEvictedAtMs } : {}
+          };
+        };
+        try {
+          return readStatus();
+        } catch (error) {
+          if (!(error instanceof ObserverHookSpoolStateInvariantError)) {
+            throw error;
+          }
+          runImmediateTransaction(() => reconcileHookSpoolState.run());
+          return readStatus();
+        }
+      },
+      captureOtlpEnvelope: (envelope) => {
+        if (envelope.envelopeId !== void 0) {
+          requireBoundedString(
+            envelope.envelopeId,
+            "OTLP envelope ID",
+            MAX_OTLP_ENVELOPE_ID_BYTES
+          );
+        }
+        requireBoundedString(
+          envelope.observerInstanceId,
+          "OTLP observer instance ID",
+          MAX_OTLP_OBSERVER_INSTANCE_ID_BYTES
+        );
+        requireBoundedString(
+          envelope.observerVersion,
+          "OTLP observer version",
+          MAX_OTLP_OBSERVER_VERSION_BYTES
+        );
+        const signal = requireOtlpSignal(envelope.signal);
+        const contentType = requireOtlpContentType(envelope.contentType);
+        const contentEncoding = requireOtlpContentEncoding(
+          envelope.contentEncoding
+        );
+        if (!Buffer.isBuffer(envelope.body)) {
+          throw new Error("OTLP envelope body must be a Buffer");
+        }
+        if (envelope.body.byteLength > MAX_OTLP_ENVELOPE_BYTES) {
+          throw new Error(
+            `OTLP envelope body exceeds ${MAX_OTLP_ENVELOPE_BYTES} bytes`
+          );
+        }
+        if (envelope.sha256 !== void 0 && !/^[0-9a-f]{64}$/.test(envelope.sha256)) {
+          throw new Error(
+            "OTLP envelope SHA-256 must be 64 lowercase hexadecimal characters"
+          );
+        }
+        const capturedAtMs = envelope.capturedAtMs ?? Date.now();
+        requireTimestamp(capturedAtMs, "OTLP envelope capture timestamp");
+        if (envelope.destination) {
+          validateOtlpDestination(envelope.destination);
+        }
+        return runImmediateTransaction(() => {
+          let envelopeId = envelope.envelopeId;
+          if (envelopeId === void 0) {
+            for (let attempt = 0; attempt < 8; attempt += 1) {
+              const candidate = crypto2.randomUUID();
+              if (!findPendingOtlpEnvelope.get(candidate)) {
+                envelopeId = candidate;
+                break;
+              }
+            }
+            if (envelopeId === void 0) {
+              throw new Error("Unable to allocate a unique OTLP envelope ID");
+            }
+          } else if (envelope.destination !== void 0 && findPendingOtlpEnvelope.get(envelopeId)) {
+            return null;
+          }
+          const logicalBytes = otlpEnvelopeLogicalBytes(envelope, envelopeId);
+          const actualSha256 = crypto2.createHash("sha256").update(envelope.body).digest("hex");
+          if (envelope.sha256 !== void 0 && actualSha256 !== envelope.sha256) {
+            throw new Error("OTLP envelope SHA-256 does not match its body");
+          }
+          if (envelope.destination === void 0) {
+            recordOtlpDrop(
+              1,
+              logicalBytes,
+              envelope.body.byteLength,
+              capturedAtMs,
+              OWNERLESS_OTLP_DROP_REASON
+            );
+            return null;
+          }
+          if (logicalBytes > maxOtlpSpoolBytes) {
+            recordOtlpDrop(
+              1,
+              logicalBytes,
+              envelope.body.byteLength,
+              capturedAtMs,
+              OTLP_ENTRY_TOO_LARGE_DROP_REASON
+            );
+            return null;
+          }
+          const retainedBytes = requireSpoolInteger(
+            getOtlpSpoolState.get(),
+            "logical_bytes"
+          );
+          const bytesToFree = retainedBytes + logicalBytes - maxOtlpSpoolBytes;
+          if (bytesToFree > 0) {
+            const plan = otlpCapacityEvictionPlan.get(bytesToFree);
+            const evictedRecords = requireSpoolInteger(plan, "record_count");
+            const evictedLogicalBytes = requireSpoolInteger(
+              plan,
+              "logical_bytes"
+            );
+            const evictedBodyBytes = requireSpoolInteger(plan, "body_bytes");
+            if (evictedRecords === 0 || evictedLogicalBytes < bytesToFree || evictOldestPendingOtlpEnvelopes.run(evictedRecords).changes !== evictedRecords) {
+              throw new Error(
+                "FML observer OTLP spool accounting could not enforce its limit"
+              );
+            }
+            recordOtlpDrop(
+              evictedRecords,
+              evictedLogicalBytes,
+              evictedBodyBytes,
+              capturedAtMs,
+              OTLP_CAPACITY_DROP_REASON
+            );
+          }
+          captureOtlpEnvelope.run(
+            envelopeId,
+            envelope.observerInstanceId,
+            envelope.observerVersion,
+            signal,
+            contentType,
+            contentEncoding,
+            envelope.body,
+            actualSha256,
+            capturedAtMs,
+            envelope.destination.targetUrl,
+            envelope.destination.destinationIdentity,
+            envelope.destination.organizationId ?? null,
+            envelope.destination.organizationSlug ?? null,
+            logicalBytes
+          );
+          return envelopeId;
+        });
+      },
+      listPendingOtlpEnvelopes: (limit = DEFAULT_OTLP_OUTBOX_BATCH_SIZE) => {
+        validateOtlpBatchLimit(limit);
+        return listPendingOtlpEnvelopes.all(limit).map(otlpOutboxRecordFromRow);
+      },
+      claimPendingOtlpEnvelopes: (destination, limit = DEFAULT_OTLP_OUTBOX_BATCH_SIZE, eligibleAtMs = Date.now()) => {
+        validateOtlpDestination(destination);
+        validateOtlpBatchLimit(limit);
+        requireTimestamp(eligibleAtMs, "OTLP envelope eligibility timestamp");
+        return runImmediateTransaction(() => {
+          if (destination.organizationId !== void 0) {
+            claimOrganizationForOtlpEnvelopes.run(
+              destination.organizationId,
+              destination.organizationSlug,
+              destination.targetUrl,
+              destination.destinationIdentity
+            );
+          }
+          return listDestinationPendingOtlpEnvelopes.all(
+            destination.targetUrl,
+            destination.destinationIdentity,
+            destination.organizationId ?? null,
+            eligibleAtMs,
+            limit
+          ).map(otlpOutboxRecordFromRow);
+        });
+      },
+      deferOtlpEnvelopes: (destination, envelopeIds, nextAttemptAtMs) => {
+        validateOtlpDestination(destination);
+        requireTimestamp(
+          nextAttemptAtMs,
+          "OTLP envelope next-attempt timestamp"
+        );
+        const uniqueEnvelopeIds = [...new Set(envelopeIds)];
+        if (uniqueEnvelopeIds.length === 0) return 0;
+        if (uniqueEnvelopeIds.length > MAX_OTLP_OUTBOX_BATCH_SIZE) {
+          throw new Error(
+            `Cannot defer more than ${MAX_OTLP_OUTBOX_BATCH_SIZE} OTLP envelopes at once`
+          );
+        }
+        for (const envelopeId of uniqueEnvelopeIds) {
+          requireBoundedString(
+            envelopeId,
+            "OTLP envelope ID",
+            MAX_OTLP_ENVELOPE_ID_BYTES
+          );
+        }
+        return runImmediateTransaction(() => {
+          let deferred = 0;
+          for (const envelopeId of uniqueEnvelopeIds) {
+            deferred += deferDestinationPendingOtlpEnvelope.run(
+              nextAttemptAtMs,
+              destination.targetUrl,
+              destination.destinationIdentity,
+              destination.organizationId ?? null,
+              envelopeId
+            ).changes;
+          }
+          return deferred;
+        });
+      },
+      nextPendingOtlpAttemptAtMs: (destination) => {
+        validateOtlpDestination(destination);
+        const value = nextDestinationPendingOtlpAttempt.get(
+          destination.targetUrl,
+          destination.destinationIdentity,
+          destination.organizationId ?? null
+        )?.next_attempt_at_ms;
+        if (value === null || value === void 0) return void 0;
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+          throw new Error(
+            "FML observer OTLP outbox next-attempt timestamp is invalid"
+          );
+        }
+        return value;
+      },
+      countPendingOtlpEnvelopes: () => {
+        const count = countPendingOtlpEnvelopes.get()?.count;
+        if (typeof count !== "number" || !Number.isSafeInteger(count)) {
+          throw new Error("FML observer OTLP outbox count is invalid");
+        }
+        return count;
+      },
+      acknowledgeOtlpEnvelopes: (destination, envelopeIds) => {
+        validateOtlpDestination(destination);
+        const uniqueEnvelopeIds = [...new Set(envelopeIds)];
+        if (uniqueEnvelopeIds.length === 0) return 0;
+        if (uniqueEnvelopeIds.length > MAX_OTLP_OUTBOX_BATCH_SIZE) {
+          throw new Error(
+            `Cannot acknowledge more than ${MAX_OTLP_OUTBOX_BATCH_SIZE} OTLP envelopes at once`
+          );
+        }
+        for (const envelopeId of uniqueEnvelopeIds) {
+          requireBoundedString(
+            envelopeId,
+            "OTLP envelope ID",
+            MAX_OTLP_ENVELOPE_ID_BYTES
+          );
+        }
+        const placeholders = uniqueEnvelopeIds.map(() => "?").join(", ");
+        const acknowledge = database.prepare(`
+          DELETE FROM otlp_envelope_outbox
+          WHERE destination_url = ?
+            AND destination_identity = ?
+            AND destination_organization_id IS ?
+            AND envelope_id IN (${placeholders})
+        `);
+        return runImmediateTransaction(
+          () => acknowledge.run(
+            destination.targetUrl,
+            destination.destinationIdentity,
+            destination.organizationId ?? null,
+            ...uniqueEnvelopeIds
+          ).changes
+        );
+      },
+      dropOtlpEnvelopes: (destination, drops, droppedAtMs = Date.now()) => {
+        validateOtlpDestination(destination);
+        const uniqueDrops = [
+          ...new Map(drops.map((drop) => [drop.envelopeId, drop])).values()
+        ];
+        if (uniqueDrops.length === 0) return 0;
+        if (uniqueDrops.length > MAX_OTLP_OUTBOX_BATCH_SIZE) {
+          throw new Error(
+            `Cannot drop more than ${MAX_OTLP_OUTBOX_BATCH_SIZE} OTLP envelopes at once`
+          );
+        }
+        requireTimestamp(droppedAtMs, "OTLP drop timestamp");
+        for (const drop of uniqueDrops) {
+          requireBoundedString(
+            drop.envelopeId,
+            "OTLP envelope ID",
+            MAX_OTLP_ENVELOPE_ID_BYTES
+          );
+          requireBoundedString(
+            drop.reason,
+            "OTLP drop reason",
+            MAX_OTLP_DROP_REASON_BYTES
+          );
+        }
+        return runImmediateTransaction(() => {
+          let droppedRecords = 0;
+          let droppedLogicalBytes = 0;
+          let droppedBodyBytes = 0;
+          let lastDropReason = uniqueDrops[0].reason;
+          for (const drop of uniqueDrops) {
+            const row = getDestinationPendingOtlpEnvelopeAccounting.get(
+              destination.targetUrl,
+              destination.destinationIdentity,
+              destination.organizationId ?? null,
+              drop.envelopeId
+            );
+            if (row === void 0) continue;
+            const logicalBytes = requireSpoolInteger(row, "logical_bytes");
+            const bodyBytes = requireSpoolInteger(row, "body_bytes");
+            const deleted = deleteDestinationPendingOtlpEnvelope.run(
+              destination.targetUrl,
+              destination.destinationIdentity,
+              destination.organizationId ?? null,
+              drop.envelopeId
+            ).changes;
+            if (deleted !== 1) {
+              throw new Error("FML observer OTLP fenced drop was incomplete");
+            }
+            droppedRecords += 1;
+            droppedLogicalBytes += logicalBytes;
+            droppedBodyBytes += bodyBytes;
+            lastDropReason = drop.reason;
+          }
+          recordOtlpDrop(
+            droppedRecords,
+            droppedLogicalBytes,
+            droppedBodyBytes,
+            droppedAtMs,
+            lastDropReason
+          );
+          return droppedRecords;
+        });
+      },
+      getOtlpSpoolStatus: () => {
+        const row = getOtlpSpoolState.get();
+        const lastDroppedAtMs = row?.last_dropped_at_ms;
+        if (lastDroppedAtMs !== null && lastDroppedAtMs !== void 0 && (typeof lastDroppedAtMs !== "number" || !Number.isSafeInteger(lastDroppedAtMs) || lastDroppedAtMs < 0)) {
+          throw new Error("FML observer OTLP drop timestamp is invalid");
+        }
+        const lastDropReason = row?.last_drop_reason;
+        if (lastDropReason !== null && lastDropReason !== void 0 && typeof lastDropReason !== "string") {
+          throw new Error("FML observer OTLP drop reason is invalid");
+        }
+        return {
+          unit: "logical_bytes",
+          maxBytes: maxOtlpSpoolBytes,
+          logicalBytes: requireSpoolInteger(row, "logical_bytes"),
+          bodyBytes: requireSpoolInteger(row, "body_bytes"),
+          droppedRecords: requireSpoolInteger(row, "dropped_records"),
+          droppedLogicalBytes: requireSpoolInteger(
+            row,
+            "dropped_logical_bytes"
+          ),
+          droppedBodyBytes: requireSpoolInteger(row, "dropped_body_bytes"),
+          ...typeof lastDroppedAtMs === "number" ? { lastDroppedAtMs } : {},
+          ...typeof lastDropReason === "string" ? { lastDropReason } : {}
+        };
+      },
+      close: () => database.close()
+    };
+  } catch (error) {
+    try {
+      database.exec("ROLLBACK");
+    } catch {
+    }
+    database.close();
+    throw error;
+  }
+}
+
+// ../../packages/panopticon/src/observer/protocol.ts
+var OBSERVER_PROTOCOL_VERSION = 1;
+var OBSERVER_SERVICE_NAME = "fml-observer";
+function isObserverHealth(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return record.status === "ok" && record.service === OBSERVER_SERVICE_NAME && record.protocolVersion === OBSERVER_PROTOCOL_VERSION && typeof record.instanceId === "string" && record.instanceId.length > 0 && typeof record.pid === "number" && Number.isInteger(record.pid) && record.pid > 0 && typeof record.port === "number" && Number.isInteger(record.port) && record.port > 0 && typeof record.version === "string" && (record.capabilities === void 0 || Array.isArray(record.capabilities) && record.capabilities.every(
+    (capability2) => typeof capability2 === "string"
+  ));
+}
+
+// ../../packages/panopticon/src/observer/server.ts
+import http from "http";
+var MAX_HOOK_REQUEST_BODY_BYTES = 4 * 1024 * 1024;
+var LOOPBACK_HOST_HEADER_PATTERN = /^(?:127\.0\.0\.1|localhost|\[::1\])(?::(\d{1,5}))?$/iu;
+var HookRequestBodyError = class extends Error {
+  constructor(status, code) {
+    super(code);
+    this.status = status;
+    this.code = code;
+  }
+};
+var OtlpRequestBodyError = class extends Error {
+  constructor(status, rpcCode, message) {
+    super(message);
+    this.status = status;
+    this.rpcCode = rpcCode;
+  }
+};
+function isAllowedObserverHost(host) {
+  if (host === void 0) return false;
+  const match = LOOPBACK_HOST_HEADER_PATTERN.exec(host);
+  if (!match) return false;
+  const port = match[1];
+  if (port === void 0) return true;
+  const numericPort = Number(port);
+  return numericPort > 0 && numericPort <= 65535;
+}
+function writeJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(payload);
+}
+function readHookRequestBody(req) {
+  const contentLengthHeader = req.headers["content-length"];
+  if (contentLengthHeader !== void 0) {
+    if (!/^\d+$/.test(contentLengthHeader)) {
+      throw new HookRequestBodyError(400, "invalid_json");
+    }
+    if (Number(contentLengthHeader) > MAX_HOOK_REQUEST_BODY_BYTES) {
+      req.resume();
+      throw new HookRequestBodyError(413, "payload_too_large");
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let byteCount = 0;
+    let settled = false;
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      chunks.length = 0;
+      reject(error);
+    };
+    req.on("data", (chunk) => {
+      if (settled) return;
+      byteCount += chunk.byteLength;
+      if (byteCount > MAX_HOOK_REQUEST_BODY_BYTES) {
+        rejectOnce(new HookRequestBodyError(413, "payload_too_large"));
+        req.resume();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (settled) return;
+      settled = true;
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks, byteCount).toString("utf8")));
+      } catch {
+        reject(new HookRequestBodyError(400, "invalid_json"));
+      }
+    });
+    req.on("error", (error) => {
+      rejectOnce(error);
+    });
+    req.on("aborted", () => rejectOnce(new Error("hook request aborted")));
+  });
+}
+function getOtlpRoute(pathname) {
+  const directSignal = pathname.startsWith("/v1/") ? pathname.slice("/v1/".length) : void 0;
+  if (directSignal === "logs" || directSignal === "metrics" || directSignal === "traces") {
+    return { signal: directSignal };
+  }
+  const segments = pathname.split("/");
+  if (segments.length === 5 && segments[0] === "" && segments[1] === "otel" && segments[3] === "v1" && (segments[4] === "logs" || segments[4] === "metrics" || segments[4] === "traces")) {
+    try {
+      return {
+        signal: segments[4],
+        pathToken: decodeURIComponent(segments[2] ?? "")
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function parseOtlpContentType(header) {
+  const mediaType = header?.split(";", 1)[0]?.trim().toLowerCase();
+  if (mediaType === "application/json" || mediaType === "application/x-protobuf") {
+    return mediaType;
+  }
+  return void 0;
+}
+function parseOtlpContentEncoding(header) {
+  if (header === void 0) return "identity";
+  const encoding = header.trim().toLowerCase();
+  if (encoding === "identity" || encoding === "gzip") return encoding;
+  return void 0;
+}
+function encodeVarint(value) {
+  const bytes = [];
+  let remaining = value;
+  do {
+    let byte = remaining & 127;
+    remaining >>>= 7;
+    if (remaining > 0) byte |= 128;
+    bytes.push(byte);
+  } while (remaining > 0);
+  return Buffer.from(bytes);
+}
+function encodeProtobufStatus(code, message) {
+  const messageBytes = Buffer.from(message, "utf8");
+  return Buffer.concat([
+    Buffer.from([8]),
+    encodeVarint(code),
+    Buffer.from([18]),
+    encodeVarint(messageBytes.byteLength),
+    messageBytes
+  ]);
+}
+function writeOtlpError(res, status, contentType, rpcCode, message, extraHeaders = {}) {
+  const payload = contentType === "application/x-protobuf" ? encodeProtobufStatus(rpcCode, message) : Buffer.from(JSON.stringify({ code: rpcCode, message }), "utf8");
+  res.writeHead(status, {
+    "Content-Type": contentType,
+    "Content-Length": String(payload.byteLength),
+    ...extraHeaders
+  });
+  res.end(payload);
+}
+function writeOtlpSuccess(res, contentType) {
+  const payload = contentType === "application/x-protobuf" ? Buffer.alloc(0) : Buffer.from("{}", "utf8");
+  res.writeHead(200, {
+    "Content-Type": contentType,
+    "Content-Length": String(payload.byteLength)
+  });
+  res.end(payload);
+}
+function readOpaqueOtlpBody(req) {
+  const contentLengthHeader = req.headers["content-length"];
+  if (contentLengthHeader !== void 0) {
+    if (!/^\d+$/.test(contentLengthHeader)) {
+      req.resume();
+      throw new OtlpRequestBodyError(400, 3, "invalid content-length");
+    }
+    if (Number(contentLengthHeader) > MAX_OTLP_ENVELOPE_BYTES) {
+      req.resume();
+      throw new OtlpRequestBodyError(413, 8, "OTLP request exceeds 16 MiB");
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let byteCount = 0;
+    let settled = false;
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      chunks.length = 0;
+      reject(error);
+    };
+    req.on("data", (chunk) => {
+      if (settled) return;
+      byteCount += chunk.byteLength;
+      if (byteCount > MAX_OTLP_ENVELOPE_BYTES) {
+        req.resume();
+        rejectOnce(
+          new OtlpRequestBodyError(413, 8, "OTLP request exceeds 16 MiB")
+        );
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (settled) return;
+      settled = true;
+      resolve(Buffer.concat(chunks, byteCount));
+    });
+    req.on("aborted", () => rejectOnce(new Error("OTLP request aborted")));
+    req.on("error", rejectOnce);
+  });
+}
+async function handleOtlpRequest(req, res, opts, route, method) {
+  const responseContentType = parseOtlpContentType(req.headers["content-type"]) ?? "application/json";
+  const authenticated = route.pathToken === void 0 ? hasObserverBearerToken(req, opts.authToken) : isObserverAuthToken(route.pathToken, opts.authToken);
+  if (!authenticated) {
+    req.resume();
+    writeOtlpError(res, 401, responseContentType, 16, "unauthorized");
+    return;
+  }
+  if (method !== "POST") {
+    req.resume();
+    writeOtlpError(res, 405, responseContentType, 12, "method not allowed", {
+      Allow: "POST"
+    });
+    return;
+  }
+  const contentType = parseOtlpContentType(req.headers["content-type"]);
+  if (contentType === void 0) {
+    req.resume();
+    writeOtlpError(
+      res,
+      415,
+      "application/json",
+      3,
+      "content-type must be application/json or application/x-protobuf"
+    );
+    return;
+  }
+  const contentEncoding = parseOtlpContentEncoding(
+    req.headers["content-encoding"]
+  );
+  if (contentEncoding === void 0) {
+    req.resume();
+    writeOtlpError(
+      res,
+      415,
+      contentType,
+      12,
+      "content-encoding must be identity or gzip"
+    );
+    return;
+  }
+  if (opts.onOtlp === void 0) {
+    req.resume();
+    writeOtlpError(res, 503, contentType, 14, "OTLP capture is unavailable", {
+      "Retry-After": "1"
+    });
+    return;
+  }
+  const capturedAtMs = Date.now();
+  let body;
+  try {
+    body = await readOpaqueOtlpBody(req);
+  } catch (error) {
+    if (error instanceof OtlpRequestBodyError) {
+      writeOtlpError(
+        res,
+        error.status,
+        contentType,
+        error.rpcCode,
+        error.message
+      );
+      return;
+    }
+    writeOtlpError(res, 400, contentType, 3, "failed to read OTLP request");
+    return;
+  }
+  try {
+    const health = opts.getHealth();
+    await opts.onOtlp({
+      observerInstanceId: health.instanceId,
+      observerVersion: health.version,
+      signal: route.signal,
+      contentType,
+      contentEncoding,
+      body,
+      capturedAtMs
+    });
+  } catch (error) {
+    console.error("FML observer OTLP capture failed", error);
+    writeOtlpError(res, 503, contentType, 14, "OTLP capture failed", {
+      "Retry-After": "1"
+    });
+    return;
+  }
+  writeOtlpSuccess(res, contentType);
+}
+async function handleObserverRequest(req, res, opts) {
+  try {
+    if (!isAllowedObserverHost(req.headers.host)) {
+      writeJson(res, 403, { error: "invalid_host" });
+      return;
+    }
+    const pathname = new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+    const method = req.method ?? "GET";
+    if (pathname === "/health") {
+      if (method !== "GET") {
+        writeJson(res, 405, { error: "method_not_allowed" });
+        return;
+      }
+      writeJson(res, 200, opts.getHealth());
+      return;
+    }
+    const otlpRoute = getOtlpRoute(pathname);
+    if (otlpRoute !== void 0) {
+      await handleOtlpRequest(req, res, opts, otlpRoute, method);
+      return;
+    }
+    const knownProtectedPath = pathname === "/status" || pathname === "/sync/wake" || pathname === "/hooks" || pathname === "/control/stop";
+    if (!knownProtectedPath) {
+      writeJson(res, 404, { error: "not_found" });
+      return;
+    }
+    if (!requireObserverBearerToken(req, res, opts.authToken)) return;
+    if (pathname === "/status") {
+      if (method !== "GET") {
+        writeJson(res, 405, { error: "method_not_allowed" });
+        return;
+      }
+      writeJson(res, 200, await opts.getStatus());
+      return;
+    }
+    if (pathname === "/sync/wake") {
+      if (method !== "POST") {
+        writeJson(res, 405, { error: "method_not_allowed" });
+        return;
+      }
+      opts.onWake();
+      writeJson(res, 202, { ok: true });
+      return;
+    }
+    if (pathname === "/hooks") {
+      if (method !== "POST") {
+        writeJson(res, 405, { error: "method_not_allowed" });
+        return;
+      }
+      let payload;
+      try {
+        payload = await readHookRequestBody(req);
+      } catch (error) {
+        if (error instanceof HookRequestBodyError) {
+          writeJson(res, error.status, { error: error.code });
+          return;
+        }
+        throw error;
+      }
+      await opts.onHook(payload);
+      writeJson(res, 202, {});
+      return;
+    }
+    if (method !== "POST") {
+      writeJson(res, 405, { error: "method_not_allowed" });
+      return;
+    }
+    writeJson(res, 202, { ok: true });
+    setImmediate(() => {
+      try {
+        opts.onShutdown();
+      } catch (error) {
+        console.error("FML observer shutdown handler failed", error);
+      }
+    });
+  } catch (error) {
+    console.error("FML observer request handler failed", error);
+    if (!res.headersSent) {
+      writeJson(res, 500, { error: "internal_error" });
+    } else {
+      res.destroy();
+    }
+  }
+}
+function createObserverHttpServer(opts) {
+  return http.createServer(async (req, res) => {
+    await handleObserverRequest(req, res, opts);
+  });
+}
+
+// src/hooks/inbox.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/hooks/inbox-config.ts
+var BYTE_SUFFIXES = {
+  b: 1,
+  kib: 1024,
+  mib: 1024 * 1024,
+  gib: 1024 * 1024 * 1024
+};
+var MAX_BYTES_PATTERN = /^([1-9]\d*)(b|kib|mib|gib)?$/i;
+var POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;
+var DEFAULT_HOOK_INBOX_MAX_BYTES = 512 * 1024 * 1024;
+var DEFAULT_HOOK_INBOX_MAX_ENTRIES = 1e4;
+function parseHookInboxMaxBytes(configured) {
+  if (configured === void 0) return DEFAULT_HOOK_INBOX_MAX_BYTES;
+  const value = configured.trim();
+  if (value.toLowerCase() === "unbounded") return void 0;
+  const match = MAX_BYTES_PATTERN.exec(value);
+  if (!match) {
+    throw new Error(
+      "FML_HOOK_INBOX_MAX_BYTES must be `unbounded` or a positive integer optionally followed by B, KiB, MiB, or GiB"
+    );
+  }
+  const quantity = Number(match[1]);
+  const suffix = match[2]?.toLowerCase() ?? "b";
+  const bytes = quantity * BYTE_SUFFIXES[suffix];
+  if (!Number.isSafeInteger(bytes)) {
+    throw new Error("FML_HOOK_INBOX_MAX_BYTES exceeds the safe integer range");
+  }
+  return bytes;
+}
+function parseHookInboxMaxEntries(configured) {
+  if (configured === void 0) return DEFAULT_HOOK_INBOX_MAX_ENTRIES;
+  const value = configured.trim();
+  if (value.toLowerCase() === "unbounded") return void 0;
+  if (!POSITIVE_INTEGER_PATTERN.test(value)) {
+    throw new Error(
+      "FML_HOOK_INBOX_MAX_ENTRIES must be `unbounded` or a positive integer"
+    );
+  }
+  const entries = Number(value);
+  if (!Number.isSafeInteger(entries)) {
+    throw new Error(
+      "FML_HOOK_INBOX_MAX_ENTRIES exceeds the safe integer range"
+    );
+  }
+  return entries;
+}
+function hookInboxLimitsFromEnv(env = process.env) {
+  const maxBytes = parseHookInboxMaxBytes(env.FML_HOOK_INBOX_MAX_BYTES);
+  const maxEntries = parseHookInboxMaxEntries(env.FML_HOOK_INBOX_MAX_ENTRIES);
+  return {
+    ...maxBytes === void 0 ? {} : { maxBytes },
+    ...maxEntries === void 0 ? {} : { maxEntries }
+  };
+}
+
+// src/hooks/inbox.ts
+var HOOK_INBOX_SCHEMA_VERSION = 1;
+var MAX_HOOK_INBOX_ENTRY_BYTES = 16 * 1024 * 1024;
+var MAX_HOOK_INBOX_DRAIN_ENTRIES = 100;
+var MAX_HOOK_INBOX_DRAIN_CURSORS = 8;
+var INBOX_ID_PATTERN = /^\d{1,16}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var INBOX_TEMP_PATTERN = /^\.(\d{1,16}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/i;
+var SYNC_ID_MAX_BYTES = 1024;
+var STALE_INBOX_TEMP_AGE_MS = 5 * 60 * 1e3;
+var DRAIN_CURSOR_SAFETY_AGE_MS = STALE_INBOX_TEMP_AGE_MS;
+var INBOX_METADATA_KEY = "_fmlHookInbox";
+var RETIREMENT_STATE_FILE = ".retirement-state.json";
+var RETIREMENT_STATE_SCHEMA_VERSION = 1;
+var CAPACITY_STATE_FILE = ".capacity-state.json";
+var CAPACITY_LOCK_FILE = ".capacity.lock";
+var CAPACITY_STATE_SCHEMA_VERSION = 1;
+var CAPACITY_LOCK_WAIT_MS = 2e3;
+var CAPACITY_LOCK_POLL_MS = 5;
+var CAPACITY_LOCK_INITIALIZATION_GRACE_MS = 1e3;
+var CAPACITY_LOCK_STALE_MS = 5 * 60 * 1e3;
+var INBOX_STATE_TEMP_PATTERN = /^\.(?:capacity-state|retirement-state)\.json\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/iu;
+var ABANDONED_CAPACITY_LOCK_PATTERN = /^\.capacity\.lock\.stale\.(\d{1,16})\.[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var UNSUPPORTED_DIRECTORY_FSYNC_CODES = /* @__PURE__ */ new Set([
+  "EBADF",
+  "EINVAL",
+  "EISDIR",
+  "ENOTSUP",
+  "EOPNOTSUPP",
+  "EPERM"
+]);
+var HOOK_INBOX_DRAIN_CURSORS = /* @__PURE__ */ new Map();
+var HookInboxCapacityError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(
+      reason === "max_bytes" ? "FML hook inbox byte limit reached" : "FML hook inbox entry limit reached"
+    );
+    this.name = "HookInboxCapacityError";
+    this.reason = reason;
+  }
+};
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function validTimestamp(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= 864e13;
+}
+function validSyncId(value) {
+  return typeof value === "string" && value.length > 0 && !/[\u0000-\u001f\u007f]/u.test(value) && Buffer.byteLength(value, "utf8") <= SYNC_ID_MAX_BYTES;
+}
+function parseDestination(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord2(value)) return null;
+  const { targetUrl, destinationIdentity } = value;
+  if (typeof targetUrl !== "string" || targetUrl.length === 0 || Buffer.byteLength(targetUrl, "utf8") > 4096 || typeof destinationIdentity !== "string" || destinationIdentity.length === 0 || Buffer.byteLength(destinationIdentity, "utf8") > 4096) {
+    return null;
+  }
+  return { targetUrl, destinationIdentity };
+}
+function parseMetadata(value) {
+  if (!isRecord2(value)) return null;
+  if (typeof value.id !== "string" || !INBOX_ID_PATTERN.test(value.id) || !validSyncId(value.syncId) || !validTimestamp(value.capturedAtMs)) {
+    return null;
+  }
+  const destination = parseDestination(value.destination);
+  if (destination === null) return null;
+  const repository = value.repository;
+  if (repository !== void 0 && (typeof repository !== "string" || repository.length === 0 || Buffer.byteLength(repository, "utf8") > 4096)) {
+    return null;
+  }
+  return {
+    id: value.id,
+    syncId: value.syncId,
+    capturedAtMs: value.capturedAtMs,
+    ...repository === void 0 ? {} : { repository },
+    ...destination === void 0 ? {} : { destination }
+  };
+}
+function entryFileName(id) {
+  if (!INBOX_ID_PATTERN.test(id)) {
+    throw new Error("Invalid FML hook inbox entry ID");
+  }
+  return `${id}.json`;
+}
+function entryPath(inboxDir, id) {
+  return path3.join(inboxDir, entryFileName(id));
+}
+function enforceOwnerOnlyDirectory(inboxDir) {
+  fs3.mkdirSync(inboxDir, { recursive: true, mode: 448 });
+  try {
+    fs3.chmodSync(inboxDir, 448);
+  } catch {
+  }
+}
+function fsyncDirectory(inboxDir) {
+  if (process.platform === "win32") return;
+  let descriptor;
+  try {
+    descriptor = fs3.openSync(inboxDir, "r");
+    fs3.fsyncSync(descriptor);
+  } catch (error) {
+    const code = error.code;
+    if (code === void 0 || !UNSUPPORTED_DIRECTORY_FSYNC_CODES.has(code)) {
+      throw error;
+    }
+  } finally {
+    if (descriptor !== void 0) fs3.closeSync(descriptor);
+  }
+}
+async function fsyncDirectoryAsync(inboxDir) {
+  if (process.platform === "win32") return;
+  let descriptor;
+  try {
+    descriptor = await fs3.promises.open(inboxDir, "r");
+    await descriptor.sync();
+  } catch (error) {
+    const code = error.code;
+    if (code === void 0 || !UNSUPPORTED_DIRECTORY_FSYNC_CODES.has(code)) {
+      throw error;
+    }
+  } finally {
+    await descriptor?.close();
+  }
+}
+function defaultRetirementState() {
+  return {
+    schemaVersion: RETIREMENT_STATE_SCHEMA_VERSION,
+    retiredEntries: 0,
+    retiredBytes: 0
+  };
+}
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function saturatingAdd(left, right) {
+  return Math.min(Number.MAX_SAFE_INTEGER, left + right);
+}
+function parseCapacityRejectionReason(value) {
+  return value === "max_bytes" || value === "max_entries" ? value : void 0;
+}
+function parseNullablePositiveInteger(value) {
+  if (value === null) return null;
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function parsePendingCapacityMutation(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord2(value)) return null;
+  if (typeof value.fileName !== "string" || !value.fileName.endsWith(".json") || !INBOX_ID_PATTERN.test(value.fileName.slice(0, -5)) || !nonNegativeInteger(value.bytes) || !validTimestamp(value.startedAtMs)) {
+    return null;
+  }
+  let temporaryFileName;
+  if (value.temporaryFileName !== void 0) {
+    if (typeof value.temporaryFileName !== "string") return null;
+    const temporaryMatch = INBOX_TEMP_PATTERN.exec(value.temporaryFileName);
+    if (!temporaryMatch || temporaryMatch[1]?.toLowerCase() !== value.fileName.slice(0, -5).toLowerCase()) {
+      return null;
+    }
+    temporaryFileName = value.temporaryFileName;
+  }
+  return {
+    fileName: value.fileName,
+    ...temporaryFileName === void 0 ? {} : { temporaryFileName },
+    bytes: value.bytes,
+    startedAtMs: value.startedAtMs
+  };
+}
+function parseCapacityState(value) {
+  if (!isRecord2(value) || value.schemaVersion !== CAPACITY_STATE_SCHEMA_VERSION || !nonNegativeInteger(value.pendingEntries) || !nonNegativeInteger(value.pendingBytes) || !nonNegativeInteger(value.rejectedEntries) || !nonNegativeInteger(value.rejectedBytes)) {
+    return null;
+  }
+  const maxEntries = parseNullablePositiveInteger(value.maxEntries);
+  const maxBytes = parseNullablePositiveInteger(value.maxBytes);
+  const pendingPersist = parsePendingCapacityMutation(value.pendingPersist);
+  const pendingRemoval = parsePendingCapacityMutation(value.pendingRemoval);
+  if (maxEntries === void 0 || maxBytes === void 0 || pendingPersist === null || pendingRemoval === null || pendingPersist !== void 0 && pendingRemoval !== void 0) {
+    return null;
+  }
+  const lastRejectionReason = parseCapacityRejectionReason(
+    value.lastRejectionReason
+  );
+  return {
+    schemaVersion: CAPACITY_STATE_SCHEMA_VERSION,
+    pendingEntries: value.pendingEntries,
+    pendingBytes: value.pendingBytes,
+    rejectedEntries: value.rejectedEntries,
+    rejectedBytes: value.rejectedBytes,
+    maxEntries,
+    maxBytes,
+    ...validTimestamp(value.lastRejectedAtMs) ? { lastRejectedAtMs: value.lastRejectedAtMs } : {},
+    ...lastRejectionReason === void 0 ? {} : { lastRejectionReason },
+    ...pendingPersist === void 0 ? {} : { pendingPersist },
+    ...pendingRemoval === void 0 ? {} : { pendingRemoval }
+  };
+}
+function capacityStatePath(inboxDir) {
+  return path3.join(inboxDir, CAPACITY_STATE_FILE);
+}
+function readCapacityStateFile(inboxDir) {
+  try {
+    return parseCapacityState(
+      JSON.parse(
+        fs3.readFileSync(capacityStatePath(inboxDir), "utf8")
+      )
+    );
+  } catch {
+    return null;
+  }
+}
+function defaultCapacityState(limits, pendingEntries, pendingBytes) {
+  return {
+    schemaVersion: CAPACITY_STATE_SCHEMA_VERSION,
+    pendingEntries,
+    pendingBytes,
+    rejectedEntries: 0,
+    rejectedBytes: 0,
+    maxEntries: limits.maxEntries ?? null,
+    maxBytes: limits.maxBytes ?? null
+  };
+}
+function writeCapacityState(inboxDir, state, capacityLock) {
+  enforceOwnerOnlyDirectory(inboxDir);
+  capacityLock.assertOwned();
+  const destination = capacityStatePath(inboxDir);
+  const temporary = path3.join(
+    inboxDir,
+    `${CAPACITY_STATE_FILE}.${process.pid}.${randomUUID2()}.tmp`
+  );
+  let descriptor;
+  try {
+    descriptor = fs3.openSync(temporary, "wx", 384);
+    fs3.writeFileSync(descriptor, `${JSON.stringify(state)}
+`, "utf8");
+    fs3.fsyncSync(descriptor);
+    capacityLock.assertOwned();
+    fs3.closeSync(descriptor);
+    descriptor = void 0;
+    fs3.renameSync(temporary, destination);
+    fsyncDirectory(inboxDir);
+    capacityLock.assertOwned();
+  } catch (error) {
+    if (descriptor !== void 0) fs3.closeSync(descriptor);
+    try {
+      fs3.rmSync(temporary, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function capacityLockIsOwned(lockPath, descriptor, ownerToken) {
+  try {
+    const openStat = fs3.fstatSync(descriptor);
+    const pathStat = fs3.statSync(lockPath);
+    if (openStat.dev !== pathStat.dev || openStat.ino !== pathStat.ino) {
+      return false;
+    }
+    const value = JSON.parse(fs3.readFileSync(lockPath, "utf8"));
+    return isRecord2(value) && value.ownerToken === ownerToken;
+  } catch {
+    return false;
+  }
+}
+function parseCapacityLockOwner(value) {
+  if (!isRecord2(value) || typeof value.ownerToken !== "string" || value.ownerToken.length === 0 || typeof value.pid !== "number" || !Number.isSafeInteger(value.pid) || value.pid <= 0 || !validTimestamp(value.createdAtMs)) {
+    return null;
+  }
+  return {
+    ownerToken: value.ownerToken,
+    pid: value.pid,
+    createdAtMs: value.createdAtMs
+  };
+}
+function readCapacityLockOwner(lockPath) {
+  try {
+    return parseCapacityLockOwner(
+      JSON.parse(fs3.readFileSync(lockPath, "utf8"))
+    );
+  } catch {
+    return null;
+  }
+}
+function capacityLockOwnerIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") return false;
+    return true;
+  }
+}
+function restoreMovedCapacityLock(abandonedPath, lockPath) {
+  try {
+    fs3.renameSync(abandonedPath, lockPath);
+  } catch (error) {
+    if (!capacityLockRaceError(error)) throw error;
+  }
+}
+function capacityLockRaceError(error) {
+  const code = error.code;
+  return code === "ENOENT" || code === "EEXIST" || code === "EACCES" || code === "EPERM" || code === "EBUSY";
+}
+function recoverStaleCapacityLock(lockPath, nowMs) {
+  let observed;
+  try {
+    observed = fs3.statSync(lockPath);
+  } catch (error) {
+    if (capacityLockRaceError(error)) return;
+    throw error;
+  }
+  const ageMs = Math.max(0, nowMs - observed.mtimeMs);
+  if (ageMs < CAPACITY_LOCK_INITIALIZATION_GRACE_MS) return;
+  const observedOwner = readCapacityLockOwner(lockPath);
+  const beyondStaleHorizon = ageMs >= CAPACITY_LOCK_STALE_MS;
+  if (!beyondStaleHorizon && (!observedOwner || capacityLockOwnerIsAlive(observedOwner.pid))) {
+    return;
+  }
+  const abandoned = `${lockPath}.stale.${nowMs}.${randomUUID2()}`;
+  try {
+    fs3.renameSync(lockPath, abandoned);
+    const moved = fs3.statSync(abandoned);
+    if (moved.dev !== observed.dev || moved.ino !== observed.ino) {
+      restoreMovedCapacityLock(abandoned, lockPath);
+      return;
+    }
+    const movedOwner = readCapacityLockOwner(abandoned);
+    const ownerChanged = observedOwner ? !movedOwner || movedOwner.ownerToken !== observedOwner.ownerToken || movedOwner.pid !== observedOwner.pid : movedOwner !== null;
+    const ownerRevivedBeforeStaleHorizon = !beyondStaleHorizon && movedOwner !== null && capacityLockOwnerIsAlive(movedOwner.pid);
+    if (ownerChanged || ownerRevivedBeforeStaleHorizon) {
+      restoreMovedCapacityLock(abandoned, lockPath);
+      return;
+    }
+    fs3.rmSync(abandoned, { force: true });
+    fsyncDirectory(path3.dirname(lockPath));
+  } catch (error) {
+    if (!capacityLockRaceError(error)) throw error;
+  }
+}
+function sleepSync(milliseconds) {
+  const buffer = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(buffer), 0, 0, milliseconds);
+}
+function acquireCapacityLock(inboxDir, waitMs = CAPACITY_LOCK_WAIT_MS) {
+  enforceOwnerOnlyDirectory(inboxDir);
+  const lockPath = path3.join(inboxDir, CAPACITY_LOCK_FILE);
+  const deadlineMs = Date.now() + Math.max(0, waitMs);
+  while (true) {
+    let descriptor;
+    let ownerToken;
+    try {
+      descriptor = fs3.openSync(lockPath, "wx+", 384);
+      ownerToken = randomUUID2();
+      fs3.writeFileSync(
+        descriptor,
+        `${JSON.stringify({ ownerToken, pid: process.pid, createdAtMs: Date.now() })}
+`,
+        "utf8"
+      );
+      fs3.fsyncSync(descriptor);
+      let released = false;
+      const capacityLock = {
+        assertOwned() {
+          if (descriptor === void 0 || ownerToken === void 0 || !capacityLockIsOwned(lockPath, descriptor, ownerToken)) {
+            throw new Error("FML hook inbox capacity lock ownership was lost");
+          }
+        },
+        release() {
+          if (released) return;
+          released = true;
+          let releaseError;
+          try {
+            if (capacityLockIsOwned(lockPath, descriptor, ownerToken)) {
+              fs3.unlinkSync(lockPath);
+              fsyncDirectory(inboxDir);
+            }
+          } catch (error) {
+            releaseError = error;
+          }
+          try {
+            fs3.closeSync(descriptor);
+          } catch (error) {
+            releaseError ??= error;
+          }
+          if (releaseError !== void 0) throw releaseError;
+        }
+      };
+      capacityLock.assertOwned();
+      return capacityLock;
+    } catch (error) {
+      if (descriptor !== void 0) {
+        const removeOwnedLock = ownerToken !== void 0 && capacityLockIsOwned(lockPath, descriptor, ownerToken);
+        try {
+          fs3.closeSync(descriptor);
+        } catch {
+        }
+        if (removeOwnedLock) {
+          try {
+            fs3.rmSync(lockPath, { force: true });
+            fsyncDirectory(inboxDir);
+          } catch {
+          }
+        }
+      }
+      if (error.code !== "EEXIST") throw error;
+      const nowMs = Date.now();
+      recoverStaleCapacityLock(lockPath, nowMs);
+      if (nowMs >= deadlineMs) return null;
+      sleepSync(CAPACITY_LOCK_POLL_MS);
+    }
+  }
+}
+function capacityMutationEvidence(inboxDir, pending, includeTemporary) {
+  const { fileName } = pending;
+  const id = fileName.slice(0, -5);
+  const prefix = `.${id}.`;
+  const candidates = [];
+  if (includeTemporary && pending.temporaryFileName) {
+    candidates.push(path3.join(inboxDir, pending.temporaryFileName));
+  } else if (includeTemporary) {
+    try {
+      for (const name of fs3.readdirSync(inboxDir)) {
+        if (name.startsWith(prefix) && name.endsWith(".tmp")) {
+          candidates.push(path3.join(inboxDir, name));
+        }
+      }
+    } catch (error) {
+      return error.code === "ENOENT" ? { kind: "missing" } : { kind: "unavailable" };
+    }
+  }
+  candidates.push(path3.join(inboxDir, fileName));
+  let presentBytes;
+  for (const candidate of candidates) {
+    try {
+      const stat = fs3.lstatSync(candidate);
+      if (!stat.isFile() || presentBytes !== void 0) {
+        return { kind: "unavailable" };
+      }
+      presentBytes = stat.size;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        return { kind: "unavailable" };
+      }
+    }
+  }
+  return presentBytes === void 0 ? { kind: "missing" } : { kind: "present", bytes: presentBytes };
+}
+function replaceAccountedBytes(totalBytes, reservedBytes, actualBytes) {
+  const withoutReservation = Math.max(0, totalBytes - reservedBytes);
+  return saturatingAdd(withoutReservation, actualBytes);
+}
+function settleCapacityState(inboxDir, state) {
+  if (state.pendingPersist) {
+    const pending = state.pendingPersist;
+    const evidence = capacityMutationEvidence(inboxDir, pending, true);
+    if (evidence.kind === "unavailable") {
+      throw new Error(
+        `FML hook inbox capacity evidence is unavailable for ${pending.fileName}`
+      );
+    }
+    const survives = evidence.kind === "present";
+    return {
+      ...state,
+      pendingEntries: Math.max(0, state.pendingEntries - (survives ? 0 : 1)),
+      pendingBytes: survives ? replaceAccountedBytes(
+        state.pendingBytes,
+        pending.bytes,
+        evidence.bytes
+      ) : Math.max(0, state.pendingBytes - pending.bytes),
+      pendingPersist: void 0
+    };
+  }
+  if (state.pendingRemoval) {
+    const pending = state.pendingRemoval;
+    const evidence = capacityMutationEvidence(inboxDir, pending, false);
+    if (evidence.kind === "unavailable") {
+      throw new Error(
+        `FML hook inbox capacity evidence is unavailable for ${pending.fileName}`
+      );
+    }
+    if (evidence.kind === "present") {
+      return {
+        ...state,
+        pendingEntries: state.pendingEntries + 1,
+        pendingBytes: saturatingAdd(state.pendingBytes, evidence.bytes),
+        pendingRemoval: void 0
+      };
+    }
+    return { ...state, pendingRemoval: void 0 };
+  }
+  return state;
+}
+function loadCapacityState(inboxDir, limits) {
+  const existing = readCapacityStateFile(inboxDir);
+  if (!existing) {
+    const current = pendingInboxSize(inboxDir, true);
+    return defaultCapacityState(
+      limits,
+      current.pendingEntries,
+      current.pendingBytes
+    );
+  }
+  const settled = settleCapacityState(inboxDir, existing);
+  return {
+    ...settled,
+    maxEntries: limits.maxEntries ?? null,
+    maxBytes: limits.maxBytes ?? null
+  };
+}
+function maintenanceCapacityLimits(inboxDir) {
+  const current = readCapacityStateFile(inboxDir);
+  if (current) {
+    return {
+      ...current.maxEntries === null ? {} : { maxEntries: current.maxEntries },
+      ...current.maxBytes === null ? {} : { maxBytes: current.maxBytes }
+    };
+  }
+  try {
+    return hookInboxLimitsFromEnv();
+  } catch {
+    return {};
+  }
+}
+function removeCapacityTrackedEntry(filePath, inboxDir, expectedBytes, missingIsSuccess = false) {
+  const capacityLock = acquireCapacityLock(inboxDir, 0);
+  if (!capacityLock) return false;
+  try {
+    let state = loadCapacityState(
+      inboxDir,
+      maintenanceCapacityLimits(inboxDir)
+    );
+    let bytes = expectedBytes;
+    try {
+      const stat = fs3.lstatSync(filePath);
+      if (!stat.isFile()) return false;
+      bytes = stat.size;
+    } catch (error) {
+      if (error.code !== "ENOENT") return false;
+      return missingIsSuccess;
+    }
+    if (bytes === void 0) return false;
+    const pendingRemoval = {
+      fileName: path3.basename(filePath),
+      bytes,
+      startedAtMs: Date.now()
+    };
+    state = {
+      ...state,
+      pendingEntries: Math.max(0, state.pendingEntries - 1),
+      pendingBytes: Math.max(0, state.pendingBytes - bytes),
+      pendingRemoval
+    };
+    writeCapacityState(inboxDir, state, capacityLock);
+    capacityLock.assertOwned();
+    try {
+      fs3.unlinkSync(filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        try {
+          writeCapacityState(
+            inboxDir,
+            {
+              ...state,
+              pendingEntries: state.pendingEntries + 1,
+              pendingBytes: state.pendingBytes + bytes,
+              pendingRemoval: void 0
+            },
+            capacityLock
+          );
+        } catch {
+        }
+        return false;
+      }
+    }
+    try {
+      capacityLock.assertOwned();
+    } catch {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  } finally {
+    capacityLock.release();
+  }
+}
+function parseRetirementReason(value) {
+  return value === "malformed" || value === "terminal_rejected" ? value : void 0;
+}
+function parseRetirementState(value) {
+  if (!isRecord2(value) || value.schemaVersion !== RETIREMENT_STATE_SCHEMA_VERSION || !nonNegativeInteger(value.retiredEntries) || !nonNegativeInteger(value.retiredBytes)) {
+    return null;
+  }
+  let pending;
+  if (value.pending !== void 0) {
+    if (!isRecord2(value.pending)) return null;
+    const reason = parseRetirementReason(value.pending.reason);
+    if (typeof value.pending.fileName !== "string" || !value.pending.fileName.endsWith(".json") || !INBOX_ID_PATTERN.test(value.pending.fileName.slice(0, -5)) || !nonNegativeInteger(value.pending.bytes) || !validTimestamp(value.pending.retiredAtMs) || reason === void 0) {
+      return null;
+    }
+    pending = {
+      fileName: value.pending.fileName,
+      bytes: value.pending.bytes,
+      reason,
+      retiredAtMs: value.pending.retiredAtMs
+    };
+  }
+  const lastRetirementReason = parseRetirementReason(
+    value.lastRetirementReason
+  );
+  return {
+    schemaVersion: RETIREMENT_STATE_SCHEMA_VERSION,
+    retiredEntries: value.retiredEntries,
+    retiredBytes: value.retiredBytes,
+    ...validTimestamp(value.lastRetiredAtMs) ? { lastRetiredAtMs: value.lastRetiredAtMs } : {},
+    ...lastRetirementReason === void 0 ? {} : { lastRetirementReason },
+    ...pending === void 0 ? {} : { pending }
+  };
+}
+function readRetirementState(inboxDir) {
+  try {
+    return parseRetirementState(
+      JSON.parse(
+        fs3.readFileSync(path3.join(inboxDir, RETIREMENT_STATE_FILE), "utf8")
+      )
+    ) ?? defaultRetirementState();
+  } catch {
+    return defaultRetirementState();
+  }
+}
+function writeRetirementState(inboxDir, state) {
+  enforceOwnerOnlyDirectory(inboxDir);
+  const destination = path3.join(inboxDir, RETIREMENT_STATE_FILE);
+  const temporary = path3.join(
+    inboxDir,
+    `${RETIREMENT_STATE_FILE}.${process.pid}.${randomUUID2()}.tmp`
+  );
+  let descriptor;
+  try {
+    descriptor = fs3.openSync(temporary, "wx", 384);
+    fs3.writeFileSync(descriptor, `${JSON.stringify(state)}
+`, "utf8");
+    fs3.fsyncSync(descriptor);
+    fs3.closeSync(descriptor);
+    descriptor = void 0;
+    fs3.renameSync(temporary, destination);
+    fsyncDirectory(inboxDir);
+  } catch (error) {
+    if (descriptor !== void 0) fs3.closeSync(descriptor);
+    try {
+      fs3.rmSync(temporary, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function completePendingRetirement(inboxDir, state) {
+  const pending = state.pending;
+  if (!pending) return state;
+  if (!removeCapacityTrackedEntry(
+    path3.join(inboxDir, pending.fileName),
+    inboxDir,
+    pending.bytes,
+    true
+  )) {
+    return null;
+  }
+  const completed = {
+    schemaVersion: RETIREMENT_STATE_SCHEMA_VERSION,
+    retiredEntries: state.retiredEntries + 1,
+    retiredBytes: state.retiredBytes + pending.bytes,
+    lastRetiredAtMs: pending.retiredAtMs,
+    lastRetirementReason: pending.reason
+  };
+  try {
+    writeRetirementState(inboxDir, completed);
+    return completed;
+  } catch {
+    return null;
+  }
+}
+function retireEntry(filePath, reason, inboxDir) {
+  const current = completePendingRetirement(
+    inboxDir,
+    readRetirementState(inboxDir)
+  );
+  if (!current) return false;
+  let bytes;
+  try {
+    bytes = fs3.lstatSync(filePath).size;
+  } catch {
+    return false;
+  }
+  const pending = {
+    ...current,
+    pending: {
+      fileName: path3.basename(filePath),
+      bytes,
+      reason,
+      retiredAtMs: Date.now()
+    }
+  };
+  try {
+    writeRetirementState(inboxDir, pending);
+  } catch {
+    return false;
+  }
+  return completePendingRetirement(inboxDir, pending) !== null;
+}
+function createHookInboxEntry(request, event, destination, persistedAtMs = Date.now()) {
+  const capturedAtMs = event.capturedAtMs ?? persistedAtMs;
+  return {
+    schemaVersion: HOOK_INBOX_SCHEMA_VERSION,
+    // File ordering follows the local durable write, not an agent-supplied
+    // event timestamp that may be delayed or backdated behind a drain cursor.
+    id: `${persistedAtMs}-${randomUUID2()}`,
+    syncId: event.syncId,
+    capturedAtMs,
+    ...event.repository ? { repository: event.repository } : {},
+    request,
+    ...destination === void 0 ? {} : {
+      destination: {
+        targetUrl: destination.targetUrl,
+        destinationIdentity: destination.destinationIdentity
+      }
+    }
+  };
+}
+function persistHookInboxEntry(entry, inboxDir = FML_HOOK_INBOX_DIR, limits = hookInboxLimitsFromEnv(), capacityLockWaitMs = CAPACITY_LOCK_WAIT_MS) {
+  const parsed = parseHookInboxEntry(entry);
+  if (!parsed || parsed.id !== entry.id) {
+    throw new Error("Invalid FML hook inbox entry");
+  }
+  const serialized = `${JSON.stringify(entry)}
+`;
+  const serializedBytes = Buffer.byteLength(serialized, "utf8");
+  if (serializedBytes > MAX_HOOK_INBOX_ENTRY_BYTES) {
+    throw new Error(
+      `FML hook inbox entry exceeds ${MAX_HOOK_INBOX_ENTRY_BYTES} bytes`
+    );
+  }
+  enforceOwnerOnlyDirectory(inboxDir);
+  const capacityLock = acquireCapacityLock(inboxDir, capacityLockWaitMs);
+  if (!capacityLock) {
+    throw new Error("FML hook inbox admission is busy");
+  }
+  const destination = entryPath(inboxDir, entry.id);
+  const temporary = path3.join(
+    inboxDir,
+    `.${entry.id}.${process.pid}.${randomUUID2()}.tmp`
+  );
+  let descriptor;
+  let state;
+  try {
+    state = loadCapacityState(inboxDir, limits);
+  } catch (error) {
+    capacityLock.release();
+    throw error;
+  }
+  const rejectionReason = limits.maxEntries !== void 0 && state.pendingEntries + 1 > limits.maxEntries ? "max_entries" : limits.maxBytes !== void 0 && state.pendingBytes + serializedBytes > limits.maxBytes ? "max_bytes" : void 0;
+  if (rejectionReason) {
+    state = {
+      ...state,
+      rejectedEntries: saturatingAdd(state.rejectedEntries, 1),
+      rejectedBytes: saturatingAdd(state.rejectedBytes, serializedBytes),
+      lastRejectedAtMs: Date.now(),
+      lastRejectionReason: rejectionReason
+    };
+    try {
+      writeCapacityState(inboxDir, state, capacityLock);
+      throw new HookInboxCapacityError(rejectionReason);
+    } finally {
+      capacityLock.release();
+    }
+  }
+  try {
+    const pendingPersist = {
+      fileName: path3.basename(destination),
+      temporaryFileName: path3.basename(temporary),
+      bytes: serializedBytes,
+      startedAtMs: Date.now()
+    };
+    state = {
+      ...state,
+      pendingEntries: state.pendingEntries + 1,
+      pendingBytes: state.pendingBytes + serializedBytes,
+      pendingPersist
+    };
+    writeCapacityState(inboxDir, state, capacityLock);
+    capacityLock.assertOwned();
+    descriptor = fs3.openSync(temporary, "wx", 384);
+    fs3.writeFileSync(descriptor, serialized, "utf8");
+    fs3.fsyncSync(descriptor);
+    capacityLock.assertOwned();
+    fs3.closeSync(descriptor);
+    descriptor = void 0;
+    fs3.renameSync(temporary, destination);
+    try {
+      fs3.chmodSync(destination, 384);
+    } catch {
+    }
+    fsyncDirectory(inboxDir);
+    capacityLock.assertOwned();
+  } catch (error) {
+    if (descriptor !== void 0) fs3.closeSync(descriptor);
+    try {
+      fs3.rmSync(temporary, { force: true });
+    } catch {
+    }
+    if (state.pendingPersist) {
+      try {
+        const settled = settleCapacityState(inboxDir, state);
+        writeCapacityState(inboxDir, settled, capacityLock);
+      } catch {
+      }
+    }
+    throw error;
+  } finally {
+    capacityLock.release();
+  }
+}
+function hookInboxDeliveryPayload(entry) {
+  return {
+    ...entry.request,
+    [INBOX_METADATA_KEY]: {
+      id: entry.id,
+      syncId: entry.syncId,
+      capturedAtMs: entry.capturedAtMs,
+      ...entry.repository === void 0 ? {} : { repository: entry.repository },
+      ...entry.destination === void 0 ? {} : { destination: entry.destination }
+    }
+  };
+}
+function parseHookInboxMetadata(value) {
+  return isRecord2(value) ? parseMetadata(value[INBOX_METADATA_KEY]) : null;
+}
+function parseHookInboxEntry(value) {
+  if (!isRecord2(value) || value.schemaVersion !== HOOK_INBOX_SCHEMA_VERSION) {
+    return null;
+  }
+  const metadata = parseMetadata(value);
+  const request = parseHookCaptureRequest(value.request);
+  if (!metadata || !request) return null;
+  return {
+    schemaVersion: HOOK_INBOX_SCHEMA_VERSION,
+    ...metadata,
+    request
+  };
+}
+function sourceDeclaresForwardSchema(source) {
+  const match = /^\s*\{\s*"schemaVersion"\s*:\s*(\d+)/u.exec(source);
+  if (!match) return false;
+  const schemaVersion = Number(match[1]);
+  return Number.isSafeInteger(schemaVersion) && schemaVersion > HOOK_INBOX_SCHEMA_VERSION;
+}
+function readEntryResult(filePath) {
+  try {
+    const stat = fs3.lstatSync(filePath);
+    if (!stat.isFile()) {
+      return { kind: "malformed" };
+    }
+    if (stat.size > MAX_HOOK_INBOX_ENTRY_BYTES) {
+      return { kind: "unsupported_schema" };
+    }
+    const source = fs3.readFileSync(filePath, "utf8");
+    let value;
+    try {
+      value = JSON.parse(source);
+    } catch {
+      return sourceDeclaresForwardSchema(source) ? { kind: "unsupported_schema" } : { kind: "malformed" };
+    }
+    if (isRecord2(value) && typeof value.schemaVersion === "number" && Number.isSafeInteger(value.schemaVersion) && value.schemaVersion > HOOK_INBOX_SCHEMA_VERSION) {
+      return { kind: "unsupported_schema" };
+    }
+    const entry = parseHookInboxEntry(value);
+    return entry ? { kind: "valid", entry } : { kind: "malformed" };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { kind: "missing" };
+    }
+    return { kind: "failed" };
+  }
+}
+function readEntry(filePath) {
+  const result = readEntryResult(filePath);
+  return result.kind === "valid" ? result.entry : null;
+}
+function acknowledgeHookInboxEntry(metadata, inboxDir = FML_HOOK_INBOX_DIR) {
+  let filePath;
+  try {
+    filePath = entryPath(inboxDir, metadata.id);
+  } catch {
+    return false;
+  }
+  const entry = readEntry(filePath);
+  if (!entry || entry.id !== metadata.id || entry.syncId !== metadata.syncId || entry.capturedAtMs !== metadata.capturedAtMs) {
+    return false;
+  }
+  return removeCapacityTrackedEntry(filePath, inboxDir);
+}
+function isPendingEntryName(name) {
+  return name.endsWith(".json") && INBOX_ID_PATTERN.test(name.slice(0, -5));
+}
+function insertOldestEntryName(names, selected, name, maximumEntries) {
+  if (selected.has(name)) return;
+  if (names.length === maximumEntries && name > names[names.length - 1]) {
+    return;
+  }
+  let low = 0;
+  let high = names.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (names[middle] < name) low = middle + 1;
+    else high = middle;
+  }
+  names.splice(low, 0, name);
+  selected.add(name);
+  if (names.length > maximumEntries) {
+    selected.delete(names.pop());
+  }
+}
+async function scanDrainEntryNames(inboxDir, maximumEntries, skipThrough, excludedName, nowMs = Date.now()) {
+  const names = [];
+  const selected = /* @__PURE__ */ new Set();
+  let failed = 0;
+  let resetCursor = false;
+  let blockCursorAdvance = false;
+  let removedOrphan = false;
+  const cutoffMs = nowMs - STALE_INBOX_TEMP_AGE_MS;
+  const directory = await fs3.promises.opendir(inboxDir);
+  try {
+    for (let dirent = await directory.read(); dirent !== null; dirent = await directory.read()) {
+      const name = dirent.name;
+      const abandonedLockMatch = ABANDONED_CAPACITY_LOCK_PATTERN.exec(name);
+      if (INBOX_STATE_TEMP_PATTERN.test(name) || abandonedLockMatch !== null) {
+        try {
+          const orphanPath = path3.join(inboxDir, name);
+          const stat = await fs3.promises.lstat(orphanPath);
+          const abandonedAtMs = abandonedLockMatch ? Number(abandonedLockMatch[1]) : void 0;
+          const isStale = abandonedLockMatch ? validTimestamp(abandonedAtMs) && abandonedAtMs <= cutoffMs : stat.mtimeMs <= cutoffMs;
+          if (stat.isFile() && isStale) {
+            await fs3.promises.unlink(orphanPath);
+            removedOrphan = true;
+          }
+        } catch (error) {
+          if (error.code !== "ENOENT") failed += 1;
+        }
+        continue;
+      }
+      if (isPendingEntryName(name)) {
+        if (name !== excludedName && (!skipThrough || name > skipThrough)) {
+          insertOldestEntryName(names, selected, name, maximumEntries);
+        }
+        continue;
+      }
+      const match = INBOX_TEMP_PATTERN.exec(name);
+      const id = match?.[1];
+      if (!id) continue;
+      const destination = entryPath(inboxDir, id);
+      const destinationName = path3.basename(destination);
+      const temporary = path3.join(inboxDir, name);
+      try {
+        const stat = await fs3.promises.lstat(temporary);
+        if (!stat.isFile()) continue;
+        blockCursorAdvance = true;
+        if (skipThrough && destinationName <= skipThrough) resetCursor = true;
+        if (stat.mtimeMs > cutoffMs) continue;
+        let destinationExists = false;
+        try {
+          await fs3.promises.lstat(destination);
+          destinationExists = true;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        if (destinationExists) {
+          await fs3.promises.unlink(temporary);
+        } else {
+          await fs3.promises.rename(temporary, destination);
+          try {
+            await fs3.promises.chmod(destination, 384);
+          } catch {
+          }
+        }
+        const recoveredBehindCursor = !destinationExists && skipThrough !== void 0 && destinationName <= skipThrough;
+        if (recoveredBehindCursor) resetCursor = true;
+        if (destinationName !== excludedName && (recoveredBehindCursor || !skipThrough || destinationName > skipThrough)) {
+          insertOldestEntryName(
+            names,
+            selected,
+            destinationName,
+            maximumEntries
+          );
+        }
+        await fsyncDirectoryAsync(inboxDir);
+      } catch (error) {
+        blockCursorAdvance = true;
+        if (skipThrough && destinationName <= skipThrough) resetCursor = true;
+        if (error.code !== "ENOENT") failed += 1;
+      }
+    }
+  } finally {
+    await directory.close();
+  }
+  if (removedOrphan) {
+    try {
+      await fsyncDirectoryAsync(inboxDir);
+    } catch {
+      failed += 1;
+    }
+  }
+  return { names, failed, resetCursor, blockCursorAdvance };
+}
+function drainCursor(inboxDir) {
+  const key = path3.resolve(inboxDir);
+  const existing = HOOK_INBOX_DRAIN_CURSORS.get(key);
+  if (existing) {
+    HOOK_INBOX_DRAIN_CURSORS.delete(key);
+    HOOK_INBOX_DRAIN_CURSORS.set(key, existing);
+    return existing;
+  }
+  if (HOOK_INBOX_DRAIN_CURSORS.size >= MAX_HOOK_INBOX_DRAIN_CURSORS) {
+    const oldestKey = HOOK_INBOX_DRAIN_CURSORS.keys().next().value;
+    if (oldestKey !== void 0) HOOK_INBOX_DRAIN_CURSORS.delete(oldestKey);
+  }
+  const created = {};
+  HOOK_INBOX_DRAIN_CURSORS.set(key, created);
+  return created;
+}
+function inboxEntryTimestamp(fileName) {
+  const separator = fileName.indexOf("-");
+  if (separator <= 0) return null;
+  const timestamp = Number(fileName.slice(0, separator));
+  return validTimestamp(timestamp) ? timestamp : null;
+}
+function safeDrainCursor(cursor, nowMs) {
+  if (cursor.skipThrough && cursor.advancedAtMs !== void 0 && nowMs >= cursor.advancedAtMs) {
+    return cursor.skipThrough;
+  }
+  cursor.skipThrough = void 0;
+  cursor.advancedAtMs = void 0;
+  return void 0;
+}
+async function pendingInboxSizeAsync(inboxDir) {
+  let pendingEntries = 0;
+  let pendingBytes = 0;
+  const directory = await fs3.promises.opendir(inboxDir);
+  try {
+    for (let dirent = await directory.read(); dirent !== null; dirent = await directory.read()) {
+      if (!isPendingEntryName(dirent.name)) continue;
+      try {
+        const stat = await fs3.promises.lstat(path3.join(inboxDir, dirent.name));
+        if (stat.isFile()) {
+          pendingEntries += 1;
+          pendingBytes += stat.size;
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+  } finally {
+    await directory.close();
+  }
+  return { pendingEntries, pendingBytes };
+}
+function pendingInboxSize(inboxDir, includeTemporary = false) {
+  let pendingEntries = 0;
+  let pendingBytes = 0;
+  const directory = fs3.opendirSync(inboxDir);
+  try {
+    for (let dirent = directory.readSync(); dirent !== null; dirent = directory.readSync()) {
+      if (!isPendingEntryName(dirent.name) && !(includeTemporary && INBOX_TEMP_PATTERN.test(dirent.name))) {
+        continue;
+      }
+      try {
+        const stat = fs3.lstatSync(path3.join(inboxDir, dirent.name));
+        if (stat.isFile()) {
+          pendingEntries += 1;
+          pendingBytes += stat.size;
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+  } finally {
+    directory.closeSync();
+  }
+  return { pendingEntries, pendingBytes };
+}
+function retireHookInboxEntry(metadata, reason, inboxDir = FML_HOOK_INBOX_DIR) {
+  let filePath;
+  try {
+    filePath = entryPath(inboxDir, metadata.id);
+  } catch {
+    return false;
+  }
+  const entry = readEntry(filePath);
+  if (!entry || entry.syncId !== metadata.syncId || entry.capturedAtMs !== metadata.capturedAtMs) {
+    return false;
+  }
+  return retireEntry(filePath, reason, inboxDir);
+}
+function emptyHookInboxStatus(limits, unreadable) {
+  return {
+    pendingEntries: 0,
+    pendingBytes: 0,
+    maxEntries: limits.maxEntries ?? null,
+    maxBytes: limits.maxBytes ?? null,
+    capacityRejectedEntries: 0,
+    capacityRejectedBytes: 0,
+    retiredEntries: 0,
+    retiredBytes: 0,
+    unreadable
+  };
+}
+function readHookInboxStatus(inboxDir = FML_HOOK_INBOX_DIR) {
+  let limits;
+  try {
+    limits = hookInboxLimitsFromEnv();
+  } catch {
+    return emptyHookInboxStatus({}, true);
+  }
+  try {
+    const retirement = readRetirementState(inboxDir);
+    const { pendingBytes, pendingEntries } = pendingInboxSize(inboxDir);
+    const capacity = readCapacityStateFile(inboxDir) ?? defaultCapacityState(limits, pendingEntries, pendingBytes);
+    return {
+      pendingEntries,
+      pendingBytes,
+      maxEntries: limits.maxEntries ?? null,
+      maxBytes: limits.maxBytes ?? null,
+      capacityRejectedEntries: capacity.rejectedEntries,
+      capacityRejectedBytes: capacity.rejectedBytes,
+      ...capacity.lastRejectedAtMs === void 0 ? {} : { lastCapacityRejectedAtMs: capacity.lastRejectedAtMs },
+      ...capacity.lastRejectionReason === void 0 ? {} : { lastCapacityRejectionReason: capacity.lastRejectionReason },
+      retiredEntries: retirement.retiredEntries,
+      retiredBytes: retirement.retiredBytes,
+      unreadable: false
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return emptyHookInboxStatus(limits, false);
+    }
+    return emptyHookInboxStatus(limits, true);
+  }
+}
+async function readHookInboxStatusAsync(inboxDir = FML_HOOK_INBOX_DIR) {
+  let limits;
+  try {
+    limits = hookInboxLimitsFromEnv();
+  } catch {
+    return emptyHookInboxStatus({}, true);
+  }
+  try {
+    const retirement = readRetirementState(inboxDir);
+    const { pendingBytes, pendingEntries } = await pendingInboxSizeAsync(inboxDir);
+    const capacity = readCapacityStateFile(inboxDir) ?? defaultCapacityState(limits, pendingEntries, pendingBytes);
+    return {
+      pendingEntries,
+      pendingBytes,
+      maxEntries: limits.maxEntries ?? null,
+      maxBytes: limits.maxBytes ?? null,
+      capacityRejectedEntries: capacity.rejectedEntries,
+      capacityRejectedBytes: capacity.rejectedBytes,
+      ...capacity.lastRejectedAtMs === void 0 ? {} : { lastCapacityRejectedAtMs: capacity.lastRejectedAtMs },
+      ...capacity.lastRejectionReason === void 0 ? {} : { lastCapacityRejectionReason: capacity.lastRejectionReason },
+      retiredEntries: retirement.retiredEntries,
+      retiredBytes: retirement.retiredBytes,
+      unreadable: false
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return emptyHookInboxStatus(limits, false);
+    }
+    return emptyHookInboxStatus(limits, true);
+  }
+}
+async function drainHookInbox(capture, inboxDir = FML_HOOK_INBOX_DIR) {
+  const retirement = readRetirementState(inboxDir);
+  const completedRetirement = completePendingRetirement(inboxDir, retirement);
+  let failed = completedRetirement === null ? 1 : 0;
+  const cursor = drainCursor(inboxDir);
+  const drainStartedAtMs = Date.now();
+  const skipThrough = safeDrainCursor(cursor, drainStartedAtMs);
+  const pendingRetirementName = completedRetirement === null ? retirement.pending?.fileName : void 0;
+  let drained = 0;
+  let rejected = 0;
+  let malformed = 0;
+  let unsupported = 0;
+  let names;
+  let effectiveSkipThrough = skipThrough;
+  let blockCursorAdvance = false;
+  try {
+    const scan = await scanDrainEntryNames(
+      inboxDir,
+      MAX_HOOK_INBOX_DRAIN_ENTRIES,
+      skipThrough,
+      pendingRetirementName
+    );
+    failed += scan.failed;
+    names = scan.names;
+    blockCursorAdvance = scan.blockCursorAdvance;
+    if (scan.resetCursor) {
+      cursor.skipThrough = void 0;
+      cursor.advancedAtMs = void 0;
+      effectiveSkipThrough = void 0;
+    }
+  } catch {
+    return {
+      drained,
+      rejected,
+      failed: failed + 1,
+      malformed,
+      unsupported
+    };
+  }
+  let cursorBlocked = blockCursorAdvance;
+  let safeThrough = effectiveSkipThrough;
+  let sawUnsupported = effectiveSkipThrough !== void 0;
+  const markResolved = (name, preservedUnsupported) => {
+    if (preservedUnsupported) sawUnsupported = true;
+    if (!sawUnsupported || cursorBlocked) return;
+    const timestamp = inboxEntryTimestamp(name);
+    if (timestamp === null || timestamp >= drainStartedAtMs - DRAIN_CURSOR_SAFETY_AGE_MS) {
+      cursorBlocked = true;
+      return;
+    }
+    safeThrough = name;
+  };
+  for (const name of names) {
+    const filePath = path3.join(inboxDir, name);
+    const readResult = readEntryResult(filePath);
+    if (readResult.kind === "missing") {
+      markResolved(name, false);
+      continue;
+    }
+    if (readResult.kind === "unsupported_schema") {
+      unsupported += 1;
+      markResolved(name, true);
+      continue;
+    }
+    if (readResult.kind === "failed") {
+      failed += 1;
+      cursorBlocked = true;
+      continue;
+    }
+    if (readResult.kind === "malformed") {
+      if (retireEntry(filePath, "malformed", inboxDir)) {
+        malformed += 1;
+        markResolved(name, false);
+      } else {
+        failed += 1;
+        cursorBlocked = true;
+      }
+      continue;
+    }
+    const { entry } = readResult;
+    try {
+      const outcome = capture(entry);
+      if (outcome === "retry") {
+        failed += 1;
+        cursorBlocked = true;
+        continue;
+      }
+      if (outcome === "terminal_rejected") {
+        if (retireEntry(filePath, "terminal_rejected", inboxDir)) {
+          rejected += 1;
+          markResolved(name, false);
+        } else {
+          failed += 1;
+          cursorBlocked = true;
+        }
+        continue;
+      }
+      if (acknowledgeHookInboxEntry(entry, inboxDir)) {
+        drained += 1;
+        markResolved(name, false);
+      } else {
+        failed += 1;
+        cursorBlocked = true;
+      }
+    } catch {
+      failed += 1;
+      cursorBlocked = true;
+    }
+  }
+  if (safeThrough !== effectiveSkipThrough) {
+    cursor.skipThrough = safeThrough;
+    cursor.advancedAtMs = drainStartedAtMs;
+  }
+  return { drained, rejected, failed, malformed, unsupported };
+}
+
+export {
+  readObserverAuthToken,
+  getOrCreateObserverAuthToken,
+  HOOK_TARGETS,
+  CODEX_HOOK_EVENTS,
+  GEMINI_HOOK_EVENTS,
+  GROK_HOOK_EVENTS,
+  parseHookCaptureRequest,
+  normalizeObserverHookCapture,
+  ObserverHookSpoolEntryTooLargeError,
+  openObserverDatabase,
+  OBSERVER_PROTOCOL_VERSION,
+  OBSERVER_SERVICE_NAME,
+  isObserverHealth,
+  createObserverHttpServer,
+  createHookInboxEntry,
+  persistHookInboxEntry,
+  hookInboxDeliveryPayload,
+  parseHookInboxMetadata,
+  acknowledgeHookInboxEntry,
+  retireHookInboxEntry,
+  readHookInboxStatus,
+  readHookInboxStatusAsync,
+  drainHookInbox
+};