@agent-vm/controller-execution-contracts 0.0.113 → 0.0.115

package/dist/controller-dispatch-boundary/index.d.ts

@@ -3,8 +3,32 @@ import * as _$_agent_vm_agent_portal_sdk0 from "@agent-vm/agent-portal-sdk";
 import { z } from "zod";
 
 //#region src/controller-dispatch-boundary/models/controller-execution-result-schema.d.ts
+declare const ControllerExecutionAuthorityBindingSchema: z.ZodObject<{
+  fingerprint: z.ZodString;
+  operationId: z.ZodString;
+}, z.core.$strict>;
+declare const ControllerExecutionNotDispatchedReasonSchema: z.ZodEnum<{
+  "authorization-fingerprint-changed": "authorization-fingerprint-changed";
+  "current-epoch-changed": "current-epoch-changed";
+  denied: "denied";
+  "duplicate-operation": "duplicate-operation";
+  "predecessor-owner-unsafe": "predecessor-owner-unsafe";
+  "public-authority-or-policy-override": "public-authority-or-policy-override";
+  "runner-setup-failed": "runner-setup-failed";
+  "stale-authority": "stale-authority";
+}>;
+declare const ControllerExecutionAmbiguousReasonSchema: z.ZodEnum<{
+  "containment-unproven": "containment-unproven";
+  "dispatch-armed": "dispatch-armed";
+  "dispatch-state-unknown": "dispatch-state-unknown";
+}>;
 declare const ControllerExecutionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-  auditCorrelationId: z.ZodString;
+  binding: z.ZodObject<{
+    fingerprint: z.ZodString;
+    operationId: z.ZodString;
+  }, z.core.$strict>;
+  certainty: z.ZodLiteral<"proven">;
+  completion: z.ZodLiteral<"succeeded">;
   diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
     code: z.ZodEnum<{
       approval_required: "approval_required";
@@ -26,10 +50,91 @@ declare const ControllerExecutionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     safeMessage: z.ZodString;
     safeParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
   }, z.core.$strict>>>;
-  status: z.ZodLiteral<"ok">;
+  kind: z.ZodLiteral<"completed">;
+  retryClass: z.ZodLiteral<"forbidden">;
   value: z.ZodType<_$_agent_vm_agent_portal_sdk0.JsonValue, unknown, z.core.$ZodTypeInternals<_$_agent_vm_agent_portal_sdk0.JsonValue, unknown>>;
 }, z.core.$strict>, z.ZodObject<{
-  auditCorrelationId: z.ZodOptional<z.ZodString>;
+  binding: z.ZodOptional<z.ZodObject<{
+    fingerprint: z.ZodString;
+    operationId: z.ZodString;
+  }, z.core.$strict>>;
+  certainty: z.ZodLiteral<"proven">;
+  diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    code: z.ZodEnum<{
+      approval_required: "approval_required";
+      capability_denied: "capability_denied";
+      validation_failed: "validation_failed";
+      provider_unavailable: "provider_unavailable";
+      execution_failed: "execution_failed";
+      cancelled: "cancelled";
+      timeout: "timeout";
+      output_truncated: "output_truncated";
+      artifact_unavailable: "artifact_unavailable";
+    }>;
+    level: z.ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+    }>;
+    safeMessage: z.ZodString;
+    safeParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+  }, z.core.$strict>>>;
+  error: z.ZodObject<{
+    code: z.ZodEnum<{
+      invalid_request: "invalid_request";
+      not_found: "not_found";
+      not_authorized: "not_authorized";
+      approval_required: "approval_required";
+      capability_denied: "capability_denied";
+      validation_failed: "validation_failed";
+      provider_unavailable: "provider_unavailable";
+      execution_failed: "execution_failed";
+      cancelled: "cancelled";
+      timeout: "timeout";
+    }>;
+    message: z.ZodString;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    safeDiagnostic: z.ZodOptional<z.ZodObject<{
+      code: z.ZodEnum<{
+        approval_required: "approval_required";
+        capability_denied: "capability_denied";
+        validation_failed: "validation_failed";
+        provider_unavailable: "provider_unavailable";
+        execution_failed: "execution_failed";
+        cancelled: "cancelled";
+        timeout: "timeout";
+        output_truncated: "output_truncated";
+        artifact_unavailable: "artifact_unavailable";
+      }>;
+      level: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+      }>;
+      safeMessage: z.ZodString;
+      safeParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  kind: z.ZodLiteral<"not-dispatched">;
+  reason: z.ZodEnum<{
+    "authorization-fingerprint-changed": "authorization-fingerprint-changed";
+    "current-epoch-changed": "current-epoch-changed";
+    denied: "denied";
+    "duplicate-operation": "duplicate-operation";
+    "predecessor-owner-unsafe": "predecessor-owner-unsafe";
+    "public-authority-or-policy-override": "public-authority-or-policy-override";
+    "runner-setup-failed": "runner-setup-failed";
+    "stale-authority": "stale-authority";
+  }>;
+  retryClass: z.ZodLiteral<"safe-before-dispatch">;
+}, z.core.$strict>, z.ZodObject<{
+  binding: z.ZodObject<{
+    fingerprint: z.ZodString;
+    operationId: z.ZodString;
+  }, z.core.$strict>;
+  certainty: z.ZodLiteral<"side-effects-and-termination-unknown">;
   diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
     code: z.ZodEnum<{
       approval_required: "approval_required";
@@ -88,8 +193,15 @@ declare const ControllerExecutionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObj
       safeParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
     }, z.core.$strict>>;
   }, z.core.$strict>;
-  status: z.ZodLiteral<"error">;
-}, z.core.$strict>], "status">;
+  kind: z.ZodLiteral<"ambiguous">;
+  reason: z.ZodEnum<{
+    "containment-unproven": "containment-unproven";
+    "dispatch-armed": "dispatch-armed";
+    "dispatch-state-unknown": "dispatch-state-unknown";
+  }>;
+  retryClass: z.ZodLiteral<"forbidden">;
+}, z.core.$strict>], "kind">;
+type ControllerExecutionAuthorityBinding = z.infer<typeof ControllerExecutionAuthorityBindingSchema>;
 type ControllerExecutionResult = z.infer<typeof ControllerExecutionResultSchema>;
 //#endregion
 //#region src/controller-dispatch-boundary/models/execution-fingerprint-schema.d.ts
@@ -115,5 +227,5 @@ declare const ExecutionFingerprintSchema: z.ZodObject<{
 }, z.core.$strict>;
 type ExecutionFingerprint = z.infer<typeof ExecutionFingerprintSchema>;
 //#endregion
-export { ControllerDispatchIntent, ControllerDispatchIntentSchema, ControllerExecutionResult, ControllerExecutionResultSchema, ControllerTrustedScopeSchema, ExecutionFingerprint, ExecutionFingerprintSchema };
+export { ControllerDispatchIntent, ControllerDispatchIntentSchema, ControllerExecutionAmbiguousReasonSchema, ControllerExecutionAuthorityBinding, ControllerExecutionAuthorityBindingSchema, ControllerExecutionNotDispatchedReasonSchema, ControllerExecutionResult, ControllerExecutionResultSchema, ControllerTrustedScopeSchema, ExecutionFingerprint, ExecutionFingerprintSchema };
 //# sourceMappingURL=index.d.ts.map

