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

package/dist/lifeops/policy-memory.js

@@ -0,0 +1,1026 @@
+const LIFEOPS_POLICY_OPERATIONS = [
+  "read_aloud",
+  "delete",
+  "send",
+  "spend_money",
+  "proofread_apply",
+  "store_affect",
+  "bulk_cleanup"
+];
+const LIFEOPS_POLICY_EFFECTS = [
+  "allow",
+  "deny",
+  "require_approval",
+  "prompt_user_first"
+];
+const LIFEOPS_POLICY_REVIEW_STATES = [
+  "draft",
+  "active",
+  "needs_review",
+  "rejected",
+  "retired"
+];
+const LIFEOPS_POLICY_SENSITIVITY_LEVELS = [
+  "public",
+  "routine",
+  "personal",
+  "confidential",
+  "restricted"
+];
+const LIFEOPS_POLICY_SURFACES = [
+  "chat",
+  "voice",
+  "email",
+  "browser",
+  "desktop",
+  "mobile",
+  "automation",
+  "api"
+];
+const LIFEOPS_POLICY_CHANNELS = [
+  "telegram",
+  "discord",
+  "slack",
+  "imessage",
+  "sms",
+  "signal",
+  "whatsapp",
+  "x_dm",
+  "email",
+  "google_calendar",
+  "browser",
+  "phone",
+  "internal"
+];
+const LIFEOPS_POLICY_SUBJECT_KINDS = [
+  "owner",
+  "contact",
+  "household",
+  "agent",
+  "organization",
+  "automation",
+  "any"
+];
+const LIFEOPS_POLICY_RESOURCE_KINDS = [
+  "message",
+  "email",
+  "calendar_event",
+  "file",
+  "payment",
+  "contact",
+  "memory",
+  "browser_page",
+  "task",
+  "unknown"
+];
+const LIFEOPS_POLICY_EVIDENCE_SOURCES = [
+  "user_instruction",
+  "user_approval",
+  "admin_policy",
+  "migration",
+  "system_policy"
+];
+const COMPARISON_OPERATORS = [
+  "lt",
+  "lte",
+  "eq",
+  "gte",
+  "gt"
+];
+const APPROVAL_MODE_BY_EFFECT = {
+  allow: null,
+  deny: null,
+  require_approval: "approval_queue",
+  prompt_user_first: "prompt_user_first"
+};
+const OUTCOME_BY_EFFECT = {
+  allow: "allow",
+  deny: "deny",
+  require_approval: "require_approval",
+  prompt_user_first: "require_approval"
+};
+const EFFECT_SEVERITY = {
+  allow: 1,
+  require_approval: 2,
+  prompt_user_first: 2,
+  deny: 3
+};
+const SENSITIVITY_SCORE = {
+  public: 0,
+  routine: 1,
+  personal: 2,
+  confidential: 3,
+  restricted: 4
+};
+const DEFAULT_OUTCOME_BY_OPERATION = {
+  read_aloud: {
+    outcome: "require_approval",
+    reasonCode: "default_requires_approval"
+  },
+  delete: {
+    outcome: "deny",
+    reasonCode: "default_denies_high_risk_operation"
+  },
+  send: {
+    outcome: "require_approval",
+    reasonCode: "default_requires_approval"
+  },
+  spend_money: {
+    outcome: "deny",
+    reasonCode: "default_denies_high_risk_operation"
+  },
+  proofread_apply: {
+    outcome: "require_approval",
+    reasonCode: "default_requires_approval"
+  },
+  store_affect: {
+    outcome: "require_approval",
+    reasonCode: "default_requires_approval"
+  },
+  bulk_cleanup: {
+    outcome: "deny",
+    reasonCode: "default_denies_high_risk_operation"
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOneOf(value, allowed) {
+  return typeof value === "string" && allowed.some((item) => item === value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isFiniteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function readStringArray(value, field, errors) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    errors.push(`${field} must be an array`);
+    return void 0;
+  }
+  const result = [];
+  for (const item of value) {
+    if (!isNonEmptyString(item)) {
+      errors.push(`${field} entries must be non-empty strings`);
+      return void 0;
+    }
+    result.push(item.trim());
+  }
+  return result;
+}
+function readEnumArray(value, field, allowed, errors) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    errors.push(`${field} must be an array`);
+    return void 0;
+  }
+  const result = [];
+  for (const item of value) {
+    if (!isOneOf(item, allowed)) {
+      errors.push(`${field} contains unsupported value`);
+      return void 0;
+    }
+    result.push(item);
+  }
+  return result;
+}
+function isValidIsoDate(value) {
+  return Number.isFinite(Date.parse(value));
+}
+function isValidTimeZone(value) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value }).format(/* @__PURE__ */ new Date(0));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseDateInput(value) {
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value : null;
+  }
+  if (typeof value === "number") {
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) ? parsed : null;
+  }
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) ? parsed : null;
+  }
+  return /* @__PURE__ */ new Date();
+}
+function sensitivityCompare(left, right) {
+  return SENSITIVITY_SCORE[left] - SENSITIVITY_SCORE[right];
+}
+function compareNumber(left, operator, right) {
+  switch (operator) {
+    case "lt":
+      return left < right;
+    case "lte":
+      return left <= right;
+    case "eq":
+      return left === right;
+    case "gte":
+      return left >= right;
+    case "gt":
+      return left > right;
+  }
+}
+function normalizeRegion(value) {
+  if (!value) return void 0;
+  return value.trim().toUpperCase();
+}
+function arrayIntersects(left, right) {
+  if (!left || !right) return false;
+  return left.some((item) => right.includes(item));
+}
+function validateEvidence(value, field, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${field} must be an array`);
+    return;
+  }
+  if (value.length === 0) {
+    errors.push(`${field} is required for durable policy rules`);
+    return;
+  }
+  for (const item of value) {
+    if (!isRecord(item)) {
+      errors.push(`${field} entries must be objects`);
+      return;
+    }
+    if (!isOneOf(item.source, LIFEOPS_POLICY_EVIDENCE_SOURCES)) {
+      errors.push(`${field}.source is unsupported`);
+    }
+    if (!isNonEmptyString(item.sourceId)) {
+      errors.push(`${field}.sourceId is required`);
+    }
+    if (!isNonEmptyString(item.actorId)) {
+      errors.push(`${field}.actorId is required`);
+    }
+    if (!isNonEmptyString(item.recordedAt) || !isValidIsoDate(item.recordedAt)) {
+      errors.push(`${field}.recordedAt must be a valid ISO datetime`);
+    }
+    if (item.reviewId !== void 0 && !isNonEmptyString(item.reviewId)) {
+      errors.push(`${field}.reviewId must be a non-empty string when present`);
+    }
+  }
+}
+function validateSubjectSelector(value, errors) {
+  if (!isRecord(value)) {
+    errors.push("subject must be an object");
+    return;
+  }
+  if (!isOneOf(value.kind, LIFEOPS_POLICY_SUBJECT_KINDS)) {
+    errors.push("subject.kind is unsupported");
+  }
+  readStringArray(value.ids, "subject.ids", errors);
+  readStringArray(value.labels, "subject.labels", errors);
+  if (value.sensitivityAtLeast !== void 0 && !isOneOf(value.sensitivityAtLeast, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+    errors.push("subject.sensitivityAtLeast is unsupported");
+  }
+  if (value.sensitivityAtMost !== void 0 && !isOneOf(value.sensitivityAtMost, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+    errors.push("subject.sensitivityAtMost is unsupported");
+  }
+}
+function validateScopes(value, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push("scopes must be an object");
+    return;
+  }
+  readEnumArray(
+    value.surfaces,
+    "scopes.surfaces",
+    LIFEOPS_POLICY_SURFACES,
+    errors
+  );
+  readStringArray(value.regions, "scopes.regions", errors);
+  readEnumArray(
+    value.channels,
+    "scopes.channels",
+    LIFEOPS_POLICY_CHANNELS,
+    errors
+  );
+  readStringArray(value.contactIds, "scopes.contactIds", errors);
+  readEnumArray(
+    value.resourceKinds,
+    "scopes.resourceKinds",
+    LIFEOPS_POLICY_RESOURCE_KINDS,
+    errors
+  );
+  readStringArray(value.resourceIds, "scopes.resourceIds", errors);
+}
+function validateThresholds(value, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push("thresholds must be an object");
+    return;
+  }
+  if (value.maxAmountUsd !== void 0 && !isFiniteNonNegative(value.maxAmountUsd)) {
+    errors.push("thresholds.maxAmountUsd must be a non-negative finite number");
+  }
+  if (value.maxBulkItemCount !== void 0 && !isFiniteNonNegative(value.maxBulkItemCount)) {
+    errors.push(
+      "thresholds.maxBulkItemCount must be a non-negative finite number"
+    );
+  }
+  if (value.maxRecipientCount !== void 0 && !isFiniteNonNegative(value.maxRecipientCount)) {
+    errors.push(
+      "thresholds.maxRecipientCount must be a non-negative finite number"
+    );
+  }
+  if (value.maxSensitivity !== void 0 && !isOneOf(value.maxSensitivity, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+    errors.push("thresholds.maxSensitivity is unsupported");
+  }
+  if (value.maxContactSensitivity !== void 0 && !isOneOf(value.maxContactSensitivity, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+    errors.push("thresholds.maxContactSensitivity is unsupported");
+  }
+}
+function validateCondition(value, index, errors) {
+  if (!isRecord(value)) {
+    errors.push(`conditions[${index}] must be an object`);
+    return;
+  }
+  const field = `conditions[${index}]`;
+  switch (value.kind) {
+    case "amount_usd":
+    case "bulk_item_count":
+    case "recipient_count":
+      if (!isOneOf(value.operator, COMPARISON_OPERATORS)) {
+        errors.push(`${field}.operator is unsupported`);
+      }
+      if (!isFiniteNonNegative(value.value)) {
+        errors.push(`${field}.value must be a non-negative finite number`);
+      }
+      return;
+    case "request_sensitivity_at_least":
+    case "request_sensitivity_at_most":
+    case "contact_sensitivity_at_least":
+    case "contact_sensitivity_at_most":
+      if (!isOneOf(value.value, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+        errors.push(`${field}.value is unsupported`);
+      }
+      return;
+    case "currency_is":
+      if (!isNonEmptyString(value.value)) {
+        errors.push(`${field}.value must be a non-empty string`);
+      }
+      return;
+    default:
+      errors.push(`${field}.kind is unsupported`);
+  }
+}
+function validateConditions(value, errors) {
+  if (value === void 0) return;
+  if (!Array.isArray(value)) {
+    errors.push("conditions must be an array");
+    return;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    validateCondition(value[index], index, errors);
+  }
+}
+function validateEffectiveWindow(value, errors) {
+  if (value === void 0) return;
+  if (!isRecord(value)) {
+    errors.push("effectiveWindow must be an object");
+    return;
+  }
+  if (value.startsAt !== void 0 && (!isNonEmptyString(value.startsAt) || !isValidIsoDate(value.startsAt))) {
+    errors.push("effectiveWindow.startsAt must be a valid ISO datetime");
+  }
+  if (value.endsAt !== void 0 && (!isNonEmptyString(value.endsAt) || !isValidIsoDate(value.endsAt))) {
+    errors.push("effectiveWindow.endsAt must be a valid ISO datetime");
+  }
+  if (value.timezone !== void 0 && (!isNonEmptyString(value.timezone) || !isValidTimeZone(value.timezone))) {
+    errors.push("effectiveWindow.timezone must be a valid IANA timezone");
+  }
+  if (value.daysOfWeek !== void 0) {
+    if (!Array.isArray(value.daysOfWeek)) {
+      errors.push("effectiveWindow.daysOfWeek must be an array");
+    } else {
+      for (const day of value.daysOfWeek) {
+        if (!Number.isInteger(day) || day < 0 || day > 6) {
+          errors.push(
+            "effectiveWindow.daysOfWeek entries must be integers 0..6"
+          );
+          break;
+        }
+      }
+    }
+  }
+  const start = value.startMinuteOfDay;
+  const end = value.endMinuteOfDay;
+  if (start !== void 0 && (typeof start !== "number" || !Number.isInteger(start) || start < 0 || start > 1439)) {
+    errors.push("effectiveWindow.startMinuteOfDay must be an integer 0..1439");
+  }
+  if (end !== void 0 && (typeof end !== "number" || !Number.isInteger(end) || end < 1 || end > 1440)) {
+    errors.push("effectiveWindow.endMinuteOfDay must be an integer 1..1440");
+  }
+  if (start === void 0 !== (end === void 0)) {
+    errors.push(
+      "effectiveWindow.startMinuteOfDay and endMinuteOfDay must be provided together"
+    );
+  }
+}
+function validateLifeOpsPolicyRule(rule) {
+  const errors = [];
+  const ruleId = isRecord(rule) && isNonEmptyString(rule.id) ? rule.id.trim() : "unknown";
+  if (!isRecord(rule)) {
+    return {
+      valid: false,
+      ruleId,
+      errors: ["rule must be an object"]
+    };
+  }
+  if (rule.kind !== "lifeops_policy_rule") {
+    errors.push("kind must be lifeops_policy_rule");
+  }
+  if (!isNonEmptyString(rule.id)) {
+    errors.push("id is required");
+  }
+  if (rule.version !== 1) {
+    errors.push("version must be 1");
+  }
+  readEnumArray(
+    rule.operations,
+    "operations",
+    LIFEOPS_POLICY_OPERATIONS,
+    errors
+  );
+  if (Array.isArray(rule.operations) && rule.operations.length === 0) {
+    errors.push("operations must contain at least one operation");
+  }
+  if (!isOneOf(rule.effect, LIFEOPS_POLICY_EFFECTS)) {
+    errors.push("effect is unsupported");
+  }
+  validateSubjectSelector(rule.subject, errors);
+  validateScopes(rule.scopes, errors);
+  validateConditions(rule.conditions, errors);
+  validateThresholds(rule.thresholds, errors);
+  if (!Number.isInteger(rule.precedence)) {
+    errors.push("precedence must be an integer");
+  }
+  validateEffectiveWindow(rule.effectiveWindow, errors);
+  if (rule.expiresAt !== void 0 && (!isNonEmptyString(rule.expiresAt) || !isValidIsoDate(rule.expiresAt))) {
+    errors.push("expiresAt must be a valid ISO datetime");
+  }
+  validateEvidence(rule.evidence, "evidence", errors);
+  if (!isOneOf(rule.reviewState, LIFEOPS_POLICY_REVIEW_STATES)) {
+    errors.push("reviewState is unsupported");
+  }
+  return {
+    valid: errors.length === 0,
+    ruleId,
+    errors
+  };
+}
+function validateRequest(request) {
+  const errors = [];
+  if (!isNonEmptyString(request.requestId)) {
+    errors.push("requestId is required");
+  }
+  if (!isOneOf(request.operation, LIFEOPS_POLICY_OPERATIONS)) {
+    errors.push("operation is unsupported");
+  }
+  if (!isNonEmptyString(request.requestedBy)) {
+    errors.push("requestedBy is required");
+  }
+  if (!isOneOf(request.sensitivity, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+    errors.push("sensitivity is unsupported");
+  }
+  if (request.contactSensitivity !== void 0 && !isOneOf(request.contactSensitivity, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+    errors.push("contactSensitivity is unsupported");
+  }
+  if (!isRecord(request.scope)) {
+    errors.push("scope must be an object");
+  } else {
+    if (!isOneOf(request.scope.surface, LIFEOPS_POLICY_SURFACES)) {
+      errors.push("scope.surface is unsupported");
+    }
+    if (request.scope.channel !== void 0 && !isOneOf(request.scope.channel, LIFEOPS_POLICY_CHANNELS)) {
+      errors.push("scope.channel is unsupported");
+    }
+    if (request.scope.resource) {
+      if (!isRecord(request.scope.resource)) {
+        errors.push("scope.resource must be an object");
+      } else {
+        if (!isOneOf(request.scope.resource.kind, LIFEOPS_POLICY_RESOURCE_KINDS)) {
+          errors.push("scope.resource.kind is unsupported");
+        }
+        if (!isNonEmptyString(request.scope.resource.id)) {
+          errors.push("scope.resource.id is required");
+        }
+      }
+    }
+  }
+  if (!isRecord(request.subject)) {
+    errors.push("subject must be an object");
+  } else {
+    if (!isOneOf(request.subject.kind, LIFEOPS_POLICY_SUBJECT_KINDS)) {
+      errors.push("subject.kind is unsupported");
+    }
+    if (!isNonEmptyString(request.subject.id)) {
+      errors.push("subject.id is required");
+    }
+    if (!isOneOf(request.subject.sensitivity, LIFEOPS_POLICY_SENSITIVITY_LEVELS)) {
+      errors.push("subject.sensitivity is unsupported");
+    }
+  }
+  if (request.amountUsd !== void 0 && !isFiniteNonNegative(request.amountUsd)) {
+    errors.push("amountUsd must be a non-negative finite number");
+  }
+  if (request.operation === "spend_money" && !isFiniteNonNegative(request.amountUsd)) {
+    errors.push("amountUsd is required for spend_money");
+  }
+  if (request.bulkItemCount !== void 0 && !isFiniteNonNegative(request.bulkItemCount)) {
+    errors.push("bulkItemCount must be a non-negative finite number");
+  }
+  if (request.operation === "bulk_cleanup" && !isFiniteNonNegative(request.bulkItemCount)) {
+    errors.push("bulkItemCount is required for bulk_cleanup");
+  }
+  if (request.recipientCount !== void 0 && !isFiniteNonNegative(request.recipientCount)) {
+    errors.push("recipientCount must be a non-negative finite number");
+  }
+  if (request.now !== void 0 && parseDateInput(request.now) === null) {
+    errors.push("now must be a valid date");
+  }
+  return errors;
+}
+function evidenceIds(rule) {
+  return rule.evidence.map((item) => `${item.source}:${item.sourceId}`);
+}
+function calculateSpecificity(rule) {
+  let score = 0;
+  if (rule.operations.length < LIFEOPS_POLICY_OPERATIONS.length) score += 2;
+  if (rule.subject.kind !== "any") score += 2;
+  score += (rule.subject.ids?.length ?? 0) * 4;
+  score += (rule.subject.labels?.length ?? 0) * 2;
+  if (rule.subject.sensitivityAtLeast) score += 1;
+  if (rule.subject.sensitivityAtMost) score += 1;
+  const scopes = rule.scopes;
+  if (scopes) {
+    score += (scopes.surfaces?.length ?? 0) * 2;
+    score += (scopes.regions?.length ?? 0) * 2;
+    score += (scopes.channels?.length ?? 0) * 2;
+    score += (scopes.contactIds?.length ?? 0) * 4;
+    score += (scopes.resourceKinds?.length ?? 0) * 2;
+    score += (scopes.resourceIds?.length ?? 0) * 4;
+  }
+  const thresholds = rule.thresholds;
+  if (thresholds) {
+    if (thresholds.maxAmountUsd !== void 0) score += 2;
+    if (thresholds.maxBulkItemCount !== void 0) score += 2;
+    if (thresholds.maxRecipientCount !== void 0) score += 2;
+    if (thresholds.maxSensitivity !== void 0) score += 1;
+    if (thresholds.maxContactSensitivity !== void 0) score += 1;
+  }
+  score += (rule.conditions?.length ?? 0) * 3;
+  if (rule.effectiveWindow) score += 1;
+  return score;
+}
+function effectiveWindowContains(window, now) {
+  if (window.startsAt && now.getTime() < Date.parse(window.startsAt)) {
+    return false;
+  }
+  if (window.endsAt && now.getTime() >= Date.parse(window.endsAt)) {
+    return false;
+  }
+  if (window.daysOfWeek || window.startMinuteOfDay !== void 0) {
+    const timezone = window.timezone ?? "UTC";
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      weekday: "short",
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit"
+    }).formatToParts(now);
+    const weekday = parts.find((part) => part.type === "weekday")?.value;
+    const day = weekdayToIndex(weekday);
+    if (window.daysOfWeek && (day === null || !window.daysOfWeek.includes(day))) {
+      return false;
+    }
+    if (window.startMinuteOfDay !== void 0 && window.endMinuteOfDay !== void 0) {
+      const hourText = parts.find((part) => part.type === "hour")?.value;
+      const minuteText = parts.find((part) => part.type === "minute")?.value;
+      const hour = hourText ? Number.parseInt(hourText, 10) % 24 : 0;
+      const minute = minuteText ? Number.parseInt(minuteText, 10) : 0;
+      const minuteOfDay = hour * 60 + minute;
+      return minuteWithinWindow(
+        minuteOfDay,
+        window.startMinuteOfDay,
+        window.endMinuteOfDay
+      );
+    }
+  }
+  return true;
+}
+function weekdayToIndex(value) {
+  switch (value) {
+    case "Sun":
+      return 0;
+    case "Mon":
+      return 1;
+    case "Tue":
+      return 2;
+    case "Wed":
+      return 3;
+    case "Thu":
+      return 4;
+    case "Fri":
+      return 5;
+    case "Sat":
+      return 6;
+    default:
+      return null;
+  }
+}
+function minuteWithinWindow(minuteOfDay, startMinute, endMinute) {
+  if (startMinute === endMinute) return false;
+  if (startMinute > endMinute) {
+    return minuteOfDay >= startMinute || minuteOfDay < endMinute;
+  }
+  return minuteOfDay >= startMinute && minuteOfDay < endMinute;
+}
+function matchesSubject(selector, subject) {
+  if (selector.kind !== "any" && selector.kind !== subject.kind) {
+    return false;
+  }
+  if (selector.ids && !selector.ids.includes(subject.id)) {
+    return false;
+  }
+  if (selector.labels && !arrayIntersects(selector.labels, subject.labels)) {
+    return false;
+  }
+  if (selector.sensitivityAtLeast && sensitivityCompare(subject.sensitivity, selector.sensitivityAtLeast) < 0) {
+    return false;
+  }
+  if (selector.sensitivityAtMost && sensitivityCompare(subject.sensitivity, selector.sensitivityAtMost) > 0) {
+    return false;
+  }
+  return true;
+}
+function matchesScope(scopes, request) {
+  if (!scopes) return true;
+  if (scopes.surfaces && !scopes.surfaces.includes(request.scope.surface)) {
+    return false;
+  }
+  if (scopes.regions) {
+    const requestRegion = normalizeRegion(request.scope.region);
+    const allowedRegions = scopes.regions.map(
+      (region) => normalizeRegion(region)
+    );
+    if (!requestRegion || !allowedRegions.includes(requestRegion)) {
+      return false;
+    }
+  }
+  if (scopes.channels && (!request.scope.channel || !scopes.channels.includes(request.scope.channel))) {
+    return false;
+  }
+  if (scopes.contactIds && (!request.scope.contactId || !scopes.contactIds.includes(request.scope.contactId))) {
+    return false;
+  }
+  if (scopes.resourceKinds && (!request.scope.resource || !scopes.resourceKinds.includes(request.scope.resource.kind))) {
+    return false;
+  }
+  if (scopes.resourceIds && (!request.scope.resource || !scopes.resourceIds.includes(request.scope.resource.id))) {
+    return false;
+  }
+  return true;
+}
+function thresholdsSatisfied(thresholds, request) {
+  if (!thresholds) return true;
+  if (thresholds.maxAmountUsd !== void 0 && (request.amountUsd === void 0 || request.amountUsd > thresholds.maxAmountUsd)) {
+    return false;
+  }
+  if (thresholds.maxBulkItemCount !== void 0 && (request.bulkItemCount === void 0 || request.bulkItemCount > thresholds.maxBulkItemCount)) {
+    return false;
+  }
+  if (thresholds.maxRecipientCount !== void 0 && (request.recipientCount === void 0 || request.recipientCount > thresholds.maxRecipientCount)) {
+    return false;
+  }
+  if (thresholds.maxSensitivity !== void 0 && sensitivityCompare(request.sensitivity, thresholds.maxSensitivity) > 0) {
+    return false;
+  }
+  if (thresholds.maxContactSensitivity !== void 0 && (request.contactSensitivity === void 0 || sensitivityCompare(
+    request.contactSensitivity,
+    thresholds.maxContactSensitivity
+  ) > 0)) {
+    return false;
+  }
+  return true;
+}
+function conditionSatisfied(condition, request) {
+  switch (condition.kind) {
+    case "amount_usd":
+      return request.amountUsd !== void 0 && compareNumber(request.amountUsd, condition.operator, condition.value);
+    case "bulk_item_count":
+      return request.bulkItemCount !== void 0 && compareNumber(
+        request.bulkItemCount,
+        condition.operator,
+        condition.value
+      );
+    case "recipient_count":
+      return request.recipientCount !== void 0 && compareNumber(
+        request.recipientCount,
+        condition.operator,
+        condition.value
+      );
+    case "request_sensitivity_at_least":
+      return sensitivityCompare(request.sensitivity, condition.value) >= 0;
+    case "request_sensitivity_at_most":
+      return sensitivityCompare(request.sensitivity, condition.value) <= 0;
+    case "contact_sensitivity_at_least":
+      return request.contactSensitivity !== void 0 && sensitivityCompare(request.contactSensitivity, condition.value) >= 0;
+    case "contact_sensitivity_at_most":
+      return request.contactSensitivity !== void 0 && sensitivityCompare(request.contactSensitivity, condition.value) <= 0;
+    case "currency_is":
+      return request.currency !== void 0 && request.currency.trim().toUpperCase() === condition.value.trim().toUpperCase();
+  }
+}
+function conditionsSatisfied(conditions, request) {
+  if (!conditions) return true;
+  return conditions.every(
+    (condition) => conditionSatisfied(condition, request)
+  );
+}
+function matchRule(rule, request, now) {
+  if (rule.reviewState !== "active") {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "review_state_not_active" }
+    };
+  }
+  if (!rule.operations.includes(request.operation)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "operation_mismatch" }
+    };
+  }
+  if (rule.expiresAt && now.getTime() >= Date.parse(rule.expiresAt)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "expired" }
+    };
+  }
+  if (rule.effectiveWindow && !effectiveWindowContains(rule.effectiveWindow, now)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "outside_effective_window" }
+    };
+  }
+  if (!matchesSubject(rule.subject, request.subject)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "subject_mismatch" }
+    };
+  }
+  if (!matchesScope(rule.scopes, request)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "scope_mismatch" }
+    };
+  }
+  if (!thresholdsSatisfied(rule.thresholds, request)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "threshold_not_satisfied" }
+    };
+  }
+  if (!conditionsSatisfied(rule.conditions, request)) {
+    return {
+      matched: false,
+      ignored: { ruleId: rule.id, reason: "condition_not_satisfied" }
+    };
+  }
+  const specificity = calculateSpecificity(rule);
+  return {
+    matched: true,
+    rule,
+    auditRef: {
+      ruleId: rule.id,
+      effect: rule.effect,
+      precedence: rule.precedence,
+      specificity,
+      evidenceIds: evidenceIds(rule)
+    }
+  };
+}
+function buildDecision(args) {
+  const reasonCodes = args.reasons.map((reason) => reason.code);
+  const evaluatedAt = args.now.toISOString();
+  return {
+    requestId: args.request.requestId,
+    operation: args.request.operation,
+    outcome: args.outcome,
+    approvalMode: args.approvalMode,
+    reasons: args.reasons,
+    record: {
+      decisionId: `lifeops-policy:${args.request.requestId}:${args.now.getTime()}`,
+      evaluatedAt,
+      requestId: args.request.requestId,
+      requestedBy: args.request.requestedBy,
+      operation: args.request.operation,
+      outcome: args.outcome,
+      approvalMode: args.approvalMode,
+      reasonCodes,
+      selectedRules: args.selectedRules,
+      matchedRules: args.matchedRules,
+      ignoredRules: args.ignoredRules,
+      invalidRules: args.invalidRules
+    }
+  };
+}
+function chooseTopMatches(matches) {
+  const maxPrecedence = Math.max(
+    ...matches.map((match) => match.auditRef.precedence)
+  );
+  const samePrecedence = matches.filter(
+    (match) => match.auditRef.precedence === maxPrecedence
+  );
+  const maxSpecificity = Math.max(
+    ...samePrecedence.map((match) => match.auditRef.specificity)
+  );
+  return samePrecedence.filter(
+    (match) => match.auditRef.specificity === maxSpecificity
+  );
+}
+function chooseEffect(matches) {
+  let effect = "allow";
+  for (const match of matches) {
+    if (EFFECT_SEVERITY[match.effect] > EFFECT_SEVERITY[effect]) {
+      effect = match.effect;
+    }
+    if (EFFECT_SEVERITY[match.effect] === EFFECT_SEVERITY[effect] && match.effect === "prompt_user_first") {
+      effect = "prompt_user_first";
+    }
+  }
+  return effect;
+}
+function reasonForEffect(effect) {
+  switch (effect) {
+    case "allow":
+      return "allowed_by_rule";
+    case "deny":
+      return "denied_by_rule";
+    case "require_approval":
+      return "approval_required_by_rule";
+    case "prompt_user_first":
+      return "prompt_user_first";
+  }
+}
+class LifeOpsPolicyMemoryEvaluator {
+  rules;
+  constructor(rules) {
+    this.rules = rules;
+  }
+  evaluate(request) {
+    return evaluateLifeOpsPolicyMemory(request, this.rules);
+  }
+}
+function evaluateLifeOpsPolicyMemory(request, rules) {
+  const now = parseDateInput(request.now);
+  const effectiveNow = now ?? /* @__PURE__ */ new Date(0);
+  const requestErrors = validateRequest(request);
+  if (requestErrors.length > 0 || now === null) {
+    const errors = now === null ? [...requestErrors, "now must be a valid date"] : requestErrors;
+    return buildDecision({
+      request,
+      now: effectiveNow,
+      outcome: "deny",
+      approvalMode: null,
+      reasons: [
+        {
+          code: "malformed_request",
+          detail: { errorCount: errors.length }
+        }
+      ],
+      selectedRules: [],
+      matchedRules: [],
+      ignoredRules: [],
+      invalidRules: [
+        {
+          ruleId: "request",
+          errors
+        }
+      ]
+    });
+  }
+  const invalidRules = [];
+  const seenRuleIds = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    const validation = validateLifeOpsPolicyRule(rule);
+    if (!validation.valid) {
+      invalidRules.push({
+        ruleId: validation.ruleId,
+        errors: validation.errors
+      });
+    }
+    if (seenRuleIds.has(validation.ruleId)) {
+      invalidRules.push({
+        ruleId: validation.ruleId,
+        errors: ["duplicate rule id"]
+      });
+    }
+    seenRuleIds.add(validation.ruleId);
+  }
+  if (invalidRules.length > 0) {
+    const duplicateRuleIds = invalidRules.filter(
+      (rule) => rule.errors.includes("duplicate rule id")
+    );
+    const reasons2 = [
+      {
+        code: "malformed_rule",
+        detail: { invalidRuleCount: invalidRules.length }
+      }
+    ];
+    if (duplicateRuleIds.length > 0) {
+      reasons2.push({
+        code: "duplicate_rule_id",
+        ruleIds: duplicateRuleIds.map((rule) => rule.ruleId)
+      });
+    }
+    return buildDecision({
+      request,
+      now: effectiveNow,
+      outcome: "deny",
+      approvalMode: null,
+      reasons: reasons2,
+      selectedRules: [],
+      matchedRules: [],
+      ignoredRules: [],
+      invalidRules
+    });
+  }
+  const matchedRules = [];
+  const ignoredRules = [];
+  for (const rule of rules) {
+    const result = matchRule(rule, request, effectiveNow);
+    if (result.matched === true) {
+      matchedRules.push({
+        rule: result.rule,
+        auditRef: result.auditRef
+      });
+    } else {
+      ignoredRules.push(result.ignored);
+    }
+  }
+  if (matchedRules.length === 0) {
+    const fallback = DEFAULT_OUTCOME_BY_OPERATION[request.operation];
+    return buildDecision({
+      request,
+      now: effectiveNow,
+      outcome: fallback.outcome,
+      approvalMode: fallback.outcome === "require_approval" ? "approval_queue" : null,
+      reasons: [{ code: fallback.reasonCode }],
+      selectedRules: [],
+      matchedRules: [],
+      ignoredRules,
+      invalidRules: []
+    });
+  }
+  const topMatches = chooseTopMatches(matchedRules);
+  const selectedEffect = chooseEffect(topMatches.map((match) => match.rule));
+  const selectedRules = topMatches.filter((match) => match.rule.effect === selectedEffect).map((match) => match.auditRef);
+  const topEffects = new Set(topMatches.map((match) => match.rule.effect));
+  const reasons = [
+    {
+      code: reasonForEffect(selectedEffect),
+      ruleIds: selectedRules.map((rule) => rule.ruleId)
+    }
+  ];
+  if (topEffects.size > 1) {
+    reasons.push({
+      code: "conflicting_top_rank_rules_resolved_conservatively",
+      ruleIds: topMatches.map((match) => match.rule.id)
+    });
+  }
+  return buildDecision({
+    request,
+    now: effectiveNow,
+    outcome: OUTCOME_BY_EFFECT[selectedEffect],
+    approvalMode: APPROVAL_MODE_BY_EFFECT[selectedEffect],
+    reasons,
+    selectedRules,
+    matchedRules: matchedRules.map((match) => match.auditRef),
+    ignoredRules,
+    invalidRules: []
+  });
+}
+export {
+  LIFEOPS_POLICY_CHANNELS,
+  LIFEOPS_POLICY_EFFECTS,
+  LIFEOPS_POLICY_EVIDENCE_SOURCES,
+  LIFEOPS_POLICY_OPERATIONS,
+  LIFEOPS_POLICY_RESOURCE_KINDS,
+  LIFEOPS_POLICY_REVIEW_STATES,
+  LIFEOPS_POLICY_SENSITIVITY_LEVELS,
+  LIFEOPS_POLICY_SUBJECT_KINDS,
+  LIFEOPS_POLICY_SURFACES,
+  LifeOpsPolicyMemoryEvaluator,
+  evaluateLifeOpsPolicyMemory,
+  validateLifeOpsPolicyRule
+};
+//# sourceMappingURL=policy-memory.js.map