@vercel/factory 0.0.14 → 0.0.15

package/dist/planning/reconcile.mjs

@@ -0,0 +1,273 @@
+import { routeKey } from "../agent-routes.mjs";
+import { BudgetExhaustedError, DispatchRefusedError, dispatchTask } from "../dispatch.mjs";
+import { taskMessageIdSchema } from "../schema/task-message.mjs";
+import { TaskMessageSourceFenceError } from "../store/task-messages.mjs";
+import { handoffPayloadSchema, handoffTaskMessageProtocol } from "../task-protocols.mjs";
+import { plannerCancellationBatch } from "./cancellation.mjs";
+import { runtimePrincipal, terminal } from "./state.mjs";
+import { cancelDescendants } from "./effects.mjs";
+import { cancelBlockedPlannerChildren } from "./dependencies.mjs";
+import { createHash } from "node:crypto";
+//#region src/planning/reconcile.ts
+const MAX_MESSAGES = 32;
+const TURN_TIMEOUT_MS = 9e5;
+function plannerReconciler(options, config, state, turns) {
+	const { stores } = options;
+	return async (snapshot) => {
+		const result = {
+			queued: [],
+			dispatched: [],
+			delivered: 0,
+			recovered: 0,
+			discarded: 0,
+			cancelled: [],
+			failed: [],
+			errors: []
+		};
+		const rows = new Map((snapshot ?? await stores.tasks.list()).map((task) => [task.id, task]));
+		const errors = (taskId, error) => result.errors.push({
+			taskId,
+			message: (error instanceof Error ? error.message : String(error)).slice(0, 1e3)
+		});
+		const roots = new Set([...rows.values()].filter(config.isPlanner).map((task) => task.rootTaskId));
+		for (const root of roots) try {
+			for (const task of await stores.work.recover(root)) rows.set(task.id, task);
+		} catch (error) {
+			errors(root, error);
+		}
+		const cancellations = plannerCancellationBatch(options);
+		for (const root of roots) try {
+			for (const task of await cancelBlockedPlannerChildren(options, config, root)) {
+				rows.set(task.id, task);
+				result.cancelled.push(task.id);
+			}
+		} catch (error) {
+			errors(root, error);
+		}
+		const planners = [...rows.values()].filter(config.isPlanner);
+		for (const planner of planners) try {
+			const current = await state.task(planner.id);
+			if (current.state !== "cancelled" && current.state !== "failed") continue;
+			result.cancelled.push(...await cancelDescendants(options, current, cancellations));
+		} catch (error) {
+			errors(planner.id, error);
+		}
+		for (const candidate of rows.values()) {
+			const parent = candidate.parentTaskId ? rows.get(candidate.parentTaskId) : void 0;
+			if (!parent || !config.isPlanner(parent)) continue;
+			try {
+				const current = await stores.tasks.get(candidate.id);
+				if (current) await cancellations.stop(current);
+			} catch (error) {
+				errors(candidate.id, error);
+			}
+		}
+		let deliveryAttempts = 0;
+		for (const candidate of rows.values()) {
+			if (deliveryAttempts >= MAX_MESSAGES) break;
+			if (!candidate.parentTaskId || !candidate.work.route || !config.allowed.has(routeKey(candidate.work.route))) continue;
+			try {
+				const child = await stores.tasks.get(candidate.id);
+				if (!child || !terminal(child) || child.question) continue;
+				const parent = await stores.tasks.get(candidate.parentTaskId);
+				if (!parent || !config.isPlanner(parent) || ![
+					"queued",
+					"running",
+					"needs_human"
+				].includes(parent.state)) continue;
+				await state.authority(parent);
+				const operationId = `result:${child.id}:${child.attempt}:${child.state}`;
+				const id = taskMessageIdSchema.parse(`msg_${createHash("sha256").update(JSON.stringify([child.id, operationId])).digest("hex")}`);
+				if (await stores.messages.get({
+					principal: runtimePrincipal,
+					toTaskId: parent.id,
+					messageId: id
+				})) continue;
+				const output = child.workResult?.output;
+				const includeOutput = output !== void 0 && Buffer.byteLength(JSON.stringify(output), "utf8") <= 48e3;
+				const payload = handoffPayloadSchema.parse({
+					outcome: child.state === "succeeded" ? "completed" : "failed",
+					summary: `${child.work.title}: ${child.state}`.slice(0, 1e3),
+					...includeOutput ? { output } : {},
+					artifacts: [],
+					concerns: includeOutput || output === void 0 ? [] : ["Output omitted from handoff; read canonical Task workResult."],
+					deviations: []
+				});
+				deliveryAttempts++;
+				await stores.messages.sendResult({
+					principal: runtimePrincipal,
+					message: {
+						operationId,
+						fromTaskId: child.id,
+						toTaskId: parent.id,
+						expectAttempt: child.attempt,
+						type: handoffTaskMessageProtocol.binding,
+						payload
+					}
+				});
+				result.delivered++;
+			} catch (error) {
+				errors(candidate.id, error);
+			}
+		}
+		let processed = 0;
+		let launchAttempted = false;
+		for (const planner of planners) try {
+			let current = await state.task(planner.id);
+			let recoveryLeased = false;
+			while (processed < MAX_MESSAGES) {
+				const head = (await stores.messages.pending({
+					principal: runtimePrincipal,
+					toTaskId: current.id
+				}))[0];
+				if (!head) break;
+				if (head.type.id !== "planner-start") {
+					const source = await stores.tasks.get(head.fromTaskId);
+					if (!source || source.attempt !== head.expectAttempt || source.state === "cancelled" && head.delivery !== "result") {
+						await stores.messages.discard({
+							principal: runtimePrincipal,
+							toTaskId: current.id,
+							messageId: head.id,
+							reason: "Source attempt changed or was cancelled; await canonical result delivery"
+						});
+						result.discarded++;
+						processed++;
+						continue;
+					}
+				}
+				const decision = current.state === "cancelled" ? null : await turns.recorded(current, head.id);
+				if (terminal(current) && (!decision || current.state === "cancelled")) {
+					await stores.messages.discard({
+						principal: runtimePrincipal,
+						toTaskId: current.id,
+						messageId: head.id,
+						reason: `Planner ${current.state}; no replayable committed decision`
+					});
+					result.discarded++;
+					processed++;
+					continue;
+				}
+				if (!decision || ![
+					"running",
+					"succeeded",
+					"failed"
+				].includes(current.state)) break;
+				try {
+					if (current.state === "running") await turns.prepare({
+						taskId: current.id,
+						attempt: current.attempt
+					});
+					if ((await turns.process(current, head.id, void 0, cancellations)).status === "idle") {
+						recoveryLeased = true;
+						break;
+					}
+					result.recovered++;
+					processed++;
+					current = await state.task(current.id);
+				} catch (error) {
+					if (!(error instanceof TaskMessageSourceFenceError)) throw error;
+					await stores.messages.discard({
+						principal: runtimePrincipal,
+						toTaskId: current.id,
+						messageId: head.id,
+						reason: "Source attempt changed; discard stale result and await canonical delivery"
+					});
+					result.discarded++;
+					processed++;
+				}
+			}
+			current = await state.task(current.id);
+			if (terminal(current) || current.state === "needs_human" || recoveryLeased) continue;
+			if (current.attempt > config.limits.maxTurns && [
+				"queued",
+				"running",
+				"stalled"
+			].includes(current.state)) {
+				await stores.tasks.transition(current.id, "failed", {
+					expectFrom: current.state,
+					expectAttempt: current.attempt,
+					reason: "Planner maxTurns exhausted"
+				});
+				result.failed.push(current.id);
+				continue;
+			}
+			await state.authority(current);
+			const activation = (await state.activation(current.id))?.value;
+			if (current.state === "running") {
+				const active = activation?.attempt === current.attempt ? activation : void 0;
+				const since = Math.max(Date.parse(active?.startedAt ?? current.updatedAt), Date.parse(current.lastProgressAt ?? current.updatedAt));
+				const expired = Date.parse(state.now()) - since >= TURN_TIMEOUT_MS;
+				const handoff = (await stores.messages.pending({
+					principal: runtimePrincipal,
+					toTaskId: current.id
+				})).some((message) => message.type.id === "handoff" && message.type.version === 1);
+				const unsubmitted = active && !await turns.recorded(current, active.triggerId);
+				if (active?.finished && (handoff || unsubmitted) || !active?.finished && expired) {
+					if (!active?.finished && !current.waitingForMessages) current = await stores.tasks.transition(current.id, "stalled", {
+						expectFrom: "running",
+						expectAttempt: current.attempt,
+						reason: "Planner turn or finished hook timed out",
+						phase: "workflow"
+					});
+					else current = await replace(current);
+				}
+			}
+			if (current.state === "stalled") current = await replace(current);
+			if (current.state !== "queued") continue;
+			if (current.attempt > config.limits.maxTurns) {
+				await stores.tasks.transition(current.id, "failed", {
+					expectFrom: "queued",
+					expectAttempt: current.attempt,
+					reason: "Planner maxTurns exhausted"
+				});
+				result.failed.push(current.id);
+				continue;
+			}
+			if (launchAttempted || current.approval === "required" || current.approval === "denied" || !await stores.graphs.dependenciesSatisfied({
+				rootTaskId: current.rootTaskId,
+				taskId: current.id
+			})) continue;
+			launchAttempted = true;
+			const launched = await dispatchTask(stores, {
+				taskId: current.id,
+				route: config.plannerRoute,
+				maxLaunchAttempts: config.limits.maxTurns,
+				...options.budget ? { budget: options.budget } : {},
+				async launch(running) {
+					await state.authority(running);
+					const prepared = await turns.prepare({
+						taskId: running.id,
+						attempt: running.attempt
+					});
+					await state.authority(running);
+					return options.launchPlanner(running, prepared.prompt);
+				}
+			});
+			rows.set(launched.id, launched);
+			result.dispatched.push(launched.id);
+		} catch (error) {
+			if (error instanceof BudgetExhaustedError) result.failed.push(planner.id);
+			if (!(error instanceof DispatchRefusedError)) errors(planner.id, error);
+		}
+		result.errors.push(...cancellations.errors);
+		result.cancellationPending = [...cancellations.pending];
+		return result;
+		async function replace(task) {
+			const exhausted = task.attempt >= config.limits.maxTurns;
+			const next = await stores.tasks.transition(task.id, exhausted ? "failed" : "queued", {
+				expectFrom: task.state,
+				expectAttempt: task.attempt,
+				phase: "workflow",
+				reason: exhausted ? "Planner maxTurns exhausted" : "Fresh planner activation after finished turn or timeout"
+			});
+			if (exhausted) result.failed.push(task.id);
+			else result.queued.push(task.id);
+			rows.set(next.id, next);
+			return next;
+		}
+	};
+}
+//#endregion
+export { plannerReconciler };
+
+//# sourceMappingURL=reconcile.mjs.map