package/dist/controller-dispatch-boundary/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/controller-dispatch-boundary/models/controller-execution-result-schema.ts","../../src/controller-dispatch-boundary/models/execution-fingerprint-schema.ts"],"mappings":";;;;;cAOa,+BAAA,EAA+B,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmBhC,yBAAA,GAA4B,CAAA,CAAE,KAAA,QAAa,+BAAA;;;cCvB1C,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;KAiB3B,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,0BAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/controller-dispatch-boundary/models/controller-execution-result-schema.ts","../../src/controller-dispatch-boundary/models/execution-fingerprint-schema.ts"],"mappings":";;;;;cAOa,yCAAA,EAAyC,CAAA,CAAA,SAAA;;;;cAOzC,4CAAA,EAA4C,CAAA,CAAA,OAAA;;;;;;;;;;cAW5C,wCAAA,EAAwC,CAAA,CAAA,OAAA;;;;;cA0CxC,+BAAA,EAA+B,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMhC,mCAAA,GAAsC,CAAA,CAAE,KAAA,QAC5C,yCAAA;AAAA,KAEI,yBAAA,GAA4B,CAAA,CAAE,KAAA,QAAa,+BAAA;;;cCzE1C,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;KAiB3B,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,0BAAA"}

package/dist/controller-dispatch-boundary/index.js

@@ -1,4 +1,4 @@
 import { n as ControllerTrustedScopeSchema, t as ControllerDispatchIntentSchema } from "../controller-dispatch-intent-schema-dw3ugqpe.js";
-import { t as ControllerExecutionResultSchema } from "../controller-execution-result-schema-BN0cqzhi.js";
+import { i as ControllerExecutionResultSchema, n as ControllerExecutionAuthorityBindingSchema, r as ControllerExecutionNotDispatchedReasonSchema, t as ControllerExecutionAmbiguousReasonSchema } from "../controller-execution-result-schema-CWymsFAD.js";
 import { t as ExecutionFingerprintSchema } from "../execution-fingerprint-schema-D4J978Oa.js";
-export { ControllerDispatchIntentSchema, ControllerExecutionResultSchema, ControllerTrustedScopeSchema, ExecutionFingerprintSchema };
+export { ControllerDispatchIntentSchema, ControllerExecutionAmbiguousReasonSchema, ControllerExecutionAuthorityBindingSchema, ControllerExecutionNotDispatchedReasonSchema, ControllerExecutionResultSchema, ControllerTrustedScopeSchema, ExecutionFingerprintSchema };

package/dist/controller-execution-data-boundary/index.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod/v4";
+
+//#region src/controller-execution-data-boundary/index.d.ts
+declare const ControllerExecutionDataPayloadMaxBytes: number;
+declare const ControllerExecutionWebSocketPath = "/agent-vm/controller-execution";
+declare const ControllerExecutionDataBindingSchema: z.ZodObject<{
+  audience: z.ZodLiteral<"controller-execution-data">;
+  channelId: z.ZodString;
+  controllerEpoch: z.ZodString;
+  executionFingerprint: z.ZodString;
+  gatewayEpoch: z.ZodString;
+  operationId: z.ZodString;
+  runtimeEpoch: z.ZodString;
+  stablePrincipal: z.ZodString;
+}, z.core.$strict>;
+declare const ControllerExecutionDataHandshakeSchema: z.ZodObject<{
+  audience: z.ZodLiteral<"controller-execution-data">;
+  channelId: z.ZodString;
+  controllerEpoch: z.ZodString;
+  executionFingerprint: z.ZodString;
+  gatewayEpoch: z.ZodString;
+  operationId: z.ZodString;
+  runtimeEpoch: z.ZodString;
+  stablePrincipal: z.ZodString;
+  kind: z.ZodLiteral<"handshake">;
+}, z.core.$strict>;
+declare const ControllerExecutionDataCreditSchema: z.ZodObject<{
+  audience: z.ZodLiteral<"controller-execution-data">;
+  channelId: z.ZodString;
+  controllerEpoch: z.ZodString;
+  executionFingerprint: z.ZodString;
+  gatewayEpoch: z.ZodString;
+  operationId: z.ZodString;
+  runtimeEpoch: z.ZodString;
+  stablePrincipal: z.ZodString;
+  availableCreditBytes: z.ZodNumber;
+  kind: z.ZodLiteral<"credit">;
+  nextSequence: z.ZodNumber;
+  queuedBytes: z.ZodNumber;
+}, z.core.$strict>;
+declare const ControllerExecutionDataFrameSchema: z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
+  audience: z.ZodLiteral<"controller-execution-data">;
+  channelId: z.ZodString;
+  controllerEpoch: z.ZodString;
+  executionFingerprint: z.ZodString;
+  gatewayEpoch: z.ZodString;
+  operationId: z.ZodString;
+  runtimeEpoch: z.ZodString;
+  stablePrincipal: z.ZodString;
+  creditBytes: z.ZodNumber;
+  kind: z.ZodLiteral<"data">;
+  payloadBase64: z.ZodString;
+  sequence: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  audience: z.ZodLiteral<"controller-execution-data">;
+  channelId: z.ZodString;
+  controllerEpoch: z.ZodString;
+  executionFingerprint: z.ZodString;
+  gatewayEpoch: z.ZodString;
+  operationId: z.ZodString;
+  runtimeEpoch: z.ZodString;
+  stablePrincipal: z.ZodString;
+  creditBytes: z.ZodNumber;
+  kind: z.ZodLiteral<"eof">;
+  sequence: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+  audience: z.ZodLiteral<"controller-execution-data">;
+  channelId: z.ZodString;
+  controllerEpoch: z.ZodString;
+  executionFingerprint: z.ZodString;
+  gatewayEpoch: z.ZodString;
+  operationId: z.ZodString;
+  runtimeEpoch: z.ZodString;
+  stablePrincipal: z.ZodString;
+  creditBytes: z.ZodNumber;
+  kind: z.ZodLiteral<"cancel">;
+  sequence: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+type ControllerExecutionDataBinding = z.infer<typeof ControllerExecutionDataBindingSchema>;
+type ControllerExecutionDataCredit = z.infer<typeof ControllerExecutionDataCreditSchema>;
+type ControllerExecutionDataFrame = z.infer<typeof ControllerExecutionDataFrameSchema>;
+type ControllerExecutionDataHandshake = z.infer<typeof ControllerExecutionDataHandshakeSchema>;
+//#endregion
+export { ControllerExecutionDataBinding, ControllerExecutionDataCredit, ControllerExecutionDataCreditSchema, ControllerExecutionDataFrame, ControllerExecutionDataFrameSchema, ControllerExecutionDataHandshake, ControllerExecutionDataHandshakeSchema, ControllerExecutionDataPayloadMaxBytes, ControllerExecutionWebSocketPath };
+//# sourceMappingURL=index.d.ts.map

