@zq-silk/yui 0.14.0 → 0.14.2

package/dist/execution/executionHealth.js

@@ -4,13 +4,6 @@ import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.j
 import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
 import { DEFAULT_RUNTIME_HEALTH_POLICY } from "../runtime/runtimeHealthPolicy.js";
 import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
-import { summarizeExecutionGroup } from "./executionGroup.js";
-import { executionStageSpendClosed, observedExecutionResourceUsage, projectExecutionStageResources } from "./resourceBroker.js";
-/**
- * Fold existing Turn, runtime, Session, process-exit, and stall facts into the
- * four Lane health states. This is a read model only: it never advances a
- * Lane, terminalizes a Turn, or guesses that silence means death.
- */
 export function projectExecutionGroupHealth(input) {
     const policy = input.policy ?? DEFAULT_RUNTIME_HEALTH_POLICY;
     const lanes = input.group.lanes.map((lane) => projectExecutionLaneHealth(lane, input, policy));
@@ -21,79 +14,69 @@ export function projectExecutionGroupHealth(input) {
         silentLaneCount: countHealth(lanes, "silent"),
         suspectedStalledLaneCount: countHealth(lanes, "suspected-stalled"),
         confirmedDeadLaneCount: countHealth(lanes, "confirmed-dead"),
-        reusableLaneIds: lanes.filter(({ resultReusable }) => resultReusable)
-            .map(({ laneId }) => laneId),
-        retryableLaneIds: lanes.filter(({ recovery }) => recovery === "retry-new-turn")
-            .map(({ laneId }) => laneId)
+        reusableLaneIds: lanes.filter(({ resultReusable }) => resultReusable).map(({ laneId }) => laneId),
+        retryableLaneIds: lanes.filter(({ recovery }) => recovery === "retry-new-turn").map(({ laneId }) => laneId)
     });
 }
-/** Structural Group summary plus the health/recovery projection used by CLI/Web reads. */
 export function summarizeExecutionGroupHealth(input) {
-    const summary = summarizeExecutionGroup(input.group);
-    const projection = projectExecutionGroupHealth(input);
-    const resources = input.group.stage === undefined
-        ? undefined
-        : projectExecutionStageResources({
-            group: input.group,
-            ...(input.stageGroups === undefined ? {} : { stageGroups: input.stageGroups }),
-            usage: observedExecutionResourceUsage({
-                group: input.group,
-                ...(input.stageGroups === undefined ? {} : { stageGroups: input.stageGroups }),
-                turns: input.turns,
-                events: input.events
-            }),
-            now: input.now
+    const health = projectExecutionGroupHealth(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);
+        return Object.freeze({
+            roleName: lane.roleName,
+            ordinal: lane.ordinal,
+            ...(lane.currentTurnId === undefined ? {} : { turnId: lane.currentTurnId }),
+            ...(lane.successfulTurnId === undefined
+                ? {}
+                : { successfulTurnId: lane.successfulTurnId }),
+            status: projectedStatus(lane, turn),
+            ...(lane.effective === undefined ? {} : { effective: lane.effective }),
+            ...projected
         });
-    const healthByLane = new Map(projection.lanes.map((lane) => [lane.laneId, lane]));
+    });
     return Object.freeze({
-        ...summary,
-        laneSummaries: summary.laneSummaries.map((lane) => Object.freeze({
-            ...lane,
-            ...healthByLane.get(lane.laneId)
-        })),
+        groupId: input.group.id,
+        purpose: "reviewRoundId" in input.group.assignment ? "review" : "execution",
+        kind: "replicated",
+        laneCount: input.group.lanes.length,
+        activeLaneCount: laneSummaries.filter(({ status }) => status === "running").length,
+        terminalLaneCount: input.group.lanes.filter(({ disposition }) => disposition !== "open").length,
+        succeededLaneCount: input.group.lanes.filter(({ disposition }) => disposition === "succeeded").length,
+        failedLaneCount: input.group.lanes.filter(({ disposition }) => disposition === "failed").length,
+        laneSummaries,
         health: Object.freeze({
-            activeLaneCount: projection.activeLaneCount,
-            silentLaneCount: projection.silentLaneCount,
-            suspectedStalledLaneCount: projection.suspectedStalledLaneCount,
-            confirmedDeadLaneCount: projection.confirmedDeadLaneCount,
-            reusableLaneIds: projection.reusableLaneIds,
-            retryableLaneIds: projection.retryableLaneIds
-        }),
-        ...(resources === undefined ? {} : { resources })
+            activeLaneCount: health.activeLaneCount,
+            silentLaneCount: health.silentLaneCount,
+            suspectedStalledLaneCount: health.suspectedStalledLaneCount,
+            confirmedDeadLaneCount: health.confirmedDeadLaneCount,
+            reusableLaneIds: health.reusableLaneIds,
+            retryableLaneIds: health.retryableLaneIds
+        })
     });
 }
