@decionis/mcp 0.1.2 → 0.1.4

package/dist/index.js

@@ -2,14 +2,15 @@
 import {
   LocalDecionisGateway,
   PolicyFileRepository,
+  external_exports,
   normalizeVerdict,
   sha256Hex
-} from "./chunk-KY5AVRL6.js";
+} from "./chunk-YVRIRS6H.js";
 
 // src/Server.ts
 import { createInterface } from "readline";
 var SUPPORTED_PROTOCOL_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
-var MCP_SERVER_VERSION = "0.1.2";
+var MCP_SERVER_VERSION = "0.1.4";
 var DEFAULT_PROTOCOL_VERSION = "2025-11-25";
 var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 function rpcResult(id, result) {
@@ -53,7 +54,10 @@ var McpMessageHandler = class {
               title,
               description,
               inputSchema,
-              annotations
+              annotations: {
+                title,
+                ...annotations
+              }
             })
           )
         });
@@ -164,10 +168,55 @@ rule matches, the platform holds the decision for review (outcome REVIEW).
 action you intend to take (e.g. {"action": "production-deploy", "agent_generated": true})
 and abide by the verdict: allow \u2192 proceed; block \u2192 do not proceed; review/escalate \u2192
 stop and ask a human.`;
+var DEMO_POLICY = `# Decionis demo policy
+
+Three rules and a default: refunds under the desk limit run, refunds over it
+wait for a named approver, deploys during a change freeze never run, and
+anything the policy has no opinion on is held for review.
+
+\`\`\`decionis
+{ "version": 1, "rules": [
+  { "name": "Block production deploys during a change freeze",
+    "priority": 100, "domain": "*",
+    "all": [{ "field": "context.change_freeze", "op": "eq", "value": true }],
+    "action": "block" },
+  { "name": "Escalate refunds over the desk limit",
+    "priority": 90, "domain": "*",
+    "all": [{ "field": "context.amount", "op": "gt", "value": 1000 }],
+    "action": "escalate" },
+  { "name": "Allow refunds within the desk limit",
+    "priority": 80, "domain": "*",
+    "all": [{ "field": "context.amount", "op": "lte", "value": 1000 }],
+    "action": "allow" } ] }
+\`\`\`
+`;
+var DEMO_INTENTS = [
+  {
+    label: "Refund $180 \u2014 within the desk limit",
+    payload: { action: "issue-refund", amount: 180, agent_generated: true },
+    shows: "Within policy: execution continues, and the rule that allowed it is named."
+  },
+  {
+    label: "Refund $7,500 \u2014 over the desk limit",
+    payload: { action: "issue-refund", amount: 7500, agent_generated: true },
+    shows: "Held short of execution and routed to a named approver \u2014 not refused."
+  },
+  {
+    label: "Production deploy during a change freeze",
+    payload: { action: "production-deploy", change_freeze: true, agent_generated: true },
+    shows: "Refused outright: nobody is asked to approve it."
+  },
+  {
+    label: "Export customer data \u2014 no rule covers it",
+    payload: { action: "export-customer-data", destination: "personal-email" },
+    shows: "No rule matched, so the decision queues for review \u2014 unmatched intents fail safe."
+  }
+];
 var DecionisTools = class {
-  constructor(gateway2, policyFiles = new PolicyFileRepository()) {
+  constructor(gateway2, policyFiles = new PolicyFileRepository(), additionalTools = []) {
     this.gateway = gateway2;
     this.policyFiles = policyFiles;
+    this.additionalTools = additionalTools;
   }
   build() {
     const gateway2 = this.gateway;
@@ -175,7 +224,7 @@ var DecionisTools = class {
       {
         name: "decionis_read_policy",
         title: "Read Repository Policy",
-        description: "Read and compile the repo's DECIONIS_POLICY.md governance policy: path, sha256, and the enforceable rules (name, verdict, priority, domain) or compile errors. Use this to learn what this repository allows, blocks, restrains, or escalates.",
+        description: "Read and compile the repo's DECIONIS_POLICY.md execution policy: path, sha256, and the enforceable rules (name, verdict, priority, domain) or compile errors. Use this to learn what this repository allows, blocks, restrains, or escalates.",
         inputSchema: {
           type: "object",
           properties: {
@@ -297,6 +346,67 @@ var DecionisTools = class {
           };
         }
       },
+      {
+        name: "decionis_demo",
+        title: "Run the One-Minute Demo",
+        description: "See Decionis work in under a minute: runs four canned intents (refund within limit, refund over limit, deploy during a change freeze, an action no rule covers) through the real protocol evaluator with a built-in sample policy. Entirely local \u2014 no account, no API key, no network, no policy file needed, nothing recorded. Call this on first contact with Decionis; use decionis_evaluate to gate this repo's own actions afterwards.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        },
+        handler: async () => {
+          const published = await gateway2.publishPolicy(DEMO_POLICY, { workflowKey: null });
+          if (!published.ok) {
+            return {
+              content: text({ error: "demo policy failed to compile", details: published.errors }),
+              isError: true
+            };
+          }
+          const decisions = [];
+          for (const intent of DEMO_INTENTS) {
+            const evaluated = await gateway2.evaluate({
+              payload: intent.payload,
+              workflowKey: null,
+              mode: "shadow"
+            });
+            if (evaluated.status !== 200) {
+              return {
+                content: text({
+                  error: `protocol evaluation failed (HTTP ${evaluated.status})`,
+                  intent: intent.label,
+                  body: evaluated.body
+                }),
+                isError: true
+              };
+            }
+            const body = evaluated.body;
+            const policyEvaluation = isPlainObject2(body.policy_evaluation) ? body.policy_evaluation : {};
+            decisions.push({
+              intent: intent.label,
+              outcome: body.outcome,
+              verdict: normalizeVerdict(body.outcome),
+              selected_rule: policyEvaluation.selected_rule_name ?? null,
+              what_this_shows: intent.shows
+            });
+          }
+          return {
+            content: text({
+              headline: "Four intents, four outcomes \u2014 each decided by policy before execution, through the same evaluator that runs in production.",
+              decisions,
+              vocabulary: "Wire outcomes are APPROVE / ESCALATE / REJECT / REVIEW \u2014 the wire spellings of the three decision classes (allow / escalate / block). ESCALATE routes to a named approver; REVIEW queues without one.",
+              note: "Local sandbox \u2014 the sample policy above, nothing recorded, no signed dossier minted. In production every decision leaves an Ed25519-signed Decision Dossier anyone can verify offline against the published JWKS.",
+              next_steps: [
+                "Gate this repo's own actions: decionis_read_policy, then decionis_evaluate before anything risky.",
+                "Watch real traffic read-only first: https://decionis.com/shadow-mode",
+                "First governed decision with signed proof: https://decionis.com/docs/quickstart"
+              ]
+            })
+          };
+        }
+      },
       {
         name: "decionis_verdict_help",
         title: "Explain Decionis Verdicts",
@@ -309,19 +419,2134 @@ var DecionisTools = class {
           openWorldHint: false
         },
         handler: async () => ({ content: text(VERDICT_HELP) })
+      },
+      ...this.additionalTools
+    ];
+  }
+};
+function createDecionisTools(gateway2, additionalTools = []) {
+  return new DecionisTools(gateway2, new PolicyFileRepository(), additionalTools).build();
+}
+
+// src/kubernetes/KubernetesActionPlanner.ts
+import { randomUUID } from "crypto";
+
+// ../../packages/sdk-node/dist/index.js
+import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
+var DEFAULT_SKEW_MS = 6 * 60 * 60 * 1e3;
+var authoritySelectorSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("ROLE"),
+    role_id: external_exports.string().regex(/^[A-Z][A-Z0-9_]{1,63}$/)
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("PRINCIPAL"),
+    principal_id: external_exports.string().min(1).max(200)
+  }).strict()
+]);
+var authorityVerificationRequirementsSchema = external_exports.object({
+  level: external_exports.enum(["STANDARD", "HIGH_CONFIDENCE"]),
+  methods: external_exports.array(external_exports.enum(["WEBAUTHN", "MOBILE_DEVICE", "ACTIVE_LIVENESS"])).min(1).max(3),
+  hardware_pki_required: external_exports.boolean(),
+  disallow_virtual_cameras: external_exports.boolean(),
+  mobile_device_policy: external_exports.enum(["WEB_OR_JIT_DEVICE", "MANAGED_DEVICE_REQUIRED"]).optional(),
+  trusted_ip_regions: external_exports.array(external_exports.string().trim().min(1).max(64)).min(1).max(100).optional()
+}).strict().superRefine((requirements, context) => {
+  if (new Set(requirements.methods).size !== requirements.methods.length) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["methods"],
+      message: "verification methods must be unique"
+    });
+  }
+  if (requirements.trusted_ip_regions !== void 0 && new Set(requirements.trusted_ip_regions).size !== requirements.trusted_ip_regions.length) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["trusted_ip_regions"],
+      message: "trusted IP regions must be unique"
+    });
+  }
+});
+var authorityResolutionPolicySchema = external_exports.object({
+  quorum: external_exports.literal(1),
+  delegation: external_exports.enum(["DISALLOWED", "REQUIREMENT_REFRESH"]),
+  fallback_role_ids: external_exports.array(external_exports.string().regex(/^[A-Z][A-Z0-9_]{1,63}$/)).max(10).default([])
+}).strict().superRefine((policy, context) => {
+  if (new Set(policy.fallback_role_ids).size !== policy.fallback_role_ids.length) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["fallback_role_ids"],
+      message: "fallback role ids must be unique"
+    });
+  }
+});
+var originatorSchema = external_exports.object({
+  organization_id: external_exports.string().min(1).max(200),
+  organization_name: external_exports.string().trim().min(1).max(160),
+  actor_id: external_exports.string().min(1).max(200).optional(),
+  display_name: external_exports.string().trim().min(1).max(160).optional(),
+  role: external_exports.string().trim().min(1).max(120).optional(),
+  provenance: external_exports.enum(["AUTHENTICATED_TENANT", "VERIFIED_CONNECTOR", "CALLER_DECLARED"])
+}).strict();
+var displayFieldSchema = external_exports.object({
+  key: external_exports.string().regex(/^[a-z][a-z0-9_]{0,63}$/),
+  label: external_exports.string().trim().min(1).max(120),
+  value: external_exports.string().trim().min(1).max(500)
+}).strict();
+var presentationSchema = external_exports.object({
+  locale: external_exports.string().min(2).max(35).regex(/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/),
+  title: external_exports.string().trim().min(1).max(160),
+  description: external_exports.string().trim().min(1).max(1e3),
+  display_fields: external_exports.array(displayFieldSchema).max(20)
+}).strict().superRefine((presentation, context) => {
+  const keys = presentation.display_fields.map((field) => field.key);
+  if (new Set(keys).size !== keys.length) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["display_fields"],
+      message: "display field keys must be unique"
+    });
+  }
+});
+var decionisAuthorityRequirementSchema = external_exports.object({
+  requirement_version: external_exports.literal("decionis.authority_requirement/1"),
+  requirement_id: external_exports.string().min(8).max(200),
+  source_decision_id: external_exports.string().min(1).max(200),
+  source_dossier_id: external_exports.string().min(1).max(200),
+  policy_version: external_exports.string().min(1).max(120),
+  policy_reason_codes: external_exports.array(external_exports.string().regex(/^[A-Z][A-Z0-9_]{1,119}$/)).min(1).max(20),
+  action_digest: external_exports.string().regex(/^[0-9a-f]{64}$/),
+  selector: authoritySelectorSchema,
+  verification_requirements: authorityVerificationRequirementsSchema,
+  resolution: authorityResolutionPolicySchema,
+  originator: originatorSchema,
+  presentation: presentationSchema,
+  nonce: external_exports.string().regex(/^[A-Za-z0-9_-]{43,128}$/),
+  issued_at: external_exports.string().datetime(),
+  expires_at: external_exports.string().datetime()
+}).strict().superRefine((requirement, context) => {
+  if (Date.parse(requirement.expires_at) <= Date.parse(requirement.issued_at)) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["expires_at"],
+      message: "expires_at must be later than issued_at"
+    });
+  }
+  if (requirement.selector.kind === "ROLE" && requirement.resolution.fallback_role_ids.includes(requirement.selector.role_id)) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["resolution", "fallback_role_ids"],
+      message: "fallback roles must not repeat the primary role"
+    });
+  }
+});
+var decionisEvaluateModeSchema = external_exports.enum(["SHADOW", "PARALLEL", "ENFORCEMENT"]);
+var decionisEvaluateOutcomeSchema = external_exports.enum(["APPROVE", "ESCALATE", "REJECT", "REVIEW"]);
+var decionisEvaluateDecisionRequestSchema = external_exports.object({
+  org_id: external_exports.string().uuid(),
+  decision_type: external_exports.string().min(1).max(120),
+  amount: external_exports.number().optional(),
+  risk_score: external_exports.number().min(0).max(1).optional(),
+  channel: external_exports.string().min(1).max(120).optional(),
+  policy_version: external_exports.string().min(1).max(120).optional(),
+  objective_profile: external_exports.string().min(1).max(120).optional(),
+  mode: decionisEvaluateModeSchema.optional(),
+  decision_band: external_exports.string().min(1).max(120).optional(),
+  transaction_type: external_exports.string().min(1).max(120).optional(),
+  workflow_key: external_exports.string().min(1).max(120).optional(),
+  vertical_pack: external_exports.string().min(1).max(120).optional(),
+  context: external_exports.record(external_exports.unknown()).optional(),
+  idempotency_key: external_exports.string().min(1).max(180).optional()
+});
+var governanceMetricsSchema = external_exports.object({
+  override_drift_rate: external_exports.number(),
+  governance_tension_index: external_exports.number(),
+  boundary_volatility_score: external_exports.number(),
+  decision_volume_under_governance: external_exports.number()
+});
+var policyGuardSchema = external_exports.object({
+  status: external_exports.enum(["ready", "configured", "missing"]),
+  requires_manual_review: external_exports.boolean(),
+  total_bundle_count: external_exports.number(),
+  active_bundle_count: external_exports.number(),
+  active_bundle_id: external_exports.string().uuid().nullable(),
+  active_bundle_version: external_exports.string().nullable(),
+  active_effective_from: external_exports.string().nullable(),
+  active_effective_to: external_exports.string().nullable(),
+  latest_bundle_id: external_exports.string().uuid().nullable(),
+  latest_bundle_version: external_exports.string().nullable(),
+  latest_effective_from: external_exports.string().nullable(),
+  latest_effective_to: external_exports.string().nullable(),
+  reason: external_exports.enum([
+    "missing_org_policy_bundle",
+    "no_active_org_policy_bundle",
+    "requested_policy_bundle_not_found"
+  ]).nullable(),
+  evaluated_at: external_exports.string()
+}).optional();
+var policyEvaluationSchema = external_exports.object({
+  resolution: external_exports.enum([
+    "policy_guard_blocked",
+    "matched_rule",
+    "no_matching_rule",
+    "missing_required_signals"
+  ]),
+  bundle_id: external_exports.string().uuid().nullable(),
+  bundle_version: external_exports.string().nullable(),
+  evaluated_at: external_exports.string(),
+  decision_domain: external_exports.string(),
+  evaluated_rule_count: external_exports.number(),
+  matched_rule_count: external_exports.number(),
+  matched_rule_ids: external_exports.array(external_exports.string()),
+  selected_rule_id: external_exports.string().nullable(),
+  selected_rule_name: external_exports.string().nullable(),
+  selected_rule_action: external_exports.enum(["REQUIRE_REVIEW", "AUTO_APPROVE", "AUTO_REJECT", "ESCALATE", "REQUEST_INFO"]).nullable(),
+  selected_rule_priority: external_exports.number().nullable(),
+  selected_rule_rationale: external_exports.string().nullable(),
+  selected_rule_severity: external_exports.enum(["routine", "elevated", "urgent"]).nullable(),
+  selected_rule_assignee_role: external_exports.string().nullable(),
+  selected_rule_sla_minutes: external_exports.number().nullable(),
+  selected_rule_authority: external_exports.unknown().optional(),
+  missing_required_signals: external_exports.array(external_exports.string()).optional()
+}).optional();
+var policySnapshotSchema = external_exports.object({
+  policy_version: external_exports.string(),
+  policy_bundle_id: external_exports.string().uuid().nullable(),
+  rules_sha256: external_exports.string().nullable(),
+  parameters_sha256: external_exports.string().nullable(),
+  effective_from: external_exports.string().nullable(),
+  effective_to: external_exports.string().nullable(),
+  evaluated_at: external_exports.string(),
+  source: external_exports.enum(["org_policy_bundle", "policy_guard", "request_default"])
+}).optional();
+var decionisEvaluateDecisionResponseSchema = external_exports.object({
+  outcome: decionisEvaluateOutcomeSchema,
+  confidence: external_exports.number(),
+  policy_version: external_exports.string(),
+  objective_profile: external_exports.string(),
+  dossier_id: external_exports.string().uuid(),
+  dossier_sha256: external_exports.string().nullable().optional(),
+  evaluation_id: external_exports.string().uuid(),
+  decision_resolution_id: external_exports.string().uuid().nullable().optional(),
+  ledger_entry_id: external_exports.string().uuid().nullable().optional(),
+  ledger_entry_hash: external_exports.string().nullable().optional(),
+  mode: decionisEvaluateModeSchema,
+  reason_codes: external_exports.array(external_exports.string().min(1)).optional(),
+  fallback_to_legacy: external_exports.boolean(),
+  fallback_reason: external_exports.string().nullable().optional(),
+  reconciliation_required: external_exports.boolean().optional(),
+  reconciliation_status: external_exports.enum(["NOT_REQUIRED", "PENDING", "IN_PROGRESS", "COMPLETED", "FAILED"]).optional(),
+  decision_domain: external_exports.string().optional(),
+  governance_metrics: governanceMetricsSchema,
+  policy_guard: policyGuardSchema,
+  policy_evaluation: policyEvaluationSchema,
+  policy_snapshot: policySnapshotSchema.nullable().optional(),
+  authority_requirement: decionisAuthorityRequirementSchema.optional(),
+  idempotent_replay: external_exports.boolean()
+});
+var authorityDecisionSchema = external_exports.object({
+  decision_id: external_exports.string().min(1),
+  chain_id: external_exports.string().nullable(),
+  status: external_exports.enum(["ALLOW", "BLOCK", "ESCALATE", "REVIEW_REQUIRED", "ERROR"]),
+  should_execute: external_exports.boolean(),
+  reason_codes: external_exports.array(external_exports.string()),
+  action_hash: external_exports.string().regex(/^sha256:[0-9a-f]{64}$/),
+  policy_version: external_exports.string().nullable().optional().default(null),
+  mode: external_exports.enum(["SHADOW", "PARALLEL", "ENFORCEMENT"]).nullable().optional().default(null),
+  execution_token: external_exports.string().min(1).nullable(),
+  execution_token_expires_at: external_exports.string().datetime().nullable(),
+  dossier_id: external_exports.string().nullable(),
+  dossier_sha256: external_exports.string().nullable().optional().default(null),
+  dossier_url: external_exports.string().nullable(),
+  approval_request_id: external_exports.string().nullable().optional().default(null),
+  ledger_entry_id: external_exports.string().nullable()
+}).passthrough();
+var DecionisExecutionClientError = class extends Error {
+  status;
+  body;
+  constructor(message, options) {
+    super(message);
+    this.name = "DecionisExecutionClientError";
+    this.status = options.status;
+    this.body = options.body;
+  }
+};
+async function postJson(options, route, body) {
+  const baseUrl = options.authorityBaseUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    Math.min(Math.max(options.timeoutMs ?? 4e3, 1), 15e3)
+  );
+  try {
+    const response = await fetchImpl(`${baseUrl}${route}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...options.defaultHeaders ?? {}
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    const responseText = await response.text();
+    const responseBody = Buffer.byteLength(responseText, "utf8") <= 100 * 1024 ? (() => {
+      try {
+        return JSON.parse(responseText);
+      } catch {
+        return null;
+      }
+    })() : null;
+    if (!response.ok) {
+      throw new DecionisExecutionClientError(
+        `Decionis execution authority request failed with status ${response.status}`,
+        {
+          status: response.status,
+          body: responseBody
+        }
+      );
+    }
+    return responseBody;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+var DecionisExecutionClient = class {
+  options;
+  constructor(options) {
+    assertAuthorityUrl(options);
+    this.options = options;
+  }
+  enforceAndBind = async (request) => {
+    const response = await postJson(
+      {
+        ...this.options,
+        defaultHeaders: {
+          "idempotency-key": request.intent_id,
+          ...this.options.defaultHeaders ?? {}
+        }
+      },
+      "/v1/authority/enforce-and-bind",
+      request
+    );
+    return authorityDecisionSchema.parse(response);
+  };
+  verifyToken = (body) => {
+    return postJson(
+      this.options,
+      "/v1/execution/verify-token",
+      body
+    );
+  };
+  consumeToken = (body) => {
+    return postJson(
+      this.options,
+      "/v1/execution/consume-token",
+      body
+    );
+  };
+  claimToken = (body) => {
+    return postJson(
+      this.options,
+      "/v1/execution/claim-token",
+      body
+    );
+  };
+  /**
+   * Grant-required, fail-closed enforcement — the default path. Delegates to
+   * {@link enforceAndExecuteStrict}: the authority must authorize AND issue a
+   * single-use grant, and that grant must redeem, BEFORE `execute` runs. Policy
+   * block, missing grant, failed redemption, and an unreachable authority all
+   * resolve to `executed: false` (`decision` is `null` on authority errors)
+   * instead of running the action. Call the strict method directly when the
+   * caller needs the grant redemption or the precise non-execution reason;
+   * this wrapper keeps the smaller executed/decision/result shape.
+   */
+  enforceAndExecute = async (input) => {
+    const strict = await this.enforceAndExecuteStrict({
+      request: input.request,
+      execute: ({ decision, executionToken }) => input.execute({ decision, executionToken })
+    });
+    if (!strict.executed) {
+      return {
+        executed: false,
+        decision: strict.decision,
+        result: null
+      };
+    }
+    return {
+      executed: true,
+      decision: strict.decision,
+      result: strict.result
+    };
+  };
+  /**
+   * Redeem a single-use execution grant via `/v1/execution/consume-token`, binding
+   * it to the exact action. Never throws — a transport/HTTP failure returns an
+   * invalid redemption so the strict path fails closed rather than executing on an
+   * unverified grant.
+   */
+  redeemGrant = async (executionToken, request, expectedDecision, commitCorrelationId = request.intent_id) => {
+    const baseUrl = this.options.authorityBaseUrl.replace(/\/+$/, "");
+    const fetchImpl = this.options.fetch ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      Math.min(Math.max(this.options.timeoutMs ?? 4e3, 1), 15e3)
+    );
+    try {
+      const response = await fetchImpl(`${baseUrl}/v1/execution/claim-token`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...this.options.defaultHeaders ?? {} },
+        body: JSON.stringify({
+          execution_token: executionToken,
+          intent_hash: request.intent_hash,
+          intent: authorityIntentBindingOf(request),
+          ...request.evidence ? { evidence: request.evidence } : {},
+          consumed_by: request.actor.id,
+          commit_correlation_id: commitCorrelationId
+        }),
+        signal: controller.signal
+      });
+      const responseText = await response.text();
+      const body = (() => {
+        if (Buffer.byteLength(responseText, "utf8") > 100 * 1024) return null;
+        try {
+          return JSON.parse(responseText);
+        } catch {
+          return null;
+        }
+      })();
+      if (!response.ok || !body || body.valid !== true) {
+        const reason_codes = Array.isArray(body?.reason_codes) ? body?.reason_codes : ["DECIONIS_GRANT_REJECTED"];
+        return { valid: false, reason_codes, claims: body?.claims ?? null };
+      }
+      const claims = body.claims;
+      const binding = claims && typeof claims.binding === "object" && !Array.isArray(claims.binding) ? claims.binding : null;
+      if (!claims || typeof claims.jti !== "string" || claims.org_id !== request.tenant_id || claims.sub !== request.actor.id || claims.action !== request.action.type || binding?.intent_hash !== request.intent_hash || expectedDecision !== void 0 && (claims.decision_id !== expectedDecision.decision_id || claims.dossier_id !== expectedDecision.dossier_id)) {
+        return {
+          valid: false,
+          reason_codes: ["DECIONIS_GRANT_BINDING_MISMATCH"],
+          claims: null
+        };
+      }
+      return {
+        valid: true,
+        reason_codes: Array.isArray(body.reason_codes) ? body.reason_codes : [],
+        claims,
+        claim_token: typeof body.claim_token === "string" ? body.claim_token : null,
+        claim_lease_expires_at: typeof body.claim_lease_expires_at === "string" ? body.claim_lease_expires_at : null,
+        ...body.evidence && typeof body.evidence === "object" ? { evidence: body.evidence } : {}
+      };
+    } catch {
+      return { valid: false, reason_codes: ["DECIONIS_GRANT_REDEEM_ERROR"], claims: null };
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+  finalizeGrant = async (input) => {
+    try {
+      const response = await postJson(
+        this.options,
+        "/v1/execution/finalize-token",
+        {
+          execution_token: input.executionToken,
+          claim_token: input.claimToken,
+          outcome: input.outcome,
+          commit_correlation_id: input.commitCorrelationId,
+          ...input.downstreamEvidence ? { downstream_evidence: input.downstreamEvidence } : {}
+        }
+      );
+      return response.finalized === true;
+    } catch {
+      return false;
+    }
+  };
+  /**
+   * Grant-required (strict) enforcement: "no valid grant, no execution." The default
+   * {@link enforceAndExecute} delegates to this path. This makes the single-use
+   * execution grant a hard precondition: the authority must authorize AND issue a
+   * grant, and that grant must redeem successfully, BEFORE `execute` runs. Because
+   * the grant is redeemed up front, a downstream failure requires a fresh decision
+   * rather than replaying an ALLOW — the fail-closed posture for consequential
+   * actions. Every non-executing path returns `executed: false` with a reason.
+   */
+  enforceAndExecuteStrict = async (input) => {
+    let decision;
+    try {
+      decision = await this.enforceAndBind(input.request);
+    } catch {
+      return {
+        executed: false,
+        decision: null,
+        grant: null,
+        reason: "AUTHORITY_ERROR",
+        result: null
+      };
+    }
+    if (!decision.should_execute) {
+      return { executed: false, decision, grant: null, reason: "BLOCKED_BY_POLICY", result: null };
+    }
+    if (!decision.execution_token) {
+      return { executed: false, decision, grant: null, reason: "NO_EXECUTION_GRANT", result: null };
+    }
+    const commitCorrelationId = input.request.intent_id;
+    const grant = await this.redeemGrant(
+      decision.execution_token,
+      input.request,
+      decision,
+      commitCorrelationId
+    );
+    if (!grant.valid || !grant.claim_token) {
+      return { executed: false, decision, grant, reason: "GRANT_NOT_REDEEMABLE", result: null };
+    }
+    let result;
+    try {
+      result = await input.execute({
+        decision,
+        executionToken: decision.execution_token,
+        grant,
+        claimToken: grant.claim_token,
+        commitCorrelationId
+      });
+    } catch (error) {
+      await this.finalizeGrant({
+        executionToken: decision.execution_token,
+        claimToken: grant.claim_token,
+        outcome: input.classifyFailure?.(error) ?? "INDETERMINATE",
+        commitCorrelationId,
+        downstreamEvidence: { error_type: error instanceof Error ? error.name : "unknown" }
+      });
+      throw error;
+    }
+    const finalized = await this.finalizeGrant({
+      executionToken: decision.execution_token,
+      claimToken: grant.claim_token,
+      outcome: "COMMITTED",
+      commitCorrelationId
+    });
+    if (!finalized) grant.reason_codes = [...grant.reason_codes, "COMMIT_FINALIZATION_PENDING"];
+    return { executed: true, decision, grant, result };
+  };
+};
+function createDecionisExecutionClient(options) {
+  return new DecionisExecutionClient(options);
+}
+function authorityIntentBindingOf(request) {
+  return {
+    protocol_version: request.protocol_version,
+    tenant_id: request.tenant_id,
+    intent_id: request.intent_id,
+    captured_at: request.captured_at,
+    expires_at: request.expires_at,
+    actor: request.actor,
+    action: request.action,
+    context: request.context,
+    downstream_target: request.downstream_target
+  };
+}
+function hashAuthorityIntentBinding(binding) {
+  const canonical = stableJsonStringify(binding);
+  if (Buffer.byteLength(canonical, "utf8") > 100 * 1024) {
+    throw new Error("DECIONIS_INTENT_TOO_LARGE");
+  }
+  return `sha256:${createHash("sha256").update(canonical, "utf8").digest("hex")}`;
+}
+function bindAuthorityIntent(binding, evidence, mode = "ENFORCEMENT") {
+  return {
+    ...binding,
+    intent_hash: hashAuthorityIntentBinding(binding),
+    mode,
+    ...evidence === void 0 ? {} : { evidence }
+  };
+}
+function stableJsonStringify(value) {
+  let entries = 0;
+  const normalize = (current, depth) => {
+    if (depth > 20) throw new Error("DECIONIS_INTENT_TOO_DEEP");
+    if (current === null || typeof current === "string" || typeof current === "boolean") {
+      return current;
+    }
+    if (typeof current === "number") {
+      if (!Number.isFinite(current)) throw new Error("DECIONIS_INTENT_NUMBER_INVALID");
+      return current;
+    }
+    if (Array.isArray(current)) {
+      if (current.length > 1e3) throw new Error("DECIONIS_INTENT_ARRAY_TOO_LARGE");
+      entries += current.length;
+      if (entries > 5e3) throw new Error("DECIONIS_INTENT_TOO_MANY_ENTRIES");
+      return current.map((item) => normalize(item, depth + 1));
+    }
+    if (!current || typeof current !== "object") throw new Error("DECIONIS_INTENT_VALUE_INVALID");
+    const source = current;
+    const keys = Object.keys(source).sort();
+    entries += keys.length;
+    if (entries > 5e3) throw new Error("DECIONIS_INTENT_TOO_MANY_ENTRIES");
+    const normalized = {};
+    for (const key of keys) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        throw new Error("DECIONIS_INTENT_KEY_UNSAFE");
+      }
+      normalized[key] = normalize(source[key], depth + 1);
+    }
+    return normalized;
+  };
+  return JSON.stringify(normalize(value, 0));
+}
+function assertAuthorityUrl(options) {
+  const url = new URL(options.authorityBaseUrl);
+  const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+  if (url.username || url.password) throw new Error("DECIONIS_URL_MUST_NOT_CONTAIN_CREDENTIALS");
+  if (url.protocol !== "https:" && !(loopback && options.allowInsecureLoopback === true)) {
+    throw new Error("DECIONIS_URL_MUST_USE_HTTPS");
+  }
+}
+function bindKubernetesAuthorityAction(input) {
+  const group = input.apiGroup || "core";
+  const actionType = `kubernetes.${input.operation.toLowerCase()}.${token(group)}.${token(input.resource)}`.slice(
+    0,
+    120
+  );
+  const parameters = {
+    cluster_id: input.clusterId,
+    operation: input.operation,
+    api_group: input.apiGroup,
+    api_version: input.apiVersion,
+    kind: input.kind,
+    resource: input.resource,
+    subresource: input.subresource ?? null,
+    namespace: input.namespace ?? null,
+    name: input.name ?? null,
+    old_object_digest: input.oldObjectDigest,
+    proposed_object_digest: input.proposedObjectDigest,
+    material_diff: input.materialDiff,
+    material_facts: input.materialFacts,
+    policy_version: input.policyVersion,
+    policy_rule: input.policyRule,
+    dry_run: input.dryRun ?? false
+  };
+  return bindAuthorityIntent(
+    {
+      protocol_version: "agent-safe.intent/1",
+      tenant_id: input.organizationId,
+      intent_id: input.intentId,
+      captured_at: input.capturedAt,
+      expires_at: input.expiresAt,
+      actor: input.actor,
+      action: {
+        type: actionType,
+        resource: [
+          input.clusterId,
+          group,
+          input.apiVersion,
+          input.resource,
+          input.subresource ?? "-",
+          input.namespace ?? "-",
+          input.name ?? "-"
+        ].map((part) => encodeURIComponent(part)).join(":").slice(0, 500),
+        parameters
+      },
+      context: {
+        source: input.requestSource ?? "kubernetes",
+        kubernetes: {
+          ...parameters,
+          request_source: input.requestSource ?? null,
+          ...input.additionalKubernetesContext ?? {}
+        }
+      },
+      downstream_target: {
+        system: `kubernetes:${input.clusterId}`,
+        operation: input.operation,
+        endpoint: [
+          group,
+          input.apiVersion,
+          input.resource,
+          input.namespace ?? "-",
+          input.name ?? "-"
+        ].map((part) => encodeURIComponent(part)).join("/").slice(0, 500)
+      }
+    },
+    void 0,
+    input.mode
+  );
+}
+function hashKubernetesObject(input) {
+  if (!input) return null;
+  return `sha256:${createHash2("sha256").update(stableJson(input), "utf8").digest("hex")}`;
+}
+function summarizeKubernetesObjectDiff(oldObject, proposedObject, secret) {
+  const paths = [];
+  collectChangedPaths(oldObject, proposedObject, "", paths, secret);
+  const unique = [...new Set(paths)].sort();
+  return {
+    changed_path_count: unique.length,
+    changed_paths: unique.slice(0, 64),
+    truncated: unique.length > 64
+  };
+}
+function deriveKubernetesMaterialFacts(input) {
+  const object = input.object ?? input.oldObject;
+  const facts = {};
+  const replicas = finiteNumber(record(input.object?.spec).replicas);
+  if (replicas !== null && replicas >= 0) facts.proposed_replicas = replicas;
+  const workloadSpec = podSpec(object, input.kind);
+  if (workloadSpec) {
+    const containers = [
+      ...records(workloadSpec.containers),
+      ...records(workloadSpec.initContainers),
+      ...records(workloadSpec.ephemeralContainers)
+    ];
+    const serviceAccount = string(workloadSpec.serviceAccountName) ?? string(workloadSpec.serviceAccount);
+    facts.workload_security = {
+      privileged_containers: containers.filter(
+        (container) => record(container.securityContext).privileged === true
+      ).length,
+      allow_privilege_escalation_containers: containers.filter(
+        (container) => record(container.securityContext).allowPrivilegeEscalation === true
+      ).length,
+      host_network: workloadSpec.hostNetwork === true,
+      host_pid: workloadSpec.hostPID === true,
+      host_ipc: workloadSpec.hostIPC === true,
+      host_path_volumes: records(workloadSpec.volumes).filter((volume) => isRecord(volume.hostPath)).length,
+      host_port_bindings: containers.reduce(
+        (count, container) => count + records(container.ports).filter((port) => finiteNumber(port.hostPort) !== null).length,
+        0
+      ),
+      gpu_count: containers.reduce((count, container) => count + gpuCount(container), 0),
+      ...serviceAccount ? {
+        workload_service_account_sha256: createHash2("sha256").update(serviceAccount, "utf8").digest("hex")
+      } : {}
+    };
+  }
+  if (input.apiGroup === "rbac.authorization.k8s.io" && ["roles", "clusterroles", "rolebindings", "clusterrolebindings"].includes(input.resource)) {
+    const roleRef = record(object?.roleRef);
+    const rules = records(object?.rules);
+    facts.rbac = {
+      binds_cluster_admin: string(roleRef.name) === "cluster-admin" && string(roleRef.kind) === "ClusterRole",
+      wildcard_rules: rules.filter((rule) => {
+        const verbs = strings(rule.verbs);
+        const resources = strings(rule.resources);
+        const apiGroups = strings(rule.apiGroups);
+        return verbs.includes("*") || resources.includes("*") || apiGroups.includes("*");
+      }).length,
+      privilege_escalation_rules: rules.filter(
+        (rule) => strings(rule.verbs).some((verb) => ["bind", "escalate", "impersonate"].includes(verb))
+      ).length
+    };
+  }
+  if (input.kind === "Secret") facts.sensitive_object = true;
+  return facts;
+}
+function collectChangedPaths(before, after, path, paths, secret) {
+  if (stableJson(before) === stableJson(after)) return;
+  if (secret && (path === "/data" || path === "/stringData")) {
+    paths.push(`${path}/<redacted>`);
+    return;
+  }
+  if (isRecord(before) && isRecord(after)) {
+    for (const key of [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort()) {
+      collectChangedPaths(before[key], after[key], `${path}/${pointer(key)}`, paths, secret);
+    }
+    return;
+  }
+  paths.push(path || "/");
+}
+function stableJson(value) {
+  if (value === void 0) return "undefined";
+  const normalize = (current) => {
+    if (Array.isArray(current)) return current.map(normalize);
+    if (!isRecord(current)) return current;
+    return Object.fromEntries(
+      Object.keys(current).sort().map((key) => [key, normalize(current[key])])
+    );
+  };
+  return JSON.stringify(normalize(value));
+}
+function podSpec(object, kind) {
+  const spec = record(object?.spec);
+  if (kind === "Pod") return spec;
+  if (kind === "CronJob") {
+    const jobSpec = record(record(spec.jobTemplate).spec);
+    const cronPodSpec = record(record(jobSpec.template).spec);
+    return Object.keys(cronPodSpec).length > 0 ? cronPodSpec : null;
+  }
+  const workloadPodSpec = record(record(spec.template).spec);
+  return Object.keys(workloadPodSpec).length > 0 ? workloadPodSpec : null;
+}
+function gpuCount(container) {
+  const resources = record(container.resources);
+  const requests = record(resources.requests);
+  const limits = record(resources.limits);
+  let total = 0;
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(requests), ...Object.keys(limits)])) {
+    if (!/(^|[./-])gpu$/i.test(key)) continue;
+    total += Math.max(quantity(requests[key]), quantity(limits[key]));
+  }
+  return total;
+}
+function quantity(input) {
+  if (typeof input === "number" && Number.isFinite(input) && input >= 0) return input;
+  if (typeof input !== "string" || !/^\d+(?:\.\d+)?$/.test(input)) return 0;
+  const parsed = Number(input);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+function finiteNumber(input) {
+  return typeof input === "number" && Number.isFinite(input) ? input : null;
+}
+function string(input) {
+  return typeof input === "string" && input.length > 0 ? input : null;
+}
+function strings(input) {
+  return Array.isArray(input) ? input.filter((value) => typeof value === "string") : [];
+}
+function records(input) {
+  return Array.isArray(input) ? input.filter(isRecord) : [];
+}
+function record(input) {
+  return isRecord(input) ? input : {};
+}
+function isRecord(input) {
+  return !!input && typeof input === "object" && !Array.isArray(input);
+}
+function pointer(input) {
+  return input.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function token(input) {
+  return input.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^[^a-z]+/, "x");
+}
+var personalDeviceSchema = external_exports.object({
+  device_id: external_exports.string(),
+  org_id: external_exports.string(),
+  label: external_exports.string(),
+  scopes: external_exports.array(external_exports.string()),
+  registered_at: external_exports.string()
+});
+var personalProtocolSchema = external_exports.object({
+  outcome: external_exports.string(),
+  dossier_id: external_exports.string(),
+  evaluation_id: external_exports.string().optional(),
+  policy_version: external_exports.string().optional(),
+  verification_url: external_exports.string().optional()
+}).passthrough();
+var personalCapsuleSchema = external_exports.object({
+  capsule_id: external_exports.string(),
+  org_id: external_exports.string(),
+  title: external_exports.string(),
+  state_hash: external_exports.string(),
+  payload_ref: external_exports.string(),
+  dossier_id: external_exports.string(),
+  verification_url: external_exports.string(),
+  evidence_hashes: external_exports.array(external_exports.string()),
+  captured_at: external_exports.string(),
+  retention_days: external_exports.number(),
+  deleted_at: external_exports.string().nullable()
+});
+var registerDeviceResponseSchema = external_exports.object({
+  device: personalDeviceSchema,
+  token: external_exports.string()
+});
+var captureCapsuleResponseSchema = external_exports.object({
+  capsule: personalCapsuleSchema,
+  protocol: personalProtocolSchema
+});
+var resumeCapsuleResponseSchema = external_exports.object({
+  verdict: external_exports.literal("RESTORE"),
+  execution: external_exports.object({
+    type: external_exports.string(),
+    parameters: external_exports.record(external_exports.unknown())
+  }).optional(),
+  protocol: personalProtocolSchema
+});
+var recallResponseSchema = external_exports.object({
+  verdict: external_exports.enum(["NO_ACTION", "PIN_RESOURCE", "LOAD_SIDEBAR", "OPEN_RESOURCE"]),
+  dispatch: external_exports.object({
+    type: external_exports.enum(["PIN_RESOURCE", "LOAD_SIDEBAR", "OPEN_RESOURCE"]),
+    parameters: external_exports.object({
+      resource_url: external_exports.string(),
+      label: external_exports.string().nullable(),
+      rule_id: external_exports.string()
+    })
+  }).nullable(),
+  protocol: personalProtocolSchema.optional()
+});
+var personalConfigResponseSchema = external_exports.object({
+  service: external_exports.literal("personal"),
+  org_id: external_exports.string(),
+  config_version: external_exports.string().nullable(),
+  device: external_exports.object({
+    device_id: external_exports.string().nullable(),
+    auth_type: external_exports.string().nullable(),
+    scopes: external_exports.array(external_exports.string())
+  }),
+  policy: external_exports.object({
+    bundle_id: external_exports.string(),
+    version: external_exports.string(),
+    rules_sha256: external_exports.string(),
+    parameters_sha256: external_exports.string(),
+    rule_count: external_exports.number(),
+    source: external_exports.string(),
+    stored_at: external_exports.string()
+  }).nullable(),
+  realms: external_exports.record(external_exports.unknown()),
+  recall_rules: external_exports.array(external_exports.record(external_exports.unknown()))
+});
+
+// src/kubernetes/KubernetesActionPlanner.ts
+var KubernetesActionPlanner = class {
+  constructor(config, runner, now = () => /* @__PURE__ */ new Date(), createId = randomUUID) {
+    this.config = config;
+    this.runner = runner;
+    this.now = now;
+    this.createId = createId;
+  }
+  discoveryCache = /* @__PURE__ */ new Map();
+  async planManifest(manifestPath, namespace, source) {
+    if (!manifestPath.trim() || manifestPath.length > 2e3 || /[\r\n\0]/.test(manifestPath)) {
+      throw new Error("KUBERNETES_MANIFEST_PATH_INVALID");
+    }
+    const namespaceArgs = namespace ? ["--namespace", namespace] : [];
+    const proposed = this.objects(
+      await this.jsonCommand([
+        "create",
+        "--dry-run=client",
+        "--output=json",
+        "--filename",
+        manifestPath,
+        ...namespaceArgs
+      ])
+    );
+    if (proposed.length === 0 || proposed.length > 100) {
+      throw new Error("KUBERNETES_MANIFEST_OBJECT_COUNT_INVALID");
+    }
+    const current = this.objects(
+      await this.jsonCommand([
+        "get",
+        "--ignore-not-found",
+        "--output=json",
+        "--filename",
+        manifestPath,
+        ...namespaceArgs
+      ])
+    );
+    return Promise.all(
+      proposed.map(async (object) => {
+        const identity = this.identity(object, namespace);
+        const oldObject = current.find((candidate) => this.sameIdentity(candidate, identity)) ?? null;
+        const resource = await this.resourceName(
+          identity.apiGroup,
+          identity.apiVersion,
+          identity.kind
+        );
+        return this.build({
+          object,
+          oldObject,
+          resource,
+          subresource: null,
+          source,
+          ...identity
+        });
+      })
+    );
+  }
+  async planScale(input) {
+    if (!Number.isInteger(input.replicas) || input.replicas < 0 || input.replicas > 1e6) {
+      throw new Error("KUBERNETES_REPLICA_COUNT_INVALID");
+    }
+    const endpoint = `/apis/apps/v1/namespaces/${encodeURIComponent(input.namespace)}/deployments/${encodeURIComponent(input.name)}/scale`;
+    const oldObject = this.record(await this.jsonCommand(["get", "--raw", endpoint]));
+    const object = {
+      ...oldObject,
+      spec: { ...this.record(oldObject.spec), replicas: input.replicas }
+    };
+    return this.build({
+      object,
+      oldObject,
+      apiGroup: "apps",
+      apiVersion: "v1",
+      kind: "Scale",
+      resource: "deployments",
+      subresource: "scale",
+      namespace: input.namespace,
+      name: input.name,
+      source: "mcp:k8s_scale",
+      executionEndpoint: endpoint
+    });
+  }
+  build(input) {
+    const capturedAt = this.now();
+    const proposedObjectDigest = hashKubernetesObject(input.object);
+    if (!proposedObjectDigest) throw new Error("KUBERNETES_OBJECT_DIGEST_MISSING");
+    const oldObjectDigest = hashKubernetesObject(input.oldObject);
+    const materialDiff = summarizeKubernetesObjectDiff(
+      input.oldObject,
+      input.object,
+      input.kind === "Secret"
+    );
+    const materialFacts = deriveKubernetesMaterialFacts({
+      object: input.object,
+      oldObject: input.oldObject,
+      kind: input.kind,
+      apiGroup: input.apiGroup,
+      resource: input.resource
+    });
+    const operation = input.oldObject ? "UPDATE" : "CREATE";
+    const request = bindKubernetesAuthorityAction({
+      organizationId: this.config.organizationId,
+      clusterId: this.config.clusterId,
+      policyVersion: this.config.policyVersion,
+      policyRule: "mcp-client-gate",
+      mode: "ENFORCEMENT",
+      intentId: this.createId(),
+      capturedAt: capturedAt.toISOString(),
+      expiresAt: new Date(capturedAt.valueOf() + this.config.grantTtlSeconds * 1e3).toISOString(),
+      actor: {
+        id: this.config.actorId,
+        type: "KUBERNETES_CLIENT",
+        runtime: "mcp",
+        trust_level: "MCP_CONFIGURED"
+      },
+      operation,
+      apiGroup: input.apiGroup,
+      apiVersion: input.apiVersion,
+      kind: input.kind,
+      resource: input.resource,
+      subresource: input.subresource,
+      namespace: input.namespace,
+      name: input.name,
+      oldObjectDigest,
+      proposedObjectDigest,
+      materialDiff,
+      materialFacts,
+      requestSource: input.source
+    });
+    return {
+      request,
+      operation,
+      apiGroup: input.apiGroup,
+      apiVersion: input.apiVersion,
+      kind: input.kind,
+      resource: input.resource,
+      namespace: input.namespace,
+      name: input.name,
+      oldObjectDigest,
+      proposedObjectDigest,
+      materialDiff,
+      materialFacts,
+      executionObject: input.object,
+      executionEndpoint: input.executionEndpoint ?? null
+    };
+  }
+  async resourceName(apiGroup, apiVersion, kind) {
+    const key = `${apiGroup}/${apiVersion}`;
+    let resources = this.discoveryCache.get(key);
+    if (!resources) {
+      const endpoint = apiGroup ? `/apis/${encodeURIComponent(apiGroup)}/${encodeURIComponent(apiVersion)}` : `/api/${encodeURIComponent(apiVersion)}`;
+      const discovery = this.record(await this.jsonCommand(["get", "--raw", endpoint]));
+      resources = Array.isArray(discovery.resources) ? discovery.resources.flatMap((candidate) => {
+        const value = this.record(candidate);
+        return typeof value.name === "string" && typeof value.kind === "string" && !value.name.includes("/") ? [{ name: value.name, kind: value.kind }] : [];
+      }) : [];
+      this.discoveryCache.set(key, resources);
+    }
+    const matched = resources.find((candidate) => candidate.kind === kind);
+    if (!matched) throw new Error("KUBERNETES_RESOURCE_DISCOVERY_FAILED");
+    return matched.name;
+  }
+  identity(object, fallbackNamespace) {
+    const apiVersionValue = typeof object.apiVersion === "string" ? object.apiVersion : "";
+    const kind = typeof object.kind === "string" ? object.kind : "";
+    const metadata = this.record(object.metadata);
+    const name = typeof metadata.name === "string" ? metadata.name : "";
+    if (!apiVersionValue || !kind || !name) throw new Error("KUBERNETES_OBJECT_IDENTITY_INVALID");
+    const separator = apiVersionValue.indexOf("/");
+    const apiGroup = separator < 0 ? "" : apiVersionValue.slice(0, separator);
+    const apiVersion = separator < 0 ? apiVersionValue : apiVersionValue.slice(separator + 1);
+    const objectNamespace = typeof metadata.namespace === "string" ? metadata.namespace : null;
+    return { apiGroup, apiVersion, kind, namespace: objectNamespace ?? fallbackNamespace, name };
+  }
+  sameIdentity(object, expected) {
+    const actual = this.identity(object, expected.namespace);
+    return actual.apiGroup === expected.apiGroup && actual.apiVersion === expected.apiVersion && actual.kind === expected.kind && actual.namespace === expected.namespace && actual.name === expected.name;
+  }
+  async jsonCommand(args) {
+    const output = await this.runner.run(args);
+    if (Buffer.byteLength(output, "utf8") > 4 * 1024 * 1024) {
+      throw new Error("KUBERNETES_COMMAND_OUTPUT_TOO_LARGE");
+    }
+    try {
+      return JSON.parse(output);
+    } catch {
+      throw new Error("KUBERNETES_COMMAND_OUTPUT_INVALID");
+    }
+  }
+  objects(input) {
+    const value = this.record(input);
+    if (value.kind === "List" && Array.isArray(value.items)) {
+      return value.items.map((item) => this.record(item)).filter((item) => Object.keys(item).length > 0);
+    }
+    return Object.keys(value).length > 0 ? [value] : [];
+  }
+  record(input) {
+    return input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  }
+};
+
+// src/kubernetes/KubernetesCommandRunner.ts
+import { spawn } from "child_process";
+var KubectlCommandError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "KubectlCommandError";
+  }
+};
+var KubectlCommandRunner = class {
+  constructor(context, timeoutMs = 1e4) {
+    this.context = context;
+    this.timeoutMs = timeoutMs;
+  }
+  run(args, standardInput) {
+    if (standardInput && Buffer.byteLength(standardInput, "utf8") > 4 * 1024 * 1024) {
+      return Promise.reject(new KubectlCommandError("KUBECTL_STANDARD_INPUT_TOO_LARGE"));
+    }
+    const fullArgs = this.context ? ["--context", this.context, ...args] : args;
+    return new Promise((resolve, reject) => {
+      const child = spawn("kubectl", fullArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+      const chunks = [];
+      let outputBytes = 0;
+      let settled = false;
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        callback();
+      };
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish(() => reject(new KubectlCommandError("KUBECTL_COMMAND_TIMEOUT")));
+      }, this.timeoutMs);
+      child.stdout.on("data", (chunk) => {
+        outputBytes += chunk.length;
+        if (outputBytes > 4 * 1024 * 1024) {
+          child.kill("SIGKILL");
+          finish(() => reject(new KubectlCommandError("KUBECTL_COMMAND_OUTPUT_TOO_LARGE")));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      child.stderr.resume();
+      child.on("error", () => {
+        finish(() => reject(new KubectlCommandError("KUBECTL_COMMAND_FAILED")));
+      });
+      child.on("close", (code) => {
+        finish(() => {
+          if (code !== 0) {
+            reject(new KubectlCommandError("KUBECTL_COMMAND_FAILED"));
+            return;
+          }
+          resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+      });
+      child.stdin.on("error", () => void 0);
+      child.stdin.end(standardInput);
+    });
+  }
+};
+
+// ../../packages/dossier-verify/src/canonical.ts
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalize(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record2 = value;
+  const sortedKeys = Object.keys(record2).sort();
+  const normalized = {};
+  for (const key of sortedKeys) {
+    normalized[key] = canonicalize(record2[key]);
+  }
+  return normalized;
+}
+function stableJsonStringify2(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function jcsCanonicalize(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "string") {
+    assertUnicodeScalarString(value);
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("JCS_NUMBER_MUST_BE_FINITE");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => jcsCanonicalize(item)).join(",")}]`;
+  if (!value || typeof value !== "object") throw new TypeError("JCS_VALUE_NOT_JSON");
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("JCS_OBJECT_MUST_BE_PLAIN");
+  }
+  const record2 = value;
+  return `{${Object.keys(record2).sort().map((key) => {
+    assertUnicodeScalarString(key);
+    if (record2[key] === void 0) throw new TypeError("JCS_UNDEFINED_NOT_ALLOWED");
+    return `${JSON.stringify(key)}:${jcsCanonicalize(record2[key])}`;
+  }).join(",")}}`;
+}
+function assertUnicodeScalarString(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) throw new TypeError("JCS_LONE_SURROGATE");
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      throw new TypeError("JCS_LONE_SURROGATE");
+    }
+  }
+}
+
+// ../../packages/dossier-verify/src/verify.ts
+import { createHash as createHash3, createPublicKey, verify as verifyEd25519 } from "crypto";
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function resolveJsonPointer(root, pointer2) {
+  if (!pointer2.startsWith("/")) return void 0;
+  return pointer2.split("/").slice(1).reduce((current, rawSegment) => {
+    const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (current && typeof current === "object" && !Array.isArray(current)) {
+      return current[segment];
+    }
+    return void 0;
+  }, root);
+}
+function findJwk(jwks, keyIds) {
+  const wanted = new Set(keyIds.filter((keyId) => keyId.trim().length > 0));
+  if (!jwks || wanted.size === 0) return null;
+  for (const key of jwks.keys) {
+    if (asString(key.kty) === "OKP" && asString(key.crv) === "Ed25519" && wanted.has(asString(key.kid) ?? "")) {
+      return key;
+    }
+  }
+  return null;
+}
+function parseProofBundle(value) {
+  const record2 = asRecord(value);
+  if (asString(record2.bundle_type) !== "decionis.decision_dossier.proof_bundle" || asString(record2.version) !== "2.0" && asString(record2.version) !== "2.1" || asString(record2.issued_at) == null || asString(record2.key_id) == null) {
+    return null;
+  }
+  const rotationPolicyRecord = asRecord(record2.rotation_policy);
+  const activeKeyId = asString(rotationPolicyRecord.active_key_id);
+  const publicJwksPath = asString(rotationPolicyRecord.public_jwks_path);
+  if (!activeKeyId || !publicJwksPath) return null;
+  const artifacts = (Array.isArray(record2.artifacts) ? record2.artifacts : []).map((entry) => {
+    const item = asRecord(entry);
+    const artifactKind = asString(item.artifact_kind);
+    const mediaType = asString(item.media_type);
+    const documentPath = asString(item.document_path);
+    const canonicalDocumentSha = asString(item.canonical_document_sha256);
+    const signature = asString(item.signature);
+    const canonicalizationProfile = asString(item.canonicalization_profile);
+    if (!artifactKind || !mediaType || !documentPath || !canonicalDocumentSha || !signature) {
+      return null;
+    }
+    return {
+      artifact_kind: artifactKind,
+      media_type: mediaType,
+      document_path: documentPath,
+      canonical_document_sha256: canonicalDocumentSha,
+      ...canonicalizationProfile === "RFC8785/JCS" || canonicalizationProfile === "DECIONIS_SORTED_JSON_V1" ? { canonicalization_profile: canonicalizationProfile } : {},
+      signature
+    };
+  }).filter((item) => item !== null);
+  if (artifacts.length === 0) return null;
+  const previousKeyIds = (Array.isArray(rotationPolicyRecord.previous_key_ids) ? rotationPolicyRecord.previous_key_ids : []).map((entry) => asString(entry)).filter((entry) => entry !== null);
+  const gracePeriod = Number.parseInt(
+    String(rotationPolicyRecord.verification_grace_period_days ?? ""),
+    10
+  );
+  return {
+    bundle_type: "decionis.decision_dossier.proof_bundle",
+    version: asString(record2.version),
+    issued_at: asString(record2.issued_at),
+    algorithm: "Ed25519",
+    key_id: asString(record2.key_id),
+    rotation_policy: {
+      strategy: asString(rotationPolicyRecord.strategy) ?? "JWKS_OVERLAP",
+      active_key_id: activeKeyId,
+      previous_key_ids: previousKeyIds,
+      verification_grace_period_days: Number.isFinite(gracePeriod) ? gracePeriod : 0,
+      rotated_at: asString(rotationPolicyRecord.rotated_at),
+      public_jwks_path: publicJwksPath,
+      public_jwks_url: asString(rotationPolicyRecord.public_jwks_url) ?? void 0
+    },
+    artifacts
+  };
+}
+function verifyDossierProofBundle(input) {
+  const integrity = asRecord(input.dossier_payload.integrity);
+  const bundle = parseProofBundle(integrity.proof_bundle);
+  if (!bundle) {
+    return {
+      verified: false,
+      available: false,
+      key_id: null,
+      artifacts_checked: 0,
+      checks: [
+        {
+          key: "proof_bundle",
+          label: "Proof Bundle",
+          verified: false,
+          severity: "warn",
+          detail: "No persisted Ed25519 proof bundle was available for verification."
+        }
+      ]
+    };
+  }
+  const jwk = findJwk(input.public_jwks ?? null, [
+    bundle.key_id,
+    bundle.rotation_policy.active_key_id,
+    ...bundle.rotation_policy.previous_key_ids
+  ]);
+  if (!jwk) {
+    return {
+      verified: false,
+      available: true,
+      key_id: bundle.key_id,
+      artifacts_checked: 0,
+      checks: [
+        {
+          key: "public_key",
+          label: "Public Key",
+          verified: false,
+          severity: "fail",
+          detail: `No Ed25519 public key matched proof bundle key ${bundle.key_id}.`
+        }
+      ]
+    };
+  }
+  let publicKey;
+  try {
+    publicKey = createPublicKey({ key: jwk, format: "jwk" });
+  } catch (err) {
+    return {
+      verified: false,
+      available: true,
+      key_id: bundle.key_id,
+      artifacts_checked: 0,
+      checks: [
+        {
+          key: "public_key",
+          label: "Public Key",
+          verified: false,
+          severity: "fail",
+          detail: err instanceof Error ? err.message : "Unable to import Ed25519 public key."
+        }
+      ]
+    };
+  }
+  const checks = [
+    {
+      key: "public_key",
+      label: "Public Key",
+      verified: true,
+      severity: "pass",
+      detail: `Loaded Ed25519 public key ${String(jwk.kid ?? bundle.key_id)}.`
+    }
+  ];
+  let artifactsChecked = 0;
+  for (const artifact of bundle.artifacts) {
+    const document = resolveJsonPointer(input.dossier_payload, artifact.document_path);
+    if (document === void 0) {
+      checks.push({
+        key: `${artifact.artifact_kind}:document`,
+        label: `${artifact.artifact_kind} Document`,
+        verified: false,
+        severity: "fail",
+        detail: `Signed document path ${artifact.document_path} was not present in the dossier payload.`
+      });
+      continue;
+    }
+    const canonicalDocument = artifact.canonicalization_profile === "RFC8785/JCS" ? jcsCanonicalize(document) : stableJsonStringify2(document);
+    const actualSha = createHash3("sha256").update(canonicalDocument, "utf8").digest("hex");
+    const hashVerified = actualSha.toLowerCase() === artifact.canonical_document_sha256.toLowerCase();
+    checks.push({
+      key: `${artifact.artifact_kind}:sha256`,
+      label: `${artifact.artifact_kind} SHA-256`,
+      verified: hashVerified,
+      severity: hashVerified ? "pass" : "fail",
+      detail: hashVerified ? `Canonical digest ${actualSha}.` : `Expected ${artifact.canonical_document_sha256}, computed ${actualSha}.`
+    });
+    let signatureVerified = false;
+    try {
+      signatureVerified = verifyEd25519(
+        null,
+        Buffer.from(canonicalDocument, "utf8"),
+        publicKey,
+        Buffer.from(artifact.signature, "base64url")
+      );
+    } catch {
+      signatureVerified = false;
+    }
+    checks.push({
+      key: `${artifact.artifact_kind}:signature`,
+      label: `${artifact.artifact_kind} Signature`,
+      verified: signatureVerified,
+      severity: signatureVerified ? "pass" : "fail",
+      detail: signatureVerified ? "Ed25519 signature verified against the public JWKS." : "Ed25519 signature did not verify against the public JWKS."
+    });
+    artifactsChecked += 1;
+  }
+  return {
+    verified: checks.every((check) => check.verified),
+    available: true,
+    key_id: bundle.key_id,
+    artifacts_checked: artifactsChecked,
+    checks
+  };
+}
+
+// ../../packages/dossier-verify/src/resolve.ts
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function extractDossierPayload(body) {
+  const record2 = asRecord2(body);
+  if (asRecord2(record2.integrity).proof_bundle !== void 0) return record2;
+  for (const key of ["dossier", "dossier_payload", "data", "result"]) {
+    const candidate = asRecord2(record2[key]);
+    if (asRecord2(candidate.integrity).proof_bundle !== void 0) return candidate;
+  }
+  return record2;
+}
+function resolveJwksUrl(payload, dossierUrl) {
+  const bundle = parseProofBundle(asRecord2(payload.integrity).proof_bundle);
+  if (!bundle) return null;
+  const absolute = bundle.rotation_policy.public_jwks_url;
+  if (absolute && /^https?:\/\//i.test(absolute)) return absolute;
+  try {
+    return new URL(bundle.rotation_policy.public_jwks_path, dossierUrl).toString();
+  } catch {
+    return null;
+  }
+}
+var MAX_VERIFICATION_RESPONSE_BYTES = 2 * 1024 * 1024;
+async function fetchJson(url, fetchImpl) {
+  const response = await fetchImpl(url, { headers: { accept: "application/json" } });
+  if (!response.ok) {
+    throw new Error(`Request to ${url} failed with HTTP ${response.status}.`);
+  }
+  const responseText = await boundedResponseText(response, url);
+  return JSON.parse(responseText);
+}
+async function boundedResponseText(response, url) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_VERIFICATION_RESPONSE_BYTES) {
+    throw new Error(`Response from ${url} exceeded the verification size limit.`);
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let receivedBytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    receivedBytes += value.byteLength;
+    if (receivedBytes > MAX_VERIFICATION_RESPONSE_BYTES) {
+      await reader.cancel().catch(() => void 0);
+      throw new Error(`Response from ${url} exceeded the verification size limit.`);
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(
+    chunks.map((chunk) => Buffer.from(chunk)),
+    receivedBytes
+  ).toString("utf8");
+}
+async function verifyDossierFromUrls(input) {
+  const fetchImpl = input.fetch ?? fetch;
+  const body = await fetchJson(input.dossierUrl, fetchImpl);
+  const payload = extractDossierPayload(body);
+  const jwksUrl = input.jwksUrl ?? resolveJwksUrl(payload, input.dossierUrl);
+  if (!jwksUrl) {
+    return {
+      result: verifyDossierProofBundle({ dossier_payload: payload, public_jwks: null }),
+      jwksUrl: null,
+      payload
+    };
+  }
+  const jwks = await fetchJson(jwksUrl, fetchImpl);
+  return {
+    result: verifyDossierProofBundle({ dossier_payload: payload, public_jwks: jwks }),
+    jwksUrl,
+    payload
+  };
+}
+
+// src/kubernetes/KubernetesOperations.ts
+var KubernetesOperations = class _KubernetesOperations {
+  constructor(planner, runner, authority, allowedVerificationOrigins) {
+    this.planner = planner;
+    this.runner = runner;
+    this.authority = authority;
+    this.allowedVerificationOrigins = allowedVerificationOrigins;
+  }
+  async plan(manifestPath, namespace) {
+    return this.planSummary(
+      await this.planner.planManifest(manifestPath, namespace, "mcp:k8s_plan")
+    );
+  }
+  async requestAuthority(manifestPath, namespace) {
+    const planned = await this.planner.planManifest(
+      manifestPath,
+      namespace,
+      "mcp:k8s_request_authority"
+    );
+    const decisions = await Promise.all(
+      planned.map(async (action) => this.authority.enforceAndBind(action.request))
+    );
+    return decisions.map((decision, index) => this.decisionSummary(decision, planned[index]));
+  }
+  async apply(manifestPath, namespace) {
+    const planned = await this.planner.planManifest(manifestPath, namespace, "mcp:k8s_apply");
+    return this.authorizeAndExecute(planned, async () => {
+      const args = ["apply", "--filename", "-"];
+      if (namespace) args.push("--namespace", namespace);
+      return this.runner.run(args, _KubernetesOperations.executionManifest(planned));
+    });
+  }
+  async rollback(manifestPath, namespace) {
+    const planned = await this.planner.planManifest(manifestPath, namespace, "mcp:k8s_rollback");
+    if (planned.some((action) => action.operation !== "UPDATE")) {
+      return {
+        executed: false,
+        verdict: "ERROR",
+        decisions: [],
+        reason_code: "KUBERNETES_ROLLBACK_TARGET_NOT_FOUND"
+      };
+    }
+    return this.authorizeAndExecute(planned, async () => {
+      const args = ["apply", "--filename", "-"];
+      if (namespace) args.push("--namespace", namespace);
+      return this.runner.run(args, _KubernetesOperations.executionManifest(planned));
+    });
+  }
+  async scale(input) {
+    const planned = await this.planner.planScale(input);
+    if (!planned.executionEndpoint) throw new Error("KUBERNETES_SCALE_ENDPOINT_MISSING");
+    return this.authorizeAndExecute(
+      [planned],
+      () => this.runner.run(
+        ["replace", "--raw", planned.executionEndpoint, "--filename", "-"],
+        JSON.stringify(planned.executionObject)
+      )
+    );
+  }
+  async verifyDossier(dossierUrl, jwksUrl) {
+    this.assertAllowedVerificationUrl(dossierUrl);
+    this.assertAllowedVerificationUrl(jwksUrl);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const verified = await verifyDossierFromUrls({
+        dossierUrl,
+        jwksUrl,
+        fetch: (input, init) => fetch(input, { ...init, redirect: "error", signal: controller.signal })
+      });
+      return {
+        verified: verified.result.verified,
+        available: verified.result.available,
+        key_id: verified.result.key_id,
+        artifacts_checked: verified.result.artifacts_checked,
+        checks: verified.result.checks,
+        jwks_url: verified.jwksUrl
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async authorizeAndExecute(planned, execute) {
+    const decisions = [];
+    for (const action of planned) {
+      try {
+        decisions.push(await this.authority.enforceAndBind(action.request));
+      } catch {
+        return {
+          executed: false,
+          verdict: "ERROR",
+          decisions: decisions.map(
+            (decision, index) => this.decisionSummary(decision, planned[index])
+          ),
+          reason_code: "DECIONIS_AUTHORITY_UNAVAILABLE"
+        };
+      }
+    }
+    const summaries = decisions.map(
+      (decision, index) => this.decisionSummary(decision, planned[index])
+    );
+    const deniedIndex = decisions.findIndex(
+      (decision, index) => decision.status !== "ALLOW" || !decision.should_execute || !decision.execution_token || decision.mode !== "ENFORCEMENT" || decision.action_hash !== planned[index]?.request.intent_hash || !decision.dossier_id || !decision.dossier_sha256
+    );
+    if (deniedIndex >= 0) {
+      const decision = decisions[deniedIndex];
+      return {
+        executed: false,
+        verdict: _KubernetesOperations.verdict(decision),
+        decisions: summaries,
+        reason_code: decision.reason_codes[0] ?? "DECIONIS_EXECUTION_NOT_AUTHORIZED"
+      };
+    }
+    for (let index = 0; index < decisions.length; index += 1) {
+      const decision = decisions[index];
+      const action = planned[index];
+      const redemption = await this.authority.redeemGrant(
+        decision.execution_token,
+        action.request,
+        decision
+      );
+      if (!redemption.valid) {
+        return {
+          executed: false,
+          verdict: "ERROR",
+          decisions: summaries,
+          reason_code: redemption.reason_codes[0] ?? "DECIONIS_EXECUTION_GRANT_INVALID"
+        };
+      }
+    }
+    try {
+      return {
+        executed: true,
+        verdict: "ALLOW",
+        decisions: summaries,
+        kubernetes_result: (await execute()).trim().slice(0, 8e3)
+      };
+    } catch {
+      return {
+        executed: false,
+        verdict: "ERROR",
+        decisions: summaries,
+        reason_code: "KUBERNETES_EXECUTION_FAILED_FRESH_AUTHORITY_REQUIRED"
+      };
+    }
+  }
+  planSummary(planned) {
+    return planned.map((action) => ({
+      action_hash: action.request.intent_hash,
+      action_type: action.request.action.type,
+      operation: action.operation,
+      api_group: action.apiGroup,
+      api_version: action.apiVersion,
+      kind: action.kind,
+      resource: action.resource,
+      namespace: action.namespace,
+      name: action.name,
+      old_object_digest: action.oldObjectDigest,
+      proposed_object_digest: action.proposedObjectDigest,
+      material_diff: action.materialDiff,
+      material_facts: action.materialFacts,
+      note: "No raw manifest or Secret value is included in this plan."
+    }));
+  }
+  decisionSummary(decision, action) {
+    return {
+      verdict: _KubernetesOperations.verdict(decision),
+      decision_id: decision.decision_id,
+      dossier_id: decision.dossier_id,
+      dossier_sha256: decision.dossier_sha256,
+      dossier_url: decision.dossier_url,
+      policy_version: decision.policy_version,
+      approval_request_id: decision.approval_request_id,
+      reason_codes: decision.reason_codes,
+      action_hash: decision.action_hash,
+      expected_action_hash: action.request.intent_hash,
+      resource: action.resource,
+      namespace: action.namespace,
+      name: action.name
+    };
+  }
+  static verdict(decision) {
+    if (decision.status === "ALLOW") return "ALLOW";
+    if (decision.status === "ESCALATE" || decision.status === "REVIEW_REQUIRED") return "HOLD";
+    if (decision.status === "BLOCK") return "BLOCK";
+    return "ERROR";
+  }
+  static executionManifest(planned) {
+    if (planned.length === 1) return JSON.stringify(planned[0].executionObject);
+    return JSON.stringify({
+      apiVersion: "v1",
+      kind: "List",
+      items: planned.map((action) => action.executionObject)
+    });
+  }
+  assertAllowedVerificationUrl(input) {
+    const url = new URL(input);
+    if (url.protocol !== "https:" || url.username || url.password || !this.allowedVerificationOrigins.has(url.origin)) {
+      throw new Error("DOSSIER_URL_ORIGIN_NOT_ALLOWED");
+    }
+  }
+};
+function createKubernetesAuthorityClient(input) {
+  return createDecionisExecutionClient({
+    authorityBaseUrl: input.baseUrl,
+    timeoutMs: input.timeoutMs,
+    defaultHeaders: { authorization: `Bearer ${input.apiKey}` }
+  });
+}
+
+// src/kubernetes/KubernetesMcpTools.ts
+var text2 = (value) => [
+  { type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }
+];
+var KubernetesMcpTools = class _KubernetesMcpTools {
+  constructor(operations) {
+    this.operations = operations;
+  }
+  build() {
+    const manifestSchema = {
+      type: "object",
+      required: ["manifest_path"],
+      properties: {
+        manifest_path: {
+          type: "string",
+          description: "Local path to the exact Kubernetes manifest. Manifest content is never returned."
+        },
+        namespace: { type: "string", description: "Optional namespace fallback." }
+      },
+      additionalProperties: false
+    };
+    return [
+      {
+        name: "k8s_plan",
+        title: "Plan Exact Kubernetes Actions",
+        description: "Resolve an exact manifest against the current cluster and return only digests, bounded material facts, and action hashes. Does not call authority or mutate Kubernetes.",
+        inputSchema: manifestSchema,
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: true
+        },
+        handler: async (args) => ({
+          content: text2(
+            await this.operations.plan(
+              _KubernetesMcpTools.requiredString(args.manifest_path, "manifest_path"),
+              _KubernetesMcpTools.optionalNamespace(args.namespace)
+            )
+          )
+        })
+      },
+      {
+        name: "k8s_request_authority",
+        title: "Request Kubernetes Execution Authority",
+        description: "Ask the existing Decionis authority for ALLOW, HOLD, or BLOCK on each exact manifest action and return dossier references. Does not run kubectl apply.",
+        inputSchema: manifestSchema,
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: false,
+          openWorldHint: true
+        },
+        handler: async (args) => ({
+          content: text2(
+            await this.operations.requestAuthority(
+              _KubernetesMcpTools.requiredString(args.manifest_path, "manifest_path"),
+              _KubernetesMcpTools.optionalNamespace(args.namespace)
+            )
+          )
+        })
+      },
+      {
+        name: "k8s_apply",
+        title: "Apply an Authorized Kubernetes Manifest",
+        description: "Recompute the exact action, require and consume a Decionis ALLOW grant, then run kubectl apply. The admission webhook remains the independent cluster-side gate.",
+        inputSchema: manifestSchema,
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: true,
+          idempotentHint: false,
+          openWorldHint: true
+        },
+        handler: async (args) => ({
+          content: text2(
+            await this.operations.apply(
+              _KubernetesMcpTools.requiredString(args.manifest_path, "manifest_path"),
+              _KubernetesMcpTools.optionalNamespace(args.namespace)
+            )
+          )
+        })
+      },
+      {
+        name: "k8s_scale",
+        title: "Scale an Authorized Kubernetes Deployment",
+        description: "Bind the exact Deployment scale object and replica count, require and consume a Decionis ALLOW grant, then run kubectl scale. Scale-to-zero is visible as a material fact.",
+        inputSchema: {
+          type: "object",
+          required: ["namespace", "name", "replicas"],
+          properties: {
+            namespace: { type: "string" },
+            name: { type: "string" },
+            replicas: { type: "integer", minimum: 0, maximum: 1e6 }
+          },
+          additionalProperties: false
+        },
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: true,
+          idempotentHint: false,
+          openWorldHint: true
+        },
+        handler: async (args) => ({
+          content: text2(
+            await this.operations.scale({
+              namespace: _KubernetesMcpTools.requiredDnsName(args.namespace, "namespace"),
+              name: _KubernetesMcpTools.requiredDnsName(args.name, "name"),
+              replicas: _KubernetesMcpTools.requiredInteger(args.replicas, "replicas")
+            })
+          )
+        })
+      },
+      {
+        name: "k8s_rollback",
+        title: "Apply an Exact Authorized Rollback",
+        description: "Apply an operator-supplied exact rollback manifest only when the target already exists and Decionis grants the bound UPDATE. Vague rollout undo is intentionally not used.",
+        inputSchema: manifestSchema,
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: true,
+          idempotentHint: false,
+          openWorldHint: true
+        },
+        handler: async (args) => ({
+          content: text2(
+            await this.operations.rollback(
+              _KubernetesMcpTools.requiredString(args.manifest_path, "manifest_path"),
+              _KubernetesMcpTools.optionalNamespace(args.namespace)
+            )
+          )
+        })
+      },
+      {
+        name: "k8s_verify_dossier",
+        title: "Verify a Kubernetes Decision Dossier",
+        description: "Fetch a dossier proof bundle and JWKS from configured HTTPS origins and verify SHA-256 plus Ed25519 evidence independently.",
+        inputSchema: {
+          type: "object",
+          required: ["dossier_url", "jwks_url"],
+          properties: {
+            dossier_url: { type: "string", format: "uri" },
+            jwks_url: { type: "string", format: "uri" }
+          },
+          additionalProperties: false
+        },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: true
+        },
+        handler: async (args) => ({
+          content: text2(
+            await this.operations.verifyDossier(
+              _KubernetesMcpTools.requiredString(args.dossier_url, "dossier_url"),
+              _KubernetesMcpTools.requiredString(args.jwks_url, "jwks_url")
+            )
+          )
+        })
       }
     ];
   }