package/dist/controller-execution-data-boundary/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/controller-execution-data-boundary/index.ts"],"mappings":";;;cAGa,sCAAA;AAAA,cACA,gCAAA;AAAA,cAYP,oCAAA,EAAoC,CAAA,CAAA,SAAA;;;;;;;;;;cAe7B,sCAAA,EAAsC,CAAA,CAAA,SAAA;;;;;;;;;;;cAItC,mCAAA,EAAmC,CAAA,CAAA,SAAA;;;;;;;;;;;;;;cA8BnC,kCAAA,EAAkC,CAAA,CAAA,qBAAA,WAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKnC,8BAAA,GAAiC,CAAA,CAAE,KAAA,QAAa,oCAAA;AAAA,KAChD,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,mCAAA;AAAA,KAC/C,4BAAA,GAA+B,CAAA,CAAE,KAAA,QAAa,kCAAA;AAAA,KAC9C,gCAAA,GAAmC,CAAA,CAAE,KAAA,QACzC,sCAAA"}

package/dist/controller-execution-data-boundary/index.js

@@ -0,0 +1,53 @@
+import { GatewayStablePrincipalDigestSchema } from "@agent-vm/agent-portal-sdk/contracts";
+import { z } from "zod/v4";
+//#region src/controller-execution-data-boundary/index.ts
+const ControllerExecutionDataPayloadMaxBytes = 1024 * 1024;
+const ControllerExecutionWebSocketPath = "/agent-vm/controller-execution";
+const canonicalPaddedBase64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
+function isCanonicalBoundedExecutionPayload(value) {
+	if (value.length < 4 || !canonicalPaddedBase64Pattern.test(value)) return false;
+	const paddingBytes = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+	return value.length / 4 * 3 - paddingBytes <= ControllerExecutionDataPayloadMaxBytes;
+}
+const ControllerExecutionDataBindingSchema = z.object({
+	audience: z.literal("controller-execution-data"),
+	channelId: z.string().min(1),
+	controllerEpoch: z.string().min(1),
+	executionFingerprint: z.string().min(1),
+	gatewayEpoch: z.string().min(1),
+	operationId: z.string().min(1),
+	runtimeEpoch: z.string().min(1),
+	stablePrincipal: GatewayStablePrincipalDigestSchema
+}).strict();
+const ControllerExecutionFrameSequenceSchema = z.number().int().nonnegative().safe();
+const ControllerExecutionDataHandshakeSchema = ControllerExecutionDataBindingSchema.extend({ kind: z.literal("handshake") }).strict();
+const ControllerExecutionDataCreditSchema = ControllerExecutionDataBindingSchema.extend({
+	availableCreditBytes: ControllerExecutionFrameSequenceSchema,
+	kind: z.literal("credit"),
+	nextSequence: ControllerExecutionFrameSequenceSchema,
+	queuedBytes: ControllerExecutionFrameSequenceSchema
+}).strict();
+const ControllerExecutionDataPayloadSchema = z.string().refine(isCanonicalBoundedExecutionPayload, { message: `Execution data payload must be canonical padded base64 containing at most ${ControllerExecutionDataPayloadMaxBytes} decoded bytes.` });
+const ControllerExecutionDataFrameVariantSchemas = [
+	ControllerExecutionDataBindingSchema.extend({
+		creditBytes: ControllerExecutionFrameSequenceSchema,
+		kind: z.literal("data"),
+		payloadBase64: ControllerExecutionDataPayloadSchema,
+		sequence: ControllerExecutionFrameSequenceSchema
+	}).strict(),
+	ControllerExecutionDataBindingSchema.extend({
+		creditBytes: ControllerExecutionFrameSequenceSchema,
+		kind: z.literal("eof"),
+		sequence: ControllerExecutionFrameSequenceSchema
+	}).strict(),
+	ControllerExecutionDataBindingSchema.extend({
+		creditBytes: ControllerExecutionFrameSequenceSchema,
+		kind: z.literal("cancel"),
+		sequence: ControllerExecutionFrameSequenceSchema
+	}).strict()
+];
+const ControllerExecutionDataFrameSchema = z.discriminatedUnion("kind", ControllerExecutionDataFrameVariantSchemas);
+//#endregion
+export { ControllerExecutionDataCreditSchema, ControllerExecutionDataFrameSchema, ControllerExecutionDataHandshakeSchema, ControllerExecutionDataPayloadMaxBytes, ControllerExecutionWebSocketPath };
+
+//# sourceMappingURL=index.js.map

