@arelis-ai/ai-governance-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,4079 @@
+'use strict';
+
+var governanceCore = require('@arelis-ai/governance-core');
+var governancePolicy = require('@arelis-ai/governance-policy');
+var governanceAudit = require('@arelis-ai/governance-audit');
+var crypto = require('crypto');
+var governanceModels = require('@arelis-ai/governance-models');
+var governanceTelemetryOtel = require('@arelis-ai/governance-telemetry-otel');
+var governanceMcp = require('@arelis-ai/governance-mcp');
+var governanceKnowledge = require('@arelis-ai/governance-knowledge');
+var governancePrompts = require('@arelis-ai/governance-prompts');
+var governanceMemory = require('@arelis-ai/governance-memory');
+var governanceDataSources = require('@arelis-ai/governance-data-sources');
+var governanceEvaluations = require('@arelis-ai/governance-evaluations');
+var governanceSecrets = require('@arelis-ai/governance-secrets');
+var governanceAgents = require('@arelis-ai/governance-agents');
+var governanceTools = require('@arelis-ai/governance-tools');
+var governanceQuotas = require('@arelis-ai/governance-quotas');
+
+// src/client.ts
+var CAUSAL_GRAPH_SCHEMA_VERSION = "1.0";
+function normalizeValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    const sortedKeys = Object.keys(record).sort();
+    const result = {};
+    for (const key of sortedKeys) {
+      result[key] = normalizeValue(record[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function canonicalizePayload(value) {
+  return JSON.stringify(normalizeValue(value));
+}
+function hashPayload(payload) {
+  return crypto.createHash("sha256").update(payload).digest("hex");
+}
+function hashObject(value) {
+  return hashPayload(canonicalizePayload(value));
+}
+function computeMerkleRoot(hashes) {
+  if (hashes.length === 0) {
+    return hashPayload("");
+  }
+  let level = [...hashes];
+  while (level.length > 1) {
+    const nextLevel = [];
+    for (let i = 0; i < level.length; i += 2) {
+      const left = level[i];
+      const right = level[i + 1] ?? left;
+      nextLevel.push(hashPayload(`${left}${right}`));
+    }
+    level = nextLevel;
+  }
+  return level[0];
+}
+var LocalCausalGraphBuilder = class {
+  runId;
+  nodes = /* @__PURE__ */ new Map();
+  edges = /* @__PURE__ */ new Map();
+  lastEventByRun = /* @__PURE__ */ new Map();
+  constructor(runId) {
+    this.runId = runId;
+  }
+  recordEvent(event) {
+    const runNodeId = `run:${event.runId}`;
+    if (!this.nodes.has(runNodeId)) {
+      this.nodes.set(runNodeId, {
+        id: runNodeId,
+        kind: "run",
+        runId: event.runId,
+        digest: hashObject({ runId: event.runId, kind: "run" })
+      });
+    }
+    const eventNodeId = `evt:${event.eventId}`;
+    if (!this.nodes.has(eventNodeId)) {
+      this.nodes.set(eventNodeId, {
+        id: eventNodeId,
+        kind: "event",
+        runId: event.runId,
+        eventId: event.eventId,
+        eventType: event.type,
+        time: event.time,
+        event,
+        digest: hashObject({
+          eventId: event.eventId,
+          runId: event.runId,
+          type: event.type,
+          time: event.time
+        })
+      });
+    }
+    const containsId = `${runNodeId}:contains:${eventNodeId}`;
+    this.edges.set(containsId, {
+      id: containsId,
+      from: runNodeId,
+      to: eventNodeId,
+      kind: "contains"
+    });
+    const lastEvent = this.lastEventByRun.get(event.runId);
+    if (lastEvent && lastEvent !== eventNodeId) {
+      const sequenceId = `${lastEvent}:sequence:${eventNodeId}`;
+      this.edges.set(sequenceId, {
+        id: sequenceId,
+        from: lastEvent,
+        to: eventNodeId,
+        kind: "sequence"
+      });
+    }
+    this.lastEventByRun.set(event.runId, eventNodeId);
+    if (event.parentRunId) {
+      const parentRunId = `run:${event.parentRunId}`;
+      if (!this.nodes.has(parentRunId)) {
+        this.nodes.set(parentRunId, {
+          id: parentRunId,
+          kind: "run",
+          runId: event.parentRunId,
+          digest: hashObject({ runId: event.parentRunId, kind: "run" })
+        });
+      }
+      const parentEdgeId = `${parentRunId}:parent:${runNodeId}`;
+      this.edges.set(parentEdgeId, {
+        id: parentEdgeId,
+        from: parentRunId,
+        to: runNodeId,
+        kind: "parent"
+      });
+    }
+  }
+  build() {
+    return {
+      runId: this.runId,
+      schemaVersion: CAUSAL_GRAPH_SCHEMA_VERSION,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      nodes: Array.from(this.nodes.values()),
+      edges: Array.from(this.edges.values())
+    };
+  }
+};
+var LocalCausalGraphAuditSink = class {
+  baseSink;
+  store;
+  builders = /* @__PURE__ */ new Map();
+  constructor(baseSink, store) {
+    this.baseSink = baseSink;
+    this.store = store;
+  }
+  async write(event) {
+    await this.baseSink.write(event);
+    this.record(event);
+    await this.persistIfComplete(event);
+  }
+  async writeBatch(events) {
+    if (this.baseSink.writeBatch) {
+      await this.baseSink.writeBatch(events);
+    } else {
+      for (const event of events) {
+        await this.baseSink.write(event);
+      }
+    }
+    for (const event of events) {
+      this.record(event);
+      await this.persistIfComplete(event);
+    }
+  }
+  async flush() {
+    if (this.baseSink.flush) {
+      await this.baseSink.flush();
+    }
+  }
+  async close() {
+    for (const builder of this.builders.values()) {
+      await this.store.save(builder.build());
+    }
+    this.builders.clear();
+    if (this.baseSink.close) {
+      await this.baseSink.close();
+    }
+  }
+  record(event) {
+    const builder = this.builders.get(event.runId) ?? new LocalCausalGraphBuilder(event.runId);
+    builder.recordEvent(event);
+    this.builders.set(event.runId, builder);
+  }
+  async persistIfComplete(event) {
+    if (event.type !== "run.ended" && event.type !== "run.error") {
+      return;
+    }
+    const builder = this.builders.get(event.runId);
+    if (!builder) {
+      return;
+    }
+    await this.store.save(builder.build());
+  }
+};
+function createCausalGraphAuditSink(baseSink, store) {
+  return new LocalCausalGraphAuditSink(baseSink, store);
+}
+function createCausalGraphCommitment(graph, signer) {
+  const nodeDigests = graph.nodes.map((node) => node.digest).sort();
+  const root = computeMerkleRoot(nodeDigests);
+  const commitment = {
+    runId: graph.runId,
+    root,
+    algorithm: "sha256",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodeCount: graph.nodes.length,
+    edgeCount: graph.edges.length
+  };
+  if (signer) {
+    const payload = `${commitment.runId}:${commitment.root}:${commitment.createdAt}`;
+    commitment.signerId = signer.id;
+    commitment.signature = signer.sign(payload);
+  }
+  return commitment;
+}
+var HashProofProvider = class extends governanceAudit.HashProofProvider {
+};
+var InMemoryComplianceArtifactStore = class {
+  artifactsByRun = /* @__PURE__ */ new Map();
+  async save(artifact) {
+    const existing = this.artifactsByRun.get(artifact.runId) ?? [];
+    existing.push(artifact);
+    this.artifactsByRun.set(artifact.runId, existing);
+  }
+  async get(runId, artifactId) {
+    const list = this.artifactsByRun.get(runId) ?? [];
+    return list.find((artifact) => artifact.id === artifactId);
+  }
+  async list(runId) {
+    return this.artifactsByRun.get(runId) ?? [];
+  }
+};
+function resolveDisclosureRules(baseRules, allowedRuleIds) {
+  if (!allowedRuleIds || allowedRuleIds.length === 0) {
+    return baseRules;
+  }
+  const allowed = new Set(allowedRuleIds);
+  return baseRules.filter((rule) => allowed.has(rule.id));
+}
+function toAuditDecisions(decisions) {
+  return decisions.map((d) => {
+    if (d.effect === "block") {
+      return {
+        effect: "block",
+        reason: d.reason,
+        code: d.code
+      };
+    } else if (d.effect === "transform") {
+      return {
+        effect: "transform",
+        reason: d.reason
+      };
+    } else if (d.effect === "require_approval") {
+      return {
+        effect: "require_approval",
+        reason: d.reason
+      };
+    }
+    return { effect: "allow" };
+  });
+}
+function toPolicySummary(result) {
+  const summary = {
+    evaluated: result.decisions.length,
+    allowed: result.decisions.filter((d) => d.effect === "allow").length,
+    blocked: result.decisions.filter((d) => d.effect === "block").length,
+    transformed: result.decisions.filter((d) => d.effect === "transform").length
+  };
+  const reasons = result.decisions.filter((d) => d.effect !== "allow").map((d) => {
+    if (d.effect === "block") return d.reason;
+    if (d.effect === "transform") return d.reason;
+    if (d.effect === "require_approval") return d.reason;
+    return void 0;
+  }).filter((r) => r !== void 0);
+  if (reasons.length > 0) {
+    summary.reasons = reasons;
+  }
+  return summary;
+}
+var ArelisClient = class {
+  modelRegistry;
+  policyEngine;
+  auditSink;
+  telemetry;
+  contextResolver;
+  toolRegistry;
+  mcpRegistry;
+  kbRegistry;
+  promptRegistry;
+  memoryRegistry;
+  dataSourceRegistry;
+  quotaManager;
+  evaluators;
+  approvalStore;
+  secretResolver;
+  redactor;
+  compiledPolicy;
+  complianceGraphStore;
+  complianceArtifactStore;
+  complianceProofProvider;
+  complianceProofJobQueue;
+  complianceDisclosureRules;
+  complianceSigner;
+  complianceProofCache = /* @__PURE__ */ new Map();
+  complianceProofTimeoutMs;
+  extensions;
+  riskRouterConfig;
+  runSnapshots = /* @__PURE__ */ new Map();
+  /**
+   * Models namespace for model operations
+   */
+  models;
+  /**
+   * Agents namespace for agent operations
+   */
+  agents;
+  /**
+   * MCP namespace for MCP server operations
+   */
+  mcp;
+  /**
+   * Knowledge namespace for knowledge base operations
+   */
+  knowledge;
+  prompts;
+  memory;
+  dataSources;
+  approvals;
+  evaluations;
+  quotas;
+  secrets;
+  compliance;
+  governance;
+  constructor(config) {
+    this.modelRegistry = config.modelRegistry;
+    this.policyEngine = config.policyEngine;
+    const compiledPolicy = config.policyCompilation ? config.policyCompilation.compiler.compile(config.policyCompilation.source) : void 0;
+    this.compiledPolicy = compiledPolicy;
+    this.complianceGraphStore = config.compliance?.causalGraphStore;
+    this.complianceArtifactStore = config.compliance?.artifactStore ?? (config.compliance ? new InMemoryComplianceArtifactStore() : void 0);
+    this.complianceProofProvider = config.compliance?.proofProvider ?? (config.compliance ? new HashProofProvider() : void 0);
+    this.complianceProofJobQueue = config.compliance?.proofJobQueue;
+    this.complianceDisclosureRules = config.compliance?.disclosureRules ?? compiledPolicy?.disclosureRules;
+    this.complianceSigner = config.compliance?.commitmentSigner;
+    this.complianceProofTimeoutMs = config.compliance?.proofTimeoutMs;
+    this.extensions = config.extensions;
+    this.riskRouterConfig = {
+      mode: config.extensions?.riskRouting?.mode ?? "off",
+      defaultAction: config.extensions?.riskRouting?.defaultAction
+    };
+    this.auditSink = this.complianceGraphStore ? createCausalGraphAuditSink(config.auditSink, this.complianceGraphStore) : config.auditSink;
+    this.telemetry = config.telemetry ?? governanceTelemetryOtel.createNoOpTelemetry();
+    this.contextResolver = config.contextResolver ?? governanceCore.defaultContextResolver;
+    this.toolRegistry = config.toolRegistry;
+    this.mcpRegistry = config.mcpRegistry ?? governanceMcp.createMCPRegistry();
+    this.kbRegistry = config.kbRegistry ?? governanceKnowledge.createKBRegistry();
+    this.promptRegistry = config.promptRegistry ?? governancePrompts.createTemplateRegistry();
+    this.memoryRegistry = config.memoryRegistry ?? governanceMemory.createMemoryRegistry();
+    if (this.memoryRegistry.list().length === 0) {
+      this.memoryRegistry.register(governanceMemory.createInMemoryMemoryProvider());
+    }
+    this.dataSourceRegistry = config.dataSourceRegistry ?? governanceDataSources.createDataSourceRegistry();
+    this.quotaManager = config.quotaManager;
+    this.evaluators = config.evaluators ?? [];
+    this.approvalStore = config.approvalStore ?? governanceCore.createInMemoryApprovalStore();
+    this.secretResolver = config.secretResolver ?? governanceSecrets.createEnvSecretResolver();
+    this.redactor = config.redactor ?? governancePolicy.createRedactor({ secretPatterns: governanceSecrets.getSecretRedactionPatterns() });
+    this.models = {
+      generate: this.generate.bind(this),
+      generateStream: this.generateStream.bind(this)
+    };
+    this.agents = {
+      run: this.runAgent.bind(this)
+    };
+    this.mcp = {
+      registerServer: this.registerMCPServer.bind(this),
+      discoverTools: this.discoverMCPTools.bind(this),
+      getRegistry: () => this.mcpRegistry
+    };
+    this.knowledge = {
+      registerKB: this.registerKB.bind(this),
+      retrieve: this.retrieve.bind(this),
+      getRegistry: () => this.kbRegistry
+    };
+    this.prompts = {
+      register: this.registerPromptTemplate.bind(this),
+      get: (query) => this.promptRegistry.get(query),
+      list: (id) => this.promptRegistry.list(id)
+    };
+    this.memory = {
+      read: this.readMemory.bind(this),
+      write: this.writeMemory.bind(this),
+      delete: this.deleteMemory.bind(this),
+      list: async (scope, contextInput) => {
+        const provider = this.getDefaultMemoryProvider();
+        const context = await this.contextResolver(contextInput);
+        return provider.list(scope, { runId: governanceCore.generateRunId(), governance: context });
+      }
+    };
+    this.dataSources = {
+      register: this.registerDataSource.bind(this),
+      read: this.readDataSource.bind(this),
+      getRegistry: () => this.dataSourceRegistry
+    };
+    this.approvals = {
+      approve: this.approveRequest.bind(this),
+      reject: this.rejectRequest.bind(this),
+      list: (status) => this.approvalStore.list(status),
+      get: (approvalId) => this.approvalStore.get(approvalId)
+    };
+    this.evaluations = {
+      run: async (input, evaluators) => this.runEvaluations(input, evaluators)
+    };
+    this.quotas = {
+      check: async (key, proposed) => {
+        if (!this.quotaManager) {
+          throw new Error("Quota manager not configured");
+        }
+        return this.quotaManager.check(key, proposed);
+      },
+      commit: async (key, actual) => {
+        if (!this.quotaManager) {
+          throw new Error("Quota manager not configured");
+        }
+        return this.quotaManager.commit(key, actual);
+      }
+    };
+    this.secrets = {
+      resolve: async (ref, contextInput) => {
+        const runId = governanceCore.generateRunId();
+        const context = contextInput ? await this.contextResolver(contextInput) : void 0;
+        const resolved = await governanceSecrets.resolveSecretValue(this.secretResolver, ref, {
+          context,
+          runId
+        });
+        if (context) {
+          await this.auditSink.write(
+            governanceAudit.createSecretResolvedEvent({
+              runId,
+              context,
+              ref,
+              resolverId: resolved.resolution.resolverId
+            })
+          );
+        }
+        return resolved.value;
+      }
+    };
+    this.compliance = {
+      requestArtifact: this.requestComplianceArtifact.bind(this),
+      getArtifacts: async (runId) => this.complianceArtifactStore ? this.complianceArtifactStore.list(runId) : [],
+      verifyArtifact: this.verifyComplianceArtifact.bind(this),
+      replayRun: this.replayComplianceRun.bind(this)
+    };
+    this.governance = {
+      createGateEvaluator: () => ({
+        resolveContext: (partial) => this.contextResolver(partial),
+        evaluatePolicy: (input) => this.evaluatePolicy(input.checkpoint, input.runId, input.context, input.data),
+        getPolicyMetadata: () => this.getPolicyAuditMetadata()
+      })
+    };
+  }
+  /**
+   * Generate a response from a model
+   */
+  async generate(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const startTime = Date.now();
+    const resolveSpan = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.MODEL_RESOLVE, {
+      "arelis.run.id": runId,
+      "arelis.model.requested": input.model,
+      ...this.telemetry.contextAttributes(context)
+    });
+    let resolved;
+    try {
+      resolved = this.modelRegistry.resolveRouteOrModel({
+        routeOrModelId: input.model,
+        context,
+        dataClass: input.dataClass,
+        requiredResidency: input.requiredResidency
+      });
+      resolveSpan.setAttribute("arelis.model.id", resolved.descriptor.id);
+      if (resolved.routeId) {
+        resolveSpan.setAttribute("arelis.model.route.id", resolved.routeId);
+      }
+    } catch (error) {
+      resolveSpan.recordError(error instanceof Error ? error : new Error(String(error)));
+      resolveSpan.setStatus(
+        "error",
+        error instanceof Error ? error.message : "Model resolution failed"
+      );
+      resolveSpan.end();
+      throw error;
+    }
+    const modelId = resolved.descriptor.id;
+    const provider = this.modelRegistry.resolve(resolved.descriptor.providerId);
+    let requestToSend = { ...input.request, model: modelId, context };
+    const promptTemplate = this.resolvePromptTemplate(input.promptTemplate);
+    if (promptTemplate) {
+      requestToSend = this.applyPromptTemplate(promptTemplate, requestToSend);
+    }
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.MODEL_GENERATE, {
+      "arelis.run.id": runId,
+      "arelis.model.id": modelId,
+      ...this.telemetry.contextAttributes(context)
+    });
+    let policySummary;
+    const warnings = [];
+    try {
+      await this.auditSink.write(
+        governanceAudit.createRunStartedEvent({
+          runId,
+          context,
+          operation: "models.generate"
+        })
+      );
+      try {
+        await this.emitModelResolutionEvents(runId, context, resolved);
+        await this.captureSnapshot({
+          runId,
+          context,
+          modelRouteId: resolved.routeId
+        });
+        resolveSpan.setStatus("ok");
+      } catch (error) {
+        resolveSpan.recordError(error instanceof Error ? error : new Error(String(error)));
+        resolveSpan.setStatus(
+          "error",
+          error instanceof Error ? error.message : "Model resolution failed"
+        );
+        throw error;
+      } finally {
+        resolveSpan.end();
+      }
+      const quotaDecision = await this.preflightQuota(
+        runId,
+        context,
+        provider,
+        requestToSend,
+        input.options
+      );
+      let generationOptions = input.options;
+      if (quotaDecision?.effect === "limit" && quotaDecision.applied.tokensOut !== void 0) {
+        const currentMax = generationOptions?.maxTokens;
+        const limited = quotaDecision.applied.tokensOut;
+        generationOptions = {
+          ...generationOptions ?? {},
+          maxTokens: currentMax ? Math.min(currentMax, limited) : limited
+        };
+      }
+      if (promptTemplate) {
+        await this.auditSink.write(
+          governanceAudit.createPromptTemplateUsedEvent({
+            runId,
+            context,
+            template: {
+              id: promptTemplate.id,
+              version: promptTemplate.version,
+              hash: promptTemplate.hash
+            }
+          })
+        );
+      }
+      const beforePromptResult = await this.evaluatePolicy("BeforePrompt", runId, context, {
+        modelId,
+        input: requestToSend.messages
+      });
+      if (!beforePromptResult.summary.allowed) {
+        throw await this.createPolicyError(beforePromptResult, runId, context);
+      }
+      await this.auditSink.write(
+        this.createPolicyEvaluatedEventWithMetadata({
+          runId,
+          context,
+          checkpoint: "BeforePrompt",
+          decisions: toAuditDecisions(beforePromptResult.decisions),
+          allowed: true,
+          policyVersion: beforePromptResult.policyVersion
+        })
+      );
+      const riskRouteMode = await this.enforceRuntimeRiskRoute({
+        runId,
+        context,
+        operation: "models.generate",
+        policyDecisions: beforePromptResult.decisions,
+        quotaEffect: quotaDecision?.effect
+      });
+      if (riskRouteMode === "sandbox") {
+        warnings.push({
+          code: "risk.sandbox",
+          message: "Execution proceeded in sandbox mode"
+        });
+      }
+      if (input.grounding) {
+        const grounded = await this.applyGrounding(input.grounding, requestToSend, runId, context);
+        requestToSend = grounded.request;
+      }
+      await this.auditSink.write(
+        governanceAudit.createModelRequestEvent({
+          runId,
+          context,
+          model: {
+            id: modelId,
+            provider: provider.id,
+            version: resolved.descriptor.version,
+            lifecycleState: resolved.descriptor.lifecycleState
+          },
+          inputRef: governanceAudit.createInlineRef(JSON.stringify(requestToSend.messages)),
+          promptTemplate: promptTemplate ? { id: promptTemplate.id, version: promptTemplate.version, hash: promptTemplate.hash } : void 0
+        })
+      );
+      const response = await provider.generate(requestToSend, generationOptions);
+      const afterOutputResult = await this.evaluatePolicy("AfterModelOutput", runId, context, {
+        modelId,
+        input: requestToSend.messages,
+        output: response.content
+      });
+      if (!afterOutputResult.summary.allowed) {
+        throw await this.createPolicyError(afterOutputResult, runId, context);
+      }
+      await this.auditSink.write(
+        this.createPolicyEvaluatedEventWithMetadata({
+          runId,
+          context,
+          checkpoint: "AfterModelOutput",
+          decisions: toAuditDecisions(afterOutputResult.decisions),
+          allowed: true,
+          policyVersion: afterOutputResult.policyVersion
+        })
+      );
+      const outputContent = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      const evaluationResult = await this.evaluateOutput(
+        runId,
+        context,
+        outputContent,
+        input.evaluators
+      );
+      if (evaluationResult?.effect === "warn") {
+        warnings.push({ code: "evaluation.warn", message: "Evaluation warnings" });
+      }
+      const validation = await this.validateOutputSchema(
+        input.outputSchema,
+        outputContent,
+        input.outputValidationMode ?? "block",
+        runId,
+        context
+      );
+      if (validation?.warning) {
+        warnings.push({ code: "output.validation", message: validation.warning });
+      }
+      await this.auditSink.write(
+        governanceAudit.createModelResponseEvent({
+          runId,
+          context,
+          model: { id: modelId, provider: provider.id },
+          outputRef: governanceAudit.createInlineRef(outputContent),
+          usage: response.usage
+        })
+      );
+      if (this.quotaManager && response.usage) {
+        await this.commitQuota(runId, context, response.usage);
+      }
+      policySummary = this.mergePolicySummaries([
+        toPolicySummary(beforePromptResult),
+        toPolicySummary(afterOutputResult)
+      ]);
+      const durationMs = Date.now() - startTime;
+      await this.auditSink.write(
+        governanceAudit.createRunEndedEvent({
+          runId,
+          context,
+          success: true,
+          durationMs
+        })
+      );
+      span.setStatus("ok");
+      span.end();
+      return {
+        runId,
+        output: response,
+        usage: response.usage,
+        policy: policySummary,
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    } catch (error) {
+      span.recordError(error instanceof Error ? error : new Error(String(error)));
+      span.setStatus("error", error instanceof Error ? error.message : "Unknown error");
+      span.end();
+      const durationMs = Date.now() - startTime;
+      await this.auditSink.write(
+        governanceAudit.createRunEndedEvent({
+          runId,
+          context,
+          success: false,
+          durationMs
+        })
+      );
+      throw error;
+    }
+  }
+  async generateStream(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const startTime = Date.now();
+    const resolveSpan = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.MODEL_RESOLVE, {
+      "arelis.run.id": runId,
+      "arelis.model.requested": input.model,
+      ...this.telemetry.contextAttributes(context)
+    });
+    let resolved;
+    try {
+      resolved = this.modelRegistry.resolveRouteOrModel({
+        routeOrModelId: input.model,
+        context,
+        dataClass: input.dataClass,
+        requiredResidency: input.requiredResidency
+      });
+      resolveSpan.setAttribute("arelis.model.id", resolved.descriptor.id);
+      if (resolved.routeId) {
+        resolveSpan.setAttribute("arelis.model.route.id", resolved.routeId);
+      }
+    } catch (error) {
+      resolveSpan.recordError(error instanceof Error ? error : new Error(String(error)));
+      resolveSpan.setStatus(
+        "error",
+        error instanceof Error ? error.message : "Model resolution failed"
+      );
+      resolveSpan.end();
+      throw error;
+    }
+    const modelId = resolved.descriptor.id;
+    const provider = this.modelRegistry.resolve(resolved.descriptor.providerId);
+    if (!governanceModels.supportsStreaming(provider)) {
+      throw new Error(`Model provider "${provider.id}" does not support streaming`);
+    }
+    let requestToSend = { ...input.request, model: modelId, context };
+    const promptTemplate = this.resolvePromptTemplate(input.promptTemplate);
+    if (promptTemplate) {
+      requestToSend = this.applyPromptTemplate(promptTemplate, requestToSend);
+    }
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.MODEL_STREAM, {
+      "arelis.run.id": runId,
+      "arelis.model.id": modelId,
+      ...this.telemetry.contextAttributes(context)
+    });
+    await this.auditSink.write(
+      governanceAudit.createRunStartedEvent({
+        runId,
+        context,
+        operation: "models.generateStream"
+      })
+    );
+    try {
+      await this.emitModelResolutionEvents(runId, context, resolved);
+      await this.captureSnapshot({
+        runId,
+        context,
+        modelRouteId: resolved.routeId
+      });
+      resolveSpan.setStatus("ok");
+    } catch (error) {
+      resolveSpan.recordError(error instanceof Error ? error : new Error(String(error)));
+      resolveSpan.setStatus(
+        "error",
+        error instanceof Error ? error.message : "Model resolution failed"
+      );
+      throw error;
+    } finally {
+      resolveSpan.end();
+    }
+    const quotaDecision = await this.preflightQuota(
+      runId,
+      context,
+      provider,
+      requestToSend,
+      input.options
+    );
+    let generationOptions = input.options;
+    if (quotaDecision?.effect === "limit" && quotaDecision.applied.tokensOut !== void 0) {
+      const currentMax = generationOptions?.maxTokens;
+      const limited = quotaDecision.applied.tokensOut;
+      generationOptions = {
+        ...generationOptions ?? {},
+        maxTokens: currentMax ? Math.min(currentMax, limited) : limited
+      };
+    }
+    if (promptTemplate) {
+      await this.auditSink.write(
+        governanceAudit.createPromptTemplateUsedEvent({
+          runId,
+          context,
+          template: {
+            id: promptTemplate.id,
+            version: promptTemplate.version,
+            hash: promptTemplate.hash
+          }
+        })
+      );
+    }
+    const beforePromptResult = await this.evaluatePolicy("BeforePrompt", runId, context, {
+      modelId,
+      input: requestToSend.messages
+    });
+    if (!beforePromptResult.summary.allowed) {
+      throw await this.createPolicyError(beforePromptResult, runId, context);
+    }
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforePrompt",
+        decisions: toAuditDecisions(beforePromptResult.decisions),
+        allowed: true,
+        policyVersion: beforePromptResult.policyVersion
+      })
+    );
+    await this.enforceRuntimeRiskRoute({
+      runId,
+      context,
+      operation: "models.generateStream",
+      policyDecisions: beforePromptResult.decisions,
+      quotaEffect: quotaDecision?.effect
+    });
+    if (input.grounding) {
+      const grounded = await this.applyGrounding(input.grounding, requestToSend, runId, context);
+      requestToSend = grounded.request;
+    }
+    await this.auditSink.write(
+      governanceAudit.createModelRequestEvent({
+        runId,
+        context,
+        model: { id: modelId, provider: provider.id, version: resolved.descriptor.version },
+        inputRef: governanceAudit.createInlineRef(JSON.stringify(requestToSend.messages)),
+        promptTemplate: promptTemplate ? { id: promptTemplate.id, version: promptTemplate.version, hash: promptTemplate.hash } : void 0
+      })
+    );
+    await this.auditSink.write(
+      governanceAudit.createModelStreamStartedEvent({
+        runId,
+        context,
+        model: { id: modelId, provider: provider.id }
+      })
+    );
+    const emitChunks = input.streamOptions?.emitChunks ?? true;
+    const abortOnSensitive = input.streamOptions?.abortOnSensitive ?? false;
+    const baseStream = provider.stream(requestToSend, generationOptions);
+    const auditSink = this.auditSink;
+    const redactor = this.redactor;
+    const evaluatePolicy = this.evaluatePolicy.bind(this);
+    const createPolicyError = this.createPolicyError.bind(this);
+    const evaluateOutput = this.evaluateOutput.bind(this);
+    const validateOutputSchema = this.validateOutputSchema.bind(this);
+    const commitQuota = this.commitQuota.bind(this);
+    const createPolicyEvaluatedEventWithMetadata = this.createPolicyEvaluatedEventWithMetadata.bind(this);
+    const quotaManager = this.quotaManager;
+    let completed = false;
+    let outputContent = "";
+    let usage;
+    async function* wrappedStream() {
+      try {
+        for await (const chunk of baseStream) {
+          if (chunk.type === "content" && chunk.content) {
+            outputContent += chunk.content;
+            if (abortOnSensitive && redactor.containsSensitiveData(chunk.content)) {
+              await auditSink.write(
+                governanceAudit.createSecretDetectedBlockedEvent({
+                  runId,
+                  context,
+                  reason: "Sensitive content detected in stream chunk"
+                })
+              );
+              await auditSink.write(
+                governanceAudit.createModelStreamAbortedEvent({
+                  runId,
+                  context,
+                  model: { id: modelId, provider: provider.id },
+                  reason: "Sensitive content detected"
+                })
+              );
+              throw new Error("Sensitive content detected during streaming");
+            }
+          }
+          if (chunk.type === "usage") {
+            usage = chunk.usage;
+          }
+          if (emitChunks) {
+            await auditSink.write(
+              governanceAudit.createModelStreamChunkEvent({
+                runId,
+                context,
+                model: { id: modelId, provider: provider.id },
+                chunkType: chunk.type,
+                size: chunk.content ? chunk.content.length : void 0
+              })
+            );
+          }
+          if (chunk.type === "done") {
+            const afterOutputResult = await evaluatePolicy("AfterModelOutput", runId, context, {
+              modelId,
+              input: requestToSend.messages,
+              output: outputContent
+            });
+            if (!afterOutputResult.summary.allowed) {
+              throw await createPolicyError(afterOutputResult, runId, context);
+            }
+            await auditSink.write(
+              createPolicyEvaluatedEventWithMetadata({
+                runId,
+                context,
+                checkpoint: "AfterModelOutput",
+                decisions: toAuditDecisions(afterOutputResult.decisions),
+                allowed: true,
+                policyVersion: afterOutputResult.policyVersion
+              })
+            );
+            await evaluateOutput(runId, context, outputContent, input.evaluators);
+            await validateOutputSchema(
+              input.outputSchema,
+              outputContent,
+              input.outputValidationMode ?? "block",
+              runId,
+              context
+            );
+            await auditSink.write(
+              governanceAudit.createModelResponseEvent({
+                runId,
+                context,
+                model: { id: modelId, provider: provider.id },
+                outputRef: governanceAudit.createInlineRef(outputContent),
+                usage
+              })
+            );
+            if (quotaManager && usage) {
+              await commitQuota(runId, context, usage);
+            }
+            await auditSink.write(
+              governanceAudit.createModelStreamEndedEvent({
+                runId,
+                context,
+                model: { id: modelId, provider: provider.id },
+                finishReason: chunk.finishReason
+              })
+            );
+            await auditSink.write(
+              governanceAudit.createRunEndedEvent({
+                runId,
+                context,
+                success: true,
+                durationMs: Date.now() - startTime
+              })
+            );
+            completed = true;
+          }
+          yield chunk;
+        }
+      } catch (error) {
+        if (!completed) {
+          await auditSink.write(
+            governanceAudit.createModelStreamAbortedEvent({
+              runId,
+              context,
+              model: { id: modelId, provider: provider.id },
+              reason: error instanceof Error ? error.message : "Stream aborted"
+            })
+          );
+          await auditSink.write(
+            governanceAudit.createRunEndedEvent({
+              runId,
+              context,
+              success: false,
+              durationMs: Date.now() - startTime
+            })
+          );
+        }
+        span.recordError(error instanceof Error ? error : new Error(String(error)));
+        span.setStatus("error", error instanceof Error ? error.message : "Unknown error");
+        span.end();
+        throw error;
+      } finally {
+        if (completed) {
+          span.setStatus("ok");
+          span.end();
+        }
+      }
+    }
+    return { runId, stream: wrappedStream() };
+  }
+  /**
+   * Run an agent with limits and governance
+   */
+  async runAgent(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.RUN, {
+      "arelis.run.id": runId,
+      "arelis.agent.id": input.agent.getConfig().agentId,
+      ...this.telemetry.contextAttributes(context)
+    });
+    try {
+      let adjustedLimits = input.limits;
+      let quotaEffect;
+      if (this.quotaManager) {
+        const key = this.toQuotaKey(context);
+        const proposed = {
+          agentSteps: input.limits?.maxSteps ?? input.agent.getConfig().limits.maxSteps,
+          wallTimeMs: input.limits?.maxTimeMs ?? input.agent.getConfig().limits.maxTimeMs
+        };
+        const decision = await this.quotaManager.check(key, proposed);
+        quotaEffect = decision.effect;
+        await this.auditSink.write(governanceAudit.createQuotaCheckedEvent({ runId, context, key }));
+        if (decision.effect === "limit") {
+          await this.auditSink.write(
+            governanceAudit.createQuotaLimitedEvent({ runId, context, key, reason: decision.reason })
+          );
+          adjustedLimits = {
+            ...adjustedLimits,
+            maxSteps: decision.applied.agentSteps ?? adjustedLimits?.maxSteps,
+            maxTimeMs: decision.applied.wallTimeMs ?? adjustedLimits?.maxTimeMs
+          };
+        }
+        if (decision.effect === "block") {
+          await this.auditSink.write(
+            governanceAudit.createQuotaExceededEvent({ runId, context, key, reason: decision.reason })
+          );
+          throw new governanceCore.PolicyBlockedError({
+            runId,
+            context,
+            reason: decision.reason,
+            policyCode: decision.code
+          });
+        }
+      }
+      await this.auditSink.write(
+        governanceAudit.createRunStartedEvent({
+          runId,
+          context,
+          operation: "agents.run"
+        })
+      );
+      await this.captureSnapshot({
+        runId,
+        context
+      });
+      await this.enforceRuntimeRiskRoute({
+        runId,
+        context,
+        operation: "agents.run",
+        policyDecisions: [],
+        quotaEffect
+      });
+      const runtimeAgent = input.agent;
+      const runtimeCanSelfGovern = typeof runtimeAgent.configureRuntimeGovernance === "function";
+      if (runtimeCanSelfGovern) {
+        runtimeAgent.configureRuntimeGovernance?.({
+          policyEngine: this.policyEngine,
+          auditSink: this.auditSink,
+          compiledPolicy: this.compiledPolicy ? {
+            snapshotHash: this.compiledPolicy.snapshot.hash,
+            compilerId: this.compiledPolicy.engineId,
+            constraints: this.compiledPolicy.constraints,
+            disclosureRules: this.compiledPolicy.disclosureRules,
+            policyVersion: this.compiledPolicy.policyVersion
+          } : void 0
+        });
+      }
+      const result = await runtimeAgent.run({
+        input: input.input,
+        runId,
+        limits: adjustedLimits,
+        onStep: runtimeCanSelfGovern ? void 0 : async (step) => {
+          const toolCalls = step.execution?.toolName && step.execution.toolName.length > 0 ? [
+            {
+              toolName: step.execution.toolName,
+              argsRef: step.execution.toolInput ? governanceAudit.createHashRef(JSON.stringify(step.execution.toolInput)) : void 0,
+              resultRef: step.execution.toolOutput !== void 0 ? governanceAudit.createHashRef(JSON.stringify(step.execution.toolOutput)) : void 0,
+              success: !step.execution.error
+            }
+          ] : void 0;
+          await this.auditSink.write(
+            governanceAudit.createAgentStepEvent({
+              runId,
+              context,
+              stepNumber: step.stepNumber,
+              stepType: "plan"
+            })
+          );
+          await this.auditSink.write(
+            governanceAudit.createAgentStepEvent({
+              runId,
+              context,
+              stepNumber: step.stepNumber,
+              stepType: "execute",
+              toolCalls
+            })
+          );
+          await this.auditSink.write(
+            governanceAudit.createAgentStepEvent({
+              runId,
+              context,
+              stepNumber: step.stepNumber,
+              stepType: "observe"
+            })
+          );
+        }
+      });
+      if (result.status === "completed" && result.output !== null) {
+        const outputContent = typeof result.output === "string" ? result.output : JSON.stringify(result.output);
+        await this.evaluateOutput(runId, context, outputContent, void 0, "agent");
+      }
+      if (this.quotaManager) {
+        const key = this.toQuotaKey(context);
+        await this.quotaManager.commit(key, {
+          agentSteps: result.totalSteps,
+          wallTimeMs: result.totalDurationMs
+        });
+        await this.auditSink.write(governanceAudit.createQuotaCommittedEvent({ runId, context, key }));
+      }
+      await this.auditSink.write(
+        governanceAudit.createRunEndedEvent({
+          runId,
+          context,
+          success: result.status === "completed",
+          durationMs: result.totalDurationMs
+        })
+      );
+      span.setStatus(result.status === "completed" ? "ok" : "error", result.error);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordError(error instanceof Error ? error : new Error(String(error)));
+      span.setStatus("error", error instanceof Error ? error.message : "Unknown error");
+      span.end();
+      throw error;
+    }
+  }
+  /**
+   * Evaluate a policy checkpoint
+   */
+  async evaluatePolicy(checkpoint, runId, context, data) {
+    const compiled = this.compiledPolicy ? {
+      compilerId: this.compiledPolicy.engineId,
+      snapshotHash: this.compiledPolicy.snapshot.hash,
+      constraints: this.compiledPolicy.constraints,
+      disclosureRules: this.compiledPolicy.disclosureRules
+    } : void 0;
+    const input = {
+      checkpoint,
+      context,
+      runId,
+      compiled,
+      data
+    };
+    if (compiled && this.policyEngine.evaluateCompiled) {
+      return this.policyEngine.evaluateCompiled(input);
+    }
+    return this.policyEngine.evaluate(input);
+  }
+  resolveRuntimeRiskRoute(input) {
+    return governancePolicy.resolveRiskRoute(
+      {
+        operation: input.operation,
+        context: input.context,
+        policyDecisions: input.policyDecisions,
+        quotaEffect: input.quotaEffect,
+        evaluationEffect: input.evaluationEffect,
+        explicitSignals: input.explicitSignals
+      },
+      this.riskRouterConfig
+    );
+  }
+  async enforceRuntimeRiskRoute(input) {
+    const decision = this.resolveRuntimeRiskRoute({
+      operation: input.operation,
+      context: input.context,
+      policyDecisions: input.policyDecisions,
+      quotaEffect: input.quotaEffect,
+      evaluationEffect: input.evaluationEffect,
+      explicitSignals: input.explicitSignals
+    });
+    await this.auditSink.write(
+      governanceAudit.createRiskRouteDecidedEvent({
+        runId: input.runId,
+        context: input.context,
+        route: decision.action,
+        score: decision.score,
+        factors: decision.factors,
+        deterministicInputsHash: decision.deterministicInputsHash
+      })
+    );
+    if (decision.action === "block") {
+      throw new governanceCore.PolicyBlockedError({
+        runId: input.runId,
+        context: input.context,
+        reason: "Risk router blocked execution",
+        policyCode: "RISK_ROUTE_BLOCKED"
+      });
+    }
+    if (decision.action === "require_approval") {
+      throw await this.createPolicyError(
+        {
+          decisions: [
+            {
+              effect: "require_approval",
+              approvers: [input.context.actor.id],
+              reason: "Risk router requires approval"
+            }
+          ],
+          summary: {
+            allowed: false,
+            blockReason: "Risk router requires approval",
+            approvers: [input.context.actor.id]
+          }
+        },
+        input.runId,
+        input.context
+      );
+    }
+    return decision.action === "sandbox" ? "sandbox" : void 0;
+  }
+  computeDeterministicHash(value) {
+    return governanceAudit.hashObject(value);
+  }
+  async captureSnapshot(input) {
+    const toolRegistryHash = this.toolRegistry ? this.computeDeterministicHash(
+      this.toolRegistry.list().map((tool) => tool.name).sort()
+    ) : void 0;
+    const configStateHash = this.computeDeterministicHash({
+      extensions: this.extensions,
+      policyCompilerId: this.compiledPolicy?.engineId,
+      policyVersion: this.compiledPolicy?.policyVersion
+    });
+    const snapshot = {
+      schema: "arelis.audit.snapshot.bundle.v1",
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      policySnapshotHash: this.compiledPolicy?.snapshot.hash,
+      modelRouteId: input.modelRouteId,
+      toolRegistryHash,
+      configStateHash
+    };
+    const snapshotHash = this.computeDeterministicHash(snapshot);
+    this.runSnapshots.set(input.runId, snapshot);
+    await this.auditSink.write(
+      governanceAudit.createSnapshotCapturedEvent({
+        runId: input.runId,
+        context: input.context,
+        snapshotSchema: snapshot.schema,
+        snapshotHash,
+        policySnapshotHash: snapshot.policySnapshotHash,
+        modelRouteId: snapshot.modelRouteId,
+        toolRegistryHash: snapshot.toolRegistryHash,
+        configStateHash: snapshot.configStateHash
+      })
+    );
+    return snapshot;
+  }
+  getPolicyAuditMetadata() {
+    return {
+      policySnapshotHash: this.compiledPolicy?.snapshot.hash,
+      policyCompilerId: this.compiledPolicy?.engineId
+    };
+  }
+  createPolicyEvaluatedEventWithMetadata(options) {
+    const event = governanceAudit.createPolicyEvaluatedEvent(options);
+    const metadata = this.getPolicyAuditMetadata();
+    if (metadata.policySnapshotHash) {
+      event.policySnapshotHash = metadata.policySnapshotHash;
+    }
+    if (metadata.policyCompilerId) {
+      event.policyCompilerId = metadata.policyCompilerId;
+    }
+    return event;
+  }
+  extractAuditContextFromGraph(graph) {
+    for (const node of graph.nodes) {
+      if (node.kind === "event" && node.event) {
+        return node.event.context;
+      }
+    }
+    return void 0;
+  }
+  extractPolicySnapshotHashFromGraph(graph) {
+    for (const node of graph.nodes) {
+      if (node.kind === "event" && node.event && node.event.type === "policy.evaluated" && node.event.policySnapshotHash) {
+        return node.event.policySnapshotHash;
+      }
+    }
+    return void 0;
+  }
+  isComposedProofCapabilityEnabled() {
+    return this.extensions?.capabilities?.["multiLayerComposedComplianceProofs"]?.enabled === true || this.extensions?.composedProofs?.profile === "hash_and_zk";
+  }
+  buildComposedProofLayers(graph) {
+    const eventNodes = graph.nodes.filter((node) => node.kind === "event" && node.eventType);
+    const idsByPrefix = (prefixes) => eventNodes.filter((node) => prefixes.some((prefix) => node.eventType?.startsWith(prefix))).map((node) => node.id);
+    return [
+      {
+        layer: "infra",
+        payload: idsByPrefix(["infra.", "resource."])
+      },
+      {
+        layer: "config",
+        payload: idsByPrefix(["config.change."])
+      },
+      {
+        layer: "auth",
+        payload: idsByPrefix(["auth."])
+      },
+      {
+        layer: "inference",
+        payload: idsByPrefix(["model.", "output.validation."])
+      },
+      {
+        layer: "agent",
+        payload: idsByPrefix(["agent."])
+      },
+      {
+        layer: "tools",
+        payload: idsByPrefix(["tool.", "mcp.tools."])
+      }
+    ];
+  }
+  async requestComplianceArtifact(input) {
+    if (!this.complianceGraphStore) {
+      throw new Error("Compliance graph store not configured");
+    }
+    const graph = await this.complianceGraphStore.get(input.runId);
+    if (!graph) {
+      throw new Error(`No causal graph found for run ${input.runId}`);
+    }
+    const disclosureRules = resolveDisclosureRules(
+      input.disclosureRules ?? this.complianceDisclosureRules ?? [],
+      input.disclosureRuleIds
+    );
+    const usingDerivedDisclosure = !input.disclosureRules && this.compiledPolicy?.disclosureDerivation?.strategy === "policy-derived";
+    const policySnapshotHash = this.extractPolicySnapshotHashFromGraph(graph) ?? this.compiledPolicy?.snapshot.hash;
+    const commitment = createCausalGraphCommitment(graph, this.complianceSigner);
+    const composedEnabled = input.composed !== void 0 || this.isComposedProofCapabilityEnabled();
+    const composedInput = composedEnabled ? {
+      layers: this.buildComposedProofLayers(graph),
+      includeNarrowingProof: input.composed?.includeNarrowingProof ?? true,
+      includeLineageProof: input.composed?.includeLineageProof ?? true,
+      enableZk: input.composed?.enableZk ?? this.extensions?.composedProofs?.enableZkMode ?? false
+    } : void 0;
+    const proofInput = {
+      graph,
+      commitment,
+      disclosureRules,
+      policySnapshotHash,
+      composed: composedInput
+    };
+    const provider = this.complianceProofProvider ?? new HashProofProvider();
+    const cacheKey = `${input.runId}:${disclosureRules.map((rule) => rule.id).sort().join("|")}:${composedEnabled ? "composed" : "legacy"}`;
+    if (input.async && this.complianceProofJobQueue) {
+      return this.complianceProofJobQueue.submit(proofInput, provider);
+    }
+    let proof = this.complianceProofCache.get(cacheKey);
+    if (!proof) {
+      const proofPromise = provider.createProof(proofInput);
+      if (this.complianceProofTimeoutMs && this.complianceProofTimeoutMs > 0) {
+        proof = await Promise.race([
+          proofPromise,
+          new Promise((_, reject) => {
+            setTimeout(() => {
+              reject(new Error("Compliance proof generation timed out"));
+            }, this.complianceProofTimeoutMs);
+          })
+        ]);
+      } else {
+        proof = await proofPromise;
+      }
+      this.complianceProofCache.set(cacheKey, proof);
+    }
+    if (usingDerivedDisclosure) {
+      const eventContext = this.extractAuditContextFromGraph(graph);
+      const derivation = this.compiledPolicy?.disclosureDerivation;
+      if (eventContext && derivation) {
+        await this.auditSink.write(
+          governanceAudit.createDisclosureDerivedGeneratedEvent({
+            runId: input.runId,
+            context: eventContext,
+            policySnapshotHash,
+            derivedRuleSetId: derivation.ruleSetId,
+            derivedRuleCount: disclosureRules.length,
+            derivationHash: derivation.ruleSetHash
+          })
+        );
+      }
+    }
+    this.telemetry.addEvent(governanceTelemetryOtel.EventNames.COMPLIANCE_PROOF_GENERATED, {
+      "arelis.run.id": input.runId,
+      "arelis.compliance.rules": disclosureRules.length
+    });
+    const artifact = {
+      id: `artifact_${input.runId}_${Date.now()}`,
+      runId: input.runId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      artifactSchema: proof.schemaVersion === governanceAudit.COMPLIANCE_PROOF_SCHEMA_V2 ? governanceAudit.COMPLIANCE_ARTIFACT_SCHEMA_V2 : governanceAudit.COMPLIANCE_ARTIFACT_SCHEMA_V1,
+      context: this.extractAuditContextFromGraph(graph),
+      policySnapshotHash,
+      commitment,
+      proof,
+      disclosureRuleIds: disclosureRules.map((rule) => rule.id)
+    };
+    if (this.complianceArtifactStore) {
+      await this.complianceArtifactStore.save(artifact);
+    }
+    if (proof.schemaVersion === governanceAudit.COMPLIANCE_PROOF_SCHEMA_V2 && artifact.context) {
+      await this.auditSink.write(
+        governanceAudit.createComplianceProofComposedEvent({
+          runId: artifact.runId,
+          context: artifact.context,
+          artifactId: artifact.id,
+          artifactSchema: governanceAudit.COMPLIANCE_ARTIFACT_SCHEMA_V2,
+          layerCount: proof.layers?.length ?? 0,
+          layerKinds: proof.layers?.map((layer) => layer.layer) ?? [],
+          includesNarrowingProof: proof.narrowingProof !== void 0,
+          includesLineageProof: proof.lineageProof !== void 0
+        })
+      );
+    }
+    return artifact;
+  }
+  async verifyComplianceArtifact(input) {
+    const provider = this.complianceProofProvider ?? new HashProofProvider();
+    const disclosureRules = input.disclosureRules ?? this.complianceDisclosureRules ?? [];
+    const expectComposed = input.expectComposed === true || input.artifact.artifactSchema === governanceAudit.COMPLIANCE_ARTIFACT_SCHEMA_V2 || input.artifact.proof.schemaVersion === governanceAudit.COMPLIANCE_PROOF_SCHEMA_V2;
+    const result = await provider.verifyProof({
+      commitment: input.artifact.commitment,
+      proof: input.artifact.proof,
+      disclosureRules,
+      policySnapshotHash: input.policySnapshotHash ?? input.artifact.policySnapshotHash,
+      expectComposed
+    });
+    if (result.valid && this.compiledPolicy?.disclosureDerivation?.strategy === "policy-derived" && !input.disclosureRules) {
+      const expectedRuleIds = [...this.compiledPolicy.disclosureRules.map((rule) => rule.id)].sort();
+      const artifactRuleIds = [...input.artifact.disclosureRuleIds ?? []].sort();
+      if (JSON.stringify(expectedRuleIds) !== JSON.stringify(artifactRuleIds)) {
+        return {
+          valid: false,
+          reason: "Derived disclosure scope does not match policy-derived rule set",
+          reasonCode: "derived.scope_mismatch",
+          reasonCodes: ["derived.scope_mismatch"]
+        };
+      }
+      if (input.artifact.policySnapshotHash && input.artifact.policySnapshotHash !== this.compiledPolicy.snapshot.hash) {
+        return {
+          valid: false,
+          reason: "Policy snapshot hash does not match derived disclosure proof scope",
+          reasonCode: "derived.snapshot_mismatch",
+          reasonCodes: ["derived.snapshot_mismatch"]
+        };
+      }
+    }
+    this.telemetry.addEvent(governanceTelemetryOtel.EventNames.COMPLIANCE_PROOF_VERIFIED, {
+      "arelis.run.id": input.artifact.runId,
+      "arelis.compliance.valid": result.valid
+    });
+    return result;
+  }
+  async replayComplianceRun(input) {
+    if (!this.complianceGraphStore) {
+      throw new Error("Compliance graph store not configured");
+    }
+    const graph = await this.complianceGraphStore.get(input.runId);
+    if (!graph) {
+      throw new Error(`No causal graph found for run ${input.runId}`);
+    }
+    const recordedSnapshot = this.runSnapshots.get(input.runId);
+    const replay = await governanceAudit.replayCausalGraph(graph, void 0, {
+      recordedSnapshot,
+      replaySnapshot: input.replaySnapshot
+    });
+    const driftFields = replay.driftDiagnostics?.filter((entry) => !entry.compatible).map((entry) => entry.field);
+    const replayContext = this.extractAuditContextFromGraph(graph);
+    if (driftFields && driftFields.length > 0 && replayContext) {
+      await this.auditSink.write(
+        governanceAudit.createReplayDriftDetectedEvent({
+          runId: input.runId,
+          context: replayContext,
+          snapshotSchema: recordedSnapshot?.schema ?? "arelis.audit.snapshot.bundle.v1",
+          driftFields,
+          compatible: false
+        })
+      );
+    }
+    return replay;
+  }
+  /**
+   * Create appropriate error from policy result
+   */
+  async createPolicyError(result, runId, context) {
+    if (result.summary.approvers && result.summary.approvers.length > 0) {
+      const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.APPROVAL_REQUEST, {
+        "arelis.run.id": runId,
+        ...this.telemetry.contextAttributes(context)
+      });
+      try {
+        const approval = await this.approvalStore.create({
+          runId,
+          context,
+          operation: "policy",
+          reason: result.summary.blockReason ?? "Approval required",
+          approvers: result.summary.approvers
+        });
+        await this.auditSink.write(
+          governanceAudit.createApprovalRequestedEvent({
+            runId,
+            context,
+            approvalId: approval.id,
+            approvers: approval.approvers,
+            reason: approval.reason
+          })
+        );
+        span.setStatus("ok");
+        return new governanceCore.PolicyApprovalRequiredError({
+          runId,
+          context,
+          reason: result.summary.blockReason ?? "Approval required",
+          approvers: result.summary.approvers,
+          approvalId: approval.id
+        });
+      } catch (error) {
+        span.recordError(error instanceof Error ? error : new Error(String(error)));
+        span.setStatus("error", error instanceof Error ? error.message : "Approval request failed");
+        throw error;
+      } finally {
+        span.end();
+      }
+    }
+    return new governanceCore.PolicyBlockedError({
+      runId,
+      context,
+      reason: result.summary.blockReason ?? "Policy blocked request",
+      policyCode: result.summary.blockCode
+    });
+  }
+  /**
+   * Register an MCP server and discover its tools
+   */
+  async registerMCPServer(input) {
+    const context = await this.contextResolver(input.context);
+    const runId = governanceCore.generateRunId();
+    const policyResult = await this.evaluatePolicy("BeforeOperation", runId, context, {
+      input: {
+        operation: "mcp.register",
+        server: {
+          id: input.server.id,
+          transport: input.server.transport.type,
+          auth: input.server.auth?.type,
+          governance: input.server.governance
+        }
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforeOperation",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    this.mcpRegistry.registerServer(input.server);
+    await this.ensureMCPTransport(input.server, context, runId);
+    await this.auditSink.write(
+      governanceAudit.createMCPServerRegisteredEvent({
+        runId,
+        context,
+        serverId: input.server.id,
+        transport: input.server.transport.type
+      })
+    );
+    await this.auditSink.write(
+      governanceAudit.createResourceCreatedEvent({
+        runId,
+        context,
+        operation: "mcp.register",
+        resource: {
+          type: "mcp.server",
+          id: input.server.id,
+          provider: input.server.transport.type,
+          metadata: {
+            governance: input.server.governance
+          }
+        }
+      })
+    );
+    if (this.toolRegistry) {
+      const discovery = await governanceMcp.discoverTools(
+        this.mcpRegistry,
+        this.toolRegistry,
+        input.server.id,
+        input.discoveryOptions
+      );
+      await this.auditSink.write(
+        governanceAudit.createMCPServerConnectedEvent({
+          runId,
+          context,
+          serverId: input.server.id
+        })
+      );
+      await this.auditSink.write(
+        governanceAudit.createMCPToolsDiscoveredEvent({
+          runId,
+          context,
+          serverId: input.server.id,
+          totalDiscovered: discovery.totalDiscovered,
+          registeredCount: discovery.registeredCount,
+          skippedCount: discovery.skippedCount,
+          toolNames: discovery.tools.map((tool) => tool.originalName)
+        })
+      );
+      return discovery;
+    }
+    const emptyResult = {
+      serverId: input.server.id,
+      totalDiscovered: 0,
+      registeredCount: 0,
+      skippedCount: 0,
+      tools: [],
+      discoveredAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.auditSink.write(
+      governanceAudit.createMCPToolsDiscoveredEvent({
+        runId,
+        context,
+        serverId: input.server.id,
+        totalDiscovered: 0,
+        registeredCount: 0,
+        skippedCount: 0,
+        toolNames: []
+      })
+    );
+    return emptyResult;
+  }
+  /**
+   * Discover tools from an MCP server
+   */
+  async discoverMCPTools(input) {
+    if (!this.toolRegistry) {
+      throw new Error("Tool registry is required for tool discovery");
+    }
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const server = this.mcpRegistry.getServer(input.serverId);
+    if (!server) {
+      throw new Error(`MCP server "${input.serverId}" not found`);
+    }
+    const policyResult = await this.evaluatePolicy("BeforeOperation", runId, context, {
+      input: {
+        operation: "mcp.discover",
+        serverId: input.serverId
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforeOperation",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    await this.ensureMCPTransport(server.descriptor, context, runId);
+    const discovery = await governanceMcp.discoverTools(
+      this.mcpRegistry,
+      this.toolRegistry,
+      input.serverId,
+      input.options
+    );
+    await this.auditSink.write(
+      governanceAudit.createMCPServerConnectedEvent({
+        runId,
+        context,
+        serverId: input.serverId
+      })
+    );
+    await this.auditSink.write(
+      governanceAudit.createMCPToolsDiscoveredEvent({
+        runId,
+        context,
+        serverId: input.serverId,
+        totalDiscovered: discovery.totalDiscovered,
+        registeredCount: discovery.registeredCount,
+        skippedCount: discovery.skippedCount,
+        toolNames: discovery.tools.map((tool) => tool.originalName)
+      })
+    );
+    return discovery;
+  }
+  /**
+   * Register a knowledge base
+   */
+  async registerKB(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const policyResult = await this.evaluatePolicy("BeforeOperation", runId, context, {
+      input: {
+        operation: "knowledge.register",
+        kb: {
+          id: input.kb.id,
+          provider: input.kb.provider,
+          region: input.kb.region,
+          governance: input.kb.governance
+        }
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforeOperation",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    this.kbRegistry.registerKB(input.kb);
+    await this.auditSink.write(
+      governanceAudit.createResourceCreatedEvent({
+        runId,
+        context,
+        operation: "knowledge.register",
+        resource: {
+          type: "knowledge.base",
+          id: input.kb.id,
+          provider: input.kb.provider,
+          region: input.kb.region,
+          metadata: {
+            governance: input.kb.governance
+          }
+        }
+      })
+    );
+  }
+  async registerPromptTemplate(input, contextInput) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(contextInput);
+    const policyResult = await this.evaluatePolicy("BeforeOperation", runId, context, {
+      input: {
+        operation: "prompts.register",
+        template: {
+          id: input.id,
+          version: input.version,
+          metadata: input.metadata
+        }
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforeOperation",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    const template = this.promptRegistry.register(input);
+    await this.auditSink.write(
+      governanceAudit.createResourceCreatedEvent({
+        runId,
+        context,
+        operation: "prompts.register",
+        resource: {
+          type: "prompt.template",
+          id: template.id,
+          name: template.version,
+          metadata: {
+            hash: template.hash,
+            tags: template.metadata?.tags
+          }
+        }
+      })
+    );
+    return template;
+  }
+  async registerDataSource(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const policyResult = await this.evaluatePolicy("BeforeOperation", runId, context, {
+      input: {
+        operation: "dataSources.register",
+        source: {
+          id: input.descriptor.id,
+          provider: input.descriptor.provider,
+          region: input.descriptor.region,
+          governance: input.descriptor.governance,
+          access: input.descriptor.access
+        }
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforeOperation",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    this.dataSourceRegistry.register(input.descriptor, input.provider);
+    await this.auditSink.write(
+      governanceAudit.createResourceCreatedEvent({
+        runId,
+        context,
+        operation: "dataSources.register",
+        resource: {
+          type: "data.source",
+          id: input.descriptor.id,
+          provider: input.descriptor.provider,
+          region: input.descriptor.region,
+          metadata: {
+            governance: input.descriptor.governance
+          }
+        }
+      })
+    );
+  }
+  /**
+   * Retrieve chunks from a knowledge base
+   */
+  async retrieve(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const registeredKB = this.kbRegistry.getKB(input.kbId);
+    if (!registeredKB) {
+      throw new Error(`Knowledge base not found: ${input.kbId}`);
+    }
+    await this.auditSink.write(
+      governanceAudit.createKBQueryEvent({
+        runId,
+        context,
+        kb: { id: input.kbId, provider: registeredKB.descriptor.provider },
+        queryId: runId,
+        topK: input.query.topK
+      })
+    );
+    const retriever = governanceKnowledge.createKBRetriever(this.kbRegistry);
+    const kbContext = { runId, governance: context };
+    const result = await retriever.retrieve(input.query, kbContext, input.options);
+    await this.auditSink.write(
+      governanceAudit.createKBResultsEvent({
+        runId,
+        context,
+        kb: { id: input.kbId, provider: registeredKB.descriptor.provider },
+        queryId: result.queryId,
+        chunkCount: result.chunks.length,
+        totalFound: result.totalFound
+      })
+    );
+    return result;
+  }
+  /**
+   * Apply grounding to a model request (internal helper)
+   */
+  async applyGrounding(grounding, request, runId, context) {
+    const groundingHelper = governanceKnowledge.createGroundingHelper();
+    const queryText = grounding.query ?? this.extractLastUserMessage(request) ?? "No query provided";
+    const retriever = governanceKnowledge.createKBRetriever(this.kbRegistry);
+    const kbContext = { runId, governance: context };
+    const retrievalResults = [];
+    const kbInfos = [];
+    const queryIds = [];
+    for (const kbId of grounding.kbIds) {
+      const registeredKB = this.kbRegistry.getKB(kbId);
+      if (!registeredKB) {
+        continue;
+      }
+      kbInfos.push({ id: kbId, provider: registeredKB.descriptor.provider });
+      await this.auditSink.write(
+        governanceAudit.createKBQueryEvent({
+          runId,
+          context,
+          kb: { id: kbId, provider: registeredKB.descriptor.provider },
+          queryId: `${runId}-${kbId}`,
+          topK: grounding.topK
+        })
+      );
+      const result = await retriever.retrieve(
+        { query: queryText, kb: kbId, topK: grounding.topK },
+        kbContext
+      );
+      queryIds.push(result.queryId);
+      retrievalResults.push(result);
+      await this.auditSink.write(
+        governanceAudit.createKBResultsEvent({
+          runId,
+          context,
+          kb: { id: kbId, provider: registeredKB.descriptor.provider },
+          queryId: result.queryId,
+          chunkCount: result.chunks.length,
+          totalFound: result.totalFound
+        })
+      );
+    }
+    const mergedResults = governanceKnowledge.mergeRetrievalResults(retrievalResults);
+    const queryIdByKbId = new Map(retrievalResults.map((result) => [result.kbId, result.queryId]));
+    const kbInfoById = new Map(kbInfos.map((info) => [info.id, info]));
+    const policyFilteredChunks = [];
+    const allowedChunks = [];
+    let policyFilteredCount = 0;
+    for (const chunk of mergedResults.chunks) {
+      const policyResult = await this.evaluatePolicy("BeforePrompt", runId, context, {
+        input: {
+          kbId: chunk.source.kbId,
+          text: chunk.text,
+          metadata: chunk.metadata,
+          source: chunk.source,
+          score: chunk.score
+        }
+      });
+      await this.auditSink.write(
+        this.createPolicyEvaluatedEventWithMetadata({
+          runId,
+          context,
+          checkpoint: "BeforePrompt",
+          decisions: toAuditDecisions(policyResult.decisions),
+          allowed: policyResult.summary.allowed,
+          policyVersion: policyResult.policyVersion
+        })
+      );
+      if (!policyResult.summary.allowed) {
+        policyFilteredCount += 1;
+        const reason = policyResult.summary.blockReason ?? "Filtered by policy";
+        policyFilteredChunks.push({ chunk, reason });
+        const kbInfo = kbInfoById.get(chunk.source.kbId);
+        const policyDecision = toAuditDecisions(policyResult.decisions).find(
+          (decision) => decision.effect !== "allow"
+        );
+        await this.auditSink.write(
+          governanceAudit.createKBChunkFilteredEvent({
+            runId,
+            context,
+            kb: { id: chunk.source.kbId, provider: kbInfo?.provider },
+            queryId: queryIdByKbId.get(chunk.source.kbId) ?? mergedResults.queryId,
+            chunkRef: governanceAudit.createHashRef(chunk.text),
+            reason,
+            policy: policyDecision
+          })
+        );
+        continue;
+      }
+      const patches = policyResult.decisions.flatMap(
+        (decision) => decision.effect === "transform" ? decision.patches : []
+      );
+      if (patches.length > 0) {
+        const transformed = governancePolicy.applyPatches(
+          {
+            text: chunk.text,
+            metadata: chunk.metadata,
+            source: chunk.source,
+            score: chunk.score
+          },
+          patches
+        );
+        allowedChunks.push({
+          ...chunk,
+          text: typeof transformed.text === "string" ? transformed.text : chunk.text,
+          metadata: transformed.metadata && typeof transformed.metadata === "object" ? transformed.metadata : chunk.metadata,
+          source: transformed.source && typeof transformed.source === "object" ? transformed.source : chunk.source,
+          score: typeof transformed.score === "number" ? transformed.score : chunk.score
+        });
+      } else {
+        allowedChunks.push(chunk);
+      }
+    }
+    const policyFilteredResults = {
+      ...mergedResults,
+      chunks: allowedChunks,
+      filteredCount: (mergedResults.filteredCount ?? 0) + policyFilteredCount
+    };
+    const groundingResult = groundingHelper.applyGrounding(
+      policyFilteredResults,
+      kbContext,
+      grounding.options
+    );
+    if (policyFilteredChunks.length > 0) {
+      groundingResult.filteredChunks.unshift(...policyFilteredChunks);
+    }
+    await this.auditSink.write(
+      governanceAudit.createKBGroundingAppliedEvent({
+        runId,
+        context,
+        kbs: kbInfos,
+        queryIds,
+        chunksUsed: groundingResult.usedChunks.length,
+        chunksFiltered: groundingResult.filteredChunks.length
+      })
+    );
+    const augmentedRequest = this.augmentRequestWithGrounding(request, groundingResult);
+    return {
+      request: augmentedRequest,
+      result: groundingResult
+    };
+  }
+  /**
+   * Augment a model request with grounding context
+   */
+  augmentRequestWithGrounding(request, groundingResult) {
+    if (!groundingResult.augmentedPrompt || groundingResult.usedChunks.length === 0) {
+      return request;
+    }
+    const groundingMessage = {
+      role: "system",
+      content: groundingResult.augmentedPrompt
+    };
+    return {
+      ...request,
+      messages: [groundingMessage, ...request.messages]
+    };
+  }
+  /**
+   * Extract the last user message from a request
+   */
+  extractLastUserMessage(request) {
+    const messages = request.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg && msg.role === "user") {
+        return typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      }
+    }
+    return void 0;
+  }
+  resolvePromptTemplate(input) {
+    if (!input) {
+      return void 0;
+    }
+    if ("content" in input && "hash" in input) {
+      return input;
+    }
+    const query = {
+      id: input.id,
+      version: input.version
+    };
+    const template = this.promptRegistry.get(query);
+    if (!template) {
+      throw new Error(`Prompt template not found: ${input.id}`);
+    }
+    return template;
+  }
+  applyPromptTemplate(template, request) {
+    const systemMessage = {
+      role: "system",
+      content: template.content
+    };
+    return {
+      ...request,
+      systemPrompt: request.systemPrompt ?? template.content,
+      messages: [systemMessage, ...request.messages]
+    };
+  }
+  async emitModelResolutionEvents(runId, context, resolved) {
+    const descriptor = resolved.descriptor;
+    if (descriptor.lifecycleState === "disabled") {
+      await this.auditSink.write(
+        governanceAudit.createModelDisabledBlockedEvent({
+          runId,
+          context,
+          model: {
+            id: descriptor.id,
+            provider: descriptor.providerId,
+            version: descriptor.version
+          },
+          reason: "Model disabled"
+        })
+      );
+      throw new Error(`Model "${descriptor.id}" is disabled`);
+    }
+    await this.auditSink.write(
+      governanceAudit.createModelResolvedEvent({
+        runId,
+        context,
+        routeId: resolved.routeId,
+        model: {
+          id: descriptor.id,
+          provider: descriptor.providerId,
+          version: descriptor.version,
+          lifecycleState: descriptor.lifecycleState
+        },
+        fallbackUsed: resolved.fallbackUsed
+      })
+    );
+    if (resolved.fallbackUsed) {
+      await this.auditSink.write(
+        governanceAudit.createModelFallbackUsedEvent({
+          runId,
+          context,
+          routeId: resolved.routeId,
+          model: {
+            id: descriptor.id,
+            provider: descriptor.providerId,
+            version: descriptor.version
+          },
+          reason: "Fallback candidate selected"
+        })
+      );
+    }
+    if (descriptor.lifecycleState === "deprecated") {
+      await this.auditSink.write(
+        governanceAudit.createModelDeprecatedUsedEvent({
+          runId,
+          context,
+          model: {
+            id: descriptor.id,
+            provider: descriptor.providerId,
+            version: descriptor.version
+          },
+          reason: "Deprecated model used"
+        })
+      );
+    }
+  }
+  toQuotaKey(context) {
+    return {
+      orgId: context.org.id,
+      teamId: context.team?.id,
+      actorId: context.actor.id,
+      purpose: context.purpose,
+      environment: context.environment
+    };
+  }
+  async preflightQuota(runId, context, provider, request, options) {
+    if (!this.quotaManager) {
+      return void 0;
+    }
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.QUOTA_CHECK, {
+      "arelis.run.id": runId,
+      "arelis.model.id": request.model,
+      ...this.telemetry.contextAttributes(context)
+    });
+    const key = this.toQuotaKey(context);
+    const proposed = {};
+    if (governanceModels.supportsTokenEstimation(provider)) {
+      proposed.tokensIn = await provider.estimateTokens(request);
+    }
+    if (options?.maxTokens) {
+      proposed.tokensOut = options.maxTokens;
+    }
+    try {
+      const decision = await this.quotaManager.check(key, proposed);
+      await this.auditSink.write(governanceAudit.createQuotaCheckedEvent({ runId, context, key }));
+      if (decision.effect === "limit") {
+        await this.auditSink.write(
+          governanceAudit.createQuotaLimitedEvent({ runId, context, key, reason: decision.reason })
+        );
+      }
+      if (decision.effect === "block") {
+        await this.auditSink.write(
+          governanceAudit.createQuotaExceededEvent({ runId, context, key, reason: decision.reason })
+        );
+        throw new governanceCore.PolicyBlockedError({
+          runId,
+          context,
+          reason: decision.reason,
+          policyCode: decision.code
+        });
+      }
+      span.setStatus("ok");
+      return decision;
+    } catch (error) {
+      span.recordError(error instanceof Error ? error : new Error(String(error)));
+      span.setStatus("error", error instanceof Error ? error.message : "Quota check failed");
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  async commitQuota(runId, context, usage) {
+    if (!this.quotaManager) {
+      return;
+    }
+    const key = this.toQuotaKey(context);
+    await this.quotaManager.commit(key, {
+      tokensIn: usage.inputTokens ?? usage.promptTokens,
+      tokensOut: usage.outputTokens ?? usage.completionTokens,
+      usd: usage.costUsd
+    });
+    await this.auditSink.write(governanceAudit.createQuotaCommittedEvent({ runId, context, key }));
+  }
+  async evaluateOutput(runId, context, outputContent, evaluatorsOverride, surface = "model") {
+    const evaluators = evaluatorsOverride ?? this.evaluators;
+    if (!evaluators || evaluators.length === 0) {
+      return void 0;
+    }
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.EVALUATION_RUN, {
+      "arelis.run.id": runId,
+      "arelis.evaluation.surface": surface,
+      ...this.telemetry.contextAttributes(context)
+    });
+    const evaluationInput = {
+      runId,
+      context,
+      surface,
+      outputRef: governanceAudit.createInlineRef(outputContent)
+    };
+    try {
+      const results = await governanceEvaluations.runEvaluations(evaluators, evaluationInput);
+      for (const result of results.results) {
+        const maxSeverity = result.findings.reduce((acc, finding) => {
+          const order = {
+            info: 0,
+            low: 1,
+            medium: 2,
+            high: 3,
+            critical: 4
+          };
+          const currentRank = order[finding.severity] ?? 0;
+          const accRank = acc ? order[acc] ?? 0 : -1;
+          return currentRank > accRank ? finding.severity : acc;
+        }, void 0);
+        await this.auditSink.write(
+          governanceAudit.createEvaluationRunEvent({
+            runId,
+            context,
+            evaluatorId: result.evaluatorId,
+            version: result.version
+          })
+        );
+        await this.auditSink.write(
+          governanceAudit.createEvaluationResultEvent({
+            runId,
+            context,
+            evaluatorId: result.evaluatorId,
+            version: result.version,
+            effect: result.effect,
+            findingCount: result.findings.length,
+            maxSeverity
+          })
+        );
+        if (result.effect === "warn") {
+          await this.auditSink.write(
+            governanceAudit.createEvaluationWarningEvent({
+              runId,
+              context,
+              evaluatorId: result.evaluatorId,
+              message: "Evaluation produced warnings"
+            })
+          );
+        }
+        if (result.effect === "block") {
+          await this.auditSink.write(
+            governanceAudit.createEvaluationBlockedEvent({
+              runId,
+              context,
+              evaluatorId: result.evaluatorId,
+              reason: "Evaluation blocked"
+            })
+          );
+          throw new governanceCore.EvaluationBlockedError({
+            runId,
+            context,
+            evaluatorId: result.evaluatorId,
+            reason: "Evaluation blocked output"
+          });
+        }
+      }
+      span.setStatus("ok");
+      return results;
+    } catch (error) {
+      span.recordError(error instanceof Error ? error : new Error(String(error)));
+      span.setStatus("error", error instanceof Error ? error.message : "Evaluation failed");
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  async validateOutputSchema(schema, outputContent, mode, runId, context) {
+    if (!schema) {
+      return void 0;
+    }
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.OUTPUT_VALIDATE, {
+      "arelis.run.id": runId,
+      "arelis.schema.type": schema.type,
+      ...this.telemetry.contextAttributes(context)
+    });
+    await this.auditSink.write(
+      governanceAudit.createOutputValidationStartedEvent({
+        runId,
+        context,
+        schemaType: schema.type
+      })
+    );
+    let valid = false;
+    let error;
+    try {
+      let data = outputContent;
+      if (schema.type === "jsonSchema" || schema.type === "zod") {
+        data = typeof outputContent === "string" ? JSON.parse(outputContent) : outputContent;
+      }
+      if (schema.type === "jsonSchema") {
+        error = this.validateJsonSchema(schema.schema, data);
+        valid = !error;
+      } else if (schema.type === "zod") {
+        const result = schema.schema.safeParse(data);
+        valid = result.success;
+        if (!result.success) {
+          error = result.error?.message ?? "Zod validation failed";
+        }
+      }
+    } catch (err) {
+      error = err instanceof Error ? err.message : "Invalid JSON output";
+      valid = false;
+    }
+    if (valid) {
+      await this.auditSink.write(
+        governanceAudit.createOutputValidationPassedEvent({
+          runId,
+          context,
+          schemaType: schema.type
+        })
+      );
+      span.setStatus("ok");
+      span.end();
+      return void 0;
+    }
+    await this.auditSink.write(
+      governanceAudit.createOutputValidationFailedEvent({
+        runId,
+        context,
+        schemaType: schema.type,
+        error: error ?? "Validation failed"
+      })
+    );
+    span.setStatus("error", error ?? "Validation failed");
+    span.end();
+    if (mode === "block") {
+      throw new Error(`Output validation failed: ${error ?? "Invalid output"}`);
+    }
+    return { warning: `Output validation failed: ${error ?? "Invalid output"}` };
+  }
+  validateJsonSchema(schema, data) {
+    const schemaType = schema["type"];
+    if (!schemaType) {
+      return void 0;
+    }
+    if (schemaType === "object") {
+      if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        return "Expected object";
+      }
+      const required = schema["required"] ?? [];
+      for (const key of required) {
+        if (!(key in data)) {
+          return `Missing required property: ${key}`;
+        }
+      }
+      const properties = schema["properties"];
+      if (properties) {
+        for (const [key, propSchema] of Object.entries(properties)) {
+          if (propSchema?.type && key in data) {
+            const value = data[key];
+            if (!this.matchesType(propSchema.type, value)) {
+              return `Invalid type for ${key}`;
+            }
+          }
+        }
+      }
+      return void 0;
+    }
+    if (!this.matchesType(schemaType, data)) {
+      return `Expected ${schemaType}`;
+    }
+    return void 0;
+  }
+  matchesType(type, value) {
+    switch (type) {
+      case "string":
+        return typeof value === "string";
+      case "number":
+        return typeof value === "number";
+      case "boolean":
+        return typeof value === "boolean";
+      case "array":
+        return Array.isArray(value);
+      case "object":
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      default:
+        return true;
+    }
+  }
+  getDefaultMemoryProvider() {
+    const providers = this.memoryRegistry.list();
+    if (providers.length === 0) {
+      throw new Error("No memory providers registered");
+    }
+    return providers[0];
+  }
+  async readMemory(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const provider = input.providerId ? this.memoryRegistry.get(input.providerId) ?? this.getDefaultMemoryProvider() : this.getDefaultMemoryProvider();
+    const policyResult = await this.evaluatePolicy("BeforePrompt", runId, context, {
+      input: {
+        memory: {
+          providerId: provider.id,
+          scope: input.scope,
+          key: input.key
+        }
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforePrompt",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    const entry = await provider.read(input.scope, input.key, { runId, governance: context });
+    await this.auditSink.write(
+      governanceAudit.createMemoryReadEvent({
+        runId,
+        context,
+        memory: { providerId: provider.id, scope: input.scope, key: input.key }
+      })
+    );
+    return entry;
+  }
+  async writeMemory(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const provider = input.providerId ? this.memoryRegistry.get(input.providerId) ?? this.getDefaultMemoryProvider() : this.getDefaultMemoryProvider();
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.MEMORY_WRITE, {
+      "arelis.run.id": runId,
+      "arelis.memory.provider": provider.id,
+      "arelis.memory.scope": input.scope,
+      "arelis.memory.key": input.key,
+      ...this.telemetry.contextAttributes(context)
+    });
+    try {
+      const policyResult = await this.evaluatePolicy("BeforePersist", runId, context, {
+        input: input.value
+      });
+      if (!policyResult.summary.allowed) {
+        throw await this.createPolicyError(policyResult, runId, context);
+      }
+      await this.auditSink.write(
+        this.createPolicyEvaluatedEventWithMetadata({
+          runId,
+          context,
+          checkpoint: "BeforePersist",
+          decisions: toAuditDecisions(policyResult.decisions),
+          allowed: true,
+          policyVersion: policyResult.policyVersion
+        })
+      );
+      const entry = await provider.write(
+        input.scope,
+        input.key,
+        input.value,
+        { runId, governance: context },
+        input.metadata
+      );
+      await this.auditSink.write(
+        governanceAudit.createMemoryWriteEvent({
+          runId,
+          context,
+          memory: { providerId: provider.id, scope: input.scope, key: input.key },
+          valueRef: governanceAudit.createHashRef(JSON.stringify(input.value ?? ""))
+        })
+      );
+      span.setStatus("ok");
+      return entry;
+    } catch (error) {
+      span.recordError(error instanceof Error ? error : new Error(String(error)));
+      span.setStatus("error", error instanceof Error ? error.message : "Memory write failed");
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  async deleteMemory(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const provider = input.providerId ? this.memoryRegistry.get(input.providerId) ?? this.getDefaultMemoryProvider() : this.getDefaultMemoryProvider();
+    const policyResult = await this.evaluatePolicy("BeforePersist", runId, context, {
+      input: {
+        memory: {
+          providerId: provider.id,
+          scope: input.scope,
+          key: input.key
+        }
+      }
+    });
+    await this.auditSink.write(
+      this.createPolicyEvaluatedEventWithMetadata({
+        runId,
+        context,
+        checkpoint: "BeforePersist",
+        decisions: toAuditDecisions(policyResult.decisions),
+        allowed: policyResult.summary.allowed,
+        policyVersion: policyResult.policyVersion
+      })
+    );
+    if (!policyResult.summary.allowed) {
+      throw await this.createPolicyError(policyResult, runId, context);
+    }
+    const result = await provider.delete(input.scope, input.key, { runId, governance: context });
+    await this.auditSink.write(
+      governanceAudit.createMemoryDeleteEvent({
+        runId,
+        context,
+        memory: { providerId: provider.id, scope: input.scope, key: input.key }
+      })
+    );
+    return result;
+  }
+  async readDataSource(input) {
+    const runId = governanceCore.generateRunId();
+    const context = await this.contextResolver(input.context);
+    const entry = this.dataSourceRegistry.get(input.sourceId);
+    if (!entry) {
+      throw new Error(`Data source not found: ${input.sourceId}`);
+    }
+    const span = this.telemetry.startSpan(governanceTelemetryOtel.SpanNames.DATA_READ, {
+      "arelis.run.id": runId,
+      "arelis.data.source": entry.descriptor.id,
+      ...this.telemetry.contextAttributes(context)
+    });
+    try {
+      await this.auditSink.write(
+        governanceAudit.createDataReadEvent({
+          runId,
+          context,
+          source: {
+            id: entry.descriptor.id,
+            provider: entry.descriptor.provider,
+            region: entry.descriptor.region
+          },
+          queryRef: governanceAudit.createHashRef(input.query)
+        })
+      );
+      const policyResult = await this.evaluatePolicy("BeforePrompt", runId, context, {
+        input: input.query
+      });
+      if (!policyResult.summary.allowed) {
+        await this.auditSink.write(
+          governanceAudit.createDataBlockedEvent({
+            runId,
+            context,
+            source: {
+              id: entry.descriptor.id,
+              provider: entry.descriptor.provider,
+              region: entry.descriptor.region
+            },
+            reason: policyResult.summary.blockReason ?? "Data blocked"
+          })
+        );
+        throw await this.createPolicyError(policyResult, runId, context);
+      }
+      await this.auditSink.write(
+        this.createPolicyEvaluatedEventWithMetadata({
+          runId,
+          context,
+          checkpoint: "BeforePrompt",
+          decisions: toAuditDecisions(policyResult.decisions),
+          allowed: true,
+          policyVersion: policyResult.policyVersion
+        })
+      );
+      const transformed = policyResult.decisions.find((d) => d.effect === "transform");
+      if (transformed) {
+        await this.auditSink.write(
+          governanceAudit.createDataFilteredEvent({
+            runId,
+            context,
+            source: {
+              id: entry.descriptor.id,
+              provider: entry.descriptor.provider,
+              region: entry.descriptor.region
+            },
+            reason: transformed.reason ?? "Data filtered by policy"
+          })
+        );
+      }
+      const result = await entry.provider.read(
+        { sourceId: input.sourceId, query: input.query, metadata: input.metadata },
+        { runId, governance: context }
+      );
+      span.setStatus("ok");
+      return result;
+    } catch (error) {
+      span.recordError(error instanceof Error ? error : new Error(String(error)));
+      span.setStatus("error", error instanceof Error ? error.message : "Data read failed");
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  async approveRequest(input) {
+    const context = await this.contextResolver(input.context);
+    await this.approvalStore.approve(input.approvalId, input.resolvedBy, input.reason);
+    await this.auditSink.write(
+      governanceAudit.createApprovalGrantedEvent({
+        runId: governanceCore.generateRunId(),
+        context,
+        approvalId: input.approvalId,
+        resolvedBy: input.resolvedBy,
+        reason: input.reason
+      })
+    );
+  }
+  async rejectRequest(input) {
+    const context = await this.contextResolver(input.context);
+    await this.approvalStore.reject(input.approvalId, input.resolvedBy, input.reason);
+    await this.auditSink.write(
+      governanceAudit.createApprovalRejectedEvent({
+        runId: governanceCore.generateRunId(),
+        context,
+        approvalId: input.approvalId,
+        resolvedBy: input.resolvedBy,
+        reason: input.reason
+      })
+    );
+  }
+  async runEvaluations(input, evaluatorsOverride) {
+    const evaluators = evaluatorsOverride ?? this.evaluators;
+    return governanceEvaluations.runEvaluations(evaluators, input);
+  }
+  async ensureMCPTransport(server, context, runId) {
+    if (this.mcpRegistry.getTransport(server.id)) {
+      return;
+    }
+    if (server.transport.type === "stdio") {
+      const env = { ...server.transport.env ?? {} };
+      if (server.auth && server.auth.type !== "none") {
+        const resolved = await governanceSecrets.resolveSecretValue(this.secretResolver, server.auth.valueRef, {
+          context,
+          runId
+        });
+        env["ARELIS_MCP_AUTH"] = resolved.value;
+        await this.auditSink.write(
+          governanceAudit.createSecretResolvedEvent({
+            runId,
+            context,
+            ref: server.auth.valueRef,
+            resolverId: resolved.resolution.resolverId
+          })
+        );
+      }
+      const transport = governanceMcp.createStdioMCPTransport({
+        ...server.transport,
+        env
+      });
+      this.mcpRegistry.setTransport(server.id, transport);
+      return;
+    }
+    if (server.transport.type === "http") {
+      const headers = { ...server.transport.headers ?? {} };
+      if (server.auth && server.auth.type !== "none") {
+        const resolved = await governanceSecrets.resolveSecretValue(this.secretResolver, server.auth.valueRef, {
+          context,
+          runId
+        });
+        if (server.auth.type === "bearer") {
+          headers["Authorization"] = `Bearer ${resolved.value}`;
+        } else if (server.auth.type === "apiKey") {
+          headers[server.auth.headerName ?? "x-api-key"] = resolved.value;
+        }
+        await this.auditSink.write(
+          governanceAudit.createSecretResolvedEvent({
+            runId,
+            context,
+            ref: server.auth.valueRef,
+            resolverId: resolved.resolution.resolverId
+          })
+        );
+      }
+      const transport = governanceMcp.createHttpMCPTransport({
+        ...server.transport,
+        headers
+      });
+      this.mcpRegistry.setTransport(server.id, transport);
+    }
+  }
+  /**
+   * Merge multiple policy summaries
+   */
+  mergePolicySummaries(summaries) {
+    const merged = {
+      evaluated: 0,
+      allowed: 0,
+      blocked: 0,
+      transformed: 0
+    };
+    const allReasons = [];
+    for (const summary of summaries) {
+      merged.evaluated += summary.evaluated;
+      merged.allowed += summary.allowed;
+      merged.blocked += summary.blocked;
+      merged.transformed += summary.transformed;
+      if (summary.reasons) {
+        allReasons.push(...summary.reasons);
+      }
+    }
+    if (allReasons.length > 0) {
+      merged.reasons = allReasons;
+    }
+    return merged;
+  }
+};
+function createArelisClient(config) {
+  return new ArelisClient(config);
+}
+
+// src/platform/platform-client.ts
+var ArelisApiError = class extends Error {
+  type;
+  title;
+  status;
+  detail;
+  instance;
+  constructor(opts) {
+    super(opts.detail);
+    this.name = "ArelisApiError";
+    this.type = opts.type;
+    this.title = opts.title;
+    this.status = opts.status;
+    this.detail = opts.detail;
+    this.instance = opts.instance;
+  }
+};
+var INITIAL_BACKOFF_MS = 500;
+var MAX_BACKOFF_MS = 3e4;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function isRetryableError(error) {
+  if (error instanceof ArelisApiError) {
+    return RETRYABLE_STATUS_CODES.has(error.status);
+  }
+  return error instanceof TypeError;
+}
+function buildQueryString(params) {
+  const entries = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      entries.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  return entries.length > 0 ? `?${entries.join("&")}` : "";
+}
+var ArelisPlatform = class {
+  baseUrl;
+  apiKey;
+  token;
+  maxRetries;
+  timeout;
+  events;
+  proofs;
+  risk;
+  replay;
+  graphs;
+  governance;
+  apiKeys;
+  usage;
+  jobs;
+  organization;
+  quotas;
+  billing;
+  metering;
+  telemetry;
+  exports;
+  namespaces;
+  approvals;
+  aiSystems;
+  mcpServers;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.token = config.token;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.timeout = config.timeout ?? 3e4;
+    this.events = {
+      create: (event) => this.request("POST", "/api/v1/events", event),
+      createBatch: (input) => this.request("POST", "/api/v1/events/batch", input),
+      list: (params) => {
+        const qs = buildQueryString(params);
+        return this.request("GET", `/api/v1/events${qs}`);
+      },
+      get: (eventId) => this.request("GET", `/api/v1/events/${eventId}`),
+      count: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/events/count${qs}`);
+      }
+    };
+    this.proofs = {
+      create: (req) => this.request("POST", "/api/v1/proofs", req),
+      get: (proofId) => this.request("GET", `/api/v1/proofs/${proofId}`),
+      verify: (input) => this.request("POST", "/api/v1/proofs/verify", input),
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/proofs${qs}`);
+      }
+    };
+    this.risk = {
+      evaluate: (input) => this.request("POST", "/api/v1/risk/evaluate", input),
+      getConfig: () => this.request("GET", "/api/v1/risk/config"),
+      updateConfig: (config2) => this.request("PUT", "/api/v1/risk/config", config2),
+      listDecisions: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/risk/decisions${qs}`);
+      },
+      simulate: (input) => this.request("POST", "/api/v1/risk/simulate", input),
+      getConfigVersions: () => this.request(
+        "GET",
+        "/api/v1/risk/config/versions"
+      ),
+      saveDraft: (input) => this.request("POST", "/api/v1/risk/config/draft", input),
+      clearDraft: () => this.request("DELETE", "/api/v1/risk/config/draft"),
+      publishDraft: (input) => this.request("POST", "/api/v1/risk/config/publish", input),
+      rollbackConfig: (input) => this.request(
+        "POST",
+        "/api/v1/risk/config/rollback",
+        input
+      )
+    };
+    this.replay = {
+      start: (req) => this.request("POST", "/api/v1/replay", req),
+      startCausalGraph: (req) => this.request("POST", "/api/v1/replay/causal-graph", req),
+      get: (replayId) => this.request("GET", `/api/v1/replay/${replayId}`),
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/replay${qs}`);
+      },
+      createTemplate: (input) => this.request("POST", "/api/v1/replay/templates", input),
+      listTemplates: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/replay/templates${qs}`);
+      },
+      getTemplate: (templateId) => this.request("GET", `/api/v1/replay/templates/${templateId}`),
+      updateTemplate: (templateId, input) => this.request("PUT", `/api/v1/replay/templates/${templateId}`, input),
+      deleteTemplate: (templateId) => this.request("DELETE", `/api/v1/replay/templates/${templateId}`),
+      compare: (input) => this.request("POST", "/api/v1/replay/compare", input)
+    };
+    this.graphs = {
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/graphs${qs}`);
+      },
+      get: (runId) => this.request("GET", `/api/v1/graphs/${runId}`),
+      commit: (runId) => this.request("POST", `/api/v1/graphs/${runId}/commit`),
+      lineage: (runId, nodeId) => {
+        const qs = nodeId ? buildQueryString({ nodeId }) : "";
+        return this.request("GET", `/api/v1/graphs/${runId}/lineage${qs}`);
+      }
+    };
+    this.governance = {
+      evaluatePolicy: (input) => this.request("POST", "/api/v1/governance/policy/evaluate", input),
+      listPolicyEvaluations: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/governance/policy/evaluations${qs}`
+        );
+      },
+      getSnapshot: (runId, params) => {
+        const qs = params ? buildQueryString(params) : "";
+        return this.request(
+          "GET",
+          `/api/v1/governance/snapshots/${runId}${qs}`
+        );
+      },
+      policies: {
+        create: (input) => this.request("POST", "/api/v1/governance/policies", input),
+        list: (params) => {
+          const qs = buildQueryString(params ?? {});
+          return this.request("GET", `/api/v1/governance/policies${qs}`);
+        },
+        get: (policyId) => this.request("GET", `/api/v1/governance/policies/${policyId}`),
+        update: (policyId, input) => this.request("PUT", `/api/v1/governance/policies/${policyId}`, input),
+        delete: (policyId) => this.request("DELETE", `/api/v1/governance/policies/${policyId}`),
+        restore: (policyId) => this.request("POST", `/api/v1/governance/policies/${policyId}/restore`),
+        createVersion: (policyId, input) => this.request(
+          "POST",
+          `/api/v1/governance/policies/${policyId}/versions`,
+          input
+        ),
+        listVersions: (policyId) => this.request(
+          "GET",
+          `/api/v1/governance/policies/${policyId}/versions`
+        ),
+        activateVersion: (policyId, input) => this.request(
+          "POST",
+          `/api/v1/governance/policies/${policyId}/activate-version`,
+          input
+        ),
+        transition: (policyId, input) => this.request(
+          "POST",
+          `/api/v1/governance/policies/${policyId}/transition`,
+          input
+        ),
+        rollback: (policyId, input) => this.request(
+          "POST",
+          `/api/v1/governance/policies/${policyId}/rollback`,
+          input
+        ),
+        simulate: (policyId, input) => this.request(
+          "POST",
+          `/api/v1/governance/policies/${policyId}/simulate`,
+          input
+        ),
+        bulkSimulate: (input) => this.request(
+          "POST",
+          "/api/v1/governance/policies/simulate",
+          input
+        ),
+        impact: (policyId, input) => this.request(
+          "POST",
+          `/api/v1/governance/policies/${policyId}/impact`,
+          input
+        )
+      }
+    };
+    this.apiKeys = {
+      create: (input) => this.request("POST", "/api/v1/api-keys", input),
+      list: () => this.request("GET", "/api/v1/api-keys"),
+      update: (keyId, input) => this.request("PUT", `/api/v1/api-keys/${keyId}`, input),
+      revoke: (keyId) => this.request("DELETE", `/api/v1/api-keys/${keyId}`),
+      rotate: (keyId) => this.request("POST", `/api/v1/api-keys/${keyId}/rotate`)
+    };
+    this.usage = {
+      get: () => this.request("GET", "/api/v1/usage"),
+      history: () => this.request("GET", "/api/v1/usage/history")
+    };
+    this.jobs = {
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/jobs${qs}`);
+      },
+      get: (jobId) => this.request("GET", `/api/v1/jobs/${jobId}`),
+      retry: (jobId) => this.request("POST", `/api/v1/jobs/${jobId}/retry`)
+    };
+    this.organization = {
+      get: () => this.request("GET", "/api/v1/organization")
+    };
+    this.quotas = {
+      get: () => this.request("GET", "/api/v1/quotas")
+    };
+    this.billing = {
+      summary: () => this.request("GET", "/api/v1/billing/summary")
+    };
+    this.metering = {
+      getMilestones: () => this.request("GET", "/api/v1/metering/milestones"),
+      updateMilestones: (input) => this.request("PUT", "/api/v1/metering/milestones", input),
+      listMilestoneDeliveries: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/metering/milestones/deliveries${qs}`
+        );
+      }
+    };
+    this.telemetry = {
+      reportUsage: (input) => this.request("POST", "/api/v1/telemetry/usage", input),
+      submitAttestation: (challengeId, input) => this.request("POST", `/api/v1/telemetry/attestations/${challengeId}`, input),
+      listReports: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/telemetry/reports${qs}`);
+      },
+      listChallenges: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/telemetry/challenges${qs}`
+        );
+      }
+    };
+    this.exports = {
+      create: (input) => this.request("POST", "/api/v1/exports", input),
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/exports${qs}`);
+      },
+      get: (exportId) => this.request("GET", `/api/v1/exports/${exportId}`),
+      download: (exportId) => this.downloadExportArtifact(exportId)
+    };
+    this.namespaces = {
+      agents: this.buildNamespaceCrud("/api/v1/namespaces/agents"),
+      approvals: this.buildNamespaceCrud("/api/v1/namespaces/approvals"),
+      complianceConfig: this.buildNamespaceCrud("/api/v1/namespaces/compliance-config"),
+      dataSources: this.buildNamespaceCrud("/api/v1/namespaces/data-sources"),
+      evaluations: this.buildNamespaceCrud("/api/v1/namespaces/evaluations"),
+      governanceConfig: this.buildNamespaceCrud("/api/v1/namespaces/governance-config"),
+      knowledge: this.buildNamespaceCrud("/api/v1/namespaces/knowledge"),
+      mcp: {
+        ...this.buildNamespaceCrud("/api/v1/namespaces/mcp"),
+        evaluateTool: (input) => this.request("POST", "/api/v1/mcp/tools/evaluate", input),
+        governedInvoke: async (input) => {
+          const { invoke, denyMode, ...evalInput } = input;
+          const decision = await this.request(
+            "POST",
+            "/api/v1/mcp/tools/evaluate",
+            evalInput
+          );
+          const isDenied = decision.decision === "deny" || decision.decision === "escalate";
+          if (isDenied) {
+            if (denyMode === "throw") {
+              throw new ArelisApiError({
+                type: "https://arelis.dev/errors/mcp-tool-denied",
+                title: "MCP Tool Call Denied",
+                status: 403,
+                detail: decision.policy.summary.blockReason ?? "MCP tool call blocked by policy"
+              });
+            }
+            return { runId: decision.runId, invoked: false, decision };
+          }
+          const result = await invoke();
+          return { runId: decision.runId, invoked: true, decision, result };
+        }
+      },
+      memory: this.buildNamespaceCrud("/api/v1/namespaces/memory"),
+      prompts: this.buildNamespaceCrud("/api/v1/namespaces/prompts"),
+      quotas: this.buildNamespaceCrud("/api/v1/namespaces/quotas/config"),
+      secrets: this.buildNamespaceCrud("/api/v1/namespaces/secrets"),
+      telemetry: this.buildNamespaceCrud("/api/v1/namespaces/telemetry"),
+      tools: this.buildNamespaceCrud("/api/v1/namespaces/tools")
+    };
+    this.approvals = {
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/namespaces/approvals${qs}`
+        );
+      },
+      resolve: (approvalId, input) => this.request(
+        "POST",
+        `/api/v1/approvals/${approvalId}/resolve`,
+        input
+      ),
+      getConfig: () => this.request(
+        "GET",
+        "/api/v1/namespaces/approvals"
+      ),
+      updateConfig: (input) => this.request(
+        "POST",
+        "/api/v1/namespaces/approvals",
+        input
+      )
+    };
+    this.aiSystems = {
+      register: (input) => this.request("POST", "/api/v1/ai-systems", input),
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/ai-systems${qs}`);
+      },
+      get: (systemId) => this.request("GET", `/api/v1/ai-systems/${systemId}`),
+      update: (systemId, input) => this.request("PUT", `/api/v1/ai-systems/${systemId}`, input),
+      archive: (systemId) => this.request("DELETE", `/api/v1/ai-systems/${systemId}`),
+      setDefault: (systemId) => this.request("POST", `/api/v1/ai-systems/${systemId}/set-default`),
+      summary: (systemId, params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/ai-systems/${systemId}/summary${qs}`
+        );
+      }
+    };
+    this.mcpServers = {
+      create: (input) => this.request("POST", "/api/v1/mcp-servers", input),
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `/api/v1/mcp-servers${qs}`);
+      },
+      get: (serverId) => this.request("GET", `/api/v1/mcp-servers/${serverId}`),
+      update: (serverId, input) => this.request("PUT", `/api/v1/mcp-servers/${serverId}`, input),
+      archive: (serverId) => this.request("DELETE", `/api/v1/mcp-servers/${serverId}`),
+      createTool: (serverId, input) => this.request(
+        "POST",
+        `/api/v1/mcp-servers/${serverId}/tools`,
+        input
+      ),
+      listTools: (serverId, params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/mcp-servers/${serverId}/tools${qs}`
+        );
+      },
+      updateTool: (serverId, toolName, input) => this.request(
+        "PUT",
+        `/api/v1/mcp-servers/${serverId}/tools/${encodeURIComponent(toolName)}`,
+        input
+      ),
+      refreshTools: (serverId) => this.request(
+        "POST",
+        `/api/v1/mcp-servers/${serverId}/refresh-tools`
+      ),
+      healthCheck: (serverId) => this.request(
+        "POST",
+        `/api/v1/mcp-servers/${serverId}/health-check`
+      ),
+      healthHistory: (serverId, params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request(
+          "GET",
+          `/api/v1/mcp-servers/${serverId}/health${qs}`
+        );
+      },
+      linkSystem: (serverId, input) => this.request(
+        "POST",
+        `/api/v1/mcp-servers/${serverId}/link`,
+        input
+      ),
+      unlinkSystem: (serverId, systemId) => this.request(
+        "DELETE",
+        `/api/v1/mcp-servers/${serverId}/link/${systemId}`
+      ),
+      linkedSystems: (serverId) => this.request(
+        "GET",
+        `/api/v1/mcp-servers/${serverId}/systems`
+      )
+    };
+  }
+  // ---------- Core request with retry logic --------------------------------
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, method, body);
+        if (response.ok) {
+          return await response.json();
+        }
+        const errorBody = await this.safeParseJson(response);
+        const apiError = new ArelisApiError({
+          type: (typeof errorBody?.["type"] === "string" ? errorBody["type"] : null) ?? `https://arelis.dev/errors/http-${response.status}`,
+          title: (typeof errorBody?.["title"] === "string" ? errorBody["title"] : null) ?? response.statusText,
+          status: response.status,
+          detail: (typeof errorBody?.["detail"] === "string" ? errorBody["detail"] : null) ?? `Request failed with status ${response.status}`,
+          instance: typeof errorBody?.["instance"] === "string" ? errorBody["instance"] : void 0
+        });
+        if (!RETRYABLE_STATUS_CODES.has(response.status) || attempt === this.maxRetries) {
+          throw apiError;
+        }
+        lastError = apiError;
+        const backoff = this.computeBackoff(attempt, response);
+        await this.sleep(backoff);
+      } catch (error) {
+        if (error instanceof ArelisApiError) {
+          if (!isRetryableError(error) || attempt === this.maxRetries) {
+            throw error;
+          }
+          lastError = error;
+        } else if (isRetryableError(error)) {
+          if (attempt === this.maxRetries) {
+            throw error;
+          }
+          lastError = error;
+        } else {
+          throw error;
+        }
+        const backoff = this.computeBackoff(attempt);
+        await this.sleep(backoff);
+      }
+    }
+    throw lastError;
+  }
+  async fetchWithTimeout(url, method, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const headers = {
+        Accept: "application/json"
+      };
+      if (this.apiKey) {
+        headers["x-api-key"] = this.apiKey;
+      } else if (this.token) {
+        headers["Authorization"] = `Bearer ${this.token}`;
+      }
+      if (body !== void 0) {
+        headers["Content-Type"] = "application/json";
+      }
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async downloadExportArtifact(exportId) {
+    const response = await this.fetchWithTimeout(
+      `${this.baseUrl}/api/v1/exports/${encodeURIComponent(exportId)}/download`,
+      "GET"
+    );
+    if (!response.ok) {
+      const errorBody = await this.safeParseJson(response);
+      throw new ArelisApiError({
+        type: (typeof errorBody?.["type"] === "string" ? errorBody["type"] : null) ?? `https://arelis.dev/errors/http-${response.status}`,
+        title: (typeof errorBody?.["title"] === "string" ? errorBody["title"] : null) ?? response.statusText,
+        status: response.status,
+        detail: (typeof errorBody?.["detail"] === "string" ? errorBody["detail"] : null) ?? `Request failed with status ${response.status}`,
+        instance: typeof errorBody?.["instance"] === "string" ? errorBody["instance"] : void 0
+      });
+    }
+    const content = await response.text();
+    const disposition = response.headers.get("Content-Disposition");
+    const fileNameMatch = disposition?.match(/filename="(.+?)"/);
+    const fileName = fileNameMatch?.[1] ?? `export-${exportId}.dat`;
+    const mimeType = response.headers.get("Content-Type") ?? "application/octet-stream";
+    return {
+      fileName,
+      mimeType,
+      content
+    };
+  }
+  buildNamespaceCrud(routePath) {
+    return {
+      list: (params) => {
+        const qs = buildQueryString(params ?? {});
+        return this.request("GET", `${routePath}${qs}`);
+      },
+      create: (data) => this.request("POST", routePath, data),
+      get: (id) => this.request("GET", `${routePath}/${id}`),
+      update: (id, data) => this.request("PUT", `${routePath}/${id}`, data),
+      archive: (id) => this.request("DELETE", `${routePath}/${id}`)
+    };
+  }
+  computeBackoff(attempt, response) {
+    if (response) {
+      const retryAfter = response.headers.get("Retry-After");
+      if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (!Number.isNaN(seconds)) {
+          return Math.min(seconds * 1e3, MAX_BACKOFF_MS);
+        }
+        const date = new Date(retryAfter);
+        if (!Number.isNaN(date.getTime())) {
+          const delayMs = date.getTime() - Date.now();
+          return Math.min(Math.max(delayMs, 0), MAX_BACKOFF_MS);
+        }
+      }
+    }
+    const base = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+    const jitter = Math.random() * base * 0.5;
+    return Math.min(base + jitter, MAX_BACKOFF_MS);
+  }
+  async safeParseJson(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ---------- SSE stream ----------------------------------------------------
+  /**
+   * Opens an SSE connection to the real-time event stream.
+   * Requires browser `EventSource` API or a polyfill in Node.js
+   * (e.g., the `eventsource` npm package assigned to `globalThis.EventSource`).
+   */
+  stream(options) {
+    const token = this.apiKey ?? this.token ?? "";
+    const url = `${this.baseUrl}/api/v1/stream?token=${encodeURIComponent(token)}`;
+    const ESConstructor = globalThis.EventSource;
+    if (!ESConstructor) {
+      throw new Error(
+        "EventSource is not available. In Node.js, install an EventSource polyfill such as 'eventsource'."
+      );
+    }
+    const eventSource = new ESConstructor(url);
+    const types = options.eventTypes ?? [
+      "event:created",
+      "proof:created",
+      "risk:evaluated",
+      "replay:completed",
+      "policy:updated",
+      "usage:updated",
+      "key:updated"
+    ];
+    for (const type of types) {
+      eventSource.addEventListener(type, (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          options.onEvent(type, data);
+        } catch {
+        }
+      });
+    }
+    return {
+      close() {
+        eventSource.close();
+      }
+    };
+  }
+};
+
+// src/platform/index.ts
+function createArelisPlatform(config) {
+  return new ArelisPlatform(config);
+}
+
+// src/unified.ts
+function createArelis(config) {
+  const runtime = config.runtime ? createArelisClient(config.runtime) : void 0;
+  const platform = config.platform ? createArelisPlatform(config.platform) : void 0;
+  if (!runtime && !platform) {
+    throw new Error("createArelis requires at least one configuration: runtime or platform");
+  }
+  return {
+    runtime,
+    platform
+  };
+}
+
+// src/extension-contracts.ts
+var EXTENSION_NAMESPACE_CONTRACTS = [
+  {
+    id: "foundation.policy_compiled_orchestration_cag_selective_disclosure",
+    capabilityFlag: "foundationPolicyCompiledOrchestrationCagSelectiveDisclosure",
+    configNamespace: "extensions.foundation",
+    apiNamespace: "foundation",
+    eventPrefixes: ["policy.", "model.", "tool.", "orchestration."],
+    checkpointNamespaces: ["BeforeOperation", "BeforePrompt", "AfterModelOutput"],
+    artifactSchemas: ["arelis.audit.compliance.v1"]
+  },
+  {
+    id: "extension.full_lifecycle_governance_audit_trail",
+    capabilityFlag: "fullLifecycleGovernanceAuditTrail",
+    configNamespace: "extensions.fullLifecycleGovernanceAuditTrail",
+    apiNamespace: "extensions.lifecycleAudit",
+    eventPrefixes: ["cli.command.", "infra.", "config.", "auth.", "mcp.server.", "mcp.tools."],
+    checkpointNamespaces: [
+      "BeforeProvision",
+      "BeforeDestroy",
+      "BeforeConfigChange",
+      "BeforeAuth"
+    ],
+    artifactSchemas: ["arelis.audit.lifecycle.v1"]
+  },
+  {
+    id: "extension.agent_operated_governed_self_service",
+    capabilityFlag: "agentOperatedGovernedSelfService",
+    configNamespace: "extensions.agentOperatedGovernedSelfService",
+    apiNamespace: "extensions.agentGovernance",
+    eventPrefixes: ["agent.step.", "agent.attestation.", "memory."],
+    checkpointNamespaces: ["BeforeAgentStep"],
+    artifactSchemas: ["arelis.audit.agent-attestation.v1"]
+  },
+  {
+    id: "extension.multi_layer_composed_compliance_proofs",
+    capabilityFlag: "multiLayerComposedComplianceProofs",
+    configNamespace: "extensions.multiLayerComposedComplianceProofs",
+    apiNamespace: "extensions.composedProofs",
+    eventPrefixes: ["compliance.proof."],
+    checkpointNamespaces: [],
+    artifactSchemas: ["arelis.audit.compliance.composed.v2"]
+  },
+  {
+    id: "extension.risk_adaptive_runtime_routing",
+    capabilityFlag: "riskAdaptiveRuntimeRouting",
+    configNamespace: "extensions.riskAdaptiveRuntimeRouting",
+    apiNamespace: "extensions.riskRouting",
+    eventPrefixes: ["risk.route."],
+    checkpointNamespaces: [],
+    artifactSchemas: ["arelis.audit.risk-routing.v1"]
+  },
+  {
+    id: "extension.time_bound_snapshot_replay",
+    capabilityFlag: "timeBoundSnapshotReplay",
+    configNamespace: "extensions.timeBoundSnapshotReplay",
+    apiNamespace: "extensions.snapshotReplay",
+    eventPrefixes: ["snapshot.", "replay."],
+    checkpointNamespaces: [],
+    artifactSchemas: ["arelis.audit.snapshot.bundle.v1"]
+  },
+  {
+    id: "extension.policy_derived_selective_disclosure",
+    capabilityFlag: "policyDerivedSelectiveDisclosure",
+    configNamespace: "extensions.policyDerivedSelectiveDisclosure",
+    apiNamespace: "extensions.policyDisclosureSynthesis",
+    eventPrefixes: ["disclosure.derived."],
+    checkpointNamespaces: [],
+    artifactSchemas: ["arelis.audit.disclosure.derived.v1"]
+  }
+];
+function extensionContractById(id) {
+  const contract = EXTENSION_NAMESPACE_CONTRACTS.find((entry) => entry.id === id);
+  if (!contract) {
+    throw new Error(`Unknown extension contract: ${id}`);
+  }
+  return contract;
+}
+function detectExtensionContractCollisions(contracts = EXTENSION_NAMESPACE_CONTRACTS) {
+  const collisions = [];
+  const seen = /* @__PURE__ */ new Map();
+  const recordCollision = (type, values, contractId) => {
+    for (const value of values) {
+      const key = `${type}:${value}`;
+      const existing = seen.get(key);
+      if (existing && existing !== contractId) {
+        collisions.push({ type, value, leftId: existing, rightId: contractId });
+        continue;
+      }
+      seen.set(key, contractId);
+    }
+  };
+  for (const contract of contracts) {
+    recordCollision("capabilityFlag", [contract.capabilityFlag], contract.id);
+    recordCollision("configNamespace", [contract.configNamespace], contract.id);
+    recordCollision("apiNamespace", [contract.apiNamespace], contract.id);
+    recordCollision("artifactSchema", contract.artifactSchemas, contract.id);
+    recordCollision("eventPrefix", contract.eventPrefixes, contract.id);
+  }
+  return collisions;
+}
+var GovernanceGateDeniedError = class extends Error {
+  decision;
+  constructor(decision) {
+    super(`Governance gate denied invocation: ${decision.reasons.join("; ") || "Policy denied"}`);
+    this.name = "GovernanceGateDeniedError";
+    this.decision = decision;
+  }
+};
+function createGovernanceGateEvaluator(options) {
+  return {
+    evaluatePolicy: options.evaluatePolicy,
+    resolveContext: options.resolveContext ?? governanceCore.defaultContextResolver,
+    getPolicyMetadata: options.getPolicyMetadata
+  };
+}
+function scanPromptForPii(prompt, options = {}) {
+  const redactor = options.redactor ?? governancePolicy.createRedactor(options.redactorConfig);
+  const redacted = redactor.redact(prompt);
+  return {
+    hasPii: redacted.findings.length > 0,
+    findings: redacted.findings.map((finding) => ({
+      type: finding.type,
+      original: finding.original,
+      start: finding.start,
+      end: finding.end,
+      pattern: finding.pattern
+    }))
+  };
+}
+async function evaluatePreInvocationGate(source, input, options = {}) {
+  const evaluator = resolveEvaluator(source);
+  const pii = scanPromptForPii(input.prompt, options);
+  const runId = input.runId ?? governanceCore.generateRunId();
+  const context = await evaluator.resolveContext({
+    org: input.context?.org ?? { id: "sdk-governance-gate" },
+    team: input.context?.team,
+    actor: input.actor,
+    purpose: input.context?.purpose ?? "pre-invocation-gate",
+    environment: input.context?.environment ?? "dev",
+    sessionId: input.context?.sessionId,
+    requestId: input.context?.requestId,
+    tags: input.context?.tags
+  });
+  const policyResult = await evaluator.evaluatePolicy({
+    checkpoint: "BeforePrompt",
+    runId,
+    context,
+    data: {
+      modelId: input.model,
+      input: [{ role: "user", content: input.prompt }]
+    }
+  });
+  const reasons = collectReasons(policyResult);
+  const codes = collectCodes(policyResult);
+  const metadata = evaluator.getPolicyMetadata?.() ?? {};
+  return {
+    runId,
+    decision: policyResult.summary.allowed ? "allow" : "deny",
+    pii,
+    policy: {
+      allowed: policyResult.summary.allowed,
+      decisions: policyResult.decisions,
+      summary: policyResult.summary,
+      policyVersion: policyResult.policyVersion
+    },
+    metadata: {
+      policyIds: [...input.policyIds ?? []],
+      policyIdsMode: "metadata_only",
+      model: input.model,
+      actor: {
+        id: input.actor.id,
+        type: input.actor.type
+      },
+      policySnapshotHash: metadata.policySnapshotHash,
+      policyCompilerId: metadata.policyCompilerId
+    },
+    reasons,
+    codes
+  };
+}
+async function withGovernanceGate(source, input, invoke, options = {}) {
+  const decision = await evaluatePreInvocationGate(source, input, options);
+  if (decision.decision === "deny") {
+    if (options.denyMode === "return") {
+      return {
+        runId: decision.runId,
+        invoked: false,
+        decision
+      };
+    }
+    throw new GovernanceGateDeniedError(decision);
+  }
+  const result = await invoke();
+  return {
+    runId: decision.runId,
+    invoked: true,
+    decision,
+    result
+  };
+}
+function resolveEvaluator(source) {
+  if ("governance" in source && source.governance?.createGateEvaluator) {
+    return source.governance.createGateEvaluator();
+  }
+  if ("evaluatePolicy" in source && "resolveContext" in source) {
+    return source;
+  }
+  throw new Error(
+    "Unsupported governance gate source: expected ArelisClient.governance.createGateEvaluator() or GovernanceGateEvaluator"
+  );
+}
+function collectReasons(result) {
+  const reasons = /* @__PURE__ */ new Set();
+  for (const decision of result.decisions) {
+    if ((decision.effect === "block" || decision.effect === "transform" || decision.effect === "require_approval") && decision.reason) {
+      reasons.add(decision.reason);
+    }
+  }
+  if (result.summary.blockReason) {
+    reasons.add(result.summary.blockReason);
+  }
+  return [...reasons];
+}
+function collectCodes(result) {
+  const codes = /* @__PURE__ */ new Set();
+  for (const decision of result.decisions) {
+    if (decision.effect === "block" && decision.code) {
+      codes.add(decision.code);
+    }
+  }
+  if (result.summary.blockCode) {
+    codes.add(result.summary.blockCode);
+  }
+  return [...codes];
+}
+async function verifyComplianceArtifact(artifact, options = {}) {
+  const provider = options.provider ?? new governanceAudit.HashProofProvider();
+  return provider.verifyProof({
+    commitment: artifact.commitment,
+    proof: artifact.proof,
+    disclosureRules: options.disclosureRules ?? [],
+    policySnapshotHash: options.policySnapshotHash ?? artifact.policySnapshotHash,
+    expectComposed: artifact.artifactSchema === governanceAudit.COMPLIANCE_ARTIFACT_SCHEMA_V2 || artifact.proof.schemaVersion === governanceAudit.COMPLIANCE_PROOF_SCHEMA_V2
+  });
+}
+
+Object.defineProperty(exports, "EvaluationBlockedError", {
+  enumerable: true,
+  get: function () { return governanceCore.EvaluationBlockedError; }
+});
+Object.defineProperty(exports, "PolicyApprovalRequiredError", {
+  enumerable: true,
+  get: function () { return governanceCore.PolicyApprovalRequiredError; }
+});
+Object.defineProperty(exports, "PolicyBlockedError", {
+  enumerable: true,
+  get: function () { return governanceCore.PolicyBlockedError; }
+});
+Object.defineProperty(exports, "generateRunId", {
+  enumerable: true,
+  get: function () { return governanceCore.generateRunId; }
+});
+Object.defineProperty(exports, "isEvaluationBlockedError", {
+  enumerable: true,
+  get: function () { return governanceCore.isEvaluationBlockedError; }
+});
+Object.defineProperty(exports, "isPolicyApprovalRequiredError", {
+  enumerable: true,
+  get: function () { return governanceCore.isPolicyApprovalRequiredError; }
+});
+Object.defineProperty(exports, "isPolicyBlockedError", {
+  enumerable: true,
+  get: function () { return governanceCore.isPolicyBlockedError; }
+});
+Object.defineProperty(exports, "allowDecision", {
+  enumerable: true,
+  get: function () { return governancePolicy.allowDecision; }
+});
+Object.defineProperty(exports, "blockDecision", {
+  enumerable: true,
+  get: function () { return governancePolicy.blockDecision; }
+});
+Object.defineProperty(exports, "compilePolicy", {
+  enumerable: true,
+  get: function () { return governancePolicy.compilePolicy; }
+});
+Object.defineProperty(exports, "createAllowAllEngine", {
+  enumerable: true,
+  get: function () { return governancePolicy.createAllowAllEngine; }
+});
+Object.defineProperty(exports, "createDenyAllEngine", {
+  enumerable: true,
+  get: function () { return governancePolicy.createDenyAllEngine; }
+});
+Object.defineProperty(exports, "createJsonPolicyCompiler", {
+  enumerable: true,
+  get: function () { return governancePolicy.createJsonPolicyCompiler; }
+});
+Object.defineProperty(exports, "createPolicyEngineFromConfig", {
+  enumerable: true,
+  get: function () { return governancePolicy.createPolicyEngineFromConfig; }
+});
+Object.defineProperty(exports, "createPolicyModeEngine", {
+  enumerable: true,
+  get: function () { return governancePolicy.createPolicyModeEngine; }
+});
+Object.defineProperty(exports, "loadPolicyConfigFile", {
+  enumerable: true,
+  get: function () { return governancePolicy.loadPolicyConfigFile; }
+});
+Object.defineProperty(exports, "loadPolicyEngineFromFile", {
+  enumerable: true,
+  get: function () { return governancePolicy.loadPolicyEngineFromFile; }
+});
+Object.defineProperty(exports, "parsePolicyConfig", {
+  enumerable: true,
+  get: function () { return governancePolicy.parsePolicyConfig; }
+});
+Object.defineProperty(exports, "requireApprovalDecision", {
+  enumerable: true,
+  get: function () { return governancePolicy.requireApprovalDecision; }
+});
+Object.defineProperty(exports, "transformDecision", {
+  enumerable: true,
+  get: function () { return governancePolicy.transformDecision; }
+});
+Object.defineProperty(exports, "HashProofProvider", {
+  enumerable: true,
+  get: function () { return governanceAudit.HashProofProvider; }
+});
+Object.defineProperty(exports, "SnarkjsProofProvider", {
+  enumerable: true,
+  get: function () { return governanceAudit.SnarkjsProofProvider; }
+});
+Object.defineProperty(exports, "assessPolicyRisk", {
+  enumerable: true,
+  get: function () { return governanceAudit.assessPolicyRisk; }
+});
+Object.defineProperty(exports, "createAgentAttestationCreatedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createAgentAttestationCreatedEvent; }
+});
+Object.defineProperty(exports, "createAuthFailedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createAuthFailedEvent; }
+});
+Object.defineProperty(exports, "createAuthStartedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createAuthStartedEvent; }
+});
+Object.defineProperty(exports, "createAuthSucceededEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createAuthSucceededEvent; }
+});
+Object.defineProperty(exports, "createBlobRef", {
+  enumerable: true,
+  get: function () { return governanceAudit.createBlobRef; }
+});
+Object.defineProperty(exports, "createCausalGraphCommitment", {
+  enumerable: true,
+  get: function () { return governanceAudit.createCausalGraphCommitment; }
+});
+Object.defineProperty(exports, "createCliCommandCompletedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createCliCommandCompletedEvent; }
+});
+Object.defineProperty(exports, "createCliCommandFailedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createCliCommandFailedEvent; }
+});
+Object.defineProperty(exports, "createCliCommandStartedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createCliCommandStartedEvent; }
+});
+Object.defineProperty(exports, "createComplianceProofComposedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createComplianceProofComposedEvent; }
+});
+Object.defineProperty(exports, "createCompositeSink", {
+  enumerable: true,
+  get: function () { return governanceAudit.createCompositeSink; }
+});
+Object.defineProperty(exports, "createConfigChangeCompletedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createConfigChangeCompletedEvent; }
+});
+Object.defineProperty(exports, "createConfigChangeFailedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createConfigChangeFailedEvent; }
+});
+Object.defineProperty(exports, "createConfigChangeStartedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createConfigChangeStartedEvent; }
+});
+Object.defineProperty(exports, "createConsoleSink", {
+  enumerable: true,
+  get: function () { return governanceAudit.createConsoleSink; }
+});
+Object.defineProperty(exports, "createDisclosureDerivedGeneratedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createDisclosureDerivedGeneratedEvent; }
+});
+Object.defineProperty(exports, "createHashRef", {
+  enumerable: true,
+  get: function () { return governanceAudit.createHashRef; }
+});
+Object.defineProperty(exports, "createInfraDestroyCompletedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInfraDestroyCompletedEvent; }
+});
+Object.defineProperty(exports, "createInfraDestroyFailedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInfraDestroyFailedEvent; }
+});
+Object.defineProperty(exports, "createInfraDestroyStartedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInfraDestroyStartedEvent; }
+});
+Object.defineProperty(exports, "createInfraProvisionCompletedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInfraProvisionCompletedEvent; }
+});
+Object.defineProperty(exports, "createInfraProvisionFailedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInfraProvisionFailedEvent; }
+});
+Object.defineProperty(exports, "createInfraProvisionStartedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInfraProvisionStartedEvent; }
+});
+Object.defineProperty(exports, "createInlineRef", {
+  enumerable: true,
+  get: function () { return governanceAudit.createInlineRef; }
+});
+Object.defineProperty(exports, "createKBChunkFilteredEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createKBChunkFilteredEvent; }
+});
+Object.defineProperty(exports, "createKBGroundingAppliedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createKBGroundingAppliedEvent; }
+});
+Object.defineProperty(exports, "createKBQueryEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createKBQueryEvent; }
+});
+Object.defineProperty(exports, "createKBResultsEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createKBResultsEvent; }
+});
+Object.defineProperty(exports, "createMCPServerConnectedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createMCPServerConnectedEvent; }
+});
+Object.defineProperty(exports, "createMCPServerDisconnectedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createMCPServerDisconnectedEvent; }
+});
+Object.defineProperty(exports, "createMCPServerRegisteredEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createMCPServerRegisteredEvent; }
+});
+Object.defineProperty(exports, "createMCPToolsDiscoveredEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createMCPToolsDiscoveredEvent; }
+});
+Object.defineProperty(exports, "createMemorySink", {
+  enumerable: true,
+  get: function () { return governanceAudit.createMemorySink; }
+});
+Object.defineProperty(exports, "createNoOpSink", {
+  enumerable: true,
+  get: function () { return governanceAudit.createNoOpSink; }
+});
+Object.defineProperty(exports, "createOrchestrationStepEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createOrchestrationStepEvent; }
+});
+Object.defineProperty(exports, "createReplayDriftDetectedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createReplayDriftDetectedEvent; }
+});
+Object.defineProperty(exports, "createResourceCreatedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createResourceCreatedEvent; }
+});
+Object.defineProperty(exports, "createResourceDeletedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createResourceDeletedEvent; }
+});
+Object.defineProperty(exports, "createResourceUpdatedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createResourceUpdatedEvent; }
+});
+Object.defineProperty(exports, "createRiskRouteDecidedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createRiskRouteDecidedEvent; }
+});
+Object.defineProperty(exports, "createSnapshotCapturedEvent", {
+  enumerable: true,
+  get: function () { return governanceAudit.createSnapshotCapturedEvent; }
+});
+Object.defineProperty(exports, "findInferenceRunsFromLifecycle", {
+  enumerable: true,
+  get: function () { return governanceAudit.findInferenceRunsFromLifecycle; }
+});
+Object.defineProperty(exports, "replayAuditRun", {
+  enumerable: true,
+  get: function () { return governanceAudit.replayAuditRun; }
+});
+Object.defineProperty(exports, "replayCausalGraph", {
+  enumerable: true,
+  get: function () { return governanceAudit.replayCausalGraph; }
+});
+Object.defineProperty(exports, "traceLifecycleOriginsForOutput", {
+  enumerable: true,
+  get: function () { return governanceAudit.traceLifecycleOriginsForOutput; }
+});
+Object.defineProperty(exports, "traverseLineage", {
+  enumerable: true,
+  get: function () { return governanceAudit.traverseLineage; }
+});
+Object.defineProperty(exports, "BaseModelProvider", {
+  enumerable: true,
+  get: function () { return governanceModels.BaseModelProvider; }
+});
+Object.defineProperty(exports, "ProviderCapabilityNotSupportedError", {
+  enumerable: true,
+  get: function () { return governanceModels.ProviderCapabilityNotSupportedError; }
+});
+Object.defineProperty(exports, "createMockProvider", {
+  enumerable: true,
+  get: function () { return governanceModels.createMockProvider; }
+});
+Object.defineProperty(exports, "createModelRegistry", {
+  enumerable: true,
+  get: function () { return governanceModels.createModelRegistry; }
+});
+Object.defineProperty(exports, "supportsAudioGeneration", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsAudioGeneration; }
+});
+Object.defineProperty(exports, "supportsAudioToImage", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsAudioToImage; }
+});
+Object.defineProperty(exports, "supportsAudioToText", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsAudioToText; }
+});
+Object.defineProperty(exports, "supportsAudioToVideo", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsAudioToVideo; }
+});
+Object.defineProperty(exports, "supportsImageGeneration", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsImageGeneration; }
+});
+Object.defineProperty(exports, "supportsImageToAudio", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsImageToAudio; }
+});
+Object.defineProperty(exports, "supportsImageToText", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsImageToText; }
+});
+Object.defineProperty(exports, "supportsImageToVideo", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsImageToVideo; }
+});
+Object.defineProperty(exports, "supportsStreaming", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsStreaming; }
+});
+Object.defineProperty(exports, "supportsTokenEstimation", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsTokenEstimation; }
+});
+Object.defineProperty(exports, "supportsVideoGeneration", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsVideoGeneration; }
+});
+Object.defineProperty(exports, "supportsVideoToAudio", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsVideoToAudio; }
+});
+Object.defineProperty(exports, "supportsVideoToImage", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsVideoToImage; }
+});
+Object.defineProperty(exports, "supportsVideoToText", {
+  enumerable: true,
+  get: function () { return governanceModels.supportsVideoToText; }
+});
+Object.defineProperty(exports, "createNoOpTelemetry", {
+  enumerable: true,
+  get: function () { return governanceTelemetryOtel.createNoOpTelemetry; }
+});
+Object.defineProperty(exports, "createOTelAdapter", {
+  enumerable: true,
+  get: function () { return governanceTelemetryOtel.createOTelAdapter; }
+});
+Object.defineProperty(exports, "createHttpMCPTransport", {
+  enumerable: true,
+  get: function () { return governanceMcp.createHttpMCPTransport; }
+});
+Object.defineProperty(exports, "createMCPRegistry", {
+  enumerable: true,
+  get: function () { return governanceMcp.createMCPRegistry; }
+});
+Object.defineProperty(exports, "createMockMCPTransport", {
+  enumerable: true,
+  get: function () { return governanceMcp.createMockMCPTransport; }
+});
+Object.defineProperty(exports, "createStdioMCPTransport", {
+  enumerable: true,
+  get: function () { return governanceMcp.createStdioMCPTransport; }
+});
+Object.defineProperty(exports, "discoverTools", {
+  enumerable: true,
+  get: function () { return governanceMcp.discoverTools; }
+});
+Object.defineProperty(exports, "getMCPToolName", {
+  enumerable: true,
+  get: function () { return governanceMcp.getMCPToolName; }
+});
+Object.defineProperty(exports, "parseMCPToolName", {
+  enumerable: true,
+  get: function () { return governanceMcp.parseMCPToolName; }
+});
+Object.defineProperty(exports, "HybridScorer", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.HybridScorer; }
+});
+Object.defineProperty(exports, "applyGrounding", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.applyGrounding; }
+});
+Object.defineProperty(exports, "createGroundingHelper", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.createGroundingHelper; }
+});
+Object.defineProperty(exports, "createKBRegistry", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.createKBRegistry; }
+});
+Object.defineProperty(exports, "createKBRetriever", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.createKBRetriever; }
+});
+Object.defineProperty(exports, "createMemoryKBProvider", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.createMemoryKBProvider; }
+});
+Object.defineProperty(exports, "mergeRetrievalResults", {
+  enumerable: true,
+  get: function () { return governanceKnowledge.mergeRetrievalResults; }
+});
+Object.defineProperty(exports, "computePromptHash", {
+  enumerable: true,
+  get: function () { return governancePrompts.computePromptHash; }
+});
+Object.defineProperty(exports, "createTemplateRegistry", {
+  enumerable: true,
+  get: function () { return governancePrompts.createTemplateRegistry; }
+});
+Object.defineProperty(exports, "createInMemoryMemoryProvider", {
+  enumerable: true,
+  get: function () { return governanceMemory.createInMemoryMemoryProvider; }
+});
+Object.defineProperty(exports, "createMemoryRegistry", {
+  enumerable: true,
+  get: function () { return governanceMemory.createMemoryRegistry; }
+});
+Object.defineProperty(exports, "createDataSourceRegistry", {
+  enumerable: true,
+  get: function () { return governanceDataSources.createDataSourceRegistry; }
+});
+Object.defineProperty(exports, "deriveEvaluationEffect", {
+  enumerable: true,
+  get: function () { return governanceEvaluations.deriveEvaluationEffect; }
+});
+Object.defineProperty(exports, "runEvaluations", {
+  enumerable: true,
+  get: function () { return governanceEvaluations.runEvaluations; }
+});
+Object.defineProperty(exports, "createEnvSecretResolver", {
+  enumerable: true,
+  get: function () { return governanceSecrets.createEnvSecretResolver; }
+});
+Object.defineProperty(exports, "getSecretRedactionPatterns", {
+  enumerable: true,
+  get: function () { return governanceSecrets.getSecretRedactionPatterns; }
+});
+Object.defineProperty(exports, "createAgentRuntime", {
+  enumerable: true,
+  get: function () { return governanceAgents.createAgentRuntime; }
+});
+Object.defineProperty(exports, "createInMemoryAgentMemory", {
+  enumerable: true,
+  get: function () { return governanceAgents.createInMemoryAgentMemory; }
+});
+Object.defineProperty(exports, "createToolRegistry", {
+  enumerable: true,
+  get: function () { return governanceTools.createToolRegistry; }
+});
+Object.defineProperty(exports, "createToolRunner", {
+  enumerable: true,
+  get: function () { return governanceTools.createToolRunner; }
+});
+Object.defineProperty(exports, "createInMemoryQuotaManager", {
+  enumerable: true,
+  get: function () { return governanceQuotas.createInMemoryQuotaManager; }
+});
+exports.ArelisApiError = ArelisApiError;
+exports.ArelisClient = ArelisClient;
+exports.ArelisPlatform = ArelisPlatform;
+exports.EXTENSION_NAMESPACE_CONTRACTS = EXTENSION_NAMESPACE_CONTRACTS;
+exports.GovernanceGateDeniedError = GovernanceGateDeniedError;
+exports.createArelis = createArelis;
+exports.createArelisClient = createArelisClient;
+exports.createArelisPlatform = createArelisPlatform;
+exports.createGovernanceGateEvaluator = createGovernanceGateEvaluator;
+exports.detectExtensionContractCollisions = detectExtensionContractCollisions;
+exports.evaluatePreInvocationGate = evaluatePreInvocationGate;
+exports.extensionContractById = extensionContractById;
+exports.scanPromptForPii = scanPromptForPii;
+exports.verifyComplianceArtifactOffline = verifyComplianceArtifact;
+exports.withGovernanceGate = withGovernanceGate;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map