@agimon-ai/po-workflow 0.0.0-alpha.79 → 0.0.0-alpha.80

package/dist/{RecoverWorkflowService-lWxTE3o6.cjs → RecoverWorkflowService-C-iiu-ku.cjs}

@@ -608,8 +608,50 @@ const WorkflowLauncherMetadataSchema = zod.z.discriminatedUnion("type", [
 	TmuxWorkflowLauncherMetadataSchema,
 	NativeWorkflowLauncherMetadataSchema
 ]);
+/** Only trusted in-process launchers set this metadata, never workflow environment. */
+const WorkflowAdmissionMetadataSchema = zod.z.object({
+	attemptId: zod.z.string().min(1),
+	admissionId: zod.z.string().uuid(),
+	ownerSessionId: zod.z.string().min(1),
+	launcherSessionId: zod.z.string().min(1),
+	reason: zod.z.enum([
+		"launch",
+		"recover",
+		"startup",
+		"resume"
+	]),
+	previousRun: zod.z.object({
+		runId: zod.z.string(),
+		ownerSessionId: zod.z.string(),
+		runKey: zod.z.string(),
+		registryWorkspace: zod.z.string()
+	}).optional(),
+	environment: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+	ready: zod.z.boolean().optional(),
+	binding: zod.z.object({
+		association: zod.z.object({
+			coordinator: zod.z.string().min(1),
+			key: zod.z.string().min(1)
+		}),
+		epoch: zod.z.object({
+			admissionId: zod.z.string().uuid(),
+			operationId: zod.z.string().uuid()
+		})
+	}).optional()
+});
+const WorkflowAdmissionIntentSchema = zod.z.object({
+	metadata: WorkflowAdmissionMetadataSchema,
+	requestHash: zod.z.string(),
+	rejected: zod.z.array(zod.z.string()).optional()
+});
 const WorkflowRunRecordSchema = zod.z.object({
 	activeRepairId: zod.z.string().regex(/^\d+$/).optional(),
+	admission: WorkflowAdmissionMetadataSchema.optional(),
+	archivedProgress: zod.z.array(WorkflowProgressEventSchema).optional(),
+	configuration: zod.z.object({
+		revision: zod.z.string(),
+		workflow: zod.z.record(zod.z.string(), zod.z.unknown())
+	}).optional(),
 	/** Read-only legacy metadata. New runs only write runner. */
 	cliAgent: zod.z.string().optional(),
 	continueOnError: zod.z.boolean().optional(),
@@ -1016,6 +1058,193 @@ var WorkflowRegistryService = class {
 	resolveWorkspace(explicitWorkspace, workflowWorkspace) {
 		return this.slugifySegment(explicitWorkspace || workflowWorkspace || DEFAULT_WORKSPACE$1, DEFAULT_WORKSPACE$1);
 	}
+	/** The journal is outside reusable and movable run directories. Exclusive publish is the CAS. */
+	async reserveAdmission(intent) {
+		intent = WorkflowAdmissionIntentSchema.parse(intent);
+		const directory = (0, node_path.resolve)(this.homeDir, "admissions");
+		(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.createDir(directory, { recursive: true }, this.runtime.ioContext));
+		const file = this.admissionPath(intent.metadata.launcherSessionId, intent.metadata.attemptId);
+		try {
+			await this.writeExclusiveJson(file, intent);
+			return {
+				intent,
+				fresh: true
+			};
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			const existing = await this.readAdmission(intent.metadata.launcherSessionId, intent.metadata.attemptId);
+			if (!existing || existing.requestHash !== intent.requestHash) throw new Error("Workflow attempt ID was reused with a different request.");
+			return {
+				intent: existing,
+				fresh: false
+			};
+		}
+	}
+	async readAdmission(launcher, attempt) {
+		const file = this.admissionPath(launcher, attempt);
+		try {
+			return WorkflowAdmissionIntentSchema.parse(JSON.parse((0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.readTextFile(file, this.runtime.ioContext))));
+		} catch (error) {
+			if (["ENOENT", "not_found"].includes(String(error.code))) return void 0;
+			throw error;
+		}
+	}
+	async rejectAdmission(intent, errors) {
+		const file = this.admissionPath(intent.metadata.launcherSessionId, intent.metadata.attemptId);
+		await this.writeAtomic(file, {
+			...intent,
+			rejected: errors
+		});
+	}
+	admissionPath(launcher, attempt) {
+		return (0, node_path.resolve)(this.homeDir, "admissions", `${(0, node_crypto.createHash)("sha256").update(JSON.stringify([launcher, attempt])).digest("hex")}.json`);
+	}
+	runRef(record) {
+		const ownerSessionId = record.admission?.ownerSessionId ?? record.env?.PO_SESSION_ID;
+		return record.runId && ownerSessionId ? {
+			runId: record.runId,
+			runKey: record.runKey,
+			ownerSessionId,
+			registryWorkspace: record.workspace
+		} : void 0;
+	}
+	/** 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);
+		if (current) return current;
+		const file = (0, node_path.resolve)(this.homeDir, "receipts", `${(0, node_crypto.createHash)("sha256").update(runId).digest("hex")}.json`);
+		if (!await this.pathExists(file)) return void 0;
+		return this.readRunRecord(file);
+	}
+	async listRunEvidence() {
+		const directory = (0, node_path.resolve)(this.homeDir, "receipts");
+		if (!await this.pathExists(directory)) return this.listRuns();
+		const entries = (0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.listDir(directory, this.runtime.ioContext));
+		const archived = await Promise.all(entries.filter((entry) => entry.name.endsWith(".json")).map((entry) => this.readRunRecord((0, node_path.resolve)(directory, entry.name))));
+		return [...new Map([...archived, ...await this.listRuns()].map((record) => [record.runId, record])).values()];
+	}
+	async preserveRunEvidence(record, runDir = this.runDirectoryFor(record)) {
+		if (!record.runId || record.stage === RUNNING_STAGE) return;
+		const directory = (0, node_path.resolve)(this.homeDir, "receipts");
+		(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.createDir(directory, { recursive: true }, this.runtime.ioContext));
+		const file = (0, node_path.resolve)(directory, `${(0, node_crypto.createHash)("sha256").update(record.runId).digest("hex")}.json`);
+		if (await this.pathExists(file)) return;
+		const progress = await readWorkflowProgress(this.runtime, runDir);
+		try {
+			await this.writeExclusiveJson(file, {
+				...record,
+				archivedProgress: progress.filter((event) => Date.parse(event.at) >= Date.parse(record.startedAt))
+			});
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+		}
+	}
+	/** All registry instances use the same stable workspace/run-key lock, including while stage dirs move. */
+	async withRunLock(recordPath, action) {
+		return this.writeCoordinator.forKey(recordPath)(async () => {
+			const runDir = (0, node_path.dirname)(recordPath);
+			const workspaceDir = (0, node_path.dirname)((0, node_path.dirname)(runDir));
+			const lockPath = (0, node_path.resolve)(workspaceDir, `${(0, node_crypto.createHash)("sha256").update(runDir.split("/").at(-1)).digest("hex")}.operation.lock`);
+			const release = await this.runtime.workflowHost.acquireRecoveryLock(lockPath, {
+				lockfilePath: lockPath,
+				realpath: false,
+				retries: {
+					retries: 100,
+					minTimeout: 10,
+					maxTimeout: 10
+				},
+				stale: DEFAULT_RECOVERY_CLAIM_TTL_MS
+			});
+			try {
+				return await action();
+			} finally {
+				await release();
+			}
+		});
+	}
+	/** Persist the epoch under the authoritative writer, await policy unlocked, then fence and acknowledge atomically. */
+	async authorizeExecution(handle, resume = false) {
+		const prepared = await this.withRunLock(handle.recordPath, async () => {
+			const current = await this.readRunRecord(handle.recordPath);
+			if (current.runId !== handle.runId || current.stage !== RUNNING_STAGE) throw new Error("Workflow generation changed before policy admission.");
+			const request = resume ? await this.readPauseRequest(handle) : void 0;
+			if (resume && (request?.action !== "resume" || current.executionState !== "resume_requested" && current.executionState !== "paused")) throw new Error("Workflow resume request changed.");
+			if (await this.hasStopRequest(handle)) throw new Error("Workflow was stopped before policy admission.");
+			if (!current.admission?.binding) return {
+				record: current,
+				request
+			};
+			const admission = structuredClone(current.admission);
+			if (resume) {
+				admission.reason = "resume";
+				admission.binding.epoch.operationId = (0, node_crypto.randomUUID)();
+			}
+			admission.ready = false;
+			const record = {
+				...current,
+				admission
+			};
+			await this.writeRunRecord(handle.recordPath, record);
+			return {
+				record,
+				request
+			};
+		});
+		const admission = prepared.record.admission;
+		let environment = {};
+		if (admission?.binding) {
+			const before = this.runtime.beforeWorkflowExecution;
+			if (!before) throw new Error(`Workflow policy coordinator is unavailable: ${admission.binding.association.coordinator}`);
+			const signal = this.runtime.workflowSignal ?? new AbortController().signal;
+			signal.throwIfAborted();
+			const result = await before({
+				binding: structuredClone(admission.binding),
+				reason: admission.reason,
+				ownerSessionId: admission.ownerSessionId,
+				launcherSessionId: admission.launcherSessionId,
+				run: this.runRef(prepared.record),
+				previousRun: admission.previousRun,
+				signal
+			});
+			signal.throwIfAborted();
+			environment = result?.environment ?? {};
+			for (const [key, value] of Object.entries(environment)) if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || /^(PO_|WORKFLOW_)/.test(key) || typeof value !== "string") throw new Error("Invalid workflow policy environment patch.");
+		} else if (!resume) return prepared.record;
+		return this.withRunLock(handle.recordPath, async () => {
+			const current = await this.readRunRecord(handle.recordPath);
+			const request = resume ? await this.readPauseRequest(handle) : void 0;
+			if (current.runId !== handle.runId || current.stage !== RUNNING_STAGE || current.admission?.binding?.epoch.operationId !== admission?.binding?.epoch.operationId || resume && (current.executionState !== prepared.record.executionState || request?.action !== "resume" || request.requestId !== prepared.request?.requestId) || await this.hasStopRequest(handle)) throw new Error("Workflow policy operation changed or stopped.");
+			const updated = { ...current };
+			if (admission?.binding) {
+				updated.admission = {
+					...current.admission,
+					ready: true,
+					environment: {
+						...current.admission?.environment,
+						...environment
+					}
+				};
+				updated.env = {
+					...current.env,
+					...environment
+				};
+			}
+			if (resume) {
+				const cursor = current.executionCursor;
+				updated.executionState = "running";
+				updated.executionCursor = {
+					...cursor,
+					phase: cursor?.phase ?? "step",
+					resumeMode: cursor?.resumeMode ?? "replay-current",
+					executionGeneration: (cursor?.executionGeneration ?? 1) + (cursor?.resumeMode === "continue-next" ? 0 : 1),
+					requestId: request.requestId,
+					revision: (cursor?.revision ?? 0) + 1
+				};
+			}
+			await this.writeRunRecord(handle.recordPath, updated);
+			return updated;
+		});
+	}
 	/**
 	* Create or resume a workflow run in the `running` stage for its workspace.
 	*/
@@ -1023,97 +1252,104 @@ var WorkflowRegistryService = class {
 		const workspace = this.resolveWorkspace(input.workspace, input.workflowWorkspace);
 		const runKey = this.slugifySegment(input.displayName, FALLBACK_RUN_KEY);
 		await this.ensureWorkspaceStructure(workspace);
-		const existingStage = await this.findReusableRunStage(workspace, runKey);
-		if (existingStage === RUNNING_STAGE) throw new WorkflowRunConflictError(workspace, runKey);
-		const runningDir = this.getRunDirectory(workspace, RUNNING_STAGE, runKey);
-		if (existingStage) {
-			const existingDir = this.getRunDirectory(workspace, existingStage, runKey);
-			let releaseRecoveryLock;
-			try {
-				if (existingStage === ERROR_STAGE$2) {
-					releaseRecoveryLock = await this.acquireRecoveryClaimLock(existingDir);
-					await this.assertRecoveryPromotion(existingDir, workspace, runKey, input.recoveryClaimId);
-				} else if (input.recoveryClaimId) throw new Error(`Workflow recovery claim does not target a failed run: ${workspace}/${runKey}`);
-				(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.remove(runningDir, {
-					recursive: true,
-					force: true
-				}, this.runtime.ioContext));
-				(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.renameFile(existingDir, runningDir, this.runtime.ioContext));
-			} finally {
-				await releaseRecoveryLock?.();
-			}
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, FIX_FILENAME$2));
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, PROCEED_FILENAME$1));
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, STOP_REQUEST_FILENAME));
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, PAUSE_REQUEST_FILENAME$1));
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, FINALIZING_FILENAME));
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, RECOVERY_CLAIM_FILENAME));
-			await this.removeFileIfExists((0, node_path.resolve)(runningDir, RECOVERY_ADOPTION_FILENAME));
-		} else {
-			if (input.recoveryClaimId) throw new Error(`Workflow recovery claim target no longer exists: ${workspace}/${runKey}`);
-			(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.createDir(runningDir, { recursive: true }, this.runtime.ioContext));
-		}
-		const runId = (0, node_crypto.randomUUID)();
-		const runRecord = {
-			activeRepairId: input.activeRepairId,
-			continueOnError: input.continueOnError,
-			displayName: input.displayName,
-			dryRun: input.dryRun,
-			env: input.env,
-			inputs: input.inputs,
-			job: input.job,
-			keepWorktree: input.keepWorktree,
-			launcher: input.launcher,
-			runKey,
-			prompt: input.prompt,
-			runner: input.runner,
-			...input.command === void 0 ? {} : { command: input.command },
-			...input.choice === void 0 ? {} : { choice: input.choice },
-			...input.profile === void 0 ? {} : { profile: input.profile },
-			runDirectory: input.runDirectory,
-			runId,
-			secretFile: input.secretFile,
-			skipLaunch: input.skipLaunch,
-			statusFile: input.statusFile,
-			terminalSocket: input.terminalSocket,
-			executionState: "running",
-			executionCursor: {
-				executionGeneration: 1,
-				phase: "starting",
-				resumeMode: "continue-next",
-				revision: 0
-			},
-			stage: RUNNING_STAGE,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			pid: input.pid ?? this.runtime.workflowHost.processId,
-			workflowPath: input.workflowPath,
-			workflowId: input.workflowId,
-			workflowName: input.workflowName,
-			workspace
-		};
-		const recordPath = (0, node_path.resolve)(runningDir, RUN_RECORD_FILENAME$1);
-		await this.writeRunRecord(recordPath, runRecord);
-		return {
-			changelogPath: (0, node_path.resolve)(runningDir, CHANGELOG_FILENAME),
-			contextPath: (0, node_path.resolve)(runningDir, CONTEXT_FILENAME),
-			displayName: input.displayName,
-			pauseRequestPath: (0, node_path.resolve)(runningDir, PAUSE_REQUEST_FILENAME$1),
-			recordPath,
-			runDir: runningDir,
-			runId,
-			runKey,
-			stopRequestPath: (0, node_path.resolve)(runningDir, STOP_REQUEST_FILENAME),
-			workspace
-		};
+		if (await this.findRunStage(workspace, runKey) === RUNNING_STAGE) await this.reconcileStaleRunningRecord(workspace, runKey);
+		return this.withRunLock((0, node_path.resolve)(this.getRunDirectory(workspace, RUNNING_STAGE, runKey), RUN_RECORD_FILENAME$1), async () => {
+			const existingStage = await this.findRunStage(workspace, runKey);
+			if (existingStage === RUNNING_STAGE) throw new WorkflowRunConflictError(workspace, runKey);
+			const runningDir = this.getRunDirectory(workspace, RUNNING_STAGE, runKey);
+			if (existingStage) {
+				const existingDir = this.getRunDirectory(workspace, existingStage, runKey);
+				await this.preserveRunEvidence(await this.readRunRecord((0, node_path.resolve)(existingDir, RUN_RECORD_FILENAME$1)));
+				let releaseRecoveryLock;
+				try {
+					if (existingStage === ERROR_STAGE$2) {
+						releaseRecoveryLock = await this.acquireRecoveryClaimLock(existingDir);
+						await this.assertRecoveryPromotion(existingDir, workspace, runKey, input.recoveryClaimId);
+					} else if (input.recoveryClaimId) throw new Error(`Workflow recovery claim does not target a failed run: ${workspace}/${runKey}`);
+					(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.remove(runningDir, {
+						recursive: true,
+						force: true
+					}, this.runtime.ioContext));
+					(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.renameFile(existingDir, runningDir, this.runtime.ioContext));
+				} finally {
+					await releaseRecoveryLock?.();
+				}
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, FIX_FILENAME$2));
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, PROCEED_FILENAME$1));
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, STOP_REQUEST_FILENAME));
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, PAUSE_REQUEST_FILENAME$1));
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, FINALIZING_FILENAME));
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, RECOVERY_CLAIM_FILENAME));
+				await this.removeFileIfExists((0, node_path.resolve)(runningDir, RECOVERY_ADOPTION_FILENAME));
+			} else {
+				if (input.recoveryClaimId) throw new Error(`Workflow recovery claim target no longer exists: ${workspace}/${runKey}`);
+				(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.createDir(runningDir, { recursive: true }, this.runtime.ioContext));
+			}
+			const runId = (0, node_crypto.randomUUID)();
+			const runRecord = {
+				activeRepairId: input.activeRepairId,
+				admission: input.admission,
+				configuration: input.configuration,
+				continueOnError: input.continueOnError,
+				displayName: input.displayName,
+				dryRun: input.dryRun,
+				env: input.env,
+				inputs: input.inputs,
+				job: input.job,
+				keepWorktree: input.keepWorktree,
+				launcher: input.launcher,
+				runKey,
+				prompt: input.prompt,
+				runner: input.runner,
+				...input.command === void 0 ? {} : { command: input.command },
+				...input.choice === void 0 ? {} : { choice: input.choice },
+				...input.profile === void 0 ? {} : { profile: input.profile },
+				runDirectory: input.runDirectory,
+				runId,
+				secretFile: input.secretFile,
+				skipLaunch: input.skipLaunch,
+				statusFile: input.statusFile,
+				terminalSocket: input.terminalSocket,
+				executionState: "running",
+				executionCursor: {
+					executionGeneration: 1,
+					phase: "starting",
+					resumeMode: "continue-next",
+					revision: 0
+				},
+				stage: RUNNING_STAGE,
+				startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				pid: input.pid ?? this.runtime.workflowHost.processId,
+				workflowPath: input.workflowPath,
+				workflowId: input.workflowId,
+				workflowName: input.workflowName,
+				workspace
+			};
+			const recordPath = (0, node_path.resolve)(runningDir, RUN_RECORD_FILENAME$1);
+			await this.writeRunRecord(recordPath, runRecord);
+			return {
+				changelogPath: (0, node_path.resolve)(runningDir, CHANGELOG_FILENAME),
+				contextPath: (0, node_path.resolve)(runningDir, CONTEXT_FILENAME),
+				displayName: input.displayName,
+				pauseRequestPath: (0, node_path.resolve)(runningDir, PAUSE_REQUEST_FILENAME$1),
+				recordPath,
+				runDir: runningDir,
+				runId,
+				runKey,
+				stopRequestPath: (0, node_path.resolve)(runningDir, STOP_REQUEST_FILENAME),
+				workspace
+			};
+		});
 	}
 	/**
 	* Finalize a workflow run by moving it into a terminal stage and updating metadata.
 	*/
 	async finalizeRun(handle, input) {
-		return this.writeCoordinator.forKey(handle.recordPath)(async () => {
+		return this.withRunLock(handle.recordPath, async () => {
 			await this.ensureWorkspaceStructure(handle.workspace);
 			const nextDir = this.getRunDirectory(handle.workspace, input.stage, handle.runKey);
 			const currentRecord = await this.readRunRecord(handle.recordPath);
+			if (currentRecord.runId !== handle.runId) throw new Error("Workflow generation changed before finalization.");
 			const finalRecord = {
 				...currentRecord,
 				errorMessage: input.errorMessage,
@@ -1246,7 +1482,7 @@ var WorkflowRegistryService = class {
 				resumeMode: "replay-current"
 			},
 			requestId: request.requestId,
-			resumeMode: "replay-current",
+			resumeMode: record.executionCursor?.resumeMode ?? "replay-current",
 			revision: revision + 1
 		}, revision);
 		await this.writeControlRequest(handle, handle.pauseRequestPath ?? (0, node_path.resolve)(handle.runDir, PAUSE_REQUEST_FILENAME$1), request);
@@ -1265,7 +1501,7 @@ var WorkflowRegistryService = class {
 		}
 	}
 	async updateExecutionState(handle, executionState, executionCursor, expectedRevision) {
-		return this.writeCoordinator.forKey(handle.recordPath)(async () => {
+		return this.withRunLock(handle.recordPath, async () => {
 			const current = await this.readRunRecord(handle.recordPath);
 			if (current.stage !== RUNNING_STAGE || current.runId && current.runId !== handle.runId) throw new Error(`Workflow run is no longer controllable: ${handle.workspace}/${handle.runKey}`);
 			const currentRevision = current.executionCursor?.revision ?? 0;
@@ -1280,7 +1516,7 @@ var WorkflowRegistryService = class {
 		});
 	}
 	async updateExecutionCursor(handle, patch) {
-		return this.writeCoordinator.forKey(handle.recordPath)(async () => {
+		return this.withRunLock(handle.recordPath, async () => {
 			const current = await this.readRunRecord(handle.recordPath);
 			if (current.stage !== RUNNING_STAGE || current.runId && current.runId !== handle.runId) throw new Error(`Workflow run is no longer controllable: ${handle.workspace}/${handle.runKey}`);
 			const currentCursor = current.executionCursor ?? {
@@ -1305,7 +1541,7 @@ var WorkflowRegistryService = class {
 	async markResumable(run, reason) {
 		const runDir = this.getRunDirectory(run.workspace, RUNNING_STAGE, run.runKey);
 		const recordPath = (0, node_path.resolve)(runDir, RUN_RECORD_FILENAME$1);
-		return this.writeCoordinator.forKey(recordPath)(async () => {
+		return this.withRunLock(recordPath, async () => {
 			const current = await this.readRunRecord(recordPath);
 			if (current.stage !== RUNNING_STAGE || current.runId !== run.runId) throw new Error(`Workflow run is no longer controllable: ${run.workspace}/${run.runKey}`);
 			if (current.executionState === "paused" || await this.hasStopRequest({
@@ -1328,8 +1564,18 @@ var WorkflowRegistryService = class {
 		});
 	}
 	/** Save worktree identity as soon as it exists, including for a later interrupted run. */
+	async updateConfiguration(handle, configuration) {
+		await this.withRunLock(handle.recordPath, async () => {
+			const record = await this.readRunRecord(handle.recordPath);
+			if (record.runId !== handle.runId || record.stage !== RUNNING_STAGE) throw new Error("Workflow configuration generation changed.");
+			await this.writeRunRecord(handle.recordPath, {
+				...record,
+				configuration
+			});
+		});
+	}
 	async updateWorktree(handle, metadata) {
-		return this.writeCoordinator.forKey(handle.recordPath)(async () => {
+		return this.withRunLock(handle.recordPath, async () => {
 			const current = await this.readRunRecord(handle.recordPath);
 			if (current.stage !== RUNNING_STAGE || current.runId !== handle.runId) throw new Error(`Workflow run is no longer controllable: ${handle.workspace}/${handle.runKey}`);
 			await this.writeRunRecord(handle.recordPath, {
@@ -1408,8 +1654,10 @@ var WorkflowRegistryService = class {
 		const tempPath = `${path}.${this.runtime.workflowHost.processId}.${(0, node_crypto.randomUUID)()}.tmp`;
 		try {
 			(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, this.runtime.ioContext));
-			await this.assertCurrentRun(handle);
-			(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.renameFile(tempPath, path, this.runtime.ioContext));
+			await this.withRunLock(handle.recordPath, async () => {
+				await this.assertCurrentRun(handle);
+				(0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.renameFile(tempPath, path, this.runtime.ioContext));
+			});
 		} catch (error) {
 			await this.removeFileIfExists(tempPath);
 			throw error;
@@ -1630,7 +1878,7 @@ var WorkflowRegistryService = class {
 	* Persist the active repair pointer and fix-cycle progress on a running record.
 	*/
 	async updateRepairState(handle, input) {
-		return this.writeCoordinator.forKey(handle.recordPath)(async () => {
+		return this.withRunLock(handle.recordPath, async () => {
 			const current = await this.readRunRecord(handle.recordPath);
 			const updated = {
 				...current,
@@ -1671,7 +1919,7 @@ var WorkflowRegistryService = class {
 		};
 		const runDir = this.getRunDirectory(input.workspace, input.stage, input.runKey);
 		const errorStage = input.stage === ERROR_STAGE$2;
-		return this.writeCoordinator.forKey((0, node_path.resolve)(runDir, RUN_RECORD_FILENAME$1))(async () => {
+		return this.withRunLock((0, node_path.resolve)(runDir, RUN_RECORD_FILENAME$1), async () => {
 			const releaseLock = errorStage ? await this.acquireRecoveryClaimLock(runDir) : void 0;
 			try {
 				if (!await this.pathExists(runDir)) throw new Error(`Workflow run not found: ${input.workspace}/${input.stage}/${input.runKey}`);
@@ -1881,16 +2129,6 @@ var WorkflowRegistryService = class {
 		return [...records.values()];
 	}
 	/**
-	* Resolve the run stage, first converting dead running records into
-	* interrupted terminal records so reruns are unblocked.
-	*/
-	async findReusableRunStage(workspace, runKey) {
-		const existingStage = await this.findRunStage(workspace, runKey);
-		if (existingStage !== RUNNING_STAGE) return existingStage;
-		await this.reconcileStaleRunningRecord(workspace, runKey);
-		return this.findRunStage(workspace, runKey);
-	}
-	/**
 	* Read a running record for status displays without mutating it on disk.
 	* If the recorded PID is gone, mark the returned record as stale but keep
 	* the persisted state untouched so the original failure metadata is not
@@ -1949,7 +2187,7 @@ var WorkflowRegistryService = class {
 	async reconcileStaleRunningRecord(workspace, runKey, expected) {
 		const runningDir = this.getRunDirectory(workspace, RUNNING_STAGE, runKey);
 		const runningRecordPath = (0, node_path.resolve)(runningDir, RUN_RECORD_FILENAME$1);
-		return this.writeCoordinator.forKey(runningRecordPath)(async () => {
+		return this.withRunLock(runningRecordPath, async () => {
 			const currentRecord = await this.readRunRecord(runningRecordPath);
 			if (expected !== void 0 && (currentRecord.runId !== expected.runId || currentRecord.env?.PO_SESSION_ID !== expected.ownerSessionId)) {
 				if (expected.stop) throw new Error(`Workflow run ownership changed: ${workspace}/${runKey}`);
@@ -2017,6 +2255,7 @@ var WorkflowRegistryService = class {
 	*/
 	async writeRunRecord(recordPath, record) {
 		await this.writeAtomic(recordPath, record);
+		if (record.stage !== RUNNING_STAGE) await this.preserveRunEvidence(record, (0, node_path.dirname)(recordPath));
 	}
 	/**
 	* Validate the persisted run record shape before returning it to callers.
@@ -4451,6 +4690,19 @@ var StepRunnerService = class StepRunnerService {
 	* progress log and telemetry instead of existing only as a log line.
 	*/
 	async executeStep(step, context, options, report) {
+		let policyEnvironment = {};
+		const runDir = context.env[WORKFLOW_RUN_DIR_ENV_KEY];
+		if (!options.dryRun && runDir) {
+			const file = (0, node_path.join)(runDir, RUN_RECORD_FILENAME);
+			if (await (0, _agimon_ai_po_core_platform.pathExists)(this.runtime.fs, file, this.runtime.ioContext)) {
+				const record = await new WorkflowRegistryService(this.runtime).readRunRecord(file);
+				if (record.admission?.binding) {
+					if (record.runId !== context.env.WORKFLOW_RUN_ID || !record.admission.ready) throw new Error("Managed workflow execution is not admitted for this generation.");
+					policyEnvironment = record.admission.environment ?? {};
+					Object.assign(context.env, policyEnvironment);
+				}
+			}
+		}
 		const fail = (reason) => {
 			this.logger.error(`    ${RED$3}${STATUS_ERROR}${RESET$4} ${reason}`);
 			report.reason = reason;
@@ -4530,6 +4782,7 @@ var StepRunnerService = class StepRunnerService {
 			...stepContext.env
 		};
 		if (step.env) for (const [key, val] of Object.entries(step.env)) stepEnv[key] = this.parser.interpolate(String(val), stepContext);
+		Object.assign(stepEnv, policyEnvironment);
 		for (const key of [
 			"WORKFLOW_RUN_ID",
 			"WORKFLOW_RUN_KEY",
@@ -4619,8 +4872,9 @@ var StepRunnerService = class StepRunnerService {
 			});
 			await this.markPaused(options.stopRequestPath, stepName, pausePolicy);
 			await options.onExecutionStateChange?.("paused", stepName);
-			await this.waitForResume(options.stopRequestPath, stepName);
+			Object.assign(stepContext.env, await this.waitForResume(options.stopRequestPath, stepName, stepContext.env.WORKFLOW_RUN_ID));
 			await options.onExecutionStateChange?.("resumed", stepName);
+			return this.executeStep(step, stepContext, options, report);
 		}
 		let maxTimeoutRetries;
 		try {
@@ -4693,12 +4947,11 @@ var StepRunnerService = class StepRunnerService {
 				});
 				await this.markPaused(options.stopRequestPath, stepName, pausePolicy, executionResult.survivors);
 				await options.onExecutionStateChange?.("paused", stepName);
-				await this.waitForResume(options.stopRequestPath, stepName);
+				Object.assign(stepContext.env, await this.waitForResume(options.stopRequestPath, stepName, stepContext.env.WORKFLOW_RUN_ID));
 				await options.onExecutionStateChange?.("resumed", stepName);
 				if (pausePolicy === "protected") return true;
 				await this.logStepLifecycle("info", "workflow.step.replay", stepEnv, { "workflow.step.outcome": "replay-current" });
-				attempt -= 1;
-				continue;
+				return this.executeStep(step, stepContext, options, report);
 			}
 			if (executionResult.status === "stop_requested") {
 				this.logger.info(`\n    ${YELLOW$2}${STATUS_INTERRUPTED}${RESET$4}  ${stepName} (${STATUS_STOP})`);
@@ -6207,8 +6460,8 @@ var StepRunnerService = class StepRunnerService {
 			throw error;
 		}
 	}
-	async waitForResume(stopRequestPath, stepName) {
-		if (!stopRequestPath) return;
+	async waitForResume(stopRequestPath, stepName, expectedRunId) {
+		if (!stopRequestPath) return {};
 		const pauseRequestPath = (0, node_path.join)((0, node_path.dirname)(stopRequestPath), PAUSE_REQUEST_FILENAME);
 		const recordPath = (0, node_path.join)((0, node_path.dirname)(stopRequestPath), RUN_RECORD_FILENAME);
 		this.logger.info(`    ${YELLOW$2}${STATUS_WAIT}${RESET$4}  ${stepName} paused; waiting for resume`);
@@ -6222,26 +6475,34 @@ var StepRunnerService = class StepRunnerService {
 				context: this.createInterruptContext(stepName, "")
 			});
 			if (await (0, _agimon_ai_po_core_platform.pathExists)(this.runtime.fs, pauseRequestPath, this.runtime.ioContext) && await this.readControlAction(pauseRequestPath) === "resume") {
-				const record = JSON.parse((0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.readTextFile(recordPath, this.runtime.ioContext)));
-				record.executionState = "running";
-				const cursor = record.executionCursor && typeof record.executionCursor === "object" ? record.executionCursor : {};
-				const request = JSON.parse((0, _agimon_ai_po_core_platform.getOrThrow)(await this.runtime.fs.readTextFile(pauseRequestPath, this.runtime.ioContext)));
-				const resumeMode = cursor.resumeMode === "continue-next" ? "continue-next" : "replay-current";
-				record.executionCursor = {
-					...cursor,
-					executionGeneration: resumeMode === "replay-current" && typeof cursor.executionGeneration === "number" ? cursor.executionGeneration + 1 : typeof cursor.executionGeneration === "number" ? cursor.executionGeneration : 1,
-					requestId: typeof request.requestId === "string" ? request.requestId : cursor.requestId,
-					revision: typeof cursor.revision === "number" ? cursor.revision + 1 : 1,
-					resumeMode
+				const registry = new WorkflowRegistryService(this.runtime);
+				const current = await registry.readRunRecord(recordPath);
+				if (expectedRunId !== void 0 && current.runId !== expectedRunId) throw new Error("Workflow generation changed while paused.");
+				const handle = {
+					runId: current.runId,
+					workspace: current.workspace,
+					runKey: current.runKey,
+					runDir: (0, node_path.dirname)(recordPath),
+					recordPath,
+					displayName: current.displayName,
+					stopRequestPath,
+					changelogPath: (0, node_path.join)((0, node_path.dirname)(recordPath), "changelog.md"),
+					contextPath: (0, node_path.join)((0, node_path.dirname)(recordPath), "context.md")
 				};
-				await this.writeControlRecord(recordPath, record);
-				return;
+				return (await registry.authorizeExecution(handle, true)).admission?.environment ?? {};
 			}
 			await new Promise((resolvePromise) => setTimeout(resolvePromise, STOP_REQUEST_POLL_INTERVAL_MS));
 		}
 	}
 	async writeControlRecord(recordPath, record) {
-		await (0, _agimon_ai_po_core_platform.writeFileAtomic)(this.runtime.fs, recordPath, `${JSON.stringify(record, null, 2)}\n`, this.runtime.ioContext);
+		const parsed = WorkflowRunRecordSchema.parse(record);
+		if (!parsed.runId) throw new Error("Workflow pause record has no generation.");
+		await new WorkflowRegistryService(this.runtime).updateExecutionState({
+			recordPath,
+			runId: parsed.runId,
+			workspace: parsed.workspace,
+			runKey: parsed.runKey
+		}, "paused", parsed.executionCursor, (parsed.executionCursor?.revision ?? 1) - 1);
 	}
 	captureTerminalState() {
 		if (!this.ownsTerminal) return null;
@@ -11567,6 +11828,7 @@ var RunWorkflowService = class {
 		* hooks. `post:` is the exception, and it is not a harmless one.
 		*/
 		let delegated = false;
+		let policyAuthorized = input.admission?.binding === void 0;
 		let progress;
 		let result = null;
 		let runError = null;
@@ -11671,6 +11933,8 @@ var RunWorkflowService = class {
 			if (dryRun && input.recovery) registryRun = await this.createRecoveryDryRunHandle(input, resolvedWorkspace);
 			else registryRun = await this.registry.createRun({
 				activeRepairId: input.recovery?.activeRepairId,
+				admission: input.admission,
+				configuration: configuration(),
 				continueOnError: input.continueOnError,
 				displayName: workflowName,
 				dryRun,
@@ -11696,6 +11960,11 @@ var RunWorkflowService = class {
 				workflowWorkspace: workflow.workspace,
 				workspace: input.workspace
 			});
+			if (!dryRun && input.admission?.binding) {
+				const admitted = await this.registry.authorizeExecution(registryRun);
+				Object.assign(workflowEnv, admitted.admission?.environment);
+				policyAuthorized = true;
+			}
 			if (input.recovery?.activeRepairId && !dryRun) activeRepair = await this.repairService.readRepair(registryRun.runDir, input.recovery.activeRepairId);
 			workflowEnv.WORKFLOW_RUN_DIR = registryRun.runDir;
 			workflowEnv.WORKFLOW_RUN_ID = registryRun.runId;
@@ -11906,6 +12175,7 @@ var RunWorkflowService = class {
 			while (!result) {
 				workflow = this.parser.selectRunner(await this.parser.parseWorkflowFile(await currentWorkflowPath()), runner);
 				this.useCommandSelection(workflow, input);
+				if (!dryRun) await this.registry.updateConfiguration(registryRun, configuration());
 				input.onConfigChanged?.({
 					runKey: registryRun.runKey,
 					runId: registryRun.runId,
@@ -12275,7 +12545,7 @@ var RunWorkflowService = class {
 					}
 				}
 			}
-			if (workflow.post && !delegated) {
+			if (workflow.post && !delegated && policyAuthorized) {
 				this.stepRunner.resetInterruption();
 				const settled = this.resolveRunOutcome(result, runError);
 				workflowEnv[WORKFLOW_PHASE_ENV] = "post";
@@ -12962,12 +13232,29 @@ var RecoverWorkflowService = class {
 	async recoverForSession(input, ownerSessionId) {
 		return await this.recoverWithOwner(input, ownerSessionId);
 	}
+	/** Read-only reconstruction reused by admission validation; no claim, process cleanup, or runner call. */
+	async prepareRecovery(input) {
+		const record = await this.registry.readRunByKey(input.workspace, ERROR_STAGE, input.runKey);
+		if (this.hooks.expectedRunId !== void 0 && record.runId !== this.hooks.expectedRunId) throw new Error("Workflow recovery generation changed.");
+		return this.buildReplay(input, void 0, record.admission?.ownerSessionId, record);
+	}
+	async recoverClaimed(input, claimId, owner, record) {
+		const replay = await this.buildReplay(input, claimId, owner, record);
+		return this.runner.run({
+			...replay,
+			onRegistered: (registration) => this.hooks.onRegistered?.(registration, replay),
+			onConfigChanged: (registration) => this.hooks.onConfigChanged?.(registration, replay)
+		});
+	}
 	async recoverWithOwner(input, ownerSessionId) {
 		const record = await this.registry.readRunByKey(input.workspace, ERROR_STAGE, input.runKey);
+		if (this.hooks.expectedRunId !== void 0 && record.runId !== this.hooks.expectedRunId) throw new Error("Workflow recovery generation changed.");
+		if (record.admission && ownerSessionId !== record.admission.ownerSessionId) throw new Error("Managed workflow recovery must run in its original owner session.");
 		if (input.dryRun || record.dryRun) return await this.recoverClaimed(input, void 0, void 0, record);
 		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 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);
@@ -12978,7 +13265,7 @@ var RecoverWorkflowService = class {
 			throw error;
 		}
 	}
-	async recoverClaimed(input, recoveryClaimId, claimedOwnerSessionId, failedRecord) {
+	async buildReplay(input, recoveryClaimId, claimedOwnerSessionId, failedRecord) {
 		const record = failedRecord ?? await this.registry.readRunByKey(input.workspace, ERROR_STAGE, input.runKey);
 		const activeRepair = record.activeRepairId ? await this.registry.readRunRepair(record.workspace, ERROR_STAGE, record.runKey, record.activeRepairId) : void 0;
 		if (activeRepair && !["pending", "active"].includes(activeRepair.status)) throw new Error(`Workflow run "${record.workspace}/${record.runKey}" points to non-active repair ${activeRepair.repairId} (${activeRepair.status})`);
@@ -13002,9 +13289,26 @@ var RecoverWorkflowService = class {
 		].includes(value))) throw new Error("Retired workflow execution cannot be replayed. Select a supported runner explicitly.");
 		const originalJob = fixRestartFrom && !activeRepair ? void 0 : record.job;
 		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 = claimedOwnerSessionId?.trim();
+		const ownerSessionId = record.admission?.ownerSessionId ?? claimedOwnerSessionId?.trim();
+		const admissionId = (0, node_crypto.randomUUID)();
+		const admission = this.hooks.admission ?? (record.admission ? {
+			...record.admission,
+			attemptId: `recover:${admissionId}`,
+			admissionId,
+			reason: this.hooks.reason ?? "recover",
+			previousRun: this.registry.runRef(record),
+			binding: record.admission.binding ? {
+				...record.admission.binding,
+				epoch: {
+					admissionId,
+					operationId: (0, node_crypto.randomUUID)()
+				}
+			} : void 0
+		} : void 0);
+		if (record.admission && admission && (admission.ownerSessionId !== record.admission.ownerSessionId || admission.launcherSessionId !== record.admission.launcherSessionId || JSON.stringify(admission.binding?.association) !== JSON.stringify(record.admission.binding?.association))) throw new Error("Workflow recovery policy ownership changed.");
 		const envOverrides = ownerSessionId ? { [PO_SESSION_ENV]: ownerSessionId } : void 0;
-		const replay = {
+		return {
+			admission,
 			runner,
 			command: record.command,
 			choice: record.choice,
@@ -13035,11 +13339,6 @@ var RecoverWorkflowService = class {
 				worktreePath: record.worktreePath
 			}
 		};
-		return await this.runner.run({
-			...replay,
-			onRegistered: (registration) => this.hooks.onRegistered?.(registration, replay),
-			onConfigChanged: (registration) => this.hooks.onConfigChanged?.(registration, replay)
-		});
 	}
 	parseTerminalFix(fixContent, allowTerminalStop) {
 		if (!fixContent.startsWith(FIX_FRONTMATTER_DELIMITER)) return {};
@@ -13343,4 +13642,4 @@ Object.defineProperty(exports, "workflowShellOutput", {
 	}
 });
 
-//# sourceMappingURL=RecoverWorkflowService-lWxTE3o6.cjs.map
+//# sourceMappingURL=RecoverWorkflowService-C-iiu-ku.cjs.map