@zq-silk/yui 0.15.7 → 0.15.9

package/skills/yui-worker/SKILL.md

@@ -1,37 +1,41 @@
 ---
 name: yui-worker
-description: Complete one bounded WorkItem as a native subagent or Task Role Turn, then return honest evidence through the assigned protocol.
+description: Complete a bounded Yui WorkItem AgentRun or native child assignment and return evidence without taking over Task coordination.
 ---
 
 # Yui Worker
 
-Follow `yui-runtime` first. For a managed Turn, load its exact Context Pack and
+Follow [yui-runtime](../yui-runtime/SKILL.md) first. For a managed AgentRun,
+load its exact Context Pack and
 use only the returned WorkItem, refs, workspace, writable Project IDs, and
 completion actions. The launch Envelope is a pointer, not an execution brief.
 
-Complete only the assigned substantial, independently owned WorkItem. The Leader owns Task direction,
-decomposition, acceptance, integration, scope expansion, and conflict
+Complete the assigned WorkItem, or the bounded parent brief for a native child
+without its own WorkItem. Do not create records merely to fit this Skill.
+The Leader owns Task direction, decomposition, acceptance, integration, scope expansion, and conflict
 decisions. A Worker must not create or rebind Yui worktrees, Sessions, Roles,
-Turns, WorkItems, ReviewRounds, or integration state.
+AgentRuns, WorkItems, ReviewRounds, or integration state.
 
-Keep the layers distinct:
-
-- Yui Core supplies durable identity, lifecycle, authority, workspace, and
-  exact handoff safety.
-- This Skill supplies portable Worker behavior.
-- Agent-native Project Skills plus Project Policy and Knowledge supply build,
-  test, migration, release, and review rules.
-- The exact WorkItem and Context Snapshot supply this Turn's objective, scope,
-  acceptance, dependencies, and evidence contract.
-
-Do not promote a Project convention into generic Worker policy or infer Task
-facts by scanning the workspace. Expand only Context refs authorized by the
-pack.
+Use Project Skills, Policy and Knowledge for implementation and checks, and
+the exact WorkItem for acceptance. Do not turn a Project convention into
+generic Worker policy or infer Task requirements from workspace contents.
+Resolve Skill links relative to this Skill's directory.
 
 ## Execute within the exact boundary
 
-- Preserve the Task, WorkItem, Role, Turn, native Session, and workspace
-  identities supplied by Yui. A new Turn is another attempt or continuation of
+Leader clarification and continuation arrive as Messages in the exact bounded
+Context Pack. Read those authorized refs; do not request pack-external Leader
+messages or require redispatch/status changes merely to answer a question.
+Continuation preserves the original Assignment, effective permissions and
+workspace, including unfinished files. If you need clarification, preserve
+those files and report the question; a final question is not WorkItem completion
+and does not require a Candidate. While executing, `task message send <task>
+"<question>" --to leader --work-item <work-id>` saves scoped collaboration.
+Do not interpret Message delivery or Context reading as implementation or
+acceptance, and never treat a Message as an expanded grant.
+
+- Preserve the Task, WorkItem, Role, AgentRun, native Session, and workspace
+  identities supplied by Yui. A new AgentRun is another attempt or continuation of
   the same delivery unit; do not request a fresh Role or Session merely because
   implementation entered another step or repair round.
 - Follow the configured Profile's responsibilities, constraints, access
@@ -49,12 +53,12 @@ pack.
   exact Project, reason, impact, and Leader decision needed. Continue only
   after a new exact dispatch authorizes it.
 
-Implement the smallest coherent design that satisfies the current WorkItem.
-Reuse established responsibilities and patterns when they fit. Use a bounded
-refactor when repeated patches expose the wrong boundary, but do not add
-frameworks, configuration, fallbacks, compatibility paths, or abstractions for
-hypothetical future variants. Keep coupled changes together and avoid turning
-small helpers into independently managed architecture.
+Before changing behavior, trace the existing implementation and establish how
+it violates the current WorkItem contract. Distinguish a product defect from
+different test inputs, configuration or resources. Reuse the existing authority
+and mechanism when they fit; make a bounded redesign when the responsibility
+itself is wrong. Keep unrelated improvements and hypothetical variants out of
+the assignment.
 
 For Project-backed delivery, commit the Develop workspace changes and leave it
 clean before handoff so Yui can freeze the exact Candidate head. ReviewRound