package/dist/planning/reconcile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.mjs","names":[],"sources":["../../src/planning/reconcile.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { routeKey } from \"../agent-routes\";\nimport { BudgetExhaustedError, dispatchTask, DispatchRefusedError } from \"../dispatch\";\nimport type { TaskId } from \"../schema/id\";\nimport type { Task } from \"../schema/task\";\nimport { taskMessageIdSchema } from \"../schema/task-message\";\nimport { TaskMessageSourceFenceError } from \"../store/task-messages\";\nimport { handoffPayloadSchema, handoffTaskMessageProtocol } from \"../task-protocols\";\nimport type { PlannerConfiguration } from \"./configuration\";\nimport type { PlannerReconcileResult, PlannerRuntimeOptions } from \"./contracts\";\nimport { cancelDescendants } from \"./effects\";\nimport { plannerCancellationBatch } from \"./cancellation\";\nimport { cancelBlockedPlannerChildren } from \"./dependencies\";\nimport { runtimePrincipal, terminal, type PlannerState } from \"./state\";\nimport type { PlannerTurns } from \"./turns\";\n\nconst MAX_MESSAGES = 32;\nconst TURN_TIMEOUT_MS = 15 * 60_000;\nexport function plannerReconciler(\n  options: PlannerRuntimeOptions,\n  config: PlannerConfiguration,\n  state: PlannerState,\n  turns: PlannerTurns,\n) {\n  const { stores } = options;\n  return async (snapshot?: readonly Task[]): Promise<PlannerReconcileResult> => {\n    const result: {\n      queued: TaskId[];\n      dispatched: TaskId[];\n      delivered: number;\n      recovered: number;\n      discarded: number;\n      cancelled: TaskId[];\n      cancellationPending?: TaskId[];\n      failed: TaskId[];\n      errors: { taskId: TaskId; message: string }[];\n    } = {\n      queued: [],\n      dispatched: [],\n      delivered: 0,\n      recovered: 0,\n      discarded: 0,\n      cancelled: [],\n      failed: [],\n      errors: [],\n    };\n    const rows = new Map((snapshot ?? (await stores.tasks.list())).map((task) => [task.id, task]));\n    const errors = (taskId: TaskId, error: unknown) =>\n      result.errors.push({\n        taskId,\n        message: (error instanceof Error ? error.message : String(error)).slice(0, 1000),\n      });\n    const roots = new Set(\n      [...rows.values()].filter(config.isPlanner).map((task) => task.rootTaskId),\n    );\n    for (const root of roots) {\n      try {\n        for (const task of await stores.work.recover(root)) rows.set(task.id, task);\n      } catch (error) {\n        errors(root, error);\n      }\n    }\n    const cancellations = plannerCancellationBatch(options);\n    for (const root of roots) {\n      try {\n        for (const task of await cancelBlockedPlannerChildren(options, config, root)) {\n          rows.set(task.id, task);\n          result.cancelled.push(task.id);\n        }\n      } catch (error) {\n        errors(root, error);\n      }\n    }\n    const planners = [...rows.values()].filter(config.isPlanner);\n    for (const planner of planners) {\n      try {\n        const current = await state.task(planner.id);\n        if (current.state !== \"cancelled\" && current.state !== \"failed\") continue;\n        result.cancelled.push(...(await cancelDescendants(options, current, cancellations)));\n      } catch (error) {\n        errors(planner.id, error);\n      }\n    }\n    for (const candidate of rows.values()) {\n      const parent = candidate.parentTaskId ? rows.get(candidate.parentTaskId) : undefined;\n      if (!parent || !config.isPlanner(parent)) continue;\n      try {\n        const current = await stores.tasks.get(candidate.id);\n        if (current) await cancellations.stop(current);\n      } catch (error) {\n        errors(candidate.id, error);\n      }\n    }\n    let deliveryAttempts = 0;\n    for (const candidate of rows.values()) {\n      if (deliveryAttempts >= MAX_MESSAGES) break;\n      if (\n        !candidate.parentTaskId ||\n        !candidate.work.route ||\n        !config.allowed.has(routeKey(candidate.work.route))\n      )\n        continue;\n      try {\n        const child = await stores.tasks.get(candidate.id);\n        if (!child || !terminal(child) || child.question) continue;\n        const parent = await stores.tasks.get(candidate.parentTaskId);\n        if (\n          !parent ||\n          !config.isPlanner(parent) ||\n          ![\"queued\", \"running\", \"needs_human\"].includes(parent.state)\n        )\n          continue;\n        await state.authority(parent);\n        const operationId = `result:${child.id}:${child.attempt}:${child.state}`;\n        const id = taskMessageIdSchema.parse(\n          `msg_${createHash(\"sha256\")\n            .update(JSON.stringify([child.id, operationId]))\n            .digest(\"hex\")}`,\n        );\n        if (\n          await stores.messages.get({\n            principal: runtimePrincipal,\n            toTaskId: parent.id,\n            messageId: id,\n          })\n        )\n          continue;\n        const output = child.workResult?.output;\n        // The envelope shares the 64 KiB JSON bound with its output; large results stay on the canonical Task.\n        const includeOutput =\n          output !== undefined && Buffer.byteLength(JSON.stringify(output), \"utf8\") <= 48_000;\n        const payload = handoffPayloadSchema.parse({\n          outcome: child.state === \"succeeded\" ? \"completed\" : \"failed\",\n          summary: `${child.work.title}: ${child.state}`.slice(0, 1000),\n          ...(includeOutput ? { output } : {}),\n          artifacts: [],\n          concerns:\n            includeOutput || output === undefined\n              ? []\n              : [\"Output omitted from handoff; read canonical Task workResult.\"],\n          deviations: [],\n        });\n        deliveryAttempts++;\n        await stores.messages.sendResult({\n          principal: runtimePrincipal,\n          message: {\n            operationId,\n            fromTaskId: child.id,\n            toTaskId: parent.id,\n            expectAttempt: child.attempt,\n            type: handoffTaskMessageProtocol.binding,\n            payload,\n          },\n        });\n        result.delivered++;\n      } catch (error) {\n        errors(candidate.id, error);\n      }\n    }\n    let processed = 0;\n    let launchAttempted = false;\n    for (const planner of planners) {\n      try {\n        let current = await state.task(planner.id);\n        let recoveryLeased = false;\n        while (processed < MAX_MESSAGES) {\n          const head = (\n            await stores.messages.pending({\n              principal: runtimePrincipal,\n              toTaskId: current.id,\n            })\n          )[0];\n          if (!head) break;\n          if (head.type.id !== \"planner-start\") {\n            const source = await stores.tasks.get(head.fromTaskId);\n            if (\n              !source ||\n              source.attempt !== head.expectAttempt ||\n              (source.state === \"cancelled\" && head.delivery !== \"result\")\n            ) {\n              await stores.messages.discard({\n                principal: runtimePrincipal,\n                toTaskId: current.id,\n                messageId: head.id,\n                reason: \"Source attempt changed or was cancelled; await canonical result delivery\",\n              });\n              result.discarded++;\n              processed++;\n              continue;\n            }\n          }\n          const decision =\n            current.state === \"cancelled\" ? null : await turns.recorded(current, head.id);\n          if (terminal(current) && (!decision || current.state === \"cancelled\")) {\n            await stores.messages.discard({\n              principal: runtimePrincipal,\n              toTaskId: current.id,\n              messageId: head.id,\n              reason: `Planner ${current.state}; no replayable committed decision`,\n            });\n            result.discarded++;\n            processed++;\n            continue;\n          }\n          if (!decision || ![\"running\", \"succeeded\", \"failed\"].includes(current.state)) break;\n          try {\n            if (current.state === \"running\")\n              await turns.prepare({ taskId: current.id, attempt: current.attempt });\n            const recovered = await turns.process(current, head.id, undefined, cancellations);\n            if (recovered.status === \"idle\") {\n              recoveryLeased = true;\n              break;\n            }\n            result.recovered++;\n            processed++;\n            current = await state.task(current.id);\n          } catch (error) {\n            if (!(error instanceof TaskMessageSourceFenceError)) throw error;\n            await stores.messages.discard({\n              principal: runtimePrincipal,\n              toTaskId: current.id,\n              messageId: head.id,\n              reason: \"Source attempt changed; discard stale result and await canonical delivery\",\n            });\n            result.discarded++;\n            processed++;\n          }\n        }\n        current = await state.task(current.id);\n        if (terminal(current) || current.state === \"needs_human\" || recoveryLeased) continue;\n        if (\n          current.attempt > config.limits.maxTurns &&\n          [\"queued\", \"running\", \"stalled\"].includes(current.state)\n        ) {\n          await stores.tasks.transition(current.id, \"failed\", {\n            expectFrom: current.state,\n            expectAttempt: current.attempt,\n            reason: \"Planner maxTurns exhausted\",\n          });\n          result.failed.push(current.id);\n          continue;\n        }\n        await state.authority(current);\n        const activation = (await state.activation(current.id))?.value;\n        if (current.state === \"running\") {\n          const active = activation?.attempt === current.attempt ? activation : undefined;\n          const since = Math.max(\n            Date.parse(active?.startedAt ?? current.updatedAt),\n            Date.parse(current.lastProgressAt ?? current.updatedAt),\n          );\n          const expired = Date.parse(state.now()) - since >= TURN_TIMEOUT_MS;\n          const pending = await stores.messages.pending({\n            principal: runtimePrincipal,\n            toTaskId: current.id,\n          });\n          const handoff = pending.some(\n            (message) => message.type.id === \"handoff\" && message.type.version === 1,\n          );\n          const unsubmitted = active && !(await turns.recorded(current, active.triggerId));\n          if ((active?.finished && (handoff || unsubmitted)) || (!active?.finished && expired)) {\n            if (!active?.finished && !current.waitingForMessages) {\n              current = await stores.tasks.transition(current.id, \"stalled\", {\n                expectFrom: \"running\",\n                expectAttempt: current.attempt,\n                reason: \"Planner turn or finished hook timed out\",\n                phase: \"workflow\",\n              });\n            } else {\n              current = await replace(current);\n            }\n          }\n        }\n        if (current.state === \"stalled\") current = await replace(current);\n        if (current.state !== \"queued\") continue;\n        if (current.attempt > config.limits.maxTurns) {\n          await stores.tasks.transition(current.id, \"failed\", {\n            expectFrom: \"queued\",\n            expectAttempt: current.attempt,\n            reason: \"Planner maxTurns exhausted\",\n          });\n          result.failed.push(current.id);\n          continue;\n        }\n        if (\n          launchAttempted ||\n          current.approval === \"required\" ||\n          current.approval === \"denied\" ||\n          !(await stores.graphs.dependenciesSatisfied({\n            rootTaskId: current.rootTaskId,\n            taskId: current.id,\n          }))\n        )\n          continue;\n        launchAttempted = true;\n        const launched = await dispatchTask(stores, {\n          taskId: current.id,\n          route: config.plannerRoute,\n          maxLaunchAttempts: config.limits.maxTurns,\n          ...(options.budget ? { budget: options.budget } : {}),\n          async launch(running) {\n            await state.authority(running);\n            const prepared = await turns.prepare({ taskId: running.id, attempt: running.attempt });\n            await state.authority(running);\n            return options.launchPlanner(running, prepared.prompt);\n          },\n        });\n        rows.set(launched.id, launched);\n        result.dispatched.push(launched.id);\n      } catch (error) {\n        if (error instanceof BudgetExhaustedError) result.failed.push(planner.id);\n        if (!(error instanceof DispatchRefusedError)) errors(planner.id, error);\n      }\n    }\n    result.errors.push(...cancellations.errors);\n    result.cancellationPending = [...cancellations.pending];\n    return result;\n\n    async function replace(task: Task): Promise<Task> {\n      const exhausted = task.attempt >= config.limits.maxTurns;\n      const next = await stores.tasks.transition(task.id, exhausted ? \"failed\" : \"queued\", {\n        expectFrom: task.state,\n        expectAttempt: task.attempt,\n        phase: \"workflow\",\n        reason: exhausted\n          ? \"Planner maxTurns exhausted\"\n          : \"Fresh planner activation after finished turn or timeout\",\n      });\n      if (exhausted) result.failed.push(task.id);\n      else result.queued.push(task.id);\n      rows.set(next.id, next);\n      return next;\n    }\n  };\n}\n"],"mappings":"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"}