package/dist/controller-execution-data-boundary/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/controller-execution-data-boundary/index.ts"],"sourcesContent":["import { GatewayStablePrincipalDigestSchema } from '@agent-vm/agent-portal-sdk/contracts';\nimport { z } from 'zod/v4';\n\nexport const ControllerExecutionDataPayloadMaxBytes = 1024 * 1024;\nexport const ControllerExecutionWebSocketPath = '/agent-vm/controller-execution';\n\nconst canonicalPaddedBase64Pattern =\n\t/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;\n\nfunction isCanonicalBoundedExecutionPayload(value: string): boolean {\n\tif (value.length < 4 || !canonicalPaddedBase64Pattern.test(value)) return false;\n\tconst paddingBytes = value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0;\n\tconst decodedBytes = (value.length / 4) * 3 - paddingBytes;\n\treturn decodedBytes <= ControllerExecutionDataPayloadMaxBytes;\n}\n\nconst ControllerExecutionDataBindingSchema = z\n\t.object({\n\t\taudience: z.literal('controller-execution-data'),\n\t\tchannelId: z.string().min(1),\n\t\tcontrollerEpoch: z.string().min(1),\n\t\texecutionFingerprint: z.string().min(1),\n\t\tgatewayEpoch: z.string().min(1),\n\t\toperationId: z.string().min(1),\n\t\truntimeEpoch: z.string().min(1),\n\t\tstablePrincipal: GatewayStablePrincipalDigestSchema,\n\t})\n\t.strict();\n\nconst ControllerExecutionFrameSequenceSchema = z.number().int().nonnegative().safe();\n\nexport const ControllerExecutionDataHandshakeSchema = ControllerExecutionDataBindingSchema.extend({\n\tkind: z.literal('handshake'),\n}).strict();\n\nexport const ControllerExecutionDataCreditSchema = ControllerExecutionDataBindingSchema.extend({\n\tavailableCreditBytes: ControllerExecutionFrameSequenceSchema,\n\tkind: z.literal('credit'),\n\tnextSequence: ControllerExecutionFrameSequenceSchema,\n\tqueuedBytes: ControllerExecutionFrameSequenceSchema,\n}).strict();\n\nconst ControllerExecutionDataPayloadSchema = z.string().refine(isCanonicalBoundedExecutionPayload, {\n\tmessage: `Execution data payload must be canonical padded base64 containing at most ${ControllerExecutionDataPayloadMaxBytes} decoded bytes.`,\n});\n\nconst ControllerExecutionDataFrameVariantSchemas = [\n\tControllerExecutionDataBindingSchema.extend({\n\t\tcreditBytes: ControllerExecutionFrameSequenceSchema,\n\t\tkind: z.literal('data'),\n\t\tpayloadBase64: ControllerExecutionDataPayloadSchema,\n\t\tsequence: ControllerExecutionFrameSequenceSchema,\n\t}).strict(),\n\tControllerExecutionDataBindingSchema.extend({\n\t\tcreditBytes: ControllerExecutionFrameSequenceSchema,\n\t\tkind: z.literal('eof'),\n\t\tsequence: ControllerExecutionFrameSequenceSchema,\n\t}).strict(),\n\tControllerExecutionDataBindingSchema.extend({\n\t\tcreditBytes: ControllerExecutionFrameSequenceSchema,\n\t\tkind: z.literal('cancel'),\n\t\tsequence: ControllerExecutionFrameSequenceSchema,\n\t}).strict(),\n] as const;\n\nexport const ControllerExecutionDataFrameSchema = z.discriminatedUnion(\n\t'kind',\n\tControllerExecutionDataFrameVariantSchemas,\n);\n\nexport type ControllerExecutionDataBinding = z.infer<typeof ControllerExecutionDataBindingSchema>;\nexport type ControllerExecutionDataCredit = z.infer<typeof ControllerExecutionDataCreditSchema>;\nexport type ControllerExecutionDataFrame = z.infer<typeof ControllerExecutionDataFrameSchema>;\nexport type ControllerExecutionDataHandshake = z.infer<\n\ttypeof ControllerExecutionDataHandshakeSchema\n>;\n"],"mappings":";;;AAGA,MAAa,yCAAyC,OAAO;AAC7D,MAAa,mCAAmC;AAEhD,MAAM,+BACL;AAED,SAAS,mCAAmC,OAAwB;CACnE,IAAI,MAAM,SAAS,KAAK,CAAC,6BAA6B,KAAK,MAAM,EAAE,OAAO;CAC1E,MAAM,eAAe,MAAM,SAAS,KAAK,GAAG,IAAI,MAAM,SAAS,IAAI,GAAG,IAAI;CAE1E,OADsB,MAAM,SAAS,IAAK,IAAI,gBACvB;;AAGxB,MAAM,uCAAuC,EAC3C,OAAO;CACP,UAAU,EAAE,QAAQ,4BAA4B;CAChD,WAAW,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC5B,iBAAiB,EAAE,QAAQ,CAAC,IAAI,EAAE;CAClC,sBAAsB,EAAE,QAAQ,CAAC,IAAI,EAAE;CACvC,cAAc,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC/B,aAAa,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC9B,cAAc,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC/B,iBAAiB;CACjB,CAAC,CACD,QAAQ;AAEV,MAAM,yCAAyC,EAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,MAAM;AAEpF,MAAa,yCAAyC,qCAAqC,OAAO,EACjG,MAAM,EAAE,QAAQ,YAAY,EAC5B,CAAC,CAAC,QAAQ;AAEX,MAAa,sCAAsC,qCAAqC,OAAO;CAC9F,sBAAsB;CACtB,MAAM,EAAE,QAAQ,SAAS;CACzB,cAAc;CACd,aAAa;CACb,CAAC,CAAC,QAAQ;AAEX,MAAM,uCAAuC,EAAE,QAAQ,CAAC,OAAO,oCAAoC,EAClG,SAAS,6EAA6E,uCAAuC,kBAC7H,CAAC;AAEF,MAAM,6CAA6C;CAClD,qCAAqC,OAAO;EAC3C,aAAa;EACb,MAAM,EAAE,QAAQ,OAAO;EACvB,eAAe;EACf,UAAU;EACV,CAAC,CAAC,QAAQ;CACX,qCAAqC,OAAO;EAC3C,aAAa;EACb,MAAM,EAAE,QAAQ,MAAM;EACtB,UAAU;EACV,CAAC,CAAC,QAAQ;CACX,qCAAqC,OAAO;EAC3C,aAAa;EACb,MAAM,EAAE,QAAQ,SAAS;EACzB,UAAU;EACV,CAAC,CAAC,QAAQ;CACX;AAED,MAAa,qCAAqC,EAAE,mBACnD,QACA,2CACA"}

package/dist/controller-execution-result-schema-CWymsFAD.js

@@ -0,0 +1,58 @@
+import { JsonValueSchema, PortalErrorSchema, SafeDiagnosticSchema } from "@agent-vm/agent-portal-sdk";
+import { z } from "zod";
+//#region src/controller-dispatch-boundary/models/controller-execution-result-schema.ts
+const ControllerExecutionAuthorityBindingSchema = z.object({
+	fingerprint: z.string().min(1),
+	operationId: z.string().min(1)
+}).strict();
+const ControllerExecutionNotDispatchedReasonSchema = z.enum([
+	"authorization-fingerprint-changed",
+	"current-epoch-changed",
+	"denied",
+	"duplicate-operation",
+	"predecessor-owner-unsafe",
+	"public-authority-or-policy-override",
+	"runner-setup-failed",
+	"stale-authority"
+]);
+const ControllerExecutionAmbiguousReasonSchema = z.enum([
+	"containment-unproven",
+	"dispatch-armed",
+	"dispatch-state-unknown"
+]);
+const ControllerExecutionCompletedResultSchema = z.object({
+	binding: ControllerExecutionAuthorityBindingSchema,
+	certainty: z.literal("proven"),
+	completion: z.literal("succeeded"),
+	diagnostics: z.array(SafeDiagnosticSchema).default([]),
+	kind: z.literal("completed"),
+	retryClass: z.literal("forbidden"),
+	value: JsonValueSchema
+}).strict();
+const ControllerExecutionNotDispatchedResultSchema = z.object({
+	binding: ControllerExecutionAuthorityBindingSchema.optional(),
+	certainty: z.literal("proven"),
+	diagnostics: z.array(SafeDiagnosticSchema).default([]),
+	error: PortalErrorSchema,
+	kind: z.literal("not-dispatched"),
+	reason: ControllerExecutionNotDispatchedReasonSchema,
+	retryClass: z.literal("safe-before-dispatch")
+}).strict();
+const ControllerExecutionAmbiguousResultSchema = z.object({
+	binding: ControllerExecutionAuthorityBindingSchema,
+	certainty: z.literal("side-effects-and-termination-unknown"),
+	diagnostics: z.array(SafeDiagnosticSchema).default([]),
+	error: PortalErrorSchema,
+	kind: z.literal("ambiguous"),
+	reason: ControllerExecutionAmbiguousReasonSchema,
+	retryClass: z.literal("forbidden")
+}).strict();
+const ControllerExecutionResultSchema = z.discriminatedUnion("kind", [
+	ControllerExecutionCompletedResultSchema,
+	ControllerExecutionNotDispatchedResultSchema,
+	ControllerExecutionAmbiguousResultSchema
+]);
+//#endregion
+export { ControllerExecutionResultSchema as i, ControllerExecutionAuthorityBindingSchema as n, ControllerExecutionNotDispatchedReasonSchema as r, ControllerExecutionAmbiguousReasonSchema as t };
+
+//# sourceMappingURL=controller-execution-result-schema-CWymsFAD.js.map