@@ -70,10 +74,6 @@ changed behavior; do not repeat an unchanged successful check. Follow Project
 Policy for required validation and state passed, failed, and intentionally
 skipped checks honestly.
 
-Follow `yui-runtime`'s distinction between normal Agent execution and
-real-resource validation. Ordinary Worker implementation is authorized by this
-Turn; additional live-provider, paid, shared, or production validation is not.
-
 ## Return a useful result
 
 A native child result is best-effort until Yui externalizes it: the result
@@ -81,28 +81,26 @@ returns through the parent Conversation, and if that Session is lost before
 the Leader consumes it, the child may need to rerun. Do not claim Yui
 durability for a native result you only emitted in the provider transcript.
 When the child brief requires a durable, independently recoverable result,
-the Leader must dispatch the work as a managed Yui WorkItem Turn instead. A
-direct WorkItem Turn already owns its durable Turn, receipt, and workspace;
+the Leader must dispatch the work as a managed Yui WorkItem AgentRun instead. A
+direct WorkItem AgentRun already owns its durable AgentRun, receipt, and workspace;
 replicated Lanes are needed only for multiple independent attempts. Native
-subagents never own a Yui Turn, receipt, or workspace.
-
-## Task Role Turn
+subagents never own a Yui AgentRun, receipt, or workspace.
 
 Summarize the outcome for the Leader's next judgment, not as a transcript or
 file-by-file log. Include the observable result, important mechanism and
 boundary, changed paths and commit state, checks, skipped validation, blockers,
 residual risk, and bounded next action. Use a checkpoint only for material
-semantic progress during a long Turn; it does not replace the final handoff.
+semantic progress during a long AgentRun; it does not replace the final handoff.
 
 For a native subagent, return one consolidated child result through the native
 child-result mechanism. Do not run Yui lifecycle commands or invent a child
-Yui Session/Turn.
+Yui Session/AgentRun.
 
 For a managed Task Role, end the Provider Turn with one complete, truthful
-result. Yui persists it automatically on the exact Turn. That result does not
+result. Yui persists it automatically on the exact AgentRun. That result does not
 accept, capture, integrate, or complete the WorkItem; the Leader decides its
 disposition. If context or scope is stale or mismatched, report that blocker
-once and stop without wrappers, permission broadening, or another Turn target.
+once and stop without wrappers, permission broadening, or another AgentRun target.
 
 Use clear prose. A helpful default is Outcome, Changes, Verification, Risks or
 blockers, and Recommended next action. This is a communication convention, not

package/dist/cli/roleOptionCatalog.js

