@zq-silk/yui 0.13.6 → 0.13.8

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 框架，不恢复后期膨胀的数据维护、租约、定时调度和恢复账本体系。
 
@@ -510,9 +516,11 @@ Task 生命周期的交互选择只展示有效来源状态：activate 只展示
 
 ## Session 与 tmux
 
-受管理的 Provider 会话仍然是普通用户会话。Yui 只添加对应的 Role Skill 与 Session Manifest 指针，并通过 Provider 原生结构化协议提交 Task 工作；Yui 不接管完整对话历史。受管理输入绝不会作为终端按键、粘贴文本或启动 argv 发送。Codex 由每个存活的 Role Runtime 启动并持有独立的 `app-server` 子进程；Task execution stop 会终止 Agent Host 及其 Provider 进程组，start 会创建新的受控运行时，不再依赖共享 Codex daemon。原生 thread 历史仍由 Codex 保留，Task、WorkItem、代码与持久消息仍由 Yui 保留。Claude 继续使用独立的持久 stream-json 进程，并以精确回放的 user message 作为接收确认。
+受管理的 Provider 会话仍然是普通用户会话。Yui 只添加对应的 Role Skill 与 Session Manifest 指针，并通过 Provider 原生结构化协议提交 Task 工作；Yui 不接管完整对话历史。受管理输入绝不会作为终端按键、粘贴文本或启动 argv 发送。Codex 在只转发字节的 `app-server proxy` 上完成 App Server WebSocket 握手，接入与 Desktop 相同的共享 daemon；原生 thread 可在 Desktop 中直接查看和操作。Task execution stop 只终止 Yui 的 Agent Host、WebSocket 与 proxy，保留共享 daemon、原生 thread、Task、WorkItem、代码与持久消息；start 创建新的 attachment。Claude 继续使用独立的持久 stream-json 进程，并以精确回放的 user message 作为接收确认。
+
+Run、Conversation、Activation 与 Turn 是四个独立身份。Conversation 可以跨多个 Run 和客户端连接；Activation 只代表 Yui 当前的连接，而不是对 Provider thread 的独占所有权；Turn 在写入前先持久化。写入超时或结果不明确会进入 `delivery-unknown`，不会自动重发。Codex 已存在的原生 active Turn 只会让 Yui 暂时等待，不会导致 Yui Run 失败；Claude 等独立进程 Provider 继续通过 Yui 的 view/takeover 边界进行人工控制。
 
-Run、Conversation、Activation 与 Turn 是四个独立身份。Conversation 可以跨多个 Run 和客户端连接；Activation 只代表 Yui 当前的连接，而不是对 Provider thread 的独占所有权；Turn 在写入前先持久化。写入超时或结果不明确会进入 `delivery-unknown`，不会自动重发。已经存在的原生 active Turn 只会让 Yui 暂时等待，不会导致 Yui Run 失败；存活的受管理 Role 应通过 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 使用以下显式入口：
 
