@zq-silk/yui 0.14.0 → 0.14.2

package/dist/execution/workItemExecutionProjection.js

@@ -0,0 +1,309 @@
+import { governingWorkItemCandidate, currentWorkItemExecutionGroup } from "../workItem/workItem.js";
+import { MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS } from "./workItemExecution.js";
+export function projectWorkItemExecution(item, turns, sessionSets = []) {
+    const group = currentWorkItemExecutionGroup(item);
+    const relevantTurns = turns.filter((turn) => turn.workItemId === item.id);
+    const sessionsByRole = new Map(sessionSets.map((set) => [set.owner.roleName, set]));
+    const lanes = group === undefined
+        ? []
+        : [...group.lanes]
+            .sort((left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id))
+            .map((lane) => projectLane(item, group, lane, relevantTurns, sessionsByRole));
+    const laneCounts = Object.freeze({
+        running: lanes.filter(({ status }) => status === "running").length,
+        succeeded: lanes.filter(({ status }) => status === "succeeded").length,
+        needsAttention: lanes.filter(({ status }) => status === "needs-attention").length,
+        failed: lanes.filter(({ status }) => status === "failed").length,
+        unknown: lanes.filter(({ status }) => status === "unknown").length
+    });
+    const mainTurn = projectMainTurn(item, group, relevantTurns, sessionsByRole);
+    const synthesis = projectSynthesis(group, lanes, mainTurn);
+    const candidate = projectCandidate(item, group, relevantTurns, lanes, mainTurn);
+    return Object.freeze({
+        schemaVersion: 1,
+        shape: group === undefined ? "direct" : "replicated",
+        ...(group === undefined ? {} : { groupId: group.id }),
+        lanes: Object.freeze(lanes),
+        laneCounts,
+        synthesis,
+        mainTurn,
+        candidate,
+        nextAction: projectNextAction(item, lanes, synthesis, mainTurn, candidate)
+    });
+}
+function projectLane(item, group, lane, turns, sessionsByRole) {
+    const current = lane.currentTurnId === undefined
+        ? undefined
+        : turns.find(({ id }) => id === lane.currentTurnId);
+    const exact = current !== undefined
+        && current.taskId === item.taskId
+        && current.workItemId === item.id
+        && current.executionGroupId === group.id
+        && current.executionLaneId === lane.id
+        && current.roleName === lane.roleName;
+    const session = exact
+        ? turnSessionStatus(current, sessionsByRole.get(lane.roleName))
+        : "unobserved";
+    if (lane.disposition === "failed") {
+        return Object.freeze({
+            laneId: lane.id,
+            ordinal: lane.ordinal,
+            roleName: lane.roleName,
+            status: "failed",
+            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
+            session,
+            observation: exact ? "observed" : "unobserved"
+        });
+    }
+    if (lane.disposition === "succeeded") {
+        const producerObserved = exact
+            && lane.successfulTurnId === current.id
+            && current.status === "completed"
+            && current.result !== undefined;
+        return Object.freeze({
+            laneId: lane.id,
+            ordinal: lane.ordinal,
+            roleName: lane.roleName,
+            status: producerObserved ? "succeeded" : "unknown",
+            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
+            ...(lane.successfulTurnId === undefined ? {} : { successfulTurnId: lane.successfulTurnId }),
+            session,
+            observation: producerObserved ? "observed" : "unobserved"
+        });
+    }
+    if (!exact) {
+        return Object.freeze({
+            laneId: lane.id,
+            ordinal: lane.ordinal,
+            roleName: lane.roleName,
+            status: "unknown",
+            ...(lane.currentTurnId === undefined ? {} : { currentTurnId: lane.currentTurnId }),
+            session: "unobserved",
+            observation: "unobserved"
+        });
+    }
+    if (current.status === "failed") {
+        return Object.freeze({
+            laneId: lane.id,
+            ordinal: lane.ordinal,
+            roleName: lane.roleName,
+            status: "needs-attention",
+            currentTurnId: current.id,
+            session,
+            retryTurnId: current.id,
+            settleTurnId: current.id,
+            observation: "observed"
+        });
+    }
+    if (current.status === "active") {
+        return Object.freeze({
+            laneId: lane.id,
+            ordinal: lane.ordinal,
+            roleName: lane.roleName,
+            status: session === "ended" ? "needs-attention" : "running",
+            currentTurnId: current.id,
+            session,
+            observation: "observed"
+        });
+    }
+    return Object.freeze({
+        laneId: lane.id,
+        ordinal: lane.ordinal,
+        roleName: lane.roleName,
+        status: "unknown",
+        currentTurnId: current.id,
+        session,
+        observation: "unobserved"
+    });
+}
+function projectMainTurn(item, group, turns, sessionsByRole) {
+    const candidates = turns.filter((turn) => (turn.purpose === "execution"
+        && turn.roleName === item.assignee
+        && turn.executionGroupId === undefined
+        && turn.executionLaneId === undefined
+        && turn.sourceExecutionGroupId === group?.id)).sort(compareTurns);
+    const turn = candidates.at(-1);
+    if (turn === undefined) {
+        return Object.freeze({
+            status: "not-started",
+            ...(item.assignee === undefined ? {} : { roleName: item.assignee }),
+            ...(group === undefined ? {} : { sourceExecutionGroupId: group.id }),
+            session: "unobserved",
+            observation: "unobserved"
+        });
+    }
+    const session = turnSessionStatus(turn, sessionsByRole.get(turn.roleName));
+    const base = {
+        roleName: turn.roleName,
+        turnId: turn.id,
+        ...(turn.sourceExecutionGroupId === undefined
+            ? {}
+            : { sourceExecutionGroupId: turn.sourceExecutionGroupId }),
+        session
+    };
+    if (turn.status === "failed") {
+        return Object.freeze({
+            ...base,
+            status: "needs-attention",
+            retryTurnId: turn.id,
+            observation: "observed"
+        });
+    }
+    if (turn.status === "active") {
+        return Object.freeze({
+            ...base,
+            status: session === "ended" ? "needs-attention" : "running",
+            observation: "observed"
+        });
+    }
+    return Object.freeze({
+        ...base,
+        status: turn.result === undefined ? "unknown" : "succeeded",
+        observation: turn.result === undefined ? "unobserved" : "observed"
+    });
+}
+function projectSynthesis(group, lanes, mainTurn) {
+    if (group === undefined) {
+        return Object.freeze({
+            status: "not-applicable",
+            successfulLaneCount: 0,
+            requiredSuccessfulLaneCount: MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
+        });
+    }
+    const successfulLaneCount = group.lanes.filter(({ disposition }) => disposition === "succeeded").length;
+    let status;
+    if (group.lanes.some(({ disposition }) => disposition === "open")) {
+        status = "blocked-by-open-lanes";
+    }
+    else if (lanes.some((lane) => (lane.status === "unknown" && group.lanes.some(({ id, disposition }) => (id === lane.laneId && disposition === "succeeded"))))) {
+        status = "unknown";
+    }
+    else if (successfulLaneCount < MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS) {
+        status = "insufficient-results";
+    }
+    else if (mainTurn.status === "not-started") {
+        status = "eligible";
+    }
+    else if (mainTurn.status === "running") {
+        status = "main-running";
+    }
+    else if (mainTurn.status === "needs-attention") {
+        status = "main-needs-attention";
+    }
+    else if (mainTurn.status === "succeeded") {
+        status = "complete";
+    }
+    else {
+        status = "unknown";
+    }
+    return Object.freeze({
+        status,
+        successfulLaneCount,
+        requiredSuccessfulLaneCount: MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
+    });
+}
+function projectCandidate(item, group, turns, lanes, mainTurn) {
+    const candidate = governingWorkItemCandidate(item);
+    if (candidate === undefined) {
+        return Object.freeze({
+            status: "none",
+            successfulLaneTurns: Object.freeze([]),
+            observation: "observed"
+        });
+    }
+    if (candidate.source.type === "direct") {
+        const valid = group === undefined && item.assignee === undefined;
+        return candidateProjection(candidate, valid ? "observed" : "unknown", [], valid);
+    }
+    const sourceTurnId = candidate.source.turnId;
+    const sourceTurn = turns.find(({ id }) => id === sourceTurnId);
+    const laneTurns = group === undefined
+        ? []
+        : [...group.lanes]
+            .filter(({ disposition, successfulTurnId }) => (disposition === "succeeded" && successfulTurnId !== undefined))
+            .sort((left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id))
+            .map((lane) => ({ laneId: lane.id, successfulTurnId: lane.successfulTurnId }));
+    const valid = sourceTurn !== undefined
+        && sourceTurn.id === mainTurn.turnId
+        && sourceTurn.status === "completed"
+        && sourceTurn.result !== undefined
+        && sourceTurn.executionGroupId === undefined
+        && sourceTurn.executionLaneId === undefined
+        && sourceTurn.sourceExecutionGroupId === group?.id
+        && candidate.executionLaneId === undefined
+        && candidate.executionGroupId === undefined
+        && (group === undefined || (laneTurns.length >= MINIMUM_WORK_ITEM_SYNTHESIS_RESULTS
+            && lanes.filter(({ successfulTurnId }) => successfulTurnId !== undefined)
+                .every(({ status }) => status === "succeeded")));
+    return candidateProjection(candidate, valid ? "observed" : "unknown", laneTurns, valid, group?.id);
+}
+function candidateProjection(candidate, status, successfulLaneTurns, observed, sourceExecutionGroupId) {
+    return Object.freeze({
+        status,
+        candidateId: candidate.id,
+        sourceType: candidate.source.type,
+        ...(candidate.source.type === "turn" ? { mainTurnId: candidate.source.turnId } : {}),
+        ...(sourceExecutionGroupId === undefined ? {} : { sourceExecutionGroupId }),
+        successfulLaneTurns: Object.freeze(successfulLaneTurns),
+        observation: observed ? "observed" : "unobserved"
+    });
+}
+function projectNextAction(item, lanes, synthesis, mainTurn, candidate) {
+    if (["completed", "retired"].includes(item.status))
+        return action("none", [], []);
+    if (item.status === "awaiting_acceptance") {
+        return candidate.status === "observed"
+            ? action("decide-candidate", ["leader"], [candidate.candidateId])
+            : action("inspect-unknown", ["leader"], candidate.candidateId === undefined ? [] : [candidate.candidateId]);
+    }
+    if (lanes.some(({ status }) => status === "unknown")) {
+        return action("inspect-unknown", ["leader"], lanes
+            .filter(({ status }) => status === "unknown")
+            .map(({ laneId }) => laneId));
+    }
+    const recoveries = lanes.filter(({ retryTurnId }) => retryTurnId !== undefined);
+    if (recoveries.length > 0) {
+        return action("retry-or-settle-lanes", ["leader"], recoveries.map(({ retryTurnId }) => retryTurnId));
+    }
+    const activeLanes = lanes.filter(({ status }) => status === "running");
+    if (activeLanes.length > 0) {
+        return action("wait-for-lanes", activeLanes.map(({ roleName }) => roleName), activeLanes.map(({ laneId }) => laneId));
+    }
+    if (synthesis.status === "insufficient-results") {
+        return action("redispatch-work", ["leader"], [item.id]);
+    }
+    if (synthesis.status === "eligible") {
+        return action("await-main-dispatch", ["controller", ...(item.assignee === undefined ? [] : [item.assignee])], [item.id]);
+    }
+    if (mainTurn.status === "running") {
+        return action("wait-for-main", mainTurn.roleName === undefined ? [] : [mainTurn.roleName], mainTurn.turnId === undefined ? [] : [mainTurn.turnId]);
+    }
+    if (mainTurn.status === "needs-attention") {
+        return mainTurn.retryTurnId === undefined
+            ? action("inspect-unknown", ["leader"], mainTurn.turnId === undefined ? [] : [mainTurn.turnId])
+            : action("retry-main", ["leader"], [mainTurn.retryTurnId]);
+    }
+    if (mainTurn.status === "succeeded" && item.status === "running") {
+        return action("submit-candidate", ["leader"], [mainTurn.turnId]);
+    }
+    if (mainTurn.status === "unknown" || synthesis.status === "unknown") {
+        return action("inspect-unknown", ["leader"], mainTurn.turnId === undefined ? [item.id] : [mainTurn.turnId]);
+    }
+    if (item.status === "pending" || item.status === "failed") {
+        return action("dispatch-work", ["leader"], [item.id]);
+    }
+    return action("inspect-unknown", ["leader"], [item.id]);
+}
+function action(kind, owners, targetIds) {
+    return Object.freeze({
+        kind,
+        owners: Object.freeze([...new Set(owners)]),
+        targetIds: Object.freeze([...new Set(targetIds)])
+    });
+}
+function turnSessionStatus(turn, set) {
+    return set?.sessions[turn.effective.agentId]?.status ?? "unobserved";
+}
+function compareTurns(left, right) {
+    return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
+}

