effect-agent 0.1.0-beta.96 → 0.1.0-beta.98

package/dist/{Subagent-Bm1dRecN.d.mts → Subagent-m7ywTCe4.d.mts}

@@ -6,9 +6,9 @@ import { s as RunTotals } from "./Usage-Dx0aknfk.mjs";
 import { t as ThreadHistory } from "./ThreadHistory-tS1KwxHR.mjs";
 import { T as RunDispositionDeclaration, _ as InstructionSource, c as Definition, m as InputPromptSource, r as AnyDefinition } from "./Agent-CM6JubNX.mjs";
 import { a as WorkerError, c as WorkerRef, l as WorkerReport, n as WorkerBudgetScope, r as WorkerCompletion } from "./Worker--j87JI__.mjs";
-import { V as RunSubagentDigests, x as RunContextPreparation } from "./RunOptions-Clj8cLsp.mjs";
+import { V as RunSubagentDigests, x as RunContextPreparation } from "./RunOptions-Bruk54SE.mjs";
 import { i as SubagentHost, l as WorkerReporting } from "./SubagentHost-DaFMZnVR.mjs";
-import { S as ToolCallWaiting, _ as SubagentDurability, b as SubagentDurabilityError, c as AgentSpawner, h as SpawnRunOptions, l as AgentSpawnerParent, o as AgentRuntimeFailure, p as RuntimeBinding, s as AgentRuntimeRequirements } from "./AgentRuntime-B64362Id.mjs";
+import { S as ToolCallWaiting, _ as SubagentDurability, b as SubagentDurabilityError, c as AgentSpawner, h as SpawnRunOptions, l as AgentSpawnerParent, o as AgentRuntimeFailure, p as RuntimeBinding, s as AgentRuntimeRequirements } from "./AgentRuntime-BMzrJos6.mjs";
 import { t as RunEventSink } from "./RunEventSink-D5aVhISG.mjs";
 import { Tool, Toolkit } from "effect/unstable/ai";
 import { Crypto, Duration, Effect, Layer, Schema, Scope, Stream } from "effect";
@@ -823,4 +823,4 @@ declare function background<const Name extends string, Input extends Schema.Top,
 declare function background<const Name extends string, Input extends Schema.Top, Output extends Schema.Top, Parameters extends Schema.Top, Success extends Schema.Top, Failure extends Schema.Top, Prepare, Project, const Selected extends BackgroundOptions>(declaration: Declaration<Name, Input, Output, Parameters, Success, Failure, Prepare, Project>, selected: Selected): ReturnType<typeof background$1<Name, Input, Output, Parameters, Success, Failure, Prepare, Project, Selected>>;
 //#endregion
 export { cancel as A, delegationAllocationFromPolicy as B, reporting as C, Worker as D, BackgroundTools as E, start as F, SubagentPolicy as I, SubagentPolicyInput as L, inspect as M, list as N, WorkerObservation as O, observe as P, SubagentPrestartDenied as R, make as S, BackgroundOptions as T, delegationCapsFromPolicy as V, SubagentTools as _, SubagentDelegation as a, define as b, SubagentFailureMode as c, SubagentResult as d, SubagentResultContext as f, SubagentToolFailure as g, SubagentTool as h, SubagentDefineOptions as i, followUp as j, awaitWorker as k, SubagentLayerRequirements as l, SubagentRuntimeOptions as m, SubagentContainedFailure as n, SubagentDurableAccounting as o, SubagentReturnModeFailure as p, SubagentDeclarationOptions as r, SubagentDurableOptions as s, SubagentChildRunFailure as t, SubagentPrepareContext as u, Subagent_d_exports as v, reportingToWorker as w, layer as x, background as y, SubagentProjectionFailure as z };
-//# sourceMappingURL=Subagent-Bm1dRecN.d.mts.map
+//# sourceMappingURL=Subagent-m7ywTCe4.d.mts.map

package/dist/{Subscription-CrTIQKZR.d.mts → Subscription-BCQ3L9Zp.d.mts}

