@iowarp/clio-coder 0.3.7 → 0.3.9

package/src/domains/dispatch/contract.ts

@@ -13,6 +13,7 @@ import type { ApprovedAssignmentRoute } from "./route-approval.js";
 import type { RouteDecisionV1 } from "./route-decision.js";
 import type { RunEnvelope, RunLineage, RunNodeIdentity, RunPhaseDurations, RunReceipt, RunStatus } from "./types.js";
 import type { DispatchFailoverCandidate, JobSpec } from "./validation.js";
+import type { WriteBoundaryAttribution } from "./write-boundary.js";
 
 export interface DispatchRequest extends JobSpec {
 	/** Coordinator-owned result contract override for a fleet plan step. */
@@ -93,6 +94,8 @@ export interface DispatchPlanTaskResolution {
 	targetId: string;
 	wireModelId: string;
 	runtimeId: string;
+	/** Canonical inference scheduler identity and its independent request-slot bound. */
+	endpoint?: { key: string; label: string; limit: number };
 	node: RunNodeIdentity;
 	/** Effective thinking control for this route; null when the runtime has none. */
 	thinkingLevel: string | null;
@@ -209,6 +212,7 @@ export interface DispatchContract {
 			topology: ReservationTopology;
 			tasks: ReadonlyArray<{ memberId: string; wave: number; resolution: DispatchPlanTaskResolution }>;
 		}): DispatchReservationRecord;
+		release(ownerId: string): DispatchReservationRecord | null;
 		rollback(ownerId: string): DispatchReservationRecord | null;
 		rollbackUnconsumed(ownerId: string): DispatchReservationRecord | null;
 		get(ownerId: string): DispatchReservationRecord | null;
@@ -240,7 +244,7 @@ export interface DispatchContract {
 	sealCouncilSynthesis?(input: {
 		group: string;
 		round: number;
-		kind: "none" | "vote";
+		kind: "none" | "vote" | "judge";
 		text: string;
 		subjects: ReadonlyArray<{ runId: string; digest: string | null }>;
 		template: RunReceipt;
@@ -252,6 +256,27 @@ export interface DispatchContract {
 	/** Get a specific immutable attempt envelope. */
 	getRun(runId: string): RunEnvelope | null;
 
+	/**
+	 * Absolute paths this run's own successful tool calls aimed a mutation at,
+	 * or null when the run kept no usable record: an unknown or evicted run, a
+	 * runtime that publishes no tool telemetry, telemetry that came back
+	 * incomplete, or a run that called a tool able to write a path its arguments
+	 * do not name. Null is not an empty list, and a caller that cannot tell them
+	 * apart will read "wrote nothing" off a run nobody watched.
+	 *
+	 * The write boundary reads this to separate what a step changed from what
+	 * changed under it, so the answer must stay a record of observation rather
+	 * than an inference from the checkout.
+	 */
+	observedRunWrites?(runId: string): ReadonlyArray<string> | null;
+
+	/**
+	 * Full write-record witness, including durable downgrade causes. New callers
+	 * use this surface; observedRunWrites remains as the closed-list compatibility
+	 * view for integrations that only know paths or null.
+	 */
+	observedRunWriteAttribution?(runId: string): WriteBoundaryAttribution | null;
+
 	/** In-memory logical assignment state and complete finalized-attempt history. */
 	readonly assignments?: {
 		/** Live assignment, including its terminal promise and detailed attempt refs. */

package/src/domains/dispatch/delegation-plan.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { pathBoundaryCovers } from "../../core/path-boundary.js";
 import { normalizeWriteBoundary } from "../agents/write-boundary.js";
 
 export type DelegationTaskMode = "sequential" | "parallel";
@@ -54,10 +55,6 @@ export function buildDelegationProposalBriefing(proposals: ReadonlyArray<{ agent
 
 const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
 
-function insideBoundary(path: string, boundary: ReadonlyArray<string>): boolean {
-	return boundary.some((root) => (root.endsWith("/") ? path.startsWith(root) : path === root));
-}
-
 function malformed(detail: string): DelegationPlanValidation {
 	return { ok: false, reason: "delegation_plan_malformed", detail };
 }
@@ -116,7 +113,7 @@ export function validateDelegationPlan(input: ValidateDelegationPlanInput): Dele
 		} catch (error) {
 			return malformed(`task '${task.id}' has invalid writes: ${error instanceof Error ? error.message : String(error)}`);
 		}
-		const outside = writes.find((path) => !insideBoundary(path, input.writes));
+		const outside = writes.find((path) => !pathBoundaryCovers(input.writes, path));
 		if (outside !== undefined) {
 			return {
 				ok: false,

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

@@ -59,6 +59,8 @@ export interface ExecutionPlanAgentStep {
 	/** Exact per-step route defaults from a version 5 fleet contract. */
 	target?: string;
 	profile?: string;
+	/** Resolved inference scheduler bound used when waves are packed. */
+	endpoint?: { key: string; limit: number; foregroundHeld?: number };
 	/** Version 5 gate authoring and baseline execution facts. */
 	gate?: { path: string; commandId: string };
 	/** Version 5 dynamic planning facts. */
@@ -163,7 +165,12 @@ function canonicalSteps(steps: ReadonlyArray<ExecutionPlanStepInput>): Execution
 }
 
 export function executionPlanWaves(
-	steps: ReadonlyArray<{ id: string; dependencies: ReadonlyArray<string>; kind?: "agent" | "code" }>,
+	steps: ReadonlyArray<{
+		id: string;
+		dependencies: ReadonlyArray<string>;
+		kind?: "agent" | "code";
+		endpoint?: { key: string; limit: number; foregroundHeld?: number };
+	}>,
 	maxWorkers: number,
 ): string[][] {
 	if (!Number.isInteger(maxWorkers) || maxWorkers < 1)
@@ -191,11 +198,24 @@ export function executionPlanWaves(
 		// capacity lease, so they ride the first chunk of their ready set without
 		// displacing an agent step or forcing an extra wave.
 		const codeReady = ready.filter((step) => step.kind === "code").map((step) => step.id);
-		const agentReady = ready.filter((step) => step.kind !== "code").map((step) => step.id);
+		const agentReady = ready.filter((step) => step.kind !== "code");
 		const chunks: string[][] = [];
-		for (let offset = 0; offset < agentReady.length; offset += maxWorkers) {
-			chunks.push(agentReady.slice(offset, offset + maxWorkers));
+		let chunk: string[] = [];
+		let endpointCounts = new Map<string, number>();
+		for (const step of agentReady) {
+			const endpoint = step.endpoint;
+			const endpointLimit =
+				endpoint === undefined ? Number.POSITIVE_INFINITY : Math.max(1, endpoint.limit - (endpoint.foregroundHeld ?? 0));
+			const endpointFull = endpoint !== undefined && (endpointCounts.get(endpoint.key) ?? 0) >= endpointLimit;
+			if (chunk.length >= maxWorkers || endpointFull) {
+				chunks.push(chunk);
+				chunk = [];
+				endpointCounts = new Map<string, number>();
+			}
+			chunk.push(step.id);
+			if (endpoint !== undefined) endpointCounts.set(endpoint.key, (endpointCounts.get(endpoint.key) ?? 0) + 1);
 		}
+		if (chunk.length > 0) chunks.push(chunk);
 		if (chunks.length === 0) chunks.push([]);
 		chunks[0] = [...codeReady, ...(chunks[0] ?? [])];
 		for (const wave of chunks) {
@@ -317,6 +337,26 @@ export function compileExecutionPlan(input: ExecutionPlanInput): ExecutionPlan {
 	return { ...canonical, hash: createHash("sha256").update(JSON.stringify(canonical)).digest("hex") };
 }
 
+/** Recompile one approved graph after route preflight supplies endpoint bounds. */
+export function bindExecutionPlanEndpoints(
+	plan: ExecutionPlan,
+	bindings: Readonly<Record<string, { key: string; limit: number; foregroundHeld?: number } | undefined>>,
+): ExecutionPlan {
+	return compileExecutionPlan({
+		topology: plan.topology,
+		rootTask: plan.rootTask,
+		maxWorkers: plan.maxWorkers,
+		...(plan.writers === 1 ? { writers: 1 as const } : {}),
+		onFailure: plan.onFailure,
+		steps: plan.steps.map((step) => {
+			if (step.kind === "code") return step;
+			const endpoint = bindings[step.id];
+			return endpoint === undefined ? step : { ...step, endpoint: { ...endpoint } };
+		}),
+		loops: plan.loops,
+	});
+}
+
 /** Transitive dependency closure of one plan step. */
 export function executionPlanAncestors(plan: ExecutionPlan, stepId: string): ReadonlySet<string> {
 	const byId = new Map(plan.steps.map((step) => [step.id, step]));

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

@@ -172,9 +172,17 @@ export function gateDeciderAgentId(requested: string | undefined): string {
  * the slot. The gate validates that answer and fails closed on a malformed one,
  * so also enforcing an inapplicable recipe postcondition would fail the run
  * before its verdict could be read.
+ *
+ * `synthesis` is the third decider and belongs here for the same reason.
+ * {@link deriveExecutionRole} already resolves it to the `judge` role, and
+ * `isBoundedGateRolePrompt` admits it only under the council judge prompt,
+ * which asks for `{"verdict","text"}`. A council seats the read-only
+ * `researcher` by default, whose recipe declares `research-report`, so leaving
+ * the recipe postcondition on the slot sealed a contract failure on every
+ * correct synthesis and burned the configured retries reproducing it.
  */
 export function appliesRecipeResultContract(gateRole: GateTopologyRole | undefined): boolean {
-	return gateRole !== "reviewer" && gateRole !== "judge";
+	return gateRole !== "reviewer" && gateRole !== "judge" && gateRole !== "synthesis";
 }
 
 /** The route dimensions a gate correlation is measured across. */