package/dist/controller-execution-result-schema-CWymsFAD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-execution-result-schema-CWymsFAD.js","names":[],"sources":["../src/controller-dispatch-boundary/models/controller-execution-result-schema.ts"],"sourcesContent":["import {\n\tJsonValueSchema,\n\tPortalErrorSchema,\n\tSafeDiagnosticSchema,\n} from '@agent-vm/agent-portal-sdk';\nimport { z } from 'zod';\n\nexport const ControllerExecutionAuthorityBindingSchema = z\n\t.object({\n\t\tfingerprint: z.string().min(1),\n\t\toperationId: z.string().min(1),\n\t})\n\t.strict();\n\nexport const ControllerExecutionNotDispatchedReasonSchema = z.enum([\n\t'authorization-fingerprint-changed',\n\t'current-epoch-changed',\n\t'denied',\n\t'duplicate-operation',\n\t'predecessor-owner-unsafe',\n\t'public-authority-or-policy-override',\n\t'runner-setup-failed',\n\t'stale-authority',\n]);\n\nexport const ControllerExecutionAmbiguousReasonSchema = z.enum([\n\t'containment-unproven',\n\t'dispatch-armed',\n\t'dispatch-state-unknown',\n]);\n\nconst ControllerExecutionCompletedResultSchema = z\n\t.object({\n\t\tbinding: ControllerExecutionAuthorityBindingSchema,\n\t\tcertainty: z.literal('proven'),\n\t\tcompletion: z.literal('succeeded'),\n\t\tdiagnostics: z.array(SafeDiagnosticSchema).default([]),\n\t\tkind: z.literal('completed'),\n\t\tretryClass: z.literal('forbidden'),\n\t\tvalue: JsonValueSchema,\n\t})\n\t.strict();\n\nconst ControllerExecutionNotDispatchedResultSchema = z\n\t.object({\n\t\tbinding: ControllerExecutionAuthorityBindingSchema.optional(),\n\t\tcertainty: z.literal('proven'),\n\t\tdiagnostics: z.array(SafeDiagnosticSchema).default([]),\n\t\terror: PortalErrorSchema,\n\t\tkind: z.literal('not-dispatched'),\n\t\treason: ControllerExecutionNotDispatchedReasonSchema,\n\t\tretryClass: z.literal('safe-before-dispatch'),\n\t})\n\t.strict();\n\nconst ControllerExecutionAmbiguousResultSchema = z\n\t.object({\n\t\tbinding: ControllerExecutionAuthorityBindingSchema,\n\t\tcertainty: z.literal('side-effects-and-termination-unknown'),\n\t\tdiagnostics: z.array(SafeDiagnosticSchema).default([]),\n\t\terror: PortalErrorSchema,\n\t\tkind: z.literal('ambiguous'),\n\t\treason: ControllerExecutionAmbiguousReasonSchema,\n\t\tretryClass: z.literal('forbidden'),\n\t})\n\t.strict();\n\nexport const ControllerExecutionResultSchema = z.discriminatedUnion('kind', [\n\tControllerExecutionCompletedResultSchema,\n\tControllerExecutionNotDispatchedResultSchema,\n\tControllerExecutionAmbiguousResultSchema,\n]);\n\nexport type ControllerExecutionAuthorityBinding = z.infer<\n\ttypeof ControllerExecutionAuthorityBindingSchema\n>;\nexport type ControllerExecutionResult = z.infer<typeof ControllerExecutionResultSchema>;\n"],"mappings":";;;AAOA,MAAa,4CAA4C,EACvD,OAAO;CACP,aAAa,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC9B,aAAa,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC9B,CAAC,CACD,QAAQ;AAEV,MAAa,+CAA+C,EAAE,KAAK;CAClE;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC;AAEF,MAAa,2CAA2C,EAAE,KAAK;CAC9D;CACA;CACA;CACA,CAAC;AAEF,MAAM,2CAA2C,EAC/C,OAAO;CACP,SAAS;CACT,WAAW,EAAE,QAAQ,SAAS;CAC9B,YAAY,EAAE,QAAQ,YAAY;CAClC,aAAa,EAAE,MAAM,qBAAqB,CAAC,QAAQ,EAAE,CAAC;CACtD,MAAM,EAAE,QAAQ,YAAY;CAC5B,YAAY,EAAE,QAAQ,YAAY;CAClC,OAAO;CACP,CAAC,CACD,QAAQ;AAEV,MAAM,+CAA+C,EACnD,OAAO;CACP,SAAS,0CAA0C,UAAU;CAC7D,WAAW,EAAE,QAAQ,SAAS;CAC9B,aAAa,EAAE,MAAM,qBAAqB,CAAC,QAAQ,EAAE,CAAC;CACtD,OAAO;CACP,MAAM,EAAE,QAAQ,iBAAiB;CACjC,QAAQ;CACR,YAAY,EAAE,QAAQ,uBAAuB;CAC7C,CAAC,CACD,QAAQ;AAEV,MAAM,2CAA2C,EAC/C,OAAO;CACP,SAAS;CACT,WAAW,EAAE,QAAQ,uCAAuC;CAC5D,aAAa,EAAE,MAAM,qBAAqB,CAAC,QAAQ,EAAE,CAAC;CACtD,OAAO;CACP,MAAM,EAAE,QAAQ,YAAY;CAC5B,QAAQ;CACR,YAAY,EAAE,QAAQ,YAAY;CAClC,CAAC,CACD,QAAQ;AAEV,MAAa,kCAAkC,EAAE,mBAAmB,QAAQ;CAC3E;CACA;CACA;CACA,CAAC"}

package/dist/controller-host-action-boundary/index.d.ts

@@ -25,7 +25,12 @@ type ControllerHostActionRequest = z.infer<typeof ControllerHostActionRequestSch
 //#endregion
 //#region src/controller-host-action-boundary/models/controller-host-action-result-schema.d.ts
 declare const ControllerHostActionResultSchema: _$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