@@ -2,8 +2,8 @@ import { d as SubagentReservationAmounts, l as SubagentGrant, o as SubagentDeleg
 import { a as Receipt, r as Principal } from "./Receipt-BAHyigAF.mjs";
 import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
 import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
-import { _ as Digest, h as DefinitionDigests } from "./Records-CMByd1eD.mjs";
-import { t as ScheduleAuthorizationDecision } from "./Schedule-BxCfnYr0.mjs";
+import { _ as Digest, h as DefinitionDigests } from "./Records-BIiRLqlz.mjs";
+import { t as ScheduleAuthorizationDecision } from "./Schedule-BNFlluAl.mjs";
 import { Context, Effect, Schema } from "effect";
 declare namespace Subscription_d_exports {
   export { AcceptedEvent, DeliveryChange, EventAcknowledgement, EventSourceVersion, PreparedInput, SourcePartition, SourceRecovery, SubscriptionAuthorizer, SubscriptionChange, SubscriptionConfiguration, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionDeliverySnapshot, SubscriptionError, SubscriptionFailpoint, SubscriptionFailpointError, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionRefusal, SubscriptionRetentionPolicy, SubscriptionScanCursors, SubscriptionScope, SubscriptionSnapshot, SubscriptionSourceError, SubscriptionStore, SubscriptionStoreFailure, defaultSubscriptionLimits, subscriptionDeliveryKeyString, subscriptionKeyString };
@@ -918,4 +918,4 @@ declare const subscriptionKeyString: (key: SubscriptionKey) => string;
 declare const subscriptionDeliveryKeyString: (key: SubscriptionDeliveryKey) => string;
 //#endregion
 export { defaultSubscriptionLimits as A, SubscriptionScanCursors as C, SubscriptionStore as D, SubscriptionSourceError as E, subscriptionKeyString as M, SubscriptionStoreFailure as O, SubscriptionRetentionPolicy as S, SubscriptionSnapshot as T, SubscriptionKey as _, PreparedInput as a, SubscriptionRecord as b, SubscriptionAuthorizer as c, SubscriptionDelivery as d, SubscriptionDeliveryKey as f, SubscriptionFailpointError as g, SubscriptionFailpoint as h, EventSourceVersion as i, subscriptionDeliveryKeyString as j, Subscription_d_exports as k, SubscriptionChange as l, SubscriptionError as m, DeliveryChange as n, SourcePartition as o, SubscriptionDeliverySnapshot as p, EventAcknowledgement as r, SourceRecovery as s, AcceptedEvent as t, SubscriptionConfiguration as u, SubscriptionLimits as v, SubscriptionScope as w, SubscriptionRefusal as x, SubscriptionName as y };
-//# sourceMappingURL=Subscription-CrTIQKZR.d.mts.map
+//# sourceMappingURL=Subscription-BCQ3L9Zp.d.mts.map

package/dist/{SubscriptionInput-BVOeFF1L.d.mts → SubscriptionInput-Cqu4_RW3.d.mts}

@@ -1,6 +1,6 @@
 import { t as AgentId } from "./Identifiers-CN2s30fF.mjs";
-import { O as PersistedJson, h as DefinitionDigests } from "./Records-CMByd1eD.mjs";
-import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, m as SubscriptionError, t as AcceptedEvent, u as SubscriptionConfiguration } from "./Subscription-CrTIQKZR.mjs";
+import { O as PersistedJson, h as DefinitionDigests } from "./Records-BIiRLqlz.mjs";
+import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, m as SubscriptionError, t as AcceptedEvent, u as SubscriptionConfiguration } from "./Subscription-BCQ3L9Zp.mjs";
 import { Context, Effect, Schema, Scope } from "effect";
 declare namespace SubscriptionInput_d_exports {
   export { SubscriptionInputBinding, SubscriptionInputBindings, makeSubscriptionInputBinding, resolveSubscriptionInput };
@@ -38,4 +38,4 @@ declare const makeSubscriptionInputBinding: <Event extends Schema.Top, Parameter
 }) => Effect.Effect<SubscriptionInputBinding, never, Exclude<R, Scope.Scope> | Exclude<Continuation["DecodingServices"], Scope.Scope> | Exclude<Continuation["EncodingServices"], Scope.Scope> | Exclude<Event["DecodingServices"], Scope.Scope> | Exclude<Input["EncodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope>>;
 //#endregion
 export { resolveSubscriptionInput as a, makeSubscriptionInputBinding as i, SubscriptionInputBindings as n, SubscriptionInput_d_exports as r, SubscriptionInputBinding as t };
-//# sourceMappingURL=SubscriptionInput-BVOeFF1L.d.mts.map
+//# sourceMappingURL=SubscriptionInput-Cqu4_RW3.d.mts.map

package/dist/{ToolReconciler-DQVaJfpE.d.mts → ToolReconciler-BmVRAHKs.d.mts}

@@ -11,6 +11,9 @@ declare const PreparedToolCallEvidence_base: Schema.Class<PreparedToolCallEviden
   readonly toolName: Schema.NonEmptyString;
   readonly parameters: Schema.declare<Schema.Json, Schema.Json>;
   readonly parametersDigest: Schema.brand<Schema.String, "@effect-agent/thread/Digest">;
+  readonly executionKind: Schema.optionalKey<Schema.Literals<readonly ["ordinary", "delegation", "orchestration"]>>;
+  readonly executionClass: Schema.optionalKey<Schema.Literals<readonly ["readonly", "idempotent", "uncertain"]>>;
+  readonly replay: Schema.optionalKey<Schema.brand<Schema.String, "@effect-agent/thread/Digest">>;
 }>, {}>;
 /**
  * Everything a reconciliation policy can consult about one prepared-but-unsettled ordinary Tool
@@ -20,7 +23,7 @@ declare const PreparedToolCallEvidence_base: Schema.Class<PreparedToolCallEviden
  */
 declare class PreparedToolCallEvidence extends PreparedToolCallEvidence_base {}
 declare const ReconciliationNeverStarted_base: Schema.Class<ReconciliationNeverStarted, Schema.TaggedStruct<"NeverStarted", {}>, {}>;
