multicorn-shield 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2507 @@
+'use strict';
+
+var lit = require('lit');
+var decorators_js = require('lit/decorators.js');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/types/index.ts
+var AGENT_STATUSES = {
+  Active: "active",
+  Paused: "paused",
+  Revoked: "revoked"
+};
+var PERMISSION_LEVELS = {
+  Read: "read",
+  Write: "write",
+  Execute: "execute",
+  Publish: "publish",
+  Create: "create"
+};
+var ACTION_STATUSES = {
+  Approved: "approved",
+  Blocked: "blocked",
+  Pending: "pending",
+  Flagged: "flagged",
+  RequiresApproval: "requires_approval"
+};
+
+// src/scopes/scope-definitions.ts
+var BUILT_IN_SERVICES = {
+  gmail: {
+    name: "gmail",
+    description: "Google Gmail: email reading, composing, and sending",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Write, PERMISSION_LEVELS.Execute]
+  },
+  calendar: {
+    name: "calendar",
+    description: "Google Calendar: event viewing, creation, and management",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Write, PERMISSION_LEVELS.Execute]
+  },
+  slack: {
+    name: "slack",
+    description: "Slack: message reading, posting, and workflow triggers",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Write, PERMISSION_LEVELS.Execute]
+  },
+  drive: {
+    name: "drive",
+    description: "Google Drive: file browsing, uploading, and sharing",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Write]
+  },
+  payments: {
+    name: "payments",
+    description: "Payment processing: balance enquiries and transaction execution",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Execute]
+  },
+  github: {
+    name: "github",
+    description: "GitHub: repository access, issues, and pull requests",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Write, PERMISSION_LEVELS.Execute]
+  },
+  jira: {
+    name: "jira",
+    description: "Jira: issue tracking, sprint management, and reporting",
+    capabilities: [PERMISSION_LEVELS.Read, PERMISSION_LEVELS.Write]
+  },
+  web: {
+    name: "web",
+    description: "Web publishing: content accessible on the open internet",
+    capabilities: [PERMISSION_LEVELS.Publish]
+  },
+  public_content: {
+    name: "public_content",
+    description: "Public content creation: blog posts, social media, public repositories",
+    capabilities: [PERMISSION_LEVELS.Create]
+  }
+};
+var SERVICE_NAME_PATTERN = /^[a-z][a-z0-9_-]*$/;
+function createScopeRegistry() {
+  const services = /* @__PURE__ */ new Map();
+  const validPermissionLevels = new Set(Object.values(PERMISSION_LEVELS));
+  for (const service of Object.values(BUILT_IN_SERVICES)) {
+    services.set(service.name, service);
+  }
+  function validateDefinition(definition) {
+    if (definition.name.length === 0) {
+      throw new Error(
+        'Service name must not be empty. Provide a lowercase identifier such as "my-service".'
+      );
+    }
+    if (!SERVICE_NAME_PATTERN.test(definition.name)) {
+      throw new Error(
+        `Invalid service name "${definition.name}". Service names must start with a lowercase letter and contain only lowercase letters, digits, hyphens, or underscores (e.g. "my-service", "analytics2").`
+      );
+    }
+    if (definition.capabilities.length === 0) {
+      throw new Error(
+        `Service "${definition.name}" must declare at least one capability (${[...validPermissionLevels].join(", ")}).`
+      );
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const cap of definition.capabilities) {
+      if (!validPermissionLevels.has(cap)) {
+        throw new Error(
+          `Invalid capability "${cap}" for service "${definition.name}". Valid capabilities are: ${[...validPermissionLevels].join(", ")}.`
+        );
+      }
+      if (seen.has(cap)) {
+        throw new Error(
+          `Duplicate capability "${cap}" in service "${definition.name}". Each capability should be listed only once.`
+        );
+      }
+      seen.add(cap);
+    }
+  }
+  return {
+    register(definition) {
+      validateDefinition(definition);
+      if (services.has(definition.name)) {
+        throw new Error(
+          `Service "${definition.name}" is already registered. Choose a unique name for your custom service.`
+        );
+      }
+      services.set(definition.name, {
+        name: definition.name,
+        description: definition.description,
+        capabilities: [...definition.capabilities]
+      });
+    },
+    get(serviceName) {
+      return services.get(serviceName);
+    },
+    has(serviceName) {
+      return services.has(serviceName);
+    },
+    getAllServices() {
+      return [...services.values()];
+    },
+    isValidScope(scope) {
+      const service = services.get(scope.service);
+      if (!service) {
+        return false;
+      }
+      return service.capabilities.includes(scope.permissionLevel);
+    }
+  };
+}
+
+// src/scopes/scope-parser.ts
+var VALID_PERMISSION_LEVELS = new Set(Object.values(PERMISSION_LEVELS));
+var PERMISSION_LEVEL_LIST = [...VALID_PERMISSION_LEVELS].join(", ");
+var ScopeParseError = class extends Error {
+  constructor(message, input) {
+    super(message);
+    this.name = "ScopeParseError";
+    this.input = input;
+  }
+};
+function doParse(input) {
+  if (input.length === 0) {
+    return {
+      success: false,
+      error: 'Scope string must not be empty. Expected format: "permission:service" (e.g. "read:gmail").'
+    };
+  }
+  if (/\s/.test(input)) {
+    return {
+      success: false,
+      error: `Scope string "${input}" contains whitespace. Remove any spaces, tabs, or newlines. Expected format: "permission:service" (e.g. "read:gmail").`
+    };
+  }
+  const colonIndex = input.indexOf(":");
+  if (colonIndex === -1) {
+    return {
+      success: false,
+      error: `Invalid scope string "${input}": missing ":" separator. Expected format: "permission:service" (e.g. "read:gmail").`
+    };
+  }
+  if (input.includes(":", colonIndex + 1)) {
+    return {
+      success: false,
+      error: `Invalid scope string "${input}": contains multiple ":" separators. Expected exactly one ":" separating permission and service (e.g. "read:gmail").`
+    };
+  }
+  const permission = input.slice(0, colonIndex);
+  const service = input.slice(colonIndex + 1);
+  if (permission.length === 0) {
+    return {
+      success: false,
+      error: `Invalid scope string "${input}": permission level is empty. Provide one of: ${PERMISSION_LEVEL_LIST} (e.g. "read:gmail").`
+    };
+  }
+  if (!VALID_PERMISSION_LEVELS.has(permission)) {
+    return {
+      success: false,
+      error: `Unknown permission level "${permission}" in scope string "${input}". Valid permission levels are: ${PERMISSION_LEVEL_LIST}.`
+    };
+  }
+  if (service.length === 0) {
+    return {
+      success: false,
+      error: `Invalid scope string "${input}": service name is empty. Provide a service name after the ":" (e.g. "read:gmail").`
+    };
+  }
+  if (!SERVICE_NAME_PATTERN.test(service)) {
+    return {
+      success: false,
+      error: `Invalid service name "${service}" in scope string "${input}". Service names must start with a lowercase letter and contain only lowercase letters, digits, hyphens, or underscores (e.g. "gmail", "my-service").`
+    };
+  }
+  return {
+    success: true,
+    scope: {
+      service,
+      permissionLevel: permission
+    }
+  };
+}
+function parseScope(input) {
+  const result = doParse(input);
+  if (result.success) {
+    return result.scope;
+  }
+  throw new ScopeParseError(result.error, input);
+}
+function parseScopes(inputs) {
+  const results = [];
+  for (const input of inputs) {
+    results.push(parseScope(input));
+  }
+  return results;
+}
+function tryParseScope(input) {
+  return doParse(input);
+}
+function formatScope(scope) {
+  return `${scope.permissionLevel}:${scope.service}`;
+}
+function isValidScopeString(input) {
+  return doParse(input).success;
+}
+
+// src/scopes/scope-validator.ts
+function validateScopeAccess(grantedScopes, requested) {
+  const isGranted = grantedScopes.some(
+    (granted) => granted.service === requested.service && granted.permissionLevel === requested.permissionLevel
+  );
+  if (isGranted) {
+    return { allowed: true };
+  }
+  const serviceScopes = grantedScopes.filter((g) => g.service === requested.service);
+  if (serviceScopes.length > 0) {
+    const grantedLevels = serviceScopes.map((g) => `"${g.permissionLevel}"`).join(", ");
+    return {
+      allowed: false,
+      reason: `Permission "${requested.permissionLevel}" is not granted for service "${requested.service}". Currently granted permission level(s): ${grantedLevels}. Requested scope "${formatScope(requested)}" requires explicit consent.`
+    };
+  }
+  return {
+    allowed: false,
+    reason: `No permissions granted for service "${requested.service}". The agent has not been authorised to access this service. Request scope "${formatScope(requested)}" via the consent screen.`
+  };
+}
+function validateAllScopesAccess(grantedScopes, requestedScopes) {
+  if (requestedScopes.length === 0) {
+    return { allowed: true };
+  }
+  for (const requested of requestedScopes) {
+    const result = validateScopeAccess(grantedScopes, requested);
+    if (!result.allowed) {
+      return result;
+    }
+  }
+  return { allowed: true };
+}
+function hasScope(grantedScopes, requested) {
+  return grantedScopes.some(
+    (granted) => granted.service === requested.service && granted.permissionLevel === requested.permissionLevel
+  );
+}
+
+// src/consent/scope-labels.ts
+var SERVICE_DISPLAY_NAMES = {
+  gmail: "Gmail",
+  calendar: "Google Calendar",
+  slack: "Slack",
+  drive: "Google Drive",
+  payments: "Payments",
+  github: "GitHub",
+  jira: "Jira",
+  web: "Web",
+  public_content: "Public Content"
+};
+var SERVICE_ICONS = {
+  gmail: "\u{1F4E7}",
+  calendar: "\u{1F4C5}",
+  slack: "\u{1F4AC}",
+  drive: "\u{1F4C1}",
+  payments: "\u{1F4B3}",
+  github: "\u{1F419}",
+  jira: "\u{1F3AF}",
+  web: "\u{1F310}",
+  public_content: "\u{1F4E2}"
+};
+var PERMISSION_DESCRIPTIONS = {
+  [PERMISSION_LEVELS.Read]: "Read",
+  [PERMISSION_LEVELS.Write]: "Create and modify",
+  [PERMISSION_LEVELS.Execute]: "Execute actions",
+  [PERMISSION_LEVELS.Publish]: "Publish",
+  [PERMISSION_LEVELS.Create]: "Create"
+};
+var PERMISSION_FULL_DESCRIPTIONS = {
+  [PERMISSION_LEVELS.Read]: (serviceName) => `Read your ${serviceName}`,
+  [PERMISSION_LEVELS.Write]: (serviceName) => `Create and modify ${serviceName} content`,
+  [PERMISSION_LEVELS.Execute]: (serviceName) => {
+    if (serviceName.toLowerCase().includes("payment")) {
+      return "Make purchases on your behalf";
+    }
+    return `Execute actions in ${serviceName}`;
+  },
+  [PERMISSION_LEVELS.Publish]: (serviceName, rawServiceName) => {
+    if (rawServiceName.toLowerCase() === "web") {
+      return "Publish content to the open internet";
+    }
+    return `Publish ${serviceName} content`;
+  },
+  [PERMISSION_LEVELS.Create]: (serviceName, rawServiceName) => {
+    if (rawServiceName.toLowerCase() === "public_content") {
+      return "Create content that is immediately public";
+    }
+    return `Create ${serviceName}`;
+  }
+};
+function getServiceDisplayName(serviceName) {
+  return SERVICE_DISPLAY_NAMES[serviceName] ?? capitalizeServiceName(serviceName);
+}
+function getServiceIcon(serviceName) {
+  return SERVICE_ICONS[serviceName] ?? "\u{1F50C}";
+}
+function getPermissionLabel(permissionLevel) {
+  return PERMISSION_DESCRIPTIONS[permissionLevel];
+}
+function getScopeLabel(scope) {
+  const serviceDisplayName = getServiceDisplayName(scope.service);
+  const descriptionFn = PERMISSION_FULL_DESCRIPTIONS[scope.permissionLevel];
+  return descriptionFn(serviceDisplayName, scope.service);
+}
+function getScopeShortLabel(scope) {
+  const serviceDisplayName = getServiceDisplayName(scope.service);
+  const permissionLabel = getPermissionLabel(scope.permissionLevel);
+  return `${serviceDisplayName}: ${permissionLabel}`;
+}
+function capitalizeServiceName(serviceName) {
+  if (serviceName.length === 0) {
+    return serviceName;
+  }
+  return serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
+}
+
+// src/scopes/scope-metadata.ts
+var SCOPE_METADATA = /* @__PURE__ */ new Map([
+  [
+    "publish:web",
+    {
+      riskLevel: "high",
+      requiresExplicitOptIn: true,
+      warningMessage: "This agent is requesting permission to publish content publicly on the internet"
+    }
+  ],
+  [
+    "create:public_content",
+    {
+      riskLevel: "high",
+      requiresExplicitOptIn: true,
+      warningMessage: "This agent is requesting permission to publish content publicly on the internet"
+    }
+  ]
+]);
+function getScopeMetadata(scopeString) {
+  return SCOPE_METADATA.get(scopeString);
+}
+function isHighRiskScope(scopeString) {
+  const metadata = getScopeMetadata(scopeString);
+  return metadata?.riskLevel === "high";
+}
+function requiresExplicitOptIn(scopeString) {
+  const metadata = getScopeMetadata(scopeString);
+  return metadata?.requiresExplicitOptIn ?? false;
+}
+function getScopeWarning(scopeString) {
+  const metadata = getScopeMetadata(scopeString);
+  return metadata?.warningMessage;
+}
+var SHIELD_COLORS = {
+  bg: "#0d0d14",
+  surface: "#14141f",
+  surfaceHover: "#1a1a2e",
+  border: "#2a2a3d",
+  borderLight: "#3a3a52",
+  text: "#e8e8f0",
+  textMuted: "#8888a0",
+  textDim: "#5a5a72",
+  accent: "#8b5cf6",
+  accentLight: "#a78bfa",
+  accentDim: "rgba(139, 92, 246, 0.12)",
+  accentGlow: "rgba(139, 92, 246, 0.25)",
+  green: "#22c55e",
+  greenDim: "rgba(34, 197, 94, 0.12)",
+  amber: "#f59e0b",
+  amberDim: "rgba(245, 158, 11, 0.12)",
+  red: "#ef4444",
+  redDim: "rgba(239, 68, 68, 0.12)"
+};
+var consentStyles = lit.css`
+  :host {
+    display: block;
+    font-family:
+      "DM Sans",
+      system-ui,
+      -apple-system,
+      BlinkMacSystemFont,
+      "Segoe UI",
+      Roboto,
+      sans-serif;
+    /* SECURITY: Every unsafeCSS() call below uses compile-time constants from
+       SHIELD_COLORS. Never pass user input or dynamic values to unsafeCSS() as
+       it bypasses Lit's CSS sanitisation and would create a CSS injection vector. */
+    color: ${lit.unsafeCSS(SHIELD_COLORS.text)};
+    --shield-bg: ${lit.unsafeCSS(SHIELD_COLORS.bg)};
+    --shield-surface: ${lit.unsafeCSS(SHIELD_COLORS.surface)};
+    --shield-surface-hover: ${lit.unsafeCSS(SHIELD_COLORS.surfaceHover)};
+    --shield-border: ${lit.unsafeCSS(SHIELD_COLORS.border)};
+    --shield-border-light: ${lit.unsafeCSS(SHIELD_COLORS.borderLight)};
+    --shield-text: ${lit.unsafeCSS(SHIELD_COLORS.text)};
+    --shield-text-muted: ${lit.unsafeCSS(SHIELD_COLORS.textMuted)};
+    --shield-text-dim: ${lit.unsafeCSS(SHIELD_COLORS.textDim)};
+    --shield-accent: ${lit.unsafeCSS(SHIELD_COLORS.accent)};
+    --shield-accent-light: ${lit.unsafeCSS(SHIELD_COLORS.accentLight)};
+    --shield-accent-dim: ${lit.unsafeCSS(SHIELD_COLORS.accentDim)};
+    --shield-accent-glow: ${lit.unsafeCSS(SHIELD_COLORS.accentGlow)};
+    --shield-green: ${lit.unsafeCSS(SHIELD_COLORS.green)};
+    --shield-green-dim: ${lit.unsafeCSS(SHIELD_COLORS.greenDim)};
+    --shield-amber: ${lit.unsafeCSS(SHIELD_COLORS.amber)};
+    --shield-amber-dim: ${lit.unsafeCSS(SHIELD_COLORS.amberDim)};
+    --shield-red: ${lit.unsafeCSS(SHIELD_COLORS.red)};
+    --shield-red-dim: ${lit.unsafeCSS(SHIELD_COLORS.redDim)};
+  }
+
+  /* Modal backdrop */
+  .backdrop {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.75);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 10000;
+    padding: 16px;
+  }
+
+  /* Main card container */
+  .card {
+    width: 100%;
+    max-width: 420px;
+    background: var(--shield-surface);
+    border-radius: 20px;
+    border: 1px solid var(--shield-border);
+    overflow: hidden;
+    box-shadow:
+      0 0 80px var(--shield-accent-glow),
+      0 20px 60px rgba(0, 0, 0, 0.5);
+    display: flex;
+    flex-direction: column;
+    max-height: calc(100vh - 32px);
+    overflow-y: auto;
+  }
+
+  /* Inline mode: no backdrop, fill parent width */
+  :host([mode="inline"]) .backdrop {
+    position: static;
+    background: transparent;
+    padding: 0;
+  }
+
+  :host([mode="inline"]) .card {
+    max-width: 100%;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+  }
+
+  /* Header section */
+  .header {
+    padding: 24px 24px 20px;
+    border-bottom: 1px solid var(--shield-border);
+    background: linear-gradient(180deg, rgba(139, 92, 246, 0.06) 0%, transparent 100%);
+  }
+
+  .header-top {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    margin-bottom: 20px;
+  }
+
+  .verified-badge {
+    padding: 3px 10px;
+    border-radius: 20px;
+    background: var(--shield-green-dim);
+    font-size: 11px;
+    color: var(--shield-green);
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+
+  .agent-info {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+  }
+
+  .agent-icon {
+    width: 44px;
+    height: 44px;
+    border-radius: 12px;
+    background: linear-gradient(135deg, var(--shield-accent), #6d28d9);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 20px;
+    flex-shrink: 0;
+  }
+
+  .agent-name {
+    font-weight: 600;
+    font-size: 16px;
+    color: var(--shield-text);
+    margin: 0;
+  }
+
+  .agent-subtitle {
+    font-size: 12px;
+    color: var(--shield-text-muted);
+    margin: 2px 0 0 0;
+  }
+
+  /* High-risk warning callout */
+  .high-risk-warning {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+    padding: 14px 24px;
+    margin: 0;
+    background: var(--shield-amber-dim);
+    border-top: 1px solid var(--shield-border);
+    border-bottom: 1px solid var(--shield-border);
+  }
+
+  .warning-icon {
+    font-size: 18px;
+    flex-shrink: 0;
+    margin-top: 1px;
+  }
+
+  .warning-text {
+    font-size: 12.5px;
+    color: var(--shield-text);
+    line-height: 1.5;
+    margin: 0;
+  }
+
+  /* Permissions section */
+  .permissions {
+    padding: 8px 24px 0;
+  }
+
+  .permissions-title {
+    font-size: 11px;
+    font-weight: 600;
+    color: var(--shield-text-dim);
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    margin: 12px 0 4px 0;
+  }
+
+  .permission-row {
+    display: flex;
+    align-items: center;
+    gap: 14px;
+    padding: 14px 0;
+    border-bottom: 1px solid var(--shield-border);
+  }
+
+  .permission-row:last-child {
+    border-bottom: none;
+  }
+
+  .permission-icon {
+    width: 36px;
+    height: 36px;
+    border-radius: 10px;
+    background: var(--shield-accent-dim);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 16px;
+    flex-shrink: 0;
+  }
+
+  .permission-content {
+    flex: 1;
+    min-width: 0;
+  }
+
+  .permission-title {
+    font-weight: 500;
+    font-size: 13.5px;
+    color: var(--shield-text);
+    margin: 0;
+  }
+
+  .permission-description {
+    font-size: 11.5px;
+    color: var(--shield-text-muted);
+    margin: 2px 0 0 0;
+  }
+
+  .permission-levels {
+    display: flex;
+    gap: 6px;
+    margin-top: 8px;
+    flex-wrap: wrap;
+  }
+
+  .permission-level-button {
+    padding: 3px 10px;
+    border-radius: 6px;
+    border: 1px solid var(--shield-border);
+    background: transparent;
+    color: var(--shield-text-dim);
+    font-family: inherit;
+    font-size: 11px;
+    cursor: pointer;
+    transition: all 0.15s;
+  }
+
+  .permission-level-button:focus-visible {
+    outline: 2px solid var(--shield-accent);
+    outline-offset: 2px;
+  }
+
+  .permission-level-button.active {
+    border-color: var(--shield-accent);
+    background: var(--shield-accent-dim);
+    color: var(--shield-accent-light);
+  }
+
+  /* Toggle switch */
+  .toggle {
+    width: 40px;
+    height: 22px;
+    border-radius: 11px;
+    border: none;
+    background: var(--shield-border);
+    cursor: pointer;
+    position: relative;
+    transition: background 0.2s;
+    flex-shrink: 0;
+    padding: 0;
+  }
+
+  .toggle:focus-visible {
+    outline: 2px solid var(--shield-accent);
+    outline-offset: 2px;
+  }
+
+  .toggle.enabled {
+    background: var(--shield-accent);
+  }
+
+  .toggle-thumb {
+    width: 16px;
+    height: 16px;
+    border-radius: 8px;
+    background: #fff;
+    position: absolute;
+    top: 3px;
+    left: 3px;
+    transition: left 0.2s;
+  }
+
+  .toggle.enabled .toggle-thumb {
+    left: 21px;
+  }
+
+  /* Spending limit section */
+  .spending-limit {
+    padding: 16px 24px;
+    border-top: 1px solid var(--shield-border);
+  }
+
+  .spending-limit-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 12px;
+  }
+
+  .spending-limit-label {
+    font-weight: 500;
+    font-size: 13px;
+    color: var(--shield-text);
+    margin: 0;
+  }
+
+  .spending-limit-description {
+    font-size: 11.5px;
+    color: var(--shield-text-muted);
+    margin: 2px 0 0 0;
+  }
+
+  .spending-limit-amount {
+    font-family: "DM Mono", "Courier New", monospace;
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--shield-accent);
+  }
+
+  /* Editable spending limit control */
+  .spending-limit-control {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .spend-step-btn {
+    width: 28px;
+    height: 28px;
+    border-radius: 8px;
+    border: 1px solid var(--shield-border);
+    background: transparent;
+    color: var(--shield-text-muted);
+    font-size: 16px;
+    font-family: inherit;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.15s;
+    padding: 0;
+    line-height: 1;
+  }
+
+  .spend-step-btn:hover:not(:disabled) {
+    background: var(--shield-surface-hover);
+    color: var(--shield-text);
+    border-color: var(--shield-accent);
+  }
+
+  .spend-step-btn:disabled {
+    opacity: 0.3;
+    cursor: default;
+  }
+
+  .spend-step-btn:focus-visible {
+    outline: 2px solid var(--shield-accent);
+    outline-offset: 2px;
+  }
+
+  .spend-input-wrap {
+    display: flex;
+    align-items: center;
+    gap: 1px;
+    background: var(--shield-accent-dim);
+    border: 1px solid var(--shield-accent);
+    border-radius: 8px;
+    padding: 4px 10px;
+  }
+
+  .spend-currency {
+    font-family: "DM Mono", "Courier New", monospace;
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--shield-accent);
+  }
+
+  .spend-input {
+    font-family: "DM Mono", "Courier New", monospace;
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--shield-accent-light);
+    background: transparent;
+    border: none;
+    outline: none;
+    width: 60px;
+    text-align: left;
+    padding: 0;
+    -moz-appearance: textfield;
+  }
+
+  .spend-input::-webkit-outer-spin-button,
+  .spend-input::-webkit-inner-spin-button {
+    -webkit-appearance: none;
+    margin: 0;
+  }
+
+  .spending-limit-hint {
+    font-size: 11px;
+    color: var(--shield-text-dim);
+    margin-top: 8px;
+    text-align: right;
+  }
+
+  /* Actions section */
+  .actions {
+    padding: 12px 24px 24px;
+    display: flex;
+    gap: 10px;
+  }
+
+  .button {
+    padding: 12px 0;
+    border-radius: 12px;
+    font-family: inherit;
+    font-weight: 500;
+    font-size: 14px;
+    cursor: pointer;
+    transition: all 0.2s;
+    border: none;
+  }
+
+  .button:focus-visible {
+    outline: 2px solid var(--shield-accent);
+    outline-offset: 2px;
+  }
+
+  .button-secondary {
+    flex: 1;
+    background: transparent;
+    border: 1px solid var(--shield-border);
+    color: var(--shield-text-muted);
+  }
+
+  .button-secondary:hover {
+    background: var(--shield-surface-hover);
+    color: var(--shield-text);
+  }
+
+  .button-primary {
+    flex: 2;
+    background: linear-gradient(135deg, var(--shield-accent), #6d28d9);
+    color: #fff;
+    font-weight: 600;
+    box-shadow: 0 4px 20px var(--shield-accent-glow);
+  }
+
+  .button-primary:hover {
+    box-shadow: 0 6px 24px var(--shield-accent-glow);
+    transform: translateY(-1px);
+  }
+
+  .button-primary:active {
+    transform: translateY(0);
+  }
+
+  /* Reduced motion support */
+  @media (prefers-reduced-motion: reduce) {
+    *,
+    *::before,
+    *::after {
+      animation-duration: 0.01ms !important;
+      animation-iteration-count: 1 !important;
+      transition-duration: 0.01ms !important;
+    }
+  }
+
+  /* Responsive: small viewports (≤480px) */
+  @media (max-width: 480px) {
+    .card {
+      max-width: 100%;
+      border-radius: 16px;
+    }
+
+    .header {
+      padding: 20px 16px 16px;
+    }
+
+    .permissions {
+      padding: 8px 16px 0;
+    }
+
+    .permission-row {
+      gap: 10px;
+      padding: 12px 0;
+    }
+
+    .permission-icon {
+      width: 32px;
+      height: 32px;
+      font-size: 14px;
+    }
+
+    .spending-limit {
+      padding: 12px 16px;
+    }
+
+    .actions {
+      padding: 12px 16px 20px;
+    }
+  }
+
+  /* Responsive: very small viewports (≤375px) */
+  @media (max-width: 375px) {
+    .header {
+      padding: 16px 12px 12px;
+    }
+
+    .agent-icon {
+      width: 36px;
+      height: 36px;
+      font-size: 16px;
+    }
+
+    .agent-name {
+      font-size: 14px;
+    }
+
+    .permissions {
+      padding: 4px 12px 0;
+    }
+
+    .permission-row {
+      gap: 8px;
+      padding: 10px 0;
+    }
+
+    .permission-description {
+      font-size: 10.5px;
+    }
+
+    .spending-limit {
+      padding: 10px 12px;
+    }
+
+    .spending-limit-amount {
+      font-size: 16px;
+    }
+
+    .actions {
+      padding: 10px 12px 16px;
+      flex-direction: column;
+      gap: 8px;
+    }
+
+    .button {
+      padding: 10px 0;
+      font-size: 13px;
+    }
+
+    .button-primary,
+    .button-secondary {
+      flex: 1;
+    }
+  }
+
+  /* Hidden class for conditional rendering */
+  .hidden {
+    display: none !important;
+  }
+`;
+
+// src/consent/focus-trap.ts
+var FOCUSABLE_SELECTOR = [
+  "button:not([disabled])",
+  "[href]",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "[tabindex]:not([tabindex='-1'])"
+].join(", ");
+function createFocusTrap(container, initialFocus) {
+  let previousActiveElement = null;
+  let keydownHandler = null;
+  function getFocusableElements() {
+    const elements = [];
+    const directElements = Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR));
+    elements.push(...directElements);
+    if (container.shadowRoot) {
+      const shadowElements = Array.from(
+        container.shadowRoot.querySelectorAll(FOCUSABLE_SELECTOR)
+      );
+      elements.push(...shadowElements);
+    }
+    return elements.filter((el) => {
+      const style = window.getComputedStyle(el);
+      return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+    });
+  }
+  function handleKeyDown(e) {
+    if (e.key !== "Tab") {
+      return;
+    }
+    const focusableElements = getFocusableElements();
+    if (focusableElements.length === 0) {
+      e.preventDefault();
+      return;
+    }
+    const firstElement = focusableElements[0];
+    const lastElement = focusableElements[focusableElements.length - 1];
+    if (!firstElement || !lastElement) {
+      return;
+    }
+    const currentElement = document.activeElement;
+    if (e.shiftKey && currentElement === firstElement) {
+      e.preventDefault();
+      lastElement.focus();
+      return;
+    }
+    if (!e.shiftKey && currentElement === lastElement) {
+      e.preventDefault();
+      firstElement.focus();
+      return;
+    }
+    if (!focusableElements.includes(currentElement)) {
+      e.preventDefault();
+      firstElement.focus();
+    }
+  }
+  return {
+    activate() {
+      previousActiveElement = document.activeElement;
+      keydownHandler = handleKeyDown;
+      container.addEventListener("keydown", keydownHandler, true);
+      const focusableElements = getFocusableElements();
+      if (focusableElements.length > 0) {
+        const firstElement = focusableElements[0];
+        if (firstElement == null) {
+          return;
+        }
+        const target = initialFocus ?? firstElement;
+        if (focusableElements.includes(target)) {
+          target.focus();
+        } else {
+          firstElement.focus();
+        }
+      }
+    },
+    deactivate() {
+      if (keydownHandler) {
+        container.removeEventListener("keydown", keydownHandler, true);
+        keydownHandler = null;
+      }
+      if (previousActiveElement && document.body.contains(previousActiveElement)) {
+        previousActiveElement.focus();
+      }
+      previousActiveElement = null;
+    }
+  };
+}
+
+// src/consent/multicorn-consent.ts
+var CONSENT_ELEMENT_TAG = "multicorn-consent";
+var DEFAULT_AGENT_COLOR = "#8b5cf6";
+var HEX_COLOR_PATTERN = /^#[\da-fA-F]{3,8}$/;
+function sanitizeColor(color) {
+  return HEX_COLOR_PATTERN.test(color) ? color : DEFAULT_AGENT_COLOR;
+}
+function groupScopesByService(scopes) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    if (!grouped.has(scope.service)) {
+      grouped.set(scope.service, /* @__PURE__ */ new Set());
+    }
+    const serviceSet = grouped.get(scope.service);
+    if (serviceSet) {
+      serviceSet.add(scope.permissionLevel);
+    }
+  }
+  return grouped;
+}
+function scopeKey(scope) {
+  return `${scope.service}:${scope.permissionLevel}`;
+}
+exports.MulticornConsent = class MulticornConsent extends lit.LitElement {
+  constructor() {
+    super(...arguments);
+    this.agentName = "";
+    this.agentColor = DEFAULT_AGENT_COLOR;
+    this.scopes = [];
+    this.spendLimit = 0;
+    this.mode = "modal";
+    this._grantedScopes = /* @__PURE__ */ new Set();
+    this._adjustedSpendLimit = 0;
+    this._isOpen = true;
+    /**
+     * Focus trap instance (only used in modal mode).
+     */
+    this._focusTrap = null;
+    /**
+     * Previously focused element (for restoring focus after modal closes).
+     */
+    this._previousActiveElement = null;
+    /**
+     * Handle keyboard events (Escape to deny).
+     */
+    this._handleKeyDown = (e) => {
+      if (e.key === "Escape" && this.mode === "modal" && this._isOpen) {
+        e.preventDefault();
+        this._emitDenied();
+      }
+    };
+    /**
+     * Handle direct input of the spending limit.
+     */
+    this._handleSpendLimitInput = (e) => {
+      const input = e.target;
+      const value = parseInt(input.value, 10);
+      this._adjustedSpendLimit = Number.isNaN(value) ? 0 : Math.max(0, Math.min(this.spendLimit, value));
+    };
+    /**
+     * Handle the "Authorize" button click.
+     */
+    this._handleAuthorize = () => {
+      const granted = [];
+      const denied = [];
+      const scopes = Array.isArray(this.scopes) ? this.scopes : [];
+      for (const scope of scopes) {
+        if (this._isScopeGranted(scope)) {
+          granted.push(scope);
+        } else {
+          denied.push(scope);
+        }
+      }
+      if (granted.length === 0) {
+        this._emitDenied();
+      } else if (denied.length === 0) {
+        this._emitGranted(granted);
+      } else {
+        this._emitPartial(granted, denied);
+      }
+      if (this.mode === "modal") {
+        this._isOpen = false;
+        this._cleanupFocusTrap();
+      }
+    };
+    /**
+     * Handle the "Deny" button click.
+     */
+    this._handleDeny = () => {
+      this._emitDenied();
+      if (this.mode === "modal") {
+        this._isOpen = false;
+        this._cleanupFocusTrap();
+      }
+    };
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (Array.isArray(this.scopes) && this.scopes.length > 0) {
+      this._initializeGrantedScopes();
+    }
+    this.addEventListener("keydown", this._handleKeyDown);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.removeEventListener("keydown", this._handleKeyDown);
+    this._cleanupFocusTrap();
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    if (changedProperties.has("scopes")) {
+      if (!Array.isArray(this.scopes)) {
+        const scopesAttr = this.getAttribute("scopes");
+        if (scopesAttr) {
+          try {
+            const parsed = JSON.parse(scopesAttr);
+            if (Array.isArray(parsed)) {
+              this.scopes = parsed;
+            }
+          } catch {
+            this.scopes = [];
+          }
+        } else {
+          this.scopes = [];
+        }
+      }
+      this._initializeGrantedScopes();
+    }
+  }
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    if (changedProperties.has("mode")) {
+      this._updateFocusTrap();
+    }
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+    this._updateFocusTrap();
+  }
+  /**
+   * Initialize the granted scopes set with all requested scopes.
+   * High-risk scopes that require explicit opt-in are defaulted to OFF.
+   */
+  _initializeGrantedScopes() {
+    const scopes = Array.isArray(this.scopes) ? this.scopes : [];
+    const granted = /* @__PURE__ */ new Set();
+    for (const scope of scopes) {
+      const scopeStr = formatScope(scope);
+      if (!requiresExplicitOptIn(scopeStr)) {
+        granted.add(scopeKey(scope));
+      }
+    }
+    this._grantedScopes = granted;
+    this._adjustedSpendLimit = this.spendLimit;
+  }
+  /**
+   * Update the focus trap based on current mode and open state.
+   */
+  _updateFocusTrap() {
+    this._cleanupFocusTrap();
+    if (this.mode === "modal" && this._isOpen) {
+      const firstFocusable = this.shadowRoot?.querySelector(
+        'button, [href], input, [tabindex]:not([tabindex="-1"])'
+      );
+      this._focusTrap = createFocusTrap(this, firstFocusable ?? void 0);
+      this._focusTrap.activate();
+    }
+  }
+  /**
+   * Clean up the focus trap.
+   */
+  _cleanupFocusTrap() {
+    if (this._focusTrap) {
+      this._focusTrap.deactivate();
+      this._focusTrap = null;
+    }
+  }
+  /**
+   * Toggle a specific scope's granted state.
+   *
+   * @param scope - The scope to toggle.
+   */
+  _toggleScope(scope) {
+    const key = scopeKey(scope);
+    if (this._grantedScopes.has(key)) {
+      this._grantedScopes.delete(key);
+    } else {
+      this._grantedScopes.add(key);
+    }
+    this._grantedScopes = new Set(this._grantedScopes);
+    this.requestUpdate();
+  }
+  /**
+   * Check if a scope is currently granted.
+   *
+   * @param scope - The scope to check.
+   * @returns True if the scope is granted.
+   */
+  _isScopeGranted(scope) {
+    return this._grantedScopes.has(scopeKey(scope));
+  }
+  /**
+   * Adjust the spending limit.
+   * Clamps between 0 and the original requested spendLimit.
+   */
+  _adjustSpendLimit(delta) {
+    this._adjustedSpendLimit = Math.max(
+      0,
+      Math.min(this.spendLimit, this._adjustedSpendLimit + delta)
+    );
+  }
+  /**
+   * Emit a consent-granted event.
+   */
+  _emitGranted(grantedScopes) {
+    const detail = {
+      grantedScopes,
+      spendLimit: this._adjustedSpendLimit,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.dispatchEvent(
+      new CustomEvent("consent-granted", {
+        detail,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  /**
+   * Emit a consent-partial event.
+   */
+  _emitPartial(grantedScopes, deniedScopes) {
+    const detail = {
+      grantedScopes,
+      deniedScopes,
+      spendLimit: this._adjustedSpendLimit,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.dispatchEvent(
+      new CustomEvent("consent-partial", {
+        detail,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  /**
+   * Emit a consent-denied event.
+   */
+  _emitDenied() {
+    const scopes = Array.isArray(this.scopes) ? this.scopes : [];
+    const detail = {
+      deniedScopes: [...scopes],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.dispatchEvent(
+      new CustomEvent("consent-denied", {
+        detail,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  /**
+   * Get parsed scopes (already handled by property converter).
+   */
+  _getParsedScopes() {
+    return Array.isArray(this.scopes) ? this.scopes : [];
+  }
+  render() {
+    const parsedScopes = this._getParsedScopes();
+    if (this.mode === "modal" && !this._isOpen) {
+      return lit.html``;
+    }
+    if (parsedScopes.length === 0) {
+      return lit.html`
+        <div class="card">
+          <div class="header">
+            <h2 class="agent-name">${this.agentName || "Agent"}</h2>
+            <p class="agent-subtitle" style="color: var(--shield-text-dim);">
+              No permissions requested.
+            </p>
+          </div>
+        </div>
+      `;
+    }
+    const groupedScopes = groupScopesByService(parsedScopes);
+    const isModal = this.mode === "modal" && this._isOpen;
+    const highRiskScopes = parsedScopes.filter((scope) => isHighRiskScope(formatScope(scope)));
+    const firstHighRiskScope = highRiskScopes[0];
+    const warningMessage = firstHighRiskScope !== void 0 ? getScopeWarning(formatScope(firstHighRiskScope)) : void 0;
+    const content = lit.html`
+      <div
+        class="card"
+        role="dialog"
+        aria-modal="${isModal ? "true" : "false"}"
+        aria-labelledby="agent-name"
+      >
+        <!-- Header -->
+        <div class="header">
+          <div class="header-top">
+            <div class="verified-badge">Verified Agent</div>
+          </div>
+          <div class="agent-info">
+            <div
+              class="agent-icon"
+              style="background: linear-gradient(135deg, ${sanitizeColor(
+      this.agentColor
+    )}, #6d28d9);"
+            >
+              🤖
+            </div>
+            <div>
+              <h2 class="agent-name" id="agent-name">${this.agentName || "Agent"}</h2>
+              <p class="agent-subtitle">wants access to your services</p>
+            </div>
+          </div>
+        </div>
+
+        <!-- High-Risk Warning -->
+        ${warningMessage ? lit.html`
+              <div class="high-risk-warning">
+                <div class="warning-icon">⚠️</div>
+                <div class="warning-text">${warningMessage}</div>
+              </div>
+            ` : lit.html``}
+
+        <!-- Permissions -->
+        <div class="permissions">
+          <div class="permissions-title">Permissions</div>
+          ${Array.from(groupedScopes.entries()).map(
+      ([service, permissionLevels]) => {
+        const serviceDisplayName = getServiceDisplayName(service);
+        const serviceIcon = getServiceIcon(service);
+        const serviceScopes = parsedScopes.filter((s) => s.service === service);
+        return lit.html`
+                <div class="permission-row">
+                  <div class="permission-icon">${serviceIcon}</div>
+                  <div class="permission-content">
+                    <div class="permission-title">${serviceDisplayName}</div>
+                    <div class="permission-description">
+                      ${serviceScopes.map((scope) => getScopeLabel(scope)).join(", ")}
+                    </div>
+                    <div class="permission-levels">
+                      ${Array.from(permissionLevels).map((level) => {
+          const scope = { service, permissionLevel: level };
+          const isGranted = this._isScopeGranted(scope);
+          const label = getScopeShortLabel(scope);
+          return lit.html`
+                          <button
+                            class="permission-level-button ${isGranted ? "active" : ""}"
+                            @click="${() => {
+            this._toggleScope(scope);
+          }}"
+                            aria-label="Toggle ${label}"
+                            type="button"
+                          >
+                            ${level.charAt(0).toUpperCase() + level.slice(1)}
+                          </button>
+                        `;
+        })}
+                    </div>
+                  </div>
+                  <button
+                    class="toggle ${this._areAllServiceScopesGranted(service, serviceScopes) ? "enabled" : ""}"
+                    @click="${() => {
+          this._toggleAllServiceScopes(service, serviceScopes);
+        }}"
+                    aria-label="Toggle all permissions for ${serviceDisplayName}"
+                    type="button"
+                  >
+                    <div class="toggle-thumb"></div>
+                  </button>
+                </div>
+              `;
+      }
+    )}
+        </div>
+
+        <!-- Spending Limit -->
+        ${this.spendLimit > 0 ? lit.html`
+              <div class="spending-limit">
+                <div class="spending-limit-header">
+                  <div>
+                    <div class="spending-limit-label">Spending limit</div>
+                    <div class="spending-limit-description">Per transaction without approval</div>
+                  </div>
+                  <div class="spending-limit-control">
+                    <button
+                      class="spend-step-btn"
+                      @click="${() => {
+      this._adjustSpendLimit(-10);
+    }}"
+                      aria-label="Decrease spending limit"
+                      type="button"
+                      ?disabled="${this._adjustedSpendLimit <= 0}"
+                    >
+                      −
+                    </button>
+                    <div class="spend-input-wrap">
+                      <span class="spend-currency">$</span>
+                      <input
+                        class="spend-input"
+                        type="number"
+                        min="0"
+                        max="${this.spendLimit}"
+                        .value="${String(this._adjustedSpendLimit)}"
+                        @change="${this._handleSpendLimitInput}"
+                        aria-label="Spending limit amount"
+                      />
+                    </div>
+                    <button
+                      class="spend-step-btn"
+                      @click="${() => {
+      this._adjustSpendLimit(10);
+    }}"
+                      aria-label="Increase spending limit"
+                      type="button"
+                      ?disabled="${this._adjustedSpendLimit >= this.spendLimit}"
+                    >
+                      +
+                    </button>
+                  </div>
+                </div>
+                ${this._adjustedSpendLimit < this.spendLimit ? lit.html`<div class="spending-limit-hint">
+                      Agent requested $${this.spendLimit}
+                    </div>` : lit.html``}
+              </div>
+            ` : lit.html``}
+
+        <!-- Actions -->
+        <div class="actions">
+          <button class="button button-secondary" @click="${this._handleDeny}" type="button">
+            Deny
+          </button>
+          <button class="button button-primary" @click="${this._handleAuthorize}" type="button">
+            Authorize Agent
+          </button>
+        </div>
+      </div>
+    `;
+    if (isModal) {
+      return lit.html` <div class="backdrop">${content}</div> `;
+    }
+    return content;
+  }
+  /**
+   * Check if all scopes for a service are granted.
+   */
+  _areAllServiceScopesGranted(service, serviceScopes) {
+    return serviceScopes.every((scope) => this._isScopeGranted(scope));
+  }
+  /**
+   * Toggle all scopes for a service.
+   */
+  _toggleAllServiceScopes(service, serviceScopes) {
+    const allGranted = this._areAllServiceScopesGranted(service, serviceScopes);
+    for (const scope of serviceScopes) {
+      const key = scopeKey(scope);
+      if (allGranted) {
+        this._grantedScopes.delete(key);
+      } else {
+        this._grantedScopes.add(key);
+      }
+    }
+    this._grantedScopes = new Set(this._grantedScopes);
+    this.requestUpdate();
+  }
+};
+exports.MulticornConsent.styles = [consentStyles];
+__decorateClass([
+  decorators_js.property({ type: String, attribute: "agent-name" })
+], exports.MulticornConsent.prototype, "agentName", 2);
+__decorateClass([
+  decorators_js.property({ type: String, attribute: "agent-color" })
+], exports.MulticornConsent.prototype, "agentColor", 2);
+__decorateClass([
+  decorators_js.property({ type: Array, attribute: "scopes" })
+], exports.MulticornConsent.prototype, "scopes", 2);
+__decorateClass([
+  decorators_js.property({ type: Number, attribute: "spend-limit" })
+], exports.MulticornConsent.prototype, "spendLimit", 2);
+__decorateClass([
+  decorators_js.property({ type: String })
+], exports.MulticornConsent.prototype, "mode", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.MulticornConsent.prototype, "_grantedScopes", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.MulticornConsent.prototype, "_adjustedSpendLimit", 2);
+__decorateClass([
+  decorators_js.state()
+], exports.MulticornConsent.prototype, "_isOpen", 2);
+exports.MulticornConsent = __decorateClass([
+  decorators_js.customElement(CONSENT_ELEMENT_TAG)
+], exports.MulticornConsent);
+
+// src/logger/action-logger.ts
+function createActionLogger(config) {
+  if (!config.apiKey || config.apiKey.trim().length === 0) {
+    throw new Error(
+      "[ActionLogger] API key is required. Provide it via the 'apiKey' config option."
+    );
+  }
+  const baseUrl = config.baseUrl ?? "https://api.multicorn.ai";
+  const timeout = config.timeout ?? 5e3;
+  if (!baseUrl.startsWith("https://") && !baseUrl.startsWith("http://localhost")) {
+    throw new Error(
+      `[ActionLogger] Base URL must use HTTPS for security. Received: "${baseUrl}". Use https:// or http://localhost for local development.`
+    );
+  }
+  const endpoint = `${baseUrl}/api/v1/actions`;
+  const batchEnabled = config.batchMode?.enabled ?? false;
+  const maxBatchSize = config.batchMode?.maxSize ?? 10;
+  const flushInterval = config.batchMode?.flushIntervalMs ?? 5e3;
+  const queue = [];
+  let flushTimer;
+  let isShutdown = false;
+  async function sendActions(actions) {
+    if (actions.length === 0) return;
+    const convertAction = (action) => ({
+      agent: action.agent,
+      service: action.service,
+      actionType: action.actionType,
+      status: action.status,
+      ...action.cost !== void 0 ? { cost: action.cost } : {},
+      ...action.metadata !== void 0 ? { metadata: action.metadata } : {}
+    });
+    const convertedActions = actions.map(convertAction);
+    const payload = batchEnabled ? { actions: convertedActions } : convertedActions[0];
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+        }, timeout);
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Multicorn-Key": config.apiKey
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          return;
+        }
+        if (response.status >= 400 && response.status < 500) {
+          const body = await response.text().catch(() => "");
+          throw new Error(
+            `[ActionLogger] Client error (${String(response.status)}): ${response.statusText}. Response: ${body}. Check your API key and payload format.`
+          );
+        }
+        if (response.status >= 500 && attempt === 0) {
+          lastError = new Error(
+            `[ActionLogger] Server error (${String(response.status)}): ${response.statusText}. Retrying once...`
+          );
+          await sleep(100 * Math.pow(2, attempt));
+          continue;
+        }
+        throw new Error(
+          `[ActionLogger] Server error (${String(response.status)}) after retry: ${response.statusText}. Multicorn API may be experiencing issues.`
+        );
+      } catch (error) {
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            lastError = new Error(
+              `[ActionLogger] Request timeout after ${String(timeout)}ms. Increase the 'timeout' config option or check your network connection.`
+            );
+          } else if (error.message.includes("Client error") || error.message.includes("Server error")) {
+            lastError = error;
+          } else {
+            lastError = new Error(
+              `[ActionLogger] Network error: ${error.message}. Check your network connection and API endpoint.`
+            );
+          }
+        } else {
+          lastError = new Error(`[ActionLogger] Unknown error: ${String(error)}`);
+        }
+        if (attempt === 0 && !lastError.message.includes("Client error")) {
+          await sleep(100 * Math.pow(2, attempt));
+          continue;
+        }
+        break;
+      }
+    }
+    if (lastError) {
+      if (config.onError) {
+        config.onError(lastError);
+      }
+    }
+  }
+  async function flushQueue() {
+    if (queue.length === 0) return;
+    const actions = queue.map((item) => item.payload);
+    queue.length = 0;
+    await sendActions(actions);
+  }
+  function startFlushTimer() {
+    if (flushTimer !== void 0) return;
+    flushTimer = setInterval(() => {
+      flushQueue().catch(() => {
+      });
+    }, flushInterval);
+    const timer = flushTimer;
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+  }
+  function stopFlushTimer() {
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = void 0;
+    }
+  }
+  if (batchEnabled) {
+    startFlushTimer();
+  }
+  return {
+    logAction(action) {
+      if (isShutdown) {
+        throw new Error(
+          "[ActionLogger] Cannot log action after shutdown. Create a new logger instance."
+        );
+      }
+      if (action.agent.trim().length === 0) {
+        throw new Error("[ActionLogger] Action must have a non-empty 'agent' field.");
+      }
+      if (action.service.trim().length === 0) {
+        throw new Error("[ActionLogger] Action must have a non-empty 'service' field.");
+      }
+      if (action.actionType.trim().length === 0) {
+        throw new Error("[ActionLogger] Action must have a non-empty 'actionType' field.");
+      }
+      if (action.status.trim().length === 0) {
+        throw new Error("[ActionLogger] Action must have a non-empty 'status' field.");
+      }
+      if (batchEnabled) {
+        queue.push({ payload: action, timestamp: Date.now() });
+        if (queue.length >= maxBatchSize) {
+          flushQueue().catch(() => {
+          });
+        }
+      } else {
+        sendActions([action]).catch(() => {
+        });
+      }
+      return Promise.resolve();
+    },
+    async flush() {
+      if (!batchEnabled) return;
+      await flushQueue();
+    },
+    async shutdown() {
+      if (isShutdown) return;
+      isShutdown = true;
+      stopFlushTimer();
+      if (batchEnabled) {
+        await flushQueue();
+      }
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/spending/spending-checker.ts
+function createSpendingChecker(config) {
+  validateLimits(config.limits);
+  let dailySpendCents = 0;
+  let monthlySpendCents = 0;
+  let lastDailyReset = /* @__PURE__ */ new Date();
+  let lastMonthlyReset = /* @__PURE__ */ new Date();
+  function validateAmount(amountCents, context) {
+    if (!Number.isInteger(amountCents)) {
+      throw new Error(
+        `[SpendingChecker] ${context} must be an integer (cents). Received: ${String(amountCents)}. Convert dollars to cents by multiplying by 100.`
+      );
+    }
+    if (amountCents < 0) {
+      throw new Error(
+        `[SpendingChecker] ${context} must be non-negative. Received: ${String(amountCents)} cents.`
+      );
+    }
+  }
+  function formatCents(cents) {
+    const dollars = cents / 100;
+    return `$${dollars.toLocaleString("en-US", {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    })}`;
+  }
+  function checkAndResetDaily() {
+    const now = /* @__PURE__ */ new Date();
+    if (shouldResetDaily(lastDailyReset, now)) {
+      dailySpendCents = 0;
+      lastDailyReset = now;
+    }
+  }
+  function checkAndResetMonthly() {
+    const now = /* @__PURE__ */ new Date();
+    if (shouldResetMonthly(lastMonthlyReset, now)) {
+      monthlySpendCents = 0;
+      lastMonthlyReset = now;
+    }
+  }
+  function shouldResetDaily(lastReset, now) {
+    return lastReset.getDate() !== now.getDate() || lastReset.getMonth() !== now.getMonth() || lastReset.getFullYear() !== now.getFullYear();
+  }
+  function shouldResetMonthly(lastReset, now) {
+    return lastReset.getMonth() !== now.getMonth() || lastReset.getFullYear() !== now.getFullYear();
+  }
+  function calculateRemainingBudget() {
+    return {
+      transaction: config.limits.perTransaction,
+      daily: Math.max(0, config.limits.perDay - dailySpendCents),
+      monthly: Math.max(0, config.limits.perMonth - monthlySpendCents)
+    };
+  }
+  return {
+    checkSpend(amountCents) {
+      validateAmount(amountCents, "Spend amount");
+      checkAndResetDaily();
+      checkAndResetMonthly();
+      if (amountCents > config.limits.perTransaction) {
+        return {
+          allowed: false,
+          reason: `Action blocked: ${formatCents(amountCents)} exceeds per-transaction limit of ${formatCents(config.limits.perTransaction)}`,
+          remainingBudget: calculateRemainingBudget()
+        };
+      }
+      const projectedDaily = dailySpendCents + amountCents;
+      if (projectedDaily > config.limits.perDay) {
+        return {
+          allowed: false,
+          reason: `Action blocked: ${formatCents(amountCents)} would exceed per-day limit. Current spend today: ${formatCents(dailySpendCents)}, limit: ${formatCents(config.limits.perDay)}`,
+          remainingBudget: calculateRemainingBudget()
+        };
+      }
+      const projectedMonthly = monthlySpendCents + amountCents;
+      if (projectedMonthly > config.limits.perMonth) {
+        return {
+          allowed: false,
+          reason: `Action blocked: ${formatCents(amountCents)} would exceed per-month limit. Current spend this month: ${formatCents(monthlySpendCents)}, limit: ${formatCents(config.limits.perMonth)}`,
+          remainingBudget: calculateRemainingBudget()
+        };
+      }
+      return {
+        allowed: true,
+        remainingBudget: calculateRemainingBudget()
+      };
+    },
+    recordSpend(amountCents) {
+      validateAmount(amountCents, "Spend amount");
+      checkAndResetDaily();
+      checkAndResetMonthly();
+      dailySpendCents += amountCents;
+      monthlySpendCents += amountCents;
+    },
+    getCurrentSpend() {
+      checkAndResetDaily();
+      checkAndResetMonthly();
+      return {
+        daily: dailySpendCents,
+        monthly: monthlySpendCents
+      };
+    },
+    reset() {
+      dailySpendCents = 0;
+      monthlySpendCents = 0;
+      lastDailyReset = /* @__PURE__ */ new Date();
+      lastMonthlyReset = /* @__PURE__ */ new Date();
+    }
+  };
+}
+function validateLimits(limits) {
+  const checks = [
+    { value: limits.perTransaction, name: "perTransaction" },
+    { value: limits.perDay, name: "perDay" },
+    { value: limits.perMonth, name: "perMonth" }
+  ];
+  for (const check of checks) {
+    if (!Number.isInteger(check.value)) {
+      throw new Error(
+        `[SpendingChecker] Limit "${check.name}" must be an integer (cents). Received: ${String(check.value)}. All limits must be specified in integer cents.`
+      );
+    }
+    if (check.value < 0) {
+      throw new Error(
+        `[SpendingChecker] Limit "${check.name}" must be non-negative. Received: ${String(check.value)} cents.`
+      );
+    }
+  }
+}
+function dollarsToCents(dollars) {
+  return Math.round(dollars * 100);
+}
+function centsToDollars(cents) {
+  const dollars = cents / 100;
+  return `$${dollars.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  })}`;
+}
+
+// src/scopes/content-review-detector.ts
+function requiresContentReview(scope) {
+  if (scope.service === "web" && scope.permissionLevel === "publish") {
+    return true;
+  }
+  if (scope.service === "public_content" && scope.permissionLevel === "create") {
+    return true;
+  }
+  return false;
+}
+function isPublicContentAction(toolName, service) {
+  const lowerToolName = toolName.toLowerCase();
+  const lowerService = service.toLowerCase();
+  if (lowerService === "web" || lowerService === "public_content") {
+    return true;
+  }
+  const publicContentIndicators = [
+    "publish",
+    "public",
+    "web",
+    "blog",
+    "post",
+    "article",
+    "social",
+    "twitter",
+    "facebook",
+    "linkedin",
+    "github_pages",
+    "deploy"
+  ];
+  return publicContentIndicators.some((indicator) => lowerToolName.includes(indicator));
+}
+
+// src/mcp/mcp-adapter.ts
+function isBlockedResult(result) {
+  return "blocked" in result;
+}
+function createMcpAdapter(config) {
+  const permissionLevel = config.requiredPermissionLevel ?? PERMISSION_LEVELS.Execute;
+  function mapPublishingService(service, toolName) {
+    const lowerService = service.toLowerCase();
+    const lowerToolName = toolName.toLowerCase();
+    const publishActions = [
+      "deploy",
+      "publish",
+      "release",
+      "go_live",
+      "make_public",
+      "pages_deploy",
+      "github_pages"
+    ];
+    if (publishActions.some((action) => lowerToolName.includes(action))) {
+      return { mappedService: "web", mappedPermissionLevel: PERMISSION_LEVELS.Publish };
+    }
+    const createActions = [
+      "post",
+      "tweet",
+      "status",
+      "update",
+      "share",
+      "comment",
+      "reply",
+      "commit"
+      // Public commits are immediately visible
+    ];
+    if (createActions.some((action) => lowerToolName.includes(action))) {
+      return { mappedService: "public_content", mappedPermissionLevel: PERMISSION_LEVELS.Create };
+    }
+    if (lowerService === "github" && lowerToolName.includes("pages")) {
+      return { mappedService: "web", mappedPermissionLevel: PERMISSION_LEVELS.Publish };
+    }
+    const socialMediaServices = ["twitter", "x", "facebook", "linkedin", "instagram"];
+    if (socialMediaServices.includes(lowerService)) {
+      return { mappedService: "public_content", mappedPermissionLevel: PERMISSION_LEVELS.Create };
+    }
+    const blogServices = ["wordpress", "medium", "blogger", "ghost"];
+    if (blogServices.includes(lowerService)) {
+      if (publishActions.some((action) => lowerToolName.includes(action))) {
+        return { mappedService: "web", mappedPermissionLevel: PERMISSION_LEVELS.Publish };
+      }
+      return { mappedService: "public_content", mappedPermissionLevel: PERMISSION_LEVELS.Create };
+    }
+    return { mappedService: service, mappedPermissionLevel: permissionLevel };
+  }
+  function deriveService(toolName) {
+    if (config.extractService !== void 0) {
+      return config.extractService(toolName);
+    }
+    const underscoreIndex = toolName.indexOf("_");
+    return underscoreIndex === -1 ? toolName : toolName.slice(0, underscoreIndex);
+  }
+  function deriveAction(toolName) {
+    if (config.extractAction !== void 0) {
+      return config.extractAction(toolName);
+    }
+    const underscoreIndex = toolName.indexOf("_");
+    return underscoreIndex === -1 ? "call" : toolName.slice(underscoreIndex + 1);
+  }
+  async function recordAction(service, action, status) {
+    if (config.logger === void 0) return;
+    await config.logger.logAction({
+      agent: config.agentId,
+      service,
+      actionType: action,
+      status
+    });
+  }
+  async function checkAutoApproveStatus() {
+    if (config.checkAutoApprove !== void 0) {
+      const result = config.checkAutoApprove(config.agentId);
+      return result instanceof Promise ? await result : result;
+    }
+    if (config.baseUrl && config.apiKey) {
+      try {
+        const agentId = config.agentId;
+        const endpoint = `${config.baseUrl}/api/v1/agents/${encodeURIComponent(agentId)}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+        }, 5e3);
+        try {
+          const response = await fetch(endpoint, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              "X-Multicorn-Key": config.apiKey
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (response.ok) {
+            const data = await response.json();
+            return data.data?.public_content_auto_approve ?? false;
+          }
+        } catch {
+          clearTimeout(timeoutId);
+          return false;
+        }
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  return {
+    async intercept(toolCall, handler) {
+      const derivedService = deriveService(toolCall.toolName);
+      const action = deriveAction(toolCall.toolName);
+      const { mappedService, mappedPermissionLevel } = mapPublishingService(
+        derivedService,
+        toolCall.toolName
+      );
+      const requestedScope = {
+        service: mappedService,
+        permissionLevel: mappedPermissionLevel
+      };
+      const validation = validateScopeAccess(config.grantedScopes, requestedScope);
+      if (!validation.allowed) {
+        await recordAction(mappedService, action, ACTION_STATUSES.Blocked);
+        return {
+          blocked: true,
+          reason: validation.reason ?? `Action blocked: "${config.agentId}" does not have "${mappedPermissionLevel}" permission for "${mappedService}".`,
+          toolName: toolCall.toolName,
+          service: mappedService,
+          action
+        };
+      }
+      const needsReview = requiresContentReview(requestedScope) || isPublicContentAction(toolCall.toolName, mappedService);
+      if (needsReview) {
+        const autoApprove = await checkAutoApproveStatus();
+        if (!autoApprove) {
+          const metadata = {
+            toolName: toolCall.toolName,
+            arguments: JSON.stringify(toolCall.arguments),
+            requiresReview: true
+          };
+          if (config.logger) {
+            await config.logger.logAction({
+              agent: config.agentId,
+              service: mappedService,
+              actionType: action,
+              status: ACTION_STATUSES.RequiresApproval,
+              metadata
+            });
+          }
+          return {
+            blocked: true,
+            reason: `Action requires content review before execution. The action has been queued for review. Check your dashboard to approve or block it.`,
+            toolName: toolCall.toolName,
+            service: mappedService,
+            action
+          };
+        }
+      }
+      await recordAction(mappedService, action, ACTION_STATUSES.Approved);
+      return handler(toolCall);
+    }
+  };
+}
+
+// src/multicorn-shield.ts
+var API_KEY_PREFIX = "mcs_";
+function formatScope2(scope) {
+  return `${scope.service}:${scope.permissionLevel}`;
+}
+function formatScopes(scopes) {
+  return scopes.map(formatScope2);
+}
+var MIN_API_KEY_LENGTH = 16;
+var MulticornShield = class {
+  // Private class fields for true runtime privacy.
+  // #apiKey is unreachable outside this class at the JS level, not just compile time.
+  #apiKey;
+  #baseUrl;
+  #logger;
+  #onError;
+  #grantedScopes = /* @__PURE__ */ new Map();
+  #spendingCheckers = /* @__PURE__ */ new Map();
+  #consentContainer = null;
+  #isDestroyed = false;
+  /**
+   * Create a new MulticornShield instance.
+   *
+   * @param config - SDK configuration options.
+   * @throws {Error} If the API key is missing, incorrectly formatted, or too short.
+   *
+   * @example
+   * ```ts
+   * const shield = new MulticornShield({ apiKey: 'mcs_your_key_here' });
+   * ```
+   */
+  constructor(config) {
+    validateApiKey(config.apiKey);
+    const baseUrl = config.baseUrl ?? "https://api.multicorn.ai";
+    validateBaseUrl(baseUrl);
+    this.#apiKey = config.apiKey;
+    this.#baseUrl = baseUrl;
+    this.#onError = config.onError;
+    this.#logger = createActionLogger({
+      apiKey: this.#apiKey,
+      ...config.baseUrl !== void 0 ? { baseUrl: config.baseUrl } : {},
+      ...config.timeout !== void 0 ? { timeout: config.timeout } : {},
+      ...config.batchMode !== void 0 ? { batchMode: config.batchMode } : {}
+    });
+  }
+  /**
+   * Show the consent screen and wait for the user's decision.
+   *
+   * Mounts the `<multicorn-consent>` web component to the document body,
+   * resolves with the user's decision (granted scopes, approved spend limit,
+   * and a timestamp), then removes the element from the DOM.
+   *
+   * Granted scopes are stored internally and enforced on every subsequent
+   * {@link logAction} call.
+   *
+   * @param options - What to request consent for.
+   * @returns The user's consent decision including which scopes were granted.
+   * @throws {ScopeParseError} If any scope string is malformed.
+   * @throws {Error} If the instance has been destroyed.
+   *
+   * @example
+   * ```ts
+   * const decision = await shield.requestConsent({
+   *   agent: 'OpenClaw',
+   *   scopes: ['read:gmail', 'write:calendar'],
+   *   spendLimit: 200,
+   * });
+   *
+   * console.log(decision.grantedScopes.map(s => `${s.permissionLevel}:${s.service}`));
+   * ```
+   */
+  async requestConsent(options) {
+    this.#assertNotDestroyed();
+    const parsedScopes = parseScopes(options.scopes);
+    const scopeRequest = {
+      agentName: options.agent,
+      scopes: parsedScopes,
+      spendLimit: options.spendLimit ?? 0
+    };
+    return new Promise((resolve) => {
+      const container = document.createElement("div");
+      this.#consentContainer = container;
+      document.body.appendChild(container);
+      const element = document.createElement(CONSENT_ELEMENT_TAG);
+      element.agentName = options.agent;
+      element.scopes = [...parsedScopes];
+      element.spendLimit = options.spendLimit ?? 0;
+      if (options.agentColor !== void 0) {
+        element.agentColor = options.agentColor;
+      }
+      const cleanup = () => {
+        element.remove();
+        container.remove();
+        if (this.#consentContainer === container) {
+          this.#consentContainer = null;
+        }
+      };
+      element.addEventListener("consent-granted", (event) => {
+        const detail = event.detail;
+        this.#grantedScopes.set(options.agent, [...detail.grantedScopes]);
+        if (detail.spendLimit > 0) {
+          this.#setupSpendingChecker(options.agent, detail.spendLimit);
+        }
+        void this.#postConsentToBackend(
+          options.agent,
+          detail.grantedScopes,
+          [],
+          detail.spendLimit,
+          detail.timestamp
+        ).catch((error) => {
+          this.#onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        cleanup();
+        resolve({
+          scopeRequest,
+          grantedScopes: detail.grantedScopes,
+          timestamp: detail.timestamp
+        });
+      });
+      element.addEventListener("consent-partial", (event) => {
+        const detail = event.detail;
+        this.#grantedScopes.set(options.agent, [...detail.grantedScopes]);
+        if (detail.spendLimit > 0) {
+          this.#setupSpendingChecker(options.agent, detail.spendLimit);
+        }
+        void this.#postConsentToBackend(
+          options.agent,
+          detail.grantedScopes,
+          detail.deniedScopes,
+          detail.spendLimit,
+          detail.timestamp
+        ).catch((error) => {
+          this.#onError?.(error instanceof Error ? error : new Error(String(error)));
+        });
+        cleanup();
+        resolve({
+          scopeRequest,
+          grantedScopes: detail.grantedScopes,
+          timestamp: detail.timestamp
+        });
+      });
+      element.addEventListener("consent-denied", (event) => {
+        const detail = event.detail;
+        this.#grantedScopes.set(options.agent, []);
+        cleanup();
+        resolve({
+          scopeRequest,
+          grantedScopes: [],
+          timestamp: detail.timestamp
+        });
+      });
+      container.appendChild(element);
+    });
+  }
+  /**
+   * Log an action taken by an agent.
+   *
+   * Verifies that the agent has a granted permission for the target service
+   * before submitting the log entry. Throws with a descriptive error if
+   * access was never granted or has been revoked. Actions are never silently
+   * discarded.
+   *
+   * @param action - The action to log.
+   * @returns Resolves when the log entry has been submitted (or queued in batch mode).
+   * @throws {Error} If the agent does not have a granted scope for the service.
+   * @throws {Error} If the instance has been destroyed.
+   *
+   * @example
+   * ```ts
+   * await shield.logAction({
+   *   agent: 'OpenClaw',
+   *   service: 'gmail',
+   *   action: 'send_email',
+   *   status: 'approved',
+   * });
+   * ```
+   */
+  async logAction(action) {
+    this.#assertNotDestroyed();
+    const granted = this.#grantedScopes.get(action.agent) ?? [];
+    const hasPermissionForService = granted.some((s) => s.service === action.service);
+    const payload = {
+      agent: action.agent,
+      service: action.service,
+      actionType: action.action,
+      status: hasPermissionForService ? action.status : "blocked",
+      ...action.cost !== void 0 ? { cost: action.cost } : {},
+      ...action.metadata !== void 0 ? { metadata: action.metadata } : {}
+    };
+    await this.#logger.logAction(payload);
+    if (!hasPermissionForService) {
+      const grantedServiceList = [...new Set(granted.map((s) => s.service))].join(", ") || "none";
+      throw new Error(
+        `[MulticornShield] Agent "${action.agent}" does not have permission to access "${action.service}". Services with granted access: ${grantedServiceList}. Call requestConsent() to grant access.`
+      );
+    }
+  }
+  /**
+   * POST granted scopes to the backend consent endpoint.
+   * @private
+   */
+  async #postConsentToBackend(agentName, grantedScopes, deniedScopes, spendLimit, timestamp) {
+    this.#assertNotDestroyed();
+    if (grantedScopes.length === 0) {
+      return;
+    }
+    const endpoint = `${this.#baseUrl}/api/v1/consent`;
+    const grantedScopeStrings = formatScopes(grantedScopes);
+    const deniedScopeStrings = formatScopes(deniedScopes);
+    const spendLimitCents = spendLimit > 0 ? Math.round(spendLimit * 100) : null;
+    const payload = {
+      agent: agentName,
+      granted_scopes: grantedScopeStrings,
+      denied_scopes: deniedScopeStrings,
+      spend_limit: spendLimitCents,
+      timestamp
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, 1e4);
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Multicorn-Key": this.#apiKey
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const rawBody = await response.text().catch(() => "");
+        const safeBody = rawBody.length > 200 ? rawBody.slice(0, 200) + "\u2026" : rawBody;
+        throw new Error(
+          `Failed to store consent: HTTP ${String(response.status)}.` + (safeBody.length > 0 ? ` Server response: ${safeBody}` : "")
+        );
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("Consent POST request timed out");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Immediately revoke a specific scope for an agent.
+   *
+   * Any subsequent {@link logAction} calls that require access to that service
+   * will be rejected. The revocation takes effect synchronously.
+   *
+   * @param agentId - The agent whose scope should be revoked.
+   * @param scope - The scope string to revoke (e.g. `"write:calendar"`).
+   * @throws {ScopeParseError} If the scope string is malformed.
+   * @throws {Error} If the instance has been destroyed.
+   *
+   * @example
+   * ```ts
+   * // OpenClaw can no longer write to calendar
+   * shield.revokeScope('OpenClaw', 'write:calendar');
+   * ```
+   */
+  revokeScope(agentId, scope) {
+    this.#assertNotDestroyed();
+    const parsed = parseScope(scope);
+    const current = this.#grantedScopes.get(agentId) ?? [];
+    this.#grantedScopes.set(
+      agentId,
+      current.filter(
+        (s) => !(s.service === parsed.service && s.permissionLevel === parsed.permissionLevel)
+      )
+    );
+  }
+  /**
+   * Return the current granted scopes for an agent.
+   *
+   * @param agentId - The agent to query.
+   * @returns The scopes granted to this agent. Empty array if none have been granted.
+   * @throws {Error} If the instance has been destroyed.
+   *
+   * @example
+   * ```ts
+   * const scopes = shield.getGrantedScopes('OpenClaw');
+   * // [{ service: 'gmail', permissionLevel: 'read' }, ...]
+   * ```
+   */
+  getGrantedScopes(agentId) {
+    this.#assertNotDestroyed();
+    return this.#grantedScopes.get(agentId) ?? [];
+  }
+  /**
+   * Pre-check whether a proposed spend would be allowed for an agent.
+   *
+   * This is a read-only check. It does **not** record the spend.
+   * Call this before executing a transaction to surface limit violations
+   * early. If no spending limit was configured via {@link requestConsent},
+   * all amounts are allowed.
+   *
+   * @param agentId - The agent proposing the spend.
+   * @param amount - The proposed spend amount in dollars (e.g. `49.99`).
+   * @returns Whether the spend is allowed and what budget remains.
+   * @throws {Error} If the instance has been destroyed.
+   *
+   * @example
+   * ```ts
+   * const result = shield.checkSpending('OpenClaw', 50);
+   * if (!result.allowed) {
+   *   console.error(result.reason);
+   * }
+   * ```
+   */
+  checkSpending(agentId, amount) {
+    this.#assertNotDestroyed();
+    const checker = this.#spendingCheckers.get(agentId);
+    if (checker === void 0) {
+      return {
+        allowed: true,
+        remainingBudget: {
+          transaction: Number.MAX_SAFE_INTEGER,
+          daily: Number.MAX_SAFE_INTEGER,
+          monthly: Number.MAX_SAFE_INTEGER
+        }
+      };
+    }
+    return checker.checkSpend(dollarsToCents(amount));
+  }
+  /**
+   * Clean up the SDK instance.
+   *
+   * Flushes any pending log entries, removes the consent screen from the
+   * DOM if it is still open, and marks the instance as destroyed. All
+   * subsequent method calls will throw after `destroy()` is called.
+   *
+   * Safe to call multiple times. Subsequent calls are no-ops.
+   *
+   * @example
+   * ```ts
+   * // In a SPA teardown hook:
+   * shield.destroy();
+   * ```
+   */
+  destroy() {
+    if (this.#isDestroyed) return;
+    this.#isDestroyed = true;
+    this.#logger.shutdown().catch(() => {
+    });
+    if (this.#consentContainer !== null) {
+      this.#consentContainer.remove();
+      this.#consentContainer = null;
+    }
+  }
+  // Private helpers
+  #assertNotDestroyed() {
+    if (this.#isDestroyed) {
+      throw new Error(
+        "[MulticornShield] This instance has been destroyed. Create a new MulticornShield instance."
+      );
+    }
+  }
+  #setupSpendingChecker(agentId, spendLimitDollars) {
+    const limitCents = dollarsToCents(spendLimitDollars);
+    this.#spendingCheckers.set(
+      agentId,
+      createSpendingChecker({
+        limits: {
+          perTransaction: limitCents,
+          // Daily and monthly limits are derived from the per-transaction limit
+          // as sensible defaults. Developers needing tighter controls can use
+          // the spending module directly.
+          perDay: limitCents * 10,
+          perMonth: limitCents * 100
+        }
+      })
+    );
+  }
+};
+function validateBaseUrl(baseUrl) {
+  if (!baseUrl.startsWith("https://") && !baseUrl.startsWith("http://localhost")) {
+    throw new Error(
+      `[MulticornShield] Base URL must use HTTPS for security. Received: "${baseUrl}". Use https:// or http://localhost for local development.`
+    );
+  }
+}
+function validateApiKey(apiKey) {
+  if (!apiKey.startsWith(API_KEY_PREFIX)) {
+    throw new Error(
+      `[MulticornShield] Invalid API key format. Keys must start with "${API_KEY_PREFIX}". Find your API key in the Multicorn dashboard under Settings \u2192 API Keys.`
+    );
+  }
+  if (apiKey.length < MIN_API_KEY_LENGTH) {
+    throw new Error(
+      `[MulticornShield] API key is too short (${String(apiKey.length)} characters). Minimum length is ${String(MIN_API_KEY_LENGTH)} characters. Find your API key in the Multicorn dashboard under Settings \u2192 API Keys.`
+    );
+  }
+}
+
+exports.ACTION_STATUSES = ACTION_STATUSES;
+exports.AGENT_STATUSES = AGENT_STATUSES;
+exports.BUILT_IN_SERVICES = BUILT_IN_SERVICES;
+exports.CONSENT_ELEMENT_TAG = CONSENT_ELEMENT_TAG;
+exports.MulticornShield = MulticornShield;
+exports.PERMISSION_LEVELS = PERMISSION_LEVELS;
+exports.SERVICE_NAME_PATTERN = SERVICE_NAME_PATTERN;
+exports.ScopeParseError = ScopeParseError;
+exports.centsToDollars = centsToDollars;
+exports.createActionLogger = createActionLogger;
+exports.createFocusTrap = createFocusTrap;
+exports.createMcpAdapter = createMcpAdapter;
+exports.createScopeRegistry = createScopeRegistry;
+exports.createSpendingChecker = createSpendingChecker;
+exports.dollarsToCents = dollarsToCents;
+exports.formatScope = formatScope;
+exports.getPermissionLabel = getPermissionLabel;
+exports.getScopeLabel = getScopeLabel;
+exports.getScopeShortLabel = getScopeShortLabel;
+exports.getServiceDisplayName = getServiceDisplayName;
+exports.getServiceIcon = getServiceIcon;
+exports.hasScope = hasScope;
+exports.isBlockedResult = isBlockedResult;
+exports.isValidScopeString = isValidScopeString;
+exports.parseScope = parseScope;
+exports.parseScopes = parseScopes;
+exports.tryParseScope = tryParseScope;
+exports.validateAllScopesAccess = validateAllScopesAccess;
+exports.validateScopeAccess = validateScopeAccess;