-  auditCorrelationId: _$zod.ZodString;
+  binding: _$zod.ZodObject<{
+    fingerprint: _$zod.ZodString;
+    operationId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strict>;
+  certainty: _$zod.ZodLiteral<"proven">;
+  completion: _$zod.ZodLiteral<"succeeded">;
   diagnostics: _$zod.ZodDefault<_$zod.ZodArray<_$zod.ZodObject<{
     code: _$zod.ZodEnum<{
       approval_required: "approval_required";
@@ -47,10 +52,91 @@ declare const ControllerHostActionResultSchema: _$zod.ZodDiscriminatedUnion<[_$z
     safeMessage: _$zod.ZodString;
     safeParams: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodNumber, _$zod.ZodBoolean]>>>;
   }, _$zod_v4_core0.$strict>>>;
-  status: _$zod.ZodLiteral<"ok">;
+  kind: _$zod.ZodLiteral<"completed">;
+  retryClass: _$zod.ZodLiteral<"forbidden">;
   value: _$zod.ZodType<_$_agent_vm_agent_portal_sdk0.JsonValue, unknown, _$zod_v4_core0.$ZodTypeInternals<_$_agent_vm_agent_portal_sdk0.JsonValue, unknown>>;
 }, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
-  auditCorrelationId: _$zod.ZodOptional<_$zod.ZodString>;
+  binding: _$zod.ZodOptional<_$zod.ZodObject<{
+    fingerprint: _$zod.ZodString;
+    operationId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strict>>;
+  certainty: _$zod.ZodLiteral<"proven">;
+  diagnostics: _$zod.ZodDefault<_$zod.ZodArray<_$zod.ZodObject<{
+    code: _$zod.ZodEnum<{
+      approval_required: "approval_required";
+      capability_denied: "capability_denied";
+      validation_failed: "validation_failed";
+      provider_unavailable: "provider_unavailable";
+      execution_failed: "execution_failed";
+      cancelled: "cancelled";
+      timeout: "timeout";
+      output_truncated: "output_truncated";
+      artifact_unavailable: "artifact_unavailable";
+    }>;
+    level: _$zod.ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+    }>;
+    safeMessage: _$zod.ZodString;
+    safeParams: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodNumber, _$zod.ZodBoolean]>>>;
+  }, _$zod_v4_core0.$strict>>>;
+  error: _$zod.ZodObject<{
+    code: _$zod.ZodEnum<{
+      invalid_request: "invalid_request";
+      not_found: "not_found";
+      not_authorized: "not_authorized";
+      approval_required: "approval_required";
+      capability_denied: "capability_denied";
+      validation_failed: "validation_failed";
+      provider_unavailable: "provider_unavailable";
+      execution_failed: "execution_failed";
+      cancelled: "cancelled";
+      timeout: "timeout";
+    }>;
+    message: _$zod.ZodString;
+    retryable: _$zod.ZodOptional<_$zod.ZodBoolean>;
+    safeDiagnostic: _$zod.ZodOptional<_$zod.ZodObject<{
+      code: _$zod.ZodEnum<{
+        approval_required: "approval_required";
+        capability_denied: "capability_denied";
+        validation_failed: "validation_failed";
+        provider_unavailable: "provider_unavailable";
+        execution_failed: "execution_failed";
+        cancelled: "cancelled";
+        timeout: "timeout";
+        output_truncated: "output_truncated";
+        artifact_unavailable: "artifact_unavailable";
+      }>;
+      level: _$zod.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+      }>;
+      safeMessage: _$zod.ZodString;
+      safeParams: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodNumber, _$zod.ZodBoolean]>>>;
+    }, _$zod_v4_core0.$strict>>;
+  }, _$zod_v4_core0.$strict>;
+  kind: _$zod.ZodLiteral<"not-dispatched">;
+  reason: _$zod.ZodEnum<{
+    "authorization-fingerprint-changed": "authorization-fingerprint-changed";
+    "current-epoch-changed": "current-epoch-changed";
+    denied: "denied";
+    "duplicate-operation": "duplicate-operation";
+    "predecessor-owner-unsafe": "predecessor-owner-unsafe";
+    "public-authority-or-policy-override": "public-authority-or-policy-override";
+    "runner-setup-failed": "runner-setup-failed";
+    "stale-authority": "stale-authority";
+  }>;
+  retryClass: _$zod.ZodLiteral<"safe-before-dispatch">;
+}, _$zod_v4_core0.$strict>, _$zod.ZodObject<{
+  binding: _$zod.ZodObject<{
+    fingerprint: _$zod.ZodString;
+    operationId: _$zod.ZodString;
+  }, _$zod_v4_core0.$strict>;
+  certainty: _$zod.ZodLiteral<"side-effects-and-termination-unknown">;
   diagnostics: _$zod.ZodDefault<_$zod.ZodArray<_$zod.ZodObject<{
     code: _$zod.ZodEnum<{
       approval_required: "approval_required";
@@ -109,8 +195,14 @@ declare const ControllerHostActionResultSchema: _$zod.ZodDiscriminatedUnion<[_$z
       safeParams: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodUnion<readonly [_$zod.ZodString, _$zod.ZodNumber, _$zod.ZodBoolean]>>>;
     }, _$zod_v4_core0.$strict>>;
   }, _$zod_v4_core0.$strict>;
-  status: _$zod.ZodLiteral<"error">;
-}, _$zod_v4_core0.$strict>], "status">;
+  kind: _$zod.ZodLiteral<"ambiguous">;
+  reason: _$zod.ZodEnum<{
+    "containment-unproven": "containment-unproven";
+    "dispatch-armed": "dispatch-armed";
+    "dispatch-state-unknown": "dispatch-state-unknown";
+  }>;
+  retryClass: _$zod.ZodLiteral<"forbidden">;
+}, _$zod_v4_core0.$strict>], "kind">;
 type ControllerHostActionResult = typeof ControllerHostActionResultSchema._output;
 //#endregion
 export { ControllerHostActionRequest, ControllerHostActionRequestSchema, ControllerHostActionResult, ControllerHostActionResultSchema };

package/dist/controller-host-action-boundary/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/controller-host-action-boundary/models/controller-host-action-request-schema.ts","../../src/controller-host-action-boundary/models/controller-host-action-result-schema.ts"],"mappings":";;;;;;cAKa,iCAAA,EAAiC,CAAA,CAAA,SAAA;gCAMpC,6BAAA,CAAA,UAAA;;;;;;;;;;;;;;;;KAEE,2BAAA,GAA8B,CAAA,CAAE,KAAA,QAAa,iCAAA;;;cCX5C,gCAAA,QAAgC,qBAAA,QAAA,SAAA;sBAAkC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;wCAAlC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEjC,0BAAA,UAAoC,gCAAA,CAAiC,OAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/controller-host-action-boundary/models/controller-host-action-request-schema.ts","../../src/controller-host-action-boundary/models/controller-host-action-result-schema.ts"],"mappings":";;;;;;cAKa,iCAAA,EAAiC,CAAA,CAAA,SAAA;gCAMpC,6BAAA,CAAA,UAAA;;;;;;;;;;;;;;;;KAEE,2BAAA,GAA8B,CAAA,CAAE,KAAA,QAAa,iCAAA;;;cCX5C,gCAAA,QAAgC,qBAAA,QAAA,SAAA;;iBAAkC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAlC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEjC,0BAAA,UAAoC,gCAAA,CAAiC,OAAA"}

package/dist/controller-host-action-boundary/index.js

@@ -1,5 +1,5 @@
 import { t as ControllerDispatchIntentSchema } from "../controller-dispatch-intent-schema-dw3ugqpe.js";