-/** Proof that the external execution never started: the call may re-execute on resume. */
+/** Proof of nonexecution: resume the original operation or report it unavailable. */
 declare class ReconciliationNeverStarted extends ReconciliationNeverStarted_base {}
 declare const ReconciliationCompleted_base: Schema.Class<ReconciliationCompleted, Schema.TaggedStruct<"CompletedWithResult", {
   readonly result: Schema.declare<Schema.Json, Schema.Json>;
@@ -32,7 +35,7 @@ declare const ReconciliationCompleted_base: Schema.Class<ReconciliationCompleted
  */
 declare class ReconciliationCompleted extends ReconciliationCompleted_base {}
 declare const ReconciliationSafeToRetry_base: Schema.Class<ReconciliationSafeToRetry, Schema.TaggedStruct<"SafeToRetry", {}>, {}>;
-/** The call is safe to repeat under a stable external idempotency contract. */
+/** Only the original operation, identity and parameters may repeat under supported semantics. */
 declare class ReconciliationSafeToRetry extends ReconciliationSafeToRetry_base {}
 declare const ReconciliationUncertain_base: Schema.Class<ReconciliationUncertain, Schema.TaggedStruct<"Uncertain", {
   readonly reason: Schema.String;
@@ -43,7 +46,8 @@ declare class ReconciliationUncertain extends ReconciliationUncertain_base {}
  * What a reconciliation policy can prove about one prepared-but-unsettled ordinary Tool Call
  * (durability §10): execution never started, execution completed with a recoverable result,
  * execution is safe to repeat, or nothing — in which case the Run enters Unknown. The engine
- * never manufactures an error result and continues.
+ * never invents an external result. Proven nonexecution can close a retired operation with
+ * an explicit not-executed result; uncertainty stays parked.
  */
 declare const ReconciliationDecision: Schema.Union<readonly [typeof ReconciliationNeverStarted, typeof ReconciliationCompleted, typeof ReconciliationSafeToRetry, typeof ReconciliationUncertain]>;
 type ReconciliationDecision = typeof ReconciliationDecision.Type;
@@ -73,4 +77,4 @@ declare class ToolReconciler extends ToolReconciler_base {
 }
 //#endregion
 export { ReconciliationSafeToRetry as a, ToolReconcilerError as c, ReconciliationNeverStarted as i, ToolReconciler_d_exports as l, ReconciliationCompleted as n, ReconciliationUncertain as o, ReconciliationDecision as r, ToolReconciler as s, PreparedToolCallEvidence as t };
-//# sourceMappingURL=ToolReconciler-DQVaJfpE.d.mts.map
+//# sourceMappingURL=ToolReconciler-BmVRAHKs.d.mts.map

package/dist/{agent-registration-BTa5vmQF.mjs → agent-registration-cXpB8cBU.mjs}

@@ -2,97 +2,62 @@ 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 { ContextRolloverTool } from "./engine/ContextWindow.mjs";
 import { getToolExecutionClass } from "./engine/DurableStep.mjs";
-import { M as ReplayContract, f as DefinitionDigestInput, p as DefinitionDigests } from "./Records-BEz5IFUu.mjs";
+import { M as ReplayContract, p as DefinitionDigests } from "./Records-DR1xtbXY.mjs";
 import { DigestError, digestDefinitions, digestJson } from "./durable/Digest.mjs";
 import { Tool } from "effect/unstable/ai";
 import { 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.
-*/
+/** No unique current executable is registered for the stable Agent identity. */
 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). */
+/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */
 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.
-*/
-var BindingManifest = class extends Schema.Class("BindingManifest")({
-	agentId: AgentId,
-	definitions: DefinitionDigestInput,
-	replay: ReplayContract
-}) {};
-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({
+/** Hash current operation contracts; no historical definitions or schemas are retained. */
+const toolReplayContracts = Effect.fn("AgentRegistration.toolReplayContracts")(function* (definition, versions, fallbackVersion = null) {
+	const declarations = 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) => ({
+			const jsonSchema = (schema) => Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));
+			return Object.values(definition.toolkit.tools).map((tool) => {
+				const version = versions === void 0 ? fallbackVersion : versions.tools[tool.name];
+				if (version === void 0 || versions !== void 0 && !Object.hasOwn(versions.tools, tool.name)) throw new Error("Every Tool needs an explicit replay semantic version");
+				return {
 					name: tool.name,
 					contract: {
-						version: versions.tools[tool.name],
+						version,
 						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)
+						executionKind: getToolExecutionKind(tool.annotations),
+						contextRollover: Context.get(tool.annotations, ContextRolloverTool),
+						completion: definition.completion?.tool === tool.name,
+						completionFromTool: definition.completionFromTools?.some((declaration) => declaration.tool === tool.name) ?? false
 					}
-				}))
-			};
+				};
+			});
 		},