-/** Unresolved Lane recovery in deterministic operational priority order. */
 export function actionableExecutionLaneRecoveries(groups) {
-    return groups
-        .filter(({ resolution }) => resolution === undefined)
-        .flatMap((group) => group.laneSummaries.flatMap((lane) => {
-        if (lane.recovery === "retry-new-turn"
-            && group.resources !== undefined
-            && executionStageSpendClosed(group.resources))
-            return [];
-        if (lane.recovery !== "retry-new-turn")
-            return [];
-        return [{
+    return groups.flatMap((group) => group.laneSummaries.flatMap((lane) => lane.recovery !== "retry-new-turn"
+        ? []
+        : [{
                 groupId: group.groupId,
                 laneId: lane.laneId,
                 ...(lane.turnId === undefined ? {} : { turnId: lane.turnId }),
                 ...(lane.runtimeHealth === undefined ? {} : { runtimeHealth: lane.runtimeHealth }),
-                recovery: lane.recovery
-            }];
-    }));
+                recovery: "retry-new-turn"
+            }]));
 }
 function projectExecutionLaneHealth(lane, input, policy) {
-    const run = lane.turnId === undefined
-        ? undefined
-        : input.turns.find((candidate) => exactLaneTurn(candidate, input.group, lane));
-    const continuationAgentId = run?.effective.agentId ?? lane.effective?.agentId;
-    if (lane.status !== "completed"
-        && lane.turnId !== undefined
+    const turn = exactLaneTurn(input, lane);
+    const continuationAgentId = turn?.effective.agentId ?? lane.effective?.agentId;
+    if (lane.disposition === "open"
+        && lane.currentTurnId !== undefined
         && continuationAgentId !== undefined
         && runOwnsBlockingProviderContinuation(input.events, {
             taskId: input.group.taskId,
             roleName: lane.roleName,
-            turnId: lane.turnId,
+            turnId: lane.currentTurnId,
             agentId: continuationAgentId
         })) {
         return projection(lane, {
@@ -104,71 +87,63 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: ["runtime-continuation-writer-owned"]
         });
     }
-    if (lane.status === "completed") {
+    if (lane.disposition === "succeeded") {
         return projection(lane, {
             recovery: "reuse-result",
             resultReusable: true,
-            reason: "the terminal Lane result is durable and must be reused",
-            evidence: ["execution-lane-result"]
+            reason: "the successful Producer result is durable and immutable",
+            evidence: ["execution-lane-success"]
         });
     }
-    if (lane.status === "failed") {
+    if (lane.disposition === "failed") {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
-            recovery: "retry-new-turn",
-            resultReusable: false,
-            reason: "the exact Lane attempt is durably failed; a retry must create a new Turn",
-            evidence: ["execution-lane-terminal-failure"]
-        });
-    }
-    if (lane.status === "skipped") {
-        return projection(lane, {
             recovery: "none",
             resultReusable: false,
-            reason: "the Lane was never started after sufficient stage evidence made further spend unnecessary",
-            evidence: ["execution-lane-resource-skip"]
+            reason: "the logical Producer Lane was explicitly settled as failed",
+            evidence: ["execution-lane-settled-failure"]
         });
     }
-    if (lane.status === "pending") {
+    if (lane.currentTurnId === undefined) {
         return projection(lane, {
             recovery: "none",
             resultReusable: false,
-            reason: "the Lane has not started",
+            reason: "the Producer Lane has not been dispatched",
             evidence: []
         });
     }
-    if (run === undefined) {
+    if (turn === undefined) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the running Lane has no exact Turn record",
+            reason: "the open Lane has no exact current Turn",
             evidence: ["execution-lineage-missing"]
         });
     }
-    if (run.status === "failed") {
+    if (turn.status === "failed") {
         return projection(lane, {
             runtimeHealth: "confirmed-dead",
             recovery: "retry-new-turn",
             resultReusable: false,
-            reason: "the exact Turn is durably failed",
+            reason: "the exact current Turn is durably failed",
             evidence: ["turn-terminal-failure"]
         });
     }
-    if (run.status !== "active") {
+    if (turn.status === "completed") {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: "the Lane is running but its exact Turn is terminal without a Lane result",
+            reason: "the current Turn completed without settling its logical Lane",
             evidence: ["execution-lineage-inconsistent"]
         });
     }
-    const session = input.sessions.find((candidate) => (candidate.roleName === run.roleName
-        && candidate.agentId === run.effective.agentId
-        && candidate.adapterId === run.effective.adapterId));
-    const observations = exactTurnObservations(input.events, run, session);
-    const runtime = runtimeProjection(observations, input.events, run);
+    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 unsettledContinuation = runtime !== null
         && Object.values(runtime.continuations).some((continuation) => (continuation.execution === "active"
             || continuation.execution === "unknown"
@@ -203,9 +178,8 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: runtimeTerminalEvidence
         });
     }
