@zq-silk/yui 0.15.7 → 0.15.8

package/dist/core/controllerServer.js

@@ -813,10 +813,9 @@ function safeDispatcherError(error) {
                 }
                 return { code: "SERVICE_ERROR", message };
             }
-            case "RuntimeLaunchStateChangedError":
-                // The launch coordinator already stopped the exact host and bounded
-                // the detail to its currentness/reservation contract. Surface that
-                // actionable diagnosis instead of collapsing it to INTERNAL_ERROR.
+            case "RuntimeLaunchFailure":
+                // Launch errors already carry bounded diagnostics (including redacted
+                // provider output). Preserve them instead of collapsing to INTERNAL_ERROR.
                 return { code: "SERVICE_ERROR", message };
             default:
                 return undefined;
@@ -832,6 +831,7 @@ function safeApplicationErrorCode(code) {
         case "METHOD_NOT_FOUND":
         case "NOT_FOUND":
         case "UNAUTHORIZED":
+        case "SESSION_BUSY":
         case "CONTROLLER_DRAINING":
             return code;
         default:

package/dist/doctor/doctor.js

@@ -424,7 +424,7 @@ function inspectReview(source, agentChecks, environment) {
     checks.push({
         name: "reviewer binding",
         status: "ok",
-        detail: `agent=${binding.agentId} adapter=${binding.adapterId}`
+        detail: `agent=${binding.agentId} component=${binding.component} adapter=${binding.adapterId}`
     });
     const agent = source.agent ?? null;
     if (agent === null) {
@@ -438,8 +438,19 @@ function inspectReview(source, agentChecks, environment) {
     checks.push({
         name: "reviewer agent",
         status: "ok",
-        detail: `id=${agent.id} adapter=${agent.adapterId} command=${agent.command}`
+        detail: `id=${agent.id} component=${agent.component} adapter=${agent.adapterId} command=${agent.command}`
     });
+    // Two products can share one connection plan, so a matching adapter is not
+    // enough: a binding naming the SDK against an Agent recorded as the CLI is a
+    // real mismatch, and launching either one would contradict the other record.
+    if (agent.component !== binding.component) {
+        checks.push({
+            name: "reviewer component",
+            status: "invalid",
+            detail: `binding component=${binding.component} does not match Agent component=${agent.component}.`
+        });
+        return reviewMisconfigured(policy, checks, "Reviewer execution component does not match its Agent binding.", role, agent.id, agent.adapterId, agent.command);
+    }
     if (agent.adapterId !== binding.adapterId) {
         checks.push({
             name: "reviewer adapter",

package/dist/domain/agentResultTransport.js

@@ -1,9 +1,9 @@
-export const MAX_TURN_RESULT_OUTPUT_BYTES = 512 * 1024;
-export const MAX_TURN_FAILURE_DIAGNOSTIC_BYTES = 16 * 1024;
+export const MAX_RUN_RESULT_OUTPUT_BYTES = 512 * 1024;
+export const MAX_RUN_FAILURE_DIAGNOSTIC_BYTES = 16 * 1024;
 /**
  * Validate only the transport envelope of an Agent result. The accepted text
  * remains byte-for-byte unchanged; missing or untransportable text becomes a
- * Core-owned failed outcome so the exact Turn can still terminalize.
+ * Core-owned failed outcome so the exact AgentRun can still terminalize.
  */
 export function transportAgentResult(value) {
     if (typeof value !== "string") {
@@ -28,10 +28,10 @@ export function transportAgentResult(value) {
         };
     }
     const bytes = Buffer.byteLength(value, "utf8");
-    if (bytes > MAX_TURN_RESULT_OUTPUT_BYTES) {
+    if (bytes > MAX_RUN_RESULT_OUTPUT_BYTES) {
         return {
             status: "failed",
-            diagnostic: `Provider Agent result is ${bytes} bytes and exceeds the ${MAX_TURN_RESULT_OUTPUT_BYTES}-byte durable result limit; the result was not stored.`,
+            diagnostic: `Provider Agent result is ${bytes} bytes and exceeds the ${MAX_RUN_RESULT_OUTPUT_BYTES}-byte durable result limit; the result was not stored.`,
             failureReason: "runtime-failed"
         };
     }
@@ -42,19 +42,19 @@ export function transportAgentResult(value) {
  * This is intentionally separate from Agent result transport: successful
  * Agent text is either retained exactly or rejected as a whole, never
  * truncated. Provider/Core diagnostics may be clipped because they are only
- * operational context for a failed Turn.
+ * operational context for a failed AgentRun.
  */
-export function boundedTurnFailureDiagnostic(value, fallback = "Provider reported a failed Agent Turn.") {
+export function boundedRunFailureDiagnostic(value, fallback = "Provider reported a failed Agent AgentRun.") {
     const candidate = typeof value === "string" && value.trim().length > 0
         ? value
         : fallback;
     const safe = candidate.replaceAll("\0", "\uFFFD");
-    if (Buffer.byteLength(safe, "utf8") <= MAX_TURN_FAILURE_DIAGNOSTIC_BYTES) {
+    if (Buffer.byteLength(safe, "utf8") <= MAX_RUN_FAILURE_DIAGNOSTIC_BYTES) {
         return safe;
     }
     const prefix = Buffer
         .from(safe, "utf8")
-        .subarray(0, MAX_TURN_FAILURE_DIAGNOSTIC_BYTES)
+        .subarray(0, MAX_RUN_FAILURE_DIAGNOSTIC_BYTES)
         .toString("utf8");
     return prefix.endsWith("\uFFFD") ? prefix.slice(0, -1) : prefix;
 }

package/dist/execution/codexThreadNaming.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-import { YUI_VERSION } from "../version.js";
+import { codexClientInitialization } from "../runtime/codexAppServerRuntime.js";
 const DEFAULT_TIMEOUT_MS = 1_000;
 export async function setCodexThreadName(request) {
     const timeoutMs = threadNameTimeout(request.timeoutMs);
@@ -42,13 +42,7 @@ class CodexNamingClient {
     static async start(command, environment, baseArgs, timeoutMs) {
         const client = new CodexNamingClient(spawn(command, [...baseArgs, "app-server", "--stdio"], { env: environment, stdio: ["pipe", "pipe", "pipe"] }));
         try {
-            await withTimeout(client.request("initialize", {
-                clientInfo: { name: "yui", title: "Yui", version: YUI_VERSION },
-                capabilities: {
-                    experimentalApi: true,
-                    requestAttestation: false
-                }
-            }), timeoutMs, "Timed out initializing Codex App Server for thread naming.");
+            await withTimeout(client.request("initialize", codexClientInitialization()), timeoutMs, "Timed out initializing Codex App Server for thread naming.");
             client.notify("initialized", {});
             return client;
         }

package/dist/execution/executionHealth.js

@@ -1,4 +1,4 @@
-import { isRoleTurnStalled, latestStallProgressAt } from "../scheduler/roleTurnStall.js";
+import { isRoleRunStalled, latestStallProgressAt } from "../scheduler/roleRunStall.js";
 import { validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
@@ -23,15 +23,15 @@ export function summarizeExecutionGroupHealth(input) {
     const healthByLane = new Map(health.lanes.map((lane) => [lane.laneId, lane]));
     const laneSummaries = input.group.lanes.map((lane) => {
         const projected = healthByLane.get(lane.id);
-        const turn = exactLaneTurn(input, lane);
+        const run = exactLaneRun(input, lane);
         return Object.freeze({
             roleName: lane.roleName,
             ordinal: lane.ordinal,
-            ...(lane.currentTurnId === undefined ? {} : { turnId: lane.currentTurnId }),
-            ...(lane.successfulTurnId === undefined
+            ...(lane.currentRunId === undefined ? {} : { runId: lane.currentRunId }),
+            ...(lane.successfulRunId === undefined
                 ? {}
-                : { successfulTurnId: lane.successfulTurnId }),
-            status: projectedStatus(lane, turn),
+                : { successfulRunId: lane.successfulRunId }),
+            status: projectedStatus(lane, run),
             ...(lane.effective === undefined ? {} : { effective: lane.effective }),
             ...projected
         });
@@ -62,28 +62,28 @@ export function actionableExecutionLaneRecoveries(groups) {
         : [{
                 groupId: group.groupId,
                 laneId: lane.laneId,
-                ...(lane.turnId === undefined ? {} : { turnId: lane.turnId }),
+                ...(lane.runId === undefined ? {} : { runId: lane.runId }),
                 ...(lane.runtimeHealth === undefined ? {} : { runtimeHealth: lane.runtimeHealth }),
                 recovery: "retry-new-turn"
             }]));
 }
 function projectExecutionLaneHealth(lane, input, policy) {
-    const turn = exactLaneTurn(input, lane);
-    const continuationAgentId = turn?.effective.agentId ?? lane.effective?.agentId;
+    const run = exactLaneRun(input, lane);
+    const continuationAgentId = run?.effective.agentId ?? lane.effective?.agentId;
     if (lane.disposition === "open"
-        && lane.currentTurnId !== undefined
+        && lane.currentRunId !== undefined
         && continuationAgentId !== undefined
         && runOwnsBlockingProviderContinuation(input.events, {
             taskId: input.group.taskId,
             roleName: lane.roleName,
-            turnId: lane.currentTurnId,
+            runId: lane.currentRunId,
             agentId: continuationAgentId
         })) {
         return projection(lane, {
             runtimeHealth: "active",
             recovery: "none",
             resultReusable: false,
-            reason: "the exact Turn still owns an unsettled Provider continuation writer",
+            reason: "the exact AgentRun still owns an unsettled Provider continuation writer",
             evidence: ["runtime-continuation-writer-owned"]
         });
     }
@@ -104,7 +104,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: ["execution-lane-settled-failure"]
         });
     }
-    if (lane.currentTurnId === undefined) {
+    if (lane.currentRunId === undefined) {
         return projection(lane, {
             recovery: "none",
             resultReusable: false,
@@ -112,38 +112,38 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: []
         });
     }
-    if (turn === undefined) {
+    if (run === undefined) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the open Lane has no exact current Turn",
+            reason: "the open Lane has no exact current AgentRun",
             evidence: ["execution-lineage-missing"]
         });
     }
-    if (turn.status === "failed") {
+    if (run.status === "failed") {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
             recovery: "retry-new-turn",
             resultReusable: false,
-            reason: "the exact current Turn is durably failed",
+            reason: "the exact current AgentRun is durably failed",
             evidence: ["turn-terminal-failure"]
         });
     }
-    if (turn.status === "completed") {
+    if (run.status === "completed") {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the current Turn completed without settling its logical Lane",
+            reason: "the current AgentRun completed without settling its logical Lane",
             evidence: ["execution-lineage-inconsistent"]
         });
     }
-    const session = input.sessions.find((candidate) => (candidate.roleName === turn.roleName
-        && candidate.agentId === turn.effective.agentId
-        && candidate.adapterId === turn.effective.adapterId));
-    const observations = exactTurnObservations(input.events, turn, session);
-    const runtime = runtimeProjection(observations, input.events, turn);
+    const session = input.sessions.find((candidate) => (candidate.roleName === run.roleName
+        && candidate.agentId === run.effective.agentId
+        && candidate.adapterId === run.effective.adapterId));
+    const observations = exactRunObservations(input.events, run, session);
+    const runtime = runtimeProjection(observations, input.events, run);
     const unsettledContinuation = runtime !== null
         && Object.values(runtime.continuations).some((continuation) => (continuation.execution === "active"
             || continuation.execution === "unknown"
@@ -152,12 +152,12 @@ function projectExecutionLaneHealth(lane, input, policy) {
         && (Object.values(runtime.operations).some(({ kind }) => kind === "subagent")
             || unsettledContinuation);
     if (observations.some((observation) => (observation.kind === "turn.failed"
-        && observation.payload.failure?.turnTerminal === true)) && !unsettledChildWork) {
+        && observation.payload.failure?.runTerminal === true)) && !unsettledChildWork) {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the Provider reported an exact Turn-terminal failure",
+            reason: "the Provider reported an exact AgentRun-terminal failure",
             evidence: ["provider-turn-terminal"]
         });
     }
@@ -178,7 +178,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: runtimeTerminalEvidence
         });
     }
-    const exit = latestExactProcessExit(input.events, turn, session);
+    const exit = latestExactProcessExit(input.events, run, session);
     if (session?.status === "ended"
         && exit !== null
         && isAbnormalExit(exit.classification)
@@ -191,20 +191,20 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: ["native-session-terminal", `process-exit:${exit.classification}`]
         });
     }
-    if (isRoleTurnStalled(input.events, turn.id)) {
+    if (isRoleRunStalled(input.events, run.id)) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: `the durable progress clock has not advanced since ${latestStallProgressAt(input.events, turn.id) ?? turn.updatedAt}; no death proof exists`,
+            reason: `the durable progress clock has not advanced since ${latestStallProgressAt(input.events, run.id) ?? run.updatedAt}; no death proof exists`,
             evidence: ["turn-stalled"]
         });
     }
     const activeOperation = runtime !== null
         && (Object.keys(runtime.operations).length > 0 || unsettledContinuation);
     const lastActivityAt = runtime?.lastRuntimeActivityAt
-        ?? turn.updatedAt
-        ?? turn.createdAt;
+        ?? run.updatedAt
+        ?? run.createdAt;
     const recentActivity = input.now.getTime() - Date.parse(lastActivityAt) < policy.quietAfterMs;
     if (activeOperation || recentActivity) {
         return projection(lane, {
@@ -215,7 +215,7 @@ function projectExecutionLaneHealth(lane, input, policy) {
                 ? "the exact runtime reports unsettled continuation work"
                 : activeOperation
                     ? "the exact runtime reports an active operation"
-                    : "the exact Turn has recent structured runtime activity",
+                    : "the exact AgentRun has recent structured runtime activity",
             evidence: unsettledContinuation
                 ? ["runtime-continuation-unsettled"]
                 : activeOperation
@@ -227,48 +227,36 @@ function projectExecutionLaneHealth(lane, input, policy) {
         runtimeHealth: "silent",
         recovery: "none",
         resultReusable: false,
-        reason: "the exact Turn remains active without recent structured activity; silence alone is not death",
+        reason: "the exact AgentRun remains active without recent structured activity; silence alone is not death",
         evidence: ["turn-active"]
     });
 }
-function exactLaneTurn(input, lane) {
-    return lane.currentTurnId === undefined
+function exactLaneRun(input, lane) {
+    return lane.currentRunId === undefined
         ? undefined
-        : input.turns.find((turn) => (turn.taskId === input.group.taskId
-            && turn.id === lane.currentTurnId
-            && turn.executionGroupId === input.group.id
-            && turn.executionLaneId === lane.id
-            && turn.roleName === lane.roleName));
+        : input.runs.find((run) => (run.taskId === input.group.taskId
+            && run.id === lane.currentRunId
+            && run.executionGroupId === input.group.id
+            && run.executionLaneId === lane.id
+            && run.roleName === lane.roleName));
 }
-function exactTurnObservations(events, turn, session) {
+function exactRunObservations(events, run, session) {
     return events.map(runtimeObservationFromTaskEvent)
-        .filter((observation) => (observation !== null
-        && observation.fence.taskId === turn.taskId
-        && observation.fence.turnId === turn.id
-        && observation.fence.roleName === turn.roleName
-        && observation.fence.agentId === turn.effective.agentId
-        && (session?.runtimeGenerationId === undefined || observation.fence.runtimeGenerationId === session.runtimeGenerationId)
-        && (session?.nativeSessionId === undefined
-            || observation.fence.nativeSessionId === session.nativeSessionId)));
+        .filter((observation) => (observation !== null && observation.fence.taskId === run.taskId && observation.fence.runId === run.id && observation.fence.roleName === run.roleName && observation.fence.agentId === run.effective.agentId && (session?.nativeSessionId === undefined || observation.fence.nativeSessionId === session.nativeSessionId)));
 }
-function runtimeProjection(observations, events, turn) {
+function runtimeProjection(observations, events, run) {
     const first = observations[0];
     return first === undefined
         ? null
-        : projectRuntimeTaskEvents(first.fence, turn.createdAt, events);
+        : projectRuntimeTaskEvents(first.fence, run.createdAt, events);
 }
-function latestExactProcessExit(events, turn, session) {
+function latestExactProcessExit(events, run, session) {
     const matching = events.flatMap((event) => {
         if (event.type !== "runtime.process-exit-observed")
             return [];
         try {
             const observation = validateRuntimeProcessExitObservation(JSON.parse(event.payload.observation ?? ""));
-            if (observation.taskId !== turn.taskId
-                || observation.turnId !== turn.id
-                || observation.roleName !== turn.roleName
-                || (session?.runtimeGenerationId !== undefined && observation.runtimeGenerationId !== session.runtimeGenerationId)
-                || (session?.nativeSessionId !== undefined
-                    && observation.nativeSessionId !== session.nativeSessionId))
+            if (observation.taskId !== run.taskId || observation.runId !== run.id || observation.roleName !== run.roleName || (session?.nativeSessionId !== undefined && observation.nativeSessionId !== session.nativeSessionId))
                 return [];
             return [{
                     observation,
@@ -284,18 +272,18 @@ function latestExactProcessExit(events, turn, session) {
 function isAbnormalExit(classification) {
     return classification === "host-abnormal" || classification === "provider-turn-failed";
 }
-function projectedStatus(lane, turn) {
+function projectedStatus(lane, run) {
     if (lane.disposition === "succeeded")
         return "succeeded";
     if (lane.disposition === "failed")
         return "failed";
-    if (lane.currentTurnId === undefined)
+    if (lane.currentRunId === undefined)
         return "pending";
-    if (turn === undefined)
+    if (run === undefined)
         return "unknown";
-    if (turn.status === "active")
+    if (run.status === "active")
         return "running";
-    if (turn.status === "failed")
+    if (run.status === "failed")
         return "needs-attention";
     return "unknown";
 }

package/dist/execution/reviewMainRun.js

@@ -0,0 +1,137 @@
+import { enqueueRoleRunDispatch } from "../coordination/workMailboxQueue.js";
+import { createRunInput } from "../context/runInputContract.js";
+import { contextSnapshotDeltaRefIds, freezeRunContextSnapshot } from "../context/runContextPack.js";
+import { contextSnapshotRef } from "../context/contextSnapshot.js";
+import { roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
+import { resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
+import { createTaskEvent } from "../event/taskEvent.js";
+import { startReviewRound } from "../review/reviewRound.js";
+import { createRun } from "../agentRun/agentRun.js";
+export function selectedReviewSynthesisProducers(store, round, group, sourceRunIds) {
+    if (sourceRunIds.length === 0 || new Set(sourceRunIds).size !== sourceRunIds.length) {
+        throw new Error("Synthesis requires explicit, distinct source AgentRun references.");
+    }
+    return sourceRunIds.map((runId) => {
+        const run = store.getRun(round.taskId, runId);
+        const lane = group.lanes.find(({ id }) => id === run?.executionLaneId);
+        if (run === null
+            || lane === undefined
+            || !["completed", "failed"].includes(run.status)
+            || run.purpose !== "review"
+            || run.reviewRoundId !== round.id
+            || run.executionGroupId !== group.id
+            || run.executionLaneId !== lane.id
+            || run.roleName !== lane.roleName
+            || run.result === undefined) {
+            throw new Error(`Synthesis source is not an exact terminal Review Producer result: `
+                + `${group.id}/${runId}.`);
+        }
+        return {
+            laneId: lane.id,
+            roleName: lane.roleName,
+            runId: run.id
+        };
+    });
+}
+/** Called within the caller's transaction after Task authority is checked. */
+export function dispatchReviewSynthesis(store, taskId, reviewRoundId, sourceRunIds, now) {
+    const task = store.getTask(taskId);
+    if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
+        throw new Error(`Task execution is not enabled: ${taskId}.`);
+    }
+    const round = store.getReviewRound(taskId, reviewRoundId);
+    if (round === null || round.status !== "running") {
+        throw new Error(`ReviewRound is not running: ${taskId}/${reviewRoundId}.`);
+    }
+    const group = round.executionGroup;
+    if (group === undefined)
+        throw new Error(`ReviewRound has no ExecutionGroup: ${round.id}.`);
+    const producers = selectedReviewSynthesisProducers(store, round, group, sourceRunIds);
+    const existing = store.listRuns(taskId).filter((run) => (run.purpose === "review"
+        && run.reviewRoundId === round.id
+        && run.sourceExecutionGroupId === group.id));
+    if (existing.length > 0 || round.reviewerRunId !== undefined) {
+        throw new Error(`Synthesis already exists for ${group.id}; retry its AgentRun explicitly.`);
+    }
+    const role = store.getRole(taskId, round.reviewerRoleName);
+    if (role === null) {
+        throw new Error(`Review main Role is missing: ${taskId}/${round.reviewerRoleName}.`);
+    }
+    if (store.getActiveRun(taskId, role.name) !== null) {
+        throw new Error(`Review main Role already has an active AgentRun: ${role.name}.`);
+    }
+    const workspace = store.getReviewRoundWorkspace(taskId, round.id);
+    if (workspace === null) {
+        throw new Error(`Review main workspace is missing: ${taskId}/${round.id}.`);
+    }
+    const effective = resolveEffectiveLaunch({
+        role,
+        purpose: "review",
+        workspace,
+        reviewRoundId: round.id,
+        reviewBaseCommit: round.reviewBaseCommit
+    });
+    const snapshot = freezeRunContextSnapshot(store, {
+        taskId,
+        roleName: role.name,
+        purpose: "review",
+        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+        reviewRoundId: round.id,
+        sourceExecutionGroupId: group.id,
+        workspace
+    }, now, "leader", group.assignment.contextSnapshotRef, sourceRunIds);
+    const run = createRun(store.nextRunId(taskId), taskId, role.name, roleAgentSessionResumeMode(store.getTaskRoleSessionSet(taskId, role.name), effective.agentId, effective), createRunInput({
+        source: {
+            type: "yui",
+            channel: round.workItemId === undefined ? "task-dispatch" : "workitem-dispatch"
+        },
+        directive: synthesisDirective(group, producers),
+        contextSnapshotRef: contextSnapshotRef(snapshot),
+        deltaRefIds: contextSnapshotDeltaRefIds(store, snapshot)
+    }), now, {
+        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+        purpose: "review",
+        reviewRoundId: round.id,
+        sourceExecutionGroupId: group.id,
+        workspace,
+        effective
+    });
+    store.saveRun(run);
+    store.saveReviewRound(taskId, startReviewRound(round, run.id));
+    store.saveActiveRun(run);
+    enqueueRoleRunDispatch(store, {
+        taskId,
+        roleName: role.name,
+        runId: run.id,
+        reason: "review-synthesis-ready",
+        occurredAt: now
+    });
+    store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "run.review-dispatched", {
+        runId: run.id,
+        role: run.roleName,
+        purpose: run.purpose,
+        mode: run.mode,
+        agent: `${run.effective.agentId}/${run.effective.adapterId}`,
+        component: run.effective.component,
+        effectiveRevision: String(run.effective.sourceDesiredRevision),
+        profileAccess: run.effective.profileAccess,
+        effectivePermission: run.effective.permission.strategy,
+        writeProjectIds: run.effective.writeProjectIds.join(",") || "none",
+        reviewRoundId: round.id,
+        sourceExecutionGroupId: group.id
+    }, now));
+    return run;
+}
+function synthesisDirective(group, producers) {
+    return [
+        "Act as the main Reviewer over the explicitly selected Producer results in the supplied order.",
+        "Expand each exact source AgentRun from the frozen Context Snapshot and consume its original result text plus Core-authored system evidence.",
+        "Resolve disagreements through review judgment against the frozen candidate. Do not rerun, retry, append, select, or abandon Lanes.",
+        "Return one complete original review result for the Leader; Yui Core does not parse or validate its semantic structure.",
+        JSON.stringify({
+            schemaVersion: 1,
+            sourceExecutionGroupId: group.id,
+            producers
+        }, null, 2)
+    ].join("\n\n");
+}