-		catch: () => DigestError.make({ message: "Replay contracts require serializable codecs and an explicit semantic version for every Tool" })
+		catch: () => DigestError.make({ message: "Operation contracts require serializable codecs and a version for every Tool" })
 	});
-	const agent = yield* digestJson(contracts.agent);
-	const tools = yield* Effect.forEach(contracts.tools, ({ name, contract }) => digestJson(contract).pipe(Effect.map((digest) => [name, digest])));
-	return BindingManifest.make({
-		agentId: definition.id,
-		definitions,
+	return Object.fromEntries(yield* Effect.forEach(declarations, ({ name, contract }) => digestJson(contract).pipe(Effect.map((digest) => [name, digest]))));
+});
+/** Compile current metadata without acquiring executable services. */
+const compileBindingContracts = Effect.fn("AgentRegistration.compileBindingContracts")(function* (definition, definitions, versions) {
+	const digests = yield* digestDefinitions(definitions);
+	const tools = yield* toolReplayContracts(definition, versions, definitions.tools);
+	return { digests: DefinitionDigests.make({
+		...digests,
 		replay: ReplayContract.make({
-			agent,
-			tools: Object.fromEntries(tools)
+			agent: digests.agent,
+			tools
 		})
-	});
+	}) };
 });
-const replaySupports = (current, retained, requiredTools) => current.agent === retained.agent && (requiredTools ?? Object.keys(retained.tools)).every((name) => retained.tools[name] !== void 0 && current.tools[name] === retained.tools[name]);
-/** Resolve executable code only. Admission, delivery, lineage and receipt comparisons stay exact. */
-const bindingSupports = (binding, digests, requiredTools) => {
-	if (definitionDigestsEqual(binding.digests, digests)) return true;
-	const retained = digests.replay ?? binding.retainedManifests?.find((entry) => definitionDigestsEqual(entry.digests, digests))?.replay;
-	return binding.digests.replay !== void 0 && retained !== void 0 && replaySupports(binding.digests.replay, retained, requiredTools);
-};
 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" })))
