@zq-silk/yui 0.13.10 → 0.14.1

package/dist/executor/fileRoleLaunchPlanner.js

@@ -97,7 +97,7 @@ export class FileRoleLaunchPlanner {
             || role === null) {
             throw new Error(`Task runtime is not current: ${input.taskId}/${input.roleName}.`);
         }
-        const run = this.store.getActiveAgentRun(input.taskId, input.roleName);
+        const run = this.store.getActiveTurn(input.taskId, input.roleName);
         const sessions = this.store.getTaskRoleSessionSet(input.taskId, input.roleName);
         const session = sessions?.sessions[role.activeAgentId];
         if (session === undefined || session.launchId === undefined) {
@@ -111,11 +111,11 @@ export class FileRoleLaunchPlanner {
             agentId: session.agentId,
             adapterId: session.adapterId,
             workspace: effective.workspace.root,
-            ...(run === null ? {} : { runId: run.id }),
+            ...(run === null ? {} : { turnId: run.id }),
             launchId: session.launchId,
             nativeSessionId: session.nativeSessionId
         });
-        if (descriptor.runId !== input.runId
+        if (descriptor.turnId !== input.turnId
             || descriptor.launchId !== input.launchId
             || descriptor.nativeSessionId !== input.nativeSessionId
             || descriptor.agentId !== input.agentId
@@ -140,22 +140,22 @@ export class FileRoleLaunchPlanner {
         const role = this.store.getRole(input.taskId, input.roleName);
         if (role === null)
             throw new Error(`Role not found: ${input.taskId}/${input.roleName}.`);
-        const activeRun = this.store.getActiveAgentRun(task.id, role.name);
-        if (input.runId !== undefined && activeRun?.id !== input.runId) {
-            throw new Error(`Role Run is no longer current: ${input.runId}.`);
+        const activeTurn = this.store.getActiveTurn(task.id, role.name);
+        if (input.turnId !== undefined && activeTurn?.id !== input.turnId) {
+            throw new Error(`Role Turn is no longer current: ${input.turnId}.`);
         }
-        const runWorkspace = activeRun?.workspace;
+        const runWorkspace = activeTurn?.workspace;
         const main = this.store.getTaskWorkspace(task.id);
         // Quick Win (EXE-04/EXE-08): classify workspace preflight failures so
         // split-brain state is never reported as a transient Provider failure.
-        const preflight = classifyWorkspacePreflight(this.store, task, input.roleName, activeRun === null ? null : { id: activeRun.id, workspace: activeRun.workspace }, this.#inspectWorkspacePhysicalState);
+        const preflight = classifyWorkspacePreflight(this.store, task, input.roleName, activeTurn === null ? null : { id: activeTurn.id, workspace: activeTurn.workspace }, this.#inspectWorkspacePhysicalState);
         if (preflight !== null) {
             throw new Error(formatWorkspacePreflightError(preflight));
         }
         const assignedWorkItem = this.store.listWorkItems(task.id).find((item) => item.assignee === role.name
             && !["completed", "failed", "retired"].includes(item.status));
-        // A Run snapshot is authoritative for the live launch.  In particular,
-        // a reviewer Run must launch from its ReviewRound-owned workspace rather
+        // A Turn snapshot is authoritative for the live launch. In particular,
+        // a Reviewer Turn must launch from its ReviewRound-owned workspace rather
         // than falling back to the WorkItem Develop workspace.  Without an
         // active snapshot, resolve the normal Role/WorkItem assignment.
         const workspace = runWorkspace !== undefined
@@ -183,8 +183,8 @@ export class FileRoleLaunchPlanner {
                 && isolatedWorkItem !== null
                 && (isolatedWorkItem.assignee === undefined || isolatedWorkItem.assignee === role.name)
                 && !["completed", "failed", "retired"].includes(isolatedWorkItem.status)
-                && (activeRun === null
-                    || activeRun.workItemId === workspace.owner.workItemId)
+                && (activeTurn === null
+                    || activeTurn.workItemId === workspace.owner.workItemId)
                 && sameWorkspaceProjects(workspace, task.projectBindings.map(({ projectId }) => projectId))
                 && sameWritableProjects(workspace, isolatedWorkItem.writeProjectIds);
             const runScoped = runWorkspace !== undefined
@@ -192,29 +192,29 @@ export class FileRoleLaunchPlanner {
                 && sameWorkspaceProjects(runWorkspace, task.projectBindings.map(({ projectId }) => projectId))
                 && (runWorkspace.owner.type === "task"
                     || (runWorkspace.owner.type === "work-item"
-                        && runWorkspace.owner.workItemId === activeRun?.workItemId)
+                        && runWorkspace.owner.workItemId === activeTurn?.workItemId)
                     || (runWorkspace.owner.type === "review-round"
-                        && activeRun?.purpose === "review"
-                        && runWorkspace.owner.reviewRoundId === activeRun.reviewRoundId)
+                        && activeTurn?.purpose === "review"
+                        && runWorkspace.owner.reviewRoundId === activeTurn.reviewRoundId)
                     || (runWorkspace.owner.type === "execution-lane"
-                        && runWorkspace.owner.executionGroupId === activeRun?.executionGroupId
-                        && runWorkspace.owner.executionLaneId === activeRun?.executionLaneId
-                        && ((runWorkspace.owner.purpose === "review" && activeRun?.purpose === "review")
-                            || (runWorkspace.owner.purpose === "execution" && activeRun?.purpose === "execution"))));
+                        && runWorkspace.owner.executionGroupId === activeTurn?.executionGroupId
+                        && runWorkspace.owner.executionLaneId === activeTurn?.executionLaneId
+                        && ((runWorkspace.owner.purpose === "review" && activeTurn?.purpose === "review")
+                            || (runWorkspace.owner.purpose === "execution" && activeTurn?.purpose === "execution"))));
             if (!runScoped && !sharedMain && !isolated) {
                 throw new Error(`Role workspace is not ready: ${input.taskId}/${input.roleName}.`);
             }
         }
         const sessionSet = this.store.getTaskRoleSessionSet(task.id, role.name);
-        const resolvedEffective = activeRun?.effective
+        const resolvedEffective = activeTurn?.effective
             ?? activeLiveRoleAgentSession(sessionSet)?.effective
             ?? resolveTaskRoleEffectiveLaunch(this.store, role);
         if (input.effective !== undefined
             && !isDeepStrictEqual(resolvedEffective, input.effective)) {
-            throw new Error(`Role launch effective Run snapshot changed: ${input.taskId}/${input.roleName}.`);
+            throw new Error(`Role launch effective Turn snapshot changed: ${input.taskId}/${input.roleName}.`);
         }
-        if (activeRun !== null && input.effective === undefined) {
-            throw new Error(`Role launch is missing the effective Run snapshot: ${input.taskId}/${input.roleName}.`);
+        if (activeTurn !== null && input.effective === undefined) {
+            throw new Error(`Role launch is missing the effective Turn snapshot: ${input.taskId}/${input.roleName}.`);
         }
         const effective = input.effective ?? resolvedEffective;
         const existing = sessionSet?.sessions[effective.agentId];
@@ -230,7 +230,7 @@ export class FileRoleLaunchPlanner {
             throw new Error(`Task Role still has a live Session: ${task.id}/${role.name}.`);
         }
         return this.#compile(role, input, { scope: "task", taskId: task.id }, resolveTaskRoleSessionTitle(input.mode === "resume" ? existing?.title : undefined, task, role.name), input.mode === "resume" && compatibleExisting ? existing.nativeSessionId : undefined, runWorkspace, effective, {
-            purpose: activeRun?.purpose ?? "execution"
+            purpose: activeTurn?.purpose ?? "execution"
         });
     }
     planGlobalRole(input) {
@@ -280,7 +280,7 @@ export class FileRoleLaunchPlanner {
         const adapter = resolveAgentAdapter(binding.adapterId);
         const effectiveWorkspace = effective.workspace.root;
         const agentWorkspace = nativeAgentWorkspace(effective.workspace);
-        if (adapter.id === "codex" && (owner.scope !== "task" || input.runId === undefined)) {
+        if (adapter.id === "codex" && (owner.scope !== "task" || input.turnId === undefined)) {
             const codexConfig = inspectCodexLaunchConfig({
                 environment: launchEnvironment,
                 workspace: agentWorkspace,
@@ -325,21 +325,21 @@ export class FileRoleLaunchPlanner {
             sessionManifestDigest: bootstrap.manifest.digest,
             sessionCliPath: bootstrap.sessionCliPath
         };
-        const managedRun = owner.scope === "task" && input.runId !== undefined
-            ? this.store.getAgentRun(owner.taskId, input.runId)
+        const managedRun = owner.scope === "task" && input.turnId !== undefined
+            ? this.store.getTurn(owner.taskId, input.turnId)
             : null;
         const driver = builtinAgentDriverRegistry().require(builtinDriverIdForAdapter(configured.adapterId));
-        if (owner.scope === "task" && input.runId !== undefined) {
+        if (owner.scope === "task" && input.turnId !== undefined) {
             const admission = managedRuntimeAdmission(driver.capabilities);
             if (!admission.admitted) {
-                throw new Error(`Agent Driver ${driver.id} cannot host managed Runs; missing capabilities: `
+                throw new Error(`Agent Driver ${driver.id} cannot host managed Turns; missing capabilities: `
                     + admission.missing.join(", "));
             }
         }
         const roleConfig = binding.config.adapterId === "claude"
             && owner.scope === "task"
-            && input.runId !== undefined
-            ? managedClaudeControlPlaneConfig(binding.config, owner.taskId, managedRun?.workItemId, input.runId)
+            && input.turnId !== undefined
+            ? managedClaudeControlPlaneConfig(binding.config, owner.taskId, managedRun?.workItemId, input.turnId)
             : binding.config;
         const effectiveConfig = withNativeProjectDirectories(roleConfig, nativeAdditionalDirectories(effective.workspace, agentWorkspace));
         const compileInput = {
@@ -356,18 +356,18 @@ export class FileRoleLaunchPlanner {
         }
         // A previous attempt may have persisted a preallocated/discovered ID
         // before its receipt was committed. Reuse that fixed session rather than
-        // allocating a second native session for the same durable AgentRun.
+        // allocating a second native session for the same durable Turn.
         const resumeNativeSessionId = input.mode === "resume"
             ? requireText(input.nativeSessionId, "Native session id")
             : knownNativeSessionId;
         const launchMode = resumeNativeSessionId === undefined
             ? "new"
             : "resume";
-        const managedControl = owner.scope === "task" && input.runId !== undefined;
+        const managedControl = owner.scope === "task" && input.turnId !== undefined;
         const managedProviderEnvironment = managedControl
             && configured.adapterId === "codex"
             ? {
-                // Managed Codex Runs are non-interactive. Use the Codex execution
+                // Managed Codex Turns are non-interactive. Use the Codex execution
                 // identity for provider requests while clientInfo still identifies Yui.
                 CODEX_INTERNAL_ORIGINATOR_OVERRIDE: "codex_exec"
             }
@@ -409,17 +409,17 @@ export class FileRoleLaunchPlanner {
         }
         if (binding.adapterId === "codex") {
             // Global/interactive Codex sessions still use notify for presentation.
-            // Managed Runs receive lifecycle facts through their ordinary App Server
+            // Managed Turns receive lifecycle facts through their ordinary App Server
             // subscription, avoiding a second Hook channel for the same Turn.
-            if (owner.scope !== "task" || input.runId === undefined) {
+            if (owner.scope !== "task" || input.turnId === undefined) {
                 args = addCodexSessionNotify(args, launchMode, this.#cliPath);
             }
-            // Managed Codex Runs use disposable proxy clients against the shared
+            // Managed Codex Turns use disposable proxy clients against the shared
             // native App Server. Their Session Manifest points at the Yui Skills;
             // no Yui Hook config is installed.
-            if (owner.scope === "task" && input.runId !== undefined) {
+            if (owner.scope === "task" && input.turnId !== undefined) {
                 if (managedRun === null || managedRun.status !== "active") {
-                    throw new Error(`Managed Codex Run is no longer active: ${input.runId}.`);
+                    throw new Error(`Managed Codex Turn is no longer active: ${input.turnId}.`);
                 }
             }
             session = launchMode === "resume"
@@ -439,9 +439,9 @@ export class FileRoleLaunchPlanner {
         }
         const managedClaudeRun = binding.adapterId === "claude"
             && owner.scope === "task"
-            && input.runId !== undefined;
+            && input.turnId !== undefined;
         if (managedClaudeRun && (managedRun === null || managedRun.status !== "active")) {
-            throw new Error(`Managed Claude Run is no longer active: ${input.runId}.`);
+            throw new Error(`Managed Claude Turn is no longer active: ${input.turnId}.`);
         }
         const runtimeDescriptor = owner.scope === "task"
             ? createExactTaskRuntimeDescriptor({
@@ -451,7 +451,7 @@ export class FileRoleLaunchPlanner {
                 agentId: configured.id,
                 adapterId: configured.adapterId,
                 workspace: effectiveWorkspace,
-                ...(input.runId === undefined ? {} : { runId: input.runId }),
+                ...(input.turnId === undefined ? {} : { turnId: input.turnId }),
                 ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
                 ...(session === null
                     ? {}
@@ -474,15 +474,15 @@ export class FileRoleLaunchPlanner {
         }
         // Session lifecycle and Turn submission are separate atomic operations.
         // Planning only starts or restores the exact native Session; delivery
-        // submits the Run input after that Session fact is durable.
+        // submits the Turn input after that Session fact is durable.
         if (managedControl && (managedRun === null || managedRun.status !== "active")) {
-            throw new Error(`Managed Run is no longer active: ${input.runId}.`);
+            throw new Error(`Managed Turn is no longer active: ${input.turnId}.`);
         }
         const providerAuthority = managedControl
             ? this.#providerAuthorityForLaunch(owner.taskId, role.name, input.launchId, input.mode)
             : undefined;
         const providerOwnedTurn = managedControl && input.mode === "resume"
-            ? this.#providerOwnedTurnForLaunch(owner.taskId, role.name, input.runId)
+            ? this.#providerOwnedTurnForLaunch(owner.taskId, role.name, input.turnId)
             : undefined;
         const providerNativeSessionId = binding.adapterId === "claude"
             ? preallocatedNativeSessionId
@@ -557,7 +557,7 @@ export class FileRoleLaunchPlanner {
                 ...(input.launchId === undefined
                     ? {}
                     : { YUI_LAUNCH_ID: input.launchId }),
-                ...(input.runId === undefined ? {} : { YUI_RUN_ID: input.runId }),
+                ...(input.turnId === undefined ? {} : { YUI_TURN_ID: input.turnId }),
                 ...(session === null
                     ? {}
                     : { YUI_NATIVE_SESSION_ID: session.nativeSessionId })
@@ -567,7 +567,13 @@ export class FileRoleLaunchPlanner {
         const scopedLaunch = owner.scope === "task"
             ? this.#applyWorkspaceScope(owner.taskId, role, launch, workspaceOverride)
             : launch;
-        const ordinaryConversationLaunch = withCodexThreadEnvironment(scopedLaunch);
+        const sharedDaemonLaunch = owner.scope === "global" && configured.adapterId === "codex"
+            ? {
+                ...scopedLaunch,
+                args: addCodexSharedDaemonRemote(scopedLaunch.args, launchMode, scopedLaunch.env)
+            }
+            : scopedLaunch;
+        const ordinaryConversationLaunch = withCodexThreadEnvironment(sharedDaemonLaunch);
         return {
             role: {
                 name: role.name,
@@ -617,17 +623,18 @@ export class FileRoleLaunchPlanner {
         }
         throw new Error(`Provider writer authority is unknown: ${taskId}/${roleName}.`);
     }
-    #providerOwnedTurnForLaunch(taskId, roleName, runId) {
+    #providerOwnedTurnForLaunch(taskId, roleName, turnId) {
         const binding = this.store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding;
-        if (binding === null || binding === undefined || binding.turn?.runId !== runId)
+        if (binding === null || binding === undefined
+            || binding.turn?.turnId !== turnId)
             return undefined;
         const turn = binding.turn;
-        if (turn === null || !["accepted", "running"].includes(turn.status))
+        if (turn === null || turn.status !== "accepted")
             return undefined;
-        if (turn.turnId === undefined) {
+        if (turn.nativeTurnId === undefined) {
             throw new Error(`Active Provider Turn has no native identity: ${taskId}/${roleName}.`);
         }
-        return { attemptId: turn.attemptId, turnId: turn.turnId };
+        return { attemptId: turn.attemptId, turnId: turn.nativeTurnId };
     }
     #applyWorkspaceScope(taskId, role, launch, workspaceOverride) {
         const workspace = workspaceOverride
@@ -748,17 +755,16 @@ function ensureClaudeLifecyclePlugin(home, cliPath) {
     }, null, 2)}\n`);
     return root;
 }
-function managedClaudeControlPlaneConfig(config, taskId, workItemId, runId) {
+function managedClaudeControlPlaneConfig(config, taskId, workItemId, turnId) {
     if (config.permission.strategy !== "configured")
         return config;
     const managed = [
-        `Bash(yui task run context ${taskId}/${runId}:*)`,
+        `Bash(yui task turn context ${taskId}/${turnId}:*)`,
         `Bash(yui --json task context ${taskId})`,
         `Bash(yui --json task work list ${taskId})`,
         ...(workItemId === undefined
             ? []
-            : [`Bash(yui --json task work show ${workItemId})`]),
-        `Bash(yui task run yield ${runId} --summary-file -:*)`
+            : [`Bash(yui --json task work show ${workItemId})`])
     ];
     const existing = (config.permission.allowedTools ?? [])
         .filter((rule) => !isManagedYuiBashRule(rule));
@@ -830,10 +836,38 @@ function addCodexSessionNotify(args, mode, cliPath) {
     }
     return [...args.slice(0, -2), ...managed, ...args.slice(-2)];
 }
+/**
+ * Global Codex keeps its native TUI, but the TUI is only a client attachment
+ * to the user's shared App Server. The daemon owns the Thread and its writer,
+ * so Desktop can open the same Yui-created Thread without a second rollout
+ * writer or a Yui-specific takeover.
+ */
+export function addCodexSharedDaemonRemote(args, mode, environment = {}) {
+    const sessionEnvironment = Object.fromEntries(Object.entries(environment).filter(([name]) => name.startsWith("YUI_")));
+    const remote = [
+        "--remote",
+        "unix://",
+        ...(Object.keys(sessionEnvironment).length === 0
+            ? []
+            : ["--config", codexShellEnvironmentConfig(sessionEnvironment)])
+    ];
+    if (mode === "new")
+        return [...args, ...remote];
+    if (args.length < 2 || args.at(-2) !== "resume") {
+        throw new Error("Codex resume launch shape is invalid.");
+    }
+    return [...args.slice(0, -2), ...remote, ...args.slice(-2)];
+}
+function codexShellEnvironmentConfig(environment) {
+    const entries = Object.entries(environment)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => `${JSON.stringify(name)}=${JSON.stringify(value)}`);
+    return `shell_environment_policy.set={${entries.join(",")}}`;
+}
 /**
  * Codex 0.145 discovers lifecycle hooks from its effective config. Keep Yui's
  * two handlers invocation-local: this avoids mutating CODEX_HOME or the Task
- * workspace, while the exact launch environment supplies the durable Run fence.
+ * workspace, while the exact launch environment supplies the durable Turn fence.
  */
 function codexLifecycleHooksConfig(cliPath) {
     const command = [

package/dist/executor/launchPlan.js

@@ -1,13 +1,13 @@
-export function withYuiRunEnvironment(launch, yuiHome, role, run, nativeSessionId, nativeSessionRoot) {
+export function withYuiTurnEnvironment(launch, yuiHome, role, turn, nativeSessionId, nativeSessionRoot) {
     return {
         ...launch,
         env: {
             ...launch.env,
             YUI_HOME: yuiHome,
-            YUI_TASK_ID: run.taskId,
+            YUI_TASK_ID: turn.taskId,
             YUI_ROLE: role.name,
             YUI_AGENT_ID: role.activeAgentId ?? role.agent ?? "",
-            YUI_RUN_ID: run.id,
+            YUI_TURN_ID: turn.id,
             YUI_WORKSPACE: role.workspace,
             ...(nativeSessionRoot === undefined ? {} : { YUI_NATIVE_SESSION_ROOT: nativeSessionRoot }),
             ...(nativeSessionId === undefined ? {} : { YUI_NATIVE_SESSION_ID: nativeSessionId })

package/dist/executor/workspacePreflightClassification.js

@@ -20,7 +20,7 @@ function ownerLabel(owner) {
  * This is a read-only check: it never mutates Git state, creates Sessions, or
  * writes recovery records.
  */
-export function classifyWorkspacePreflight(store, task, roleName, activeRun, inspectPhysical) {
+export function classifyWorkspacePreflight(store, task, roleName, activeTurn, inspectPhysical) {
     const main = store.getTaskWorkspace(task.id);
     const bindings = task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory }));
     // 1. Owner validation: the Task main workspace must be a durable,
@@ -41,26 +41,26 @@ export function classifyWorkspacePreflight(store, task, roleName, activeRun, ins
             actual
         };
     }
-    // 2. Run snapshot validation: when the active Run carries a workspace
+    // 2. Turn snapshot validation: when the active Turn carries a workspace
     //    snapshot its launch-stable identity must match the durable
     //    ManagedWorkspace. Audit timestamps may change without changing the
-    //    owner, root, or Project entries authorized for the Run.
-    if (activeRun?.workspace !== undefined) {
-        const durableRunWorkspace = store.getManagedWorkspace(activeRun.workspace.owner);
+    //    owner, root, or Project entries authorized for the Turn.
+    if (activeTurn?.workspace !== undefined) {
+        const durableRunWorkspace = store.getManagedWorkspace(activeTurn.workspace.owner);
         if (durableRunWorkspace === null
-            || !sameManagedWorkspaceIdentity(durableRunWorkspace, activeRun.workspace)) {
+            || !sameManagedWorkspaceIdentity(durableRunWorkspace, activeTurn.workspace)) {
             const diff = [];
             if (durableRunWorkspace === null) {
-                diff.push(`durable ManagedWorkspace for owner ${JSON.stringify(activeRun.workspace.owner)} is missing`);
+                diff.push(`durable ManagedWorkspace for owner ${JSON.stringify(activeTurn.workspace.owner)} is missing`);
             }
             else {
-                if (durableRunWorkspace.root !== activeRun.workspace.root) {
-                    diff.push(`root: durable=${durableRunWorkspace.root} run=${activeRun.workspace.root}`);
+                if (durableRunWorkspace.root !== activeTurn.workspace.root) {
+                    diff.push(`root: durable=${durableRunWorkspace.root} run=${activeTurn.workspace.root}`);
                 }
-                if (durableRunWorkspace.entries.length !== activeRun.workspace.entries.length) {
-                    diff.push(`entries: durable=${durableRunWorkspace.entries.length} run=${activeRun.workspace.entries.length}`);
+                if (durableRunWorkspace.entries.length !== activeTurn.workspace.entries.length) {
+                    diff.push(`entries: durable=${durableRunWorkspace.entries.length} run=${activeTurn.workspace.entries.length}`);
                 }
-                for (const [index, entry] of activeRun.workspace.entries.entries()) {
+                for (const [index, entry] of activeTurn.workspace.entries.entries()) {
                     const durableEntry = durableRunWorkspace.entries[index];
                     if (durableEntry === undefined) {
                         diff.push(`entry[${index}] ${entry.projectId}: missing from durable`);
@@ -76,10 +76,10 @@ export function classifyWorkspacePreflight(store, task, roleName, activeRun, ins
             }
             return {
                 kind: "workspace-stale",
-                reason: `Role Run workspace is not the durable owner: ${task.id}/${roleName}.`,
+                reason: `Role Turn workspace is not the durable owner: ${task.id}/${roleName}.`,
                 taskId: task.id,
                 roleName,
-                runId: activeRun.id,
+                turnId: activeTurn.id,
                 diff
             };
         }
@@ -89,7 +89,7 @@ export function classifyWorkspacePreflight(store, task, roleName, activeRun, ins
     // from that immutable boundary. A reset/repoint outside the lineage is
     // physical drift and must fail before Provider launch.
     if (inspectPhysical !== undefined) {
-        const effective = activeRun?.workspace ?? main;
+        const effective = activeTurn?.workspace ?? main;
         for (const entry of effective.entries) {
             const physical = inspectPhysical(entry);
             if (!physical.recordedBaseIsAncestor) {
@@ -121,7 +121,7 @@ export function formatWorkspacePreflightError(classification) {
                 + "` to inspect the binding, ManagedWorkspace, and physical HEAD.");
             break;
         case "workspace-stale":
-            lines.push(`  Run ${classification.runId} snapshot differs from the durable ManagedWorkspace:`);
+            lines.push(`  Turn ${classification.turnId} snapshot differs from the durable ManagedWorkspace:`);
             for (const entry of classification.diff) {
                 lines.push(`    - ${entry}`);
             }

package/dist/grant/capabilityGrant.js

@@ -1,6 +1,6 @@
 import { requireIdentity, requireText, requireTimestamp, requirePositiveInteger } from "../domain/validation.js";
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
-export const CAPABILITY_GRANT_SCHEMA_VERSION = 1;
+export const CAPABILITY_GRANT_SCHEMA_VERSION = 2;
 const IRREVERSIBILITY_RANK = {
     none: 0,
     reversible: 1,
@@ -19,6 +19,7 @@ export function createCapabilityGrant(id, taskId, input, now) {
         ...(input.expiresAt === undefined ? {} : { expiresAt: requireTimestamp(input.expiresAt, "Capability grant expiresAt") }),
         ...(input.maxUses === undefined ? {} : { maxUses: requirePositiveInteger(input.maxUses, "Capability grant maxUses") }),
         usesUsed: 0,
+        useReservations: Object.freeze([]),
         irreversibilityCeiling: normalizeCeiling(input.irreversibilityCeiling),
         createdAt: timestamp,
         updatedAt: timestamp
@@ -61,16 +62,14 @@ export function checkGrant(grant, request, now, options) {
     }
     return { allowed: true };
 }
-/** The reservation keys recorded on a grant, or an empty list for legacy grants. */
+/** The reservation keys recorded on a grant. */
 export function grantUseReservations(grant) {
-    return grant.useReservations ?? [];
+    return grant.useReservations;
 }
 /**
  * Record one use against the grant, failing closed once the limit is reached.
- * When `reservationKey` is supplied it is appended to the grant's durable
- * reservations so a later resume can recognize this exact attempt and avoid a
- * double charge. A use recorded without a key (legacy callers) leaves the
- * reservation list untouched.
+ * The reservation key is appended to the grant's durable reservations so a
+ * later resume recognizes this exact attempt and avoids a double charge.
  */
 export function recordGrantUse(grant, now, reservationKey) {
     validateCapabilityGrant(grant);
@@ -80,9 +79,7 @@ export function recordGrantUse(grant, now, reservationKey) {
     return validateCapabilityGrant({
         ...grant,
         usesUsed: grant.usesUsed + 1,
-        ...(reservationKey === undefined
-            ? {}
-            : { useReservations: Object.freeze([...grantUseReservations(grant), reservationKey]) }),
+        useReservations: Object.freeze([...grantUseReservations(grant), reservationKey]),
         updatedAt: now.toISOString()
     });
 }
@@ -105,7 +102,7 @@ export function revokeGrant(grant, revokedBy, now) {
 }
 export function validateCapabilityGrant(grant) {
     if (grant.schemaVersion !== CAPABILITY_GRANT_SCHEMA_VERSION) {
-        throw new Error("Capability grant must use schemaVersion 1.");
+        throw new Error("Capability grant must use schemaVersion 2.");
     }
     validateTaskRecordReference({ taskId: grant.taskId, localId: grant.id }, "capabilityGrant");
     requireIdentity(grant.taskId, "Task id");
@@ -125,22 +122,20 @@ export function validateCapabilityGrant(grant) {
     if (grant.maxUses !== undefined && grant.usesUsed > grant.maxUses) {
         throw new Error("Capability grant usesUsed cannot exceed maxUses.");
     }
-    if (grant.useReservations !== undefined) {
-        if (!Array.isArray(grant.useReservations)) {
-            throw new Error("Capability grant useReservations must be an array.");
-        }
-        for (const key of grant.useReservations) {
-            if (typeof key !== "string" || key.length === 0) {
-                throw new Error("Capability grant useReservations must be non-empty strings.");
-            }
-        }
-        if (new Set(grant.useReservations).size !== grant.useReservations.length) {
-            throw new Error("Capability grant useReservations must be unique.");
-        }
-        if (grant.useReservations.length > grant.usesUsed) {
-            throw new Error("Capability grant useReservations cannot outnumber usesUsed.");
+    if (!Array.isArray(grant.useReservations)) {
+        throw new Error("Capability grant useReservations must be an array.");
+    }
+    for (const key of grant.useReservations) {
+        if (typeof key !== "string" || key.length === 0) {
+            throw new Error("Capability grant useReservations must be non-empty strings.");
         }
     }
+    if (new Set(grant.useReservations).size !== grant.useReservations.length) {
+        throw new Error("Capability grant useReservations must be unique.");
+    }
+    if (grant.useReservations.length > grant.usesUsed) {
+        throw new Error("Capability grant useReservations cannot outnumber usesUsed.");
+    }
     normalizeCeiling(grant.irreversibilityCeiling);
     if ((grant.revokedAt === undefined) !== (grant.revokedBy === undefined)) {
         throw new Error("Capability grant revocation requires both revokedAt and revokedBy.");

package/dist/input/inputRequest.js

@@ -14,7 +14,7 @@ export function createInputRequest(id, taskId, requester, input, now) {
     const timestamp = requireDate(now, "Input request creation time");
     const choices = normalizeChoices(input.choices);
     return validateInputRequest({
-        schemaVersion: 2,
+        schemaVersion: 3,
         id: requireIdentity(id, "Input request id"),
         taskId: requireIdentity(taskId, "Input request Task id"),
         requester: normalizeRequester(requester),
@@ -72,12 +72,12 @@ export function validateInputRequest(value) {
         "schemaVersion", "id", "taskId", "requester", "question", "choices",
         "blockedRefs", "policy", "status", "createdAt", "updatedAt", ...terminalField
     ], "Input request");
-    if (request.schemaVersion !== 2)
-        throw new Error("Input request must use schemaVersion 2.");
+    if (request.schemaVersion !== 3)
+        throw new Error("Input request must use schemaVersion 3.");
     const choices = validateChoices(request.choices);
     const createdAt = requireTimestamp(request.createdAt, "Input request createdAt");
     const base = {
-        schemaVersion: 2,
+        schemaVersion: 3,
         id: requireIdentity(request.id, "Input request id"),
         taskId: requireIdentity(request.taskId, "Input request Task id"),
         requester: normalizeRequester(request.requester),
@@ -91,10 +91,10 @@ export function validateInputRequest(value) {
     validateTaskRecordReference({ taskId: base.taskId, localId: base.id }, "inputRequest");
     validateTaskRecordReference({
         taskId: base.requester.taskId,
-        localId: base.requester.runId
-    }, "agentRun");
+        localId: base.requester.turnId
+    }, "turn");
     for (const reference of base.blockedRefs) {
-        validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, reference.type === "run" ? "agentRun" : "workItem");
+        validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, reference.type === "turn" ? "turn" : "workItem");
     }
     if (base.requester.taskId !== base.taskId
         || base.blockedRefs.some(({ taskId }) => taskId !== base.taskId)) {
@@ -175,8 +175,8 @@ function normalizeBlockedRefs(value) {
     const references = value.map((reference) => {
         const item = record(reference, "Input blocked reference");
         exact(item, ["type", "taskId", "id"], "Input blocked reference");
-        if (item.type !== "work-item" && item.type !== "run") {
-            throw new Error("Input blocked reference type must be work-item or run.");
+        if (item.type !== "work-item" && item.type !== "turn") {
+            throw new Error("Input blocked reference type must be work-item or turn.");
         }
         return {
             type: item.type,
@@ -224,15 +224,15 @@ function validateBlockedRefs(value) {
 function normalizeRequester(value) {
     const requester = record(value, "Input requester");
     exact(requester, requester.nativeSessionId === undefined
-        ? ["taskId", "roleName", "agentId", "runId"]
-        : ["taskId", "roleName", "agentId", "runId", "nativeSessionId"], "Input requester");
+        ? ["taskId", "roleName", "agentId", "turnId"]
+        : ["taskId", "roleName", "agentId", "turnId", "nativeSessionId"], "Input requester");
     if (requester.roleName !== "leader")
         throw new Error("Input requester must be the Task Leader.");
     return {
         taskId: requireIdentity(requester.taskId, "Input requester Task id"),
         roleName: "leader",
         agentId: requireIdentity(requester.agentId, "Input requester Agent id"),
-        runId: requireIdentity(requester.runId, "Input requester Run id"),
+        turnId: requireIdentity(requester.turnId, "Input requester Turn id"),
         ...(requester.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireIdentity(requester.nativeSessionId, "Input requester native session id") })

package/dist/integration/changeSet.js

@@ -3,18 +3,16 @@ import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { validateChangeSetManifest } from "./changeSetManifest.js";
 export function createWorkItemChangeSet(input, now) {
     return validateChangeSet({
-        schemaVersion: 3,
+        schemaVersion: 4,
         ...input,
         changedPaths: [...input.changedPaths],
-        ...(input.manifest === undefined
-            ? {}
-            : { manifest: validateChangeSetManifest(input.manifest) }),
+        manifest: validateChangeSetManifest(input.manifest),
         createdAt: now.toISOString()
     });
 }
 export function validateChangeSet(changeSet) {
-    if (changeSet.schemaVersion !== 3)
-        throw new Error("ChangeSet must use schemaVersion 3.");
+    if (changeSet.schemaVersion !== 4)
+        throw new Error("ChangeSet must use schemaVersion 4.");
     validateTaskRecordReference({ taskId: changeSet.taskId, localId: changeSet.id }, "changeSet");
     validateTaskRecordReference({
         taskId: changeSet.taskId,
@@ -28,13 +26,11 @@ export function validateChangeSet(changeSet) {
     }
     requireText(changeSet.branch, "ChangeSet branch");
     normalizedUniqueText(changeSet.changedPaths, "ChangeSet path");
-    if (changeSet.manifest !== undefined) {
-        const manifest = validateChangeSetManifest(changeSet.manifest);
-        const changed = new Set(changeSet.changedPaths);
-        for (const deleted of manifest.deletedPaths) {
-            if (!changed.has(deleted)) {
-                throw new Error(`ChangeSet manifest deleted path is not a changed path: ${deleted}.`);
-            }
+    const manifest = validateChangeSetManifest(changeSet.manifest);
+    const changed = new Set(changeSet.changedPaths);
+    for (const deleted of manifest.deletedPaths) {
+        if (!changed.has(deleted)) {
+            throw new Error(`ChangeSet manifest deleted path is not a changed path: ${deleted}.`);
         }
     }
     requireTimestamp(changeSet.createdAt, "ChangeSet createdAt");