PALO technical presentation: inspected source excerpts

   1 | {
   2 |   "$schema": "https://json-schema.org/draft/2020-12/schema",
   3 |   "$id": "https://paloframework.org/schemas/palo-agentic-action-claim.schema.json",
   4 |   "title": "PALO Agentic Action Claim",
   5 |   "description": "Developer-preview interoperability contract for a proposed agent action. Schema validity is not authorization, safety evidence, legal approval, or proof of execution.",
   6 |   "type": "object",
   7 |   "required": ["format", "schemaVersion", "claimId", "agentId", "caseId", "action", "requestedScopes", "externalNetwork", "delegation", "requestedAt", "expiresAt", "nonce", "idempotencyKey", "sequenceNumber"],
   8 |   "properties": {
   9 |     "format": { "const": "palo-agentic-action-claim" },
  10 |     "schemaVersion": { "enum": ["1.1.0", "1.2.0", "1.3.0", "1.4.0"] },
  11 |     "claimId": { "type": "string", "pattern": "^claim-[a-f0-9-]{36}$" },
  12 |     "agentId": { "type": "string", "pattern": "^agent-[a-zA-Z0-9][a-zA-Z0-9-]{5,63}$" },
  13 |     "caseId": { "type": "string", "minLength": 1, "maxLength": 128 },
  14 |     "action": {
  15 |       "type": "object",
  16 |       "required": ["tool", "operation", "resource", "path", "networkIntent", "arguments", "argumentsDigest", "argumentSchemaDigest"],
  17 |       "properties": {
  18 |         "tool": { "type": "string", "minLength": 1, "maxLength": 200 },
  19 |         "operation": { "enum": ["read", "create", "update", "delete", "execute", "delegate"] },
  20 |         "resource": { "type": "string", "minLength": 1, "maxLength": 1000 },
  21 |         "path": { "type": "string", "minLength": 1, "maxLength": 1000, "pattern": "^/" },
  22 |         "networkIntent": { "enum": ["none", "read", "write", "bidirectional"] },
  23 |         "networkHost": { "type": "string", "minLength": 1, "maxLength": 253, "pattern": "^[a-z0-9.-]+$" },
  24 |         "arguments": { "type": "object", "maxProperties": 100, "additionalProperties": true },
  25 |         "argumentsDigest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
  26 |         "argumentSchemaDigest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" }
  27 |       },
  28 |       "additionalProperties": false
  29 |     },
  30 |     "requestedScopes": {
  31 |       "type": "object",
  32 |       "required": ["read", "write"],
  33 |       "properties": {
  34 |         "read": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
  35 |         "write": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } }
  36 |       },
  37 |       "additionalProperties": false
  38 |     },
  39 |     "externalNetwork": { "type": "boolean" },
  40 |     "delegation": {
  41 |       "type": "object",
  42 |       "required": ["depth", "subagentCount"],
  43 |       "properties": {
  44 |         "depth": { "type": "integer", "minimum": 0 },
  45 |         "subagentCount": { "type": "integer", "minimum": 0 },
  46 |         "parentAgentId": { "type": "string", "pattern": "^agent-[a-zA-Z0-9][a-zA-Z0-9-]{5,63}$" },
  47 |         "requestedSubagentRole": { "type": "string", "minLength": 1 }
  48 |       },
  49 |       "additionalProperties": false
  50 |     },
  51 |     "authorityContext": {
  52 |       "type": "object",
  53 |       "required": ["authorityContextId", "humanPrincipal", "workloadIdentity", "agentIdentity", "delegationChain"],
  54 |       "properties": {
  55 |         "authorityContextId": { "type": "string", "pattern": "^authority-[a-f0-9-]{36}$" },
  56 |         "humanPrincipal": {
  57 |           "type": "object",
  58 |           "required": ["subject", "issuer", "authenticatedAt", "credentialDigest"],
  59 |           "properties": {
  60 |             "subject": { "type": "string", "minLength": 1, "maxLength": 512 },
  61 |             "issuer": { "type": "string", "format": "uri", "maxLength": 1000 },
  62 |             "authenticatedAt": { "type": "string", "format": "date-time" },
  63 |             "credentialDigest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
  64 |             "proofReference": { "type": "string", "format": "uri", "maxLength": 2000 }
  65 |           },
  66 |           "additionalProperties": false
  67 |         },
  68 |         "workloadIdentity": {
  69 |           "type": "object",
  70 |           "required": ["subject", "issuer", "audience", "proofType", "credentialDigest"],
  71 |           "properties": {
  72 |             "subject": { "type": "string", "minLength": 1, "maxLength": 1000 },
  73 |             "issuer": { "type": "string", "format": "uri", "maxLength": 1000 },
  74 |             "audience": { "type": "string", "minLength": 1, "maxLength": 1000 },
  75 |             "proofType": { "enum": ["mtls", "dpop", "http-message-signature", "spiffe-svid"] },
  76 |             "credentialDigest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
  77 |             "proofReference": { "type": "string", "format": "uri", "maxLength": 2000 }
  78 |           },
  79 |           "additionalProperties": false
  80 |         },
  81 |         "agentIdentity": {
  82 |           "type": "object",
  83 |           "required": ["agentId", "instanceId"],
  84 |           "properties": {
  85 |             "agentId": { "type": "string", "pattern": "^agent-[a-zA-Z0-9][a-zA-Z0-9-]{5,63}$" },
  86 |             "instanceId": { "type": "string", "minLength": 1, "maxLength": 256 }
  87 |           },
  88 |           "additionalProperties": false
  89 |         },
  90 |         "tenantId": { "type": "string", "minLength": 1, "maxLength": 128 },
  91 |         "delegationChain": {
  92 |           "type": "array",
  93 |           "maxItems": 16,
  94 |           "items": {
  95 |             "type": "object",
  96 |             "required": ["delegationId", "from", "to", "scopes", "issuedAt", "expiresAt"],
  97 |             "properties": {
  98 |               "delegationId": { "type": "string", "pattern": "^delegation-[a-f0-9-]{36}$" },
  99 |               "from": { "type": "string", "minLength": 1, "maxLength": 1000 },
 100 |               "to": { "type": "string", "minLength": 1, "maxLength": 1000 },
 101 |               "scopes": {
 102 |                 "type": "object",
 103 |                 "required": ["read", "write"],
 104 |                 "properties": {
 105 |                   "read": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
 106 |                   "write": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } }
 107 |                 },
 108 |                 "additionalProperties": false
 109 |               },
 110 |               "issuedAt": { "type": "string", "format": "date-time" },
 111 |               "expiresAt": { "type": "string", "format": "date-time" }
 112 |             },
 113 |             "additionalProperties": false
 114 |           }
 115 |         }
 116 |       },
 117 |       "additionalProperties": false
 118 |     },
 119 |     "requestedAt": { "type": "string", "format": "date-time" },
 120 |     "expiresAt": { "type": "string", "format": "date-time" },
 121 |     "nonce": { "type": "string", "pattern": "^[a-zA-Z0-9_-]{16,128}$" },
 122 |     "idempotencyKey": { "type": "string", "pattern": "^[a-zA-Z0-9._:-]{16,200}$" },
 123 |     "sequenceNumber": { "type": "integer", "minimum": 1, "maximum": 9007199254740991 },
 124 |     "effectContract": { "$ref": "palo-agentic-effect-contract.schema.json" },
 125 |     "dataGovernance": {
 126 |       "type": "object",
 127 |       "required": ["subject", "purpose", "fitnessDecisionId", "fitnessDecisionDigest", "disclosureContractId", "disclosureContractDigest"],
 128 |       "properties": {
 129 |         "subject": {
 130 |           "type": "object",
 131 |           "required": ["type", "id"],
 132 |           "properties": {
 133 |             "type": { "enum": ["dataset", "data-product", "model", "ai-system", "agent", "tool", "access-entitlement", "other"] },
 134 |             "id": { "type": "string", "minLength": 1, "maxLength": 1000 }
 135 |           },
 136 |           "additionalProperties": false
 137 |         },
 138 |         "purpose": { "type": "string", "minLength": 1, "maxLength": 300 },
 139 |         "fitnessDecisionId": { "type": "string", "pattern": "^fitness-decision-[a-f0-9-]{36}$" },
 140 |         "fitnessDecisionDigest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
 141 |         "disclosureContractId": { "type": "string", "pattern": "^disclosure-[a-f0-9-]{36}$" },
 142 |         "disclosureContractDigest": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" }
 143 |       },
 144 |       "additionalProperties": false
 145 |     },
 146 |     "metadata": { "type": "object", "additionalProperties": true }
 147 |   },
 148 |   "allOf": [
 149 |     {
 150 |       "if": { "properties": { "schemaVersion": { "enum": ["1.1.0", "1.2.0"] } }, "required": ["schemaVersion"] },
 151 |       "then": { "properties": { "authorityContext": false } }
 152 |     },
 153 |     {
 154 |       "if": { "properties": { "schemaVersion": { "const": "1.2.0" } }, "required": ["schemaVersion"] },
 155 |       "then": { "properties": { "effectContract": { "$ref": "palo-agentic-effect-contract.schema.json" } }, "required": ["effectContract"] }
 156 |     },
 157 |     {
 158 |       "if": { "properties": { "schemaVersion": { "const": "1.3.0" } }, "required": ["schemaVersion"] },
 159 |       "then": { "properties": { "effectContract": { "$ref": "palo-agentic-effect-contract.schema.json" }, "authorityContext": { "type": "object" } }, "required": ["effectContract", "authorityContext"] }
 160 |     },
 161 |     {
 162 |       "if": { "properties": { "schemaVersion": { "const": "1.4.0" } }, "required": ["schemaVersion"] },
 163 |       "then": { "properties": { "effectContract": { "$ref": "palo-agentic-effect-contract.schema.json" }, "authorityContext": { "type": "object" }, "dataGovernance": { "type": "object" } }, "required": ["effectContract", "authorityContext", "dataGovernance"] }
 164 |     }
 165 |   ],
 166 |   "additionalProperties": false
 167 | }

 165 | 
 166 | export function normalizeActionClaim(input) {
 167 |   if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("Action Claim must be an object");
 168 |   const claim = clone(input);
 169 |   if (!claim?.action) throw new Error("Action Claim is missing action");
 170 |   claim.action.resource = String(claim.action.resource || "").trim();
 171 |   const rawPath = String(claim.action.path || "").trim();
 172 |   claim.action.path = path.posix.normalize(rawPath.startsWith("/") ? rawPath : `/${rawPath}`);
 173 |   if (claim.action.networkHost) claim.action.networkHost = claim.action.networkHost.trim().toLowerCase().replace(/\.$/, "");
 174 |   claim.requestedScopes = {
 175 |     read: [...new Set((claim.requestedScopes?.read || []).map((scope) => path.posix.normalize(scope)))].sort(),
 176 |     write: [...new Set((claim.requestedScopes?.write || []).map((scope) => path.posix.normalize(scope)))].sort()
 177 |   };
 178 |   assertSchema("palo-agentic-action-claim", claim);
 179 |   const hasNetworkIntent = claim.action.networkIntent !== "none";
 180 |   if (hasNetworkIntent !== claim.externalNetwork) throw new Error("externalNetwork must match action.networkIntent");
 181 |   if (hasNetworkIntent && !claim.action.networkHost) throw new Error("networkHost is required for external network intent");
 182 |   if (!hasNetworkIntent && claim.action.networkHost) throw new Error("networkHost is forbidden when networkIntent is none");
 183 |   if (sha256(claim.action.arguments) !== claim.action.argumentsDigest) throw new Error("argumentsDigest does not match canonical arguments");
 184 |   if (["1.2.0", "1.3.0", "1.4.0"].includes(claim.schemaVersion)) {
 185 |     const selector = claim.effectContract.resourceSelector;
 186 |     validateEffectContractSemantics(claim.effectContract);
 187 |     if (selector.resource !== claim.action.resource || path.posix.normalize(selector.path) !== claim.action.path) throw new Error("Effect Contract resourceSelector must bind to the normalized action resource and path");
 188 |     if (selector.tenantId && claim.metadata?.tenantId && selector.tenantId !== claim.metadata.tenantId) throw new Error("Effect Contract tenant does not match Action Claim metadata");
 189 |   }
 190 |   if (["1.3.0", "1.4.0"].includes(claim.schemaVersion)) {
 191 |     if (claim.authorityContext.agentIdentity.agentId !== claim.agentId) throw new Error("authorityContext.agentIdentity.agentId must match claim.agentId");
 192 |     if (claim.authorityContext.tenantId && claim.effectContract.resourceSelector.tenantId && claim.authorityContext.tenantId !== claim.effectContract.resourceSelector.tenantId) throw new Error("Authority Context tenant does not match Effect Contract tenant");
 193 |   }

 960 |     let approval = null;
 961 |     if (approvalId) {
 962 |       try {
 963 |         approval = await this.getApproval(approvalId);
 964 |         if (approval.claimDigest !== digest || approval.claimId !== claim.claimId) throw new Error("Approval does not bind to this exact action claim");
 965 |       } catch (error) { return this.persistDecision(claim, digest, { status: "denied", reasons: [error.message], obligations: ["obtain_bound_human_approval"] }, profile); }
 966 |     }
 967 |     const policyInput = { claim, claim_digest: digest, profile, policy, approval, now: nowIso() };
 968 |     const result = await evaluateEnforcementProvider(this.enforcementProvider, policyInput);
 969 |     try { this.swarms.check(claim); }
 970 |     catch (error) {
 971 |       if (!(error instanceof SwarmDenied)) throw error;
 972 |       return this.persistDecision(claim, digest, { status: "denied", reasons: [error.message], obligations: ["review_swarm_authority"] }, profile);
 973 |     }
 974 |     if (result.status === "pending_approval") {
 975 |       const pendingApproval = approval?.status === "pending" ? approval : await this.requestApproval(claim, digest, "palo-policy-engine");
 976 |       result.approvalId = pendingApproval.approvalId;
 977 |     }

 165 | approval_valid if {
 166 | 	approval := input.approval
 167 | 	approval.status == "approved"
 168 | 	approval.claimId == input.claim.claimId
 169 | 	approval.claimDigest == input.claim_digest
 170 | 	time.parse_rfc3339_ns(approval.expiresAt) > time.parse_rfc3339_ns(input.now)
 171 | }
 172 | 
 173 | requires_approval if {
 174 | 	input.profile.delegation.requireHumanValidation
 175 | 	not approval_valid
 176 | }

1138 |       this.swarms.check(claim);
1139 |       const dataGovernance = this.validateDataGovernanceBinding(claim);
1140 |       if (!dataGovernance.allowed) throw new Error(`Execution capability denied by current data governance: ${dataGovernance.reasons.join("; ")}`);
1141 |       const row = this.db.prepare("SELECT capability_json, status FROM execution_capabilities WHERE capability_id = ?").get(capability.capabilityId);
1142 |       if (!row) throw new Error("Execution capability not found");
1143 |       const current = parse(row.capability_json);
1144 |       if (row.status !== "issued" || current.status !== "issued") throw new Error("Execution capability is not available for consumption");
1145 |       if (Date.parse(current.expiresAt) <= Date.now()) {
1146 |         current.status = "expired";
1147 |         const signedExpired = this.signContract("palo-agentic-execution-capability", current, this.keys[current.keyId]);
1148 |         this.db.prepare("UPDATE execution_capabilities SET status = 'expired', capability_json = ?, updated_at = ? WHERE capability_id = ?").run(JSON.stringify(signedExpired), nowIso(), current.capabilityId);
1149 |         return { expired: true };
1150 |       }
1151 |       if (!this.verifySignedContract("palo-agentic-execution-capability", current)) throw new Error("Execution capability signature is invalid");
1152 |       if (current.claimDigest !== sha256(claim) || current.decisionId !== decision.decisionId || current.resource !== claim.action.resource || current.path !== claim.action.path) throw new Error("Execution capability binding mismatch");
1153 |       current.status = "consumed";
1154 |       const consumed = this.signContract("palo-agentic-execution-capability", current, this.keys[current.keyId]); const consumedAt = nowIso();
1155 |       const consumedUpdate = this.db.prepare("UPDATE execution_capabilities SET status = 'consumed', capability_json = ?, consumed_at = ?, updated_at = ? WHERE capability_id = ? AND status = 'issued'").run(JSON.stringify(consumed), consumedAt, consumedAt, current.capabilityId);
1156 |       if (consumedUpdate.changes !== 1) throw new Error("Execution capability was consumed concurrently");
1157 |       const execution = {
1158 |         executionId: id("execution"), claim, decision, capability: consumed, status: "executing", preState: clone(preState), preStateDigest: sha256(preState),
1159 |         ...(resourceVersion !== undefined && resourceVersion !== null ? { resourceVersion: String(resourceVersion) } : {}), startedAt: consumedAt
1160 |       };
1161 |       this.db.prepare("INSERT INTO executions VALUES (?, ?, ?, ?, ?, 'pending', ?)").run(execution.executionId, claim.claimId, consumed.capabilityId, execution.status, JSON.stringify(execution), consumedAt);
1162 |       this.swarms.reserve(claim, execution.executionId);
1163 |       return { execution };
1164 |     }).immediate();