package/dist/planning/runtime.d.mts

@@ -0,0 +1,27 @@
+import { Task } from "../schema/task.mjs";
+import { TaskMessageId } from "../schema/task-message.mjs";
+import { TaskAttemptRef } from "../schema/execution.mjs";
+import { PlannerContext, PlannerDecision, PlannerLimits, PlannerPrepareResult, PlannerReconcileResult, PlannerRuntimeOptions, PlannerStores, PlannerSubmitResult, plannerDecisionSchema } from "./contracts.mjs";
+import { PlannerMessageProtocols, createPlannerMessagePolicy, createPlannerMessageProtocols } from "./configuration.mjs";
+//#region src/planning/runtime.d.ts
+/** Identifies one proposed decision for the active turn of an exact Task attempt. */
+interface PlannerSubmitInput {
+  readonly task: TaskAttemptRef;
+  readonly triggerId: TaskMessageId;
+  readonly proposed: unknown;
+}
+/** Operations exposed by the bounded durable planner runtime. */
+interface PlannerRuntime {
+  prepare(task: TaskAttemptRef): Promise<PlannerPrepareResult>;
+  context(task: TaskAttemptRef): Promise<PlannerContext>;
+  submit(input: PlannerSubmitInput): Promise<PlannerSubmitResult>;
+  turnFinished(task: TaskAttemptRef): Promise<void>;
+  reconcile(snapshot?: readonly Task[]): Promise<PlannerReconcileResult>;
+  isPlanner(task: Task): boolean;
+  readonly limits: PlannerLimits;
+}
+/** Trusted workflow runtime. Transport tools must supply authenticated Task ID/attempt, never model principals. */
+declare function createPlannerRuntime(options: PlannerRuntimeOptions): PlannerRuntime;
+//#endregion
+export { type PlannerContext, type PlannerDecision, type PlannerLimits, type PlannerMessageProtocols, type PlannerPrepareResult, type PlannerReconcileResult, PlannerRuntime, type PlannerRuntimeOptions, type PlannerStores, PlannerSubmitInput, type PlannerSubmitResult, createPlannerMessagePolicy, createPlannerMessageProtocols, createPlannerRuntime, plannerDecisionSchema };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/planning/runtime.mjs

