effect-agent 0.1.0-beta.95 → 0.1.0-beta.97

package/dist/agent-registration-CXGDwvJH.mjs

@@ -0,0 +1,379 @@
+import { AgentId } from "./core/Identifiers.mjs";
+import { getToolExecutionKind } from "./core/SubagentContract.mjs";
+import { a as PinnedTool, l as ToolNamespace, n as DiscoveryTool, r as IncludesCatalogDocumentation, t as AdditionalToolCatalog } from "./ToolExposure-C93U1sPu.mjs";
+import { BackgroundReporting, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
+import { getToolExecutionClass } from "./engine/DurableStep.mjs";
+import { M as ReplayContract, T as PersistedJson, f as DefinitionDigestInput, p as DefinitionDigests } from "./Records-BAutSSnJ.mjs";
+import { DigestError, digestDefinitions, digestJson } from "./durable/Digest.mjs";
+import { Tool } from "effect/unstable/ai";
+import { Array, Context, Effect, Layer, Schema } from "effect";
+//#region src/durable/internal/agent-registration.ts
+/**
+* No Agent Binding is registered for the requested stable identity. Recovery
+* fails closed: it never substitutes the latest Binding or runs different
+* code.
+*/
+var BindingUnavailable = class extends Schema.TaggedError()("BindingUnavailable", {
+	agentId: AgentId,
+	message: Schema.String
+}) {};
+/**
+* A Binding is registered for the identity but neither the exact admission fingerprints
+* nor its declared replay contract support the retained pending operations. Refusal leaves
+* the original Submission pending until compatible code is available.
+*/
+var BindingDigestMismatch = class extends Schema.TaggedError()("BindingDigestMismatch", {
+	agentId: AgentId,
+	message: Schema.String
+}) {};
+/** Byte-for-byte equality of two stored definition digest triples (SUB-023). */
+const definitionDigestsEqual = (left, right) => left.agent === right.agent && left.model === right.model && left.tools === right.tools && Schema.toEquivalence(Schema.UndefinedOr(ReplayContract))(left.replay, right.replay);
+/**
+* Data exported from a definition, never an old executable Binding. A host may supply an audited
+* manifest from the original release for work admitted before replay contracts were retained.
+* Its original declarations must hash to that admission; a bare old digest is not a manifest.
+*/
+const ToolReplayDeclaration = Schema.Struct({
+	version: PersistedJson,
+	parameters: PersistedJson,
+	success: PersistedJson,
+	failure: PersistedJson,
+	failureMode: Schema.String,
+	needsApproval: Schema.Union([Schema.Boolean, Schema.Literal("dynamic")]),
+	executionClass: Schema.String,
+	executionKind: Schema.String
+});
+const AgentReplayDeclaration = Schema.Struct({
+	version: PersistedJson,
+	id: AgentId,
+	input: PersistedJson,
+	output: PersistedJson,
+	updates: Schema.NullOr(PersistedJson),
+	completion: Schema.NullOr(Schema.Struct({
+		tool: Schema.String,
+		required: Schema.Boolean
+	})),
+	completionFromTools: Schema.Array(Schema.String),
+	disposition: Schema.NullOr(PersistedJson)
+});
+var BindingManifest = class extends Schema.Class("BindingManifest")({
+	agentId: AgentId,
+	definitions: DefinitionDigestInput,
+	replay: ReplayContract,
+	agentContract: Schema.optionalKey(AgentReplayDeclaration),
+	toolContracts: Schema.optionalKey(Schema.Record(Schema.String, ToolReplayDeclaration))
+}) {};
+const makeBindingManifest = Effect.fn("AgentRegistration.makeBindingManifest")(function* (definition, definitions, versions) {
+	const jsonSchema = (schema) => Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));
+	const contracts = yield* Effect.try({
+		try: () => {
+			const tools = Object.values(definition.toolkit.tools);
+			if (tools.some((tool) => !Object.hasOwn(versions.tools, tool.name))) throw new Error("Every Tool needs an explicit replay semantic version");
+			return {
+				agent: {
+					version: versions.agent,
+					id: definition.id,
+					input: jsonSchema(definition.input),
+					output: jsonSchema(definition.output),
+					updates: definition.updates === void 0 ? null : jsonSchema(definition.updates),
+					completion: definition.completion === void 0 ? null : {
+						tool: definition.completion.tool,
+						required: definition.completion.required ?? false
+					},
+					completionFromTools: definition.completionFromTools?.map((entry) => entry.tool).sort() ?? [],
+					disposition: definition.runDisposition === void 0 ? null : jsonSchema(definition.runDisposition.schema)
+				},
+				tools: tools.map((tool) => ({
+					name: tool.name,
+					contract: {
+						version: versions.tools[tool.name],
+						parameters: jsonSchema(tool.parametersSchema),
+						success: jsonSchema(tool.successSchema),
+						failure: jsonSchema(tool.failureSchema),
+						failureMode: tool.failureMode,
+						needsApproval: typeof tool.needsApproval === "function" ? "dynamic" : tool.needsApproval ?? false,
+						executionClass: getToolExecutionClass(tool),
+						executionKind: getToolExecutionKind(tool.annotations)
+					}
+				}))
+			};
+		},
+		catch: () => DigestError.make({ message: "Replay contracts require serializable codecs and an explicit semantic version for every Tool" })
+	});
+	const agent = yield* digestJson(contracts.agent);
+	const agentBehavior = yield* digestJson({
+		...contracts.agent,
+		input: null
+	});
+	const tools = yield* Effect.forEach(contracts.tools, ({ name, contract }) => digestJson(contract).pipe(Effect.map((digest) => [name, digest])));
+	return BindingManifest.make({
+		agentId: definition.id,
+		definitions,
+		replay: ReplayContract.make({
+			agent,
+			agentBehavior,
+			tools: Object.fromEntries(tools)
+		}),
+		agentContract: contracts.agent,
+		toolContracts: Object.fromEntries(contracts.tools.map(({ name, contract }) => [name, contract]))
+	});
+});
+const jsonEqual = Schema.toEquivalence(PersistedJson);
+const schemasCompatible = (previous, current) => {
+	if (jsonEqual(previous, current)) return true;
+	const hasNegativeSchema = (value) => {
+		if (Array.isArray(value)) return value.some(hasNegativeSchema);
+		if (value === null || typeof value !== "object") return false;
+		return Object.entries(value).some(([key, child]) => key === "oneOf" || key === "maxContains" || key === "unevaluatedProperties" || key === "unevaluatedItems" || key === "if" || key === "then" || key === "else" || key === "$dynamicRef" || key === "$recursiveRef" || key === "not" && !jsonEqual(child, {}) || hasNegativeSchema(child));
+	};
+	if (hasNegativeSchema(previous) || hasNegativeSchema(current)) return false;
+	const compare = (before, after) => {
+		if (jsonEqual(before, after)) return true;
+		if (before === null || typeof before !== "object" || Array.isArray(before) || after === null || typeof after !== "object" || Array.isArray(after)) return false;
+		if (Object.keys(before).length !== Object.keys(after).length) return false;
+		return Object.entries(before).every(([key, value]) => {
+			if (!Object.hasOwn(after, key)) return false;
+			const next = after[key];
+			if (jsonEqual(value, next)) return true;
+			if (key === "additionalProperties") return value === false && next === true;
+			if (key === "items") return compare(value, next);
+			if ((key === "anyOf" || key === "allOf") && Array.isArray(value) && Array.isArray(next)) return value.length === next.length && value.every((entry, index) => compare(entry, next[index]));
+			if ((key === "properties" || key === "$defs" || key === "definitions") && value !== null && typeof value === "object" && !Array.isArray(value) && next !== null && typeof next === "object" && !Array.isArray(next)) return Object.keys(value).length === Object.keys(next).length && Object.entries(value).every(([name, schema]) => Object.hasOwn(next, name) && compare(schema, next[name]));
+			return false;
+		});
+	};
+	return compare(previous, current);
+};
+/** Compile audited declaration data once, without acquiring an executable or rewriting receipts.
+* Full input schemas stay in registration metadata, never in each admission's replay contract. */
+const compileBindingManifest = Effect.fn("AgentRegistration.compileBindingManifest")(function* (definition, definitions, versions, retained = []) {
+	const manifest = yield* makeBindingManifest(definition, definitions, versions);
+	const validContract = Effect.fnUntraced(function* (entry) {
+		if (entry.agentContract === void 0) return void 0;
+		if (entry.agentContract.id !== entry.agentId || (yield* digestJson(entry.agentContract)) !== entry.replay.agent || entry.replay.agentBehavior !== void 0 && (yield* digestJson({
+			...entry.agentContract,
+			input: null
+		})) !== entry.replay.agentBehavior) return yield* DigestError.make({ message: "A manifest's Agent contract does not match its replay digest" });
+		return entry.agentContract;
+	});
+	const current = manifest.agentContract;
+	const acceptsInput = Schema.is(Schema.toEncoded(definition.input));
+	const validateTools = Effect.fnUntraced(function* (entry) {
+		for (const [name, contract] of Object.entries(entry.toolContracts ?? {})) if ((yield* digestJson(contract)) !== entry.replay.tools[name]) return yield* DigestError.make({ message: "A manifest's Tool contract does not match its replay digest" });
+	});
+	const digests = yield* digestDefinitions(manifest.definitions);
+	const retainedManifests = yield* Effect.forEach(retained, Effect.fnUntraced(function* (entry) {
+		if (entry.agentId !== manifest.agentId) return yield* DigestError.make({ message: "A retained manifest belongs to another Agent" });
+		const previous = yield* validContract(entry);
+		yield* validateTools(entry);
+		const compatible = previous !== void 0 && jsonEqual({
+			...previous,
+			input: null,
+			output: null,
+			updates: null,
+			disposition: null
+		}, {
+			...current,
+			input: null,
+			output: null,
+			updates: null,
+			disposition: null
+		}) && schemasCompatible(previous.output, current.output) && schemasCompatible(previous.updates, current.updates) && schemasCompatible(previous.disposition, current.disposition);
+		const compatibleTools = {};
+		for (const [name, oldTool] of Object.entries(entry.toolContracts ?? {})) {
+			const newTool = manifest.toolContracts?.[name];
+			if (newTool !== void 0 && jsonEqual({
+				...oldTool,
+				parameters: null,
+				success: null,
+				failure: null
+			}, {
+				...newTool,
+				parameters: null,
+				success: null,
+				failure: null
+			}) && schemasCompatible(oldTool.parameters, newTool.parameters) && schemasCompatible(oldTool.success, newTool.success) && schemasCompatible(oldTool.failure, newTool.failure)) compatibleTools[name] = manifest.replay.tools[name];
+		}
+		return {
+			digests: yield* digestDefinitions(entry.definitions),
+			replay: entry.replay,
+			compatibleTools,
+			...compatible ? { compatibleAgent: manifest.replay.agent } : {}
+		};
+	}));
+	return {
+		digests: DefinitionDigests.make({
+			...digests,
+			replay: manifest.replay
+		}),
+		manifest,
+		retainedManifests,
+		acceptsInput: (input) => {
+			try {
+				return acceptsInput(input);
+			} catch {
+				return false;
+			}
+		}
+	};
+});
+const replaySupports = (current, retained, requiredTools, inputCompatible = false, compatibleTools = {}) => (current.agent === retained.agent || inputCompatible) && (requiredTools ?? Object.keys(retained.tools)).every((name) => retained.tools[name] !== void 0 && (current.tools[name] === retained.tools[name] || current.tools[name] !== void 0 && compatibleTools[name] === current.tools[name]));
+/** Resolve executable code only. Admission, delivery, lineage and receipt comparisons stay exact. */
+const bindingSupports = (binding, digests, requiredTools, input) => {
+	if (definitionDigestsEqual(binding.digests, digests)) return true;
+	const manifest = binding.retainedManifests?.find((entry) => definitionDigestsEqual(entry.digests, digests) || definitionDigestsEqual({
+		...entry.digests,
+		replay: entry.replay
+	}, digests));
+	const retained = digests.replay ?? manifest?.replay;
+	return binding.digests.replay !== void 0 && retained !== void 0 && replaySupports(binding.digests.replay, retained, requiredTools, input !== void 0 && binding.acceptsInput?.(input) === true && (binding.digests.replay.agentBehavior !== void 0 && binding.digests.replay.agentBehavior === retained.agentBehavior || manifest?.compatibleAgent === binding.digests.replay.agent), manifest?.compatibleTools);
+};
+const captureReporting = (reports) => Effect.map(Effect.context(), (context) => reports.map((report) => ({
+	...report,
+	prepare: (value) => Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(Effect.provide(context), Effect.mapError((error) => Schema.is(WorkerReportPreparationFailure)(error) ? error : WorkerReportPreparationFailure.make({ stage: "preparation" })))
+})));
+const backgroundReports = (definition) => [...new Set(Object.values(definition.toolkit.tools).flatMap((tool) => {
+	const report = Context.get(tool.annotations, BackgroundReporting);
+	return report === void 0 ? [] : [report];
+}))];
+const capture = (agent, attemptLayer) => Effect.map(Effect.context(), (context) => ({
+	agentId: agent.definition.id,
+	definition: agent.definition,
+	attempt: (driver, threadId, claim) => {
+		const execute = driver(agent, threadId, claim);
+		return (attemptLayer === void 0 ? execute : execute.pipe(Effect.provide(Layer.fresh(attemptLayer({
+			threadId,
+			submissionId: claim.submissionId,
+			attemptId: claim.attemptId
+		}))))).pipe(Effect.provide(context));
+	}
+}));
+/**
+* Build one exact worker registration from an executable Agent Binding and
+* its already-computed definition digests.
+*
+* `make(agent, digests)` captures the binding plus its worker-requirement
+* Context at Layer/effect construction time. Hosts that start from application
+* version declarations should use `compileRegistrations`; low-level fixtures
+* may supply a previously computed digest triple directly.
+*/
+const DurableWorkerBinding = { make: (agent, digests, reporting) => Effect.gen(function* () {
+	const binding = yield* capture(agent);
+	const reports = yield* captureReporting([...reporting ?? [], ...backgroundReports(agent.definition)]);
+	return {
+		...binding,
+		digests,
+		reporting: reports
+	};
+}) };
+/** INTERNAL identity-only capture retained for the legacy direct worker path. */
+const makeLegacyWorkerBinding = capture;
+const resolveWorkerBinding = (bindings, agentId, digests, requiredTools, input) => {
+	const registered = bindings.filter((binding) => binding.agentId === agentId);
+	if (registered.length === 0) return Effect.fail(BindingUnavailable.make({
+		agentId,
+		message: `No Agent Binding is registered for ${agentId}; recovery never substitutes different code (SUB-023)`
+	}));
+	const compatible = registered.find((binding) => definitionDigestsEqual(binding.digests, digests)) ?? (registered.length === 1 && bindingSupports(registered[0], digests, requiredTools, input) ? registered[0] : void 0);
+	if (compatible === void 0) return Effect.fail(BindingDigestMismatch.make({
+		agentId,
+		message: `No registered Binding proves the retained replay contracts for ${agentId}; the original request and receipts remain pending`
+	}));
+	return Effect.succeed(compatible);
+};
+/** Resolve authoring-time admission through the one exact host registration, never by identity alone. */
+const resolveDefinitionBinding = (bindings, definition) => {
+	const candidates = bindings.filter((binding) => binding.agentId === definition.id);
+	const binding = candidates[0];
+	if (candidates.length !== 1 || binding === void 0) return Effect.fail(BindingUnavailable.make({
+		agentId: definition.id,
+		message: "Registered admission requires exactly one binding for the Agent identity"
+	}));
+	if (!Object.is(binding.definition, definition)) return Effect.fail(BindingUnavailable.make({
+		agentId: definition.id,
+		message: "Registered admission requires the exact Agent Definition used in registration"
+	}));
+	return Effect.succeed(binding);
+};
+const registrationDefinitions = (entry) => {
+	const definition = entry.model === void 0 ? entry.agent.definition : entry.agent;
+	const automatic = backgroundReports(definition);
+	const declaredDefinitions = definition.updates === void 0 ? entry.definitions : {
+		...entry.definitions,
+		agent: {
+			declaration: entry.definitions.agent,
+			updates: Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(definition.updates)),
+			updateProtocol: {
+				schemaVersion: 1,
+				tool: "emit_update"
+			}
+		}
+	};
+	const definitions = automatic.length === 0 ? declaredDefinitions : {
+		...declaredDefinitions,
+		agent: {
+			declaration: declaredDefinitions.agent,
+			backgroundReporting: automatic.map((report) => ({
+				delegationId: report.delegationId,
+				targetAgentId: report.target.id,
+				mode: report.mode ?? "custom",
+				destinationDelegationId: report.destination?.delegationId ?? null
+			}))
+		}
+	};
+	const exposure = definition.toolExposure;
+	if (exposure === void 0 && !Object.values(definition.toolkit.tools).some((tool) => Context.get(tool.annotations, DiscoveryTool) || Context.get(tool.annotations, PinnedTool))) return definitions;
+	return {
+		...definitions,
+		agent: {
+			declaration: definitions.agent,
+			toolExposure: {
+				initialToolNames: exposure === void 0 ? null : [...exposure.initialToolNames ?? []],
+				maxTools: exposure?.maxTools ?? 64,
+				maxSchemaBytes: exposure?.maxSchemaBytes ?? 262144,
+				requiredCompletion: definition.completion?.required === true ? definition.completion.tool : null,
+				tools: Object.values(definition.toolkit.tools).map((tool) => ({
+					name: tool.name,
+					pinned: Context.get(tool.annotations, PinnedTool),
+					discovery: Context.get(tool.annotations, DiscoveryTool),
+					namespace: Context.get(tool.annotations, ToolNamespace) ?? null,
+					includesCatalogDocumentation: Context.get(tool.annotations, IncludesCatalogDocumentation),
+					additional: Context.get(tool.annotations, AdditionalToolCatalog).map((entry) => ({
+						name: entry.tool.name,
+						namespace: entry.namespace,
+						method: entry.method
+					}))
+				}))
+			}
+		}
+	};
+};
+const compileRegistration = (entry) => Effect.flatMap(Effect.try({
+	try: () => registrationDefinitions(entry),
+	catch: () => DigestError.make({ message: "Agent update schema has no serializable wire contract" })
+}), (definitions) => Effect.gen(function* () {
+	const binding = yield* capture(entry.model === void 0 ? entry.agent : {
+		definition: entry.agent,
+		model: entry.model
+	}, entry.attemptLayer);
+	const reporting = yield* captureReporting([...entry.reporting ?? [], ...backgroundReports(binding.definition)]);
+	if (entry.continuity === void 0) return {
+		...binding,
+		digests: yield* digestDefinitions(definitions),
+		reporting
+	};
+	return {
+		...binding,
+		...yield* compileBindingManifest(binding.definition, definitions, entry.continuity.versions, entry.continuity.retainedManifests),
+		reporting
+	};
+}));
+/** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
+const compileRegistrations = (entries) => {
+	const compileEntry = compileRegistration;
+	return Effect.forEach(entries, compileEntry);
+};
+//#endregion
+export { bindingSupports as a, definitionDigestsEqual as c, resolveDefinitionBinding as d, resolveWorkerBinding as f, DurableWorkerBinding as i, makeBindingManifest as l, BindingManifest as n, compileBindingManifest as o, BindingUnavailable as r, compileRegistrations as s, BindingDigestMismatch as t, makeLegacyWorkerBinding as u };
+
+//# sourceMappingURL=agent-registration-CXGDwvJH.mjs.map

package/dist/agent-registration-CXGDwvJH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-registration-CXGDwvJH.mjs","names":["run"],"sources":["../src/durable/internal/agent-registration.ts"],"sourcesContent":["import {\n  type Crypto,\n  type Option,\n  type Scope,\n  Array,\n  Context,\n  Effect,\n  Layer,\n  Schema,\n} from \"effect\";\nimport { Tool } from \"effect/unstable/ai\";\n\nimport type * as Agent from \"../../core/Agent.ts\";\nimport {\n  type InputPromptSource,\n  type InstructionSource,\n  type ModelServices,\n  type RunDispositionDeclaration,\n} from \"../../core/Agent.ts\";\nimport { type ThreadId, AgentId } from \"../../core/Identifiers.ts\";\nimport { getToolExecutionKind } from \"../../core/SubagentContract.ts\";\nimport {\n  AdditionalToolCatalog,\n  DiscoveryTool,\n  IncludesCatalogDocumentation,\n  PinnedTool,\n  ToolNamespace,\n} from \"../../core/ToolExposure.ts\";\nimport { type RuntimeBinding } from \"../../engine/AgentRuntime.ts\";\nimport { getToolExecutionClass } from \"../../engine/DurableStep.ts\";\nimport {\n  BackgroundReporting,\n  WorkerReportPreparationFailure,\n  type WorkerReporting,\n} from \"../../engine/SubagentHost.ts\";\nimport { digestDefinitions, digestJson, DigestError } from \"../Digest.ts\";\nimport type { DurableWorkerFailure, DurableWorkerRequirements } from \"../DurableAgentRuntime.ts\";\nimport {\n  DefinitionDigestInput,\n  DefinitionDigests,\n  ReplayContract,\n  PersistedJson,\n} from \"../Records.ts\";\nimport type { Claim, Settlement } from \"../SubmissionLedger.ts\";\n\n/**\n * No Agent Binding is registered for the requested stable identity. Recovery\n * fails closed: it never substitutes the latest Binding or runs different\n * code.\n */\nexport class BindingUnavailable extends Schema.TaggedError<BindingUnavailable>()(\n  \"BindingUnavailable\",\n  {\n    agentId: AgentId,\n    message: Schema.String,\n  },\n) {}\n\n/**\n * A Binding is registered for the identity but neither the exact admission fingerprints\n * nor its declared replay contract support the retained pending operations. Refusal leaves\n * the original Submission pending until compatible code is available.\n */\nexport class BindingDigestMismatch extends Schema.TaggedError<BindingDigestMismatch>()(\n  \"BindingDigestMismatch\",\n  {\n    agentId: AgentId,\n    message: Schema.String,\n  },\n) {}\n\n/** The typed refusal family of durable Binding resolution (spec §11, SUB-032). */\nexport type DurableBindingFailure = BindingUnavailable | BindingDigestMismatch;\n\n/** Byte-for-byte equality of two stored definition digest triples (SUB-023). */\nexport const definitionDigestsEqual = (\n  left: DefinitionDigests,\n  right: DefinitionDigests,\n): boolean =>\n  left.agent === right.agent &&\n  left.model === right.model &&\n  left.tools === right.tools &&\n  Schema.toEquivalence(Schema.UndefinedOr(ReplayContract))(left.replay, right.replay);\n\n/**\n * Host-owned semantic versions, independent of deployment and tool inventory. Change a version\n * when the meaning of an operation, its durable Step names or external idempotency keys changes.\n * Codecs and execution class are included automatically; JSON Schema alone cannot prove semantics.\n */\nexport interface ReplayVersions {\n  readonly agent: PersistedJson;\n  readonly tools: Readonly<Record<string, PersistedJson>>;\n}\n\n/**\n * Data exported from a definition, never an old executable Binding. A host may supply an audited\n * manifest from the original release for work admitted before replay contracts were retained.\n * Its original declarations must hash to that admission; a bare old digest is not a manifest.\n */\nconst ToolReplayDeclaration = Schema.Struct({\n  version: PersistedJson,\n  parameters: PersistedJson,\n  success: PersistedJson,\n  failure: PersistedJson,\n  failureMode: Schema.String,\n  needsApproval: Schema.Union([Schema.Boolean, Schema.Literal(\"dynamic\")]),\n  executionClass: Schema.String,\n  executionKind: Schema.String,\n});\n\nconst AgentReplayDeclaration = Schema.Struct({\n  version: PersistedJson,\n  id: AgentId,\n  input: PersistedJson,\n  output: PersistedJson,\n  updates: Schema.NullOr(PersistedJson),\n  completion: Schema.NullOr(Schema.Struct({ tool: Schema.String, required: Schema.Boolean })),\n  completionFromTools: Schema.Array(Schema.String),\n  disposition: Schema.NullOr(PersistedJson),\n});\n\nexport class BindingManifest extends Schema.Class<BindingManifest>(\"BindingManifest\")({\n  agentId: AgentId,\n  definitions: DefinitionDigestInput,\n  replay: ReplayContract,\n  agentContract: Schema.optionalKey(AgentReplayDeclaration),\n  toolContracts: Schema.optionalKey(Schema.Record(Schema.String, ToolReplayDeclaration)),\n}) {}\n\nexport const makeBindingManifest = Effect.fn(\"AgentRegistration.makeBindingManifest\")(function* (\n  definition: Agent.AnyDefinition,\n  definitions: DefinitionDigestInput,\n  versions: ReplayVersions,\n) {\n  const jsonSchema = (schema: Schema.Top) =>\n    Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));\n\n  const contracts = yield* Effect.try({\n    try: () => {\n      const tools = Object.values(definition.toolkit.tools);\n\n      if (tools.some((tool) => !Object.hasOwn(versions.tools, tool.name)))\n        throw new Error(\"Every Tool needs an explicit replay semantic version\");\n\n      return {\n        agent: {\n          version: versions.agent,\n          id: definition.id,\n          input: jsonSchema(definition.input),\n          output: jsonSchema(definition.output),\n          updates: definition.updates === undefined ? null : jsonSchema(definition.updates),\n          completion:\n            definition.completion === undefined\n              ? null\n              : {\n                  tool: definition.completion.tool,\n                  required: definition.completion.required ?? false,\n                },\n          completionFromTools:\n            definition.completionFromTools?.map((entry) => entry.tool).sort() ?? [],\n          disposition:\n            definition.runDisposition === undefined\n              ? null\n              : jsonSchema(definition.runDisposition.schema),\n        },\n        tools: tools.map((tool) => ({\n          name: tool.name,\n          contract: {\n            version: versions.tools[tool.name]!,\n            parameters: jsonSchema(tool.parametersSchema),\n            success: jsonSchema(tool.successSchema),\n            failure: jsonSchema(tool.failureSchema),\n            failureMode: tool.failureMode,\n            needsApproval:\n              typeof tool.needsApproval === \"function\" ? \"dynamic\" : (tool.needsApproval ?? false),\n            executionClass: getToolExecutionClass(tool),\n            executionKind: getToolExecutionKind(tool.annotations),\n          },\n        })),\n      };\n    },\n    catch: () =>\n      DigestError.make({\n        message:\n          \"Replay contracts require serializable codecs and an explicit semantic version for every Tool\",\n      }),\n  });\n\n  const agent = yield* digestJson(contracts.agent);\n  const agentBehavior = yield* digestJson({ ...contracts.agent, input: null });\n\n  const tools = yield* Effect.forEach(contracts.tools, ({ name, contract }) =>\n    digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),\n  );\n\n  return BindingManifest.make({\n    agentId: definition.id,\n    definitions,\n    replay: ReplayContract.make({ agent, agentBehavior, tools: Object.fromEntries(tools) }),\n    agentContract: contracts.agent,\n    toolContracts: Object.fromEntries(\n      contracts.tools.map(({ name, contract }) => [name, contract]),\n    ),\n  });\n});\n\nconst jsonEqual = Schema.toEquivalence(PersistedJson);\n\n// JSON Schema generation can widen object openness without changing an Effect codec.\n// Prove only this widening; all other codec changes still require an exact contract.\nconst schemasCompatible = (previous: PersistedJson, current: PersistedJson): boolean => {\n  if (jsonEqual(previous, current)) return true;\n\n  const hasNegativeSchema = (value: PersistedJson): boolean => {\n    if (Array.isArray<PersistedJson>(value)) return value.some(hasNegativeSchema);\n    if (value === null || typeof value !== \"object\") return false;\n\n    return Object.entries(value).some(\n      ([key, child]) =>\n        key === \"oneOf\" ||\n        key === \"maxContains\" ||\n        key === \"unevaluatedProperties\" ||\n        key === \"unevaluatedItems\" ||\n        key === \"if\" ||\n        key === \"then\" ||\n        key === \"else\" ||\n        key === \"$dynamicRef\" ||\n        key === \"$recursiveRef\" ||\n        (key === \"not\" && !jsonEqual(child, {})) ||\n        hasNegativeSchema(child),\n    );\n  };\n\n  if (hasNegativeSchema(previous) || hasNegativeSchema(current)) return false;\n\n  const compare = (before: PersistedJson, after: PersistedJson): boolean => {\n    if (jsonEqual(before, after)) return true;\n    if (\n      before === null ||\n      typeof before !== \"object\" ||\n      Array.isArray<PersistedJson>(before) ||\n      after === null ||\n      typeof after !== \"object\" ||\n      Array.isArray<PersistedJson>(after)\n    )\n      return false;\n    if (Object.keys(before).length !== Object.keys(after).length) return false;\n\n    return Object.entries(before).every(([key, value]) => {\n      if (!Object.hasOwn(after, key)) return false;\n      const next = after[key]!;\n\n      if (jsonEqual(value, next)) return true;\n      if (key === \"additionalProperties\") return value === false && next === true;\n      if (key === \"items\") return compare(value, next);\n      if (\n        (key === \"anyOf\" || key === \"allOf\") &&\n        Array.isArray<PersistedJson>(value) &&\n        Array.isArray<PersistedJson>(next)\n      )\n        return (\n          value.length === next.length &&\n          value.every((entry, index) => compare(entry, next[index]!))\n        );\n      if (\n        (key === \"properties\" || key === \"$defs\" || key === \"definitions\") &&\n        value !== null &&\n        typeof value === \"object\" &&\n        !Array.isArray<PersistedJson>(value) &&\n        next !== null &&\n        typeof next === \"object\" &&\n        !Array.isArray<PersistedJson>(next)\n      )\n        return (\n          Object.keys(value).length === Object.keys(next).length &&\n          Object.entries(value).every(\n            ([name, schema]) => Object.hasOwn(next, name) && compare(schema, next[name]!),\n          )\n        );\n\n      return false;\n    });\n  };\n\n  return compare(previous, current);\n};\n\n/** Compile audited declaration data once, without acquiring an executable or rewriting receipts.\n * Full input schemas stay in registration metadata, never in each admission's replay contract. */\nexport const compileBindingManifest = Effect.fn(\"AgentRegistration.compileBindingManifest\")(\n  function* (\n    definition: Agent.AnyDefinition,\n    definitions: DefinitionDigestInput,\n    versions: ReplayVersions,\n    retained: ReadonlyArray<BindingManifest> = [],\n  ): Effect.fn.Return<\n    Pick<ResolvedBinding, \"digests\" | \"manifest\" | \"retainedManifests\" | \"acceptsInput\">,\n    DigestError,\n    Crypto.Crypto\n  > {\n    const manifest = yield* makeBindingManifest(definition, definitions, versions);\n\n    const validContract = Effect.fnUntraced(function* (entry: BindingManifest) {\n      if (entry.agentContract === undefined) return undefined;\n      if (\n        entry.agentContract.id !== entry.agentId ||\n        (yield* digestJson(entry.agentContract)) !== entry.replay.agent ||\n        (entry.replay.agentBehavior !== undefined &&\n          (yield* digestJson({ ...entry.agentContract, input: null })) !==\n            entry.replay.agentBehavior)\n      )\n        return yield* DigestError.make({\n          message: \"A manifest's Agent contract does not match its replay digest\",\n        });\n\n      return entry.agentContract;\n    });\n\n    const current = manifest.agentContract!;\n    const acceptsInput = Schema.is(Schema.toEncoded(definition.input));\n\n    const validateTools = Effect.fnUntraced(function* (entry: BindingManifest) {\n      for (const [name, contract] of Object.entries(entry.toolContracts ?? {}))\n        if ((yield* digestJson(contract)) !== entry.replay.tools[name])\n          return yield* DigestError.make({\n            message: \"A manifest's Tool contract does not match its replay digest\",\n          });\n    });\n\n    const digests = yield* digestDefinitions(manifest.definitions);\n\n    const retainedManifests = yield* Effect.forEach(\n      retained,\n      Effect.fnUntraced(function* (entry) {\n        if (entry.agentId !== manifest.agentId)\n          return yield* DigestError.make({\n            message: \"A retained manifest belongs to another Agent\",\n          });\n        const previous = yield* validContract(entry);\n\n        yield* validateTools(entry);\n\n        const compatible =\n          previous !== undefined &&\n          jsonEqual(\n            { ...previous, input: null, output: null, updates: null, disposition: null },\n            { ...current, input: null, output: null, updates: null, disposition: null },\n          ) &&\n          schemasCompatible(previous.output, current.output) &&\n          schemasCompatible(previous.updates, current.updates) &&\n          schemasCompatible(previous.disposition, current.disposition);\n\n        const compatibleTools: Record<string, string> = {};\n\n        for (const [name, oldTool] of Object.entries(entry.toolContracts ?? {})) {\n          const newTool = manifest.toolContracts?.[name];\n\n          if (\n            newTool !== undefined &&\n            jsonEqual(\n              { ...oldTool, parameters: null, success: null, failure: null },\n              { ...newTool, parameters: null, success: null, failure: null },\n            ) &&\n            schemasCompatible(oldTool.parameters, newTool.parameters) &&\n            schemasCompatible(oldTool.success, newTool.success) &&\n            schemasCompatible(oldTool.failure, newTool.failure)\n          )\n            compatibleTools[name] = manifest.replay.tools[name]!;\n        }\n\n        return {\n          digests: yield* digestDefinitions(entry.definitions),\n          replay: entry.replay,\n          compatibleTools,\n          ...(compatible ? { compatibleAgent: manifest.replay.agent } : {}),\n        };\n      }),\n    );\n\n    return {\n      digests: DefinitionDigests.make({ ...digests, replay: manifest.replay }),\n      manifest,\n      retainedManifests,\n      acceptsInput: (input: PersistedJson) => {\n        // Async checks and defective guards cannot establish synchronous replay proof.\n        try {\n          return acceptsInput(input);\n        } catch {\n          return false;\n        }\n      },\n    };\n  },\n);\n\nconst replaySupports = (\n  current: ReplayContract,\n  retained: ReplayContract,\n  requiredTools?: ReadonlyArray<string>,\n  inputCompatible = false,\n  compatibleTools: Readonly<Record<string, string>> = {},\n): boolean =>\n  (current.agent === retained.agent || inputCompatible) &&\n  (requiredTools ?? Object.keys(retained.tools)).every(\n    (name) =>\n      retained.tools[name] !== undefined &&\n      (current.tools[name] === retained.tools[name] ||\n        (current.tools[name] !== undefined && compatibleTools[name] === current.tools[name])),\n  );\n\n/** Resolve executable code only. Admission, delivery, lineage and receipt comparisons stay exact. */\nexport const bindingSupports = (\n  binding: Pick<ResolvedBinding, \"digests\" | \"retainedManifests\" | \"acceptsInput\">,\n  digests: DefinitionDigests,\n  requiredTools?: ReadonlyArray<string>,\n  input?: PersistedJson,\n): boolean => {\n  if (definitionDigestsEqual(binding.digests, digests)) return true;\n\n  const manifest = binding.retainedManifests?.find(\n    (entry) =>\n      definitionDigestsEqual(entry.digests, digests) ||\n      definitionDigestsEqual({ ...entry.digests, replay: entry.replay }, digests),\n  );\n\n  const retained = digests.replay ?? manifest?.replay;\n\n  return (\n    binding.digests.replay !== undefined &&\n    retained !== undefined &&\n    replaySupports(\n      binding.digests.replay,\n      retained,\n      requiredTools,\n      input !== undefined &&\n        binding.acceptsInput?.(input) === true &&\n        ((binding.digests.replay.agentBehavior !== undefined &&\n          binding.digests.replay.agentBehavior === retained.agentBehavior) ||\n          manifest?.compatibleAgent === binding.digests.replay.agent),\n      manifest?.compatibleTools,\n    )\n  );\n};\n\ntype ExecutableDefinition = Agent.AnyDefinition & {\n  readonly instructions: InstructionSource<never, unknown, unknown>;\n  readonly inputPrompt?: InputPromptSource<never, unknown, unknown> | undefined;\n};\n\n/** Executable model Binding accepted by durable registration descriptors. */\nexport type ExecutableAgentBinding = {\n  readonly definition: ExecutableDefinition;\n  readonly model: Layer.Layer<ModelServices, never, unknown>;\n};\n\n/**\n * Internal coordinator entry point for one fenced Attempt over an already-granted claim.\n * The generic signature matches `runAttempt` and is specialized for each captured Agent.\n */\ntype ResolvedAttemptDriver = <\n  InputSchema extends Schema.Top,\n  OutputSchema extends Schema.Top,\n  Instructions,\n  Tools extends Record<string, Tool.Any>,\n  Provider,\n  ModelProvides,\n  ModelRequires,\n  InstructionError,\n  InstructionRequirements,\n  RunDispositionValue extends\n    | RunDispositionDeclaration<OutputSchema[\"Type\"], Schema.Top>\n    | undefined,\n  InputPromptValue extends InputPromptSource<InputSchema[\"Type\"], unknown, unknown> | undefined,\n  UpdatesSchema extends Schema.Top | undefined,\n>(\n  agent: RuntimeBinding<\n    InputSchema,\n    OutputSchema,\n    Instructions,\n    Tools,\n    Provider,\n    ModelProvides,\n    ModelRequires,\n    InstructionError,\n    InstructionRequirements,\n    RunDispositionValue,\n    InputPromptValue,\n    UpdatesSchema\n  >,\n  threadId: ThreadId,\n  claim: Claim,\n) => Effect.Effect<\n  Option.Option<Settlement>,\n  DurableWorkerFailure,\n  DurableWorkerRequirements<\n    RuntimeBinding<\n      InputSchema,\n      OutputSchema,\n      Instructions,\n      Tools,\n      Provider,\n      ModelProvides,\n      ModelRequires,\n      InstructionError,\n      InstructionRequirements,\n      RunDispositionValue,\n      InputPromptValue,\n      UpdatesSchema\n    >,\n    InstructionRequirements\n  >\n>;\n\ntype CapturedAttempt<A extends ExecutableAgentBinding> = (\n  agent: A,\n  threadId: ThreadId,\n  claim: Claim,\n) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure, DurableWorkerRequirements<A>>;\n\n/**\n * An Agent with its worker services captured, ready to drive a fenced Attempt.\n * Concrete Schema and model types stay inside this closure when registrations are collected.\n */\ninterface CapturedBinding {\n  readonly agentId: AgentId;\n  /** Exact immutable definition whose codecs and behavior the worker captured. */\n  readonly definition: Agent.AnyDefinition;\n  /** Captured independently from per-Attempt services: report preparation has no fenced Claim. */\n  readonly reporting?: ReadonlyArray<WorkerReporting<WorkerReportPreparationFailure>>;\n  readonly attempt: (\n    driver: ResolvedAttemptDriver,\n    threadId: ThreadId,\n    claim: Claim,\n  ) => Effect.Effect<Option.Option<Settlement>, DurableWorkerFailure>;\n}\n\ntype ReportRequirements<Reports> =\n  Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>>\n    ? [Reports[number]] extends [never]\n      ? never\n      : Reports[number] extends WorkerReporting<unknown, infer R>\n        ? Exclude<R, Scope.Scope>\n        : never\n    : never;\n\nconst captureReporting = <R>(reports: ReadonlyArray<WorkerReporting<unknown, R>>) =>\n  Effect.map(Effect.context<Exclude<R, Scope.Scope>>(), (context) =>\n    reports.map((report): WorkerReporting<WorkerReportPreparationFailure> => ({\n      ...report,\n      prepare: (value) =>\n        Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(\n          Effect.provide(context),\n          Effect.mapError((error) =>\n            Schema.is(WorkerReportPreparationFailure)(error)\n              ? error\n              : WorkerReportPreparationFailure.make({ stage: \"preparation\" }),\n          ),\n        ),\n    })),\n  );\n\nconst backgroundReports = (definition: Agent.AnyDefinition) => [\n  ...new Set(\n    Object.values(definition.toolkit.tools).flatMap((tool) => {\n      const report = Context.get(tool.annotations, BackgroundReporting);\n\n      return report === undefined ? [] : [report];\n    }),\n  ),\n];\n\n/** One exact executable registration used by durable claim-time resolution. */\nexport interface ResolvedBinding extends CapturedBinding {\n  readonly digests: DefinitionDigests;\n  readonly manifest?: BindingManifest;\n  /** Current encoded input guard, acquired without executable services. */\n  readonly acceptsInput?: (input: PersistedJson) => boolean;\n  readonly retainedManifests?: ReadonlyArray<{\n    readonly digests: DefinitionDigests;\n    readonly replay: ReplayContract;\n    readonly compatibleTools?: Readonly<Record<string, string>>;\n    /** Original declarations prove unchanged semantics and output/completion contracts. */\n    readonly compatibleAgent?: string;\n  }>;\n}\n\n/** Trusted claim identity for resolving per-Attempt application services. Not model input. */\nexport interface AgentAttemptContext {\n  readonly threadId: ThreadId;\n  readonly submissionId: Claim[\"submissionId\"];\n  readonly attemptId: Claim[\"attemptId\"];\n}\n\nconst capture = <A extends ExecutableAgentBinding, Provides = never, Requires = never>(\n  agent: A,\n  attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<Provides, never, Requires>,\n): Effect.Effect<\n  CapturedBinding,\n  never,\n  Exclude<DurableWorkerRequirements<A>, Provides> | Requires\n> =>\n  Effect.map(\n    Effect.context<Exclude<DurableWorkerRequirements<A>, Provides> | Requires>(),\n    (context): CapturedBinding => ({\n      agentId: agent.definition.id,\n      definition: agent.definition,\n      attempt: (driver, threadId, claim) => {\n        // Registration closes one concrete Binding before heterogeneous registrations are\n        // collected. TypeScript cannot instantiate the higher-rank RuntimeBinding parameters\n        // from the intentionally erased public shape, so specialize the driver back to A here.\n        const run = driver as unknown as CapturedAttempt<A>;\n        const execute = run(agent, threadId, claim);\n\n        const scoped =\n          attemptLayer === undefined\n            ? execute\n            : execute.pipe(\n                Effect.provide(\n                  Layer.fresh(\n                    attemptLayer({\n                      threadId,\n                      submissionId: claim.submissionId,\n                      attemptId: claim.attemptId,\n                    }),\n                  ),\n                ),\n              );\n\n        return scoped.pipe(Effect.provide(context)) as Effect.Effect<\n          Option.Option<Settlement>,\n          DurableWorkerFailure\n        >;\n      },\n    }),\n  );\n\n/**\n * Build one exact worker registration from an executable Agent Binding and\n * its already-computed definition digests.\n *\n * `make(agent, digests)` captures the binding plus its worker-requirement\n * Context at Layer/effect construction time. Hosts that start from application\n * version declarations should use `compileRegistrations`; low-level fixtures\n * may supply a previously computed digest triple directly.\n */\nexport const DurableWorkerBinding = {\n  make: <\n    A extends ExecutableAgentBinding,\n    const Reports extends ReadonlyArray<WorkerReporting<unknown, unknown>> = readonly [],\n  >(\n    agent: A,\n    digests: DefinitionDigests,\n    reporting?: Reports,\n  ): Effect.Effect<\n    ResolvedBinding,\n    never,\n    DurableWorkerRequirements<A> | ReportRequirements<Reports>\n  > =>\n    Effect.gen(function* () {\n      const binding = yield* capture(agent);\n\n      const reports = yield* captureReporting([\n        ...(reporting ?? []),\n        ...backgroundReports(agent.definition),\n      ]);\n\n      return { ...binding, digests, reporting: reports };\n    }) as Effect.Effect<\n      ResolvedBinding,\n      never,\n      DurableWorkerRequirements<A> | ReportRequirements<Reports>\n    >,\n} as const;\n\n/** INTERNAL identity-only capture retained for the legacy direct worker path. */\nexport const makeLegacyWorkerBinding = capture;\n\nexport const resolveWorkerBinding = (\n  bindings: ReadonlyArray<ResolvedBinding>,\n  agentId: AgentId,\n  digests: DefinitionDigests,\n  requiredTools?: ReadonlyArray<string>,\n  input?: PersistedJson,\n): Effect.Effect<ResolvedBinding, DurableBindingFailure> => {\n  const registered = bindings.filter((binding) => binding.agentId === agentId);\n\n  if (registered.length === 0) {\n    return Effect.fail(\n      BindingUnavailable.make({\n        agentId,\n        message: `No Agent Binding is registered for ${agentId}; recovery never substitutes different code (SUB-023)`,\n      }),\n    );\n  }\n  const exact = registered.find((binding) => definitionDigestsEqual(binding.digests, digests));\n\n  const compatible =\n    exact ??\n    (registered.length === 1 && bindingSupports(registered[0]!, digests, requiredTools, input)\n      ? registered[0]\n      : undefined);\n\n  if (compatible === undefined) {\n    return Effect.fail(\n      BindingDigestMismatch.make({\n        agentId,\n        message: `No registered Binding proves the retained replay contracts for ${agentId}; the original request and receipts remain pending`,\n      }),\n    );\n  }\n\n  return Effect.succeed(compatible);\n};\n\n/** Resolve authoring-time admission through the one exact host registration, never by identity alone. */\nexport const resolveDefinitionBinding = (\n  bindings: ReadonlyArray<ResolvedBinding>,\n  definition: Pick<Agent.AnyDefinition, \"id\">,\n): Effect.Effect<ResolvedBinding, BindingUnavailable> => {\n  const candidates = bindings.filter((binding) => binding.agentId === definition.id);\n  const binding = candidates[0];\n\n  if (candidates.length !== 1 || binding === undefined) {\n    return Effect.fail(\n      BindingUnavailable.make({\n        agentId: definition.id,\n        message: \"Registered admission requires exactly one binding for the Agent identity\",\n      }),\n    );\n  }\n\n  if (!Object.is(binding.definition, definition)) {\n    return Effect.fail(\n      BindingUnavailable.make({\n        agentId: definition.id,\n        message: \"Registered admission requires the exact Agent Definition used in registration\",\n      }),\n    );\n  }\n\n  return Effect.succeed(binding);\n};\n\n/** Application versions and a model Layer, supplied directly or through an existing Binding. */\nexport type AgentRegistration<A extends ExecutableAgentBinding = ExecutableAgentBinding> = (\n  | { readonly agent: A; readonly model?: never; readonly definitions: DefinitionDigestInput }\n  | {\n      readonly agent: A[\"definition\"];\n      readonly model: A[\"model\"];\n      readonly definitions: DefinitionDigestInput;\n    }\n) & {\n  /** Opt into contract-checked deployment continuity. Omit to require an exact registration. */\n  readonly continuity?: {\n    readonly versions: ReplayVersions;\n    readonly retainedManifests?: ReadonlyArray<BindingManifest>;\n  };\n  /**\n   * Source-owned reports capture services outside attemptLayer and open a fresh Scope per\n   * preparation. Version changes with this registration. Missing exact code and preparation\n   * failures become retained report refusals; durable delivery retries reuse the frozen input.\n   */\n  readonly reporting?: ReadonlyArray<WorkerReporting<unknown, unknown>>;\n  /**\n   * Build fresh services for exactly one fenced Attempt, across all its Tool/model turns.\n   * Finalizes on completion, suspension, failure and interruption. Never reused after eviction.\n   * Resolve invocation authority from the trusted claim identity, not captured caller state.\n   * Keep fallible resource acquisition lazy in typed Tool operations; this Layer cannot fail.\n   */\n  readonly attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<never, never, unknown>;\n};\n\ntype EntryWorkerRequirements<Entry> = Entry extends {\n  readonly agent: infer A extends ExecutableAgentBinding;\n}\n  ? DurableWorkerRequirements<A>\n  : Entry extends {\n        readonly agent: infer D extends ExecutableDefinition;\n        readonly model: infer M extends ExecutableAgentBinding[\"model\"];\n      }\n    ? DurableWorkerRequirements<{ readonly definition: D; readonly model: M }>\n    : never;\n\ntype AttemptLayerRequirements<Requirements, AttemptLayer> = AttemptLayer extends (\n  context: AgentAttemptContext,\n) => Layer.Layer<infer Provides, never, infer Requires>\n  ? Exclude<Requirements, Provides> | Requires\n  : Requirements;\n\n// Conditional options retain every service they may consume. An absent attempt Layer\n// still needs the original worker services; only a definite Layer can remove them.\ntype EntryRequirements<Entry> = Entry extends unknown\n  ?\n      | AttemptLayerRequirements<\n          EntryWorkerRequirements<Entry>,\n          \"attemptLayer\" extends keyof Entry ? Entry[\"attemptLayer\"] : undefined\n        >\n      | (\"reporting\" extends keyof Entry ? ReportRequirements<Entry[\"reporting\"]> : never)\n  : never;\n\ntype RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [\n  Entries[number],\n] extends [never]\n  ? never\n  : EntryRequirements<Entries[number]>;\n\nconst registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInput => {\n  const definition = entry.model === undefined ? entry.agent.definition : entry.agent;\n  const automatic = backgroundReports(definition);\n\n  const declaredDefinitions =\n    definition.updates === undefined\n      ? entry.definitions\n      : {\n          ...entry.definitions,\n          agent: {\n            declaration: entry.definitions.agent,\n            updates: Schema.decodeUnknownSync(Schema.Json)(\n              Tool.getJsonSchemaFromSchema(definition.updates),\n            ),\n            updateProtocol: { schemaVersion: 1, tool: \"emit_update\" },\n          },\n        };\n\n  const definitions =\n    automatic.length === 0\n      ? declaredDefinitions\n      : {\n          ...declaredDefinitions,\n          agent: {\n            declaration: declaredDefinitions.agent,\n            backgroundReporting: automatic.map((report) => ({\n              delegationId: report.delegationId,\n              targetAgentId: report.target.id,\n              mode: report.mode ?? \"custom\",\n              destinationDelegationId: report.destination?.delegationId ?? null,\n            })),\n          },\n        };\n\n  const exposure = definition.toolExposure;\n\n  if (\n    exposure === undefined &&\n    !Object.values(definition.toolkit.tools).some(\n      (tool) =>\n        Context.get(tool.annotations, DiscoveryTool) || Context.get(tool.annotations, PinnedTool),\n    )\n  )\n    return definitions;\n\n  return {\n    ...definitions,\n    agent: {\n      declaration: definitions.agent,\n      toolExposure: {\n        initialToolNames: exposure === undefined ? null : [...(exposure.initialToolNames ?? [])],\n        maxTools: exposure?.maxTools ?? 64,\n        maxSchemaBytes: exposure?.maxSchemaBytes ?? 262_144,\n        requiredCompletion:\n          definition.completion?.required === true ? definition.completion.tool : null,\n        tools: Object.values(definition.toolkit.tools).map((tool) => ({\n          name: tool.name,\n          pinned: Context.get(tool.annotations, PinnedTool),\n          discovery: Context.get(tool.annotations, DiscoveryTool),\n          namespace: Context.get(tool.annotations, ToolNamespace) ?? null,\n          includesCatalogDocumentation: Context.get(tool.annotations, IncludesCatalogDocumentation),\n          additional: Context.get(tool.annotations, AdditionalToolCatalog).map((entry) => ({\n            name: entry.tool.name,\n            namespace: entry.namespace,\n            method: entry.method,\n          })),\n        })),\n      },\n    },\n  };\n};\n\nconst compileRegistration = <Entry extends AgentRegistration>(\n  entry: Entry,\n): Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>> =>\n  Effect.flatMap(\n    Effect.try({\n      try: () => registrationDefinitions(entry),\n      catch: () =>\n        DigestError.make({ message: \"Agent update schema has no serializable wire contract\" }),\n    }),\n    (definitions) =>\n      Effect.gen(function* () {\n        const binding = yield* capture(\n          entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model },\n          entry.attemptLayer,\n        );\n\n        const reporting = yield* captureReporting([\n          ...(entry.reporting ?? []),\n          ...backgroundReports(binding.definition),\n        ]);\n\n        if (entry.continuity === undefined)\n          return { ...binding, digests: yield* digestDefinitions(definitions), reporting };\n\n        return {\n          ...binding,\n          ...(yield* compileBindingManifest(\n            binding.definition,\n            definitions,\n            entry.continuity.versions,\n            entry.continuity.retainedManifests,\n          )),\n          reporting,\n        };\n      }),\n    // The erased descriptor accepts arbitrary provided services. Restore the concrete entry's\n    // Exclude<worker requirements, provided services> | layer requirements at this collection seam.\n  ) as Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>>;\n\n/** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */\nexport const compileRegistrations = <const Entries extends ReadonlyArray<AgentRegistration>>(\n  entries: Entries,\n): Effect.Effect<\n  ReadonlyArray<ResolvedBinding>,\n  DigestError,\n  Crypto.Crypto | RegistrationRequirements<Entries>\n> => {\n  // `Effect.forEach` instantiates a generic callback at its constraint. Specialize the callback to\n  // this tuple's distributed requirement union before collection so empty and heterogeneous tuples\n  // retain their exact service requirements.\n  const compileEntry = compileRegistration as unknown as (\n    entry: Entries[number],\n  ) => Effect.Effect<\n    ResolvedBinding,\n    DigestError,\n    Crypto.Crypto | RegistrationRequirements<Entries>\n  >;\n\n  return Effect.forEach(entries, compileEntry);\n};\n"],"mappings":"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"}

