@iowarp/clio-coder 0.3.4 → 0.3.7

package/src/domains/dispatch/execution-scheduler.ts

@@ -1,4 +1,5 @@
 import { closeAgentLedger, openAgentLedger } from "./agent-ledger-store.js";
+import type { DelegationPlan } from "./delegation-plan.js";
 import { type ExecutionHandoff, projectExecutionHandoffs } from "./execution-handoff.js";
 import {
 	type ExecutionPlan,
@@ -18,6 +19,11 @@ export interface ExecutionStepResult extends ExecutionHandoff {
 	 * its own writes is not a witness.
 	 */
 	boundaryViolated?: boolean;
+	failureReason?: string;
+	gatePathHash?: string;
+	delegationPlanHash?: string;
+	/** Coordinator-validated tasks that the scheduler may splice after this step settles. */
+	delegationPlan?: DelegationPlan;
 }
 
 /**
@@ -83,6 +89,8 @@ export interface ExecutionLoopDecisionInput {
 }
 
 export interface ExecutionSchedulerAdapter {
+	/** Successful prefix results that retain their original receipt references. */
+	replayed?: ReadonlyMap<string, ExecutionStepResult>;
 	preflight(step: ExecutionPlanAgentStep): ExecutionPlanAdmission;
 	reserve(plan: ExecutionPlan, admissions: ReadonlyArray<ExecutionPlanAdmission>): { ownerId: string };
 	run(
@@ -131,6 +139,14 @@ export interface ExecutionSchedulerAdapter {
 	cancel(assignmentId: string): void;
 	release(ownerId: string): void;
 	releaseUnconsumed(ownerId: string): void;
+	/** Persist a settled result after boundary enforcement and before a dependent starts. */
+	onStepSettled?(step: ExecutionPlanStep, result: ExecutionStepResult): void | Promise<void>;
+	/** Recompile the live plan after a successful dynamic plan step settles. */
+	spliceAfter?(
+		plan: ExecutionPlan,
+		step: ExecutionPlanAgentStep,
+		result: ExecutionStepResult,
+	): ExecutionPlan | null | Promise<ExecutionPlan | null>;
 }
 export interface ExecutionPlanResult {
 	planHash: string;
@@ -164,11 +180,19 @@ function isWorkspaceMutator(step: ExecutionPlanStep): boolean {
 	return step.verification !== true && step.commitFrom === undefined;
 }
 
+/** A token writer either declares a non-empty agent boundary or may mutate workspace state. */
+function isExecutionPlanWriter(step: ExecutionPlanStep): boolean {
+	if (step.kind === "agent" && (step.writes?.length ?? 0) > 0) return true;
+	return isWorkspaceMutator(step);
+}
+
 export async function executePlan(
-	plan: ExecutionPlan,
+	initialPlan: ExecutionPlan,
 	adapter: ExecutionSchedulerAdapter,
 	signal?: AbortSignal,
 ): Promise<ExecutionPlanResult> {
+	let plan = initialPlan;
+	const replayed = adapter.replayed ?? new Map<string, ExecutionStepResult>();
 	const stepsById = new Map(plan.steps.map((step) => [step.id, step]));
 	const loopsById = new Map(plan.loops.map((loop) => [loop.id, loop]));
 	const agentSteps: ExecutionPlanAgentStep[] = [];
@@ -182,7 +206,7 @@ export async function executePlan(
 		if (step.approvedAuthority === null || step.approvedAuthority !== step.requestedAuthority) {
 			throw new Error(`execution plan: step '${step.id}' lacks its requested authority grant`);
 		}
-		agentSteps.push(step);
+		if (!replayed.has(step.id)) agentSteps.push(step);
 	}
 	for (const loop of plan.loops) {
 		if (loop.checkKind === "agent" && adapter.decideLoop === undefined) {
@@ -205,6 +229,8 @@ export async function executePlan(
 	if (ledgerId !== null) await openAgentLedger(ledgerId);
 	const admissions = agentSteps.map((step) => adapter.preflight(step));
 	const reservation = adapter.reserve(plan, admissions);
+	const reservationOwners = new Set([reservation.ownerId]);
+	const reservationByStep = new Map(agentSteps.map((step) => [step.id, reservation.ownerId]));
 	const results = new Map<string, ExecutionStepResult>();
 	const skipped = new Set<string>();
 	const unneeded = new Set<string>();
@@ -232,7 +258,7 @@ export async function executePlan(
 		stopped = true;
 		for (const owned of running.values()) if (owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
 		codeAbort.abort();
-		adapter.releaseUnconsumed(reservation.ownerId);
+		for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
 	};
 	signal?.addEventListener("abort", cancelOwned, { once: true });
 
@@ -247,6 +273,42 @@ export async function executePlan(
 		results.set(step.id, result);
 		if (isWorkspaceMutator(step)) lastMutationSeq = sequence;
 	};
+	for (const step of plan.steps) {
+		const result = replayed.get(step.id);
+		if (result === undefined) continue;
+		if (!result.succeeded || !result.integrityValid) {
+			throw new Error(`execution plan: replayed step '${step.id}' is not a completed successful step`);
+		}
+		recordCompletion(step, result);
+		if (step.loop?.role === "check" && step.kind === "code") {
+			checkPassed.set(step.id, result.succeeded);
+			attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
+		}
+		if (step.loop?.role === "check" && step.kind === "agent") {
+			const loop = loopsById.get(step.loop.loopId);
+			const decide = adapter.decideLoop;
+			if (loop === undefined || decide === undefined) {
+				throw new Error(`execution plan: replayed loop check '${step.id}' has no decider`);
+			}
+			const decision = await decide({
+				loop,
+				step,
+				attempt: step.loop.attempt,
+				terminalAttempt: step.loop.attempt >= loop.maxAttempts,
+				result,
+				priorResults: results,
+			});
+			checkPassed.set(step.id, decision.resolved);
+			attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
+			if (decision.findings !== null) loopFindings.set(`${loop.id}:${step.loop.attempt}`, decision.findings);
+			if (decision.needsDecision !== undefined && decision.needsDecision !== null) {
+				needsDecision.push(decision.needsDecision);
+			}
+		}
+		if (step.loop?.role === "repair") {
+			repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
+		}
+	}
 
 	/**
 	 * A failed predecessor normally disqualifies its dependents. Two deliberate
@@ -408,7 +470,7 @@ export async function executePlan(
 				if (plan.onFailure === "stop") {
 					stopped = true;
 					codeAbort.abort();
-					adapter.releaseUnconsumed(reservation.ownerId);
+					for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
 					halt = true;
 				}
 			}
@@ -479,12 +541,16 @@ export async function executePlan(
 		});
 
 	try {
-		for (const [waveIndex, wave] of plan.waves.entries()) {
+		let waveIndex = 0;
+		while (waveIndex < plan.waves.length) {
+			const wave = plan.waves[waveIndex];
+			if (wave === undefined) break;
 			if (stopped || signal?.aborted) break;
 			if (await revalidateFor(wave)) break;
 			const admitted = wave.flatMap((id) => {
 				const step = stepsById.get(id);
 				if (!step) throw new Error(`execution plan: unknown scheduled step '${id}'`);
+				if (results.has(id)) return [];
 				if (isUnneeded(step)) {
 					unneeded.add(step.id);
 					return [];
@@ -495,72 +561,122 @@ export async function executePlan(
 				}
 				return [{ step, handoffs: handoffsFor(step) }];
 			});
-			const launch = admitted.filter(
-				(entry): entry is { step: ExecutionPlanAgentStep; handoffs: ExecutionHandoff[] } => entry.step.kind === "agent",
-			);
-			const codeWork = admitted.filter(
-				(entry): entry is { step: ExecutionPlanCodeStep; handoffs: ExecutionHandoff[] } => entry.step.kind === "code",
-			);
-			const boundaryWindow = `wave-${waveIndex}`;
-			const enforced = openBoundary(
-				boundaryWindow,
-				admitted.map((entry) => entry.step),
-			);
-			const started = await Promise.all(
-				launch.map(async ({ step, handoffs }) => ({
-					step,
-					handle: await adapter.run(step, handoffs, { ownerId: reservation.ownerId, memberId: step.id }, ledger),
-				})),
-			);
-			for (const { step, handle } of started) running.set(step.id, { assignmentId: handle.assignmentId });
-			const onSettled = (step: ExecutionPlanStep, result: ExecutionStepResult): void => {
-				if (isPlanFailure(step, result) && plan.onFailure === "stop") {
-					stopped = true;
-					for (const [runningStepId, owned] of running) {
-						if (runningStepId !== step.id && owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
+			const admissionGroups: Array<typeof admitted> = [];
+			if (plan.writers === 1) {
+				const readers = admitted.filter(({ step }) => !isExecutionPlanWriter(step));
+				const writers = admitted.filter(({ step }) => isExecutionPlanWriter(step));
+				if (writers.length === 0) admissionGroups.push(readers);
+				else {
+					admissionGroups.push([...readers, ...(writers[0] === undefined ? [] : [writers[0]])]);
+					for (const writer of writers.slice(1)) admissionGroups.push([writer]);
+				}
+			} else admissionGroups.push(admitted);
+			for (const [groupIndex, group] of admissionGroups.entries()) {
+				if (stopped || signal?.aborted) break;
+				const launch = group.filter(
+					(entry): entry is { step: ExecutionPlanAgentStep; handoffs: ExecutionHandoff[] } => entry.step.kind === "agent",
+				);
+				const codeWork = group.filter(
+					(entry): entry is { step: ExecutionPlanCodeStep; handoffs: ExecutionHandoff[] } => entry.step.kind === "code",
+				);
+				const boundaryWindow = groupIndex === 0 ? `wave-${waveIndex}` : `wave-${waveIndex}-writer-${groupIndex + 1}`;
+				const enforced = openBoundary(
+					boundaryWindow,
+					group.map((entry) => entry.step),
+				);
+				const started = await Promise.all(
+					launch.map(async ({ step, handoffs }) => ({
+						step,
+						handle: await adapter.run(
+							step,
+							handoffs,
+							{ ownerId: reservationByStep.get(step.id) ?? reservation.ownerId, memberId: step.id },
+							ledger,
+						),
+					})),
+				);
+				for (const { step, handle } of started) running.set(step.id, { assignmentId: handle.assignmentId });
+				const onSettled = (step: ExecutionPlanStep, result: ExecutionStepResult): void => {
+					if (isPlanFailure(step, result) && plan.onFailure === "stop") {
+						stopped = true;
+						for (const [runningStepId, owned] of running) {
+							if (runningStepId !== step.id && owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
+						}
+						codeAbort.abort();
+						for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
 					}
-					codeAbort.abort();
-					adapter.releaseUnconsumed(reservation.ownerId);
+				};
+				const ran = await Promise.all([
+					...started.map(async ({ step, handle }) => {
+						const result = await handle.result;
+						onSettled(step, result);
+						return { step: step as ExecutionPlanStep, result };
+					}),
+					...codeWork.map(async ({ step, handoffs }) => {
+						const result = await runCodeStepNode(step, handoffs);
+						onSettled(step, result);
+						return { step: step as ExecutionPlanStep, result };
+					}),
+				]);
+				// The boundary is settled before anything is recorded or handed on, so
+				// a rolled-back step never appears upstream of the work it would have
+				// contaminated.
+				const settled = await closeBoundary(boundaryWindow, enforced, ran);
+				for (const { step, result } of settled) {
+					running.set(step.id, { assignmentId: result.assignmentId });
+					recordCompletion(step, result);
+					await adapter.onStepSettled?.(step, result);
+					if (step.loop?.role === "repair") {
+						repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
+					}
+					running.delete(step.id);
 				}
-			};
-			const ran = await Promise.all([
-				...started.map(async ({ step, handle }) => {
-					const result = await handle.result;
-					onSettled(step, result);
-					return { step: step as ExecutionPlanStep, result };
-				}),
-				...codeWork.map(async ({ step, handoffs }) => {
-					const result = await runCodeStepNode(step, handoffs);
-					onSettled(step, result);
-					return { step: step as ExecutionPlanStep, result };
-				}),
-			]);
-			// The boundary is settled before anything is recorded or handed on, so
-			// a rolled-back step never appears upstream of the work it would have
-			// contaminated.
-			const settled = await closeBoundary(boundaryWindow, enforced, ran);
-			for (const { step, result } of settled) {
-				running.set(step.id, { assignmentId: result.assignmentId });
-				recordCompletion(step, result);
-				if (step.loop?.role === "repair") {
-					repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
+				// Loop continuation is decided after the wave settles, so a gate's
+				// verdict is read from a sealed result rather than from a live stream.
+				for (const { step, result } of settled) await settleCheck(step, result);
+				// A loop that spent its last attempt without converging ends the run
+				// under a stop policy, whether the verdict came from an exit code or
+				// from a gate that answered "no" perfectly well.
+				const exhausted = settled.some(({ step }) => {
+					const loop = step.loop?.role === "check" ? loopOf(step) : null;
+					return loop !== null && step.loop !== undefined && step.loop.attempt >= loop.maxAttempts && !loopResolved(loop);
+				});
+				if ((exhausted || settled.some(({ step, result }) => isPlanFailure(step, result))) && plan.onFailure === "stop") {
+					stopped = true;
+					for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
 				}
-				running.delete(step.id);
 			}
-			// Loop continuation is decided after the wave settles, so a gate's
-			// verdict is read from a sealed result rather than from a live stream.
-			for (const { step, result } of settled) await settleCheck(step, result);
-			// A loop that spent its last attempt without converging ends the run
-			// under a stop policy, whether the verdict came from an exit code or
-			// from a gate that answered "no" perfectly well.
-			const exhausted = settled.some(({ step }) => {
-				const loop = step.loop?.role === "check" ? loopOf(step) : null;
-				return loop !== null && step.loop !== undefined && step.loop.attempt >= loop.maxAttempts && !loopResolved(loop);
-			});
-			if ((exhausted || settled.some(({ step, result }) => isPlanFailure(step, result))) && plan.onFailure === "stop") {
-				stopped = true;
-				adapter.releaseUnconsumed(reservation.ownerId);
+			if (!stopped && adapter.spliceAfter !== undefined) {
+				for (const stepId of wave) {
+					const step = stepsById.get(stepId);
+					const settled = results.get(stepId);
+					if (
+						step?.kind !== "agent" ||
+						step.plan === undefined ||
+						settled === undefined ||
+						!settled.succeeded ||
+						!settled.integrityValid
+					) {
+						continue;
+					}
+					const spliced = await adapter.spliceAfter(plan, step, settled);
+					if (spliced === null) continue;
+					const previousIds = new Set(plan.steps.map((entry) => entry.id));
+					const additions = spliced.steps.filter((entry) => !previousIds.has(entry.id));
+					for (const addition of additions) stepsById.set(addition.id, addition);
+					const newAgentSteps = additions.filter(
+						(addition): addition is ExecutionPlanAgentStep => addition.kind === "agent",
+					);
+					if (newAgentSteps.length > 0) {
+						const newAdmissions = newAgentSteps.map((addition) => adapter.preflight(addition));
+						const additionalReservation = adapter.reserve(spliced, newAdmissions);
+						reservationOwners.add(additionalReservation.ownerId);
+						for (const addition of newAgentSteps) reservationByStep.set(addition.id, additionalReservation.ownerId);
+					}
+					plan = spliced;
+				}
 			}
+			waveIndex += 1;
 		}
 		return {
 			planHash: plan.hash,
@@ -577,7 +693,7 @@ export async function executePlan(
 		throw error;
 	} finally {
 		signal?.removeEventListener("abort", cancelOwned);
-		adapter.release(reservation.ownerId);
+		for (const ownerId of reservationOwners) adapter.release(ownerId);
 		if (ledgerId !== null) await closeAgentLedger(ledgerId);
 	}
 }