@@ -0,0 +1,25 @@
+import { createPlannerMessagePolicy, createPlannerMessageProtocols, plannerConfiguration } from "./configuration.mjs";
+import { plannerState } from "./state.mjs";
+import { plannerReconciler } from "./reconcile.mjs";
+import { plannerDecisionSchema } from "./contracts.mjs";
+import { plannerTurns } from "./turns.mjs";
+//#region src/planning/runtime.ts
+/** Trusted workflow runtime. Transport tools must supply authenticated Task ID/attempt, never model principals. */
+function createPlannerRuntime(options) {
+	const config = plannerConfiguration(options);
+	const state = plannerState(options, config);
+	const turns = plannerTurns(options, config, state);
+	return Object.freeze({
+		prepare: turns.prepare,
+		context: turns.context,
+		submit: ({ task, triggerId, proposed }) => turns.submit(task, triggerId, proposed),
+		turnFinished: turns.turnFinished,
+		reconcile: plannerReconciler(options, config, state, turns),
+		isPlanner: config.isPlanner,
+		limits: config.limits
+	});
+}
+//#endregion
+export { createPlannerMessagePolicy, createPlannerMessageProtocols, createPlannerRuntime, plannerDecisionSchema };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/planning/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../../src/planning/runtime.ts"],"sourcesContent":["import { plannerConfiguration } from \"./configuration\";\nimport type { PlannerRuntimeOptions } from \"./contracts\";\nimport { plannerReconciler } from \"./reconcile\";\nimport { plannerState } from \"./state\";\nimport { plannerTurns } from \"./turns\";\nimport type {\n  PlannerContext,\n  PlannerPrepareResult,\n  PlannerReconcileResult,\n  PlannerSubmitResult,\n} from \"./contracts\";\nimport type { TaskAttemptRef } from \"../schema/execution\";\nimport type { TaskMessageId } from \"../schema/task-message\";\n\nexport { plannerDecisionSchema } from \"./contracts\";\nexport type {\n  PlannerContext,\n  PlannerDecision,\n  PlannerLimits,\n  PlannerPrepareResult,\n  PlannerReconcileResult,\n  PlannerRuntimeOptions,\n  PlannerStores,\n  PlannerSubmitResult,\n} from \"./contracts\";\nexport { createPlannerMessagePolicy, createPlannerMessageProtocols } from \"./configuration\";\nexport type { PlannerMessageProtocols } from \"./configuration\";\n\n/** Identifies one proposed decision for the active turn of an exact Task attempt. */\nexport interface PlannerSubmitInput {\n  readonly task: TaskAttemptRef;\n  readonly triggerId: TaskMessageId;\n  readonly proposed: unknown;\n}\n\n/** Operations exposed by the bounded durable planner runtime. */\nexport interface PlannerRuntime {\n  prepare(task: TaskAttemptRef): Promise<PlannerPrepareResult>;\n  context(task: TaskAttemptRef): Promise<PlannerContext>;\n  submit(input: PlannerSubmitInput): Promise<PlannerSubmitResult>;\n  turnFinished(task: TaskAttemptRef): Promise<void>;\n  reconcile(snapshot?: readonly import(\"../schema/task\").Task[]): Promise<PlannerReconcileResult>;\n  isPlanner(task: import(\"../schema/task\").Task): boolean;\n  readonly limits: import(\"./contracts\").PlannerLimits;\n}\n\n/** Trusted workflow runtime. Transport tools must supply authenticated Task ID/attempt, never model principals. */\nexport function createPlannerRuntime(options: PlannerRuntimeOptions): PlannerRuntime {\n  const config = plannerConfiguration(options);\n  const state = plannerState(options, config);\n  const turns = plannerTurns(options, config, state);\n  return Object.freeze({\n    prepare: turns.prepare,\n    context: turns.context,\n    submit: ({ task, triggerId, proposed }: PlannerSubmitInput) =>\n      turns.submit(task, triggerId, proposed),\n    turnFinished: turns.turnFinished,\n    reconcile: plannerReconciler(options, config, state, turns),\n    isPlanner: config.isPlanner,\n    limits: config.limits,\n  });\n}\n"],"mappings":";;;;;;;AA+CA,SAAgB,qBAAqB,SAAgD;CACnF,MAAM,SAAS,qBAAqB,OAAO;CAC3C,MAAM,QAAQ,aAAa,SAAS,MAAM;CAC1C,MAAM,QAAQ,aAAa,SAAS,QAAQ,KAAK;CACjD,OAAO,OAAO,OAAO;EACnB,SAAS,MAAM;EACf,SAAS,MAAM;EACf,SAAS,EAAE,MAAM,WAAW,eAC1B,MAAM,OAAO,MAAM,WAAW,QAAQ;EACxC,cAAc,MAAM;EACpB,WAAW,kBAAkB,SAAS,QAAQ,OAAO,KAAK;EAC1D,WAAW,OAAO;EAClB,QAAQ,OAAO;CACjB,CAAC;AACH"}

