@agimon-ai/po-workflow 0.0.0-alpha.82 → 0.0.0-alpha.84

package/dist/{RecoverWorkflowService-mue4GOSA.cjs → RecoverWorkflowService-3K1OgTtI.cjs}

@@ -637,6 +637,21 @@ const WorkflowAdmissionMetadataSchema = zod.z.object({
 			admissionId: zod.z.string().uuid(),
 			operationId: zod.z.string().uuid()
 		})
+	}).optional(),
+	/**
+	* What the bound coordinator is owed for this terminal generation. Undelivered settlements are
+	* retried until the coordinator acknowledges them, so a held lock is never orphaned.
+	*/
+	settlement: zod.z.object({
+		outcome: zod.z.enum([
+			"success",
+			"skipped",
+			"failed",
+			"interrupted",
+			"abandoned"
+		]),
+		delivered: zod.z.boolean(),
+		at: zod.z.string()
 	}).optional()
 });
 const WorkflowAdmissionIntentSchema = zod.z.object({
@@ -992,6 +1007,93 @@ function summarizeWorkflowProgress(events) {
 	return [...jobs.values()];
 }
 //#endregion
+//#region src/services/workflowSettlement/index.ts
+/** What a terminal bound generation is owed and not yet acknowledged, or undefined when nothing is. */
+function owedSettlement(record) {
+	const admission = record.admission;
+	if (!admission?.binding || record.stage === "running" || admission.settlement?.delivered === true) return void 0;
+	return admission.settlement?.outcome ?? record.outcome ?? (record.stage === "completed" ? "success" : "interrupted");
+}
+/**
+* Durable settlement delivery. A held lock is released only through its coordinator, so every owed
+* settlement is retried (on coordinator registration and whenever a run settles) until acknowledged.
+*/
+function createWorkflowSettlement(options) {
+	let sweeping;
+	let again = false;
+	const deliverOne = async (registry, record) => {
+		const outcome = owedSettlement(record);
+		const admission = record.admission;
+		const run = registry.runRef(record);
+		if (!outcome || !admission?.binding || !run || admission.launcherSessionId !== options.sessionId) return;
+		if (await options.settle({
+			binding: structuredClone(admission.binding),
+			run,
+			outcome,
+			...record.failedJob === void 0 ? {} : { failedJob: record.failedJob },
+			ownerSessionId: admission.ownerSessionId,
+			launcherSessionId: admission.launcherSessionId,
+			signal: options.signal
+		}) !== "unavailable") await registry.recordSettlement(record, {
+			outcome,
+			delivered: true
+		}, outcome);
+	};
+	const sweep = async () => {
+		for (const registry of await options.registries()) for (const record of await registry.listRuns()) {
+			if (options.signal.aborted) return;
+			try {
+				await deliverOne(registry, record);
+			} catch (error) {
+				options.report(error);
+			}
+		}
+	};
+	/** Coalesces concurrent requests into one sweep, plus one more if a request arrived mid-sweep. */
+	const deliver = () => {
+		if (sweeping) {
+			again = true;
+			return sweeping;
+		}
+		sweeping = (async () => {
+			do {
+				again = false;
+				await sweep();
+			} while (again && !options.signal.aborted);
+		})().finally(() => {
+			sweeping = void 0;
+		});
+		return sweeping;
+	};
+	/**
+	* A person gives up a failed bound run: its coordinator releases what it holds and the run is never
+	* recovered. Takes the recovery claim so it cannot race a recovery of the same run.
+	*/
+	const abandon = async (registry, run) => {
+		const record = await registry.readRunByKey(run.registryWorkspace, "error", run.runKey);
+		if (record.runId !== run.runId) throw new Error("Workflow run generation changed.");
+		if (!record.admission?.binding) throw new Error("This run holds no lock, so there is nothing to abandon.");
+		if (record.admission.settlement?.outcome === "abandoned") {
+			deliver();
+			return;
+		}
+		const claim = await registry.claimRunRecovery(record.workspace, record.runKey, options.sessionId);
+		try {
+			if (!await registry.recordSettlement(record, {
+				outcome: "abandoned",
+				delivered: false
+			})) throw new Error("Workflow run changed before it could be abandoned.");
+		} finally {
+			await registry.releaseRunRecoveryClaim(record.workspace, record.runKey, claim.claimId);
+		}
+		await deliver();
+	};
+	return {
+		deliver,
+		abandon
+	};
+}
+//#endregion
 //#region src/services/WorkflowRegistryService/index.ts
 /**
 * WorkflowRegistryService
@@ -1108,6 +1210,33 @@ var WorkflowRegistryService = class {
 			registryWorkspace: record.workspace
 		} : void 0;
 	}
+	/**
+	* Record what a terminal bound generation owes its coordinator, or that the coordinator acknowledged it.
+	* Fenced by run and operation, so a replaced generation is never marked. With `expected`, it writes only
+	* while that outcome is still the one owed, so an abandon that lands mid-delivery is never marked delivered.
+	*/
+	async recordSettlement(record, settlement, expected) {
+		if (record.stage === RUNNING_STAGE || !record.admission?.binding) return false;
+		const recordPath = (0, node_path.resolve)(this.runDirectoryFor(record), RUN_RECORD_FILENAME$1);
+		if (!await this.pathExists(recordPath)) return false;
+		return this.withRunLock(recordPath, async () => {
+			const current = await this.readRunRecord(recordPath);
+			const admission = current.admission;
+			if (current.runId !== record.runId || current.stage === RUNNING_STAGE || admission?.binding?.epoch.operationId !== record.admission?.binding?.epoch.operationId) return false;
+			if (expected !== void 0 && owedSettlement(current) !== expected) return false;
+			await this.writeRunRecord(recordPath, {
+				...current,
+				admission: {
+					...admission,
+					settlement: {
+						...settlement,
+						at: (/* @__PURE__ */ new Date()).toISOString()
+					}
+				}
+			});
+			return true;
+		});
+	}
 	/** Exact-ID evidence survives replay, deletion and a lost secondary admission index write. */
 	async readRunEvidence(runId) {
 		const current = (await this.listRuns()).find((record) => record.runId === runId);
@@ -13254,7 +13383,9 @@ var RecoverWorkflowService = class {
 		const claim = input.recoveryClaimId ? await this.registry.adoptRunRecoveryClaim(record.workspace, record.runKey, input.recoveryClaimId) : await this.registry.claimRunRecovery(record.workspace, record.runKey, ownerSessionId);
 		try {
 			if (!input.recoveryClaimId) await this.registry.adoptRunRecoveryClaim(record.workspace, record.runKey, claim.claimId);
-			if ((await this.registry.readRunByKey(record.workspace, ERROR_STAGE, record.runKey)).runId !== record.runId) throw new Error("Workflow recovery generation changed after claiming.");
+			const current = await this.registry.readRunByKey(record.workspace, ERROR_STAGE, record.runKey);
+			if (current.runId !== record.runId) throw new Error("Workflow recovery generation changed after claiming.");
+			if (current.admission?.settlement?.outcome === "abandoned") throw new Error(`Workflow run "${record.workspace}/${record.runKey}" was abandoned and cannot be recovered`);
 			const runDir = this.registry.runDirectoryFor(record);
 			const paneRefs = (await readWorkflowProgress(this.runtime, runDir)).flatMap((event) => event.ref?.kind === "pane" ? [event.ref.id] : []);
 			await new NativeTerminalService$1(this.runtime).killRunPanes(record.runId, paneRefs);
@@ -13276,6 +13407,7 @@ var RecoverWorkflowService = class {
 		const terminalFixContent = activeRepair && !terminalStopAuthorized ? null : await this.registry.readRunFixContent(record.workspace, ERROR_STAGE, record.runKey);
 		const terminalFix = terminalFixContent ? this.parseTerminalFix(terminalFixContent, terminalStopAuthorized) : {};
 		if (terminalFix.terminal) throw new Error(`Workflow run "${record.workspace}/${record.runKey}" has a terminal fix request and cannot be recovered`);
+		if (record.admission?.settlement?.outcome === "abandoned") throw new Error(`Workflow run "${record.workspace}/${record.runKey}" was abandoned and cannot be recovered`);
 		const fixRestartFrom = terminalFix.restartFrom;
 		const recoveredJob = activeRepair ? this.repairService.resolveRecoveryStart(activeRepair) : fixRestartFrom ?? record.failedJob;
 		if (!recoveredJob) throw new Error(`Workflow run "${record.workspace}/${record.runKey}" does not include a recoverable failed job`);
@@ -13291,8 +13423,11 @@ var RecoverWorkflowService = class {
 		if (!this.parser.resolveJobOrder(workflow.jobs, originalJob ?? null).includes(recoveredJob)) throw new Error(`Workflow run "${record.workspace}/${record.runKey}" recovery target "${recoveredJob}" is not in the workflow job order`);
 		const ownerSessionId = record.admission?.ownerSessionId ?? claimedOwnerSessionId?.trim();
 		const admissionId = (0, node_crypto.randomUUID)();
+		const { settlement: _settlement, ...inherited } = record.admission ?? {};
 		const admission = this.hooks.admission ?? (record.admission ? {
-			...record.admission,
+			...inherited,
+			ownerSessionId: record.admission.ownerSessionId,
+			launcherSessionId: record.admission.launcherSessionId,
 			attemptId: `recover:${admissionId}`,
 			admissionId,
 			reason: this.hooks.reason ?? "recover",
@@ -13509,6 +13644,12 @@ Object.defineProperty(exports, "createWorkflowRuntime", {
 		return createWorkflowRuntime;
 	}
 });
+Object.defineProperty(exports, "createWorkflowSettlement", {
+	enumerable: true,
+	get: function() {
+		return createWorkflowSettlement;
+	}
+});
 Object.defineProperty(exports, "diagnoseWorkflow", {
 	enumerable: true,
 	get: function() {
@@ -13642,4 +13783,4 @@ Object.defineProperty(exports, "workflowShellOutput", {
 	}
 });
 
-//# sourceMappingURL=RecoverWorkflowService-mue4GOSA.cjs.map
+//# sourceMappingURL=RecoverWorkflowService-3K1OgTtI.cjs.map