@@ -133,18 +98,13 @@ const DurableWorkerBinding = { make: (agent, digests, reporting) => Effect.gen(f
 }) };
 /** INTERNAL identity-only capture retained for the legacy direct worker path. */
 const makeLegacyWorkerBinding = capture;
-const resolveWorkerBinding = (bindings, agentId, digests, requiredTools) => {
+const resolveWorkerBinding = (bindings, agentId) => {
 	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) ? registered[0] : void 0);
-	if (compatible === void 0) return Effect.fail(BindingDigestMismatch.make({
+	const binding = registered[0];
+	return registered.length === 1 && binding !== void 0 ? Effect.succeed(binding) : Effect.fail(BindingUnavailable.make({
 		agentId,
-		message: `No registered Binding proves the retained replay contracts for ${agentId}; the original request and receipts remain pending`
+		message: `Exactly one current Agent Binding must be registered for ${agentId}`
 	}));
-	return Effect.succeed(compatible);
 };
 /** Resolve authoring-time admission through the one exact host registration, never by identity alone. */
 const resolveDefinitionBinding = (bindings, definition) => {
@@ -216,31 +176,16 @@ const registrationDefinitions = (entry) => {
 const compileRegistration = (entry) => Effect.flatMap(Effect.try({
 	try: () => registrationDefinitions(entry),
 	catch: () => DigestError.make({ message: "Agent update schema has no serializable wire contract" })
-}).pipe(Effect.flatMap(digestDefinitions)), (digests) => Effect.gen(function* () {
+}), (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,
-		reporting
-	};
-	const manifest = yield* makeBindingManifest(binding.definition, registrationDefinitions(entry), entry.continuity.versions);
-	const retainedManifests = yield* Effect.forEach(entry.continuity.retainedManifests ?? [], (retained) => retained.agentId === binding.agentId ? digestDefinitions(retained.definitions).pipe(Effect.map((digests) => ({
-		digests,
-		replay: retained.replay
-	}))) : Effect.fail(DigestError.make({ message: "A retained manifest belongs to another Agent" })));
 	return {
 		...binding,
-		digests: DefinitionDigests.make({
-			...digests,
-			replay: manifest.replay
-		}),
-		reporting,
-		manifest,
-		retainedManifests
+		...yield* compileBindingContracts(binding.definition, definitions, entry.continuity?.versions),
+		reporting
 	};
 }));
 /** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
@@ -249,6 +194,6 @@ const compileRegistrations = (entries) => {
 	return Effect.forEach(entries, compileEntry);
 };
 //#endregion
-export { bindingSupports as a, makeBindingManifest as c, resolveWorkerBinding as d, DurableWorkerBinding as i, makeLegacyWorkerBinding as l, BindingManifest as n, compileRegistrations as o, BindingUnavailable as r, definitionDigestsEqual as s, BindingDigestMismatch as t, resolveDefinitionBinding as u };
+export { definitionDigestsEqual as a, resolveWorkerBinding as c, compileRegistrations as i, toolReplayContracts as l, DurableWorkerBinding as n, makeLegacyWorkerBinding as o, compileBindingContracts as r, resolveDefinitionBinding as s, BindingUnavailable as t };
 
-//# sourceMappingURL=agent-registration-BTa5vmQF.mjs.map
+//# sourceMappingURL=agent-registration-cXpB8cBU.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent-registration-cXpB8cBU.mjs","names":["run"],"sources":["../src/durable/internal/agent-registration.ts"],"sourcesContent":["import { type Crypto, type Option, type Scope, Context, Effect, Layer, Schema } 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 { ContextRolloverTool } from \"../../engine/ContextWindow.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 type { DefinitionDigestInput, PersistedJson } from \"../Records.ts\";\nimport { DefinitionDigests, ReplayContract } from \"../Records.ts\";\nimport type { Claim, Settlement } from \"../SubmissionLedger.ts\";\n\n/** No unique current executable is registered for the stable Agent identity. */\nexport class BindingUnavailable extends Schema.TaggedError<BindingUnavailable>()(\n  \"BindingUnavailable\",\n  { agentId: AgentId, message: Schema.String },\n) {}\n\nexport type DurableBindingFailure = BindingUnavailable;\n\n/** Exact immutable admission, lineage and delivery evidence; never an executable-code gate. */\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/** Change an operation version when its meaning, durable Steps or idempotency keys change. */\nexport interface ReplayVersions {\n  readonly tools: Readonly<Record<string, PersistedJson>>;\n}\n\n/** Hash current operation contracts; no historical definitions or schemas are retained. */\nexport const toolReplayContracts = Effect.fn(\"AgentRegistration.toolReplayContracts\")(function* (\n  definition: Agent.AnyDefinition,\n  versions?: ReplayVersions,\n  fallbackVersion: PersistedJson = null,\n) {\n  const declarations = yield* Effect.try({\n    try: () => {\n      const jsonSchema = (schema: Schema.Top) =>\n        Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(schema));\n\n      return Object.values(definition.toolkit.tools).map((tool) => {\n        const version = versions === undefined ? fallbackVersion : versions.tools[tool.name];\n\n        if (\n          version === undefined ||\n          (versions !== undefined && !Object.hasOwn(versions.tools, tool.name))\n        )\n          throw new Error(\"Every Tool needs an explicit replay semantic version\");\n\n        return {\n          name: tool.name,\n          contract: {\n            version,\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            contextRollover: Context.get(tool.annotations, ContextRolloverTool),\n            completion: definition.completion?.tool === tool.name,\n            completionFromTool:\n              definition.completionFromTools?.some(\n                (declaration) => declaration.tool === tool.name,\n              ) ?? false,\n          },\n        };\n      });\n    },\n    catch: () =>\n      DigestError.make({\n        message: \"Operation contracts require serializable codecs and a version for every Tool\",\n      }),\n  });\n\n  return Object.fromEntries(\n    yield* Effect.forEach(declarations, ({ name, contract }) =>\n      digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),\n    ),\n  );\n});\n\n/** Compile current metadata without acquiring executable services. */\nexport const compileBindingContracts = Effect.fn(\"AgentRegistration.compileBindingContracts\")(\n  function* (\n    definition: Agent.AnyDefinition,\n    definitions: DefinitionDigestInput,\n    versions?: ReplayVersions,\n  ): Effect.fn.Return<Pick<ResolvedBinding, \"digests\">, DigestError, Crypto.Crypto> {\n    const digests = yield* digestDefinitions(definitions);\n    const tools = yield* toolReplayContracts(definition, versions, definitions.tools);\n\n    return {\n      digests: DefinitionDigests.make({\n        ...digests,\n        replay: ReplayContract.make({ agent: digests.agent, tools }),\n      }),\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}\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): Effect.Effect<ResolvedBinding, BindingUnavailable> => {\n  const registered = bindings.filter((binding) => binding.agentId === agentId);\n  const binding = registered[0];\n\n  return registered.length === 1 && binding !== undefined\n    ? Effect.succeed(binding)\n    : Effect.fail(\n        BindingUnavailable.make({\n          agentId,\n          message: `Exactly one current Agent Binding must be registered for ${agentId}`,\n        }),\n      );\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  /** Explicit operation versions let unchanged unfinished handlers survive toolbox changes. */\n  readonly continuity?: {\n    readonly versions: ReplayVersions;\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        return {\n          ...binding,\n          ...(yield* compileBindingContracts(\n            binding.definition,\n            definitions,\n            entry.continuity?.versions,\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-Clj8cLsp.mjs";
+import { o as CommandDrainPolicy } from "../RunOptions-Bruk54SE.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-Clj8cLsp.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-Bruk54SE.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-Bm1dRecN.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-m7ywTCe4.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/capabilities/Subagent.mjs

@@ -1,5 +1,5 @@
 import { SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant } from "../core/SubagentContract.mjs";
 import { WorkerCompletion, WorkerReport } from "../core/Worker.mjs";
 import "./SubagentReservations.mjs";
-import { C as delegationCapsFromPolicy, S as delegationAllocationFromPolicy, _ as reporting, a as define, b as SubagentPrestartDenied, c as Worker, d as cancel, f as followUp, g as start, h as observe, i as background, l as WorkerObservation, m as list, n as SubagentResult, o as layer, p as inspect, s as make, t as SubagentDurableAccounting, u as awaitWorker, v as reportingToWorker, x as SubagentProjectionFailure, y as SubagentPolicy } from "../Subagent-Cbfzylz1.mjs";
+import { C as delegationCapsFromPolicy, S as delegationAllocationFromPolicy, _ as reporting, a as define, b as SubagentPrestartDenied, c as Worker, d as cancel, f as followUp, g as start, h as observe, i as background, l as WorkerObservation, m as list, n as SubagentResult, o as layer, p as inspect, s as make, t as SubagentDurableAccounting, u as awaitWorker, v as reportingToWorker, x as SubagentProjectionFailure, y as SubagentPolicy } from "../Subagent-C2s8PFrd.mjs";
 export { SubagentDurableAccounting, SubagentExecutionFailure, SubagentExecutionFailureClassification, SubagentGrant, SubagentPolicy, SubagentPrestartDenied, SubagentProjectionFailure, SubagentResult, 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-CMByd1eD.mjs";
+import { _ as Digest } from "../Records-BIiRLqlz.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-BEz5IFUu.mjs";
+import { T as PersistedJson, h as Digest, k as RecordId, u as CanonicalSequence } from "../Records-DR1xtbXY.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 { 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-CMByd1eD.mjs";
+import { Ar as RetryCommand, Cr as ObligationEntry, Dr as RECOVERY_DECISION_MEANINGS, Er as ObligationThresholds, Fr as recoveryDecisionMeaning, Ir as renderRecoveryExplanation, Mr as RetryRefused, Nr as obligationSeverityOf, Or as RecoveryDisposition, Pr as predictRecoveryDisposition, Sr as ObligationBlockedOn, Tr as ObligationSeverity, _r as ExplainedUnknownCall, br as IntegrityCheckStatus, gr as ExplainedSubmission, hr as ExplainedEvidence, jr as RetryRefusalReason, kr as RecoveryExplanation, vr as IntegrityCheck, wr as ObligationReport, xr as IntegrityReport, yr as IntegrityCheckName } from "../Records-BIiRLqlz.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,10 +1,10 @@
 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 { et as ToolCallUnknown, u as CanonicalSequence, z as SettlementOutcome } from "../Records-BEz5IFUu.mjs";
+import { X as ToolCallPrepared, et as ToolCallUnknown, u as CanonicalSequence, z as SettlementOutcome } from "../Records-DR1xtbXY.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";
+import { DateTime, Effect, Schema } from "effect";
 //#region src/durable/Admin.ts
 var Admin_exports = /* @__PURE__ */ __exportAll({
 	ExplainedEvidence: () => ExplainedEvidence,
@@ -63,13 +63,13 @@ var ExplainedSubmission = class extends Schema.Class("@effect-agent/thread/Expla
 	readyAgeSeconds: Schema.optionalKey(AgeSeconds),
 	parentLinkage: Schema.optionalKey(ParentLinkage)
 }) {};
-/** One durable Unknown Outcome and whether a covering resolution intent exists (DUR-017). */
+/** One durable Unknown Outcome and whether its result is canonical (DUR-017). */
 var ExplainedUnknownCall = class extends Schema.Class("@effect-agent/thread/ExplainedUnknownCall")({
 	toolCallId: ToolCallId,
 	toolName: ToolCallUnknown.fields.toolName,
 	reason: ToolCallUnknown.fields.reason,
 	recordedAt: Schema.DateTimeUtcFromString,
-	/** A durable `resolveUnknown` intent covers this call. */
+	/** A real canonical ToolCallSettled closes this call; an intent alone is not an outcome. */
 	resolved: Schema.Boolean
 }) {};
 /**
@@ -84,6 +84,8 @@ var ExplainedEvidence = class extends Schema.Class("@effect-agent/thread/Explain
 	recordedSettlementOutcome: Schema.optionalKey(SettlementOutcome),
 	/** Prepared ordinary Tool Calls without a canonical outcome (DUR-009). */
 	openToolCalls: Schema.Array(OpenToolCallEvidence),
+	/** Original prepared operation identities, arguments and recovery contracts; settled calls are excluded. */
+	pendingOperations: Schema.Array(ToolCallPrepared).pipe(Schema.withConstructorDefault(Effect.succeed([]))),
 	/** Delegation Tool Calls with an open parent-side obligation. */
 	openDelegationCalls: Schema.Array(OpenDelegationCallEvidence),
 	/** Canonically requested approvals without a canonical decision. */
@@ -140,11 +142,11 @@ const RECOVERY_DECISION_MEANINGS = {
 	FinalizeLedgerFromHistory: "The canonical settlement record exists: recovery rebuilds/finalizes the ledger from history and never rewrites history from the cached ledger status (DUR-011, DUR-015).",
 	SettleAborted: "A durable abort intent exists with no reserved outcome and no open attached-child obligation: recovery settles aborted, first recording ToolCallUnknown audits for open ordinary calls — abort never asserts external rollback (durability §13).",
 	MarkUnknown: "Prepared ordinary Tool Calls have no canonical outcome: recovery reconciles each open call and marks the remainder Unknown — never an automatic replay (DUR-009/DUR-017).",
-	ResumePendingToolBatch: "A committed tool-declaring response has zero prepared and zero settled records: a claiming worker resumes the declared batch without model re-invocation and without Unknown (durability §15).",
+	ResumePendingToolBatch: "A committed tool-declaring response has zero prepared and zero settled records: a claiming worker checks unfinished operation contracts and resumes the declared batch without model re-invocation (durability §15).",
 	AwaitApprovalDecision: "Canonically requested approvals lack decisions: the lane waits durably for the authorized resolveApproval path (recovery repairs a lost suspend transition from history).",
 	ResumeSuspended: "Every pending approval has a durable decision: a claiming worker resumes the declared batch, appending the canonical ToolApprovalDecided records first.",
-	AwaitUnknownResolution: "Unknown Outcomes lack covering resolutions: the lane stays blocked awaiting the authorized DUR-017 resolveUnknown path; the obligation stays visible, nothing replays.",
-	ApplyUnknownResolutions: "Durable resolution intents cover every open call: recovery applies them canonically and reopens the lane.",
+	AwaitUnknownResolution: "Unknown Outcomes lack covering resolutions: this Submission stays parked awaiting the authorized DUR-017 resolveUnknown path; later eligible input may run, and the original obligation stays visible.",
+	ApplyUnknownResolutions: "Durable resolution intents cover every open call: recovery wakes the original Submission when required retry contracts are supported; its next claim applies canonical outcomes.",
 	RevertJoining: "The Submission is joining without a canonical input record: recovery reverts it to ready — the input was never consumed and will be delivered exactly once later (DUR-016).",
 	RepairJoinMarker: "The canonical joined input exists but the joined marker was lost: recovery repairs the marker only; the input reattaches, never duplicates (DUR-015/DUR-016).",
 	SettleJoinedWithHost: "The host Run settled canonically: recovery settles this joined Submission with the host outcome — each joined Submission is owed its own settlement (DUR-002).",
@@ -297,8 +299,8 @@ const obligationSeverityOf = (ageSeconds, thresholds) => ageSeconds >= threshold
 /**
 * The mandatory-audit retry command (SEC-011): `author`/`reason` carry the same bounds as the
 * canonical abort command so every mutating administrative operation stays attributable. The
-* executed repair itself appends the deterministic `RepairAnnotated` audit record (DUR-013) —
-* retry adds no new canonical record type.
+* operator and decision are logged. A repair with a claim also appends a best-effort
+* `RepairAnnotated` attempt using that claim's epoch; state-only repairs do not append audits.
 */
 var RetryCommand = class extends Schema.Class("@effect-agent/thread/RetryCommand")({
 	submissionId: SubmissionId,
@@ -312,7 +314,7 @@ const RetryRefusalReason = Schema.Literals([
 	"await-approval-decision"
 ]);
 /**
-* Typed refusal of `retry` (plan §3): lanes blocked on `AwaitUnknownResolution` or
+* Typed refusal of `retry` (plan §3): Submissions waiting on `AwaitUnknownResolution` or
 * `AwaitApprovalDecision` have their own authorized operations, and settled work is never
 * re-driven. The refusal names the classifier decision so the operator sees WHY.
 */