package/dist/planning/state.mjs

@@ -0,0 +1,92 @@
+import { taskIdSchema } from "../schema/id.mjs";
+import { isoDateTimeSchema, schemaVersionSchema } from "../schema/common.mjs";
+import { RecordExistsError, VersionConflictError } from "../store/driver.mjs";
+import { taskMessageIdSchema } from "../schema/task-message.mjs";
+import { z } from "zod";
+//#region src/planning/state.ts
+const runtimePrincipal = Object.freeze({ id: "factory:planner-runtime" });
+const terminal = (task) => [
+	"succeeded",
+	"failed",
+	"cancelled"
+].includes(task.state);
+const activationSchema = z.strictObject({
+	schemaVersion: schemaVersionSchema,
+	taskId: taskIdSchema.describe("Planner Task and directly addressed checkpoint key."),
+	attempt: z.number().int().positive().describe("Task attempt owning this activation."),
+	triggerId: taskMessageIdSchema.describe("One immutable trigger for this entire activation."),
+	seed: z.boolean().describe("Whether preparation must ensure a self-start message is delivered."),
+	finished: z.boolean().describe("Trusted turn-finished hook observed; not a provider session lifecycle."),
+	startedAt: isoDateTimeSchema.describe("Workflow activation time used for bounded missing-hook recovery.")
+});
+function plannerState(options, config) {
+	const { stores } = options;
+	const driver = stores.workflowRecords;
+	const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+	async function task(id, attempt) {
+		taskIdSchema.parse(id);
+		if (attempt !== void 0) z.number().int().positive().parse(attempt);
+		const value = await stores.tasks.get(id);
+		if (!value || !config.isPlanner(value)) throw new Error(`Task ${id} requires the exact planner route`);
+		if (attempt !== void 0 && value.attempt !== attempt) throw new Error(`Stale planner attempt ${attempt}; current attempt is ${value.attempt}`);
+		return value;
+	}
+	async function authority(value, allowTerminal = false) {
+		const current = await task(value.id, value.attempt);
+		if (current.state === "cancelled" || !allowTerminal && terminal(current)) throw new Error("Planner is terminal or cancelled");
+		if (current.attempt > config.limits.maxTurns) throw new Error("Planner maxTurns exhausted");
+		let cursor = current;
+		const seen = /* @__PURE__ */ new Set([cursor.id]);
+		while (cursor.parentTaskId) {
+			const parent = await stores.tasks.get(cursor.parentTaskId);
+			if (!parent || parent.rootTaskId !== current.rootTaskId || seen.has(parent.id)) throw new Error("Invalid planner ancestry");
+			if (terminal(parent)) throw new Error("Planner ancestor is terminal or cancelled");
+			seen.add(parent.id);
+			cursor = parent;
+		}
+		if (cursor.id !== current.rootTaskId) throw new Error("Planner root is missing");
+		for (const repositoryId of current.repositoryIds) if (options.canUseRepository && await options.canUseRepository(repositoryId, current) !== true) throw new Error(`Planner repository ${repositoryId} is not permitted`);
+		return current;
+	}
+	async function activation(id) {
+		const stored = await driver.get("plannerActivations", id);
+		if (!stored) return null;
+		const value = activationSchema.parse(stored.value);
+		if (value.taskId !== id) throw new Error("Planner activation identity mismatch");
+		return {
+			value,
+			version: stored.version
+		};
+	}
+	async function save(value, version) {
+		const parsed = activationSchema.parse(value);
+		try {
+			if (version === void 0) await driver.insert({
+				collection: "plannerActivations",
+				id: value.taskId,
+				value: parsed
+			});
+			else await driver.update({
+				collection: "plannerActivations",
+				id: value.taskId,
+				value: parsed,
+				expectedVersion: version
+			});
+			return true;
+		} catch (error) {
+			if (error instanceof RecordExistsError || error instanceof VersionConflictError) return false;
+			throw error;
+		}
+	}
+	return {
+		now,
+		task,
+		authority,
+		activation,
+		save
+	};
+}
+//#endregion
+export { plannerState, runtimePrincipal, terminal };
+
+//# sourceMappingURL=state.mjs.map