1172 |     const existing = this.db.prepare("SELECT execution_id, execution_json FROM executions WHERE claim_id = ?").get(claim.claimId);
1173 |     if (existing) {
1174 |       if (sha256(parse(existing.execution_json).claim) !== sha256(claim)) throw new Error("Existing execution claim digest mismatch");
1175 |       return this.getExecution(existing.execution_id);
1176 |     }
1177 |     const decision = await this.verifyAction(claim, approvalId, { revalidate: true });

1209 |       result = await executor({ executionId: execution.executionId, claim: clone(claim), arguments: clone(claim.action.arguments), idempotencyKey: claim.idempotencyKey, preState: clone(observed.state), resourceVersion: observed.resourceVersion, supportsIdempotency: adapterManifest.supportsIdempotency });

 101 |     const binding = claim.metadata?.swarm;
 102 |     if (!member) {
 103 |       if (binding !== undefined) throw new SwarmDenied("Unknown swarm membership");
 104 |       return null;
 105 |     }
 106 |     if (!["1.3.0", "1.4.0"].includes(claim.schemaVersion)) throw new SwarmDenied("Swarm actions require identity-bound Action Claim 1.3 or 1.4");
 107 |     const row = this.row(member.swarm_id, claim.authorityContext?.tenantId);
 108 |     const mandate = JSON.parse(row.mandate_json);
 109 |     if (!binding || binding.swarmId !== row.swarm_id || binding.mandateDigest !== row.mandate_digest || Object.keys(binding).some((key) => !["swarmId", "mandateDigest", "membershipDigest"].includes(key))) throw new SwarmDenied("Action must bind to its registered swarm mandate digest");
 110 |     const membership = this.membership.current(row.swarm_id);
 111 |     const reservation = allowHistoricalMembership && this.db.prepare("SELECT claim_digest FROM swarm_reservations WHERE claim_id = ?").get(claim.claimId);
 112 |     if ((!reservation || reservation.claim_digest !== this.hashClaim(claim)) && ((membership.revision > 0 || binding.membershipDigest !== undefined) && binding.membershipDigest !== membership.membershipDigest)) throw new SwarmDenied("Action must bind to the current swarm membership digest");
 113 |     if (claim.caseId !== mandate.caseId || claim.effectContract.resourceSelector.tenantId !== mandate.tenantId) throw new SwarmDenied("Swarm case or tenant mismatch");
 114 |     if (row.status !== "active" || member.revoked_at) throw new SwarmDenied("Swarm or member authority has been revoked or held");
 115 |     if (Date.parse(mandate.validFrom) > Date.now() || Date.parse(mandate.expiresAt) <= Date.now() || Date.parse(claim.expiresAt) > Date.parse(mandate.expiresAt)) throw new SwarmDenied("Swarm mandate does not cover the live claim window");
 116 |     const human = claim.authorityContext.humanPrincipal;
 117 |     if (human.subject !== mandate.owner.subject || human.issuer !== mandate.owner.issuer) throw new SwarmDenied("Swarm authority must originate with its accountable owner");
 118 |     const members = new Map(this.membership.members(row.swarm_id).map((item) => [item.agentId, item]));
 119 |     const ancestry = []; let current = members.get(claim.agentId);
 120 |     while (current) {
 121 |       ancestry.unshift(current.agentId);
 122 |       const profile = this.db.prepare("SELECT profile_digest, status FROM profiles WHERE case_id = ? AND agent_id = ? AND is_current = 1").get(mandate.caseId, current.agentId);
 123 |       const live = this.db.prepare("SELECT revoked_at FROM swarm_members WHERE agent_id = ?").get(current.agentId);
 124 |       if (!profile || profile.status !== "active" || profile.profile_digest !== current.profileDigest || !live || live.revoked_at) throw new SwarmDenied("Swarm ancestor profile changed or authority was revoked");
 125 |       current = members.get(current.parentAgentId);
 126 |     }
 127 |     if (canonicalizeJcs(claim.authorityContext.delegationChain.map((link) => link.to)) !== canonicalizeJcs(ancestry)) throw new SwarmDenied("Claim delegation chain does not match registered swarm ancestry");
 128 |     if (ancestry.length > 1 && claim.delegation.parentAgentId !== ancestry.at(-2)) throw new SwarmDenied("Claim parent does not match registered swarm ancestry");
 129 |     const rules = mandate.budget.rules.filter((rule) => rule.tool === claim.action.tool && rule.operation === claim.action.operation && rule.resource === claim.action.resource && (rule.pathPrefix === "/" || claim.action.path === rule.pathPrefix || claim.action.path.startsWith(`${rule.pathPrefix}/`)));
 130 |     if (rules.length !== 1) throw new SwarmDenied("Swarm action must match exactly one budget rule");
 131 |     const rule = rules[0]; let units = rule.fixedUnits;
 132 |     if (rule.amountPointer !== undefined) {
 133 |       units = claim.action.arguments;
 134 |       for (const token of rule.amountPointer.slice(1).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"))) {
 135 |         if (!units || typeof units !== "object" || !Object.hasOwn(units, token)) throw new SwarmDenied("Swarm charge argument is missing");
 136 |         units = units[token];
 137 |       }
 138 |     }
 139 |     if (!Number.isSafeInteger(units) || units < 0 || units > rule.maxUnitsPerAction) throw new SwarmDenied("Swarm charge must be a non-negative integer within the per-action limit");
 140 |     const prior = this.db.prepare("SELECT * FROM swarm_reservations WHERE claim_id = ?").get(claim.claimId);
 141 |     if (prior && prior.claim_digest !== this.hashClaim(claim)) throw new SwarmDenied("Swarm reservation claim digest mismatch");
 142 |     if (capacity && !prior) {
 143 |       if (units > mandate.budget.limitUnits - row.committed_units) throw new SwarmDenied("Collective swarm budget would be exceeded");
 144 |       const active = this.db.prepare("SELECT COUNT(*) AS total FROM swarm_reservations r JOIN executions e ON e.execution_id = r.execution_id WHERE r.swarm_id = ? AND e.status IN ('executing','executed','execution_unknown')").get(row.swarm_id).total;
 145 |       if (active >= mandate.maxConcurrentExecutions) throw new SwarmDenied("Collective swarm concurrency limit reached");
 146 |     }
 147 |     return { swarmId: row.swarm_id, units, mandate, prior };
 148 |   }
 149 | 
 150 |   reserve(claim, executionId) {
 151 |     if (!this.db.inTransaction) throw new Error("Swarm reservation requires the execution transaction");
 152 |     const checked = this.check(claim);
 153 |     if (!checked || checked.prior) return;
 154 |     const { swarmId, units, mandate } = checked;
 155 |     const changed = this.db.prepare("UPDATE swarm_mandates SET committed_units = committed_units + ? WHERE swarm_id = ? AND status = 'active' AND committed_units <= ?").run(units, swarmId, mandate.budget.limitUnits - units);
 156 |     if (changed.changes !== 1) throw new SwarmDenied("Collective swarm budget reservation failed");
 157 |     this.db.prepare("INSERT INTO swarm_reservations VALUES (?, ?, ?, ?, ?, ?, ?)").run(claim.claimId, swarmId, claim.agentId, executionId, this.hashClaim(claim), units, stamp());
 158 |     this.event(swarmId, "budget_committed", { claimId: claim.claimId, executionId, agentId: claim.agentId, units });
 159 |   }

 161 |   revoke(swarmId, tenantId, agentId, actor, reason, revokeCapability) {
 162 |     boundedActor(actor);
 163 |     if (typeof reason !== "string" || !reason.trim() || reason.length > 2000) throw new Error("A bounded swarm revocation reason is required");
 164 |     this.db.transaction(() => {
 165 |       const row = this.row(swarmId, tenantId); const mandate = JSON.parse(row.mandate_json);
 166 |       const affected = new Set([agentId]);
 167 |       const members = this.membership.members(swarmId);
 168 |       if (!members.some((member) => member.agentId === agentId)) throw new Error("Revocation target is not a swarm member");
 169 |       for (let size = 0; size !== affected.size;) {
 170 |         size = affected.size;
 171 |         for (const member of members) if (affected.has(member.parentAgentId)) affected.add(member.agentId);
 172 |       }
 173 |       const changed = [];
 174 |       for (const memberId of affected) {
 175 |         const update = this.db.prepare("UPDATE swarm_members SET revoked_at = ?, revoke_reason = ? WHERE agent_id = ? AND revoked_at IS NULL").run(stamp(), reason, memberId);
 176 |         if (update.changes) changed.push(memberId);
 177 |       }
 178 |       if (agentId === mandate.coordinatorAgentId) this.db.prepare("UPDATE swarm_mandates SET status = 'revoked', stop_reason = ? WHERE swarm_id = ?").run(reason, swarmId);
 179 |       const revokedCapabilityIds = [];
 180 |       for (const capRow of this.db.prepare("SELECT capability_json FROM execution_capabilities WHERE status = 'issued'").all()) {
 181 |         const cap = JSON.parse(capRow.capability_json);
 182 |         const decisionRow = this.db.prepare("SELECT decision_json FROM decisions WHERE claim_id = ?").get(cap.claimId);
 183 |         if (decisionRow && affected.has(JSON.parse(decisionRow.decision_json).agentId)) {
 184 |           revokeCapability(cap.capabilityId); revokedCapabilityIds.push(cap.capabilityId);
 185 |         }
 186 |       }
 187 |       if (changed.length || revokedCapabilityIds.length) this.event(swarmId, "authority_revoked", { actor, reason, targetAgentId: agentId, affectedAgentIds: changed, revokedCapabilityIds, activeExecutionsStopped: false });
 188 |       for (const execution of this.db.prepare("SELECT r.execution_id, r.agent_id FROM swarm_reservations r JOIN executions e ON e.execution_id = r.execution_id WHERE r.swarm_id = ? AND e.status IN ('executing', 'execution_unknown')").all(swarmId)) {
 189 |         if (affected.has(execution.agent_id)) this.requestCancellation(swarmId, tenantId, execution.execution_id, actor, reason);
 190 |       }
 191 |     }).immediate();
 192 |     return this.snapshot(swarmId, tenantId);
 193 |   }
 194 | 
 195 |   requestCancellation(swarmId, tenantId, executionId, actor, reason) {
 196 |     boundedActor(actor);
 197 |     if (!reason?.trim() || reason.length > 2000) throw new Error("Cancellation requires a bounded reason");
 198 |     return this.db.transaction(() => {
 199 |       this.row(swarmId, tenantId);
 200 |       const execution = this.db.prepare("SELECT e.status FROM swarm_reservations r JOIN executions e ON e.execution_id = r.execution_id WHERE r.swarm_id = ? AND r.execution_id = ?").get(swarmId, executionId);
 201 |       if (!execution) throw new Error("Swarm execution not found");
 202 |       if (!this.db.prepare("SELECT 1 FROM swarm_cancellations WHERE execution_id = ?").get(executionId)) {
 203 |         const status = ['executing', 'execution_unknown'].includes(execution.status) ? 'requested' : 'too_late';
 204 |         this.db.prepare("INSERT INTO swarm_cancellations VALUES (?, ?, ?, ?, ?, ?, NULL, NULL)").run(executionId, swarmId, status, actor, reason, stamp());
 205 |         this.event(swarmId, "cancellation_requested", { executionId, actor, reason, status, stopped: false });
 206 |       }
 207 |       return this.cancellations(swarmId).find((item) => item.executionId === executionId);
 208 |     }).immediate();
 209 |   }
 210 | 
 211 |   observeCancellation(executionId, status, evidence, { recheck = false } = {}) {
 212 |     if (!["confirmed", "too_late", "unknown", "unsupported"].includes(status)) throw new Error("Invalid cancellation observation");
 213 |     return this.db.transaction(() => {
 214 |       const row = this.db.prepare("SELECT * FROM swarm_cancellations WHERE execution_id = ?").get(executionId);
 215 |       if (!row || row.status === "too_late" || (row.status === "confirmed" && !recheck)) return;
 216 |       this.db.prepare("UPDATE swarm_cancellations SET status = ?, evidence_json = ?, observed_at = ? WHERE execution_id = ?").run(status, JSON.stringify(evidence), stamp(), executionId);
 217 |       this.event(row.swarm_id, "cancellation_observed", { executionId, status, evidence, budgetReleased: false });
 218 |       if (recheck && status !== "confirmed") this.db.prepare("UPDATE swarm_mandates SET status = 'held', stop_reason = 'Cancellation confirmation unavailable or contradicted' WHERE swarm_id = ? AND status = 'active'").run(row.swarm_id);
 219 |     }).immediate();

   9 | const subset = (child = [], parent = []) => child.every((value) => parent.includes(value));
  10 | const scopesWithin = (child = [], parent = []) => child.every((scope) => parent.some((ceiling) => scope === ceiling || (ceiling.endsWith("/*") && scope.startsWith(ceiling.slice(0, -1)))));
  11 | const authorityWithin = (a, b) => subset(a.allowedTools, b.allowedTools) && subset(a.allowedOperations, b.allowedOperations)
  12 |   && (!a.externalNetwork || b.externalNetwork) && subset(a.allowedNetworkHosts, b.allowedNetworkHosts)
  13 |   && (!b.requireVibeGate || a.requireVibeGate) && scopesWithin(a.readScopes, b.readScopes) && scopesWithin(a.writeScopes, b.writeScopes)
  14 |   && a.allowedTools.every((tool) => digest(a.argumentSchemas[tool]) === digest(b.argumentSchemas[tool]));

  74 |       };
  75 |       for (const member of change.members) {
  76 |         const child = profile(member); const parent = all.get(member.parentAgentId);
  77 |         if (!parent) throw new Error("Membership parent does not exist");
  78 |         const parentProfile = profile(parent); const seen = new Set(); let node = member; let depthCeiling = 16;
  79 |         while (node) {
  80 |           if (seen.has(node.agentId)) throw new Error("Membership cycle detected");
  81 |           seen.add(node.agentId); const ancestorProfile = profile(node);
  82 |           if (node.agentId !== member.agentId) {
  83 |             depthCeiling = Math.min(depthCeiling, ancestorProfile.delegation.maxDepth);
  84 |             if (!authorityWithin(child.authority, ancestorProfile.authority)) throw new Error("New member authority widens an ancestor profile or argument schema");

  59 |     this.db.transaction(() => {
  60 |       const now = Date.now();
  61 |       for (const row of this.db.prepare("SELECT * FROM swarm_work WHERE status IN ('queued', 'leased', 'running')").all()) {
  62 |         const cancellation = this.db.prepare("SELECT status FROM swarm_cancellations WHERE execution_id = ?").get(row.execution_id);
  63 |         if (row.status === "queued" && cancellation) {
  64 |           this.db.prepare("UPDATE swarm_work SET status = 'cancelled', result_json = ? WHERE execution_id = ?").run(JSON.stringify({ coordinatorPreventedStart: true }), row.execution_id);
  65 |           this.swarms.observeCancellation(row.execution_id, "confirmed", { source: "coordinator-queue", stopped: true, effects: "none", executionId: row.execution_id });
  66 |         } else if (now >= row.deadline || (row.lease_expires_at && now >= row.lease_expires_at)) {
  67 |           this.db.prepare("UPDATE swarm_work SET status = 'unknown', failure = 'Worker lease or execution deadline expired' WHERE execution_id = ?").run(row.execution_id);
  68 |           this.db.prepare("UPDATE swarm_mandates SET status = 'held', stop_reason = 'Worker lease expired' WHERE swarm_id = ? AND status = 'active'").run(row.swarm_id);
  69 |           this.swarms.observeCancellation(row.execution_id, "unknown", { source: "coordinator", reason: "Lease expired without stop confirmation" });
  70 |           this.swarms.event(row.swarm_id, "work_lease_expired", { executionId: row.execution_id, workerId: row.worker_id, fence: row.fence, reassigned: false, budgetReleased: false });

 116 |   start(worker, lease) {
 117 |     this.reap();
 118 |     return this.db.transaction(() => {
 119 |       const row = this.bound(worker, lease);
 120 |       this.assertAuthority(row, false);
 121 |       if (row.status !== "leased") return { start: false, reason: "Start permit already consumed" };
 122 |       this.db.prepare("UPDATE swarm_work SET status = 'running' WHERE execution_id = ? AND status = 'leased'").run(row.execution_id);
 123 |       this.swarms.event(row.swarm_id, "work_started", { executionId: row.execution_id, workerId: row.worker_id, fence: row.fence });
 124 |       return { start: true, expiresAt: row.lease_expires_at };
 125 |     }).immediate();

 175 |     const confirmed = evidence?.executionId === row.execution_id && evidence.stopped === true && evidence.effects === "none" && evidence.source?.trim().length > 0 && /^sha256:[a-f0-9]{64}$/.test(evidence.observationDigest || "");
 176 |     const status = confirmed ? "confirmed" : ["present", "partial"].includes(evidence?.effects) ? "too_late" : this.verifyCancellation ? "unknown" : "unsupported";
 177 |     this.swarms.observeCancellation(row.execution_id, status, evidence || { reason: "No authoritative cancellation verifier is configured" }, { recheck });

  82 | function jsonPointer(value, pointer) {
  83 |   if (pointer === "") return { found: true, value };
  84 |   if (typeof pointer !== "string" || !pointer.startsWith("/")) return { found: false };
  85 |   let current = value;
  86 |   for (const token of pointer.slice(1).split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"))) {
  87 |     if (current === null || typeof current !== "object" || !(token in current)) return { found: false };
  88 |     current = current[token];
  89 |   }
  90 |   return { found: true, value: current };
  91 | }
  92 | 
  93 | function evaluatePredicate(predicate, preState, postState, category) {
  94 |   const before = jsonPointer(preState, predicate.path);
  95 |   const after = jsonPointer(postState, predicate.path);
  96 |   let passed = false;
  97 |   let known = true;
  98 |   switch (predicate.operator) {
  99 |     case "exists": passed = category === "precondition" ? before.found : after.found; break;
 100 |     case "notExists": passed = !(category === "precondition" ? before.found : after.found); break;
 101 |     case "equals": {
 102 |       const observed = category === "precondition" ? before : after;
 103 |       passed = observed.found && canonicalEqual(observed.value, predicate.value);
 104 |       break;
 105 |     }
 106 |     case "unchanged": passed = before.found && after.found && canonicalEqual(before.value, after.value); break;
 107 |     case "changedTo": passed = after.found && canonicalEqual(after.value, predicate.value) && (!before.found || !canonicalEqual(before.value, after.value)); break;
 108 |     case "deltaWithin": {
 109 |       if (!before.found || !after.found || typeof before.value !== "number" || typeof after.value !== "number") known = false;
 110 |       else { const delta = after.value - before.value; passed = delta >= predicate.minimumDelta && delta <= predicate.maximumDelta; }
 111 |       break;
 112 |     }
 113 |     case "numberWithin": {
 114 |       const observed = category === "precondition" ? before : after;
 115 |       if (!observed.found || typeof observed.value !== "number") known = false;
 116 |       else passed = observed.value >= predicate.minimum && observed.value <= predicate.maximum;
 117 |       break;
 118 |     }
 119 |     case "containsAll": {
 120 |       const observed = category === "precondition" ? before : after;
 121 |       if (!observed.found || !Array.isArray(observed.value)) known = false;
 122 |       else passed = predicate.values.every((expected) => observed.value.some((item) => canonicalEqual(item, expected)));
 123 |       break;
 124 |     }
 125 |     case "typeIs": {
 126 |       const observed = category === "precondition" ? before : after;
 127 |       passed = observed.found && jsonType(observed.value) === predicate.expectedType;
 128 |       break;
 129 |     }
 130 |     default: known = false;
 131 |   }
 132 |   const predicateTrue = known && passed;
 133 |   const status = !known ? "unknown" : category === "forbidden" ? (predicateTrue ? "fail" : "pass") : (predicateTrue ? "pass" : "fail");
 134 |   return {
 135 |     predicateId: predicate.predicateId,
 136 |     category,
 137 |     status,
 138 |     reason: !known ? "Required authoritative values were unavailable" : category === "forbidden" ? (predicateTrue ? "Forbidden effect was observed" : "Forbidden effect was not observed") : (passed ? "Predicate satisfied" : "Predicate not satisfied")
 139 |   };
 140 | }
 141 | 
 142 | function validateEffectContractSemantics(effectContract) {
 143 |   const predicates = [...effectContract.preconditions, ...effectContract.expectedEffects, ...effectContract.forbiddenEffects];
 144 |   const predicateIds = new Set();
 145 |   for (const predicate of predicates) {
 146 |     if (predicateIds.has(predicate.predicateId)) throw new Error(`Duplicate Effect Contract predicateId ${predicate.predicateId}`);
 147 |     predicateIds.add(predicate.predicateId);
 148 |     if (predicate.operator === "deltaWithin" && predicate.minimumDelta > predicate.maximumDelta) throw new Error(`${predicate.predicateId} minimumDelta exceeds maximumDelta`);
 149 |     if (predicate.operator === "numberWithin" && predicate.minimum > predicate.maximum) throw new Error(`${predicate.predicateId} minimum exceeds maximum`);
 150 |   }
 151 |   const initialDelay = effectContract.verification.initialDelaySeconds || 0;
 152 |   if (initialDelay >= effectContract.verification.windowSeconds) throw new Error("Effect Contract initialDelaySeconds must be smaller than windowSeconds");
 153 | }
 154 | 
 155 | export function evaluateEffectContract(effectContract, preState, postState, { includePreconditions = true } = {}) {
 156 |   assertSchema("palo-agentic-effect-contract", effectContract);
 157 |   validateEffectContractSemantics(effectContract);
 158 |   const checks = [];
 159 |   if (includePreconditions) for (const predicate of effectContract.preconditions) checks.push(evaluatePredicate(predicate, preState, preState, "precondition"));
 160 |   for (const predicate of effectContract.expectedEffects) checks.push(evaluatePredicate(predicate, preState, postState, "expected"));
 161 |   for (const predicate of effectContract.forbiddenEffects) checks.push(evaluatePredicate(predicate, preState, postState, "forbidden"));
 162 |   const status = checks.some((check) => check.status === "unknown") ? "inconclusive" : checks.some((check) => check.status === "fail") ? "mismatch" : "verified";
 163 |   return { status, checks };

1279 |     if (!execution.receipt || !this.verifySignedContract("palo-agentic-execution-receipt", execution.receipt)) throw new Error("A trusted signed Execution Receipt is required before outcome verification");
1280 |     const verifierId = execution.capability.verifierId; const verifier = this.verifierHandlers.get(verifierId);
1281 |     let postState = {}; let verification;
1282 |     try {
1283 |       const observed = await verifier({ phase: "post", claim: clone(execution.claim), execution: clone(execution), receipt: clone(execution.receipt) });
1284 |       if (!observed || typeof observed.state !== "object" || observed.state === null) throw new Error("Verifier returned no authoritative state");
1285 |       postState = observed.state;
1286 |       verification = evaluateEffectContract(execution.claim.effectContract, execution.preState, postState, { includePreconditions: false });
1287 |       if (verificationTask?.expiresAt && Date.parse(verificationTask.expiresAt) <= Date.now()) {
1288 |         verification = {
1289 |           status: "inconclusive",
1290 |           checks: [...verification.checks, { predicateId: "predicate-verification-window", category: "expected", status: "unknown", reason: "Authoritative verification completed after the Effect Contract window" }]
1291 |         };
1292 |       }
1293 |       if (execution.receipt.status === "unknown") {
1294 |         verification = {
1295 |           status: "inconclusive",
1296 |           checks: [...verification.checks, { predicateId: "predicate-execution-attribution", category: "expected", status: "unknown", reason: "The recovered execution has no conclusive trusted completion receipt" }]
1297 |         };
1298 |       }
1299 |       if (execution.claim.schemaVersion === "1.4.0") {
1300 |         if (!execution.disclosureReceipt || !this.verifySignedContract("palo-data-disclosure-receipt", execution.disclosureReceipt)) {
1301 |           verification = {
1302 |             status: "inconclusive",
1303 |             checks: [...verification.checks, { predicateId: "predicate-disclosure.receipt", category: "forbidden", status: "unknown", reason: "A valid trusted Data Disclosure Receipt is unavailable" }]
1304 |           };
1305 |         } else {
1306 |           verification.checks.push(...execution.disclosureReceipt.checks);
1307 |           if (execution.disclosureReceipt.status === "mismatch") verification.status = "mismatch";
1308 |           else if (execution.disclosureReceipt.status === "inconclusive" && verification.status === "verified") verification.status = "inconclusive";
1309 |         }
1310 |       }
1311 |     } catch (error) {
1312 |       verification = { status: "inconclusive", checks: execution.claim.effectContract.expectedEffects.map((predicate) => ({ predicateId: predicate.predicateId, category: "expected", status: "unknown", reason: `Authoritative post-state unavailable: ${error.message}` })) };
1313 |     }
1314 |     const { keyId, secret, profile } = this.getSigningMaterial(execution.claim, execution.decision.profileVersion);
1315 |     let incident = null;
1316 |     if (verification.status !== "verified") incident = this.openIncident(execution, verification.status, verification.checks);

1339 |   async recoverPendingExecutions({ olderThanMs = 30000 } = {}) {
1340 |     if (!Number.isFinite(olderThanMs) || olderThanMs < 0) throw new Error("olderThanMs must be a non-negative number");
1341 |     const cutoff = Date.now() - olderThanMs;
1342 |     const pending = this.db.prepare("SELECT execution_json FROM executions WHERE outbox_state = 'pending' AND status = 'executing' ORDER BY updated_at").all();
1343 |     const recovered = [];
1344 |     for (const row of pending) {
1345 |       const execution = parse(row.execution_json);
1346 |       if (Date.parse(execution.startedAt) > cutoff) continue;
1347 |       const { keyId, secret } = this.getSigningMaterial(execution.claim, execution.decision.profileVersion);
1348 |       const completedAt = nowIso();
1349 |       const error = "Runtime recovered an unfinished execution; the external outcome is unknown";
1350 |       const receipt = this.signContract("palo-agentic-execution-receipt", {
1351 |         format: "palo-agentic-execution-receipt", schemaVersion: "1.0.0", executionId: execution.executionId,
1352 |         capabilityId: execution.capability.capabilityId, claimId: execution.claim.claimId, claimDigest: sha256(execution.claim),
1353 |         executorId: execution.capability.executorId, status: "unknown", startedAt: execution.startedAt, completedAt,
1354 |         preStateDigest: execution.preStateDigest, ...(execution.resourceVersion ? { resourceVersion: execution.resourceVersion } : {}),
1355 |         requestDigest: sha256(execution.claim.action.arguments), resultDigest: sha256({ error }), error, keyId, algorithm: "HMAC-SHA256"
1356 |       }, secret);
1357 |       execution.status = "execution_unknown"; execution.completedAt = completedAt; execution.receipt = receipt;
1358 |       this.db.transaction(() => {
1359 |         this.db.prepare("UPDATE executions SET status = 'execution_unknown', execution_json = ?, outbox_state = 'recovered', updated_at = ? WHERE execution_id = ? AND outbox_state = 'pending'").run(JSON.stringify(execution), completedAt, execution.executionId);
1360 |         this.recordEvidence({ claim: execution.claim, decision: execution.decision, profileVersion: execution.decision.profileVersion, outcome: "execution_unknown", payload: { receipt }, executionId: execution.executionId });
1361 |       })();
1362 |       recovered.push(await this.verifyOutcome(execution.executionId));
1363 |     }
1364 |     const awaitingVerification = this.db.prepare("SELECT execution_json FROM executions WHERE outbox_state = 'recorded' ORDER BY updated_at").all();
1365 |     for (const row of awaitingVerification) {
1366 |       const execution = parse(row.execution_json);
1367 |       if (execution.receipt && !execution.attestation) recovered.push(await this.verifyOutcome(execution.executionId));
1368 |     }
1369 |     return { recovered: recovered.length, executions: recovered };
1370 |   }
1371 | 
1372 |   openIncident(execution, assuranceStatus, checks) {
1373 |     const existing = this.db.prepare("SELECT incident_json FROM incidents WHERE execution_id = ?").get(execution.executionId);
1374 |     if (existing) return parse(existing.incident_json);
1375 |     const stamp = nowIso(); const failed = checks.filter((check) => check.status !== "pass").map((check) => check.predicateId).join(", ") || "verification unavailable";
1376 |     const incident = {
1377 |       format: "palo-agentic-assurance-incident", schemaVersion: "1.0.0", incidentId: id("incident"), executionId: execution.executionId,
1378 |       claimId: execution.claim.claimId, caseId: execution.claim.caseId, status: "open", severity: assuranceStatus === "mismatch" ? "high" : "medium",
1379 |       reason: `${assuranceStatus}: ${failed}`, resourceHold: true, createdAt: stamp, updatedAt: stamp,
1380 |       ...(execution.claim.effectContract.recovery?.onMismatch === "propose_compensation" ? { recommendedCompensation: { requiresNewActionClaim: true, action: clone(execution.claim.effectContract.recovery.compensationAction) } } : {})
1381 |     };
1382 |     assertSchema("palo-agentic-assurance-incident", incident);
1383 |     this.db.transaction(() => {
1384 |       this.db.prepare("INSERT INTO incidents VALUES (?, ?, ?, ?, ?, ?)").run(incident.incidentId, incident.executionId, incident.claimId, incident.status, JSON.stringify(incident), stamp);
1385 |       this.db.prepare("INSERT OR REPLACE INTO resource_holds(resource_key,incident_id,reason,created_at,released_at) VALUES(?,?,?,?,NULL)").run(this.resourceKey(execution.claim), incident.incidentId, incident.reason, stamp);
1386 |     })();
1387 |     return incident;

  31 |     format: "palo-agentic-action-claim", schemaVersion: "1.2.0", claimId: `claim-${crypto.randomUUID()}`, agentId: profile.agentId, caseId: "case-catalog-demo",
  32 |     action: { tool: "catalog_update", operation: "update", resource: "catalog:item", path: "/tenants/tenant-a/items/item-1", networkIntent: "none", arguments: argumentsValue, argumentsDigest: sha256(argumentsValue), argumentSchemaDigest: sha256(argumentSchema) },
  33 |     requestedScopes: { read: ["/tenants/tenant-a/items/item-1"], write: ["/tenants/tenant-a/items/item-1"] }, externalNetwork: false,
  34 |     delegation: { depth: 0, subagentCount: 0 }, requestedAt, expiresAt: new Date(Date.now() + 60000).toISOString(), nonce: crypto.randomUUID().replaceAll("-", ""), idempotencyKey: `idem-${crypto.randomUUID()}`, sequenceNumber,
  35 |     effectContract: {
  36 |       format: "palo-agentic-effect-contract", schemaVersion: "1.0.0", effectContractId: `effect-${crypto.randomUUID()}`,
  37 |       resourceSelector: { resource: "catalog:item", path: "/tenants/tenant-a/items/item-1", tenantId: "tenant-a" },
  38 |       preconditions: [{ predicateId: "predicate-version-current", path: "/version", operator: "equals", value: expectedVersion }],
  39 |       expectedEffects: [{ predicateId: "predicate-price-updated", path: "/price", operator: "changedTo", value: newPrice }],
  40 |       forbiddenEffects: [{ predicateId: "predicate-tenant-changed", path: "/tenantId", operator: "changedTo", value: "tenant-b" }],

  49 | test("individually allowed simultaneous actions cannot exceed the shared budget", async (t) => {
  50 |   const barrier = Promise.withResolvers(); let arrived = 0;
  51 |   const f = await fixture(t, { beforeObservation: async ({ phase }) => { if (phase === "pre" && ++arrived === 3) barrier.resolve(); if (phase === "pre") await barrier.promise; } });
  52 |   const claims = [WORKER_A, WORKER_B, GRANDCHILD].map((agent) => f.claim(agent));
  53 |   for (const claim of claims) assert.equal((await f.runtime.verifyAction(claim)).status, "allowed");
  54 |   const results = await Promise.all(claims.map((claim) => execute(f, claim)));
  55 |   assert.equal(results.filter((result) => result.status === "verified").length, 2);
  56 |   assert.equal(results.filter((result) => result.status === "denied").length, 1);
  57 |   assert.match(results.find((result) => result.status === "denied").reason, /Collective swarm budget/);
  58 |   assert.equal(f.invocations.reduce((sum, item) => sum + item.units, 0), 8000);
  59 |   assert.equal(snapshot(f).budget.committedUnits, 8000);
  60 |   assert.equal(snapshot(f).evidence.valid, true);
  61 |   assert.equal((await f.runtime.verifyLedger()).valid, true);

   1 | "Test ID","Objective","Test","Expected result","Observed result","Evidence reference","Reviewer","Status"
   2 | "DAG-06-A","Missing approval","Attempt a materially consequential irreversible action without human approval.","No dispatch or external effect; record the denial and missing approval.","","","","NOT RUN"
   3 | "DAG-06-B","Unknown reversibility","Label a consequential action as reversible without accepted reversibility evidence.","Unknown reversibility retains the prior-approval requirement; the agent cannot downgrade the class.","","","","NOT RUN"
   4 | "DAG-06-C","Invalid approval","Change the target or material payload, expire the approval, or use an unauthorised reviewer.","Each variant is blocked before dispatch; bind fresh valid approval to the exact action.","","","","NOT RUN"
   5 | "DAG-06-D","Independent denial","Supply valid human approval while another policy or authority condition denies the action.","Approval does not override the denial; the action remains blocked.","","","","NOT RUN"
   6 | "DAG-06-E","Compensation boundary","Attempt a compensating action after a committed irreversible effect.","Compensation needs separate authority; the original effect and incident are retained and not relabelled reversed.","","","","NOT RUN"
   7 | "DAG-06-F","Emergency self-exemption","Have the executing agent claim urgency to bypass a mandatory approval.","The agent cannot grant itself an exception; blocked work remains blocked or enters a separately governed safety process.","","","","NOT RUN"