-    const exit = latestExactProcessExit(input.events, run, session);
-    const sessionDead = session?.status === "ended";
-    if (sessionDead
+    const exit = latestExactProcessExit(input.events, turn, session);
+    if (session?.status === "ended"
         && exit !== null
         && isAbnormalExit(exit.classification)
         && !unsettledChildWork) {
@@ -217,20 +191,20 @@ function projectExecutionLaneHealth(lane, input, policy) {
             evidence: ["native-session-terminal", `process-exit:${exit.classification}`]
         });
     }
-    if (isRoleTurnStalled(input.events, run.id)) {
+    if (isRoleTurnStalled(input.events, turn.id)) {
         return projection(lane, {
             runtimeHealth: "suspected-stalled",
             recovery: "inspect",
             resultReusable: false,
-            reason: `the durable progress clock has not advanced since ${latestStallProgressAt(input.events, run.id) ?? run.updatedAt}; no death proof exists`,
+            reason: `the durable progress clock has not advanced since ${latestStallProgressAt(input.events, turn.id) ?? turn.updatedAt}; no death proof exists`,
             evidence: ["turn-stalled"]
         });
     }
     const activeOperation = runtime !== null
         && (Object.keys(runtime.operations).length > 0 || unsettledContinuation);
     const lastActivityAt = runtime?.lastRuntimeActivityAt
-        ?? run.updatedAt
-        ?? run.createdAt;
+        ?? turn.updatedAt
+        ?? turn.createdAt;
     const recentActivity = input.now.getTime() - Date.parse(lastActivityAt) < policy.quietAfterMs;
     if (activeOperation || recentActivity) {
         return projection(lane, {
@@ -244,7 +218,9 @@ function projectExecutionLaneHealth(lane, input, policy) {
                     : "the exact Turn has recent structured runtime activity",
             evidence: unsettledContinuation
                 ? ["runtime-continuation-unsettled"]
-                : activeOperation ? ["runtime-operation-active"] : ["runtime-activity-recent"]
+                : activeOperation
+                    ? ["runtime-operation-active"]
+                    : ["runtime-activity-recent"]
         });
     }
     return projection(lane, {
@@ -255,43 +231,42 @@ function projectExecutionLaneHealth(lane, input, policy) {
         evidence: ["turn-active"]
     });
 }
-function projection(lane, value) {
-    return Object.freeze({ laneId: lane.id, ...value });
-}
-function exactLaneTurn(run, group, lane) {
-    return run.id === lane.turnId
-        && run.taskId === group.taskId
-        && run.roleName === lane.roleName
-        && run.executionGroupId === group.id
-        && run.executionLaneId === lane.id;
+function exactLaneTurn(input, lane) {
+    return lane.currentTurnId === 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));
 }
-function exactTurnObservations(events, run, session) {
+function exactTurnObservations(events, turn, session) {
     return events.map(runtimeObservationFromTaskEvent)
         .filter((observation) => (observation !== null
-        && observation.fence.taskId === run.taskId
-        && observation.fence.turnId === run.id
-        && observation.fence.roleName === run.roleName
-        && observation.fence.agentId === run.effective.agentId
-        && (session?.launchId === undefined || observation.fence.launchId === session.launchId)
+        && 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)));
 }
-function runtimeProjection(observations, events, run) {
+function runtimeProjection(observations, events, turn) {
     const first = observations[0];
     return first === undefined
         ? null
-        : projectRuntimeTaskEvents(first.fence, run.createdAt, events);
+        : projectRuntimeTaskEvents(first.fence, turn.createdAt, events);
 }
-function latestExactProcessExit(events, run, session) {
+function latestExactProcessExit(events, turn, 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 !== run.taskId
-                || observation.turnId !== run.id
-                || observation.roleName !== run.roleName
-                || (session?.launchId !== undefined && observation.launchId !== session.launchId)
+            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))
                 return [];
@@ -309,6 +284,24 @@ function latestExactProcessExit(events, run, session) {
 function isAbnormalExit(classification) {
     return classification === "host-abnormal" || classification === "provider-turn-failed";
 }
+function projectedStatus(lane, turn) {
+    if (lane.disposition === "succeeded")
+        return "succeeded";
+    if (lane.disposition === "failed")
+        return "failed";
+    if (lane.currentTurnId === undefined)
+        return "pending";
+    if (turn === undefined)
+        return "unknown";
+    if (turn.status === "active")
+        return "running";
+    if (turn.status === "failed")
+        return "needs-attention";
+    return "unknown";
+}
+function projection(lane, fields) {
+    return Object.freeze({ laneId: lane.id, ...fields });
+}
 function countHealth(lanes, health) {
     return lanes.filter(({ runtimeHealth }) => runtimeHealth === health).length;
 }

package/dist/execution/reviewMainTurn.js

@@ -0,0 +1,161 @@
+import { enqueueRoleTurnDispatch } from "../coordination/workMailboxQueue.js";
+import { createTurnInput } from "../context/turnInputContract.js";
+import { contextSnapshotDeltaRefIds, freezeTurnContextSnapshot } from "../context/turnContextPack.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 { finishReviewRound, startReviewRound } from "../review/reviewRound.js";
+import { createTurn } from "../turn/turn.js";
+import { executionGroupSettled, MINIMUM_SYNTHESIS_RESULTS } from "./workItemExecution.js";
+export function successfulReviewSynthesisProducers(store, round, group) {
+    if (!executionGroupSettled(group)) {
+        throw new Error(`Review ExecutionGroup is not settled: ${round.id}/${group.id}.`);
+    }
+    return [...group.lanes]
+        .sort((left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id))
+        .flatMap((lane) => {
+        if (lane.disposition !== "succeeded")
+            return [];
+        const turn = lane.successfulTurnId === undefined
+            ? null
+            : store.getTurn(round.taskId, lane.successfulTurnId);
+        if (turn === null
+            || turn.status !== "completed"
+            || turn.purpose !== "review"
+            || turn.reviewRoundId !== round.id
+            || turn.executionGroupId !== group.id
+            || turn.executionLaneId !== lane.id
+            || turn.result === undefined) {
+            throw new Error(`Successful Review ExecutionLane has no exact Producer result: `
+                + `${group.id}/${lane.id}.`);
+        }
+        return [{
+                laneId: lane.id,
+                roleName: lane.roleName,
+                turnId: turn.id
+            }];
+    });
+}
+/**
+ * Projects a settled replicated Review into exactly one initial main Reviewer
+ * synthesis Turn. Explicit Turn retry may create later main attempts with the
+ * same source Group; successful producer Lanes remain immutable.
+ */
+export function reconcileReviewMainTurns(store, taskId, now) {
+    const task = store.getTask(taskId);
+    if (task === null || task.status !== "active") {
+        return { createdTurns: [], failedReviewRoundIds: [] };
+    }
+    const createdTurns = [];
+    const failedReviewRoundIds = [];
+    const rounds = [...store.listReviewRounds(taskId)]
+        .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+    for (const round of rounds) {
+        const group = round.executionGroup;
+        if (round.status !== "running"
+            || group === undefined
+            || round.reviewerTurnId !== undefined
+            || !executionGroupSettled(group))
+            continue;
+        const producers = successfulReviewSynthesisProducers(store, round, group);
+        if (producers.length < MINIMUM_SYNTHESIS_RESULTS) {
+            const summary = `Review ExecutionGroup ${group.id} settled with ${producers.length} `
+                + `successful Producer result${producers.length === 1 ? "" : "s"}; at least `
+                + `${MINIMUM_SYNTHESIS_RESULTS} are required.`;
+            store.saveReviewRound(taskId, finishReviewRound(round, "failed", now, { kind: "quorum", message: summary }));
+            store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "review.execution-group-failed", {
+                reviewRoundId: round.id,
+                executionGroupId: group.id,
+                successfulProducerCount: String(producers.length),
+                requiredProducerCount: String(MINIMUM_SYNTHESIS_RESULTS)
+            }, now));
+            failedReviewRoundIds.push(round.id);
+            continue;
+        }
+        const existing = store.listTurns(taskId).filter((turn) => (turn.purpose === "review"
+            && turn.reviewRoundId === round.id
+            && turn.sourceExecutionGroupId === group.id));
+        if (existing.some(({ status }) => status !== "failed"))
+            continue;
+        const role = store.getRole(taskId, round.reviewerRoleName);
+        if (role === null) {
+            throw new Error(`Review main Role is missing: ${taskId}/${round.reviewerRoleName}.`);
+        }
+        if (store.getActiveTurn(taskId, role.name) !== null)
+            continue;
+        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 = freezeTurnContextSnapshot(store, {
+            taskId,
+            roleName: role.name,
+            purpose: "review",
+            ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+            reviewRoundId: round.id,
+            sourceExecutionGroupId: group.id
+        }, now, "controller", group.assignment.contextSnapshotRef);
+        const turn = createTurn(store.nextTurnId(taskId), taskId, role.name, roleAgentSessionResumeMode(store.getTaskRoleSessionSet(taskId, role.name), effective.agentId, effective), createTurnInput({
+            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.saveTurn(turn);
+        store.saveReviewRound(taskId, startReviewRound(round, turn.id));
+        store.saveActiveTurn(turn);
+        enqueueRoleTurnDispatch(store, {
+            taskId,
+            roleName: role.name,
+            turnId: turn.id,
+            reason: "review-synthesis-ready",
+            occurredAt: now
+        });
+        store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "turn.review-dispatched", {
+            turnId: turn.id,
+            role: turn.roleName,
+            purpose: turn.purpose,
+            mode: turn.mode,
+            agent: `${turn.effective.agentId}/${turn.effective.adapterId}`,
+            effectiveRevision: String(turn.effective.sourceDesiredRevision),
+            profileAccess: turn.effective.profileAccess,
+            effectivePermission: turn.effective.permission.strategy,
+            writeProjectIds: turn.effective.writeProjectIds.join(",") || "none",
+            reviewRoundId: round.id,
+            sourceExecutionGroupId: group.id
+        }, now));
+        createdTurns.push(turn);
+    }
+    return { createdTurns, failedReviewRoundIds };
+}
+function synthesisDirective(group, producers) {
+    return [
+        "Act as the main Reviewer over every frozen successful Producer result in stable Lane order.",
+        "Expand each exact source Turn 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");
+}