package/dist/execution/workItemMainTurn.js

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

package/dist/executor/agentExecutor.js

@@ -11,10 +11,10 @@ export function createRoleSessionSet(owner, activeAgentId, now) {
         updatedAt: now.toISOString()
     };
     return owner.scope === "global"
-        ? { ...base, schemaVersion: 4 }
+        ? { ...base, schemaVersion: 5 }
         : {
             ...base,
-            schemaVersion: 11,
+            schemaVersion: 12,
             providerBinding: null
         };
 }
@@ -46,7 +46,7 @@ export function recordRoleAgentSession(set, input, now) {
     const nativeSessionId = requireText(input.nativeSessionId, "Native session id");
     if (set.owner.scope === "task") {
         const historical = (set.history ?? []).find((entry) => (entry.nativeSessionId === nativeSessionId
-            || (input.launchId !== undefined && entry.launchId === input.launchId)));
+            || (input.runtimeGenerationId !== undefined && entry.runtimeGenerationId === input.runtimeGenerationId)));
         if (historical !== undefined) {
             throw new Error("A new Task Role Session cannot reuse a historical native identity.");
         }
@@ -78,13 +78,13 @@ export function recordRoleAgentSession(set, input, now) {
     const timestamp = now.toISOString();
     const continuing = existing?.nativeSessionId === nativeSessionId ? existing : undefined;
     const session = {
-        schemaVersion: 4,
+        schemaVersion: 5,
         agentId,
         adapterId,
         nativeSessionId,
-        ...(input.launchId === undefined
-            ? continuing?.launchId === undefined ? {} : { launchId: continuing.launchId }
-            : { launchId: requireText(input.launchId, "Launch id") }),
+        ...(input.runtimeGenerationId === undefined
+            ? continuing?.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: continuing.runtimeGenerationId }
+            : { runtimeGenerationId: requireText(input.runtimeGenerationId, "Runtime generation id") }),
         ...optionalSessionText("title", input.title ?? continuing?.title),
         ...optionalSessionText("preview", input.preview ?? continuing?.preview),
         policy: input.policy,
@@ -207,7 +207,7 @@ export function retireConfirmedAbsentInactiveTaskRolePlaceholders(set, now) {
         const isNeverStartedInactiveClaude = agentId !== set.activeAgentId
             && session.adapterId === "claude"
             && session.status === "active"
-            && session.launchId === undefined
+            && session.runtimeGenerationId === undefined
             && session.recentCompletedTurnIds.length === 0;
         if (!isNeverStartedInactiveClaude)
             return [agentId, session];
@@ -327,7 +327,7 @@ export function detachRoleAgentSessionHost(set, now) {
     if (active === undefined || active.status === "ended")
         return set;
     const timestamp = requireDate(now, "Role Host detach timestamp");
-    const { launchId: _launchId, endReason: _endReason, ...session } = active;
+    const { runtimeGenerationId: _runtimeGenerationId, endReason: _endReason, ...session } = active;
     let updated = validateRoleSessionSet({
         ...set,
         sessions: {
@@ -431,7 +431,7 @@ export function validateRoleSessionSet(set) {
         validateRoleAgentSession(session, agentId);
     }
     if (set.owner.scope === "global") {
-        if (set.schemaVersion !== 4) {
+        if (set.schemaVersion !== 5) {
             throw new Error("Global Role session set schema version is invalid.");
         }
         if (Object.hasOwn(set, "providerBinding")) {
@@ -449,7 +449,7 @@ export function validateRoleSessionSet(set) {
         }
     }
     else {
-        if (set.schemaVersion !== 11) {
+        if (set.schemaVersion !== 12) {
             throw new Error("Task Role session set schema version is invalid.");
         }
         if (!Object.hasOwn(set, "providerBinding")) {
@@ -495,7 +495,7 @@ export function validateRoleSessionSet(set) {
     return set;
 }
 export function validateRoleAgentSession(session, expectedAgentId = session.agentId) {
-    if (session.schemaVersion !== 4) {
+    if (session.schemaVersion !== 5) {
         throw new Error(`Role Agent session schema version is invalid: ${expectedAgentId}.`);
     }
     const agentId = requireSafeIdentity(session.agentId, "Agent id");
@@ -510,15 +510,15 @@ export function validateRoleAgentSession(session, expectedAgentId = session.agen
     // A restored opaque host may have no provider-native identity; retain its
     // launch fence so it can be inspected or stopped without inventing identity.
     if (session.nativeSessionId === undefined) {
-        if (session.launchId === undefined) {
-            throw new Error("Role Agent session requires a native Session or launch id.");
+        if (session.runtimeGenerationId === undefined) {
+            throw new Error("Role Agent session requires a native Session or runtime generation id.");
         }
     }
     else {
         requireText(session.nativeSessionId, "Native session id");
     }
-    if (session.launchId !== undefined)
-        requireSafeIdentity(session.launchId, "Launch id");
+    if (session.runtimeGenerationId !== undefined)
+        requireSafeIdentity(session.runtimeGenerationId, "Runtime generation id");
     if (session.title !== undefined
         && optionalSessionText("title", session.title).title !== session.title) {
         throw new Error("Role Agent session title is invalid.");
@@ -550,10 +550,10 @@ function taskRoleSessionIdentity(session) {
     if (session.nativeSessionId !== undefined) {
         return `${session.agentId}\0native\0${session.nativeSessionId}`;
     }
-    if (session.launchId === undefined) {
-        throw new Error("Opaque Task Role session requires a launch identity.");
+    if (session.runtimeGenerationId === undefined) {
+        throw new Error("Opaque Task Role session requires a runtime generation identity.");
     }
-    return `${session.agentId}\0launch\0${session.launchId}`;
+    return `${session.agentId}\0runtime-generation\0${session.runtimeGenerationId}`;
 }
 function optionalSessionText(field, value) {
     if (value === undefined)

package/dist/executor/executorRegistry.js

@@ -92,12 +92,12 @@ export class ExecutorRegistry {
                 const request = input.mode === "new"
                     ? createSessionLaunchRequest({
                         ...common,
-                        launchId: deliveryBase.deliveryId,
+                        runtimeGenerationId: deliveryBase.deliveryId,
                         mode: "new"
                     })
                     : createSessionLaunchRequest({
                         ...common,
-                        launchId: deliveryBase.deliveryId,
+                        runtimeGenerationId: deliveryBase.deliveryId,
                         mode: "resume",
                         nativeSessionId: input.nativeSessionId
                     });
@@ -118,7 +118,7 @@ export class ExecutorRegistry {
         }
         const delivery = {
             ...deliveryBase,
-            ...(binding === undefined ? {} : { launchId: binding.launchId }),
+            ...(binding === undefined ? {} : { runtimeGenerationId: binding.runtimeGenerationId }),
             sessionStarted,
             session,
         };
@@ -145,27 +145,6 @@ export class ExecutorRegistry {
             if (turnId === undefined) {
                 throw new Error("Runtime prompt delivery requires a Task-local Turn id.");
             }
-            // A reused native process retains the stable descriptor path from its
-            // original control plane. Publish only the current-control source after
-            // the Turn/Session fence is durable and immediately before Provider input;
-            // the reused Hook self-refreshes its own source before the volatile
-            // fence instead of the Controller scanning history to keep it fresh.
-            if (prepared.binding.hostCreated === false
-                && this.planner.refreshTaskRuntimeDescriptor !== undefined) {
-                if (!hasText(prepared.binding.nativeSessionId)) {
-                    throw new Error("Runtime prompt delivery requires a native Session id.");
-                }
-                this.planner.refreshTaskRuntimeDescriptor({
-                    taskId: input.delivery.prepared.taskId,
-                    roleName: input.delivery.prepared.roleName,
-                    turnId,
-                    launchId: prepared.binding.launchId,
-                    nativeSessionId: prepared.binding.nativeSessionId,
-                    agentId: prepared.binding.agentId,
-                    adapterId: prepared.binding.adapterId,
-                    workspace: prepared.workspace
-                });
-            }
             const outcome = await this.runtimePorts.promptPush.tryPush({
                 binding: prepared.binding,
                 envelope: createPromptEnvelope({
@@ -195,7 +174,7 @@ export class ExecutorRegistry {
             return "unavailable";
         const outcome = await this.runtimePorts.promptPush.trySteer({
             owner: { scope: "task", taskId: input.taskId, roleName: input.roleName },
-            launchId: input.launchId,
+            runtimeGenerationId: input.runtimeGenerationId,
             agentId: input.agentId,
             adapterId: input.adapterId,
             nativeSessionId: input.nativeSessionId,
@@ -223,8 +202,8 @@ export class ExecutorRegistry {
                 || delivery.roleName !== input.roleName
                 || (input.turnId !== undefined
                     && delivery.turnId !== input.turnId)
-                || (input.launchId !== undefined
-                    && delivery.launchId !== input.launchId)) {
+                || (input.runtimeGenerationId !== undefined
+                    && delivery.runtimeGenerationId !== input.runtimeGenerationId)) {
                 continue;
             }
             this.#prepared.delete(deliveryId);
@@ -287,7 +266,7 @@ export class ExecutorRegistry {
             ...(input.nativeSessionId === undefined
                 ? {}
                 : { nativeSessionId: input.nativeSessionId }),
-            ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+            ...(input.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: input.runtimeGenerationId }),
             ...(input.progressAt === undefined ? {} : { progressAt: input.progressAt })
         }));
         if (this.runtimePorts?.roleResourceInventory !== undefined