@paybond/kit 0.12.4 → 0.12.6

package/dist/agent/facade.d.ts

@@ -42,6 +42,8 @@ export type PaybondWrapToolsOptions = {
     sandbox?: boolean;
     attach?: import("./instrument.js").PaybondInstrumentAttachInput;
     context?: import("./instrument.js").PaybondInstrumentContextInput;
+    /** Fail closed on provider-executed AI SDK tools (Vercel AI / Cloudflare Agents). */
+    denyProviderExecutedTools?: boolean;
 };
 /** Wrap tools for an existing bound run without reloading policy. */
 export declare function wrapPaybondTools(run: PaybondAgentRun, tools: unknown, options?: PaybondWrapToolsOptions): unknown;

package/dist/agent/facade.js

@@ -3,6 +3,7 @@ import { createPaybondOpenAIAgentsConfig } from "../openai-agents/index.js";
 import { isKnownPolicyPresetId, resolvePolicyPresetPath } from "../policy/presets.js";
 import { createPaybondCloudflareAgentsConfig } from "../cloudflare-agents/config.js";
 import { createPaybondMastraConfig } from "../mastra/config.js";
+import { createPaybondGoogleAdkConfig } from "../google-adk/config.js";
 import { createPaybondVercelAgentConfig } from "../vercel-ai/config.js";
 import { createPaybondGenericAgentConfig, createPaybondGenericInputGuard, } from "./generic-runner.js";
 import { instrumentPaybondAgent, PaybondInstrumentRuntime, } from "./instrument.js";
