@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/routes/lifeops-routes.js

@@ -0,0 +1,2337 @@
+import {
+  checkRateLimit,
+  createIntegrationTelemetrySpan
+} from "@elizaos/agent";
+import { handleCalendarRoutes } from "@elizaos/plugin-calendar/routes/calendar-routes";
+import {
+  logger,
+  requireConfirmation
+} from "@elizaos/core";
+import {
+  LIFEOPS_SCHEDULE_STATE_SCOPES
+} from "@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-contracts";
+import {
+  LIFEOPS_ACTIVITY_SIGNAL_STATES,
+  LIFEOPS_CONNECTOR_MODES,
+  LIFEOPS_CONNECTOR_SIDES,
+  LIFEOPS_GMAIL_SPAM_REVIEW_STATUSES,
+  LIFEOPS_HEALTH_CONNECTOR_PROVIDERS,
+  LIFEOPS_INBOX_CACHE_MODES,
+  LIFEOPS_INBOX_CHANNELS,
+  LIFEOPS_SCREEN_TIME_RANGES
+} from "../contracts/index.js";
+import {
+  loadLifeOpsAppState,
+  saveLifeOpsAppState
+} from "../lifeops/app-state.js";
+import {
+  FinancesService,
+  sanitizePaymentSourceForClient
+} from "@elizaos/plugin-finances/finances-service";
+import { FinancesServiceError } from "@elizaos/plugin-finances/finance-normalize";
+import { probeFullDiskAccess } from "../lifeops/fda-probe.js";
+import { LifeOpsRepository } from "../lifeops/repository.js";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+function requireAuthorizedRouteContext(ctx) {
+  if (!ctx.state.runtime) {
+    ctx.error(ctx.res, "Agent runtime is not available", 503);
+    return false;
+  }
+  return true;
+}
+function getService(ctx) {
+  if (!requireAuthorizedRouteContext(ctx)) {
+    return null;
+  }
+  const runtime = ctx.state.runtime;
+  if (!runtime) {
+    return null;
+  }
+  return new LifeOpsService(runtime, {
+    ownerEntityId: ctx.state.adminEntityId
+  });
+}
+function getFinancesService(ctx) {
+  if (!requireAuthorizedRouteContext(ctx)) {
+    return null;
+  }
+  const runtime = ctx.state.runtime;
+  if (!runtime) {
+    return null;
+  }
+  return new FinancesService(runtime, {
+    ownerEntityId: ctx.state.adminEntityId
+  });
+}
+const LIFEOPS_RATE_LIMITS = {
+  google_api_read: { maxRequests: 120, windowMs: 6e4 },
+  google_api_write: { maxRequests: 30, windowMs: 6e4 },
+  reminders_process: { maxRequests: 10, windowMs: 6e4 },
+  task_create: { maxRequests: 30, windowMs: 6e4 },
+  task_update: { maxRequests: 30, windowMs: 6e4 },
+  gmail_draft: { maxRequests: 20, windowMs: 6e4 },
+  // Tightened from 5/min: composing and sending email is the most sensitive
+  // outbound action LifeOps takes; cap the burst at 2/min so a bug or a
+  // confused operator cannot machine-gun the user's contacts.
+  gmail_send: { maxRequests: 2, windowMs: 6e4 },
+  calendar_create: { maxRequests: 20, windowMs: 6e4 },
+  calendar_update: { maxRequests: 20, windowMs: 6e4 },
+  calendar_delete: { maxRequests: 10, windowMs: 6e4 },
+  // OAuth + connector lifecycle: tight cap because these mutate stored
+  // credentials or initiate consent flows.
+  oauth_init: { maxRequests: 5, windowMs: 6e4 },
+  connector_write: { maxRequests: 10, windowMs: 6e4 },
+  // Generic outbound messaging (X DMs, iMessage, signal, telegram). Tighter
+  // than the default to limit blast radius.
+  outbound_message: { maxRequests: 5, windowMs: 6e4 },
+  default: { maxRequests: 60, windowMs: 6e4 }
+};
+const ACTIVITY_SIGNALS_DEFAULT_LIMIT = 200;
+const ACTIVITY_SIGNALS_MAX_LIMIT = 500;
+const MS_PER_DAY = 864e5;
+const MAX_SCREEN_TIME_WINDOW_DAYS = 31;
+const MAX_SCREEN_TIME_WINDOW_MS = MAX_SCREEN_TIME_WINDOW_DAYS * MS_PER_DAY;
+const routeSchemaBootstraps = /* @__PURE__ */ new WeakMap();
+async function ensureRouteSchema(runtime) {
+  if (!runtime) return;
+  const adapter = runtime.adapter;
+  if (!adapter || typeof adapter.runPluginMigrations !== "function") return;
+  if (typeof adapter.isReady === "function" && !await adapter.isReady()) {
+    return;
+  }
+  let bootstrap = routeSchemaBootstraps.get(runtime);
+  if (!bootstrap) {
+    bootstrap = LifeOpsRepository.bootstrapSchema(runtime).catch((error) => {
+      routeSchemaBootstraps.delete(runtime);
+      throw error;
+    });
+    routeSchemaBootstraps.set(runtime, bootstrap);
+  }
+  await bootstrap;
+}
+function rateLimitRequest(ctx, operation) {
+  const agentId = String(ctx.state.runtime?.agentId ?? "unknown");
+  const limitKey = `${agentId}:${operation}`;
+  const config = LIFEOPS_RATE_LIMITS[operation];
+  const { allowed, retryAfterMs } = checkRateLimit(limitKey, config);
+  if (!allowed) {
+    ctx.res.writeHead(429, {
+      "Retry-After": String(Math.ceil(retryAfterMs / 1e3))
+    });
+    ctx.res.end(JSON.stringify({ error: "Rate limit exceeded", retryAfterMs }));
+    return true;
+  }
+  return false;
+}
+function routeOperation(ctx) {
+  return `${ctx.method.toUpperCase()} ${ctx.pathname}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function occurrenceStateToTodoStatus(state) {
+  switch (state) {
+    case "snoozed":
+      return "in_progress";
+    case "completed":
+      return "completed";
+    default:
+      return "pending";
+  }
+}
+function decodeMatchedPathComponent(ctx, match, index, res, label) {
+  const raw = match?.[index];
+  return raw ? ctx.decodePathComponent(raw, res, label) : null;
+}
+function parseRouteInput(ctx, parser) {
+  try {
+    return parser();
+  } catch (error) {
+    if (error instanceof LifeOpsServiceError) {
+      ctx.error(ctx.res, error.message, error.status);
+      return null;
+    }
+    throw error;
+  }
+}
+function parsePositiveIntegerQuery(value, field, options = {}) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+  if (!/^\d+$/.test(normalized)) {
+    throw new LifeOpsServiceError(400, `${field} must be a positive integer`);
+  }
+  const parsed = Number.parseInt(normalized, 10);
+  if (parsed <= 0) {
+    throw new LifeOpsServiceError(400, `${field} must be a positive integer`);
+  }
+  if (options.max !== void 0 && parsed > options.max) {
+    throw new LifeOpsServiceError(
+      400,
+      `${field} must be less than or equal to ${options.max}`
+    );
+  }
+  return parsed;
+}
+function isOneOf(value, values) {
+  return values.some((allowed) => allowed === value);
+}
+function parseConnectorModeQuery(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (!isOneOf(normalized, LIFEOPS_CONNECTOR_MODES)) {
+    throw new LifeOpsServiceError(
+      400,
+      `mode must be one of: ${LIFEOPS_CONNECTOR_MODES.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function parseConnectorModeInput(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new LifeOpsServiceError(
+      400,
+      `mode must be one of: ${LIFEOPS_CONNECTOR_MODES.join(", ")}`
+    );
+  }
+  return parseConnectorModeQuery(value);
+}
+function parseConnectorSideQuery(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (!isOneOf(normalized, LIFEOPS_CONNECTOR_SIDES)) {
+    throw new LifeOpsServiceError(
+      400,
+      `side must be one of: ${LIFEOPS_CONNECTOR_SIDES.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function parseConnectorSideInput(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new LifeOpsServiceError(
+      400,
+      `side must be one of: ${LIFEOPS_CONNECTOR_SIDES.join(", ")}`
+    );
+  }
+  return parseConnectorSideQuery(value);
+}
+function parseConnectorSideFromRequest(url, body) {
+  const querySide = parseConnectorSideQuery(url.searchParams.get("side"));
+  const bodySide = parseConnectorSideInput(body?.side);
+  if (querySide && bodySide && querySide !== bodySide) {
+    throw new LifeOpsServiceError(
+      400,
+      "side must match between query string and request body"
+    );
+  }
+  return bodySide ?? querySide;
+}
+function parseHealthConnectorProvider(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!isOneOf(normalized, LIFEOPS_HEALTH_CONNECTOR_PROVIDERS)) {
+    throw new LifeOpsServiceError(
+      400,
+      `provider must be one of: ${LIFEOPS_HEALTH_CONNECTOR_PROVIDERS.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function parseOptionalHealthConnectorProvider(value) {
+  const normalized = value?.trim();
+  return normalized ? parseHealthConnectorProvider(normalized) : null;
+}
+function parseHealthConnectorProviderPath(ctx, match) {
+  return parseRouteInput(ctx, () => {
+    const provider = decodeMatchedPathComponent(
+      ctx,
+      match,
+      1,
+      ctx.res,
+      "provider"
+    );
+    return provider ? parseHealthConnectorProvider(provider) : null;
+  });
+}
+function parseDateOnlyQuery(value, field) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(normalized)) {
+    throw new LifeOpsServiceError(400, `${field} must be a YYYY-MM-DD date`);
+  }
+  return normalized;
+}
+function parseGmailSpamReviewStatusInput(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new LifeOpsServiceError(
+      400,
+      `${field} must be one of: ${LIFEOPS_GMAIL_SPAM_REVIEW_STATUSES.join(", ")}`
+    );
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (!isOneOf(normalized, LIFEOPS_GMAIL_SPAM_REVIEW_STATUSES)) {
+    throw new LifeOpsServiceError(
+      400,
+      `${field} must be one of: ${LIFEOPS_GMAIL_SPAM_REVIEW_STATUSES.join(", ")}`
+    );
+  }
+  return normalized;
+}
+function parseGmailSpamReviewStatusQuery(value) {
+  return parseGmailSpamReviewStatusInput(value, "status");
+}
+function parseBooleanQuery(value, field) {
+  if (value === null) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0") {
+    return false;
+  }
+  throw new LifeOpsServiceError(400, `${field} must be a boolean`);
+}
+function requireBodyString(body, field) {
+  const value = body[field];
+  if (typeof value !== "string") {
+    throw new LifeOpsServiceError(400, `${field} is required`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new LifeOpsServiceError(400, `${field} is required`);
+  }
+  return trimmed;
+}
+function parseOptionalBodyString(body, field) {
+  const value = body[field];
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new LifeOpsServiceError(400, `${field} must be a string`);
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function parseOptionalBodyBoolean(body, field) {
+  const value = body[field];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new LifeOpsServiceError(400, `${field} must be a boolean`);
+  }
+  return value;
+}
+function parseOptionalBodyStringArray(body, field) {
+  const value = body[field];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new LifeOpsServiceError(400, `${field} must be an array of strings`);
+  }
+  const parsed = value.map((entry) => {
+    if (typeof entry !== "string") {
+      throw new LifeOpsServiceError(
+        400,
+        `${field} must be an array of strings`
+      );
+    }
+    return entry.trim();
+  });
+  if (parsed.some((entry) => entry.length === 0)) {
+    throw new LifeOpsServiceError(
+      400,
+      `${field} must be an array of non-empty strings`
+    );
+  }
+  return parsed;
+}
+function parseActivitySignalStates(url) {
+  const rawValues = [
+    ...url.searchParams.getAll("state"),
+    ...url.searchParams.getAll("states").flatMap((value) => value.split(","))
+  ].map((value) => value.trim()).filter((value) => value.length > 0);
+  if (rawValues.length === 0) {
+    return null;
+  }
+  const states = [];
+  for (const value of rawValues) {
+    if (!isOneOf(value, LIFEOPS_ACTIVITY_SIGNAL_STATES)) {
+      throw new LifeOpsServiceError(
+        400,
+        `state must be one of: ${LIFEOPS_ACTIVITY_SIGNAL_STATES.join(", ")}`
+      );
+    }
+    states.push(value);
+  }
+  return states;
+}
+function parseScreenTimeSourceQuery(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized !== "app" && normalized !== "website") {
+    throw new LifeOpsServiceError(400, "source must be app or website");
+  }
+  return normalized;
+}
+function parseScreenTimeIdentifierQuery(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function parseScreenTimeRangeQuery(value) {
+  const normalized = value?.trim().toLowerCase() || "today";
+  if (!isOneOf(normalized, LIFEOPS_SCREEN_TIME_RANGES)) {
+    throw new LifeOpsServiceError(
+      400,
+      `range must be one of: ${LIFEOPS_SCREEN_TIME_RANGES.join(", ")}`
+    );
+  }
+  return normalized;
+}
+const ISO_INSTANT_QUERY_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+function parseRequiredIsoQuery(url, field) {
+  const value = url.searchParams.get(field)?.trim();
+  if (!value) {
+    throw new LifeOpsServiceError(400, `${field} is required`);
+  }
+  if (!ISO_INSTANT_QUERY_RE.test(value) || !Number.isFinite(Date.parse(value))) {
+    throw new LifeOpsServiceError(400, `${field} must be a valid ISO string`);
+  }
+  return value;
+}
+function parseOptionalIsoQuery(value, field) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return null;
+  }
+  if (!Number.isFinite(Date.parse(normalized))) {
+    throw new LifeOpsServiceError(400, `${field} must be a valid ISO string`);
+  }
+  return normalized;
+}
+function parseBoundedIsoWindowQuery(url) {
+  const since = parseRequiredIsoQuery(url, "since");
+  const until = parseRequiredIsoQuery(url, "until");
+  const sinceMs = Date.parse(since);
+  const untilMs = Date.parse(until);
+  if (untilMs <= sinceMs) {
+    throw new LifeOpsServiceError(400, "until must be after since");
+  }
+  if (untilMs - sinceMs > MAX_SCREEN_TIME_WINDOW_MS) {
+    throw new LifeOpsServiceError(
+      400,
+      `window must be ${MAX_SCREEN_TIME_WINDOW_DAYS} days or less`
+    );
+  }
+  return { since, until };
+}
+async function runRoute(ctx, fn) {
+  const operation = routeOperation(ctx);
+  const span = createIntegrationTelemetrySpan({
+    boundary: "lifeops",
+    operation
+  });
+  const service = getService(ctx);
+  if (!service) {
+    logger.info(
+      {
+        boundary: "lifeops",
+        operation,
+        statusCode: 503
+      },
+      "[lifeops] Route rejected because agent runtime is unavailable"
+    );
+    span.failure({
+      statusCode: 503,
+      errorKind: "runtime_unavailable"
+    });
+    return true;
+  }
+  try {
+    await ensureRouteSchema(ctx.state.runtime);
+    await fn(service);
+    span.success({
+      statusCode: ctx.res.statusCode >= 400 ? ctx.res.statusCode : 200
+    });
+    return true;
+  } catch (error) {
+    if (error instanceof LifeOpsServiceError) {
+      const logFn = error.status === 401 ? logger.debug.bind(logger) : logger.warn.bind(logger);
+      logFn(
+        {
+          boundary: "lifeops",
+          operation,
+          statusCode: error.status
+        },
+        `[lifeops] Route failed: ${error.message}`
+      );
+      span.failure({
+        statusCode: error.status,
+        error,
+        errorKind: error.status === 401 ? "lifeops_auth_invalid" : "lifeops_service_error"
+      });
+      ctx.error(ctx.res, error.message, error.status);
+      return true;
+    }
+    logger.error(
+      {
+        boundary: "lifeops",
+        operation
+      },
+      `[lifeops] Route crashed: ${errorMessage(error)}`
+    );
+    span.failure({
+      error,
+      errorKind: "unhandled_error"
+    });
+    throw error;
+  }
+}
+async function runFinancesRoute(ctx, fn) {
+  const operation = routeOperation(ctx);
+  const span = createIntegrationTelemetrySpan({
+    boundary: "lifeops",
+    operation
+  });
+  const service = getFinancesService(ctx);
+  if (!service) {
+    logger.info(
+      {
+        boundary: "lifeops",
+        operation,
+        statusCode: 503
+      },
+      "[lifeops] Route rejected because agent runtime is unavailable"
+    );
+    span.failure({
+      statusCode: 503,
+      errorKind: "runtime_unavailable"
+    });
+    return true;
+  }
+  try {
+    await ensureRouteSchema(ctx.state.runtime);
+    await fn(service);
+    span.success({
+      statusCode: ctx.res.statusCode >= 400 ? ctx.res.statusCode : 200
+    });
+    return true;
+  } catch (error) {
+    if (error instanceof FinancesServiceError) {
+      const logFn = error.status === 401 ? logger.debug.bind(logger) : logger.warn.bind(logger);
+      logFn(
+        {
+          boundary: "lifeops",
+          operation,
+          statusCode: error.status
+        },
+        `[lifeops] Route failed: ${error.message}`
+      );
+      span.failure({
+        statusCode: error.status,
+        error,
+        errorKind: error.status === 401 ? "lifeops_auth_invalid" : "lifeops_service_error"
+      });
+      ctx.error(ctx.res, error.message, error.status);
+      return true;
+    }
+    logger.error(
+      {
+        boundary: "lifeops",
+        operation
+      },
+      `[lifeops] Route crashed: ${errorMessage(error)}`
+    );
+    span.failure({
+      error,
+      errorKind: "unhandled_error"
+    });
+    throw error;
+  }
+}
+function parseConnectorRefreshDetailFromQuery(ctx, defaults) {
+  return parseRouteInput(ctx, () => ({
+    side: parseConnectorSideQuery(ctx.url.searchParams.get("side")) ?? defaults.side,
+    mode: parseConnectorModeQuery(ctx.url.searchParams.get("mode")) ?? defaults.mode
+  }));
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function serializeInlineScriptValue(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function writeHtml(res, status, title, message, refreshDetail) {
+  const refreshScript = refreshDetail ? `
+    <script>
+      (() => {
+        const payload = ${serializeInlineScriptValue({
+    type: "lifeops-google-connector-refresh",
+    detail: {
+      ...refreshDetail,
+      source: "callback"
+    }
+  })};
+        if (window.opener && typeof window.opener.postMessage === "function") {
+          window.opener.postMessage(payload, "*");
+        }
+        if (typeof BroadcastChannel === "function") {
+          for (const channelName of [
+            "elizaos:lifeops:google-connector",
+            "eliza:lifeops:google-connector",
+          ]) {
+            const channel = new BroadcastChannel(channelName);
+            channel.postMessage(payload);
+            channel.close();
+          }
+        }
+        if (typeof localStorage !== "undefined") {
+          for (const storageKey of [
+            "elizaos:lifeops:google-connector-refresh",
+            "eliza:lifeops:google-connector-refresh",
+          ]) {
+            localStorage.setItem(
+              storageKey,
+              JSON.stringify({
+                ...payload,
+                at: Date.now(),
+              }),
+            );
+            localStorage.removeItem(storageKey);
+          }
+        }
+      })();
+    </script>` : "";
+  res.statusCode = status;
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  res.end(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+    <style>
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        background: #f5f1e8;
+        color: #18120d;
+        font-family: "IBM Plex Sans", "Helvetica Neue", sans-serif;
+      }
+      main {
+        width: min(32rem, calc(100vw - 2rem));
+        padding: 2rem;
+        border: 1px solid rgba(24, 18, 13, 0.12);
+        border-radius: 1.25rem;
+        background: rgba(255, 255, 255, 0.92);
+        box-shadow: 0 24px 80px rgba(24, 18, 13, 0.08);
+      }
+      h1 {
+        margin: 0 0 0.75rem;
+        font-size: 1.25rem;
+      }
+      p {
+        margin: 0;
+        line-height: 1.5;
+        color: rgba(24, 18, 13, 0.78);
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${escapeHtml(title)}</h1>
+      <p>${escapeHtml(message)}</p>
+    </main>
+    ${refreshScript}
+    <script>
+      window.setTimeout(() => {
+        if (typeof window.close === "function") {
+          window.close();
+        }
+      }, 250);
+    </script>
+  </body>
+</html>`);
+}
+async function handleLifeOpsRoutes(ctx) {
+  const { req, res, method, pathname, url, json, readJsonBody } = ctx;
+  if (await handleCalendarRoutes({
+    method,
+    pathname,
+    url,
+    runRoute: (fn) => runRoute(ctx, fn),
+    rateLimit: (key) => rateLimitRequest(ctx, key),
+    json: (data, status) => json(res, data, status),
+    readJsonBody: () => readJsonBody(req, res),
+    decodePathComponent: (raw, label) => ctx.decodePathComponent(raw, res, label),
+    parseConnectorMode: (value) => parseConnectorModeQuery(value),
+    parseConnectorSide: (value) => parseConnectorSideQuery(value),
+    parseBoolean: (value, field) => parseBooleanQuery(value, field),
+    serviceError: (status, message) => new LifeOpsServiceError(status, message)
+  })) {
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/lifeops/app-state") {
+    if (!requireAuthorizedRouteContext(ctx)) return true;
+    const runtime = ctx.state.runtime;
+    if (!runtime) return true;
+    json(res, await loadLifeOpsAppState(runtime));
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/lifeops/features/toggle") {
+    if (!requireAuthorizedRouteContext(ctx)) return true;
+    if (rateLimitRequest(ctx, "default")) return true;
+    const runtime = ctx.state.runtime;
+    if (!runtime) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) {
+      return true;
+    }
+    const { getFeatureFlagRegistry } = await import("../lifeops/registries/feature-flag-registry.js");
+    const featureFlagRegistry = getFeatureFlagRegistry(runtime);
+    if (!featureFlagRegistry) {
+      ctx.error(res, "feature flag registry not initialized", 503);
+      return true;
+    }
+    if (typeof body.featureKey !== "string" || !featureFlagRegistry.has(body.featureKey)) {
+      ctx.error(
+        res,
+        `featureKey must be a registered feature flag (one of: ${featureFlagRegistry.list().map((c) => c.key).join(", ")})`,
+        400
+      );
+      return true;
+    }
+    if (typeof body.enabled !== "boolean") {
+      ctx.error(res, "enabled must be a boolean", 400);
+      return true;
+    }
+    const { createFeatureFlagService } = await import("../lifeops/feature-flags.js");
+    const service = createFeatureFlagService(runtime);
+    const next = body.enabled ? await service.enable(body.featureKey, "local", null) : await service.disable(body.featureKey, "local", null);
+    json(res, {
+      feature: {
+        featureKey: next.featureKey,
+        enabled: next.enabled,
+        source: next.source,
+        label: next.label,
+        description: next.description,
+        costsMoney: next.costsMoney,
+        enabledAt: next.enabledAt ? next.enabledAt.toISOString() : null,
+        enabledBy: next.enabledBy,
+        packageId: typeof next.metadata.packageId === "string" ? next.metadata.packageId : null
+      }
+    });
+    return true;
+  }
+  if (method === "PUT" && pathname === "/api/lifeops/app-state") {
+    if (!requireAuthorizedRouteContext(ctx)) return true;
+    if (rateLimitRequest(ctx, "default")) return true;
+    const runtime = ctx.state.runtime;
+    if (!runtime) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) {
+      return true;
+    }
+    if (typeof body.enabled !== "boolean") {
+      ctx.error(res, "enabled must be a boolean", 400);
+      return true;
+    }
+    const previous = await loadLifeOpsAppState(runtime);
+    let priorityScoring = previous.priorityScoring;
+    if (body.priorityScoring !== void 0) {
+      if (!body.priorityScoring || typeof body.priorityScoring !== "object" || Array.isArray(body.priorityScoring)) {
+        ctx.error(res, "priorityScoring must be an object", 400);
+        return true;
+      }
+      const ps = body.priorityScoring;
+      const enabled = typeof ps.enabled === "boolean" ? ps.enabled : priorityScoring.enabled;
+      let model = priorityScoring.model;
+      if (ps.model === null) {
+        model = null;
+      } else if (typeof ps.model === "string") {
+        const trimmed = ps.model.trim();
+        model = trimmed.length > 0 ? trimmed : null;
+      } else if (ps.model !== void 0) {
+        ctx.error(res, "priorityScoring.model must be a string or null", 400);
+        return true;
+      }
+      priorityScoring = { enabled, model };
+    }
+    try {
+      const saved = await saveLifeOpsAppState(runtime, {
+        enabled: body.enabled,
+        priorityScoring
+      });
+      json(res, saved);
+    } catch (error) {
+      ctx.error(
+        res,
+        `failed to persist LifeOps app state: ${error instanceof Error ? error.message : String(error)}`,
+        500
+      );
+    }
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/lifeops/gmail/triage") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const request = {
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        forceSync: parseBooleanQuery(
+          url.searchParams.get("forceSync"),
+          "forceSync"
+        ),
+        maxResults: parsePositiveIntegerQuery(
+          url.searchParams.get("maxResults"),
+          "maxResults"
+        ) ?? void 0,
+        grantId: url.searchParams.get("grantId") ?? void 0
+      };
+      json(res, await service.getGmailTriage(url, request));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/gmail/search") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const query = url.searchParams.get("query");
+      const request = {
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        forceSync: parseBooleanQuery(
+          url.searchParams.get("forceSync"),
+          "forceSync"
+        ),
+        maxResults: parsePositiveIntegerQuery(
+          url.searchParams.get("maxResults"),
+          "maxResults"
+        ) ?? void 0,
+        query: query ?? "",
+        replyNeededOnly: parseBooleanQuery(
+          url.searchParams.get("replyNeededOnly"),
+          "replyNeededOnly"
+        ),
+        includeSpamTrash: parseBooleanQuery(
+          url.searchParams.get("includeSpamTrash"),
+          "includeSpamTrash"
+        ),
+        grantId: url.searchParams.get("grantId") ?? void 0
+      };
+      json(res, await service.getGmailSearch(url, request));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/gmail/needs-response") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const request = {
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        forceSync: parseBooleanQuery(
+          url.searchParams.get("forceSync"),
+          "forceSync"
+        ),
+        maxResults: parsePositiveIntegerQuery(
+          url.searchParams.get("maxResults"),
+          "maxResults"
+        ) ?? void 0,
+        grantId: url.searchParams.get("grantId") ?? void 0
+      };
+      json(res, await service.getGmailNeedsResponse(url, request));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/gmail/recommendations") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const query = url.searchParams.get("query");
+      const request = {
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        forceSync: parseBooleanQuery(
+          url.searchParams.get("forceSync"),
+          "forceSync"
+        ),
+        maxResults: parsePositiveIntegerQuery(
+          url.searchParams.get("maxResults"),
+          "maxResults"
+        ) ?? void 0,
+        query: query ?? void 0,
+        replyNeededOnly: parseBooleanQuery(
+          url.searchParams.get("replyNeededOnly"),
+          "replyNeededOnly"
+        ),
+        includeSpamTrash: parseBooleanQuery(
+          url.searchParams.get("includeSpamTrash"),
+          "includeSpamTrash"
+        ),
+        grantId: url.searchParams.get("grantId") ?? void 0
+      };
+      json(res, await service.getGmailRecommendations(url, request));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/gmail/spam-review") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const request = {
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        grantId: url.searchParams.get("grantId") ?? void 0,
+        status: parseGmailSpamReviewStatusQuery(url.searchParams.get("status")),
+        maxResults: parsePositiveIntegerQuery(
+          url.searchParams.get("maxResults"),
+          "maxResults"
+        ) ?? void 0
+      };
+      json(res, await service.getGmailSpamReviewItems(url, request));
+    });
+  }
+  const gmailSpamReviewMatch = pathname.match(
+    /^\/api\/lifeops\/gmail\/spam-review\/([^/]+)$/
+  );
+  if (method === "PATCH" && gmailSpamReviewMatch) {
+    if (rateLimitRequest(ctx, "google_api_write")) return true;
+    const itemId = decodeMatchedPathComponent(
+      ctx,
+      gmailSpamReviewMatch,
+      1,
+      res,
+      "itemId"
+    );
+    if (!itemId) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      const status = parseGmailSpamReviewStatusInput(body.status, "status");
+      if (!status) {
+        throw new LifeOpsServiceError(400, "status is required");
+      }
+      json(
+        res,
+        await service.updateGmailSpamReviewItem(url, itemId, { status })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/gmail/unresponded") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const request = {
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        maxResults: parsePositiveIntegerQuery(
+          url.searchParams.get("maxResults"),
+          "maxResults"
+        ) ?? void 0,
+        olderThanDays: parsePositiveIntegerQuery(
+          url.searchParams.get("olderThanDays"),
+          "olderThanDays"
+        ) ?? void 0,
+        grantId: url.searchParams.get("grantId") ?? void 0
+      };
+      json(res, await service.getGmailUnresponded(url, request));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/inbox") {
+    return runRoute(ctx, async (service) => {
+      const limit = parsePositiveIntegerQuery(url.searchParams.get("limit"), "limit") ?? void 0;
+      const rawChannels = url.searchParams.get("channels");
+      let channels;
+      if (rawChannels !== null && rawChannels.trim().length > 0) {
+        const parsed = rawChannels.split(",").map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+        const parsedChannels = [];
+        for (const value of parsed) {
+          if (!isOneOf(value, LIFEOPS_INBOX_CHANNELS)) {
+            throw new LifeOpsServiceError(
+              400,
+              `channels must be a comma-separated subset of: ${LIFEOPS_INBOX_CHANNELS.join(", ")}`
+            );
+          }
+          parsedChannels.push(value);
+        }
+        channels = parsedChannels;
+      }
+      const groupByThread = url.searchParams.get("groupByThread") === "true";
+      const rawChatTypeFilter = url.searchParams.get("chatTypeFilter");
+      let chatTypeFilter;
+      if (rawChatTypeFilter !== null && rawChatTypeFilter.trim().length > 0) {
+        const parsed = rawChatTypeFilter.split(",").map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+        const allowed = [];
+        for (const value of parsed) {
+          if (value !== "dm" && value !== "group" && value !== "channel") {
+            throw new LifeOpsServiceError(
+              400,
+              "chatTypeFilter must be a comma-separated subset of: dm, group, channel"
+            );
+          }
+          allowed.push(value);
+        }
+        if (allowed.length > 0) chatTypeFilter = allowed;
+      }
+      const maxParticipants = parsePositiveIntegerQuery(
+        url.searchParams.get("maxParticipants"),
+        "maxParticipants"
+      ) ?? void 0;
+      const gmailAccountIdRaw = url.searchParams.get("gmailAccountId");
+      const gmailAccountId = gmailAccountIdRaw !== null && gmailAccountIdRaw.trim().length > 0 ? gmailAccountIdRaw.trim() : void 0;
+      const phoneAccountIds = url.searchParams.get("phoneAccountIds")?.split(",").map((value) => value.trim()).filter(Boolean);
+      const missedOnly = url.searchParams.get("missedOnly") === "true";
+      const sortByPriority = url.searchParams.get("sortByPriority") === "true";
+      const rawCacheMode = url.searchParams.get("cacheMode");
+      let cacheMode;
+      if (rawCacheMode !== null && rawCacheMode.trim().length > 0) {
+        const parsedCacheMode = rawCacheMode.trim().toLowerCase();
+        if (!isOneOf(parsedCacheMode, LIFEOPS_INBOX_CACHE_MODES)) {
+          throw new LifeOpsServiceError(
+            400,
+            `cacheMode must be one of: ${LIFEOPS_INBOX_CACHE_MODES.join(", ")}`
+          );
+        }
+        cacheMode = parsedCacheMode;
+      }
+      const cacheLimit = parsePositiveIntegerQuery(
+        url.searchParams.get("cacheLimit"),
+        "cacheLimit"
+      ) ?? void 0;
+      const request = {
+        limit,
+        channels,
+        groupByThread: groupByThread || void 0,
+        chatTypeFilter,
+        maxParticipants,
+        gmailAccountId,
+        phoneAccountIds: phoneAccountIds && phoneAccountIds.length > 0 ? phoneAccountIds : void 0,
+        missedOnly: missedOnly || void 0,
+        sortByPriority: sortByPriority || void 0,
+        cacheMode,
+        cacheLimit
+      };
+      json(res, await service.getInbox(request));
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/reply-drafts") {
+    if (rateLimitRequest(ctx, "gmail_draft")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, { draft: await service.createGmailReplyDraft(url, body) }, 201);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/batch-reply-drafts") {
+    if (rateLimitRequest(ctx, "gmail_draft")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        { batch: await service.createGmailBatchReplyDrafts(url, body) },
+        201
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/reply-send") {
+    if (rateLimitRequest(ctx, "gmail_send")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.sendGmailReply(url, body));
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/message-send") {
+    if (rateLimitRequest(ctx, "gmail_send")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.sendGmailMessage(url, body));
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/batch-reply-send") {
+    if (rateLimitRequest(ctx, "gmail_send")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.sendGmailReplies(url, body));
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/manage") {
+    if (rateLimitRequest(ctx, "google_api_write")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.manageGmailMessages(url, body));
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/gmail/events/ingest") {
+    if (rateLimitRequest(ctx, "google_api_write")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.ingestGmailEvent(url, body), 202);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/health/status") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getHealthDataConnectorStatuses(
+          url,
+          parseConnectorModeQuery(url.searchParams.get("mode")),
+          parseConnectorSideQuery(url.searchParams.get("side"))
+        )
+      );
+    });
+  }
+  const healthStatusMatch = pathname.match(
+    /^\/api\/lifeops\/connectors\/health\/([^/]+)\/status$/
+  );
+  if (method === "GET" && healthStatusMatch) {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const provider = parseHealthConnectorProviderPath(ctx, healthStatusMatch);
+    if (!provider) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getHealthDataConnectorStatus(
+          provider,
+          url,
+          parseConnectorModeQuery(url.searchParams.get("mode")),
+          parseConnectorSideQuery(url.searchParams.get("side"))
+        )
+      );
+    });
+  }
+  const healthCallbackMatch = pathname.match(
+    /^\/api\/lifeops\/connectors\/health\/([^/]+)\/callback$/
+  );
+  if (method === "GET" && healthCallbackMatch) {
+    const provider = parseHealthConnectorProviderPath(ctx, healthCallbackMatch);
+    if (!provider) return true;
+    const service = getService(ctx);
+    if (!service) return true;
+    try {
+      await ensureRouteSchema(ctx.state.runtime);
+      const status = await service.completeHealthConnectorCallback(url);
+      if (status.provider !== provider) {
+        throw new LifeOpsServiceError(
+          409,
+          "Health connector callback provider did not match the request path."
+        );
+      }
+      writeHtml(
+        res,
+        200,
+        `${provider} Connected`,
+        `${provider} health data is now available in Eliza. You can close this window.`
+      );
+      return true;
+    } catch (error) {
+      if (error instanceof LifeOpsServiceError) {
+        writeHtml(res, error.status, "Health Connection Failed", error.message);
+        return true;
+      }
+      throw error;
+    }
+  }
+  const healthSuccessMatch = pathname.match(
+    /^\/api\/lifeops\/connectors\/health\/([^/]+)\/success$/
+  );
+  if (method === "GET" && healthSuccessMatch) {
+    const provider = parseHealthConnectorProviderPath(ctx, healthSuccessMatch);
+    if (!provider) return true;
+    writeHtml(
+      res,
+      200,
+      `${provider} Connected`,
+      `${provider} health data is now available in Eliza. You can close this window.`
+    );
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/lifeops/health/summary") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    return runRoute(ctx, async (service) => {
+      const request = {
+        provider: parseOptionalHealthConnectorProvider(
+          url.searchParams.get("provider")
+        ),
+        mode: parseConnectorModeQuery(url.searchParams.get("mode")),
+        side: parseConnectorSideQuery(url.searchParams.get("side")),
+        days: parsePositiveIntegerQuery(url.searchParams.get("days"), "days", {
+          max: 31
+        }) ?? void 0,
+        startDate: parseDateOnlyQuery(
+          url.searchParams.get("startDate"),
+          "startDate"
+        ),
+        endDate: parseDateOnlyQuery(url.searchParams.get("endDate"), "endDate"),
+        forceSync: url.searchParams.get("forceSync") === "true"
+      };
+      json(res, await service.getHealthSummary(request));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/x/status") {
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getXConnectorStatus(
+          parseConnectorModeQuery(url.searchParams.get("mode")),
+          parseConnectorSideQuery(url.searchParams.get("side"))
+        )
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/x/posts") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.createXPost(body), 201);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/x/dms/digest") {
+    return runRoute(ctx, async (service) => {
+      const limit = parsePositiveIntegerQuery(url.searchParams.get("limit"), "limit", {
+        max: 100
+      }) ?? void 0;
+      const conversationId = url.searchParams.get("conversationId")?.trim();
+      json(
+        res,
+        await service.getXDmDigest({
+          limit,
+          conversationId: conversationId?.length ? conversationId : void 0
+        })
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/x/dms/curate") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.curateXDms({
+          messageIds: parseOptionalBodyStringArray(body, "messageIds"),
+          conversationId: parseOptionalBodyString(body, "conversationId"),
+          markRead: parseOptionalBodyBoolean(body, "markRead"),
+          markReplied: parseOptionalBodyBoolean(body, "markReplied")
+        })
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/x/dms/send") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.sendXDirectMessage({
+          participantId: requireBodyString(body, "participantId"),
+          text: requireBodyString(body, "text"),
+          confirmSend: parseOptionalBodyBoolean(body, "confirmSend"),
+          mode: parseConnectorModeInput(body.mode),
+          side: parseConnectorSideInput(body.side)
+        }),
+        201
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/imessage/status") {
+    return runRoute(ctx, async (service) => {
+      json(res, await service.getIMessageConnectorStatus());
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/imessage/chats") {
+    return runRoute(ctx, async (service) => {
+      const chats = await service.listIMessageChats();
+      json(res, { chats, count: chats.length });
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/imessage/messages") {
+    return runRoute(ctx, async (service) => {
+      const query = {
+        chatId: url.searchParams.get("chatId")?.trim() || void 0,
+        since: url.searchParams.get("since")?.trim() || void 0,
+        limit: parsePositiveIntegerQuery(url.searchParams.get("limit"), "limit", {
+          max: 250
+        }) ?? void 0
+      };
+      const messages = await service.readIMessages(query);
+      json(res, { messages, count: messages.length });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/connectors/imessage/send") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.sendIMessage({
+          to: requireBodyString(body, "to"),
+          text: requireBodyString(body, "text"),
+          attachmentPaths: parseOptionalBodyStringArray(
+            body,
+            "attachmentPaths"
+          )
+        }),
+        201
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/telegram/status") {
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getTelegramConnectorStatus(
+          parseConnectorSideQuery(url.searchParams.get("side"))
+        )
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/connectors/telegram/verify") {
+    if (rateLimitRequest(ctx, "oauth_init")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.verifyTelegramConnector(body));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/signal/status") {
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getSignalConnectorStatus(
+          parseConnectorSideQuery(url.searchParams.get("side"))
+        )
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/signal/messages") {
+    return runRoute(ctx, async (service) => {
+      const limit = parsePositiveIntegerQuery(url.searchParams.get("limit"), "limit", {
+        max: 100
+      }) ?? 25;
+      const messages = await service.readSignalInbound(limit);
+      json(res, { messages, count: messages.length });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/connectors/signal/send") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.sendSignalMessage({
+          side: parseConnectorSideFromRequest(url, body),
+          recipient: requireBodyString(body, "recipient"),
+          text: requireBodyString(body, "text")
+        }),
+        201
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/discord/status") {
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getDiscordConnectorStatus(
+          parseConnectorSideQuery(url.searchParams.get("side"))
+        )
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/connectors/discord/send") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.sendDiscordMessage({
+          side: parseConnectorSideFromRequest(url, body),
+          channelId: parseOptionalBodyString(body, "channelId"),
+          text: requireBodyString(body, "text")
+        }),
+        201
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/connectors/discord/verify") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.verifyDiscordConnector({
+          side: parseConnectorSideFromRequest(url, body),
+          channelId: parseOptionalBodyString(body, "channelId"),
+          sendMessage: parseOptionalBodyString(body, "sendMessage")
+        })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/whatsapp/status") {
+    return runRoute(ctx, async (service) => {
+      json(res, await service.getWhatsAppConnectorStatus());
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/connectors/whatsapp/send") {
+    if (rateLimitRequest(ctx, "outbound_message")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.sendWhatsAppMessage({
+          to: requireBodyString(body, "to"),
+          text: requireBodyString(body, "text"),
+          replyToMessageId: parseOptionalBodyString(body, "replyToMessageId")
+        }),
+        201
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/connectors/whatsapp/messages") {
+    return runRoute(ctx, async (service) => {
+      const limit = parsePositiveIntegerQuery(url.searchParams.get("limit"), "limit", {
+        max: 500
+      }) ?? 25;
+      json(res, await service.pullWhatsAppRecent(limit));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/channel-policies") {
+    return runRoute(ctx, async (service) => {
+      json(res, { policies: await service.listChannelPolicies() });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/channel-policies") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, { policy: await service.upsertChannelPolicy(body) }, 201);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/channels/phone-consent") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.capturePhoneConsent(body), 201);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/activity-signals") {
+    return runRoute(ctx, async (service) => {
+      await ensureRouteSchema(ctx.state.runtime);
+      json(res, {
+        signals: await service.listActivitySignals({
+          sinceAt: parseOptionalIsoQuery(
+            url.searchParams.get("sinceAt"),
+            "sinceAt"
+          ),
+          limit: parsePositiveIntegerQuery(url.searchParams.get("limit"), "limit", {
+            max: ACTIVITY_SIGNALS_MAX_LIMIT
+          }) ?? ACTIVITY_SIGNALS_DEFAULT_LIMIT,
+          states: parseActivitySignalStates(url)
+        })
+      });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/activity-signals") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      await ensureRouteSchema(ctx.state.runtime);
+      json(res, { signal: await service.captureActivitySignal(body) }, 201);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/manual-override") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.captureManualOverride(body), 201);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/reminders/process") {
+    if (rateLimitRequest(ctx, "reminders_process")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.processReminders(body));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/reminder-preferences") {
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getReminderPreference(
+          url.searchParams.get("definitionId") ?? void 0
+        )
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/reminder-preferences") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.setReminderPreference(body), 201);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/reminders/acknowledge") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.acknowledgeReminder(body));
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/website-access/relock") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.relockWebsiteAccessGroup(body.groupKey));
+    });
+  }
+  const websiteAccessCallbackMatch = pathname.match(
+    /^\/api\/lifeops\/website-access\/callbacks\/([^/]+)\/resolve$/
+  );
+  if (method === "POST" && websiteAccessCallbackMatch) {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const callbackKey = decodeMatchedPathComponent(
+      ctx,
+      websiteAccessCallbackMatch,
+      1,
+      res,
+      "website access callback key"
+    );
+    if (!callbackKey) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (body === null) return true;
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.resolveWebsiteAccessCallback(
+          body.callbackKey || callbackKey
+        )
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/reminders/inspection") {
+    return runRoute(ctx, async (service) => {
+      const ownerType = url.searchParams.get("ownerType");
+      const ownerId = url.searchParams.get("ownerId");
+      if (ownerType !== "occurrence" && ownerType !== "calendar_event") {
+        throw new LifeOpsServiceError(
+          400,
+          "ownerType must be occurrence or calendar_event"
+        );
+      }
+      if (!ownerId) {
+        throw new LifeOpsServiceError(400, "ownerId is required");
+      }
+      json(res, await service.inspectReminder(ownerType, ownerId));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/workflows") {
+    return runRoute(ctx, async (service) => {
+      json(res, { workflows: await service.listWorkflows() });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/workflows") {
+    if (rateLimitRequest(ctx, "task_create")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.createWorkflow(body), 201);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/schedule/observations") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.ingestScheduleObservations(body));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/schedule/merged-state") {
+    const scopeParam = url.searchParams.get("scope");
+    const scope = scopeParam?.trim() ?? "";
+    if (scope.length > 0 && !LIFEOPS_SCHEDULE_STATE_SCOPES.includes(
+      scope
+    ) && scope !== "effective") {
+      ctx.error(res, "scope must be local, cloud, or effective", 400);
+      return true;
+    }
+    const refreshParam = url.searchParams.get("refresh")?.trim().toLowerCase();
+    if (refreshParam && refreshParam !== "1" && refreshParam !== "0" && refreshParam !== "true" && refreshParam !== "false") {
+      ctx.error(res, "refresh must be true, false, 1, or 0", 400);
+      return true;
+    }
+    const refresh = refreshParam === "1" || refreshParam === "true";
+    return runRoute(ctx, async (service) => {
+      json(res, {
+        mergedState: await service.getScheduleMergedState({
+          timezone: url.searchParams.get("timezone"),
+          scope: scope.length > 0 ? scope : void 0,
+          refresh
+        })
+      });
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/schedule/inspection") {
+    const timezoneParam = url.searchParams.get("timezone")?.trim() || "UTC";
+    return runRoute(ctx, async (service) => {
+      json(res, await service.inspectSchedule({ timezone: timezoneParam }));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/schedule/summary") {
+    const timezoneParam = url.searchParams.get("timezone")?.trim() || "UTC";
+    return runRoute(ctx, async (service) => {
+      json(res, await service.readScheduleSummary({ timezone: timezoneParam }));
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/permissions/full-disk-access") {
+    return runRoute(ctx, async () => {
+      json(res, await probeFullDiskAccess());
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/screen-time/summary") {
+    return runRoute(ctx, async (service) => {
+      const window = parseBoundedIsoWindowQuery(url);
+      json(
+        res,
+        await service.getScreenTimeSummary({
+          since: window.since,
+          until: window.until,
+          source: parseScreenTimeSourceQuery(url.searchParams.get("source")),
+          identifier: parseScreenTimeIdentifierQuery(
+            url.searchParams.get("identifier")
+          ),
+          topN: parsePositiveIntegerQuery(url.searchParams.get("topN"), "topN", {
+            max: 20
+          }) ?? void 0
+        })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/screen-time/breakdown") {
+    return runRoute(ctx, async (service) => {
+      const window = parseBoundedIsoWindowQuery(url);
+      json(
+        res,
+        await service.getScreenTimeBreakdown({
+          since: window.since,
+          until: window.until,
+          source: parseScreenTimeSourceQuery(url.searchParams.get("source")),
+          identifier: parseScreenTimeIdentifierQuery(
+            url.searchParams.get("identifier")
+          ),
+          topN: parsePositiveIntegerQuery(url.searchParams.get("topN"), "topN", {
+            max: 50
+          }) ?? void 0
+        })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/screen-time/history") {
+    return runRoute(ctx, async (service) => {
+      json(
+        res,
+        await service.getScreenTimeHistory({
+          range: parseScreenTimeRangeQuery(url.searchParams.get("range")),
+          topN: parsePositiveIntegerQuery(url.searchParams.get("topN"), "topN", {
+            max: 50
+          }) ?? void 0,
+          socialTopN: parsePositiveIntegerQuery(
+            url.searchParams.get("socialTopN"),
+            "socialTopN",
+            { max: 50 }
+          ) ?? void 0
+        })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/social/summary") {
+    return runRoute(ctx, async (service) => {
+      const window = parseBoundedIsoWindowQuery(url);
+      json(
+        res,
+        await service.getSocialHabitSummary({
+          since: window.since,
+          until: window.until,
+          topN: parsePositiveIntegerQuery(url.searchParams.get("topN"), "topN", {
+            max: 50
+          }) ?? void 0
+        })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/capabilities") {
+    return runRoute(ctx, async (service) => {
+      json(res, await service.getCapabilityStatus());
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/overview") {
+    return runRoute(ctx, async (service) => {
+      json(res, await service.getOverview());
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/todos") {
+    return runRoute(ctx, async (service) => {
+      const overview = await service.getOverview();
+      const todos = overview.owner.occurrences.map((occurrence) => ({
+        id: occurrence.id,
+        title: occurrence.title,
+        status: occurrenceStateToTodoStatus(occurrence.state),
+        dueDate: occurrence.dueAt
+      }));
+      json(res, { todos });
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/money/dashboard") {
+    return runFinancesRoute(ctx, async (service) => {
+      const windowDaysRaw = url.searchParams.get("windowDays");
+      const windowDays = windowDaysRaw ? Number(windowDaysRaw) : null;
+      json(
+        res,
+        await service.getPaymentsDashboard({
+          windowDays: Number.isFinite(windowDays) ? windowDays : null
+        })
+      );
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/money/sources") {
+    return runFinancesRoute(ctx, async (service) => {
+      json(res, { sources: await service.listPaymentSources() });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/sources") {
+    if (rateLimitRequest(ctx, "connector_write")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const source = await service.addPaymentSource(body);
+      json(res, { source: sanitizePaymentSourceForClient(source) }, 201);
+    });
+  }
+  if (method === "DELETE" && pathname.startsWith("/api/lifeops/money/sources/")) {
+    if (rateLimitRequest(ctx, "connector_write")) return true;
+    const sourceId = pathname.slice("/api/lifeops/money/sources/".length);
+    if (!sourceId) {
+      ctx.error(res, "sourceId required", 400);
+      return true;
+    }
+    return runFinancesRoute(ctx, async (service) => {
+      await service.deletePaymentSource(decodeURIComponent(sourceId));
+      json(res, { ok: true });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/import-csv") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.importTransactionsCsv(body);
+      json(res, result);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/money/transactions") {
+    return runFinancesRoute(ctx, async (service) => {
+      const sourceId = url.searchParams.get("sourceId");
+      const limitRaw = url.searchParams.get("limit");
+      const limit = limitRaw ? Number(limitRaw) : null;
+      const merchantContains = url.searchParams.get("merchantContains");
+      const onlyDebitsRaw = url.searchParams.get("onlyDebits");
+      const transactions = await service.listTransactions({
+        sourceId: sourceId ?? null,
+        limit: Number.isFinite(limit) ? limit : null,
+        merchantContains: merchantContains ?? null,
+        onlyDebits: onlyDebitsRaw === "true" ? true : null
+      });
+      json(res, { transactions });
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/money/recurring") {
+    return runFinancesRoute(ctx, async (service) => {
+      const sourceId = url.searchParams.get("sourceId");
+      const sinceDaysRaw = url.searchParams.get("sinceDays");
+      const sinceDays = sinceDaysRaw ? Number(sinceDaysRaw) : null;
+      const charges = await service.getRecurringCharges({
+        sourceId: sourceId ?? null,
+        sinceDays: Number.isFinite(sinceDays) ? sinceDays : null
+      });
+      json(res, { charges });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/plaid/link-token") {
+    if (rateLimitRequest(ctx, "oauth_init")) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.createPlaidLinkToken();
+      json(res, result);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/plaid/complete") {
+    if (rateLimitRequest(ctx, "oauth_init")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const source = await service.completePlaidLink({
+        publicToken: body.publicToken,
+        label: body.label ?? null
+      });
+      json(
+        res,
+        {
+          source: sanitizePaymentSourceForClient(source)
+        },
+        201
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/plaid/sync") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.syncPlaidTransactions({
+        sourceId: body.sourceId
+      });
+      json(res, result);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/paypal/authorize-url") {
+    if (rateLimitRequest(ctx, "oauth_init")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.createPaypalAuthorizeUrl({
+        state: body.state
+      });
+      json(res, result);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/paypal/complete") {
+    if (rateLimitRequest(ctx, "oauth_init")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const { source, capability } = await service.completePaypalLink({
+        code: body.code,
+        label: body.label ?? null
+      });
+      json(
+        res,
+        {
+          source: sanitizePaymentSourceForClient(source),
+          capability
+        },
+        201
+      );
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/paypal/sync") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.syncPaypalTransactions({
+        sourceId: body.sourceId,
+        windowDays: body.windowDays ?? null
+      });
+      json(res, result);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/smart-features/settings") {
+    return runRoute(ctx, async (service) => {
+      const get = (key) => {
+        const value = service.runtime.getSetting(key);
+        if (value === void 0 || value === null) return null;
+        return typeof value === "string" ? value : String(value);
+      };
+      json(res, {
+        emailClassifierEnabled: (get("lifeops.emailClassifier.enabled") ?? "true") !== "false",
+        emailClassifierModel: get("lifeops.emailClassifier.model") ?? "TEXT_SMALL",
+        billsAutoExtract: (get("lifeops.bills.autoExtract") ?? "true") !== "false"
+      });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/smart-features/settings") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      const setRuntime = service.runtime.setSetting.bind(service.runtime);
+      if (typeof setRuntime !== "function") {
+        ctx.error(res, "Runtime does not support setSetting", 501);
+        return;
+      }
+      if (typeof body.emailClassifierEnabled === "boolean") {
+        setRuntime(
+          "lifeops.emailClassifier.enabled",
+          body.emailClassifierEnabled ? "true" : "false",
+          false
+        );
+      }
+      if (typeof body.emailClassifierModel === "string") {
+        setRuntime(
+          "lifeops.emailClassifier.model",
+          body.emailClassifierModel.trim() || "TEXT_SMALL",
+          false
+        );
+      }
+      if (typeof body.billsAutoExtract === "boolean") {
+        setRuntime(
+          "lifeops.bills.autoExtract",
+          body.billsAutoExtract ? "true" : "false",
+          false
+        );
+      }
+      json(res, { ok: true });
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/money/bills") {
+    return runFinancesRoute(ctx, async (service) => {
+      const bills = await service.getUpcomingBills({});
+      json(res, { bills });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/bills/mark-paid") {
+    if (rateLimitRequest(ctx, "task_update")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.markBillPaid({
+        billId: body.billId,
+        paidAt: body.paidAt ?? null
+      });
+      json(res, result);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/money/bills/snooze") {
+    if (rateLimitRequest(ctx, "task_update")) return true;
+    const body = await readJsonBody(
+      req,
+      res
+    );
+    if (!body) return true;
+    return runFinancesRoute(ctx, async (service) => {
+      const result = await service.snoozeBill({
+        billId: body.billId,
+        days: body.days ?? 7
+      });
+      json(res, result);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/subscriptions/playbook-lookup") {
+    return runRoute(ctx, async (service) => {
+      const merchant = url.searchParams.get("merchant") ?? "";
+      const playbook = service.findSubscriptionPlaybookForMerchant(merchant);
+      json(res, { playbook });
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/subscriptions/playbooks") {
+    return runRoute(ctx, async (service) => {
+      const playbooks = await service.listSubscriptionPlaybooks();
+      const summary = playbooks.filter((playbook) => !playbook.key.startsWith("fixture_")).map((playbook) => ({
+        key: playbook.key,
+        serviceName: playbook.serviceName,
+        aliases: playbook.aliases,
+        managementUrl: playbook.managementUrl,
+        executorPreference: playbook.executorPreference
+      }));
+      json(res, { playbooks: summary });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/subscriptions/cancel") {
+    if (rateLimitRequest(ctx, "default")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      const summary = await service.cancelSubscription({
+        candidateId: body.candidateId ?? null,
+        serviceName: body.serviceName ?? null,
+        serviceSlug: body.serviceSlug ?? null,
+        executor: body.executor ?? null,
+        confirmed: body.confirmed ?? false
+      });
+      json(res, summary);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/email-unsubscribe/scan") {
+    if (rateLimitRequest(ctx, "google_api_read")) return true;
+    return runRoute(ctx, async (service) => {
+      const requestUrl = ctx.url;
+      const result = await service.scanEmailSubscriptions(requestUrl, {});
+      json(res, result);
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/email-unsubscribe/unsubscribe") {
+    if (rateLimitRequest(ctx, "google_api_write")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      const runtime = ctx.state.runtime;
+      if (!runtime) {
+        ctx.error(res, "Agent runtime is not available", 503);
+        return;
+      }
+      const senderEmail = body.senderEmail?.trim();
+      if (!senderEmail) {
+        ctx.error(res, "senderEmail is required", 400);
+        return;
+      }
+      const entityId = String(ctx.state.adminEntityId ?? "lifeops-owner");
+      const confirmMessage = {
+        entityId,
+        roomId: entityId,
+        content: {
+          text: typeof body.userConfirmationText === "string" ? body.userConfirmationText : "",
+          source: "lifeops-api"
+        },
+        createdAt: Date.now()
+      };
+      const preview = `Unsubscribe from ${senderEmail}?`;
+      const decision = await requireConfirmation({
+        runtime,
+        message: confirmMessage,
+        actionName: "EMAIL_UNSUBSCRIBE",
+        pendingKey: senderEmail.toLowerCase(),
+        prompt: preview
+      });
+      if (decision.status !== "confirmed") {
+        json(
+          res,
+          {
+            requiresConfirmation: decision.status === "pending",
+            awaitingUserInput: decision.status === "pending",
+            cancelled: decision.status === "cancelled",
+            preview: `${preview} Reply yes to confirm or no to cancel.`
+          },
+          decision.status === "pending" ? 409 : 200
+        );
+        return;
+      }
+      const requestUrl = ctx.url;
+      const result = await service.unsubscribeEmailSender(requestUrl, {
+        senderEmail,
+        blockAfter: body.blockAfter ?? false,
+        trashExisting: body.trashExisting ?? false,
+        userAuthorization: true
+      });
+      json(res, result);
+    });
+  }
+  if (method === "GET" && pathname === "/api/lifeops/definitions") {
+    return runRoute(ctx, async (service) => {
+      json(res, { definitions: await service.listDefinitions() });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/definitions") {
+    if (rateLimitRequest(ctx, "task_create")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.createDefinition(body), 201);
+    });
+  }
+  const definitionMatch = pathname.match(
+    /^\/api\/lifeops\/definitions\/([^/]+)$/
+  );
+  if (definitionMatch) {
+    const definitionId = decodeMatchedPathComponent(
+      ctx,
+      definitionMatch,
+      1,
+      res,
+      "definition id"
+    );
+    if (!definitionId) return true;
+    if (method === "GET") {
+      return runRoute(ctx, async (service) => {
+        json(res, await service.getDefinition(definitionId));
+      });
+    }
+    if (method === "PUT") {
+      if (rateLimitRequest(ctx, "task_update")) return true;
+      const body = await readJsonBody(req, res);
+      if (!body) return true;
+      return runRoute(ctx, async (service) => {
+        json(res, await service.updateDefinition(definitionId, body));
+      });
+    }
+    if (method === "DELETE") {
+      if (rateLimitRequest(ctx, "task_update")) return true;
+      return runRoute(ctx, async (service) => {
+        await service.deleteDefinition(definitionId);
+        json(res, { deleted: true });
+      });
+    }
+  }
+  if (method === "GET" && pathname === "/api/lifeops/goals") {
+    return runRoute(ctx, async (service) => {
+      json(res, { goals: await service.listGoals() });
+    });
+  }
+  if (method === "POST" && pathname === "/api/lifeops/goals") {
+    if (rateLimitRequest(ctx, "task_create")) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.createGoal(body), 201);
+    });
+  }
+  const goalMatch = pathname.match(/^\/api\/lifeops\/goals\/([^/]+)$/);
+  if (goalMatch) {
+    const goalId = decodeMatchedPathComponent(
+      ctx,
+      goalMatch,
+      1,
+      res,
+      "goal id"
+    );
+    if (!goalId) return true;
+    if (method === "GET") {
+      return runRoute(ctx, async (service) => {
+        json(res, await service.getGoal(goalId));
+      });
+    }
+    if (method === "PUT") {
+      if (rateLimitRequest(ctx, "task_update")) return true;
+      const body = await readJsonBody(req, res);
+      if (!body) return true;
+      return runRoute(ctx, async (service) => {
+        json(res, await service.updateGoal(goalId, body));
+      });
+    }
+    if (method === "DELETE") {
+      if (rateLimitRequest(ctx, "task_update")) return true;
+      return runRoute(ctx, async (service) => {
+        await service.deleteGoal(goalId);
+        json(res, { deleted: true });
+      });
+    }
+  }
+  const goalReviewMatch = pathname.match(
+    /^\/api\/lifeops\/goals\/([^/]+)\/review$/
+  );
+  if (goalReviewMatch && method === "GET") {
+    const goalId = decodeMatchedPathComponent(
+      ctx,
+      goalReviewMatch,
+      1,
+      res,
+      "goal id"
+    );
+    if (!goalId) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.reviewGoal(goalId));
+    });
+  }
+  const workflowMatch = pathname.match(/^\/api\/lifeops\/workflows\/([^/]+)$/);
+  if (workflowMatch) {
+    const workflowId = decodeMatchedPathComponent(
+      ctx,
+      workflowMatch,
+      1,
+      res,
+      "workflow id"
+    );
+    if (!workflowId) return true;
+    if (method === "GET") {
+      return runRoute(ctx, async (service) => {
+        json(res, await service.getWorkflow(workflowId));
+      });
+    }
+    if (method === "PUT") {
+      if (rateLimitRequest(ctx, "task_update")) return true;
+      const body = await readJsonBody(req, res);
+      if (!body) return true;
+      return runRoute(ctx, async (service) => {
+        json(res, await service.updateWorkflow(workflowId, body));
+      });
+    }
+  }
+  const workflowRunMatch = pathname.match(
+    /^\/api\/lifeops\/workflows\/([^/]+)\/run$/
+  );
+  if (method === "POST" && workflowRunMatch) {
+    if (rateLimitRequest(ctx, "task_create")) return true;
+    const workflowId = decodeMatchedPathComponent(
+      ctx,
+      workflowRunMatch,
+      1,
+      res,
+      "workflow id"
+    );
+    if (!workflowId) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, { run: await service.runWorkflow(workflowId, body) }, 201);
+    });
+  }
+  const occurrenceExplanationMatch = pathname.match(
+    /^\/api\/lifeops\/occurrences\/([^/]+)\/explanation$/
+  );
+  if (occurrenceExplanationMatch && method === "GET") {
+    const occurrenceId = decodeMatchedPathComponent(
+      ctx,
+      occurrenceExplanationMatch,
+      1,
+      res,
+      "occurrence id"
+    );
+    if (!occurrenceId) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, await service.explainOccurrence(occurrenceId));
+    });
+  }
+  const completeMatch = pathname.match(
+    /^\/api\/lifeops\/occurrences\/([^/]+)\/complete$/
+  );
+  if (method === "POST" && completeMatch) {
+    if (rateLimitRequest(ctx, "task_update")) return true;
+    const occurrenceId = decodeMatchedPathComponent(
+      ctx,
+      completeMatch,
+      1,
+      res,
+      "occurrence id"
+    );
+    if (!occurrenceId) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, {
+        occurrence: await service.completeOccurrence(occurrenceId, body)
+      });
+    });
+  }
+  const skipMatch = pathname.match(
+    /^\/api\/lifeops\/occurrences\/([^/]+)\/skip$/
+  );
+  if (method === "POST" && skipMatch) {
+    if (rateLimitRequest(ctx, "task_update")) return true;
+    const occurrenceId = decodeMatchedPathComponent(
+      ctx,
+      skipMatch,
+      1,
+      res,
+      "occurrence id"
+    );
+    if (!occurrenceId) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, {
+        occurrence: await service.skipOccurrence(occurrenceId)
+      });
+    });
+  }
+  const snoozeMatch = pathname.match(
+    /^\/api\/lifeops\/occurrences\/([^/]+)\/snooze$/
+  );
+  if (method === "POST" && snoozeMatch) {
+    if (rateLimitRequest(ctx, "task_update")) return true;
+    const occurrenceId = decodeMatchedPathComponent(
+      ctx,
+      snoozeMatch,
+      1,
+      res,
+      "occurrence id"
+    );
+    if (!occurrenceId) return true;
+    const body = await readJsonBody(req, res);
+    if (!body) return true;
+    return runRoute(ctx, async (service) => {
+      json(res, {
+        occurrence: await service.snoozeOccurrence(occurrenceId, body)
+      });
+    });
+  }
+  return false;
+}
+export {
+  handleLifeOpsRoutes
+};
+//# sourceMappingURL=lifeops-routes.js.map