package/dist/capabilities/Commands.d.mts

@@ -1,4 +1,4 @@
-import { o as CommandDrainPolicy } from "../RunOptions-CE-G3niT.mjs";
+import { o as CommandDrainPolicy } from "../RunOptions-Clj8cLsp.mjs";
 import { Effect, Schema } from "effect";
 declare namespace Commands_d_exports {
   export { FollowUpCommand, RunCommand, RunCommandQueue, RunCommandQueueClosed, RunCommandQueueConfig, SteeringCommand, makeRunCommandQueue };

package/dist/capabilities/RunHooks.d.mts

@@ -2,7 +2,7 @@ import { c as ThreadLimitExceeded, i as ThreadEncodingError, s as ThreadHistoryD
 import { RedactionError, Redactor } from "./Redaction.mjs";
 import { ApprovalAudit, ApprovalAuditLimitExceeded, ApprovalDecisionMismatch, ApprovalRequestDraft, ApprovalResolver, ApprovalResolverError } from "./Approval.mjs";
 import { BudgetExceeded, UsageBudgetNode } from "./Budget.mjs";
-import { M as RunOptions, R as RunSchedulingHook, _ as RunBudgetHook, b as RunContextHook, g as RunApprovalRequest, h as RunApprovalHook, j as RunInputHook, w as RunContextRequest } from "../RunOptions-CE-G3niT.mjs";
+import { M as RunOptions, R as RunSchedulingHook, _ as RunBudgetHook, b as RunContextHook, g as RunApprovalRequest, h as RunApprovalHook, j as RunInputHook, w as RunContextRequest } from "../RunOptions-Clj8cLsp.mjs";
 import { RunCommandQueue } from "./Commands.mjs";
 import { Prompt } from "effect/unstable/ai";
 import { Effect, Schema } from "effect";

package/dist/capabilities/Subagent.d.mts

@@ -1,4 +1,4 @@
 import { c as SubagentExecutionFailureClassification, l as SubagentGrant, s as SubagentExecutionFailure } from "../SubagentContract-DdT7Cqe6.mjs";
 import { l as WorkerReport, r as WorkerCompletion } from "../Worker--j87JI__.mjs";
-import { A as cancel, B as delegationAllocationFromPolicy, C as reporting, D as Worker, E as BackgroundTools, F as start, I as SubagentPolicy, L as SubagentPolicyInput, M as inspect, N as list, O as WorkerObservation, P as observe, R as SubagentPrestartDenied, S as make, T as BackgroundOptions, V as delegationCapsFromPolicy, _ as SubagentTools, a as SubagentDelegation, b as define, c as SubagentFailureMode, d as SubagentResult, f as SubagentResultContext, g as SubagentToolFailure, h as SubagentTool, i as SubagentDefineOptions, j as followUp, k as awaitWorker, l as SubagentLayerRequirements, m as SubagentRuntimeOptions, n as SubagentContainedFailure, o as SubagentDurableAccounting, p as SubagentReturnModeFailure, r as SubagentDeclarationOptions, s as SubagentDurableOptions, t as SubagentChildRunFailure, u as SubagentPrepareContext, w as reportingToWorker, x as layer, y as background, z as SubagentProjectionFailure } from "../Subagent-DscbtbNY.mjs";
+import { A as cancel, B as delegationAllocationFromPolicy, C as reporting, D as Worker, E as BackgroundTools, F as start, I as SubagentPolicy, L as SubagentPolicyInput, M as inspect, N as list, O as WorkerObservation, P as observe, R as SubagentPrestartDenied, S as make, T as BackgroundOptions, V as delegationCapsFromPolicy, _ as SubagentTools, a as SubagentDelegation, b as define, c as SubagentFailureMode, d as SubagentResult, f as SubagentResultContext, g as SubagentToolFailure, h as SubagentTool, i as SubagentDefineOptions, j as followUp, k as awaitWorker, l as SubagentLayerRequirements, m as SubagentRuntimeOptions, n as SubagentContainedFailure, o as SubagentDurableAccounting, p as SubagentReturnModeFailure, r as SubagentDeclarationOptions, s as SubagentDurableOptions, t as SubagentChildRunFailure, u as SubagentPrepareContext, w as reportingToWorker, x as layer, y as background, z as SubagentProjectionFailure } from "../Subagent-Bm1dRecN.mjs";
 export { type BackgroundOptions, type BackgroundTools, SubagentChildRunFailure, SubagentContainedFailure, SubagentDeclarationOptions, SubagentDefineOptions, SubagentDelegation, SubagentDurableAccounting, SubagentDurableOptions, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentFailureMode, SubagentGrant, SubagentLayerRequirements, SubagentPolicy, type SubagentPolicyInput, SubagentPrepareContext, SubagentPrestartDenied, SubagentProjectionFailure, SubagentResult, SubagentResultContext, SubagentReturnModeFailure, SubagentRuntimeOptions, SubagentTool, SubagentToolFailure, SubagentTools, Worker, WorkerCompletion, WorkerObservation, WorkerReport, awaitWorker as await, background, cancel, define, delegationAllocationFromPolicy, delegationCapsFromPolicy, followUp, inspect, layer, list, make, observe, reporting, reportingToWorker, start };

package/dist/durable/ActivityStore.d.mts

@@ -1,4 +1,4 @@
-import { _ as Digest } from "../Records-B84j3Jq_.mjs";
+import { _ as Digest } from "../Records-CV49DgQK.mjs";
 import { Context, Effect, Layer, Schema } from "effect";
 declare namespace ActivityStore_d_exports {
   export { ActivityBusy, ActivityClaim, ActivityClaimRequest, ActivityMutationFailpoint, ActivityMutationFailure, ActivityMutationPoint, ActivityOwnershipLost, ActivityProcessorKey, ActivityProcessorStore, ActivityProgress, ActivityStoreError, ActivityStoreFailure, ActivityWorkConflict, PreparedActivity };

package/dist/durable/ActivityStore.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
 import { ThreadId } from "../core/Identifiers.mjs";
-import { T as PersistedJson, h as Digest, k as RecordId, u as CanonicalSequence } from "../Records-CsEsSW2o.mjs";
+import { T as PersistedJson, h as Digest, k as RecordId, u as CanonicalSequence } from "../Records-BAutSSnJ.mjs";
 import { Context, Effect, Layer, Schema } from "effect";
 //#region src/durable/ActivityStore.ts
 var ActivityStore_exports = /* @__PURE__ */ __exportAll({

package/dist/durable/Admin.d.mts

@@ -1,2 +1,2 @@
-import { Cr as RetryCommand, Dr as predictRecoveryDisposition, Er as obligationSeverityOf, Or as recoveryDecisionMeaning, Sr as RecoveryExplanation, Tr as RetryRefused, _r as ObligationReport, br as RECOVERY_DECISION_MEANINGS, cr as ExplainedEvidence, dr as IntegrityCheck, fr as IntegrityCheckName, gr as ObligationEntry, hr as ObligationBlockedOn, kr as renderRecoveryExplanation, lr as ExplainedSubmission, mr as IntegrityReport, pr as IntegrityCheckStatus, ur as ExplainedUnknownCall, vr as ObligationSeverity, wr as RetryRefusalReason, xr as RecoveryDisposition, yr as ObligationThresholds } from "../Records-B84j3Jq_.mjs";
+import { Ar as obligationSeverityOf, Cr as ObligationThresholds, Dr as RetryCommand, Er as RecoveryExplanation, Mr as recoveryDecisionMeaning, Nr as renderRecoveryExplanation, Or as RetryRefusalReason, Sr as ObligationSeverity, Tr as RecoveryDisposition, _r as IntegrityCheckStatus, br as ObligationEntry, fr as ExplainedEvidence, gr as IntegrityCheckName, hr as IntegrityCheck, jr as predictRecoveryDisposition, kr as RetryRefused, mr as ExplainedUnknownCall, pr as ExplainedSubmission, vr as IntegrityReport, wr as RECOVERY_DECISION_MEANINGS, xr as ObligationReport, yr as ObligationBlockedOn } from "../Records-CV49DgQK.mjs";
 export { ExplainedEvidence, ExplainedSubmission, ExplainedUnknownCall, IntegrityCheck, IntegrityCheckName, IntegrityCheckStatus, IntegrityReport, ObligationBlockedOn, ObligationEntry, ObligationReport, ObligationSeverity, ObligationThresholds, RECOVERY_DECISION_MEANINGS, RecoveryDisposition, RecoveryExplanation, RetryCommand, RetryRefusalReason, RetryRefused, obligationSeverityOf, predictRecoveryDisposition, recoveryDecisionMeaning, renderRecoveryExplanation };

package/dist/durable/Admin.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
 import { SubmissionId, ThreadId, ToolCallId } from "../core/Identifiers.mjs";
 import { QueueSequence } from "../core/Receipt.mjs";
-import { L as SettlementOutcome, Q as ToolCallUnknown, u as CanonicalSequence } from "../Records-CsEsSW2o.mjs";
+import { et as ToolCallUnknown, u as CanonicalSequence, z as SettlementOutcome } from "../Records-BAutSSnJ.mjs";
 import { AbortCommand, AbortIntent, ApprovalDecisionIntent, ChildAttachmentSnapshot, JoinSnapshot, ParentLinkage, SubmissionState, SuspensionSnapshot, UnknownResolutionIntent } from "./SubmissionLedger.mjs";
 import { OpenDelegationCallEvidence, OpenToolCallEvidence, PendingApprovalEvidence, RecoveryDecision } from "./Recovery.mjs";
 import { DateTime, Schema } from "effect";

package/dist/durable/AgentRegistration.d.mts

@@ -1,2 +1,2 @@
-import { Br as definitionDigestsEqual, Fr as DurableBindingFailure, Ir as DurableWorkerBinding, Lr as ExecutableAgentBinding, Mr as AgentRegistration, Nr as BindingDigestMismatch, Pr as BindingUnavailable, Rr as ResolvedBinding, jr as AgentAttemptContext, zr as compileRegistrations } from "../Records-B84j3Jq_.mjs";
-export { type AgentAttemptContext, type AgentRegistration, BindingDigestMismatch, BindingUnavailable, type DurableBindingFailure, DurableWorkerBinding, type ExecutableAgentBinding, type ResolvedBinding, compileRegistrations, definitionDigestsEqual };
+import { Br as DurableBindingFailure, Fr as AgentAttemptContext, Gr as bindingSupports, Hr as ExecutableAgentBinding, Ir as AgentRegistration, Jr as definitionDigestsEqual, Kr as compileBindingManifest, Lr as BindingDigestMismatch, Rr as BindingManifest, Ur as ReplayVersions, Vr as DurableWorkerBinding, Wr as ResolvedBinding, Yr as makeBindingManifest, qr as compileRegistrations, zr as BindingUnavailable } from "../Records-CV49DgQK.mjs";
+export { type AgentAttemptContext, type AgentRegistration, BindingDigestMismatch, BindingManifest, BindingUnavailable, type DurableBindingFailure, DurableWorkerBinding, type ExecutableAgentBinding, type ReplayVersions, type ResolvedBinding, bindingSupports, compileBindingManifest, compileRegistrations, definitionDigestsEqual, makeBindingManifest };

package/dist/durable/AgentRegistration.mjs

@@ -1,14 +1,18 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
-import { a as definitionDigestsEqual, i as compileRegistrations, n as BindingUnavailable, r as DurableWorkerBinding, t as BindingDigestMismatch } from "../agent-registration-CWDMOAZA.mjs";
+import { a as bindingSupports, c as definitionDigestsEqual, i as DurableWorkerBinding, l as makeBindingManifest, n as BindingManifest, o as compileBindingManifest, r as BindingUnavailable, s as compileRegistrations, t as BindingDigestMismatch } from "../agent-registration-CXGDwvJH.mjs";
 //#region src/durable/AgentRegistration.ts
 var AgentRegistration_exports = /* @__PURE__ */ __exportAll({
 	BindingDigestMismatch: () => BindingDigestMismatch,
+	BindingManifest: () => BindingManifest,
 	BindingUnavailable: () => BindingUnavailable,
 	DurableWorkerBinding: () => DurableWorkerBinding,
+	bindingSupports: () => bindingSupports,
+	compileBindingManifest: () => compileBindingManifest,
 	compileRegistrations: () => compileRegistrations,
-	definitionDigestsEqual: () => definitionDigestsEqual
+	definitionDigestsEqual: () => definitionDigestsEqual,
+	makeBindingManifest: () => makeBindingManifest
 });
 //#endregion
-export { BindingDigestMismatch, BindingUnavailable, DurableWorkerBinding, compileRegistrations, definitionDigestsEqual, AgentRegistration_exports as t };
+export { BindingDigestMismatch, BindingManifest, BindingUnavailable, DurableWorkerBinding, bindingSupports, compileBindingManifest, compileRegistrations, definitionDigestsEqual, makeBindingManifest, AgentRegistration_exports as t };
 
 //# sourceMappingURL=AgentRegistration.mjs.map

package/dist/durable/AgentRegistration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"AgentRegistration.mjs","names":[],"sources":["../../src/durable/AgentRegistration.ts"],"sourcesContent":["/** Public AgentRegistration API. Implementation helpers remain private. */\nexport {\n  BindingUnavailable,\n  BindingDigestMismatch,\n  DurableWorkerBinding,\n  compileRegistrations,\n  definitionDigestsEqual,\n  type AgentRegistration,\n  type AgentAttemptContext,\n  type ExecutableAgentBinding,\n  type DurableBindingFailure,\n  type ResolvedBinding,\n} from \"./internal/agent-registration.ts\";\n"],"mappings":""}
+{"version":3,"file":"AgentRegistration.mjs","names":[],"sources":["../../src/durable/AgentRegistration.ts"],"sourcesContent":["/** Public AgentRegistration API. Implementation helpers remain private. */\nexport {\n  BindingUnavailable,\n  BindingDigestMismatch,\n  DurableWorkerBinding,\n  compileRegistrations,\n  definitionDigestsEqual,\n  bindingSupports,\n  BindingManifest,\n  makeBindingManifest,\n  compileBindingManifest,\n  type ReplayVersions,\n  type AgentRegistration,\n  type AgentAttemptContext,\n  type ExecutableAgentBinding,\n  type DurableBindingFailure,\n  type ResolvedBinding,\n} from \"./internal/agent-registration.ts\";\n"],"mappings":""}

package/dist/durable/Certification.d.mts

@@ -1,4 +1,4 @@
-import { Va as SubmissionLedger, nn as ThreadStore } from "../Records-B84j3Jq_.mjs";
+import { Xa as SubmissionLedger, in as ThreadStore } from "../Records-CV49DgQK.mjs";
 import { Crypto, Effect, Schema } from "effect";
 //#region src/durable/Certification.d.ts
 declare const CertifiedAdapterIdentity_base: Schema.Class<CertifiedAdapterIdentity, Schema.Struct<{
@@ -43,7 +43,7 @@ declare const CertificationSweepStatus: Schema.Literals<readonly ["converged", "
 type CertificationSweepStatus = typeof CertificationSweepStatus.Type;
 declare const CertificationSweepResult_base: Schema.Class<CertificationSweepResult, Schema.Struct<{
   readonly scenario: Schema.Literals<readonly ["plain", "uncertain-tool", "durable-steps", "approval", "join", "delegation"]>;
-  readonly location: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+  readonly location: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
   /** The armed fault actually fired (one-shot) somewhere in the cell's drive or re-drive. */
   readonly failpointFired: Schema.Boolean;
   readonly status: Schema.Literals<readonly ["converged", "not-triggered", "failed"]>;

package/dist/durable/CommittedActivity.d.mts

@@ -1,4 +1,4 @@
-import { O as PersistedJson, Qt as ThreadNotMaterialized, Vr as DigestError, l as CanonicalRecordEnvelope, nn as ThreadStore, rn as ThreadStoreError } from "../Records-B84j3Jq_.mjs";
+import { O as PersistedJson, Xr as DigestError, an as ThreadStoreError, en as ThreadNotMaterialized, in as ThreadStore, l as CanonicalRecordEnvelope } from "../Records-CV49DgQK.mjs";
 import { ActivityProcessorKey, ActivityProcessorStore, ActivityStoreFailure, PreparedActivity } from "./ActivityStore.mjs";
 import { Crypto, Effect, Schema, Scope } from "effect";
 declare namespace CommittedActivity_d_exports {