package/dist/planning/state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.mjs","names":[],"sources":["../../src/planning/state.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { isoDateTimeSchema, schemaVersionSchema } from \"../schema/common\";\nimport { taskIdSchema, type TaskId } from \"../schema/id\";\nimport type { Task } from \"../schema/task\";\nimport { taskMessageIdSchema } from \"../schema/task-message\";\nimport { RecordExistsError, VersionConflictError } from \"../store/driver\";\nimport type { PlannerRuntimeOptions } from \"./contracts\";\nimport type { PlannerConfiguration } from \"./configuration\";\n\nexport const runtimePrincipal = Object.freeze({ id: \"factory:planner-runtime\" });\nexport const terminal = (task: Task) => [\"succeeded\", \"failed\", \"cancelled\"].includes(task.state);\nconst activationSchema = z.strictObject({\n  schemaVersion: schemaVersionSchema,\n  taskId: taskIdSchema.describe(\"Planner Task and directly addressed checkpoint key.\"),\n  attempt: z.number().int().positive().describe(\"Task attempt owning this activation.\"),\n  triggerId: taskMessageIdSchema.describe(\"One immutable trigger for this entire activation.\"),\n  seed: z.boolean().describe(\"Whether preparation must ensure a self-start message is delivered.\"),\n  finished: z\n    .boolean()\n    .describe(\"Trusted turn-finished hook observed; not a provider session lifecycle.\"),\n  startedAt: isoDateTimeSchema.describe(\n    \"Workflow activation time used for bounded missing-hook recovery.\",\n  ),\n});\nexport type PlannerActivation = z.infer<typeof activationSchema>;\n\nexport function plannerState(options: PlannerRuntimeOptions, config: PlannerConfiguration) {\n  const { stores } = options;\n  const driver = stores.workflowRecords;\n  const now = options.now ?? (() => new Date().toISOString());\n  async function task(id: TaskId, attempt?: number): Promise<Task> {\n    taskIdSchema.parse(id);\n    if (attempt !== undefined) z.number().int().positive().parse(attempt);\n    const value = await stores.tasks.get(id);\n    if (!value || !config.isPlanner(value))\n      throw new Error(`Task ${id} requires the exact planner route`);\n    if (attempt !== undefined && value.attempt !== attempt)\n      throw new Error(`Stale planner attempt ${attempt}; current attempt is ${value.attempt}`);\n    return value;\n  }\n  async function authority(value: Task, allowTerminal = false): Promise<Task> {\n    const current = await task(value.id, value.attempt);\n    if (current.state === \"cancelled\" || (!allowTerminal && terminal(current)))\n      throw new Error(\"Planner is terminal or cancelled\");\n    if (current.attempt > config.limits.maxTurns) throw new Error(\"Planner maxTurns exhausted\");\n    let cursor: Task = current;\n    const seen = new Set<string>([cursor.id]);\n    while (cursor.parentTaskId) {\n      const parent = await stores.tasks.get(cursor.parentTaskId);\n      if (!parent || parent.rootTaskId !== current.rootTaskId || seen.has(parent.id))\n        throw new Error(\"Invalid planner ancestry\");\n      if (terminal(parent)) throw new Error(\"Planner ancestor is terminal or cancelled\");\n      seen.add(parent.id);\n      cursor = parent;\n    }\n    if (cursor.id !== current.rootTaskId) throw new Error(\"Planner root is missing\");\n    for (const repositoryId of current.repositoryIds) {\n      if (\n        options.canUseRepository &&\n        (await options.canUseRepository(repositoryId, current)) !== true\n      ) {\n        throw new Error(`Planner repository ${repositoryId} is not permitted`);\n      }\n    }\n    return current;\n  }\n  async function activation(id: TaskId) {\n    const stored = await driver.get(\"plannerActivations\", id);\n    if (!stored) return null;\n    const value = activationSchema.parse(stored.value);\n    if (value.taskId !== id) throw new Error(\"Planner activation identity mismatch\");\n    return { value, version: stored.version };\n  }\n  async function save(value: PlannerActivation, version?: number): Promise<boolean> {\n    const parsed = activationSchema.parse(value);\n    try {\n      if (version === undefined)\n        await driver.insert({ collection: \"plannerActivations\", id: value.taskId, value: parsed });\n      else\n        await driver.update({\n          collection: \"plannerActivations\",\n          id: value.taskId,\n          value: parsed,\n          expectedVersion: version,\n        });\n      return true;\n    } catch (error) {\n      if (error instanceof RecordExistsError || error instanceof VersionConflictError) return false;\n      throw error;\n    }\n  }\n  return { now, task, authority, activation, save };\n}\nexport type PlannerState = ReturnType<typeof plannerState>;\n"],"mappings":";;;;;;AASA,MAAa,mBAAmB,OAAO,OAAO,EAAE,IAAI,0BAA0B,CAAC;AAC/E,MAAa,YAAY,SAAe;CAAC;CAAa;CAAU;AAAW,CAAC,CAAC,SAAS,KAAK,KAAK;AAChG,MAAM,mBAAmB,EAAE,aAAa;CACtC,eAAe;CACf,QAAQ,aAAa,SAAS,qDAAqD;CACnF,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,sCAAsC;CACpF,WAAW,oBAAoB,SAAS,mDAAmD;CAC3F,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS,oEAAoE;CAC/F,UAAU,EACP,QAAQ,CAAC,CACT,SAAS,wEAAwE;CACpF,WAAW,kBAAkB,SAC3B,kEACF;AACF,CAAC;AAGD,SAAgB,aAAa,SAAgC,QAA8B;CACzF,MAAM,EAAE,WAAW;CACnB,MAAM,SAAS,OAAO;CACtB,MAAM,MAAM,QAAQ,+BAAc,IAAI,KAAK,EAAA,CAAE,YAAY;CACzD,eAAe,KAAK,IAAY,SAAiC;EAC/D,aAAa,MAAM,EAAE;EACrB,IAAI,YAAY,KAAA,GAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,OAAO;EACpE,MAAM,QAAQ,MAAM,OAAO,MAAM,IAAI,EAAE;EACvC,IAAI,CAAC,SAAS,CAAC,OAAO,UAAU,KAAK,GACnC,MAAM,IAAI,MAAM,QAAQ,GAAG,kCAAkC;EAC/D,IAAI,YAAY,KAAA,KAAa,MAAM,YAAY,SAC7C,MAAM,IAAI,MAAM,yBAAyB,QAAQ,uBAAuB,MAAM,SAAS;EACzF,OAAO;CACT;CACA,eAAe,UAAU,OAAa,gBAAgB,OAAsB;EAC1E,MAAM,UAAU,MAAM,KAAK,MAAM,IAAI,MAAM,OAAO;EAClD,IAAI,QAAQ,UAAU,eAAgB,CAAC,iBAAiB,SAAS,OAAO,GACtE,MAAM,IAAI,MAAM,kCAAkC;EACpD,IAAI,QAAQ,UAAU,OAAO,OAAO,UAAU,MAAM,IAAI,MAAM,4BAA4B;EAC1F,IAAI,SAAe;EACnB,MAAM,uBAAO,IAAI,IAAY,CAAC,OAAO,EAAE,CAAC;EACxC,OAAO,OAAO,cAAc;GAC1B,MAAM,SAAS,MAAM,OAAO,MAAM,IAAI,OAAO,YAAY;GACzD,IAAI,CAAC,UAAU,OAAO,eAAe,QAAQ,cAAc,KAAK,IAAI,OAAO,EAAE,GAC3E,MAAM,IAAI,MAAM,0BAA0B;GAC5C,IAAI,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,2CAA2C;GACjF,KAAK,IAAI,OAAO,EAAE;GAClB,SAAS;EACX;EACA,IAAI,OAAO,OAAO,QAAQ,YAAY,MAAM,IAAI,MAAM,yBAAyB;EAC/E,KAAK,MAAM,gBAAgB,QAAQ,eACjC,IACE,QAAQ,oBACP,MAAM,QAAQ,iBAAiB,cAAc,OAAO,MAAO,MAE5D,MAAM,IAAI,MAAM,sBAAsB,aAAa,kBAAkB;EAGzE,OAAO;CACT;CACA,eAAe,WAAW,IAAY;EACpC,MAAM,SAAS,MAAM,OAAO,IAAI,sBAAsB,EAAE;EACxD,IAAI,CAAC,QAAQ,OAAO;EACpB,MAAM,QAAQ,iBAAiB,MAAM,OAAO,KAAK;EACjD,IAAI,MAAM,WAAW,IAAI,MAAM,IAAI,MAAM,sCAAsC;EAC/E,OAAO;GAAE;GAAO,SAAS,OAAO;EAAQ;CAC1C;CACA,eAAe,KAAK,OAA0B,SAAoC;EAChF,MAAM,SAAS,iBAAiB,MAAM,KAAK;EAC3C,IAAI;GACF,IAAI,YAAY,KAAA,GACd,MAAM,OAAO,OAAO;IAAE,YAAY;IAAsB,IAAI,MAAM;IAAQ,OAAO;GAAO,CAAC;QAEzF,MAAM,OAAO,OAAO;IAClB,YAAY;IACZ,IAAI,MAAM;IACV,OAAO;IACP,iBAAiB;GACnB,CAAC;GACH,OAAO;EACT,SAAS,OAAO;GACd,IAAI,iBAAiB,qBAAqB,iBAAiB,sBAAsB,OAAO;GACxF,MAAM;EACR;CACF;CACA,OAAO;EAAE;EAAK;EAAM;EAAW;EAAY;CAAK;AAClD"}