@@ -524,7 +532,7 @@ yui task role takeover <task-id> <role>
 yui task role release <task-id> <role>
 ```
 
-Codex Role thread 仍可在 Desktop 中查看，但存活的受管理 Role 应通过 `view`、`takeover`、`release` 进行人工控制；若要从其他客户端恢复该 thread，应先停止 Task execution。Yui 不写入全局 Hook/config，也不依赖或控制共享 Codex daemon。Global Operator 与 global Role 继续使用原生交互式 CLI，不属于受管理 Task Provider 协议。
+Codex Role thread 可在 Desktop 中直接查看和操作；Desktop 已有 active Turn 时，Yui 只保留待投递工作并等待，不会失败或重复投递。`view`、`takeover`、`release` 继续作为 Claude 等独立进程 Provider 的人工控制入口。Yui 不写入全局 Hook/config，也不启动、重启或停止共享 daemon；Codex CLI/daemon 故障由 Task 生命周期之外修复。Global Operator 与 global Role 继续使用原生交互式 CLI，不属于受管理 Task Provider 协议。
 
 当新版本需要离线迁移 Home 时，应等待当前 Turn/Run 完成，然后从普通 shell
 执行 `yui session stop --all`，再重新执行 `yui update`。停止命令会先整体预检：
@@ -560,7 +568,7 @@ state、receipt 与 pane fence。Yui 不会解析 prompt glyph、进度文本、
 或其他 Agent 终端输出来推断 ready 或 success。`captureRole()` 只用于显式的人类
 transcript 查看，不具备生命周期权威。
 
-稳定的 Role 上下文不会创建额外的 bootstrap Turn。Task execution Run 按角色使用通用 Leader 或 Worker Skill，review Run 则按持久 Run purpose 使用通用 Reviewer Skill；Provider 可以通过安全的追加式原生上下文通道携带 Skill，也可以在普通 Task 投递中指向它。这些都只是 Yui 自己拥有的可移植编排规则。Project Skills 始终是 Project 中正常版本化的文件，由 Agent 通过自身项目机制发现、选择并按需加载；Yui 不扫描、不解析、不复制，也不注入 Project Skills。Managed Codex 保留用户原有的 developer instructions；普通 Task 消息会携带精简的 Session Manifest 绝对路径，Manifest 再指向对应的 Yui Role Skill，供 Codex 按需读取。每个存活 Role 的 Yui-owned App Server 进程会加载所选 Codex 原生 config profile；model、effort、permission、workspace 与 shell 设置作为线程级 `thread/start` 或 `thread/resume` 配置传入，Yui 不修改底层 Codex 配置文件。App Server 原生通知是 Managed Codex 线程的生命周期权威；Yui 不为它安装 Hook，也不占用 `notify`。交互式 Codex Session 仍可使用 Yui 的结构化 `notify` callback，Doctor 会报告最终生效的配置冲突。`skills.config` 只负责启停已发现 Skill，Yui 不会误用它。Claude 从 Yui 管理的私有 `0600` context 文件读取同一份 Yui Role Skill 内容，不再把大段或敏感文本放进 argv；重试和 resume 会复用按 purpose 区分的稳定路径。非 Operator 的 global Role 保持中性，不会注入 Task 编排 Skill。因此 Operator 会停在空白的原生 composer，用户输入仍是第一条 user message；Leader wake、Worker 和 Reviewer Run assignment 仍是邮箱投递的真实工作消息。
+稳定的 Role 上下文不会创建额外的 bootstrap Turn。Task execution Run 按角色使用通用 Leader 或 Worker Skill，review Run 则按持久 Run purpose 使用通用 Reviewer Skill；Provider 可以通过安全的追加式原生上下文通道携带 Skill，也可以在普通 Task 投递中指向它。这些都只是 Yui 自己拥有的可移植编排规则。Project Skills 始终是 Project 中正常版本化的文件，由 Agent 通过自身项目机制发现、选择并按需加载；Yui 不扫描、不解析、不复制，也不注入 Project Skills。Managed Codex 保留用户原有的 developer instructions；普通 Task 消息会携带精简的 Session Manifest 绝对路径，Manifest 再指向对应的 Yui Role Skill，供 Codex 按需读取。model、effort、permission、workspace 与 shell 设置作为共享 daemon 上的线程级 `thread/start` 或 `thread/resume` 配置传入；Codex 原生 config profile 因无法隔离到单条共享 thread 而被拒绝，Yui 不修改底层 Codex 配置文件。App Server 原生通知是 Managed Codex 线程的生命周期权威；Yui 不为它安装 Hook，也不占用 `notify`。交互式 Codex Session 仍可使用 Yui 的结构化 `notify` callback，Doctor 会报告最终生效的配置冲突。`skills.config` 只负责启停已发现 Skill，Yui 不会误用它。Claude 从 Yui 管理的私有 `0600` context 文件读取同一份 Yui Role Skill 内容，不再把大段或敏感文本放进 argv；重试和 resume 会复用按 purpose 区分的稳定路径。非 Operator 的 global Role 保持中性，不会注入 Task 编排 Skill。因此 Operator 会停在空白的原生 composer，用户输入仍是第一条 user message；Leader wake、Worker 和 Reviewer Run assignment 仍是邮箱投递的真实工作消息。
 
 ## Controller 与失败处理
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.13.6",
+  "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