@zq-silk/yui 0.15.6 → 0.15.8

package/dist/review/deltaRecheck.js

@@ -7,7 +7,7 @@ import { validateDeltaRecheckRecord } from "./reviewRound.js";
 export async function assessDeltaRecheck(input) {
     const { repositoryPaths, previousRound, candidate, git } = input;
     if (previousRound.status !== "completed"
-        || previousRound.reviewerTurnId === undefined
+        || previousRound.reviewerRunId === undefined
         || (previousRound.scope ?? "work-item") !== "task") {
         return {
             kind: "ineligible",
@@ -129,8 +129,8 @@ export function buildDeltaRecheckDispatchContext(input) {
         "  semantic change, evidence doubt). This is the safe default.",
         "Yui verified only the technical delta boundary; a Task-control Agent selected this mode.",
         `Previous accepted ReviewRound: ${previousRound.id}@${record.previousBaseCommit}`,
-        `Previous Reviewer Turn: ${previousRound.reviewerTurnId ?? "unavailable"}`,
-        "Read that exact source Turn's original result from the frozen Context Snapshot.",
+        `Previous Reviewer AgentRun: ${previousRound.reviewerRunId ?? "unavailable"}`,
+        "Read that exact source AgentRun's original result from the frozen Context Snapshot.",
         ...(round.taskCandidate?.projects.map((project) => {
             const previous = previousRound.taskCandidate?.projects
                 .find((entry) => entry.projectId === project.projectId)?.commit;

package/dist/review/reviewAcceptance.js

@@ -1,29 +1,29 @@
-export function isCompletedReviewExecutionFromTurns(round, turns) {
-    if (round.status !== "completed" || round.reviewerTurnId === undefined)
+export function isCompletedReviewExecutionFromRuns(round, runs) {
+    if (round.status !== "completed" || round.reviewerRunId === undefined)
         return false;
-    const turn = turns.find(({ id }) => id === round.reviewerTurnId);
-    return turn !== undefined
-        && turn.status === "completed"
-        && turn.result !== undefined
-        && turn.purpose === "review"
-        && turn.taskId === round.taskId
-        && turn.reviewRoundId === round.id
-        && turn.roleName === round.reviewerRoleName
-        && turn.executionGroupId === undefined
-        && turn.effective.reviewBaseCommit === round.reviewBaseCommit;
+    const run = runs.find(({ id }) => id === round.reviewerRunId);
+    return run !== undefined
+        && run.status === "completed"
+        && run.result !== undefined
+        && run.purpose === "review"
+        && run.taskId === round.taskId
+        && run.reviewRoundId === round.id
+        && run.roleName === round.reviewerRoleName
+        && run.executionGroupId === undefined
+        && run.effective.reviewBaseCommit === round.reviewBaseCommit;
 }
 /**
- * Whether a Task-final ReviewRound has one exact completed main Reviewer Turn.
+ * Whether a Task-final ReviewRound has one exact completed main Reviewer AgentRun.
  * This is structural evidence only and never means the Leader accepted it.
  */
 export function isCompletedTaskReviewEvidence(store, round) {
-    return isCompletedTaskReviewEvidenceFromTurns(round, store.listTurns(round.taskId));
+    return isCompletedTaskReviewEvidenceFromRuns(round, store.listRuns(round.taskId));
 }
-export function isCompletedTaskReviewEvidenceFromTurns(round, turns) {
+export function isCompletedTaskReviewEvidenceFromRuns(round, runs) {
     if ((round.scope ?? "work-item") !== "task"
         || round.taskCandidate === undefined
         || round.taskCandidate.projects.length === 0) {
         return false;
     }
-    return isCompletedReviewExecutionFromTurns(round, turns);
+    return isCompletedReviewExecutionFromRuns(round, runs);
 }

package/dist/review/reviewDecision.js

@@ -3,7 +3,7 @@ import { isCompletedTaskReviewEvidence } from "./reviewAcceptance.js";
 import { projectReviewerAvailability } from "./reviewerAvailability.js";
 /** Read-only facts for Leader judgment; this projection never blocks an action. */
 export function projectReviewDecision(input) {
-    const { store, task, roles, turns, rounds, reviewConfig, currentCandidate } = input;
+    const { store, task, roles, runs, rounds, reviewConfig, currentCandidate } = input;
     const taskRounds = rounds.filter((round) => (round.scope ?? "work-item") === "task");
     const accepted = [...taskRounds]
         .filter((round) => isCompletedTaskReviewEvidence(store, round))
@@ -20,15 +20,15 @@ export function projectReviewDecision(input) {
     const activeReviews = taskRounds
         .filter((round) => (round.status === "pending" || round.status === "running"))
         .map((round) => {
-        const activeTurn = turns.find((turn) => (turn.status === "active" && turn.reviewRoundId === round.id));
-        const workspaceRoot = round.workspace?.root ?? activeTurn?.workspace?.root;
+        const activeRun = runs.find((run) => (run.status === "active" && run.reviewRoundId === round.id));
+        const workspaceRoot = round.workspace?.root ?? activeRun?.workspace?.root;
         return {
             reviewRoundId: round.id,
             reviewerRoleName: round.reviewerRoleName,
             mode: round.deltaRecheck === undefined ? "full" : "delta-recheck",
             status: round.status,
-            ...(activeTurn === undefined ? {} : { activeTurnId: activeTurn.id }),
-            startedAt: activeTurn?.createdAt ?? round.createdAt,
+            ...(activeRun === undefined ? {} : { activeRunId: activeRun.id }),
+            startedAt: activeRun?.createdAt ?? round.createdAt,
             frozenCandidate: round.taskCandidate ?? null,
             candidateRelation: candidateRelation(round.taskCandidate ?? null, currentCandidate),
             ...(workspaceRoot === undefined ? {} : { workspaceRoot })
@@ -62,9 +62,9 @@ export function projectReviewDecision(input) {
             reviewerRoleName,
             status: "busy",
             phase: availability.phase,
-            ...(availability.activeTurnId === undefined
+            ...(availability.activeRunId === undefined
                 ? {}
-                : { activeTurnId: availability.activeTurnId }),
+                : { activeRunId: availability.activeRunId }),
             ...(availability.activeReviewRoundId === undefined
                 ? {}
                 : { activeReviewRoundId: availability.activeReviewRoundId }),

package/dist/review/reviewRound.js

@@ -78,12 +78,12 @@ export function attachReviewRoundWorkspace(round, workspace) {
     }
     return validateReviewRound({ ...round, workspace });
 }
-export function startReviewRound(round, reviewerTurnId) {
+export function startReviewRound(round, reviewerRunId) {
     validateReviewRound(round);
     if (round.status !== "pending"
         && !(round.status === "running"
             && round.executionGroup !== undefined
-            && round.reviewerTurnId === undefined)) {
+            && round.reviewerRunId === undefined)) {
         throw new Error(`ReviewRound cannot start from ${round.status}: ${round.id}.`);
     }
     if (round.workspace === undefined) {
@@ -91,7 +91,7 @@ export function startReviewRound(round, reviewerTurnId) {
     }
     return validateReviewRound({
         ...round,
-        reviewerTurnId: requireIdentity(reviewerTurnId, "Reviewer Turn id"),
+        reviewerRunId: requireIdentity(reviewerRunId, "Reviewer AgentRun id"),
         status: "running"
     });
 }
@@ -125,7 +125,7 @@ export function finishReviewRound(round, status, now, failure) {
 }
 /**
  * Retry a failed review execution attempt under the same semantic Round
- * identity. Turn history remains the attempt trail; the Round itself returns
+ * identity. AgentRun history remains the attempt trail; the Round itself returns
  * to pending so infrastructure retries do not manufacture a new semantic
  * ReviewRound or duplicate findings.
  */
@@ -172,12 +172,13 @@ export function retryReviewRound(round, requestedBy, now) {
                     deletedLines: round.deltaRecheck.deletedLines
                 })
             }),
-        // A replicated retry preserves settled successful Producers and reopens
-        // only failed Lanes. If every Producer succeeded, only the main Reviewer
-        // Turn is retried.
+        // A main retry consumes its already selected sources and leaves every
+        // Producer attempt untouched. A pre-main retry reopens failed Lanes only.
         ...(round.executionGroup === undefined
             ? {}
-            : { executionGroup: retryFailedExecutionLanes(round.executionGroup, now) }),
+            : { executionGroup: round.reviewerRunId === undefined
+                    ? retryFailedExecutionLanes(round.executionGroup, now)
+                    : round.executionGroup }),
         requestedBy: validateReviewRequestSource(requestedBy),
         status: "pending",
         ...(round.workspace === undefined ? {} : { workspace: round.workspace }),
@@ -191,16 +192,16 @@ export function retryTaskReviewRound(round, requestedBy, now) {
     }
     return retryReviewRound(round, requestedBy, now);
 }
-/** A failed producer attempt leaves its logical Lane open for another Turn. */
-export function retryRunningReviewExecutionLane(round, executionLaneId, turnId) {
+/** A failed producer attempt leaves its logical Lane open for another AgentRun. */
+export function retryRunningReviewExecutionLane(round, executionLaneId, runId) {
     validateReviewRound(round);
     if (round.status !== "running" || round.executionGroup === undefined) {
         throw new Error(`ReviewRound ${round.id} has no running ExecutionGroup.`);
     }
     const lane = round.executionGroup.lanes.find(({ id }) => id === executionLaneId);
-    if (lane === undefined || lane.disposition !== "open" || lane.currentTurnId !== turnId) {
+    if (lane === undefined || lane.disposition !== "open" || lane.currentRunId !== runId) {
         throw new Error(`Review retry does not target the current failed Lane attempt: `
-            + `${round.executionGroup.id}/${executionLaneId}/${turnId}.`);
+            + `${round.executionGroup.id}/${executionLaneId}/${runId}.`);
     }
     return round;
 }
@@ -268,7 +269,7 @@ export function validateReviewRound(round) {
         "workItemId",
         "candidateId",
         "reviewerRoleName",
-        "reviewerTurnId",
+        "reviewerRunId",
         "reviewBaseCommit",
         "scope",
         "taskCandidate",
@@ -338,19 +339,19 @@ export function validateReviewRound(round) {
         }
         validateDeltaRecheckRecord(round.deltaRecheck);
     }
-    if (round.reviewerTurnId !== undefined) {
+    if (round.reviewerRunId !== undefined) {
         validateTaskRecordReference({
             taskId: round.taskId,
-            localId: round.reviewerTurnId
-        }, "turn");
+            localId: round.reviewerRunId
+        }, "run");
     }
     if (round.workspace !== undefined)
         validateReviewWorkspace(round, round.workspace);
     requireTimestamp(round.createdAt, "ReviewRound createdAt");
     const terminal = round.status === "completed" || round.status === "failed";
     if (terminal) {
-        if (round.status === "completed" && round.reviewerTurnId === undefined) {
-            throw new Error("A completed ReviewRound requires its exact main Reviewer Turn.");
+        if (round.status === "completed" && round.reviewerRunId === undefined) {
+            throw new Error("A completed ReviewRound requires its exact main Reviewer AgentRun.");
         }
         if (round.status === "completed" && round.failure !== undefined) {
             throw new Error("A completed ReviewRound cannot carry failure metadata.");
@@ -370,9 +371,9 @@ export function validateReviewRound(round) {
         throw new Error("A running ReviewRound requires its main Reviewer workspace.");
     }
     if (round.status === "running"
-        && round.reviewerTurnId === undefined
+        && round.reviewerRunId === undefined
         && round.executionGroup === undefined) {
-        throw new Error("A running ReviewRound requires a direct Reviewer Turn or replicated Group.");
+        throw new Error("A running ReviewRound requires a direct Reviewer AgentRun or replicated Group.");
     }
     if (round.workspaceDisposition !== undefined) {
         if (!terminal || round.workspace === undefined) {

package/dist/review/reviewerAvailability.js

@@ -2,13 +2,13 @@ import { nextPendingBatch, mailboxHasWork } from "../coordination/workMailbox.js
 import { runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 /** One authoritative read-only projection for a Task Reviewer Role slot. */
 export function projectReviewerAvailability(store, taskId, reviewerRoleName) {
-    const active = store.getActiveTurn(taskId, reviewerRoleName);
+    const active = store.getActiveRun(taskId, reviewerRoleName);
     if (active !== null) {
         return {
             kind: "busy",
             reviewerRoleName,
             phase: "active-turn",
-            activeTurnId: active.id,
+            activeRunId: active.id,
             ...(active.reviewRoundId === undefined
                 ? {}
                 : { activeReviewRoundId: active.reviewRoundId }),

package/dist/role/role.js

@@ -1,9 +1,20 @@
 import { isDeepStrictEqual } from "node:util";
+import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
+import { isAgentAdapterId } from "../agent/adapterCatalog.js";
+import { adapterIdForExecutionComponent, resolveAgentExecutionComponent } from "../agent/executionComponents.js";
 import { defaultRoleAgentConfig, resolveAgentAdapter } from "../executor/agentAdapter.js";
 import { validateRoleSessionSet } from "../executor/agentExecutor.js";
+/**
+ * The Agent argument is the stored record, not a hand-picked pair of fields.
+ * `component` is required for exactly that reason: an Agent registered as the
+ * Claude Agent SDK that reached a Role binding as `unknown-acp-agent` would be
+ * silently demoted, and an optional parameter makes that a quiet default
+ * instead of a compile error at the call site that forgot it.
+ */
 export function createRoleAgentBinding(agent, config) {
     const agentId = requireSafeIdentity(agent.id, "Role Agent id");
     const adapterId = requireSupportedAdapterId(agent.adapterId);
+    const component = resolveAgentExecutionComponent(adapterId, agent.component);
     const defaults = defaultRoleAgentConfig(adapterId);
     const effectiveConfig = config === undefined
         ? defaults
@@ -13,7 +24,7 @@ export function createRoleAgentBinding(agent, config) {
     if (effectiveConfig.adapterId !== adapterId) {
         throw new Error(`Role Agent config adapter does not match Agent: ${agentId}.`);
     }
-    return cloneBinding({ agentId, adapterId, config: effectiveConfig });
+    return cloneBinding({ agentId, component, adapterId, config: effectiveConfig });
 }
 export function createRole(taskId, name, bindings, activeAgentId, workspace, now, profile = {}, defaultAccess = "write") {
     const owner = createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess);
@@ -72,6 +83,11 @@ export function updateRole(role, patch, now) {
         ...cloneRolePatch(patch),
         updatedAt: now.toISOString()
     };
+    if (patch.executionEnvironment === null)
+        delete updated.executionEnvironment;
+    else if (patch.executionEnvironment !== undefined) {
+        updated.executionEnvironment = cloneJson(patch.executionEnvironment);
+    }
     clearProfileFields(updated, patch);
     updated.launchRevision = isDeepStrictEqual(desiredBefore, desiredLaunchProjection(updated))
         ? role.launchRevision
@@ -93,7 +109,7 @@ export function switchActiveRoleAgent(role, sessions, targetAgentId, runtime, no
         : updateGlobalRole(role, { activeAgentId: normalizedTarget }, now);
     // A running process keeps its immutable effective identity. The desired
     // switch becomes visible only when the next launch is planned.
-    const updatedSessions = runtime.activeTurn || runtime.nativeProcessRunning
+    const updatedSessions = runtime.activeRun || runtime.nativeProcessRunning
         ? sessions
         : {
             ...sessions,
@@ -129,11 +145,11 @@ export function unbindRoleAgent(role, sessions, agentId, now) {
         const taskSessions = sessions.owner.scope === "task"
             ? sessions
             : null;
-        if (taskSessions?.providerBinding?.turn !== null
-            && taskSessions?.providerBinding?.turn !== undefined
+        if (taskSessions?.providerBinding?.run !== null
+            && taskSessions?.providerBinding?.run !== undefined
             && taskSessions.activeAgentId === normalizedAgentId
-            && ["submitting", "accepted", "running"].includes(taskSessions.providerBinding.turn.status)) {
-            throw new Error(`Cannot unbind Role Agent with an active Turn: ${normalizedAgentId}.`);
+            && ["submitting", "accepted", "running"].includes(taskSessions.providerBinding.run.status)) {
+            throw new Error(`Cannot unbind Role Agent with an active AgentRun: ${normalizedAgentId}.`);
         }
         const targetSession = sessions.sessions[normalizedAgentId];
         if (targetSession !== undefined && targetSession.status === "active") {
@@ -215,6 +231,14 @@ function validateRoleOwner(role) {
     requireSafeIdentity(role.name, "Role name");
     requireSafeIdentity(role.activeAgentId, "Role active Agent id");
     requireText(role.workspace, "Role workspace");
+    if ("executionEnvironment" in role && role.executionEnvironment !== undefined) {
+        if (!("taskId" in role))
+            throw new Error("Only a Task Role may bind an execution environment.");
+        validateExecutionEnvironmentSnapshot(role.executionEnvironment);
+        if (role.executionEnvironment.taskId !== role.taskId) {
+            throw new Error("Role execution environment belongs to another Task.");
+        }
+    }
     const entries = Object.entries(role.agentBindings);
     if (entries.length === 0)
         throw new Error("Role requires at least one Agent binding.");
@@ -232,6 +256,16 @@ function validateRoleOwner(role) {
 function validateRoleAgentBinding(binding) {
     const agentId = requireSafeIdentity(binding.agentId, "Role Agent id");
     const adapterId = requireSupportedAdapterId(binding.adapterId);
+    // Storage 10 backfilled every stored binding, so a missing component here is
+    // a corrupt record rather than an old one. Defaulting it would invent a
+    // product identity for data that never lost one.
+    if (binding.component === undefined) {
+        throw new Error(`Role Agent binding is missing its execution component: ${agentId}.`);
+    }
+    const component = resolveAgentExecutionComponent(adapterId, binding.component);
+    if (adapterIdForExecutionComponent(component) !== adapterId) {
+        throw new Error(`Role Agent binding execution component is inconsistent: ${agentId}.`);
+    }
     if (binding.config === null || typeof binding.config !== "object" || Array.isArray(binding.config)) {
         throw new Error(`Role Agent config is invalid: ${agentId}.`);
     }
@@ -272,6 +306,9 @@ function desiredLaunchProjection(role) {
         agentBindings: role.agentBindings,
         workspace: role.workspace,
         defaultAccess: role.defaultAccess,
+        ...("taskId" in role && role.executionEnvironment !== undefined
+            ? { executionEnvironment: role.executionEnvironment }
+            : {}),
         ...cloneProfile(role)
     };
 }
@@ -281,6 +318,10 @@ function cloneBindings(bindings) {
 function cloneBinding(binding) {
     return {
         agentId: binding.agentId,
+        // Copied, never re-derived. Cloning is not the place to decide what an
+        // absent component means: validation above already refuses that record,
+        // and resolving here would hide the refusal behind a plausible default.
+        component: binding.component,
         adapterId: binding.adapterId,
         config: cloneJson(binding.config)
     };
@@ -313,7 +354,10 @@ function cloneJson(value) {
 }
 function requireSupportedAdapterId(value) {
     const normalized = requireText(value, "Role Agent adapter id");
-    if (normalized !== "codex" && normalized !== "claude") {
+    // The catalog defines which adapters exist. A second list here would let a
+    // catalogued adapter be registered as an Agent and then rejected when a Role
+    // binds to it, which reads as corruption rather than as the missing entry.
+    if (!isAgentAdapterId(normalized)) {
         throw new Error(`Role Agent adapter is unsupported: ${normalized}.`);
     }
     return normalized;

package/dist/role/taskRoleUpdate.js

@@ -0,0 +1,30 @@
+import { createTaskEvent } from "../event/taskEvent.js";
+import { enqueueWork } from "../coordination/workMailboxQueue.js";
+/** Called inside the owner's transaction, after authorization and validation.
+ * Current Role, history and durable wake are one mutation. Runtime notification
+ * belongs to the entry point, only after the outer transaction commits.
+ */
+export function saveTaskRoleUpdate(store, previous, current, now, source) {
+    store.saveRole(current.taskId, current);
+    store.saveEvent(current.taskId, createTaskEvent(store.nextEventId(current.taskId), current.taskId, "role.updated", {
+        ...source,
+        role: current.name,
+        ...roleLaunchEventPayload(current, store.getTaskRoleSessionSet(current.taskId, current.name)),
+        previous: JSON.stringify(previous),
+        current: JSON.stringify(current)
+    }, now));
+    enqueueWork(store, { kind: "task", taskId: current.taskId }, "role-updated", now, [{ type: "task", id: current.taskId }]);
+}
+export function roleLaunchEventPayload(role, sessions) {
+    const effective = sessions?.sessions[sessions.activeAgentId]?.effective;
+    return {
+        desiredRevision: String(role.launchRevision),
+        defaultAccess: role.defaultAccess,
+        effectiveRevision: effective === undefined ? "none" : String(effective.sourceDesiredRevision),
+        profileAccess: effective?.profileAccess ?? "none",
+        effectivePermission: effective?.permission.strategy ?? "none",
+        desiredDrift: effective === undefined
+            ? "not-started"
+            : effective.sourceDesiredRevision === role.launchRevision ? "none" : "pending-next-launch"
+    };
+}