@zq-silk/yui 0.6.13 → 0.6.15

package/dist/tmux/tmuxManager.js

@@ -97,6 +97,8 @@ export class TmuxManager {
                 ";",
                 "set-option", "-g", "history-limit", String(this.#historyLimit),
                 ";",
+                "set-option", "-g", "remain-on-exit", "on",
+                ";",
                 "new-session", "-d",
                 "-x", String(this.#initialColumns),
                 "-y", String(this.#initialRows),
@@ -109,6 +111,7 @@ export class TmuxManager {
         }
         else {
             this.configureServerHistory();
+            this.run(["set-option", "-g", "remain-on-exit", "on"]);
             this.run([
                 "new-window",
                 "-t", this.sessionName(taskId),
@@ -141,6 +144,8 @@ export class TmuxManager {
                 ";",
                 "set-option", "-g", "history-limit", String(this.#historyLimit),
                 ";",
+                "set-option", "-g", "remain-on-exit", "on",
+                ";",
                 "new-session", "-d",
                 "-x", String(this.#initialColumns),
                 "-y", String(this.#initialRows),
@@ -153,6 +158,7 @@ export class TmuxManager {
         }
         else {
             await this.configureServerHistoryAsync();
+            await this.runAsync(["set-option", "-g", "remain-on-exit", "on"]);
             await this.runAsync([
                 "new-window",
                 "-t", this.sessionName(taskId),
@@ -324,6 +330,9 @@ export class TmuxManager {
             "capture-pane", "-p", "-t", this.target(taskId, roleName), "-S", `-${lines}`
         ]);
     }
+    captureRolePane(taskId, roleName, lines = 80) {
+        return this.captureRole(taskId, roleName, lines);
+    }
     dispatchRole(taskId, role, launch, input, options) {
         if (options.replaceExisting === true) {
             try {
@@ -356,24 +365,33 @@ export class TmuxManager {
         const target = this.target(taskId, roleName);
         const output = this.run([
             "display-message", "-p", "-t", target,
-            "#{pane_dead}|#{pane_pid}|#{pane_current_command}"
+            [
+                "#{pane_dead}",
+                "#{pane_pid}",
+                "#{pane_current_command}",
+                "#{pane_dead_status}"
+            ].join("|")
         ]).trim();
         const separator = output.indexOf("|");
         const secondSeparator = separator < 0 ? -1 : output.indexOf("|", separator + 1);
-        if (separator < 0 || secondSeparator < 0) {
+        const lastSeparator = secondSeparator < 0 ? -1 : output.lastIndexOf("|");
+        if (separator < 0 || secondSeparator < 0 || lastSeparator <= secondSeparator) {
             throw runtimeError(`Tmux returned an invalid pane state for ${roleName}.`);
         }
         const dead = output.slice(0, separator);
         const pidText = output.slice(separator + 1, secondSeparator);
-        const currentCommand = output.slice(secondSeparator + 1);
+        const currentCommand = output.slice(secondSeparator + 1, lastSeparator);
+        const exitStatusText = output.slice(lastSeparator + 1);
         const pid = Number(pidText);
+        const exitStatus = nonNegativeNumber(exitStatusText);
         return {
             taskId,
             roleName,
             target,
             dead: dead === "1",
             ...(Number.isSafeInteger(pid) && pid > 0 ? { pid } : {}),
-            currentCommand
+            currentCommand,
+            ...(dead === "1" && exitStatus !== undefined ? { exitStatus } : {})
         };
     }
     async inspectPaneAsync(taskId, roleName) {
@@ -396,14 +414,33 @@ export class TmuxManager {
                 "#{cursor_y}",
                 "#{history_size}",
                 "#{pane_current_command}",
+                "#{pane_dead_status}",
                 receiptFormat
             ].join("|")
         ]);
-        const state = output.trimEnd().split("|");
-        if (state.length !== 8 || state[0] !== PANE_STATE_MARKER) {
+        const normalizedOutput = output.trimEnd();
+        const fieldSeparators = [...normalizedOutput.matchAll(/\|/g)].map((match) => match.index);
+        const lastSeparator = fieldSeparators.at(-1);
+        const exitSeparator = fieldSeparators.at(-2);
+        if (fieldSeparators.length < 8
+            || lastSeparator === undefined
+            || exitSeparator === undefined
+            || !normalizedOutput.startsWith(PANE_STATE_MARKER)) {
+            throw runtimeError(`Tmux returned an invalid pane state for ${roleName}.`);
+        }
+        const [markerEnd, deadEnd, pidEnd, cursorXEnd, cursorYEnd, historyEnd] = fieldSeparators;
+        const receiptSeparator = lastSeparator;
+        const deadText = normalizedOutput.slice(markerEnd + 1, deadEnd);
+        const pidText = normalizedOutput.slice(deadEnd + 1, pidEnd);
+        const cursorXText = normalizedOutput.slice(pidEnd + 1, cursorXEnd);
+        const cursorYText = normalizedOutput.slice(cursorXEnd + 1, cursorYEnd);
+        const historySizeText = normalizedOutput.slice(cursorYEnd + 1, historyEnd);
+        const currentCommand = normalizedOutput.slice(historyEnd + 1, exitSeparator);
+        const exitStatusText = normalizedOutput.slice(exitSeparator + 1, receiptSeparator);
+        const receiptText = normalizedOutput.slice(receiptSeparator + 1);
+        if (!normalizedOutput.slice(0, markerEnd).startsWith(PANE_STATE_MARKER)) {
             throw runtimeError(`Tmux returned an invalid pane state for ${roleName}.`);
         }
-        const [, deadText, pidText, cursorXText, cursorYText, historySizeText, currentCommand, receiptText] = state;
         if ((deadText !== "0" && deadText !== "1")
             || currentCommand === undefined
             || receiptText === undefined
@@ -414,6 +451,7 @@ export class TmuxManager {
         const cursorX = nonNegativeNumber(cursorXText);
         const cursorY = nonNegativeNumber(cursorYText);
         const historySize = nonNegativeNumber(historySizeText);
+        const exitStatus = nonNegativeNumber(exitStatusText);
         if (cursorX === undefined || cursorY === undefined || historySize === undefined) {
             throw runtimeError(`Tmux returned an invalid pane state for ${roleName}.`);
         }
@@ -425,6 +463,7 @@ export class TmuxManager {
                 dead: deadText === "1",
                 ...(pid === undefined ? {} : { pid }),
                 currentCommand,
+                ...(deadText === "1" && exitStatus !== undefined ? { exitStatus } : {}),
                 cursorX,
                 cursorY,
                 historySize
@@ -775,7 +814,8 @@ export class TmuxManager {
             ...(pane.pid === undefined ? {} : { pid: pane.pid }),
             target: pane.target,
             dead: pane.dead,
-            currentCommand: pane.currentCommand
+            currentCommand: pane.currentCommand,
+            ...(pane.exitStatus === undefined ? {} : { exitStatus: pane.exitStatus })
         };
     }
     async inspectRolePaneAsync(taskId, roleName) {
@@ -784,7 +824,8 @@ export class TmuxManager {
             ...(pane.pid === undefined ? {} : { pid: pane.pid }),
             target: pane.target,
             dead: pane.dead,
-            currentCommand: pane.currentCommand
+            currentCommand: pane.currentCommand,
+            ...(pane.exitStatus === undefined ? {} : { exitStatus: pane.exitStatus })
         };
     }
     stopTask(taskId) {

package/dist/web/assets/client/i18n.js

@@ -66,6 +66,8 @@ const messages = {
     "detail.focus": "Current focus",
     "detail.runtimeHealth": "Runtime health",
     "detail.lastProgress": "Last semantic progress",
+    "detail.recoveryFence": "Canonical recovery fence (Yui durable)",
+    "detail.recoveryProviderObserved": "Provider observation (evidence only)",
     "input.freeText": "Type your answer",
     "input.answered": "Input answered.",
     "input.new": "A new input needs your attention.",
@@ -364,6 +366,8 @@ const messages = {
     "detail.focus": "当前重点",
     "detail.runtimeHealth": "运行健康",
     "detail.lastProgress": "最近语义进展",
+    "detail.recoveryFence": "规范恢复 fence（Yui 持久）",
+    "detail.recoveryProviderObserved": "Provider 观测（仅证据）",
     "input.freeText": "输入回答",
     "input.answered": "输入已回答。",
     "input.new": "有新的输入请求需要处理。",

package/dist/web/assets/client/view.js

@@ -340,6 +340,24 @@ export function renderTaskDetail(detail, data, t, locale, actions) {
         node("p", "record-copy", (run.kind || "workflow-not-progressing") + " · " + (run.classification || "truly-stalled")),
         node("small", "", t("detail.lastProgress") + " · " + formatDateTime(run.progressAt, locale))
       );
+      // Issue 08: the same canonical recovery projection as the CLI. The
+      // durable fence and the Provider observation stay clearly separated;
+      // the exact recovery actions live in "yui task run show".
+      if (run.recovery) {
+        if (run.recovery.canonicalProgressAt) {
+          card.append(node("small", "",
+            t("detail.recoveryFence") + " · " + formatDateTime(run.recovery.canonicalProgressAt, locale)));
+        }
+        if (run.recovery.provider && run.recovery.provider.observedAt) {
+          card.append(node("small", "",
+            t("detail.recoveryProviderObserved") + " · " + run.recovery.provider.observationKind
+            + " " + formatDateTime(run.recovery.provider.observedAt, locale)));
+        }
+        if (run.recovery.recoverable) {
+          card.append(node("small", "record-copy",
+            "yui task run show " + task.id + "/" + run.runId));
+        }
+      }
       runtimeHealthBody.append(card);
     });
     scaffold.append(anchorSection(

package/dist/web/webSnapshot.js

@@ -1,7 +1,11 @@
-import { isRoleRunStalled } from "../scheduler/roleRunStall.js";
+import { isRoleRunStalled, latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { summarizeExecutionGroup } from "../execution/executionGroup.js";
 import { currentWorkItemExecutionGroup } from "../workItem/workItem.js";
+import { projectRunRecovery, readRunRecoveryFacts } from "../run/recoveryProjection.js";
+import { classifyRuntimeHealth, projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
+import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
+import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 export function buildWebDashboardSnapshot(store, now = new Date()) {
     return store.transaction((reader) => {
         const statusCounts = {
@@ -52,7 +56,7 @@ export function buildWebDashboardSnapshot(store, now = new Date()) {
         };
     });
 }
-export function buildWebTaskDetail(store, taskId) {
+export function buildWebTaskDetail(store, taskId, now = new Date()) {
     return store.transaction((reader) => {
         const task = reader.getTask(taskId);
         if (task === null)
@@ -67,16 +71,24 @@ export function buildWebTaskDetail(store, taskId) {
         const events = reader.listEvents?.(taskId) ?? [];
         const needsAttentionRuns = runs
             .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
-            .map((run) => ({
-            runId: run.id,
-            roleName: run.roleName,
-            progressAt: latestStallProgress(events, run.id),
-            kind: latestStallField(events, run.id, "kind") ?? "workflow-not-progressing",
-            classification: latestStallField(events, run.id, "classification") ?? "truly-stalled"
-        }));
+            .map((run) => {
+            const facts = readRunRecoveryFacts(reader, taskId, run.id);
+            return {
+                runId: run.id,
+                roleName: run.roleName,
+                progressAt: latestStallProgress(events, run.id),
+                kind: latestStallField(events, run.id, "kind") ?? "workflow-not-progressing",
+                classification: latestStallField(events, run.id, "classification") ?? "truly-stalled",
+                // Issue 08: the same canonical recovery projection the CLI exposes.
+                ...(facts === null ? {} : { recovery: projectRunRecovery(facts) })
+            };
+        });
         const activeRuns = new Map(runs
             .filter((run) => run.status === "active")
             .map((run) => [run.roleName, run]));
+        const activeRunHealth = runs
+            .filter((run) => run.status === "active")
+            .map((run) => projectWebRunRuntimeHealth(reader, taskId, run, events, now));
         const roles = reader.listRoles(taskId).map((role) => {
             const activeRun = activeRuns.get(role.name);
             const sessions = reader.getTaskRoleSessionSet(taskId, role.name);
@@ -105,7 +117,7 @@ export function buildWebTaskDetail(store, taskId) {
                 };
             }),
             runs,
-            runtimeHealth: { needsAttentionRuns },
+            runtimeHealth: { needsAttentionRuns, activeRuns: activeRunHealth },
             reviewRounds: reader.listReviewRounds(taskId),
             openInputs: inputs.filter((request) => request.status === "open"),
             messages: reader.listMessages(taskId),
@@ -117,6 +129,84 @@ export function buildWebTaskDetail(store, taskId) {
 function latestStallProgress(events, runId) {
     return latestStallField(events, runId, "progressAt");
 }
+/**
+ * Layered runtime health for one active Run, computed from the same stored
+ * observations and durable semantic fold as the CLI status projection. The
+ * Web snapshot has no live tmux pane, so host state stays "unknown"; the
+ * classifier still surfaces session/turn/operation/observer layers and the
+ * scheduler's durable `run.stalled` episode is surfaced as
+ * `stalled-candidate`.
+ */
+function projectWebRunRuntimeHealth(reader, taskId, run, events, now) {
+    const stalled = isRoleRunStalled(events, run.id);
+    const sessions = reader.getTaskRoleSessionSet(taskId, run.roleName);
+    const session = sessions?.sessions[run.effective.agentId];
+    const stallReason = "the live active Run has no durable progress in the configured stall window";
+    if (run.deliveredAt === undefined || session?.launchId === undefined) {
+        return {
+            runId: run.id,
+            roleName: run.roleName,
+            layer: stalled ? "stalled-candidate" : "awaiting-provider-acceptance",
+            reason: stalled ? stallReason : "the pushed active Run is awaiting provider acceptance",
+            stalled,
+            lastSemanticProgressAt: run.createdAt
+        };
+    }
+    let driverId;
+    try {
+        driverId = builtinDriverIdForAdapter(run.effective.adapterId);
+    }
+    catch {
+        return {
+            runId: run.id,
+            roleName: run.roleName,
+            layer: stalled ? "stalled-candidate" : "runtime-unobservable",
+            reason: stalled ? stallReason : "the Agent Driver is not a built-in driver",
+            stalled,
+            lastSemanticProgressAt: run.deliveredAt
+        };
+    }
+    const fence = {
+        taskId,
+        roleName: run.roleName,
+        runId: run.id,
+        agentId: run.effective.agentId,
+        driverId,
+        launchId: session.launchId,
+        sessionGenerationId: session.launchId,
+        nativeSessionId: session.nativeSessionId,
+        nativeTurnId: run.id,
+        receiptId: formatAgentRunReceiptId(taskId, run.id)
+    };
+    const projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
+    const view = {
+        getAgentRun: (taskId, runId) => reader.listAgentRuns(taskId).find((candidate) => candidate.id === runId) ?? null,
+        listEvents: () => events,
+        getWorkItem: (workItemTaskId, workItemId) => reader.listWorkItems(workItemTaskId).find((item) => item.id === workItemId) ?? null,
+        listReviewRounds: (taskId) => reader.listReviewRounds(taskId),
+        listChangeSets: (taskId) => reader.listChangeSets(taskId),
+        listIntegrationAttempts: (taskId) => reader.listIntegrationAttempts(taskId),
+        listInputRequests: (taskId) => reader.listInputRequests(taskId)
+    };
+    const semanticProgress = latestRunDurableProgressAt(view, taskId, run.roleName, run.id)
+        ?? { progressAt: run.deliveredAt };
+    const classification = classifyRuntimeHealth({
+        projection,
+        semanticProgressAt: semanticProgress.progressAt,
+        now
+    });
+    return {
+        runId: run.id,
+        roleName: run.roleName,
+        layer: stalled ? "stalled-candidate" : classification.layer,
+        reason: stalled ? stallReason : classification.reason,
+        stalled,
+        ...(classification.lastRuntimeActivityAt === undefined
+            ? {}
+            : { lastRuntimeActivityAt: classification.lastRuntimeActivityAt }),
+        lastSemanticProgressAt: classification.lastSemanticProgressAt
+    };
+}
 function latestStallField(events, runId, field) {
     const stalled = events
         .filter((event) => event.type === "run.stalled" && event.payload.runId === runId)

package/i18n/README.zh-CN.md

@@ -116,16 +116,16 @@ yui task activate <task-id>
 
 ```sh
 yui config show
-yui config set --time-zone Europe/London
+yui config set time-zone Europe/London
 ```
 
 WorkItem 审查只有一条可选的全局规则，并直接复用已有 Global Role 的
 Agent、model、权限、prompt 和 Skills：
 
 ```sh
-yui config review set --role reviewer --trigger always
-yui config review show
-yui config review clear
+yui config set review --role reviewer --trigger always
+yui config show
+yui config clear review
 ```
 
 对带 Project 的软件交付，可使用 `--trigger final`：WorkItem 验收与
@@ -133,7 +133,7 @@ Integration 保持独立，在 Task 完成前只对所有已集成 Project 的
 一次 Task 级 ReviewRound：
 
 ```sh
-yui config review set --role reviewer --trigger final
+yui config set review --role reviewer --trigger final
 ```
 
 每个进入 Leader 验收阶段的结果，都会成为原 WorkItem 上一个明确的候选。

package/package.json

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

package/skills/yui-leader/SKILL.md

@@ -96,6 +96,19 @@ children through adapter metadata, and routes a later result reference through
 the durable inbox. Do not poll, send a waiting Message, rewrite a checkpoint,
 or yield merely to preserve that native wait.
 
+Native child results have an explicit durability boundary. A native subagent is
+best-effort by default: its result returns through the parent Conversation, and
+if the parent Session is lost before Yui externalizes the result, rerun the
+child — Yui does not claim it was durably received. When Yui persists a
+continuation report with result content, the child becomes durable-result:
+`yui task continuation list <task>` shows its mode, content digest, and the
+Task event holding the full result. After a parent crash, read durable-result
+children by their event reference instead of rerunning them; rerun only
+best-effort children whose result was never externalized. Critical,
+non-repeatable, or independently verifiable work must use a Yui
+WorkItem/ExecutionGroup, not a native subagent, because only a managed Lane
+owns an independent Run, receipt, and workspace.
+
 For a managed Task Role or Reviewer Run, persist a necessary changed checkpoint,
 yield the active Leader Run, and stop the turn. Its durable mailbox result or an
 attention event wakes a later Leader Run. An unchanged healthy managed wait is
@@ -191,8 +204,17 @@ character budget: choose the smallest useful abstraction for the recipient.
 
 ## Recover and persist Task context
 
-A launch or wake message is a pointer, not the full context. Start with the
-complete Task projection, then follow its Project Policy references:
+A launch or wake message is a pointer, not the full context. A wake carries a
+minimal envelope: the wake id, the aggregated reason tags, and the delta
+window. It never embeds context content. Read the delta on demand:
+
+```sh
+yui task wake show <task-id> <wake-id>
+```
+
+For a fresh generation (no native history), or when the envelope indicates a
+major change, start with the complete Task projection, then follow its Project
+Policy references:
 
 ```sh
 yui task context <task-id>
@@ -200,10 +222,18 @@ yui project show <project>
 yui project knowledge list <project>
 ```
 
-Inspect `task work`, `task role`, `task integration`, `task input`, and other
-narrower records only when the projection identifies a specific record that
-needs closer evidence. Use exact IDs returned by Yui. Never edit `state.json`,
-managed refs, worktrees, Sessions, or provider IDs directly.
+The `wake show` delta lists the exact events, messages, and Runs that arrived
+in the window. Inspect `task work`, `task role`, `task integration`, `task
+input`, and other narrower records only when the projection or delta
+identifies a specific record that needs closer evidence. Use exact IDs
+returned by Yui. Never edit `state.json`, managed refs, worktrees, Sessions,
+or provider IDs directly.
+
+For a `role-run-stalled` or runtime-health wake, diagnose from the exact
+Run/Event/Session and related WorkItem/Review/Integration records. Preserve
+the current fence and write a Task Message only for a new root cause, impact,
+recovery action, acceptance decision, or user-relevant conclusion; an
+unchanged healthy wait is zero Message.
 
 Maintain durable context throughout a long-running Task:
 
@@ -220,8 +250,11 @@ Maintain durable context throughout a long-running Task:
   work. Supersede it explicitly when the choice changes.
 - Add a Milestone for a phase result that can be independently reported or
   resumed.
-- Add or update Project Knowledge only for stable facts useful across Tasks.
-  Do not use it as a Task log, transcript, or scratchpad.
+- Propose Project Knowledge promotion for stable conclusions useful across
+  Tasks. Project Knowledge is an Operator authority: a Leader proposes a
+  candidate (with its source Task/Decision/Milestone evidence) and an Operator
+  reviews and accepts it; the Leader cannot write the authoritative Knowledge
+  list directly. Do not use Knowledge as a Task log, transcript, or scratchpad.
 - Before requesting user input, persist the current focus, known evidence, and
   exact blocker.
 
@@ -236,10 +269,16 @@ yui task decision record <task-id> \
   --title "<material choice>" --rationale "<reason and consequences>"
 yui task milestone add <task-id> \
   --title "<phase>" --summary "<delivered result and evidence>"
-yui project knowledge add <project> "<stable fact>" --body "<reusable knowledge>"
+yui project knowledge propose <project> \
+  --title "<stable conclusion>" --body "<self-contained project-level knowledge>" \
+  --task <task-id> [--decision <id>] [--milestone <id>]
 ```
 
-Update an existing Knowledge record instead of creating duplicates.
+Resubmitting the same candidate is deduplicated to the existing proposal. A
+proposal that conflicts with an existing Knowledge entry is never silently
+overwritten: the Operator chooses an explicit update, supersede, or reject.
+Pending proposals appear in `yui task next-action <task-id>` as a non-blocking
+advisory; they do not block Task completion.
 
 ## Choose the execution path
 

package/skills/yui-operator/SKILL.md

@@ -139,15 +139,29 @@ yui project discover [name]
 yui project show <project>
 yui project knowledge list <project>
 yui project knowledge show <project> <knowledge-id>
+yui project knowledge proposals list <project>
+yui project knowledge proposals show <project> <proposal-id>
+yui project knowledge accept <project> <proposal-id>
+yui project knowledge accept <project> <proposal-id> --update <knowledge-id>
+yui project knowledge reject <project> <proposal-id> --reason "<text>"
 yui task create "<title>" \
   --project <project-a> --project <project-b> \
   --base <project-a>=<ref> --base <project-b>=<ref>
 yui task activate <task-id>
 ```
 
-Keep catalog metadata current with `project update`. Update current Knowledge
-and retire obsolete Knowledge without deleting its history. If discovery finds
-an existing stable checkout, bind it with `project add`. If only a remote is
+Keep catalog metadata current with `project update`. Project Knowledge is an
+Operator authority: a Leader proposes promotion candidates (with source
+Task/Decision/Milestone evidence) and the Operator reviews and accepts or
+rejects them. Acceptance writes the Knowledge entry with its provenance; a
+candidate that duplicates an existing entry is deduplicated, and one that
+conflicts with an existing title fails closed so the Operator must choose an
+explicit proposal-backed `accept --update`, supersede, or reject. Direct
+Knowledge mutation is not supported because it would erase version history;
+`--update` is allowed only when the current version is already traceable to an
+accepted proposal. Otherwise submit the replacement with `--supersedes` so the
+old Knowledge entry remains retired and readable. If discovery finds an
+existing stable checkout, bind it with `project add`. If only a remote is
 known, explain the clone destination and impact, obtain confirmation, then run
 `project clone`; do not send the user mechanical clone steps.
 

package/skills/yui-worker/SKILL.md

@@ -114,6 +114,14 @@ child Session or Run record. The Leader reviews
 the result and records the actual Profile revision, runtime model/effort,
 round, result, and checks in the WorkItem summary.
 
+A native child result is best-effort until Yui externalizes it: the result
+returns through the parent Conversation, and if that Session is lost before
+the Leader consumes it, the child may need to rerun. Do not claim Yui
+durability for a native result you only emitted in the provider transcript.
+When the child brief requires a durable, independently recoverable result,
+the Leader must dispatch the work as a Yui WorkItem/ExecutionGroup instead —
+native subagents never own a Yui Run, receipt, or workspace.
+
 ## Task Role AgentRun
 
 The managed input names the current Run ID. Before ending a managed Codex or