-import { t as ControllerExecutionResultSchema } from "../controller-execution-result-schema-BN0cqzhi.js";
+import { i as ControllerExecutionResultSchema } from "../controller-execution-result-schema-CWymsFAD.js";
 import { JsonObjectSchema } from "@agent-vm/agent-portal-sdk";
 import { z } from "zod";
 //#region src/controller-host-action-boundary/models/controller-host-action-request-schema.ts

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { n as ControllerDispatchIntentSchema, r as ControllerTrustedScopeSchema, t as ControllerDispatchIntent } from "./controller-dispatch-intent-schema-fqjx2pb2.js";
-import { ControllerExecutionResult, ControllerExecutionResultSchema, ExecutionFingerprint, ExecutionFingerprintSchema } from "./controller-dispatch-boundary/index.js";
+import { ControllerExecutionAmbiguousReasonSchema, ControllerExecutionAuthorityBinding, ControllerExecutionAuthorityBindingSchema, ControllerExecutionNotDispatchedReasonSchema, ControllerExecutionResult, ControllerExecutionResultSchema, ExecutionFingerprint, ExecutionFingerprintSchema } from "./controller-dispatch-boundary/index.js";
+import { ControllerExecutionDataBinding, ControllerExecutionDataCredit, ControllerExecutionDataCreditSchema, ControllerExecutionDataFrame, ControllerExecutionDataFrameSchema, ControllerExecutionDataHandshake, ControllerExecutionDataHandshakeSchema, ControllerExecutionDataPayloadMaxBytes, ControllerExecutionWebSocketPath } from "./controller-execution-data-boundary/index.js";
 import { ControllerHostActionRequest, ControllerHostActionRequestSchema, ControllerHostActionResult, ControllerHostActionResultSchema } from "./controller-host-action-boundary/index.js";
 import { a as ManagedVmExecRequestSchema, c as ManagedVmTimeoutMaxMs, i as ManagedVmExecRequest, l as ManagedVmTokenMaxLength, n as ManagedVmEnvironmentMaxEntries, o as ManagedVmStdinMaxBytes, r as ManagedVmEnvironmentValueMaxLength, s as ManagedVmStreamMaxBytes, t as ManagedVmArgvMaxItems } from "./managed-vm-exec-request-schema-BkkZ7zYn.js";
 import { ArtifactPolicySchema, CancellationPolicySchema, ControllerExecutionArgvMaxItems, ControllerExecutionArgvTokenMaxLength, ControllerExecutionOutputMaxBytes, ControllerExecutionTimeoutMaxMs, CwdPolicySchema, EgressPolicySchema, EnvironmentPolicySchema, ManagedVmArtifactReadMaxBytes, ManagedVmArtifactReadRequest, ManagedVmArtifactReadRequestSchema, OutputPolicySchema, ValidatedCliInvocation, ValidatedCliInvocationSchema } from "./tool-vm-runner-boundary/index.js";
-export { ArtifactPolicySchema, CancellationPolicySchema, ControllerDispatchIntent, ControllerDispatchIntentSchema, ControllerExecutionArgvMaxItems, ControllerExecutionArgvTokenMaxLength, ControllerExecutionOutputMaxBytes, ControllerExecutionResult, ControllerExecutionResultSchema, ControllerExecutionTimeoutMaxMs, ControllerHostActionRequest, ControllerHostActionRequestSchema, ControllerHostActionResult, ControllerHostActionResultSchema, ControllerTrustedScopeSchema, CwdPolicySchema, EgressPolicySchema, EnvironmentPolicySchema, ExecutionFingerprint, ExecutionFingerprintSchema, ManagedVmArgvMaxItems, ManagedVmArtifactReadMaxBytes, ManagedVmArtifactReadRequest, ManagedVmArtifactReadRequestSchema, ManagedVmEnvironmentMaxEntries, ManagedVmEnvironmentValueMaxLength, ManagedVmExecRequest, ManagedVmExecRequestSchema, ManagedVmStdinMaxBytes, ManagedVmStreamMaxBytes, ManagedVmTimeoutMaxMs, ManagedVmTokenMaxLength, OutputPolicySchema, ValidatedCliInvocation, ValidatedCliInvocationSchema };
+export { ArtifactPolicySchema, CancellationPolicySchema, ControllerDispatchIntent, ControllerDispatchIntentSchema, ControllerExecutionAmbiguousReasonSchema, ControllerExecutionArgvMaxItems, ControllerExecutionArgvTokenMaxLength, ControllerExecutionAuthorityBinding, ControllerExecutionAuthorityBindingSchema, ControllerExecutionDataBinding, ControllerExecutionDataCredit, ControllerExecutionDataCreditSchema, ControllerExecutionDataFrame, ControllerExecutionDataFrameSchema, ControllerExecutionDataHandshake, ControllerExecutionDataHandshakeSchema, ControllerExecutionDataPayloadMaxBytes, ControllerExecutionNotDispatchedReasonSchema, ControllerExecutionOutputMaxBytes, ControllerExecutionResult, ControllerExecutionResultSchema, ControllerExecutionTimeoutMaxMs, ControllerExecutionWebSocketPath, ControllerHostActionRequest, ControllerHostActionRequestSchema, ControllerHostActionResult, ControllerHostActionResultSchema, ControllerTrustedScopeSchema, CwdPolicySchema, EgressPolicySchema, EnvironmentPolicySchema, ExecutionFingerprint, ExecutionFingerprintSchema, ManagedVmArgvMaxItems, ManagedVmArtifactReadMaxBytes, ManagedVmArtifactReadRequest, ManagedVmArtifactReadRequestSchema, ManagedVmEnvironmentMaxEntries, ManagedVmEnvironmentValueMaxLength, ManagedVmExecRequest, ManagedVmExecRequestSchema, ManagedVmStdinMaxBytes, ManagedVmStreamMaxBytes, ManagedVmTimeoutMaxMs, ManagedVmTokenMaxLength, OutputPolicySchema, ValidatedCliInvocation, ValidatedCliInvocationSchema };

package/dist/index.js

@@ -1,8 +1,9 @@
 import { n as ControllerTrustedScopeSchema, t as ControllerDispatchIntentSchema } from "./controller-dispatch-intent-schema-dw3ugqpe.js";
-import { t as ControllerExecutionResultSchema } from "./controller-execution-result-schema-BN0cqzhi.js";
+import { i as ControllerExecutionResultSchema, n as ControllerExecutionAuthorityBindingSchema, r as ControllerExecutionNotDispatchedReasonSchema, t as ControllerExecutionAmbiguousReasonSchema } from "./controller-execution-result-schema-CWymsFAD.js";
 import { t as ExecutionFingerprintSchema } from "./execution-fingerprint-schema-D4J978Oa.js";
 import "./controller-dispatch-boundary/index.js";
+import { ControllerExecutionDataCreditSchema, ControllerExecutionDataFrameSchema, ControllerExecutionDataHandshakeSchema, ControllerExecutionDataPayloadMaxBytes, ControllerExecutionWebSocketPath } from "./controller-execution-data-boundary/index.js";
 import { ControllerHostActionRequestSchema, ControllerHostActionResultSchema } from "./controller-host-action-boundary/index.js";
 import { _ as EnvironmentPolicySchema, a as ManagedVmStdinMaxBytes, c as ManagedVmTokenMaxLength, d as ControllerExecutionArgvMaxItems, f as ControllerExecutionArgvTokenMaxLength, g as EgressPolicySchema, h as CwdPolicySchema, i as ManagedVmExecRequestSchema, l as ArtifactPolicySchema, m as ControllerExecutionTimeoutMaxMs, n as ManagedVmEnvironmentMaxEntries, o as ManagedVmStreamMaxBytes, p as ControllerExecutionOutputMaxBytes, r as ManagedVmEnvironmentValueMaxLength, s as ManagedVmTimeoutMaxMs, t as ManagedVmArgvMaxItems, u as CancellationPolicySchema, v as OutputPolicySchema, y as ValidatedCliInvocationSchema } from "./managed-vm-exec-request-schema-oPmsc4H8.js";
 import { ManagedVmArtifactReadMaxBytes, ManagedVmArtifactReadRequestSchema } from "./tool-vm-runner-boundary/index.js";
