@zq-silk/yui 0.15.7 → 0.15.8

package/dist/execution/reviewMainTurn.js

@@ -1,161 +0,0 @@
-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");
-}

package/dist/execution/workItemMainTurn.js

@@ -1,164 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-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 { createTurn } from "../turn/turn.js";
-import { currentWorkItemExecutionGroup, updateWorkItemStatus } from "../workItem/workItem.js";
-import { MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS, workItemExecutionGroupSettled } from "./workItemExecution.js";
-export function successfulWorkItemSynthesisProducers(store, item, group) {
-    if (!workItemExecutionGroupSettled(group)) {
-        throw new Error(`WorkItem ExecutionGroup is not settled: ${item.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(item.taskId, lane.successfulTurnId);
-        if (turn === null
-            || turn.status !== "completed"
-            || turn.workItemId !== item.id
-            || turn.executionGroupId !== group.id
-            || turn.executionLaneId !== lane.id
-            || turn.result === undefined) {
-            throw new Error(`Successful ExecutionLane has no exact Producer Turn result: ${group.id}/${lane.id}.`);
-        }
-        return [{
-                laneId: lane.id,
-                roleName: lane.roleName,
-                turnId: turn.id
-            }];
-    });
-}
-/**
- * Reconcile every settled replicated WorkItem in one Task. The Turn row is the
- * durable caller/idempotency record: at most one initial main Turn may name a
- * source Group, while explicit retries append more Turns with the same source.
- */
-export function reconcileWorkItemMainTurns(store, taskId, now) {
-    const task = store.getTask(taskId);
-    if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
-        return { createdTurns: [], failedWorkItemIds: [] };
-    }
-    const createdTurns = [];
-    const failedWorkItemIds = [];
-    const items = [...store.listWorkItems(taskId)].sort((left, right) => (left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)));
-    for (const item of items) {
-        if (item.status !== "running")
-            continue;
-        const group = currentWorkItemExecutionGroup(item);
-        if (group === undefined || !workItemExecutionGroupSettled(group))
-            continue;
-        const producers = successfulWorkItemSynthesisProducers(store, item, group);
-        if (producers.length < MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS) {
-            const summary = `ExecutionGroup ${group.id} settled with ${producers.length} successful `
-                + `Producer result${producers.length === 1 ? "" : "s"}; at least `
-                + `${MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS} are required.`;
-            store.saveWorkItem(taskId, updateWorkItemStatus(item, "failed", now, summary));
-            store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "work.execution-group-failed", {
-                workItemId: item.id,
-                executionGroupId: group.id,
-                successfulProducerCount: String(producers.length),
-                requiredProducerCount: String(MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS)
-            }, now));
-            failedWorkItemIds.push(item.id);
-            continue;
-        }
-        const existing = store.listTurns(taskId).some((turn) => (turn.purpose === "execution"
-            && turn.workItemId === item.id
-            && turn.sourceExecutionGroupId === group.id));
-        if (existing)
-            continue;
-        if (item.assignee === undefined) {
-            throw new Error(`Replicated WorkItem has no main assignee: ${item.id}.`);
-        }
-        const role = store.getRole(taskId, item.assignee);
-        if (role === null)
-            throw new Error(`WorkItem main Role is missing: ${taskId}/${item.assignee}.`);
-        if (store.getActiveTurn(taskId, role.name) !== null)
-            continue;
-        const workspace = role.name === "leader"
-            ? store.getTaskWorkspace(taskId)
-            : store.getWorkItemWorkspace(taskId, item.id);
-        if (workspace === null) {
-            throw new Error(`WorkItem main workspace is missing: ${taskId}/${item.id}.`);
-        }
-        const visibleProjectIds = workspace.entries.map(({ projectId }) => projectId).sort();
-        const taskProjectIds = task.projectBindings.map(({ projectId }) => projectId).sort();
-        const writableProjectIds = workspace.entries
-            .filter(({ access }) => access === "write")
-            .map(({ projectId }) => projectId)
-            .sort();
-        if (!isDeepStrictEqual(visibleProjectIds, taskProjectIds)
-            || !isDeepStrictEqual(writableProjectIds, [...item.writeProjectIds].sort())) {
-            throw new Error(`WorkItem main workspace does not match its approved scope: ${item.id}.`);
-        }
-        const effective = resolveEffectiveLaunch({
-            role,
-            purpose: "execution",
-            workspace,
-            workItemWriteProjectIds: item.writeProjectIds
-        });
-        const snapshot = freezeTurnContextSnapshot(store, {
-            taskId,
-            roleName: role.name,
-            purpose: "execution",
-            workItemId: item.id,
-            sourceExecutionGroupId: group.id,
-            workspace
-        }, 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: "workitem-dispatch" },
-            directive: synthesisDirective(group, producers),
-            contextSnapshotRef: contextSnapshotRef(snapshot),
-            deltaRefIds: contextSnapshotDeltaRefIds(store, snapshot)
-        }), now, {
-            workItemId: item.id,
-            sourceExecutionGroupId: group.id,
-            workspace,
-            effective
-        });
-        store.saveTurn(turn);
-        store.saveActiveTurn(turn);
-        enqueueRoleTurnDispatch(store, {
-            taskId,
-            roleName: role.name,
-            turnId: turn.id,
-            reason: "workitem-synthesis-ready",
-            occurredAt: now
-        });
-        store.saveEvent(taskId, createTaskEvent(store.nextEventId(taskId), taskId, "turn.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",
-            workItemId: item.id,
-            sourceExecutionGroupId: group.id
-        }, now));
-        createdTurns.push(turn);
-    }
-    return { createdTurns, failedWorkItemIds };
-}
-function synthesisDirective(group, producers) {
-    return [
-        "Synthesize 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.",
-        "Do not rerun, retry, append, or abandon any Lane. Form the final WorkItem result from these records.",
-        JSON.stringify({
-            schemaVersion: 1,
-            sourceExecutionGroupId: group.id,
-            producers
-        }, null, 2)
-    ].join("\n\n");
-}