@zq-silk/yui 0.13.7 → 0.13.8

package/dist/role/role.js

@@ -19,19 +19,22 @@ export function createRole(taskId, name, bindings, activeAgentId, workspace, now
     const owner = createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess);
     return validateTaskRole({
         ...owner,
-        taskId: requireSafeIdentity(taskId, "Task id"),
-        status: "idle"
+        schemaVersion: 4,
+        taskId: requireSafeIdentity(taskId, "Task id")
     });
 }
 export function createGlobalRole(name, bindings, activeAgentId, workspace, now, profile = {}, defaultAccess = "write") {
-    return createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess);
+    return validateGlobalRole({
+        ...createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess),
+        schemaVersion: 3
+    });
 }
 export function copyGlobalRoleToTaskRole(globalRole, taskId, now, name = globalRole.name) {
     validateGlobalRole(globalRole);
     const timestamp = now.toISOString();
     return validateTaskRole({
         ...cloneProfile(globalRole),
-        schemaVersion: 3,
+        schemaVersion: 4,
         launchRevision: 1,
         defaultAccess: globalRole.defaultAccess,
         taskId: requireSafeIdentity(taskId, "Task id"),
@@ -39,7 +42,6 @@ export function copyGlobalRoleToTaskRole(globalRole, taskId, now, name = globalR
         activeAgentId: globalRole.activeAgentId,
         agentBindings: cloneBindings(globalRole.agentBindings),
         workspace: globalRole.workspace,
-        status: "idle",
         createdAt: timestamp,
         updatedAt: timestamp
     });
@@ -76,12 +78,6 @@ export function updateRole(role, patch, now) {
         : role.launchRevision + 1;
     return validateTaskRole(updated);
 }
-export function updateRoleStatus(role, status, now) {
-    validateTaskRole(role);
-    if (!isRoleStatus(status))
-        throw new Error(`Role status is invalid: ${status}.`);
-    return { ...role, status, updatedAt: now.toISOString() };
-}
 export function switchActiveRoleAgent(role, sessions, targetAgentId, runtime, now) {
     validateRoleOwner(role);
     const normalizedTarget = requireSafeIdentity(targetAgentId, "Target Agent id");
@@ -175,8 +171,6 @@ export function validateGlobalRole(role) {
 }
 export function validateTaskRole(role) {
     requireSafeIdentity(role.taskId, "Task id");
-    if (!isRoleStatus(role.status))
-        throw new Error(`Role status is invalid: ${role.status}.`);
     return validateRoleOwner(role);
 }
 function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile, defaultAccess) {
@@ -189,9 +183,8 @@ function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile,
         mappedBindings[binding.agentId] = binding;
     }
     const timestamp = now.toISOString();
-    return validateGlobalRole({
+    return {
         ...cloneProfile(profile),
-        schemaVersion: 3,
         launchRevision: 1,
         defaultAccess,
         name: requireSafeIdentity(name, "Role name"),
@@ -200,11 +193,13 @@ function createRoleOwner(name, bindings, activeAgentId, workspace, now, profile,
         workspace: requireText(workspace, "Role workspace"),
         createdAt: timestamp,
         updatedAt: timestamp
-    });
+    };
 }
 function validateRoleOwner(role) {
-    if (role.schemaVersion !== 3)
+    const expectedSchemaVersion = "taskId" in role ? 4 : 3;
+    if (role.schemaVersion !== expectedSchemaVersion) {
         throw new Error("Role schema version is invalid.");
+    }
     if (!Number.isSafeInteger(role.launchRevision) || role.launchRevision < 1) {
         throw new Error("Role launch revision must be a positive integer.");
     }
@@ -333,6 +328,3 @@ function requireText(value, label) {
         throw new Error(`${label} is required.`);
     return normalized;
 }
-function isRoleStatus(value) {
-    return ["idle", "running", "detached", "exited", "failed"].includes(value);
-}

package/dist/runtime/index.js

@@ -14,7 +14,7 @@ export { formatRuntimeLaunchDiagnostic, redactLaunchArgument, redactLaunchText,
 export { DEFAULT_FORCED_GRACE_MS, DEFAULT_GRACEFUL_GRACE_MS, terminateSessionOwners } from "./sessionTerminationGuard.js";
 export { ProviderContinuationReconciliationService } from "./providerContinuationReconciliationService.js";
 export { codexNotificationBoundary, codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime } from "./codexAppServerRuntime.js";
-export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rebindProviderRuntimeRun, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
+export { createProviderRuntimeBinding, acceptProviderTurn, beginProviderTurn, currentProviderActivation, currentProviderAuthority, currentProviderConversation, endProviderActivation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurnSubmission, settleProviderTurn, startProviderActivation, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
 export { FencedProviderControl } from "./providerControl.js";
 export { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
 export { decideProviderRecovery } from "./providerRecoveryDecision.js";

package/dist/runtime/providerRuntimeIdentity.js

@@ -1,10 +1,9 @@
 export function createProviderRuntimeBinding(input) {
     const startedAt = timestamp(input.startedAt, "Provider Activation startedAt");
     return validateProviderRuntimeBinding({
-        schemaVersion: 2,
+        schemaVersion: 3,
         providerNamespace: identity(input.providerNamespace, "Provider namespace"),
         accountScope: identity(input.accountScope, "Provider account scope"),
-        runId: identity(input.runId, "Run id"),
         currentConversationEpoch: 1,
         conversations: [{
                 conversationId: identity(input.conversationId, "Provider Conversation id"),
@@ -40,17 +39,6 @@ export function currentProviderActivation(binding) {
     const conversation = currentProviderConversation(binding);
     return [...binding.activations].reverse().find((entry) => (entry.conversationId === conversation.conversationId && entry.status === "active")) ?? null;
 }
-/** Rebinds the live Conversation state to the next Yui Run without resetting authority. */
-export function rebindProviderRuntimeRun(raw, runId) {
-    const binding = validateProviderRuntimeBinding(raw);
-    if (providerTurnIsActive(binding.turn)) {
-        throw new Error("Provider Runtime cannot bind another Run while a Turn is unsettled.");
-    }
-    return validateProviderRuntimeBinding({
-        ...binding,
-        runId: identity(runId, "Run id")
-    });
-}
 export function startProviderActivation(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
     if (currentProviderActivation(binding) !== null) {
@@ -158,8 +146,10 @@ export function transferProviderAuthority(raw, input) {
 }
 export function beginProviderTurn(raw, input) {
     const binding = validateProviderRuntimeBinding(raw);
+    const runId = identity(input.runId, "Run id");
     const attemptId = identity(input.attemptId, "Provider input attempt id");
-    if (binding.turn?.attemptId === attemptId
+    if (binding.turn?.runId === runId
+        && binding.turn.attemptId === attemptId
         && binding.turn.authorityEpoch === input.authorityEpoch
         && binding.turn.status === "submitting") {
         return binding;
@@ -176,6 +166,7 @@ export function beginProviderTurn(raw, input) {
     return validateProviderRuntimeBinding({
         ...binding,
         turn: {
+            runId,
             attemptId,
             authorityEpoch: input.authorityEpoch,
             status: "submitting",
@@ -350,11 +341,10 @@ export function supersedeProviderConversation(raw, input) {
     });
 }
 export function validateProviderRuntimeBinding(value) {
-    if (value.schemaVersion !== 2)
-        throw new Error("Provider Runtime Binding schemaVersion must be 2.");
+    if (value.schemaVersion !== 3)
+        throw new Error("Provider Runtime Binding schemaVersion must be 3.");
     identity(value.providerNamespace, "Provider namespace");
     identity(value.accountScope, "Provider account scope");
-    identity(value.runId, "Run id");
     integer(value.currentConversationEpoch, 1, "Current Provider Conversation epoch");
     if (!Array.isArray(value.conversations) || value.conversations.length === 0) {
         throw new Error("Provider Runtime Binding requires a Conversation.");
@@ -459,6 +449,7 @@ export function validateProviderRuntimeBinding(value) {
     return value;
 }
 function validateProviderTurn(turn, currentAuthorityEpoch) {
+    identity(turn.runId, "Run id");
     identity(turn.attemptId, "Provider input attempt id");
     integer(turn.authorityEpoch, 1, "Provider Turn authority epoch");
     if (turn.authorityEpoch > currentAuthorityEpoch) {

package/dist/scheduler/activeRoleRunDelivery.js

@@ -497,17 +497,9 @@ async function processActiveRunContinuation(store, delivery, task, role, run, no
         };
     }
     // Managed input has one write path: a new structured Turn at a settled
-    // boundary. Corrections retain their priority while the current Turn runs.
+    // boundary. AgentHost owns Provider serialization; a busy send releases the
+    // claim and leaves the durable correction pending for the next pass.
     const mode = "followup";
-    if (session.status === "running") {
-        return {
-            taskId: task.id,
-            roleName: role.name,
-            runId: run.id,
-            status: "skipped",
-            reason: "not-ready"
-        };
-    }
     if (writer === null) {
         return {
             taskId: task.id,

package/dist/scheduler/activeTaskProgress.js

@@ -25,8 +25,6 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             const run = store.getActiveAgentRun(task.id, role.name);
             return run === null ? [] : [run];
         });
-        const hasInFlightTurn = roles.some((role) => store.hasInFlightTurn(task.id, role.name));
-        const hasLeaderInFlightTurn = store.hasInFlightTurn(task.id, "leader");
         const leaderTarget = { kind: "role", taskId: task.id, roleName: "leader" };
         const leaderMailbox = store.getWorkMailbox(leaderTarget);
         const projection = projectTaskExecution({
@@ -41,8 +39,7 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             && !activeRuns.some(({ roleName }) => roleName === "leader")
             && activeRuns.some(({ roleName }) => roleName !== "leader")
             && projection.status === "waiting-on-agents";
-        if ((queuedAlongsideActiveSibling ? hasLeaderInFlightTurn : hasInFlightTurn)
-            || store.hasOpenInputRequest(task.id)
+        if (store.hasOpenInputRequest(task.id)
             || store.getLeaderFailure(task.id) !== null
             || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
             || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {

package/dist/scheduler/leaderWakeupProcessor.js

@@ -42,11 +42,6 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             results.push({ taskId: task.id, status: "skipped", reason: "busy" });
             continue;
         }
-        if (typeof store.hasInFlightTurn === "function"
-            && store.hasInFlightTurn(task.id, role.name)) {
-            results.push({ taskId: task.id, status: "skipped", reason: "busy" });
-            continue;
-        }
         const reopening = wakeup.reasons.includes("task-reopened");
         let existingSession = store.getRoleSession(task.id, role.name, reopening ? undefined : role.effective.agentId);
         let effectiveSession = existingSession;

package/dist/scheduler/roleRunStall.js

@@ -786,7 +786,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             continue;
         const evidenceKey = [
             kind,
-            stallEvidenceKey(candidate.role.status, candidate.session?.status),
+            stallEvidenceKey(candidate.session?.status),
             classification,
             ...(candidate.role.name === "leader"
                 ? [leaderStallEvidence(store, candidate.task.id, observed, now, windowMs)]
@@ -1001,8 +1001,8 @@ function leaderStallEvidence(store, taskId, observed, now, windowMs) {
                 : "recent";
     return `downstream=active:${active},healthy:${healthy},stalled:${stalled}:leader-mailbox=${pendingAge},leader-processing=${processingAge}`;
 }
-function stallEvidenceKey(roleStatus, sessionStatus) {
-    return `live-pane-no-progress:role=${roleStatus}:session=${sessionStatus ?? "unknown"}`;
+function stallEvidenceKey(sessionStatus) {
+    return `live-pane-no-progress:session=${sessionStatus ?? "unknown"}`;
 }
 function exactLiveStatuses(statuses, candidates) {
     const expected = new Set(candidates.map(({ task, role }) => `${task.id}\0${role.name}`));

package/dist/storage/migration/productionRegistry.js

@@ -99,10 +99,14 @@ const RELEASE_WORKFLOW_FROM_VERSION = 0;
 const RELEASE_WORKFLOW_TO_VERSION = 1;
 const WORK_MAILBOX_FROM_VERSION = 1;
 const WORK_MAILBOX_TO_VERSION = 2;
+const TASK_ROLE_FROM_VERSION = 3;
+const TASK_ROLE_TO_VERSION = 4;
 const TASK_ROLE_SESSION_SET_FROM_VERSION = 4;
 const TASK_ROLE_SESSION_SET_TO_VERSION = 5;
 const STRUCTURED_PROVIDER_SESSION_SET_FROM_VERSION = 5;
 const STRUCTURED_PROVIDER_SESSION_SET_TO_VERSION = 6;
+const AGENT_FIRST_SESSION_SET_FROM_VERSION = 6;
+const AGENT_FIRST_SESSION_SET_TO_VERSION = 7;
 const PUBLICATION_REFERENCE_FROM_VERSION = 0;
 const PUBLICATION_REFERENCE_TO_VERSION = 1;
 const CONFIG_FROM_VERSION = 1;
@@ -203,12 +207,68 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(capabilityGrantIntroductionStep())
         .registerOfflineMigration(releaseWorkflowIntroductionStep())
         .registerOfflineMigration(workMailboxV2Step())
+        .registerOfflineMigration(agentRunOwnedTaskRoleStep())
         .registerOfflineMigration(taskRoleSessionSetV5Step())
         .registerOfflineMigration(structuredProviderSessionSetV6Step())
+        .registerOfflineMigration(agentFirstSessionSetV7Step())
         .registerOfflineMigration(publicationReferenceIntroductionStep());
     assertRegistryCoversBaselineToCurrent(registry);
     return registry;
 }
+/** Removes the independently writable Role runtime projection; AgentRun owns workflow activity. */
+function agentRunOwnedTaskRoleStep() {
+    return {
+        axis: "record",
+        recordKind: "taskRole",
+        fromVersion: TASK_ROLE_FROM_VERSION,
+        toVersion: TASK_ROLE_TO_VERSION,
+        preconditions: requireTaskRoleV3Family,
+        transform: migrateTaskRoleV3ToV4,
+        declaredEffects: []
+    };
+}
+function requireTaskRoleV3Family(snapshot) {
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (versions.taskRole !== TASK_ROLE_FROM_VERSION) {
+        throw new Error(`Record taskRole migration requires manifest version ${TASK_ROLE_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawAggregate] of Object.entries(tasks)) {
+        const aggregate = asObject(rawAggregate, `Task aggregate ${taskId}`);
+        const roles = asObject(aggregate.roles, `Task Roles ${taskId}`);
+        for (const [roleName, rawRole] of Object.entries(roles)) {
+            const role = asObject(rawRole, `Task Role ${taskId}/${roleName}`);
+            if (role.schemaVersion !== TASK_ROLE_FROM_VERSION) {
+                throw new Error(`Task Role ${taskId}/${roleName} must use schemaVersion ${TASK_ROLE_FROM_VERSION}.`);
+            }
+        }
+    }
+}
+function migrateTaskRoleV3ToV4(snapshot) {
+    requireTaskRoleV3Family(snapshot);
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...versions, taskRole: TASK_ROLE_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = Object.fromEntries(Object.entries(tasks).map(([taskId, rawAggregate]) => {
+        const aggregate = asObject(rawAggregate, `Task aggregate ${taskId}`);
+        const roles = asObject(aggregate.roles, `Task Roles ${taskId}`);
+        const nextRoles = Object.fromEntries(Object.entries(roles).map(([roleName, rawRole]) => {
+            const role = asObject(rawRole, `Task Role ${taskId}/${roleName}`);
+            const { status: _status, ...retained } = role;
+            void _status;
+            return [roleName, { ...retained, schemaVersion: TASK_ROLE_TO_VERSION }];
+        }));
+        return [taskId, { ...aggregate, roles: nextRoles }];
+    }));
+    return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
+}
 function configV2Step() {
     return {
         axis: "record",
@@ -2718,6 +2778,89 @@ function structuredProviderSessionSetV6Step() {
         declaredEffects: []
     };
 }
+/**
+ * A Provider binding describes one reusable Conversation. Run correlation now
+ * belongs to the concrete Provider Turn instead of making the Conversation a
+ * second writable projection of the current AgentRun.
+ */
+function agentFirstSessionSetV7Step() {
+    return {
+        axis: "record",
+        recordKind: "taskRoleSessionSet",
+        fromVersion: AGENT_FIRST_SESSION_SET_FROM_VERSION,
+        toVersion: AGENT_FIRST_SESSION_SET_TO_VERSION,
+        preconditions: requireTaskRoleSessionSetV6Family,
+        transform: migrateTaskRoleSessionSetV6ToV7,
+        declaredEffects: []
+    };
+}
+function requireTaskRoleSessionSetV6Family(snapshot) {
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (versions.taskRoleSessionSet !== AGENT_FIRST_SESSION_SET_FROM_VERSION) {
+        throw new Error(`Record taskRoleSessionSet migration requires manifest version ${AGENT_FIRST_SESSION_SET_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawAggregate] of Object.entries(tasks)) {
+        const aggregate = asObject(rawAggregate, `Task aggregate ${taskId}`);
+        const sets = asObject(aggregate.roleSessionSets, `Task Role session sets ${taskId}`);
+        for (const [roleName, rawSet] of Object.entries(sets)) {
+            const set = asObject(rawSet, `Task Role session set ${taskId}/${roleName}`);
+            if (set.schemaVersion !== AGENT_FIRST_SESSION_SET_FROM_VERSION) {
+                throw new Error(`Task Role session set ${taskId}/${roleName} must use schemaVersion ${AGENT_FIRST_SESSION_SET_FROM_VERSION}.`);
+            }
+            if (set.providerBinding !== null) {
+                const binding = asObject(set.providerBinding, `Provider Binding ${taskId}/${roleName}`);
+                if (binding.schemaVersion !== 2 || typeof binding.runId !== "string") {
+                    throw new Error(`Provider Binding ${taskId}/${roleName} must use schemaVersion 2.`);
+                }
+            }
+        }
+    }
+}
+function migrateTaskRoleSessionSetV6ToV7(snapshot) {
+    requireTaskRoleSessionSetV6Family(snapshot);
+    const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...versions,
+            taskRoleSessionSet: AGENT_FIRST_SESSION_SET_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawAggregate] of Object.entries(tasks)) {
+        const aggregate = asObject(rawAggregate, `Task aggregate ${taskId}`);
+        const rawSets = asObject(aggregate.roleSessionSets, `Task Role session sets ${taskId}`);
+        const nextSets = {};
+        for (const [roleName, rawSet] of Object.entries(rawSets)) {
+            const set = asObject(rawSet, `Task Role session set ${taskId}/${roleName}`);
+            let providerBinding = null;
+            if (set.providerBinding !== null) {
+                const binding = asObject(set.providerBinding, `Provider Binding ${taskId}/${roleName}`);
+                const { runId, ...conversation } = binding;
+                providerBinding = {
+                    ...conversation,
+                    schemaVersion: 3,
+                    turn: binding.turn === null
+                        ? null
+                        : { ...asObject(binding.turn, `Provider Turn ${taskId}/${roleName}`), runId }
+                };
+            }
+            nextSets[roleName] = {
+                ...set,
+                schemaVersion: AGENT_FIRST_SESSION_SET_TO_VERSION,
+                providerBinding
+            };
+        }
+        nextTasks[taskId] = { ...aggregate, roleSessionSets: nextSets };
+    }
+    return { schemaManifest, state: { ...snapshot.state, tasks: nextTasks } };
+}
 function requireTaskRoleSessionSetV5Family(snapshot) {
     const versions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
     if (versions.taskRoleSessionSet !== STRUCTURED_PROVIDER_SESSION_SET_FROM_VERSION) {

package/dist/storage/taskStore.js

@@ -64,7 +64,7 @@ export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 3;
 export const CURRENT_TASK_SCHEMA_VERSION = 6;
 export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
-export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 3;
+export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 4;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
 export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 12;
 export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 6;
@@ -118,7 +118,7 @@ export const CURRENT_STORED_TASK_SCHEMA_VERSION = 18;
  * Keep these named at the storage boundary so the upgrade record-axis map can
  * assert it is classifying the same bytes the store reads and writes.
  */
-export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 6;
+export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 7;
 /**
  * v7 combines optional Issue 04 retry/receipt fields and Issue 05 Leader
  * actionability fields. All are optional, so the v6→v7 migration is a

package/dist/web/webSnapshot.js

@@ -92,6 +92,9 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
             const effectiveLaunch = activeRun?.effective ?? activeSession?.effective ?? null;
             return {
                 ...role,
+                // Presentation only: workflow activity is derived from AgentRun; the
+                // native Session contributes lifecycle detail when no Run is active.
+                status: activeRun === undefined ? activeSession?.status ?? "idle" : "running",
                 sessionTokens: projectSessionTokenMetrics(events, resolveSessionTokenIdentity(activeSession === undefined
                     ? null
                     : { taskId, roleName: role.name, ...activeSession })),

package/i18n/README.zh-CN.md

@@ -2,9 +2,15 @@
 
 # Yui
 
-Yui 是面向持久 Codex/Claude 工作的本地控制平面。用户只需和 Operator
-对话；Operator 将不同 Project 的需求、Bug、审查和问题咨询路由到对应
-Task，Leader 再负责拆解、执行选择、验收和安全集成。
+Yui 是面向智能 Codex/Claude Agent 的本地控制平面。它持久保存用户意图、
+Project Knowledge、Task、交接和结果，并提供上下文、消息、委派、工作区、
+Session、审查和集成等小而原子的能力。Agent 组合这些能力，自主决定规划、
+顺序、委派、重试和恢复。
+
+Yui 不把 Agent 的判断固化成确定性的工作流引擎。核心只负责持久身份、用户
+授权、工作区隔离和原子状态变更；Provider Session 与运行时观测用于执行和
+连续性，但不是 Task 事实的另一套来源。用户只需和 Operator 对话，Operator
+负责路由，Leader 负责目标拆解、执行选择、验收和集成。
 
 当前实现保留实用的 Role/Agent/session 与 CLI 框架，不恢复后期膨胀的数据维护、租约、定时调度和恢复账本体系。
 
@@ -514,6 +520,8 @@ Task 生命周期的交互选择只展示有效来源状态：activate 只展示
 
 Run、Conversation、Activation 与 Turn 是四个独立身份。Conversation 可以跨多个 Run 和客户端连接；Activation 只代表 Yui 当前的连接，而不是对 Provider thread 的独占所有权；Turn 在写入前先持久化。写入超时或结果不明确会进入 `delivery-unknown`，不会自动重发。Codex 已存在的原生 active Turn 只会让 Yui 暂时等待，不会导致 Yui Run 失败；Claude 等独立进程 Provider 继续通过 Yui 的 view/takeover 边界进行人工控制。
 
+AgentRun 是 Role 是否有工作正在执行的唯一持久调度状态。Conversation 不再维护另一份 current Run；Provider Turn 中的 Run id 只用于关联接收回执和终态事件。TaskRole 本身只保存身份和期望启动配置，不再保存可写的运行状态；CLI/Web 展示的 Role 状态由活动 AgentRun 派生，并叠加 Session/Driver 生命周期事实用于诊断。Agent 可以在 Provider 终态到达前声明旧 Run 的语义结果，下一批 mailbox 工作也可以先形成新的 AgentRun；Agent Host 仍会串行等待旧 Turn 结束，再投递被保留的新输入，不回滚事件，也不把旧 Conversation 强行换绑到新 Run。
+
 Task Role 使用以下显式入口：
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.13.7",
+  "version": "0.13.8",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-runtime/SKILL.md

@@ -12,10 +12,11 @@ workspace layout, native transcript, or an earlier Run.
 For every managed Task Run:
 
 1. Read the exact Run identity from the newest Bootstrap Envelope.
-2. Before acting, load its authorized pack with the ordinary Yui CLI command:
+2. Before acting, load its authorized pack with the Session CLI named by the
+   current Session Manifest:
 
    ```sh
-   yui task run context "$YUI_TASK_ID/<run-id>" --json
+   "$YUI_SESSION_CLI" task run context "$YUI_TASK_ID/<run-id>" --json
    ```
 
 3. Verify that the returned Task, Run, Role, purpose, Snapshot digest, workspace,
@@ -27,7 +28,7 @@ For every managed Task Run:
    `refId`:
 
    ```sh
-   yui task run context expand "$YUI_TASK_ID/<run-id>" <ref-id> --store <store> --mode full --json
+   "$YUI_SESSION_CLI" task run context expand "$YUI_TASK_ID/<run-id>" <ref-id> --store <store> --mode full --json
    ```
 
    A bare `<ref-id>` remains supported only when it identifies exactly one
@@ -46,7 +47,7 @@ For a global Operator or custom GlobalRole Session, load the stable authorized v
 before routing or acting:
 
 ```sh
-yui session context "$YUI_ROLE" --json
+"$YUI_SESSION_CLI" session context "$YUI_ROLE" --json
 ```
 
 Global context grants no Task implementation workspace. Read a Task only after