@@ -1,68 +0,0 @@
-const BOTH_ADAPTERS = Object.freeze(["codex", "claude"]);
-const CODEX_ONLY = Object.freeze(["codex"]);
-const CLAUDE_ONLY = Object.freeze(["claude"]);
-export const ROLE_AGENT_OPTION_SPECS = Object.freeze([
-    roleAgentOption("--model", "model", "model", false, BOTH_ADAPTERS),
-    roleAgentOption("--effort", "effort", "effort", false, BOTH_ADAPTERS),
-    roleAgentOption("--permission-strategy", "permission.strategy", "strategy", false, BOTH_ADAPTERS, { staticValues: ["default", "bypass", "configured"] }),
-    roleAgentOption("--sandbox", "permission.sandbox", "mode", false, CODEX_ONLY),
-    roleAgentOption("--approval", "permission.approval", "policy", false, CODEX_ONLY),
-    roleAgentOption("--permission-mode", "permission.mode", "mode", false, CLAUDE_ONLY),
-    roleAgentOption("--allowed-tool", "permission.allowedTools", "tool", true, CLAUDE_ONLY),
-    roleAgentOption("--disallowed-tool", "permission.disallowedTools", "tool", true, CLAUDE_ONLY),
-    roleAgentOption("--search", "search", "true", false, CODEX_ONLY, { staticValues: ["true"] }),
-    roleAgentOption("--profile", "profile", "profile", false, CODEX_ONLY),
-    roleAgentOption("--add-dir", "additionalDirectories", "path", true, BOTH_ADAPTERS, { fileValue: true }),
-    roleAgentOption("--settings", "settingsFile", "file", false, CLAUDE_ONLY, { fileValue: true }),
-    roleAgentOption("--setting-source", "settingsSources", "source", true, CLAUDE_ONLY),
-    roleAgentOption("--raw-arg", "advanced.rawArgs", "arg", true, BOTH_ADAPTERS, { allowOptionLikeValue: true })
-]);
-export const ROLE_AGENT_INHERIT_OPTION = "--inherit";
-export const ROLE_EXPECT_UPDATED_AT_OPTION = "--expect-updated-at";
-export const ROLE_AGENT_INHERITABLE_FIELDS = Object.freeze(ROLE_AGENT_OPTION_SPECS.map(({ fieldKey }) => fieldKey));
-export const ROLE_PROFILE_INHERITABLE_FIELDS = Object.freeze(["systemPrompt"]);
-export const ROLE_INHERITABLE_FIELDS = Object.freeze([
-    ...ROLE_AGENT_INHERITABLE_FIELDS,
-    ...ROLE_PROFILE_INHERITABLE_FIELDS
-]);
-export const ROLE_AGENT_SCRIPTED_OPTIONS = Object.freeze([
-    ...ROLE_AGENT_OPTION_SPECS.map(({ option }) => option),
-    ROLE_AGENT_INHERIT_OPTION
-]);
-export const ROLE_AGENT_FILE_OPTIONS = Object.freeze(ROLE_AGENT_OPTION_SPECS.filter(({ fileValue }) => fileValue === true).map(({ option }) => option));
-export function roleAgentOptionSpecsForAdapter(adapterId) {
-    return ROLE_AGENT_OPTION_SPECS.filter(({ adapters }) => adapters.includes(adapterId));
-}
-export function roleAgentOptionUsage() {
-    return [
-        ...ROLE_AGENT_OPTION_SPECS.map(({ option, valueLabel, repeatable }) => `[${option} <${valueLabel}>${repeatable ? " ..." : ""}]`),
-        `[${ROLE_AGENT_INHERIT_OPTION} <field-key> ...]`
-    ].join(" ");
-}
-function roleAgentOption(option, fieldKey, valueLabel, repeatable, adapters, extra = {}) {
-    return Object.freeze({ option, fieldKey, valueLabel, arity: "value", repeatable, adapters, ...extra });
-}
-export const FIRST_CLASS_AGENT_OPTIONS = Object.freeze([
-    Object.freeze({ id: "codex", label: "Codex" }),
-    Object.freeze({ id: "claude", label: "Claude" })
-]);
-export function orderRoleOptions(roles) {
-    return [...roles].sort((left, right) => {
-        const rank = roleRank(left) - roleRank(right);
-        if (rank !== 0)
-            return rank;
-        return roleName(left).localeCompare(roleName(right));
-    });
-}
-function roleRank(role) {
-    const kind = role.kind?.toLowerCase();
-    const name = roleName(role).toLowerCase();
-    if (kind === "operator" || name === "operator")
-        return 0;
-    if (kind === "leader" || name === "leader")
-        return 1;
-    return 2;
-}
-function roleName(role) {
-    return role.name ?? role.id ?? "";
-}

package/dist/context/sourceTurnContext.js

@@ -1,30 +0,0 @@
-import { MAX_TURN_RESULT_OUTPUT_BYTES } from "../domain/agentResultTransport.js";
-export const MAX_SYNTHESIS_SOURCE_TURNS = 8;
-export const MAX_CONTEXT_SOURCE_TURNS = MAX_SYNTHESIS_SOURCE_TURNS + 1;
-export const MAX_CONTEXT_SOURCE_TURN_BYTES = MAX_CONTEXT_SOURCE_TURNS * (MAX_TURN_RESULT_OUTPUT_BYTES + 16 * 1024);
-/**
- * Frozen input for synthesis. The main Agent needs the producer identity and
- * exact result, not another copy of its prompt history, launch configuration,
- * or workspace descriptor.
- */
-export function sourceTurnContextValue(turn) {
-    if (turn.result === undefined) {
-        throw new Error(`Source Turn has no result: ${turn.id}.`);
-    }
-    return Object.freeze({
-        schemaVersion: 1,
-        id: turn.id,
-        taskId: turn.taskId,
-        roleName: turn.roleName,
-        purpose: turn.purpose,
-        ...(turn.workItemId === undefined ? {} : { workItemId: turn.workItemId }),
-        ...(turn.reviewRoundId === undefined ? {} : { reviewRoundId: turn.reviewRoundId }),
-        ...(turn.executionGroupId === undefined
-            ? {}
-            : { executionGroupId: turn.executionGroupId }),
-        ...(turn.executionLaneId === undefined ? {} : { executionLaneId: turn.executionLaneId }),
-        result: turn.result,
-        createdAt: turn.createdAt,
-        updatedAt: turn.updatedAt
-    });
-}

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");
-}