+  static requiredString(input, field) {
+    if (typeof input !== "string" || !input.trim())
+      throw new Error(`${field.toUpperCase()}_REQUIRED`);
+    return input.trim();
+  }
+  static optionalNamespace(input) {
+    if (input === void 0) return null;
+    return _KubernetesMcpTools.requiredDnsName(input, "namespace");
+  }
+  static requiredDnsName(input, field) {
+    const value = _KubernetesMcpTools.requiredString(input, field);
+    if (!/^[a-z0-9](?:[-a-z0-9.]*[a-z0-9])?$/.test(value) || value.length > 253) {
+      throw new Error(`${field.toUpperCase()}_INVALID`);
+    }
+    return value;
+  }
+  static requiredInteger(input, field) {
+    if (!Number.isInteger(input)) throw new Error(`${field.toUpperCase()}_INVALID`);
+    return input;
+  }
 };
-function createDecionisTools(gateway2) {
-  return new DecionisTools(gateway2).build();
+function createKubernetesMcpToolsFromEnvironment(environment = process.env) {
+  if (environment.DECIONIS_KUBERNETES_TOOLS_ENABLED !== "true") return [];
+  const baseUrl = requiredEnvironment(environment, "DECIONIS_AUTHORITY_BASE_URL");
+  const apiKey = requiredEnvironment(environment, "DECIONIS_API_KEY");
+  const organizationId = requiredEnvironment(environment, "DECIONIS_ORG_ID");
+  const clusterId = requiredEnvironment(environment, "DECIONIS_KUBERNETES_CLUSTER_ID");
+  const actorId = requiredEnvironment(environment, "DECIONIS_KUBERNETES_ACTOR");
+  const policyVersion = requiredEnvironment(environment, "DECIONIS_KUBERNETES_POLICY_VERSION");
+  const context = environment.DECIONIS_KUBERNETES_CONTEXT?.trim() || null;
+  const timeoutMs = boundedInteger(environment.DECIONIS_KUBERNETES_TIMEOUT_MS, 4e3, 100, 1e4);
+  const grantTtlSeconds = boundedInteger(
+    environment.DECIONIS_KUBERNETES_GRANT_TTL_SECONDS,
+    60,
+    1,
+    300
+  );
+  const authorityOrigin = new URL(baseUrl).origin;
+  const allowedVerificationOrigins = /* @__PURE__ */ new Set([
+    authorityOrigin,
+    ...(environment.DECIONIS_KUBERNETES_VERIFICATION_ORIGINS ?? "").split(",").map((value) => value.trim()).filter(Boolean).map((value) => new URL(value).origin)
+  ]);
+  const runner = new KubectlCommandRunner(context, timeoutMs);
+  const planner = new KubernetesActionPlanner(
+    { organizationId, clusterId, actorId, policyVersion, grantTtlSeconds },
+    runner
+  );
+  const operations = new KubernetesOperations(
+    planner,
+    runner,
+    createKubernetesAuthorityClient({ baseUrl, apiKey, timeoutMs }),
+    allowedVerificationOrigins
+  );
+  return new KubernetesMcpTools(operations).build();
+}
+function requiredEnvironment(environment, name) {
+  const value = environment[name]?.trim();
+  if (!value) throw new Error(`${name}_REQUIRED`);
+  return value;
+}
+function boundedInteger(input, fallback, minimum, maximum) {
+  const value = input === void 0 ? fallback : Number(input);
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error("DECIONIS_KUBERNETES_NUMERIC_CONFIGURATION_INVALID");
+  }
+  return value;
+}
+
+// src/ShieldClient.ts
+var ShieldClient = class {
+  baseUrl;
+  apiKey;
+  appId;
+  fetchImpl;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? process.env.DECIONIS_SHIELD_API_URL ?? "https://api.decionis.com").replace(/\/+$/, "");
+    this.apiKey = options.apiKey ?? process.env.DECIONIS_SHIELD_API_KEY ?? "";
+    this.appId = options.appId ?? process.env.DECIONIS_SHIELD_APP_ID ?? "";
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  authorize(request) {
+    return this.json("/v1/shield/authorize", "POST", request);
+  }
+  permission() {
+    return this.json("/v1/shield/permission", "GET");
+  }
+  requestApproval(decisionId) {
+    return this.json(`/v1/shield/decisions/${encodeURIComponent(decisionId)}/approval`, "POST", {});
+  }
+  decision(decisionId) {
+    return this.json(`/v1/shield/decisions/${encodeURIComponent(decisionId)}`, "GET");
+  }
+  async json(path, method, body) {
+    if (!this.apiKey || !this.appId) {
+      throw new ShieldClientError(
+        "SHIELD_MCP_CONFIGURATION_REQUIRED",
+        "Configure DECIONIS_SHIELD_API_KEY and DECIONIS_SHIELD_APP_ID. Do not execute the transaction."
+      );
+    }
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json",
+        "x-shield-app-id": this.appId,
+        "x-shield-environment": "production"
+      },
+      ...method === "POST" ? { body: JSON.stringify(body ?? {}) } : {}
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) {
+      const server = asRecord3(payload);
+      throw new ShieldClientError(
+        typeof server.error === "string" ? server.error : "SHIELD_MCP_REQUEST_FAILED",
+        typeof server.message === "string" ? `${server.message} Do not execute the transaction.` : `Shield returned HTTP ${response.status}. Do not execute the transaction.`
+      );
+    }
+    return asRecord3(payload);
+  }
+};
+var ShieldClientError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ShieldClientError";
+  }
+};
+function asRecord3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+// src/ShieldTools.ts
+var text3 = (value) => [
+  { type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }
+];
+var purchaseProperties = {
+  amount: { type: "number", minimum: 0, description: "Amount in major currency units." },
+  currency: {
+    type: "string",
+    pattern: "^[A-Za-z]{3}$",
+    description: "ISO 4217 currency code."
+  },
+  purpose: {
+    type: "string",
+    minLength: 1,
+    description: "Clear user-facing reason for spending."
+  },
+  merchant: { type: "string" },
+  category: { type: "string" },
+  agentId: {
+    type: "string",
+    description: "Registered agent identity, when an agent is spending."
+  },
+  transactionType: {
+    type: "string",
+    enum: ["PURCHASE", "SUBSCRIPTION", "RENEWAL", "TRANSFER", "REFUND", "OTHER"]
+  },
+  metadata: { type: "object" }
+};
+var networkMutation = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var networkRead = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function createShieldTools(shield) {
+  const authorize = async (args) => {
+    if (typeof args.amount !== "number" || typeof args.currency !== "string" || typeof args.purpose !== "string") {
+      return {
+        content: text3(
+          "amount, currency, and purpose are required. Do not execute the transaction."
+        ),
+        isError: true
+      };
+    }
+    return shieldResult(async () => await shield.authorize(args));
+  };
+  return [
+    {
+      name: "shield.request_purchase",
+      title: "Request Shield Purchase Authorization",
+      description: "Ask the user's Shield for ALLOW, ASK, or BLOCK before a purchase. Execute only on ALLOW.",
+      inputSchema: {
+        type: "object",
+        required: ["amount", "currency", "purpose"],
+        properties: purchaseProperties,
+        additionalProperties: false
+      },
+      annotations: networkMutation,
+      handler: authorize
+    },
+    {
+      name: "shield.check_spending_authority",
+      title: "Check Shield Spending Authority",
+      description: "Check spending authority for an app or AI agent before taking the consequential action.",
+      inputSchema: {
+        type: "object",
+        required: ["amount", "currency", "purpose"],
+        properties: purchaseProperties,
+        additionalProperties: false
+      },
+      annotations: networkMutation,
+      handler: authorize
+    },
+    {
+      name: "shield.get_permission",
+      title: "Get Shield Permission",
+      description: "Read the spender identity and user-owned limits bound to this Shield credential.",
+      inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      annotations: networkRead,
+      handler: async () => shieldResult(async () => await shield.permission())
+    },
+    {
+      name: "shield.request_approval",
+      title: "Request Shield Approval",
+      description: "Start or poll Presence approval for an ASK decision. Do not execute while the verdict remains ASK.",
+      inputSchema: {
+        type: "object",
+        required: ["decisionId"],
+        properties: { decisionId: { type: "string" } },
+        additionalProperties: false
+      },
+      annotations: networkMutation,
+      handler: async (args) => typeof args.decisionId === "string" ? shieldResult(async () => await shield.requestApproval(args.decisionId)) : {
+        content: text3("decisionId is required. Do not execute the transaction."),
+        isError: true
+      }
+    },
+    {
+      name: "shield.get_decision",
+      title: "Get Shield Decision",
+      description: "Retrieve the current ALLOW, ASK, or BLOCK decision and its evidence identifiers.",
+      inputSchema: {
+        type: "object",
+        required: ["decisionId"],
+        properties: { decisionId: { type: "string" } },
+        additionalProperties: false
+      },
+      annotations: networkRead,
+      handler: async (args) => typeof args.decisionId === "string" ? shieldResult(async () => await shield.decision(args.decisionId)) : {
+        content: text3("decisionId is required. Do not execute the transaction."),
+        isError: true
+      }
+    }
+  ];
+}
+async function shieldResult(work) {
+  try {
+    return { content: text3(await work()) };
+  } catch (error) {
+    return {
+      content: text3({
+        error: error instanceof Error ? error.name : "ShieldError",
+        message: error instanceof Error ? error.message : String(error),
+        safeToExecute: false
+      }),
+      isError: true
+    };
+  }
 }
 
 // src/index.ts
 var gateway = new LocalDecionisGateway();
+var shieldConfigured = Boolean(
+  process.env.DECIONIS_SHIELD_API_KEY && process.env.DECIONIS_SHIELD_APP_ID
+);
 var handler = createMcpHandler({
   serverInfo: { name: "decionis-mcp", version: MCP_SERVER_VERSION },
-  tools: createDecionisTools(gateway)
+  tools: createDecionisTools(gateway, [
+    ...createKubernetesMcpToolsFromEnvironment(),
+    ...shieldConfigured ? createShieldTools(new ShieldClient()) : []
+  ])
 });
 runStdioServer(handler).then(async () => {
   await gateway.close();