@@ -62,6 +63,8 @@ export function toPaybondAgentResult(result) {
             break;
         case "mastra":
             break;
+        case "google-adk":
+            break;
         case "cloudflare-agents":
             if (result.toolApproval) {
                 hooks.toolApproval = result.toolApproval;
@@ -102,19 +105,24 @@ export async function createPaybondAgent(paybond, input) {
 /** Wrap tools for an existing bound run without reloading policy. */
 export function wrapPaybondTools(run, tools, options) {
     const framework = options?.framework ?? "generic";
+    const adapterOptions = options?.denyProviderExecutedTools === true
+        ? { denyProviderExecutedTools: true }
+        : undefined;
     switch (framework) {
         case "generic":
             return createPaybondGenericAgentConfig(run, tools).tools;
         case "vercel-ai":
-            return createPaybondVercelAgentConfig(run, tools).tools;
+            return createPaybondVercelAgentConfig(run, tools, adapterOptions).tools;
         case "openai-agents":
             return createPaybondOpenAIAgentsConfig(run, tools).tools;
         case "claude-agents":
             return createPaybondClaudeAgentsConfig(run, tools).agentTools;
         case "mastra":
             return createPaybondMastraConfig(run, tools).tools;
+        case "google-adk":
+            return createPaybondGoogleAdkConfig(run, tools).tools;
         case "cloudflare-agents":
-            return createPaybondCloudflareAgentsConfig(run, tools).tools;
+            return createPaybondCloudflareAgentsConfig(run, tools, adapterOptions).tools;
         case "langgraph":
             throw new Error('framework "langgraph" does not wrap tools in place; use instrument() or createPaybondLangGraphHooks(run)');
         default: {

package/dist/agent/guarded-agent.d.ts

@@ -7,11 +7,12 @@ import { paybondVercelToolApproval } from "../vercel-ai/tool-approval.js";
 import { type PaybondLangGraphAwrapToolCall } from "../langgraph/awrap-tool-call.js";
 import { paybondToolNode } from "../langgraph/tool-node.js";
 import { type ClaudeAgentsConfig } from "../claude-agents/config.js";
+import { type PaybondGoogleAdkConfig } from "../google-adk/config.js";
 import type { PaybondToolRegistry } from "./registry.js";
 import type { PaybondAgentRunHost } from "./run.js";
 import { PaybondAgentRun } from "./run.js";
 import type { PaybondRunBindingAttachInput } from "./types.js";
-export type GuardedAgentFramework = "generic" | "openai-agents" | "vercel-ai" | "langgraph" | "claude-agents" | "mastra" | "cloudflare-agents";
+export type GuardedAgentFramework = "generic" | "openai-agents" | "google-adk" | "vercel-ai" | "langgraph" | "claude-agents" | "mastra" | "cloudflare-agents";
 export type CreateGuardedAgentInput<TTools = unknown> = {
     policy: PaybondPolicyLoadSource | PaybondPolicy;
     /** Agent-agnostic wrapping when omitted. Pass a framework only when SDK-specific hooks are required. */
@@ -39,6 +40,7 @@ export type CreateGuardedAgentResultBase = {
     openAIAgentsAdapter?: ReturnType<typeof createOpenAIAgentsAdapter>;
     runConfig?: ReturnType<typeof createOpenAIAgentsAdapter>["runConfig"];
     claudeAgentsConfig?: ClaudeAgentsConfig;
+    googleAdkConfig?: PaybondGoogleAdkConfig;
 };
 export type CreateGuardedAgentResult<TTools = unknown> = CreateGuardedAgentResultBase & {
     agentTools: TTools;

package/dist/agent/guarded-agent.js

@@ -5,6 +5,7 @@ import { createPaybondLangGraphHooks } from "../langgraph/config.js";
 import { createPaybondClaudeAgentsConfig, } from "../claude-agents/config.js";
 import { createPaybondCloudflareAgentsConfig, } from "../cloudflare-agents/config.js";
 import { createPaybondMastraConfig, } from "../mastra/config.js";
+import { createPaybondGoogleAdkConfig, } from "../google-adk/config.js";
 import { createPaybondGenericAgentConfig, } from "./generic-runner.js";
 import { PaybondAgentRun } from "./run.js";
 async function resolvePolicy(source) {
@@ -48,13 +49,14 @@ export async function createGuardedAgent(paybond, input) {
     const run = await bindGuardedRun(paybond, policy, input);
     const base = { run, policy, registry };
     const framework = input.framework ?? "generic";
+    const adapterOptions = policy.toAdapterOptions();
     switch (framework) {
         case "generic": {
             const config = createPaybondGenericAgentConfig(run, input.tools);
             return { ...base, framework: "generic", agentTools: config.tools };
         }
         case "vercel-ai": {
-            const config = createPaybondVercelAgentConfig(run, input.tools);
+            const config = createPaybondVercelAgentConfig(run, input.tools, adapterOptions);
             return {
                 ...base,
                 framework: "vercel-ai",
@@ -73,6 +75,15 @@ export async function createGuardedAgent(paybond, input) {
                 runConfig: config.runConfig,
             };
         }
+        case "google-adk": {
+            const googleAdkConfig = createPaybondGoogleAdkConfig(run, input.tools);
+            return {
+                ...base,
+                framework: "google-adk",
+                agentTools: googleAdkConfig.tools,
+                googleAdkConfig,
+            };
+        }
         case "langgraph": {
             const hooks = createPaybondLangGraphHooks(run);
             return {
@@ -101,7 +112,7 @@ export async function createGuardedAgent(paybond, input) {
             };
         }
         case "cloudflare-agents": {
-            const config = createPaybondCloudflareAgentsConfig(run, input.tools);
+            const config = createPaybondCloudflareAgentsConfig(run, input.tools, adapterOptions);
             return {
                 ...base,
                 framework: "cloudflare-agents",

package/dist/agent/index.d.ts

@@ -1,7 +1,7 @@
 export { PaybondAgentFacade, createPaybondAgentCallable, type GetAgentReceiptInput, type PaybondAgentCallable, } from "./receipt-client.js";
 export { createGuardedAgent, createGuardedAgentRunner, type CreateGuardedAgentInput, type CreateGuardedAgentResult, type CreateGuardedAgentResultBase, type GuardedAgentFramework, } from "./guarded-agent.js";
 export { createPaybondAgent, resolveAgentPolicySource, toPaybondAgentResult, wrapPaybondTools, type PaybondAgentHooks, type PaybondAgentInput, type PaybondAgentResult, type PaybondInstrumentInput, type PaybondWrapToolsOptions, } from "./facade.js";
-export { PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, type PaybondAgentInstrumentation, type PaybondInlinePolicy, type PaybondInstrumentAgentOptions, type PaybondInstrumentAttachInput, type PaybondInstrumentBinding, type PaybondInstrumentContext, type PaybondInstrumentContextInput, type PaybondInstrumentContextProvider, } from "./instrument.js";
+export { PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondGoogleAdk, instrumentPaybondVercel, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, type PaybondAgentInstrumentation, type PaybondInlinePolicy, type PaybondInstrumentAgentOptions, type PaybondInstrumentAttachInput, type PaybondInstrumentBinding, type PaybondInstrumentContext, type PaybondInstrumentContextInput, type PaybondInstrumentContextProvider, } from "./instrument.js";
 export { formatPaybondAttachEnvSnippet, openPaybondAttachBundle, PAYBOND_ATTACH_BUNDLE_ENV, PAYBOND_ATTACH_BUNDLE_PREFIX, PAYBOND_ATTACH_INTENT_ID_ENV, PAYBOND_CAPABILITY_TOKEN_ENV, productionEvidenceFromAttachBundle, resolveAttachContextFromEnv, sealPaybondAttachBundle, type PaybondAttachBundlePayloadV1, type PaybondAttachEnvRecord, } from "./attach-bundle.js";
 export { createPaybondGenericAgentConfig, createPaybondGenericInputGuard, type PaybondGenericAgentConfig, } from "./generic-runner.js";
 export { runGenericSandboxDemo, type RunGenericSandboxDemoInput, type RunGenericSandboxDemoResult, } from "./generic-sandbox-demo.js";
@@ -11,4 +11,4 @@ export { PaybondToolInterceptor } from "./interceptor.js";
 export { PaybondToolRegistry, createPaybondToolRegistry, } from "./registry.js";
 export { PaybondAgentRun, PaybondAgentRunFacade, type PaybondAgentRunHost, } from "./run.js";
 export { agentRegistryDocumentToConfig, buildSmokeRegistry, loadAgentRegistryFile, parseAgentRegistryText, validateAgentRegistryDocument, type AgentRegistryFileDocument, type AgentRegistryValidationResult, } from "./registry-file.js";
-export { PaybondAgentRunBindError, PaybondAutoEvidenceError, PaybondAutoEvidenceSubmitError, PaybondEvidenceSubmitError, PaybondToolRegistryValidationError, PaybondUnregisteredSideEffectingToolError, type PaybondAgentRunBindInput, type PaybondAuthorizeToolCallInput, type PaybondEvidenceMapper, type PaybondExternalAttestationMapper, type PaybondInterceptEvidenceResult, type PaybondInterceptWrapExecuteInput, type PaybondInterceptWrapExecuteResult, type PaybondRunBinding, type PaybondRunBindingAttachInput, type PaybondRunBindingSandboxBootstrapInput, type PaybondRunProductionEvidenceCredentials, type PaybondRunGuard, type PaybondSideEffectingToolEntry, type PaybondSideEffectingToolPolicy, type PaybondSpendResolver, type PaybondToolCallContext, type PaybondToolInputGuardAllowDecision, type PaybondToolInputGuardApprovalRequiredDecision, type PaybondToolInputGuardDecision, type PaybondToolInputGuardDenyDecision, type PaybondToolRegistryConfig, type PaybondToolResolution, type PaybondTraceEvent, type PaybondTraceSink, } from "./types.js";
+export { PaybondAgentRunBindError, PaybondAutoEvidenceError, PaybondAutoEvidenceSubmitError, PaybondEvidenceSubmitError, PaybondToolRegistryValidationError, PaybondUnregisteredSideEffectingToolError, type PaybondAgentRunBindInput, type PaybondAuthorizeToolCallInput, type PaybondEvidenceMapper, type PaybondExternalAttestationMapper, type AgentReceiptComposeResult, type AgentReceiptComposeStatus, type PaybondInterceptEvidenceResult, type PaybondInterceptWrapExecuteInput, type PaybondInterceptWrapExecuteResult, type PaybondRunBinding, type PaybondRunBindingAttachInput, type PaybondRunBindingSandboxBootstrapInput, type PaybondRunProductionEvidenceCredentials, type PaybondRunGuard, type PaybondSideEffectingToolEntry, type PaybondSideEffectingToolPolicy, type PaybondSpendResolver, type PaybondToolCallContext, type PaybondToolInputGuardAllowDecision, type PaybondToolInputGuardApprovalRequiredDecision, type PaybondToolInputGuardDecision, type PaybondToolInputGuardDenyDecision, type PaybondToolRegistryConfig, type PaybondToolResolution, type PaybondTraceEvent, type PaybondTraceSink, } from "./types.js";

package/dist/agent/index.js

@@ -1,7 +1,7 @@
 export { PaybondAgentFacade, createPaybondAgentCallable, } from "./receipt-client.js";
 export { createGuardedAgent, createGuardedAgentRunner, } from "./guarded-agent.js";
 export { createPaybondAgent, resolveAgentPolicySource, toPaybondAgentResult, wrapPaybondTools, } from "./facade.js";
-export { PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondVercel, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, } from "./instrument.js";
+export { PaybondInstrumentBuilder, PaybondInstrumented, PaybondInstrumentRuntime, PaybondLazyContextError, PaybondUnboundContextError, discoverPolicyFromAgent, discoverToolNames, discoverToolsFromAgent, inlinePolicyToDocument, instrumentPaybondAgent, instrumentPaybondClaudeAgents, instrumentPaybondLangGraph, instrumentPaybondMCP, instrumentPaybondOpenAI, instrumentPaybondGoogleAdk, instrumentPaybondVercel, isInlinePolicy, isInstrumentableAgentObject, readPaybondAgentInstrumentation, } from "./instrument.js";
 export { formatPaybondAttachEnvSnippet, openPaybondAttachBundle, PAYBOND_ATTACH_BUNDLE_ENV, PAYBOND_ATTACH_BUNDLE_PREFIX, PAYBOND_ATTACH_INTENT_ID_ENV, PAYBOND_CAPABILITY_TOKEN_ENV, productionEvidenceFromAttachBundle, resolveAttachContextFromEnv, sealPaybondAttachBundle, } from "./attach-bundle.js";
 export { createPaybondGenericAgentConfig, createPaybondGenericInputGuard, } from "./generic-runner.js";
 export { runGenericSandboxDemo, } from "./generic-sandbox-demo.js";

package/dist/agent/instrument.d.ts

@@ -145,6 +145,9 @@ export declare function instrumentPaybondLangGraph<TTools>(paybond: PaybondAgent
 export declare function instrumentPaybondOpenAI<TTools>(paybond: PaybondAgentRunHost, input: Omit<PaybondInstrumentBaseInput<TTools>, "framework"> & {
     tools: TTools;
 }): Promise<PaybondInstrumented<TTools> | PaybondInstrumentRuntime<TTools>>;
+export declare function instrumentPaybondGoogleAdk<TTools>(paybond: PaybondAgentRunHost, input: Omit<PaybondInstrumentBaseInput<TTools>, "framework"> & {
+    tools: TTools;
+}): Promise<PaybondInstrumented<TTools> | PaybondInstrumentRuntime<TTools>>;
 export declare function instrumentPaybondVercel<TTools>(paybond: PaybondAgentRunHost, input: Omit<PaybondInstrumentBaseInput<TTools>, "framework"> & {
     tools: TTools;
 }): Promise<PaybondInstrumented<TTools> | PaybondInstrumentRuntime<TTools>>;

package/dist/agent/instrument.js

@@ -3,6 +3,8 @@ import { wrapDeferredTools } from "./deferred-tools.js";
 import { PaybondLazyContextError, wrapLazyContextTools } from "./lazy-context-tools.js";
 import { attachPaybondAgentInstrumentation, discoverPolicyFromAgent, discoverToolsFromAgent, isInstrumentableAgentObject, } from "./discover.js";
 import { createGuardedAgent, } from "./guarded-agent.js";
+import { createPaybondGenericInputGuard, } from "./generic-runner.js";
+import { paybondVercelToolApproval } from "../vercel-ai/tool-approval.js";
 import { toPaybondAgentResult, wrapPaybondTools, } from "./facade.js";
 import { PaybondAgentRun } from "./run.js";
 import { resolveAttachContextFromEnv, } from "./attach-bundle.js";
@@ -186,14 +188,25 @@ function bindingFromRun(run, mode, userId) {
 function hooksFromGuardedResult(result) {
     return toPaybondAgentResult(result).hooks;
 }
-function wrapToolsForFramework(run, rawTools, framework, guarded) {
+function wrapToolsForFramework(run, rawTools, framework, guarded, adapterOptions) {
     if (framework === "langgraph") {
         return rawTools;
     }
     if (guarded) {
         return guarded.agentTools;
     }
-    return wrapPaybondTools(run, rawTools, { framework });
+    return wrapPaybondTools(run, rawTools, { framework, ...adapterOptions });
+}
+function hooksForAttachedFramework(run, framework, adapterOptions) {
+    const hooks = {};
+    if (framework === "generic") {
+        hooks.inputGuard = createPaybondGenericInputGuard(run);
+        return hooks;
+    }
+    if (framework === "vercel-ai" || framework === "cloudflare-agents") {
+        hooks.toolApproval = paybondVercelToolApproval(run, adapterOptions);
+    }
+    return hooks;
 }
 /**
  * Bound Paybond runtime for one agent session — immutable; create a new runtime per request.
@@ -299,14 +312,9 @@ async function createBoundRuntime(paybond, policy, rawTools, framework, context,
         attach,
         traceSink,
     });
-    const tools = wrapToolsForFramework(run, rawTools, framework);
-    const hooks = hooksFromGuardedResult({
-        run,
-        policy,
-        registry: policy.toToolRegistry(),
-        framework,
-        agentTools: tools,
-    });
+    const adapterOptions = policy.toAdapterOptions();
+    const tools = wrapToolsForFramework(run, rawTools, framework, undefined, adapterOptions);
+    const hooks = hooksForAttachedFramework(run, framework, adapterOptions);
     return new PaybondInstrumentRuntime(tools, run, policy, hooks, bindingFromRun(run, "attach", context.userId));
 }
 function toPaybondInstrumentRuntime(result, rawTools, bindMode, userId) {
@@ -431,6 +439,9 @@ export function instrumentPaybondLangGraph(paybond, input) {
 export function instrumentPaybondOpenAI(paybond, input) {
     return frameworkInstrument(paybond, "openai-agents", input);
 }
+export function instrumentPaybondGoogleAdk(paybond, input) {
+    return frameworkInstrument(paybond, "google-adk", input);
+}
 export function instrumentPaybondVercel(paybond, input) {
     return frameworkInstrument(paybond, "vercel-ai", input);
 }

package/dist/agent/interceptor.js

@@ -23,6 +23,23 @@ function assertOperationAllowed(operation, allowedTools) {
         throw new Error(`operation "${operation}" is not in bound intent allowedTools (${allowedTools.join(", ")})`);
     }
 }
+function parseAgentReceiptComposeResult(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    const composeStatus = record.compose_status;
+    if (composeStatus !== "composed" && composeStatus !== "failed") {
+        return undefined;
+    }
+    return {
+        composeStatus,
+        receiptId: typeof record.receipt_id === "string" ? record.receipt_id : undefined,
+        scope: typeof record.scope === "string" ? record.scope : undefined,
+        warningCode: typeof record.warning_code === "string" ? record.warning_code : undefined,
+        warningMessage: typeof record.warning_message === "string" ? record.warning_message : undefined,
+    };
+}
 function mapSandboxEvidenceResult(result) {
     return {
         submitted: true,
@@ -31,6 +48,7 @@ function mapSandboxEvidenceResult(result) {
         sandboxLifecycleStatus: result.sandbox_lifecycle_status,
         payloadDigestSha256Hex: result.payload_digest?.trim().toLowerCase() || undefined,
         artifactsDigestSha256Hex: result.artifacts_digest?.trim().toLowerCase() || undefined,
+        agentReceipt: parseAgentReceiptComposeResult(result.agent_receipt),
     };
 }
 function isSpendApprovalRequiredError(err) {
@@ -486,6 +504,7 @@ export class PaybondToolInterceptor {
                 predicatePassed,
                 payloadDigestSha256Hex,
                 artifactsDigestSha256Hex,
+                agentReceipt: parseAgentReceiptComposeResult(resultRecord.agent_receipt),
             };
         }
         catch (err) {

package/dist/agent/types.d.ts

@@ -165,6 +165,15 @@ export type PaybondRunGuard = {
     assertSpendAuthorized(input: PaybondRunGuardAuthInput): Promise<PaybondRunGuardAuthResult>;
     completeSpendAuthorization(decisionId: string, outcome: "consumed" | "released"): Promise<void>;
 };
+export type AgentReceiptComposeStatus = "composed" | "failed";
+/** Structured Gateway compose outcome attached to Harbor evidence responses when signing is configured. */
+export type AgentReceiptComposeResult = {
+    composeStatus: AgentReceiptComposeStatus;
+    receiptId?: string;
+    scope?: string;
+    warningCode?: string;
+    warningMessage?: string;
+};
 export type PaybondInterceptEvidenceResult = {
     submitted: true;
     intentId: string;
@@ -175,6 +184,11 @@ export type PaybondInterceptEvidenceResult = {
     payloadDigestSha256Hex?: string;
     /** sha256 hex digest of submitted evidence artifacts, when returned by Harbor. */
     artifactsDigestSha256Hex?: string;
+    /**
+     * Gateway agent-receipt compose outcome when `PAYBOND_AGENT_RECEIPT_SIGNING_KEY_HEX` is
+     * configured. `composeStatus: "failed"` is a structured warning — evidence still succeeded.
+     */
+    agentReceipt?: AgentReceiptComposeResult;
 };
 export type PaybondInterceptWrapExecuteResult<TResult> = {
     toolResult: TResult;

package/dist/agent-receipt-acta.d.ts

@@ -0,0 +1,58 @@
+/**
+ * ACTA decision-receipt projection for `paybond.agent_receipt_v1`.
+ *
+ * Maps ARS fields into the ACTA Signed Decision Receipt shape
+ * (`draft-farley-acta-signed-receipts`) for MCP / governance handoff.
+ * This is an export projection only — ARS remains the canonical wire format
+ * and authenticity is verified via native ARS verify, not ACTA JCS re-sign.
+ */
+import type { AgentReceiptV1 } from "./agent-receipt.js";
+/** ACTA payload `type` for Paybond agent-receipt projections. */
+export declare const ACTA_AGENT_RECEIPT_TYPE = "paybond:agent_receipt";
+/** ACTA signature algorithm label used in the projected envelope. */
+export declare const ACTA_SIGNATURE_ALG_EDDSA = "EdDSA";
+export type ActaDecision = "allow" | "deny";
+export type ActaDecisionReceiptPayloadV1 = {
+    type: typeof ACTA_AGENT_RECEIPT_TYPE;
+    issued_at: string;
+    issuer_id: string;
+    tool_name?: string;
+    decision: ActaDecision;
+    reason?: string;
+    policy_digest?: string;
+    session_id?: string;
+    action_ref?: string;
+    payload_digest?: string;
+    /** Correlation: native ARS receipt_id. */
+    ars_receipt_id: string;
+    /** Correlation: ARS scope (`action` | `intent_terminal`). */
+    ars_scope: string;
+    /** Correlation: ARS kind constant. */
+    ars_kind: "paybond.agent_receipt_v1";
+};
+export type ActaDecisionReceiptSignatureV1 = {
+    alg: typeof ACTA_SIGNATURE_ALG_EDDSA;
+    kid: string;
+    sig: string;
+};
+/**
+ * ACTA-shaped decision receipt projected from a verified/composed ARS envelope.
+ *
+ * `signature` copies ARS Ed25519 material for correlation. Consumers MUST verify
+ * the original ARS envelope (or `payload_digest`) with native ARS verify —
+ * ACTA JCS signing over this projected payload is not performed.
+ */
+export type ActaDecisionReceiptV1 = {
+    payload: ActaDecisionReceiptPayloadV1;
+    signature: ActaDecisionReceiptSignatureV1;
+};
+/**
+ * Maps ARS execution / outcome fields to an ACTA allow/deny decision.
+ */
+export declare function projectActaDecisionFromAgentReceipt(receipt: AgentReceiptV1 | Record<string, unknown>): ActaDecision;
+/**
+ * Projects a composed/verified ARS receipt into an ACTA decision-receipt shape.
+ *
+ * @throws Error when required ARS correlation fields are missing
+ */
+export declare function projectAgentReceiptToActaDecisionReceipt(receipt: AgentReceiptV1 | Record<string, unknown>): ActaDecisionReceiptV1;

package/dist/agent-receipt-acta.js

@@ -0,0 +1,140 @@
+/**
+ * ACTA decision-receipt projection for `paybond.agent_receipt_v1`.
+ *
+ * Maps ARS fields into the ACTA Signed Decision Receipt shape
+ * (`draft-farley-acta-signed-receipts`) for MCP / governance handoff.
+ * This is an export projection only — ARS remains the canonical wire format
+ * and authenticity is verified via native ARS verify, not ACTA JCS re-sign.
+ */
+/** ACTA payload `type` for Paybond agent-receipt projections. */
+export const ACTA_AGENT_RECEIPT_TYPE = "paybond:agent_receipt";
+/** ACTA signature algorithm label used in the projected envelope. */
+export const ACTA_SIGNATURE_ALG_EDDSA = "EdDSA";
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function optionalString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function sha256Prefixed(hexDigest) {
+    const normalized = hexDigest.trim().toLowerCase();
+    if (normalized.startsWith("sha256:")) {
+        return normalized;
+    }
+    return `sha256:${normalized}`;
+}
+/**
+ * Maps ARS execution / outcome fields to an ACTA allow/deny decision.
+ */
+export function projectActaDecisionFromAgentReceipt(receipt) {
+    const doc = receipt;
+    const scope = optionalString(doc.scope)?.toLowerCase();
+    const outcome = asRecord(doc.outcome);
+    const execution = asRecord(doc.execution);
+    const evidence = asRecord(doc.evidence);
+    if (scope === "intent_terminal") {
+        const settlement = optionalString(outcome?.settlement_outcome)?.toUpperCase();
+        if (settlement === "FAILED" || settlement === "REVERSED") {
+            return "deny";
+        }
+        if (settlement === "SETTLED" || settlement === "PENDING_FINALITY") {
+            return "allow";
+        }
+        const harbor = optionalString(outcome?.harbor_state)?.toLowerCase();
+        if (harbor === "failed" || harbor === "failure" || harbor === "refunded") {
+            return "deny";
+        }
+        return "allow";
+    }
+    const execOutcome = optionalString(execution?.outcome)?.toLowerCase();
+    if (execOutcome && execOutcome !== "executed") {
+        return "deny";
+    }
+    if (evidence?.predicate_passed === false || outcome?.predicate_passed === false) {
+        return "deny";
+    }
+    return "allow";
+}
+/**
+ * Projects a composed/verified ARS receipt into an ACTA decision-receipt shape.
+ *
+ * @throws Error when required ARS correlation fields are missing
+ */
+export function projectAgentReceiptToActaDecisionReceipt(receipt) {
+    const doc = receipt;
+    const receiptId = optionalString(doc.receipt_id);
+    const issuedAt = optionalString(doc.issued_at);
+    const scope = optionalString(doc.scope);
+    const pubKey = optionalString(doc.signing_public_key_ed25519_hex)?.toLowerCase();
+    const sig = optionalString(doc.ed25519_signature_hex)?.toLowerCase();
+    const messageDigest = optionalString(doc.message_digest_sha256_hex)?.toLowerCase();
+    if (!receiptId) {
+        throw new Error("acta projection: receipt_id is required");
+    }
+    if (!issuedAt) {
+        throw new Error("acta projection: issued_at is required");
+    }
+    if (!scope) {
+        throw new Error("acta projection: scope is required");
+    }
+    if (!pubKey) {
+        throw new Error("acta projection: signing_public_key_ed25519_hex is required");
+    }
+    if (!sig) {
+        throw new Error("acta projection: ed25519_signature_hex is required");
+    }
+    const authorization = asRecord(doc.authorization);
+    const policy = asRecord(authorization?.policy);
+    const execution = asRecord(doc.execution);
+    const outcome = asRecord(doc.outcome);
+    const continuity = asRecord(doc.continuity);
+    const policyDigestHex = optionalString(policy?.content_digest_sha256_hex);
+    const toolName = optionalString(execution?.tool_name);
+    const sessionId = optionalString(execution?.run_id) ?? optionalString(continuity?.run_id);
+    const actionRef = optionalString(execution?.arguments_digest_sha256_hex) ?? messageDigest;
+    const reason = optionalString(outcome?.harbor_state) ??
+        optionalString(outcome?.spend_reservation_outcome) ??
+        optionalString(outcome?.settlement_outcome);
+    const payload = {
+        type: ACTA_AGENT_RECEIPT_TYPE,
+        issued_at: issuedAt,
+        issuer_id: pubKey,
+        decision: projectActaDecisionFromAgentReceipt(doc),
+        ars_receipt_id: receiptId,
+        ars_scope: scope,
+        ars_kind: "paybond.agent_receipt_v1",
+    };
+    if (toolName) {
+        payload.tool_name = toolName;
+    }
+    if (reason) {
+        payload.reason = reason;
+    }
+    if (policyDigestHex) {
+        payload.policy_digest = sha256Prefixed(policyDigestHex);
+    }
+    if (sessionId) {
+        payload.session_id = sessionId;
+    }
+    if (actionRef) {
+        payload.action_ref = actionRef.toLowerCase();
+    }
+    if (messageDigest) {
+        payload.payload_digest = sha256Prefixed(messageDigest);
+    }
+    return {
+        payload,
+        signature: {
+            alg: ACTA_SIGNATURE_ALG_EDDSA,
+            kid: pubKey,
+            sig,
+        },
+    };
+}

package/dist/agent-receipt-inclusion.d.ts

@@ -0,0 +1,40 @@
+import { type VerifyAgentReceiptV1Options } from "./agent-receipt.js";
+export declare const AGENT_RECEIPT_TRANSPARENCY_STH_KIND_V1 = "paybond.agent_receipt_transparency_sth_v1";
+export declare const AGENT_RECEIPT_TRANSPARENCY_INCLUSION_PROOF_KIND_V1 = "paybond.agent_receipt_transparency_inclusion_proof_v1";
+export declare const AGENT_RECEIPT_TRANSPARENCY_SCHEMA_VERSION = 1;
+export type SignedTreeHeadV1 = {
+    kind: string;
+    schema_version: number;
+    tenant_id: string;
+    tree_size: number;
+    root_hash_sha256_hex: string;
+    issued_at: string;
+    signing_algorithm: string;
+    signing_public_key_ed25519_hex: string;
+    message_digest_sha256_hex: string;
+    ed25519_signature_hex: string;
+};
+export type InclusionProofV1 = {
+    kind: string;
+    schema_version: number;
+    tenant_id: string;
+    receipt_id: string;
+    message_digest_sha256_hex: string;
+    leaf_index: number;
+    tree_size: number;
+    leaf_hash_sha256_hex: string;
+    audit_path_sha256_hex: string[];
+    root_hash_sha256_hex: string;
+    tree_head: SignedTreeHeadV1;
+};
+/** RFC 6962 leaf hash: SHA-256(0x00 || leafData). */
+export declare function merkleLeafHashRFC6962(leafData: Uint8Array): Uint8Array;
+/** RFC 6962 internal node hash: SHA-256(0x01 || left || right). */
+export declare function merkleNodeHashRFC6962(left: Uint8Array, right: Uint8Array): Uint8Array;
+/** Verifies a signed tree head (digest + Ed25519). */
+export declare function verifySignedTreeHeadV1(sth: SignedTreeHeadV1, options?: VerifyAgentReceiptV1Options): Promise<SignedTreeHeadV1>;
+/**
+ * Verifies that a receipt message digest is included in a published signed tree head
+ * via an RFC 6962 Merkle inclusion proof.
+ */
+export declare function verifyAgentReceiptInclusion(proof: InclusionProofV1, options?: VerifyAgentReceiptV1Options): Promise<InclusionProofV1>;