-export { ArtifactPolicySchema, CancellationPolicySchema, ControllerDispatchIntentSchema, ControllerExecutionArgvMaxItems, ControllerExecutionArgvTokenMaxLength, ControllerExecutionOutputMaxBytes, ControllerExecutionResultSchema, ControllerExecutionTimeoutMaxMs, ControllerHostActionRequestSchema, ControllerHostActionResultSchema, ControllerTrustedScopeSchema, CwdPolicySchema, EgressPolicySchema, EnvironmentPolicySchema, ExecutionFingerprintSchema, ManagedVmArgvMaxItems, ManagedVmArtifactReadMaxBytes, ManagedVmArtifactReadRequestSchema, ManagedVmEnvironmentMaxEntries, ManagedVmEnvironmentValueMaxLength, ManagedVmExecRequestSchema, ManagedVmStdinMaxBytes, ManagedVmStreamMaxBytes, ManagedVmTimeoutMaxMs, ManagedVmTokenMaxLength, OutputPolicySchema, ValidatedCliInvocationSchema };
+export { ArtifactPolicySchema, CancellationPolicySchema, ControllerDispatchIntentSchema, ControllerExecutionAmbiguousReasonSchema, ControllerExecutionArgvMaxItems, ControllerExecutionArgvTokenMaxLength, ControllerExecutionAuthorityBindingSchema, ControllerExecutionDataCreditSchema, ControllerExecutionDataFrameSchema, ControllerExecutionDataHandshakeSchema, ControllerExecutionDataPayloadMaxBytes, ControllerExecutionNotDispatchedReasonSchema, ControllerExecutionOutputMaxBytes, ControllerExecutionResultSchema, ControllerExecutionTimeoutMaxMs, ControllerExecutionWebSocketPath, ControllerHostActionRequestSchema, ControllerHostActionResultSchema, ControllerTrustedScopeSchema, CwdPolicySchema, EgressPolicySchema, EnvironmentPolicySchema, ExecutionFingerprintSchema, ManagedVmArgvMaxItems, ManagedVmArtifactReadMaxBytes, ManagedVmArtifactReadRequestSchema, ManagedVmEnvironmentMaxEntries, ManagedVmEnvironmentValueMaxLength, ManagedVmExecRequestSchema, ManagedVmStdinMaxBytes, ManagedVmStreamMaxBytes, ManagedVmTimeoutMaxMs, ManagedVmTokenMaxLength, OutputPolicySchema, ValidatedCliInvocationSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-vm/controller-execution-contracts",
-  "version": "0.0.113",
+  "version": "0.0.115",
   "description": "Zod contracts for controller-owned portal execution boundaries.",
   "homepage": "https://github.com/ShravanSunder/agent-vm#readme",
   "bugs": {
@@ -28,6 +28,10 @@
       "types": "./dist/controller-dispatch-boundary/index.d.ts",
       "import": "./dist/controller-dispatch-boundary/index.js"
     },
+    "./controller-execution-data-boundary": {
+      "types": "./dist/controller-execution-data-boundary/index.d.ts",
+      "import": "./dist/controller-execution-data-boundary/index.js"
+    },
     "./controller-host-action-boundary": {
       "types": "./dist/controller-host-action-boundary/index.d.ts",
       "import": "./dist/controller-host-action-boundary/index.js"
@@ -46,7 +50,7 @@
   },
   "dependencies": {
     "zod": "^4.4.3",
-    "@agent-vm/agent-portal-sdk": "0.0.113"
+    "@agent-vm/agent-portal-sdk": "0.0.115"
   },
   "devDependencies": {
     "vitest": "^4.1.5"

package/dist/controller-execution-result-schema-BN0cqzhi.js

@@ -1,18 +0,0 @@
-import { JsonValueSchema, PortalErrorSchema, SafeDiagnosticSchema } from "@agent-vm/agent-portal-sdk";
-import { z } from "zod";
-//#region src/controller-dispatch-boundary/models/controller-execution-result-schema.ts
-const ControllerExecutionResultSchema = z.discriminatedUnion("status", [z.object({
-	auditCorrelationId: z.string().min(1),
-	diagnostics: z.array(SafeDiagnosticSchema).default([]),
-	status: z.literal("ok"),
-	value: JsonValueSchema
-}).strict(), z.object({
-	auditCorrelationId: z.string().min(1).optional(),
-	diagnostics: z.array(SafeDiagnosticSchema).default([]),
-	error: PortalErrorSchema,
-	status: z.literal("error")
-}).strict()]);
-//#endregion
-export { ControllerExecutionResultSchema as t };
-
-//# sourceMappingURL=controller-execution-result-schema-BN0cqzhi.js.map

package/dist/controller-execution-result-schema-BN0cqzhi.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"controller-execution-result-schema-BN0cqzhi.js","names":[],"sources":["../src/controller-dispatch-boundary/models/controller-execution-result-schema.ts"],"sourcesContent":["import {\n\tJsonValueSchema,\n\tPortalErrorSchema,\n\tSafeDiagnosticSchema,\n} from '@agent-vm/agent-portal-sdk';\nimport { z } from 'zod';\n\nexport const ControllerExecutionResultSchema = z.discriminatedUnion('status', [\n\tz\n\t\t.object({\n\t\t\tauditCorrelationId: z.string().min(1),\n\t\t\tdiagnostics: z.array(SafeDiagnosticSchema).default([]),\n\t\t\tstatus: z.literal('ok'),\n\t\t\tvalue: JsonValueSchema,\n\t\t})\n\t\t.strict(),\n\tz\n\t\t.object({\n\t\t\tauditCorrelationId: z.string().min(1).optional(),\n\t\t\tdiagnostics: z.array(SafeDiagnosticSchema).default([]),\n\t\t\terror: PortalErrorSchema,\n\t\t\tstatus: z.literal('error'),\n\t\t})\n\t\t.strict(),\n]);\n\nexport type ControllerExecutionResult = z.infer<typeof ControllerExecutionResultSchema>;\n"],"mappings":";;;AAOA,MAAa,kCAAkC,EAAE,mBAAmB,UAAU,CAC7E,EACE,OAAO;CACP,oBAAoB,EAAE,QAAQ,CAAC,IAAI,EAAE;CACrC,aAAa,EAAE,MAAM,qBAAqB,CAAC,QAAQ,EAAE,CAAC;CACtD,QAAQ,EAAE,QAAQ,KAAK;CACvB,OAAO;CACP,CAAC,CACD,QAAQ,EACV,EACE,OAAO;CACP,oBAAoB,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,UAAU;CAChD,aAAa,EAAE,MAAM,qBAAqB,CAAC,QAAQ,EAAE,CAAC;CACtD,OAAO;CACP,QAAQ,EAAE,QAAQ,QAAQ;CAC1B,CAAC,CACD,QAAQ,CACV,CAAC"}