holycodex 0.15.1-dev.35.1 → 0.15.2-dev.37.1

package/dist/{src-BmUZJGuC.js → src-le8tAupU.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { newQuickJSWASMModule } from "quickjs-emscripten";
 import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -8888,15 +8888,6 @@ const exitFailCause$1 = (cause) => {
 	return effect;
 };
 /** @internal */
-const exitFlatMap = /*#__PURE__*/ dual(2, (self, f) => {
-	switch (self._tag) {
-		case OP_FAILURE: return exitFailCause$1(self.effect_instruction_i0);
-		case OP_SUCCESS: return f(self.effect_instruction_i0);
-	}
-});
-/** @internal */
-const exitFlatten = (self) => pipe(self, exitFlatMap(identity));
-/** @internal */
 const exitInterrupt$1 = (fiberId) => exitFailCause$1(interrupt(fiberId));
 /** @internal */
 const exitMap = /*#__PURE__*/ dual(2, (self, f) => {
@@ -14236,25 +14227,6 @@ const makeSemaphore$1 = (permits) => sync$1(() => unsafeMakeSemaphore(permits));
 /** @internal */
 const raceFirst$1 = /*#__PURE__*/ dual(2, (self, that) => pipe(exit(self), race(exit(that)), (effect) => flatten$1(effect)));
 /** @internal */
-const timeoutFail$1 = /*#__PURE__*/ dual(2, (self, { duration, onTimeout }) => flatten$1(timeoutTo(self, {
-	onTimeout: () => failSync$1(onTimeout),
-	onSuccess: succeed$4,
-	duration
-})));
-/** @internal */
-const timeoutTo = /*#__PURE__*/ dual(2, (self, { duration, onSuccess, onTimeout }) => fiberIdWith((parentFiberId) => uninterruptibleMask$1((restore) => raceFibersWith(exit(restore(self)), interruptible$1(sleep(duration)), {
-	onSelfWin: (winner, loser) => flatMap$3(winner.await, (exit) => {
-		const selfExit = exitFlatten(exit);
-		if (selfExit._tag === "Success") return flatMap$3(winner.inheritAll, () => as(interruptAsFiber(loser, parentFiberId), onSuccess(selfExit.value)));
-		else return flatMap$3(interruptAsFiber(loser, parentFiberId), () => exitFailCause$1(selfExit.cause));
-	}),
-	onOtherWin: (winner, loser) => flatMap$3(winner.await, (exit) => {
-		if (exit._tag === "Success") return flatMap$3(winner.inheritAll, () => as(interruptAsFiber(loser, parentFiberId), onTimeout()));
-		else return flatMap$3(interruptAsFiber(loser, parentFiberId), () => exitFailCause$1(exit.cause));
-	}),
-	otherScope: globalScope
-}))));
-/** @internal */
 const SynchronizedTypeId = /*#__PURE__*/ Symbol.for("effect/Ref/SynchronizedRef");
 /** @internal */
 const synchronizedVariance = { 
@@ -16241,72 +16213,6 @@ const ensuring = ensuring$1;
 */
 const scoped = scopedEffect;
 /**
-* Specifies a custom error to be produced when a timeout occurs.
-*
-* **Details**
-*
-* This function allows you to handle timeouts in a customized way by defining a
-* specific error to be raised when an effect exceeds the given duration. Unlike
-* default timeout behaviors that use generic exceptions, this function gives
-* you the flexibility to specify a meaningful error type that aligns with your
-* application's needs.
-*
-* When you apply this function, you provide:
-* - A `duration`: The time limit for the effect.
-* - An `onTimeout` function: A lazy evaluation function that generates the
-*   custom error if the timeout occurs.
-*
-* If the effect completes within the time limit, its result is returned
-* normally. Otherwise, the `onTimeout` function is triggered, and its output is
-* used as the error for the effect.
-*
-* **Example**
-*
-* ```ts
-* import { Effect } from "effect"
-*
-* const task = Effect.gen(function* () {
-*   console.log("Start processing...")
-*   yield* Effect.sleep("2 seconds") // Simulates a delay in processing
-*   console.log("Processing complete.")
-*   return "Result"
-* })
-*
-* class MyTimeoutError {
-*   readonly _tag = "MyTimeoutError"
-* }
-*
-* const program = task.pipe(
-*   Effect.timeoutFail({
-*     duration: "1 second",
-*     onTimeout: () => new MyTimeoutError() // Custom timeout error
-*   })
-* )
-*
-* Effect.runPromiseExit(program).then(console.log)
-* // Output:
-* // Start processing...
-* // {
-* //   _id: 'Exit',
-* //   _tag: 'Failure',
-* //   cause: {
-* //     _id: 'Cause',
-* //     _tag: 'Fail',
-* //     failure: MyTimeoutError { _tag: 'MyTimeoutError' }
-* //   }
-* // }
-* ```
-*
-* @see {@link timeout} for a version that raises a `TimeoutException`.
-* @see {@link timeoutFailCause} for a version that raises a custom defect.
-* @see {@link timeoutTo} for a version that allows specifying both success and
-* timeout handlers.
-*
-* @since 2.0.0
-* @category Delays & Timeouts
-*/
-const timeoutFail = timeoutFail$1;
-/**
 * Provides necessary dependencies to an effect, removing its environmental
 * requirements.
 *
@@ -21707,14 +21613,6 @@ const DEFAULT_OPTIONAL_CAPABILITY_SELECTIONS = Object.freeze({
 	web: false,
 	security: false
 });
-function migrateOptionalCapabilitySelections(input) {
-	return {
-		computer_use: input?.[CAPABILITY_REGISTRY.computer_use.migrationKey] === true,
-		work: input?.[CAPABILITY_REGISTRY.work.migrationKey] === true,
-		web: input?.[CAPABILITY_REGISTRY.web.migrationKey] === true,
-		security: input?.[CAPABILITY_REGISTRY.security.migrationKey] === true
-	};
-}
 function resolveOptionalCapabilitySelections(requested, previous) {
 	const fallback = previous ?? DEFAULT_OPTIONAL_CAPABILITY_SELECTIONS;
 	return {
@@ -21740,18 +21638,8 @@ function pluginIdsForOptionalCapabilities(selections, additionalPluginIds = [])
 	}
 	return ids;
 }
-function capabilityHealth(selected, providerStatus) {
-	if (!selected) return "healthy";
-	switch (providerStatus) {
-		case "installed": return "healthy";
-		case "disabled": return "disabled";
-		case "uncertain": return "uncertain";
-		case "missing":
-		case void 0: return "missing";
-	}
-}
 Struct({
-	identifier: Literal("workflow.create", "workflow.run", "workflow.resume", "local.repository.edit", "local.repository.check", "local.repository.lint", "local.repository.format", "implementation.plan", "origin.mutation", "ci.trigger"),
+	identifier: Literal("workflow.create", "workflow.run", "workflow.resume", "local.repository.edit", "local.repository.check", "local.repository.lint", "local.repository.format", "local.repository.commit", "external.read", "specialist.dispatch", "vcs.server.mutation", "vcs.server.ci-trigger", "unknown.effect"),
 	label: String$,
 	requiresRootApproval: Boolean$
 });
@@ -21770,9 +21658,12 @@ Struct({
 	localRepositoryCheck: approvalPolicyEntrySchema("local.repository.check"),
 	localRepositoryLint: approvalPolicyEntrySchema("local.repository.lint"),
 	localRepositoryFormat: approvalPolicyEntrySchema("local.repository.format"),
-	implementationPlan: approvalPolicyEntrySchema("implementation.plan"),
-	originMutation: approvalPolicyEntrySchema("origin.mutation"),
-	ciTrigger: approvalPolicyEntrySchema("ci.trigger")
+	localRepositoryCommit: approvalPolicyEntrySchema("local.repository.commit"),
+	externalRead: approvalPolicyEntrySchema("external.read"),
+	specialistDispatch: approvalPolicyEntrySchema("specialist.dispatch"),
+	versionControlServerMutation: approvalPolicyEntrySchema("vcs.server.mutation"),
+	versionControlServerCiTrigger: approvalPolicyEntrySchema("vcs.server.ci-trigger"),
+	unknownEffect: approvalPolicyEntrySchema("unknown.effect")
 });
 const APPROVAL_POLICY = {
 	workflowCreate: {
@@ -21810,19 +21701,34 @@ const APPROVAL_POLICY = {
 		label: "local repository format",
 		requiresRootApproval: false
 	},
-	implementationPlan: {
-		identifier: "implementation.plan",
-		label: "implementation plans",
+	localRepositoryCommit: {
+		identifier: "local.repository.commit",
+		label: "local repository commit",
+		requiresRootApproval: false
+	},
+	externalRead: {
+		identifier: "external.read",
+		label: "external read",
+		requiresRootApproval: false
+	},
+	specialistDispatch: {
+		identifier: "specialist.dispatch",
+		label: "specialist dispatch",
+		requiresRootApproval: false
+	},
+	versionControlServerMutation: {
+		identifier: "vcs.server.mutation",
+		label: "version-control-server mutation",
 		requiresRootApproval: true
 	},
-	originMutation: {
-		identifier: "origin.mutation",
-		label: "origin mutation",
+	versionControlServerCiTrigger: {
+		identifier: "vcs.server.ci-trigger",
+		label: "version-control-server CI triggering",
 		requiresRootApproval: true
 	},
-	ciTrigger: {
-		identifier: "ci.trigger",
-		label: "CI triggering",
+	unknownEffect: {
+		identifier: "unknown.effect",
+		label: "unclassified effect",
 		requiresRootApproval: true
 	}
 };
@@ -21925,7 +21831,13 @@ const PONYTAIL_ROLE_SKILL = Object.freeze({
 const ROLE_DEFINITIONS = [
 	{
 		role: "Explorer",
-		tasks: ["lookup", "trace"],
+		tasks: [{
+			name: "lookup",
+			instruction: "Locate the exact requested repository fact."
+		}, {
+			name: "trace",
+			instruction: "Trace the complete in-scope execution or reference path."
+		}],
 		capability: "repository-read",
 		authority: "Read only the assigned repository scope; Root owns decisions.",
 		evidence: "Return exact paths, symbols, callers, tests, and constraints.",
@@ -21940,7 +21852,13 @@ const ROLE_DEFINITIONS = [
 	},
 	{
 		role: "Librarian",
-		tasks: ["lookup", "research"],
+		tasks: [{
+			name: "lookup",
+			instruction: "Locate the exact requested authoritative external fact."
+		}, {
+			name: "research",
+			instruction: "Synthesize the assigned current sources with citations."
+		}],
 		capability: "current-research",
 		authority: "Research only the assigned current sources; Root owns decisions.",
 		evidence: "Return sourced facts, dates, and explicit uncertainty.",
@@ -21956,10 +21874,22 @@ const ROLE_DEFINITIONS = [
 	{
 		role: "Worker",
 		tasks: [
-			"mechanical",
-			"implementation",
-			"integration",
-			"operations"
+			{
+				name: "mechanical",
+				instruction: "Apply only deterministic, already-decided edits."
+			},
+			{
+				name: "implementation",
+				instruction: "Implement and verify the bounded behavior seam."
+			},
+			{
+				name: "integration",
+				instruction: "Integrate the decided seams and verify them together."
+			},
+			{
+				name: "operations",
+				instruction: "Perform only the explicitly approved stateful operation."
+			}
 		],
 		capability: "bounded-write",
 		authority: "Change only the assigned seam; Root owns material choices.",
@@ -21976,9 +21906,18 @@ const ROLE_DEFINITIONS = [
 	{
 		role: "Reviewer",
 		tasks: [
-			"plan",
-			"code",
-			"artifact"
+			{
+				name: "plan",
+				instruction: "Review the complete plan to a fixed point."
+			},
+			{
+				name: "code",
+				instruction: "Review and repair the implemented code to a fixed point."
+			},
+			{
+				name: "artifact",
+				instruction: "Review and repair the produced artifact to a fixed point."
+			}
 		],
 		capability: "bounded-review",
 		authority: "Inspect and repair only reviewer-owned defects; Root owns material choices.",
@@ -21996,8 +21935,10 @@ const ROLE_DEFINITIONS = [
 freezeDeep(ROLE_DEFINITIONS);
 const roleDefinitionsByName = new Map(ROLE_DEFINITIONS.map((definition) => [definition.role, definition]));
 const roleNameSet = new Set(ROLE_DEFINITIONS.map((definition) => definition.role));
-const routeKeys$1 = ROLE_DEFINITIONS.flatMap((definition) => definition.tasks.map((task) => `${definition.role}:${task}`));
+const routeKeys$1 = ROLE_DEFINITIONS.flatMap((definition) => definition.tasks.map((task) => `${definition.role}:${task.name}`));
 const routeKeySet = new Set(routeKeys$1);
+const nativeAgentTypes = routeKeys$1.map((key) => key.replace(":", "."));
+const nativeAgentTypeSet = new Set(nativeAgentTypes);
 function isRole(value) {
 	return typeof value === "string" && roleNameSet.has(value);
 }
@@ -22006,10 +21947,10 @@ function isRoleTask(value) {
 	const role = value.role;
 	const task = value.task;
 	if (!isRole(role) || typeof task !== "string") return false;
-	return roleDefinitionsByName.get(role)?.tasks.some((candidate) => candidate === task) === true;
+	return roleDefinitionsByName.get(role)?.tasks.some((candidate) => candidate.name === task) === true;
 }
 function isTaskForRole(role, value) {
-	return typeof value === "string" && roleDefinitionsByName.get(role)?.tasks.some((candidate) => candidate === value) === true;
+	return typeof value === "string" && roleDefinitionsByName.get(role)?.tasks.some((candidate) => candidate.name === value) === true;
 }
 function isRouteKey(value) {
 	return typeof value === "string" && routeKeySet.has(value);
@@ -22022,6 +21963,18 @@ declare((value) => isTaskForRole("Reviewer", value));
 const RoleTaskSchema = declare(isRoleTask);
 const ROUTE_KEYS = Object.freeze(routeKeys$1.filter((key) => isRouteKey(key)));
 const RouteKeySchema = declare(isRouteKey);
+Object.freeze(nativeAgentTypes.filter((agentType) => nativeAgentTypeSet.has(agentType)));
+const NativeAgentTypeSchema = declare((value) => typeof value === "string" && nativeAgentTypeSet.has(value));
+function nativeAgentTypeFor(route) {
+	const value = `${route.role}.${route.task}`;
+	if (!nativeAgentTypeSet.has(value)) throw new Error("Unknown native specialist agent type.");
+	return value;
+}
+function taskInstructionFor(route) {
+	const task = roleDefinitionsByName.get(route.role)?.tasks.find((candidate) => candidate.name === route.task);
+	if (task === void 0) throw new Error("Unknown specialist task policy.");
+	return task.instruction;
+}
 function lookupRoleDefinition(role) {
 	const definition = roleDefinitionsByName.get(role);
 	if (definition === void 0) throw new Error("Unknown specialist role.");
@@ -22152,7 +22105,6 @@ function toCryptoBuffer(bytes) {
 	copy.set(bytes);
 	return copy;
 }
-const sha256DomainDigest = domainSeparatedSha256;
 //#endregion
 //#region packages/core/src/envelopes.ts
 const SpecialistStatusSchema = Literal("blocked", "completed", "failed", "partial");
@@ -22487,13 +22439,13 @@ function routesForPlan(plan) {
 	const override = effortOverridesByPlan.get(plan);
 	if (override === void 0) throw new CoreError("catalog_invalid", "A specialist plan has no route effort policy.", { plan });
 	return ROLE_DEFINITIONS.flatMap((definition) => definition.tasks.map((task) => {
-		const key = `${definition.role}:${task}`;
+		const key = `${definition.role}:${task.name}`;
 		const effort = override.efforts[key];
 		if (effort === void 0) throw new CoreError("catalog_invalid", "A route effort policy is incomplete.", {
 			plan,
 			route: key
 		});
-		return route(definition.role, task, effort);
+		return route(definition.role, task.name, effort);
 	}));
 }
 function specialistPlan(input) {
@@ -22527,7 +22479,7 @@ const planDefinitions = [
 		budget: {
 			costTarget: 1,
 			costMax: 1.5,
-			maxCalls: 10,
+			maxCalls: 1e4,
 			maxConcurrency: 3
 		}
 	}),
@@ -22540,7 +22492,7 @@ const planDefinitions = [
 		budget: {
 			costTarget: 1.6,
 			costMax: 2.5,
-			maxCalls: 16,
+			maxCalls: 1e4,
 			maxConcurrency: 3
 		}
 	}),
@@ -22553,7 +22505,7 @@ const planDefinitions = [
 		budget: {
 			costTarget: 3,
 			costMax: 4.5,
-			maxCalls: 24,
+			maxCalls: 1e4,
 			maxConcurrency: 4
 		}
 	}),
@@ -22566,7 +22518,7 @@ const planDefinitions = [
 		budget: {
 			costTarget: 5,
 			costMax: 7.5,
-			maxCalls: 40,
+			maxCalls: 1e4,
 			maxConcurrency: 6
 		}
 	}),
@@ -22579,7 +22531,7 @@ const planDefinitions = [
 		budget: {
 			costTarget: 12,
 			costMax: 20,
-			maxCalls: 64,
+			maxCalls: 1e4,
 			maxConcurrency: 8
 		}
 	})
@@ -23642,8 +23594,7 @@ const PredicateSchema = Struct({
 });
 const RepeatUntilSchema = Struct({
 	path: PathSchema,
-	equals: JsonValueSchema,
-	maxIterations: Number$.pipe(int(), greaterThanOrEqualTo(1), lessThanOrEqualTo(16))
+	equals: JsonValueSchema
 });
 const AssignmentMetadataSchema = Struct({
 	id: optional(IdentifierSchema),
@@ -23651,7 +23602,6 @@ const AssignmentMetadataSchema = Struct({
 	dependencies: optional(Array$(IdentifierSchema)),
 	retries: optional(NonNegativeIntegerSchema),
 	attempt: optional(NonNegativeIntegerSchema),
-	timeoutMs: optional(PositiveIntegerSchema$1),
 	writes: optional(Array$(WriteScopeSchema)),
 	when: optional(ConditionSchema),
 	stopWhen: optional(PredicateSchema),
@@ -24021,14 +23971,11 @@ function normalizeMetadata(input, policy) {
 	}
 	const retries = metadata.retries ?? 0;
 	if (!Number.isInteger(retries) || retries < 0 || retries > policy.capacity.maxRetries) throw workflowFailure("validation", "The workflow retry policy is invalid.");
-	const timeoutMs = metadata.timeoutMs;
-	if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 6e4)) throw workflowFailure("validation", "The workflow timeout policy is invalid.");
 	return Object.freeze({
 		capabilities: Object.freeze(capabilities),
 		dependencies: Object.freeze(dependencies),
 		retries,
 		writes: Object.freeze(uniqueStrings$1((metadata.writes ?? []).map(normalizeWriteScope))),
-		...timeoutMs === void 0 ? {} : { timeoutMs },
 		...metadata.when === void 0 ? {} : { when: freezeCondition(metadata.when) },
 		...metadata.stopWhen === void 0 ? {} : { stopWhen: freezePredicate(metadata.stopWhen) },
 		...metadata.repeatUntil === void 0 ? {} : { repeatUntil: freezeRepeatUntil(metadata.repeatUntil) }
@@ -24202,10 +24149,7 @@ function freezePredicate(input) {
 	});
 }
 function freezeRepeatUntil(input) {
-	return Object.freeze({
-		...freezePredicate(input),
-		maxIterations: input.maxIterations
-	});
+	return freezePredicate(input);
 }
 function isAncestor(nodeById, nodeId, candidate) {
 	const visited = /* @__PURE__ */ new Set();
@@ -29483,6 +29427,7 @@ interface WorkflowAssignment<I extends WorkflowJsonValue = WorkflowJsonValue, O
 interface WorkflowStepDefinition<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> { readonly id: string; readonly assignment: WorkflowAssignment<I, O>; }
 interface WorkflowValue<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> { readonly input: I; readonly output: O; }
 interface WorkflowWait<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> { readonly input: I; readonly result: O; }
+interface WorkflowDefinition<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> { readonly name: string; readonly workflow: WorkflowWait<I, O>; }
 type WorkflowQueueStageOutput<Current extends WorkflowJsonValue, Stage> = Stage extends WorkflowValue<Current, infer Output> ? Output : Stage extends WorkflowWait<Current, infer Output> ? Output : Stage extends (input: Current) => WorkflowValue<Current, infer Output> ? Output : Stage extends (input: Current) => WorkflowWait<Current, infer Output> ? Output : never;
 type WorkflowQueueStageChain<Current extends WorkflowJsonValue, Stages extends readonly unknown[]> = Stages extends readonly [infer Stage, ...infer Rest] ? [WorkflowQueueStageOutput<Current, Stage>] extends [never] ? never : readonly [Stage, ...WorkflowQueueStageChain<WorkflowQueueStageOutput<Current, Stage>, Rest>] : readonly [];
 type WorkflowQueueOutput<Current extends WorkflowJsonValue, Stages extends readonly unknown[]> = Stages extends readonly [infer Stage, ...infer Rest] ? WorkflowQueueOutput<WorkflowQueueStageOutput<Current, Stage>, Rest> : Current;
@@ -29503,6 +29448,7 @@ declare module "@holycodex/workflow" {
   export type StepDefinition<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowStepDefinition<I, O>;
   export type Workflow<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowValue<I, O>;
   export type Wait<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowWait<I, O>;
+  export type Definition<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowDefinition<I, O>;
   export const workflow: WorkflowDsl;
   export function createCodec<T extends WorkflowJsonValue = WorkflowJsonValue>(name: string, decoder: ((value: unknown) => T) | WorkflowPortableSchema<T>): ValueCodec<T>;
 }
@@ -29512,6 +29458,7 @@ declare module "@holycodex/workflow-runtime" {
   export type StepDefinition<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowStepDefinition<I, O>;
   export type Workflow<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowValue<I, O>;
   export type Wait<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowWait<I, O>;
+  export type Definition<I extends WorkflowJsonValue = WorkflowJsonValue, O extends WorkflowJsonValue = WorkflowJsonValue> = WorkflowDefinition<I, O>;
   export const workflow: WorkflowDsl;
   export function createCodec<T extends WorkflowJsonValue = WorkflowJsonValue>(name: string, decoder: ((value: unknown) => T) | WorkflowPortableSchema<T>): ValueCodec<T>;
 }
@@ -29632,7 +29579,7 @@ function rewriteNativeSource(source) {
 		if (token.text === "{") braceDepth += 1;
 		if (token.text === "}") braceDepth = Math.max(0, braceDepth - 1);
 	}
-	if (exports !== 1) throw sourceError("The native workflow must export exactly one workflow.wait(...) value.");
+	if (exports !== 1) throw sourceError("The native workflow must export exactly one named workflow definition.");
 	return applyReplacements(source, replacements);
 }
 function nativeImportReplacement(statement) {
@@ -29805,6 +29752,7 @@ async function evaluateNativeWorkflowSource(input) {
 		if (new TextEncoder().encode(canonicalJson(ir)).byteLength > limits.maxSerializedIRBytes) throw new WorkflowRuntimeError("resource_limit", "The native workflow IR is too large.");
 		const codecMap = session.codecProxies();
 		return Object.freeze({
+			name: graph.name,
 			ir,
 			codecs: codecMap,
 			dispose: () => session.dispose()
@@ -29983,17 +29931,23 @@ var NativeSourceSession = class {
 		const dumped = this.context.dump(result.value);
 		result.value.dispose();
 		let finalHandle;
+		let name = "workflow";
 		try {
-			finalHandle = this.readHandle(dumped);
+			if (isRecord(dumped) && "name" in dumped && "workflow" in dumped) {
+				if (typeof dumped["name"] !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(dumped["name"])) throw new Error("invalid workflow definition");
+				name = dumped["name"];
+				finalHandle = this.readHandle(dumped["workflow"]);
+			} else finalHandle = this.readHandle(dumped);
 		} catch {
-			throw new WorkflowRuntimeError("source_rejected", "The native workflow default export must be workflow.wait(...).");
+			throw new WorkflowRuntimeError("source_rejected", "The native workflow default export is invalid.");
 		}
-		if (finalHandle.kind !== "wait") throw new WorkflowRuntimeError("source_rejected", "The native workflow default export must be workflow.wait(...).");
+		if (finalHandle.kind !== "wait") throw new WorkflowRuntimeError("source_rejected", "The native workflow definition must contain workflow.wait(...).");
 		if (this.handles.size > this.limits.maxPlanNodes * 4) throw new WorkflowRuntimeError("resource_limit", "The native workflow graph metadata is too large.");
 		const targets = finalHandle.targets;
 		const nodes = mergeTargets(targets).nodes;
 		if (nodes.length > this.limits.maxPlanNodes) throw new WorkflowRuntimeError("resource_limit", "The native workflow graph exceeds its node limit.");
 		return {
+			name,
 			nodes,
 			roots: uniqueStrings(targets.flatMap((target) => target.graph.roots)),
 			output: targets.length === 1 ? targets[0]?.output ?? {
@@ -30370,7 +30324,6 @@ function readMetadata(value) {
 	const dependencies = readOptionalStringArray(value["dependencies"], "metadata.dependencies");
 	const retries = readOptionalInteger(value["retries"], "metadata.retries");
 	const attempt = readOptionalInteger(value["attempt"], "metadata.attempt");
-	const timeoutMs = readOptionalInteger(value["timeoutMs"], "metadata.timeoutMs");
 	const writes = readOptionalStringArray(value["writes"], "metadata.writes");
 	const when = readCondition(value["when"]);
 	const stopWhen = readPredicate(value["stopWhen"]);
@@ -30381,7 +30334,6 @@ function readMetadata(value) {
 		...dependencies === void 0 ? {} : { dependencies },
 		...retries === void 0 ? {} : { retries },
 		...attempt === void 0 ? {} : { attempt },
-		...timeoutMs === void 0 ? {} : { timeoutMs },
 		...writes === void 0 ? {} : { writes },
 		...when === void 0 ? {} : { when },
 		...stopWhen === void 0 ? {} : { stopWhen },
@@ -30393,7 +30345,6 @@ function readMetadata(value) {
 		"dependencies",
 		"retries",
 		"attempt",
-		"timeoutMs",
 		"writes",
 		"when",
 		"stopWhen",
@@ -30436,11 +30387,10 @@ function readPredicate(value) {
 }
 function readRepeatUntil(value) {
 	if (value === void 0) return void 0;
-	if (!isRecord(value) || !isStringArray(value["path"]) || !isJsonValue$1(value["equals"]) || typeof value["maxIterations"] !== "number" || !Number.isInteger(value["maxIterations"])) throw new Error("The workflow repeat policy is invalid.");
+	if (!isRecord(value) || !isStringArray(value["path"]) || !isJsonValue$1(value["equals"])) throw new Error("The workflow repeat policy is invalid.");
 	return {
 		path: value["path"],
-		equals: value["equals"],
-		maxIterations: value["maxIterations"]
+		equals: value["equals"]
 	};
 }
 function isStringArray(value) {
@@ -30644,6 +30594,7 @@ function makeCapacityService(capacity) {
 		const session = yield* makeSemaphore(capacity.sessionConcurrency);
 		const codex = yield* makeSemaphore(capacity.codexConcurrency);
 		const transaction = yield* makeSemaphore(1);
+		const runGates = /* @__PURE__ */ new Map();
 		const state = {
 			runs: /* @__PURE__ */ new Map(),
 			committedByRun: /* @__PURE__ */ new Map(),
@@ -30653,80 +30604,108 @@ function makeCapacityService(capacity) {
 			overflow: false
 		};
 		const globalConcurrency = Math.min(capacity.planConcurrency, capacity.sessionConcurrency, capacity.codexConcurrency);
+		const dispatch = yield* makeSemaphore(globalConcurrency);
 		const globalCostMax = capacity.costMax ?? Number.MAX_SAFE_INTEGER;
 		const globalCallsMax = capacity.maxCalls ?? Number.MAX_SAFE_INTEGER;
-		const acquire = (request) => transaction.withPermits(1)(gen(function* () {
-			const invalid = validateDispatchRequest(request);
-			if (invalid !== void 0) return yield* fail$1(invalid);
-			if (state.overflow) return yield* fail$1(workflowFailure("settlement_overflow", "The workflow cost ledger is closed after an overage.", { retryable: false }));
-			const existing = state.runs.get(request.runId);
-			const run = existing ?? createRunState(request);
-			if (run.maxCalls !== request.maxCalls || run.maxCost !== request.maxCost) {
-				run.maxCalls = Math.min(run.maxCalls, request.maxCalls);
-				run.maxCost = Math.min(run.maxCost, request.maxCost);
-			}
-			if (run.calls >= run.maxCalls) return yield* fail$1(workflowFailure("admission_exceeded", "The workflow call capacity was exhausted."));
-			if (state.globalCalls >= globalCallsMax) return yield* fail$1(workflowFailure("admission_exceeded", "The shared workflow call capacity was exhausted."));
-			if (run.inFlight >= request.maxConcurrency || state.inFlight >= globalConcurrency) return yield* fail$1(workflowFailure("admission_exceeded", "The workflow concurrency capacity was exhausted."));
-			const plannedCoverage = Math.min(run.plannedCost, request.estimatedCost);
-			const incrementalReservation = request.estimatedCost - plannedCoverage;
-			const nextRunCost = safeSum([
-				run.committedCost,
-				run.plannedCost,
-				run.outstandingCost,
-				incrementalReservation
-			]);
-			if (nextRunCost === void 0 || nextRunCost > run.maxCost) return yield* fail$1(workflowFailure("admission_exceeded", "The workflow cost capacity was exhausted."));
-			const nextGlobalCost = safeAdd(state.globalCost, incrementalReservation);
-			if (nextGlobalCost === void 0 || nextGlobalCost > globalCostMax) return yield* fail$1(workflowFailure("admission_exceeded", "The shared workflow cost capacity was exhausted."));
-			if (existing === void 0) state.runs.set(request.runId, run);
-			run.calls += 1;
-			run.inFlight += 1;
-			run.plannedCost -= plannedCoverage;
-			run.outstandingCost += request.estimatedCost;
-			state.inFlight += 1;
-			state.globalCalls += 1;
-			state.globalCost = nextGlobalCost;
-			let released = false;
-			let settled = false;
-			return {
-				estimatedCost: request.estimatedCost,
-				settle: (settlement) => transaction.withPermits(1)(gen(function* () {
-					const invalidSettlement = validateSettlement(settlement);
-					if (invalidSettlement !== void 0) return yield* fail$1(invalidSettlement);
-					if (settled) return;
-					if (state.runs.get(request.runId) !== run || run.outstandingCost < request.estimatedCost) return yield* fail$1(workflowFailure("ledger_corruption", "The workflow cost lease is no longer tracked."));
-					settled = true;
-					run.outstandingCost -= request.estimatedCost;
-					const nextCommittedCost = safeAdd(run.committedCost, settlement.costUnits);
-					const nextGlobalCost = safeAdd(state.globalCost - request.estimatedCost, settlement.costUnits);
-					run.committedCost = nextCommittedCost ?? Number.MAX_SAFE_INTEGER;
-					state.globalCost = nextGlobalCost ?? Number.MAX_SAFE_INTEGER;
-					state.committedByRun.set(request.runId, {
-						calls: run.calls,
-						cost: run.committedCost
-					});
-					const runTotal = safeSum([
+		const acquire = (request) => {
+			let dispatchHeld = false;
+			let runGate;
+			let runHeld = false;
+			const releasePermits = gen(function* () {
+				if (runHeld && runGate !== void 0) {
+					runHeld = false;
+					yield* runGate.release(1);
+				}
+				if (dispatchHeld) {
+					dispatchHeld = false;
+					yield* dispatch.release(1);
+				}
+			});
+			return gen(function* () {
+				yield* dispatch.take(1);
+				dispatchHeld = true;
+				runGate = yield* transaction.withPermits(1)(gen(function* () {
+					const existing = runGates.get(request.runId);
+					if (existing !== void 0) return existing;
+					const created = yield* makeSemaphore(request.maxConcurrency);
+					runGates.set(request.runId, created);
+					return created;
+				}));
+				yield* runGate.take(1);
+				runHeld = true;
+				return yield* transaction.withPermits(1)(gen(function* () {
+					const invalid = validateDispatchRequest(request);
+					if (invalid !== void 0) return yield* fail$1(invalid);
+					if (state.overflow) return yield* fail$1(workflowFailure("settlement_overflow", "The workflow cost ledger is closed after an overage.", { retryable: false }));
+					const existing = state.runs.get(request.runId);
+					const run = existing ?? createRunState(request);
+					if (run.maxCalls !== request.maxCalls || run.maxCost !== request.maxCost) {
+						run.maxCalls = Math.min(run.maxCalls, request.maxCalls);
+						run.maxCost = Math.min(run.maxCost, request.maxCost);
+					}
+					if (run.calls >= run.maxCalls) return yield* fail$1(workflowFailure("admission_exceeded", "The workflow call capacity was exhausted."));
+					if (state.globalCalls >= globalCallsMax) return yield* fail$1(workflowFailure("admission_exceeded", "The shared workflow call capacity was exhausted."));
+					const plannedCoverage = Math.min(run.plannedCost, request.estimatedCost);
+					const incrementalReservation = request.estimatedCost - plannedCoverage;
+					const nextRunCost = safeSum([
 						run.committedCost,
 						run.plannedCost,
-						run.outstandingCost
+						run.outstandingCost,
+						incrementalReservation
 					]);
-					const runOverflow = nextCommittedCost === void 0 || runTotal === void 0 || runTotal > run.maxCost;
-					const globalOverflow = nextGlobalCost === void 0 || state.globalCost > globalCostMax;
-					if (runOverflow || globalOverflow) {
-						run.overflow = true;
-						state.overflow = true;
-						return yield* fail$1(workflowFailure("settlement_overflow", "Measured workflow cost exceeded the hard budget.", { retryable: false }));
-					}
-				})),
-				release: transaction.withPermits(1)(sync(() => {
-					if (released) return;
-					released = true;
-					run.inFlight = Math.max(0, run.inFlight - 1);
-					state.inFlight = Math.max(0, state.inFlight - 1);
-				}))
-			};
-		}));
+					if (nextRunCost === void 0 || nextRunCost > run.maxCost) return yield* fail$1(workflowFailure("admission_exceeded", "The workflow cost capacity was exhausted."));
+					const nextGlobalCost = safeAdd(state.globalCost, incrementalReservation);
+					if (nextGlobalCost === void 0 || nextGlobalCost > globalCostMax) return yield* fail$1(workflowFailure("admission_exceeded", "The shared workflow cost capacity was exhausted."));
+					if (existing === void 0) state.runs.set(request.runId, run);
+					run.calls += 1;
+					run.inFlight += 1;
+					run.plannedCost -= plannedCoverage;
+					run.outstandingCost += request.estimatedCost;
+					state.inFlight += 1;
+					state.globalCalls += 1;
+					state.globalCost = nextGlobalCost;
+					let released = false;
+					let settled = false;
+					return {
+						estimatedCost: request.estimatedCost,
+						settle: (settlement) => transaction.withPermits(1)(gen(function* () {
+							const invalidSettlement = validateSettlement(settlement);
+							if (invalidSettlement !== void 0) return yield* fail$1(invalidSettlement);
+							if (settled) return;
+							if (state.runs.get(request.runId) !== run || run.outstandingCost < request.estimatedCost) return yield* fail$1(workflowFailure("ledger_corruption", "The workflow cost lease is no longer tracked."));
+							settled = true;
+							run.outstandingCost -= request.estimatedCost;
+							const nextCommittedCost = safeAdd(run.committedCost, settlement.costUnits);
+							const nextGlobalCost = safeAdd(state.globalCost - request.estimatedCost, settlement.costUnits);
+							run.committedCost = nextCommittedCost ?? Number.MAX_SAFE_INTEGER;
+							state.globalCost = nextGlobalCost ?? Number.MAX_SAFE_INTEGER;
+							state.committedByRun.set(request.runId, {
+								calls: run.calls,
+								cost: run.committedCost
+							});
+							const runTotal = safeSum([
+								run.committedCost,
+								run.plannedCost,
+								run.outstandingCost
+							]);
+							const runOverflow = nextCommittedCost === void 0 || runTotal === void 0 || runTotal > run.maxCost;
+							const globalOverflow = nextGlobalCost === void 0 || state.globalCost > globalCostMax;
+							if (runOverflow || globalOverflow) {
+								run.overflow = true;
+								state.overflow = true;
+								return yield* fail$1(workflowFailure("settlement_overflow", "Measured workflow cost exceeded the hard budget.", { retryable: false }));
+							}
+						})),
+						release: transaction.withPermits(1)(sync(() => {
+							if (released) return;
+							released = true;
+							run.inFlight = Math.max(0, run.inFlight - 1);
+							state.inFlight = Math.max(0, state.inFlight - 1);
+						})).pipe(andThen(releasePermits))
+					};
+				}));
+			}).pipe(catchAllCause((cause) => releasePermits.pipe(andThen(failCause(cause)))));
+		};
 		const reserveRun = (request) => transaction.withPermits(1)(gen(function* () {
 			const invalid = validateReservationRequest(request);
 			if (invalid !== void 0) return yield* fail$1(invalid);
@@ -30754,6 +30733,7 @@ function makeCapacityService(capacity) {
 				const current = state.runs.get(request.runId);
 				if (current !== run) return;
 				state.runs.delete(request.runId);
+				runGates.delete(request.runId);
 				state.inFlight = Math.max(0, state.inFlight - current.inFlight);
 				state.globalCost = Math.max(0, state.globalCost - current.plannedCost - current.outstandingCost);
 			})) };
@@ -30811,6 +30791,7 @@ function makeCapacityService(capacity) {
 			const run = state.runs.get(runId);
 			if (run === void 0) return;
 			state.runs.delete(runId);
+			runGates.delete(runId);
 			state.inFlight = Math.max(0, state.inFlight - run.inFlight);
 			state.globalCost = Math.max(0, state.globalCost - run.plannedCost - run.outstandingCost);
 		}));
@@ -30924,8 +30905,7 @@ function runNode(node, results, rootInput, runId, capacity, planGate, options) {
 		const agent = options.services?.agent;
 		const repeatUntil = node.metadata.repeatUntil;
 		let previousFingerprint;
-		const maxIterations = repeatUntil?.maxIterations ?? 1;
-		for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+		for (;;) {
 			const output = yield* runNodeIteration(node, input, results, runId, capacity, planGate, options, agent, () => {
 				attempt += 1;
 				return attempt;
@@ -30941,10 +30921,6 @@ function runNode(node, results, rootInput, runId, capacity, planGate, options) {
 			}));
 			previousFingerprint = fingerprint;
 		}
-		return yield* fail$1(workflowFailure("iteration_limit", "The workflow repeat iteration limit was exhausted.", {
-			nodeId: node.id,
-			retryable: false
-		}));
 	}).pipe(catchAll((failure) => notifyJournal(options.services, {
 		type: "failed",
 		runId,
@@ -31001,11 +30977,7 @@ function runNodeIteration(node, input, results, runId, capacity, planGate, optio
 		}).pipe(andThen(dispatch));
 	});
 	const retried = node.metadata.retries === 0 ? task : retryOrElse(task, recurs(node.metadata.retries).pipe(whileInput((failure) => failure.retryable !== false)), () => fail$1(workflowFailure("retry_exhausted", "The workflow retry schedule was exhausted.", { nodeId: node.id })));
-	const timed = node.metadata.timeoutMs === void 0 ? retried : timeoutFail({
-		duration: `${node.metadata.timeoutMs} millis`,
-		onTimeout: () => workflowFailure("timeout", "The workflow step timed out.", { nodeId: node.id })
-	})(retried);
-	return options.capacity.codex.withPermits(1)(options.capacity.session.withPermits(1)(options.capacity.plan.withPermits(1)(planGate.withPermits(1)(timed)))).pipe(flatMap$1((output) => notifyJournal(services, {
+	return planGate.withPermits(1)(retried).pipe(flatMap$1((output) => notifyJournal(services, {
 		type: "completed",
 		runId,
 		nodeId: node.id,
@@ -31656,10 +31628,23 @@ async function monitorChild(processHandle, input, limits) {
 		let settled = false;
 		let operationCount = 0;
 		const outstanding = /* @__PURE__ */ new Map();
-		const timer = setTimeout(() => {
+		const pending = [];
+		let remainingEvaluationMs = limits.wallTimeMs;
+		let evaluationStartedAt = performance.now();
+		let timer;
+		const timeOut = () => {
 			sendCancellation(processHandle, limits, "timed_out");
 			finish(failure(new WorkflowRuntimeError("timed_out", "The workflow timed out.")));
-		}, limits.wallTimeMs);
+		};
+		const resumeEvaluationTimer = () => {
+			evaluationStartedAt = performance.now();
+			timer = setTimeout(timeOut, remainingEvaluationMs);
+		};
+		const pauseEvaluationTimer = () => {
+			clearTimeout(timer);
+			remainingEvaluationMs = Math.max(0, remainingEvaluationMs - (performance.now() - evaluationStartedAt));
+		};
+		resumeEvaluationTimer();
 		const abortListener = () => {
 			sendCancellation(processHandle, limits, "cancelled");
 			finish(failure(new WorkflowRuntimeError("cancelled", "The workflow was cancelled.")));
@@ -31685,6 +31670,17 @@ async function monitorChild(processHandle, input, limits) {
 			finish(failure(new WorkflowRuntimeError("child_crashed", "The workflow child output is unavailable.")));
 			return;
 		}
+		const startOperation = (message) => {
+			const task = serviceOperation(processHandle, message, input.operationHandler, limits).catch(() => {
+				finish(failure(new WorkflowRuntimeError("protocol_breach", "The workflow operation response failed.")));
+			}).finally(() => {
+				outstanding.delete(message.request_id);
+				const next = pending.shift();
+				if (next !== void 0) startOperation(next);
+				else if (outstanding.size === 0 && !settled) resumeEvaluationTimer();
+			});
+			outstanding.set(message.request_id, task);
+		};
 		consumeStream(stdout, limits, (line) => {
 			if (settled) return;
 			let message;
@@ -31695,25 +31691,18 @@ async function monitorChild(processHandle, input, limits) {
 				return;
 			}
 			if (message.type === "operation-request") {
+				if (outstanding.size === 0 && pending.length === 0) pauseEvaluationTimer();
 				if (operationCount >= limits.maxOperationCount) {
 					finish(failure(new WorkflowRuntimeError("resource_limit", "The workflow operation limit was exceeded.")));
 					return;
 				}
-				if (outstanding.size >= limits.maxConcurrentOperations) {
-					finish(failure(new WorkflowRuntimeError("resource_limit", "The workflow concurrency limit was exceeded.")));
-					return;
-				}
-				if (outstanding.has(message.request_id)) {
+				if (outstanding.has(message.request_id) || pending.some((request) => request.request_id === message.request_id)) {
 					finish(failure(new WorkflowRuntimeError("protocol_breach", "The child reused a workflow operation request id.")));
 					return;
 				}
 				operationCount += 1;
-				const task = serviceOperation(processHandle, message, input.operationHandler, limits).catch(() => {
-					finish(failure(new WorkflowRuntimeError("protocol_breach", "The workflow operation response failed.")));
-				}).finally(() => {
-					outstanding.delete(message.request_id);
-				});
-				outstanding.set(message.request_id, task);
+				if (outstanding.size >= limits.maxConcurrentOperations) pending.push(message);
+				else startOperation(message);
 				return;
 			}
 			if (message.type === "terminal-success") {
@@ -31954,4 +31943,4 @@ function isAbsolutePath(value) {
 	return value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value);
 }
 //#endregion
-export { DelegationModeSchema as $, runSync as $t, DEFAULT_WORKFLOW_LIMITS as A, decodeUnknownEither as At, resolvePlanSelection as B, pattern as Bt, workflowFailure as C, Number$ as Ct, Step as D, Union as Dt, Run as E, Struct as Et, parseProtocolLine as F, maxItems as Ft, parseCapabilityResultV2 as G, async as Gt, SpecialistOutcomeSchema as H, is as Ht, serializeProtocolMessage as I, maxLength as It, canonicalIdentityUtf8 as J, mapError$1 as Jt, parseCliEnvelope as K, fail$1 as Kt, toWireLimits as L, minItems as Lt, WorkflowLimitsSchema as M, greaterThan as Mt, WorkflowProtocolMessageSchema as N, greaterThanOrEqualTo as Nt, Wait as O, Unknown as Ot, WorkflowRuntimeError as P, int as Pt, sha256DomainDigest as Q, runPromise as Qt, lookupPlan as R, minLength as Rt, isWorkflowFailure as S, Null as St, Queue as T, String$ as Tt, SpecialistOutcomeV2Schema as U, _void as Ut, SPECIALIST_OUTCOME_VERSION as V, positive as Vt, normalizeSpecialistOutcome as W, acquireRelease as Wt, canonicalJsonUtf8 as X, provide as Xt, canonicalJson as Y, orElseSucceed as Yt, domainSeparatedSha256 as Z, raceFirst as Zt, NATIVE_WORKFLOW_ABI_VERSION as _, resolveOptionalCapabilitySelections as _t, runExecutionPlan as a, fromEffect as an, RouteKeySchema as at, nativeWorkflowIdentityDigest as b, Boolean$ as bt, loadNativeWorkflowSource as c, scoped$1 as cn, createProjectId as ct, CompileOptionsSchema as d, isLeft as dn, CAPABILITY_REGISTRY as dt, scoped as en, EffortSchema as et, ExecutionPlan as f, isRight as fn, CapabilityNameSchema as ft, NATIVE_OUTPUT_REFERENCE_KEY as g, pluginIdsForOptionalCapabilities as gt, hydrateWorkflowPlanIR as h, migrateOptionalCapabilitySelections as ht, makeCapacityService as i, try_ as in, RoleTaskSchema as it, MAX_WORKFLOW_LIMITS as j, filter as jt, Workflow as k, declare as kt, mergeNativeWorkflowLimits as l, succeed$2 as ln, createSha256Digest as lt, compileWorkflowUnsafe as m, STATE_SCHEMA_EPOCH as mn, capabilityHealth as mt, evaluateWorkflowCompatibility as n, sync as nn, RoleSchema as nt, DEFAULT_NATIVE_WORKFLOW_LIMITS as o, mapError$2 as on, ServiceTierSchema as ot, compileWorkflow as p, CLI_SCHEMA_VERSION as pn, OPTIONAL_CAPABILITY_NAMES as pt, specialistOutcomeFromCapabilityResult as q, gen as qt, runWorkflowChild as r, tryPromise as rn, RoleSkillProfileSchema as rt, evaluateNativeWorkflowSource as s, provide$1 as sn, lookupRoleDefinition as st, evaluateWorkflow as t, succeed$1 as tn, PlanNameSchema as tt, transformNativeWorkflowSource as u, Tag as un, createTrustId as ut, freezeWorkflowPlanIR as v, decodeUnknown$1 as vt, decodePortableSchema as w, Record as wt, validateWorkflowPlanIR as x, Literal as xt, nativePlanJson as y, Array$ as yt, lookupRoute as z, optional as zt };
+export { EffortSchema as $, runPromise as $t, DEFAULT_WORKFLOW_LIMITS as A, declare as At, resolvePlanSelection as B, optional as Bt, workflowFailure as C, Null as Ct, Step as D, Struct as Dt, Run as E, String$ as Et, parseProtocolLine as F, int as Ft, parseCapabilityResultV2 as G, acquireRelease as Gt, SpecialistOutcomeSchema as H, positive as Ht, serializeProtocolMessage as I, maxItems as It, canonicalIdentityUtf8 as J, gen as Jt, parseCliEnvelope as K, async as Kt, toWireLimits as L, maxLength as Lt, WorkflowLimitsSchema as M, filter as Mt, WorkflowProtocolMessageSchema as N, greaterThan as Nt, Wait as O, Union as Ot, WorkflowRuntimeError as P, greaterThanOrEqualTo as Pt, DelegationModeSchema as Q, raceFirst as Qt, lookupPlan as R, minItems as Rt, isWorkflowFailure as S, Literal as St, Queue as T, Record as Tt, SpecialistOutcomeV2Schema as U, is as Ut, SPECIALIST_OUTCOME_VERSION as V, pattern as Vt, normalizeSpecialistOutcome as W, _void as Wt, canonicalJsonUtf8 as X, orElseSucceed as Xt, canonicalJson as Y, mapError$1 as Yt, domainSeparatedSha256 as Z, provide as Zt, NATIVE_WORKFLOW_ABI_VERSION as _, pluginIdsForOptionalCapabilities as _t, runExecutionPlan as a, try_ as an, RoleTaskSchema as at, nativeWorkflowIdentityDigest as b, Array$ as bt, loadNativeWorkflowSource as c, provide$1 as cn, lookupRoleDefinition as ct, CompileOptionsSchema as d, Tag as dn, createProjectId as dt, runSync as en, NativeAgentTypeSchema as et, ExecutionPlan as f, isLeft as fn, createSha256Digest as ft, NATIVE_OUTPUT_REFERENCE_KEY as g, OPTIONAL_CAPABILITY_NAMES as gt, hydrateWorkflowPlanIR as h, STATE_SCHEMA_EPOCH as hn, CapabilityNameSchema as ht, makeCapacityService as i, tryPromise as in, RoleSkillProfileSchema as it, MAX_WORKFLOW_LIMITS as j, decodeUnknownEither as jt, Workflow as k, Unknown as kt, mergeNativeWorkflowLimits as l, scoped$1 as ln, nativeAgentTypeFor as lt, compileWorkflowUnsafe as m, CLI_SCHEMA_VERSION as mn, CAPABILITY_REGISTRY as mt, evaluateWorkflowCompatibility as n, succeed$1 as nn, ROLE_DEFINITIONS as nt, DEFAULT_NATIVE_WORKFLOW_LIMITS as o, fromEffect as on, RouteKeySchema as ot, compileWorkflow as p, isRight as pn, createTrustId as pt, specialistOutcomeFromCapabilityResult as q, fail$1 as qt, runWorkflowChild as r, sync as rn, RoleSchema as rt, evaluateNativeWorkflowSource as s, mapError$2 as sn, ServiceTierSchema as st, evaluateWorkflow as t, scoped as tn, PlanNameSchema as tt, transformNativeWorkflowSource as u, succeed$2 as un, taskInstructionFor as ut, freezeWorkflowPlanIR as v, resolveOptionalCapabilitySelections as vt, decodePortableSchema as w, Number$ as wt, validateWorkflowPlanIR as x, Boolean$ as xt, nativePlanJson as y, decodeUnknown$1 as yt, lookupRoute as z, minLength as zt };