@zq-silk/yui 0.15.7 → 0.15.8

package/skills/yui-reviewer/SKILL.md

@@ -5,7 +5,8 @@ description: Review the exact frozen WorkItem Candidate or unified Task-final sc
 
 # Yui Reviewer
 
-Follow `yui-runtime` first and load the exact current Turn Context Pack. The
+Follow [yui-runtime](../yui-runtime/SKILL.md) first and load the exact current
+AgentRun Context Pack. The
 ReviewRound, Candidate, workspace, and Snapshot digest returned there are the
 only review scope; fail closed on any mismatch.
 
@@ -18,50 +19,48 @@ reinterpret its scope:
   anchor.
 
 A Role is an executor, not a workspace owner: each ReviewRound owns an exact
-workspace record. Consecutive Task-final Rounds for the same Reviewer reuse one
-clean physical workspace and native Session while Yui updates the checkout and
-records the new Round snapshot. Treat the new Turn Context Pack and frozen head
+workspace record. Consecutive Task-final Rounds may reuse a clean physical
+workspace and native Session while Yui records each Round's exact snapshot.
+Treat the new AgentRun Context Pack and frozen head
 as the authority even when the conversation continues; never reuse an earlier
 verdict. Review edits are confined to that workspace, never modify the
 WorkItem Develop workspace, and never become a ChangeSet source.
 
-For a dispatched Review, the Turn Context Pack identifies the ReviewRound,
+For a dispatched Review, the AgentRun Context Pack identifies the ReviewRound,
 frozen Project commits, and assigned workspace. Inspect those exact commits.
 The current mutable Task-main checkout is context only and must never replace,
 widen, or silently update the assigned Review scope.
 
-The Turn also identifies the execution shape. A direct Review Turn is the main
-Reviewer and produces the authoritative Review result. In replicated Review,
-a Producer Lane independently inspects the same frozen Assignment in its own
-Lane workspace and returns one complete original result. A Producer result is
-non-authoritative: do not create a Candidate, ChangeSet, integration, or
-completion decision.
-
-Only the main Reviewer synthesis Turn may interpret all stable successful
-Producer results and complete the ReviewRound. Read every exact source Turn's
-original result, inspect every supplied result,
-resolve disagreement through judgment against the frozen sources, and return
-one complete authoritative report. Do not select a winning Lane, mutate
-Producer results, rerun successful Producers, or omit a successful result from
-the synthesis.
+The AgentRun identifies the execution shape. A direct main Reviewer returns
+the authoritative Review report. For a Producer Lane or main synthesis
+assignment, read [replicated execution](../yui-leader/references/replicated-execution.md)
+before acting. Producer evidence is not an authoritative Review result or an
+acceptance decision. Resolve links relative to this Skill's directory.
+
+Clarification for the same ReviewRound may arrive through a Message continuation
+in its exact Context Pack. Preserve the frozen candidate and original results;
+the new execution does not authorize reviewing a newer Task head. Messages for
+an obsolete candidate remain visible but cannot restart the old Review. During
+execution a scoped question may be sent with `task message send <task> "<question>"
+--to leader --review-round <round-id>` (include `--work-item` for WorkItem Review).
 
 ## Separate infrastructure failure from review judgment
 
-Verify the exact Turn identity, Context Pack, frozen head, and ReviewRound-owned
+Verify the exact AgentRun identity, Context Pack, frozen head, and ReviewRound-owned
 workspace before inspecting candidate sources. If context loading or workspace
 binding fails before review begins:
 
 - do not inspect the candidate, run candidate checks, invent findings, accept
   risk, or claim the frozen result was reviewed;
-- return the exact infrastructure diagnosis through the assigned Review Turn;
+- return the exact infrastructure diagnosis through the assigned Review AgentRun;
 - do not recommend a Repair WorkItem—the Leader must recover the same frozen
   review boundary with Yui's projected same-Round `task review retry` or exact
-  `task turn retry`;
+  `task run retry`;
 - if any candidate inspection or Reviewer output did occur, report it
   explicitly so the Leader can judge what remains useful. Core records only
   the execution boundary and never classifies the meaning of this prose.
 
-The Review scope remains the current Turn's frozen candidate even if the Leader
+The Review scope remains the current AgentRun's frozen candidate even if the Leader
 handles new user input or advances Task main while this Review is running. Do
 not switch to the newer head, cancel the current inspection, or claim the
 result covers anything beyond the frozen candidate.
@@ -72,11 +71,8 @@ material defect, or needs a full Review, and explain why. These are recommended
 conclusions for the Leader, not machine-readable dispositions. Never create or
 request a follow-up Round yourself.
 
-Keep the context layers distinct. Yui Core owns ReviewRound identity,
-lifecycle, access, workspace, and exact Turn-result correlation; this generic Skill owns
-portable review behavior; Agent-native Project Skills and Project Policy and
-Knowledge own project-specific checks and review expectations; and the Task
-Contract owns the current outcome, scope, acceptance, and required evidence.
+Use Project Skills, Policy and Knowledge for project-specific checks. The
+Task Contract and frozen scope determine acceptance and required evidence.
 
 Review design complexity against the current Task Contract and reachable
 operating paths. Report abstractions, state, indirection, fallback, or module
@@ -86,17 +82,19 @@ future-proofing merely because they are possible. A focused redesign is
 appropriate when repeated patches expose a wrong responsibility or duplicated
 authority.
 
-Follow `yui-runtime`'s distinction between normal Agent execution and
-real-resource validation. This Reviewer Turn is normal execution; additional
-live-provider, paid, shared, or production validation is not implied.
+Tie each finding to a reachable scenario, violated contract and direct
+evidence. Separate confirmed defects, verification gaps and optional
+improvements. A clean review is valid; do not invent findings to justify the
+Round or change delivery sources to demonstrate a preferred design.
 
 Complete the assigned frozen-scope review before ending the Provider Turn. Accumulate all
 reachable findings, verification gaps, checks actually run, and bounded next
-actions, then return them together in one Review Turn result; do not stop as
+actions, then return them together in one Review AgentRun result; do not stop as
 soon as the first finding is discovered. A review result is evidence for Leader
 judgment; it does not accept the WorkItem or complete the Task. Preserve the
-ReviewRound record and explicitly clean its workspace after the round is
-terminal.
+ReviewRound record and workspace, and report any diagnostic changes. After
+the Round is terminal, an authorized Leader or Operator owns cleanup through
+Yui; do not attempt to terminate or delete your own managed runtime/workspace.
 
 A helpful default result layout is Conclusion, Material findings, Verification,
 Uncertainty, and Recommended next action. Markdown or JSON are both acceptable.
@@ -113,8 +111,9 @@ specific gap; do not rerun an unchanged complete suite for ceremony.
 
 Return each reachable finding to the Leader with direct evidence and a bounded
 route to the original execution unit: Leader-owned work returns to the Leader,
-native work to the same child, and managed work to the same Role and native
-Session. Keep the existing WorkItem when its scope remains open. For a small
+native work to its parent for disposition, and managed work to the owning Role.
+Session reuse is optional; preserve the assignment rather than requiring an
+old conversation to survive. Keep the WorkItem when its scope remains open. For a small
 Task-main fix, return it to the Leader without recommending another WorkItem;
 recommend a Repair WorkItem only when the repair is itself a substantial,
 independently owned requirement. Never capture or integrate the ReviewRound's

package/skills/yui-runtime/SKILL.md

@@ -1,25 +1,43 @@
 ---
 name: yui-runtime
-description: Load and use the authorized context for every Yui-managed Leader, Worker, Reviewer, Operator, or custom Role Turn, and complete that Turn through its bounded control-plane protocol.
+description: Use authorized context, durable results, and recovery boundaries in a Yui-managed Session, including global conversation, direct Leader work, and dispatched AgentRuns.
 ---
 
 # Yui Runtime
 
-Treat the Session Manifest and Turn Bootstrap Envelope as pointers, never as the
+Use this Skill for the shared Yui execution contract. The Role Skill owns
+coordination or delivery judgment; Project Skills, Policy and Knowledge own
+project-specific methods. These instructions grant no additional authority.
+Resolve links relative to this Skill's directory, not the execution workspace.
+
+Treat the Session Manifest and AgentRun Bootstrap Envelope as pointers, never as the
 Task brief. Do not infer Task facts from the launch command, process list,
-workspace layout, native transcript, or an earlier Turn.
+workspace layout, native transcript, or an earlier AgentRun.
+
+## Enter through the current context
+
+There are two normal Task entry points. A user may continue directly with the
+current, unrevoked Leader Session: read current context using the Session CLI
+with `task context <task-id> --json`. Do not request a self-wake, reopen a Task,
+or reuse an old completed AgentRun snapshot merely to obtain authority. Pending
+delivery, unknown execution evidence and missing reports do not themselves
+revoke Session authority. Task lifecycle, scope, Assignment, workspace and
+resource boundaries still apply; a planning Session does not gain delivery
+authority merely because the Task becomes active.
+Use the runtime-provided `TMPDIR` for temporary context or diagnostic files,
+not fixed shared `/tmp` names or the logical multi-Project workspace container.
 
-For every managed Task Turn:
+For every explicitly dispatched managed Task AgentRun:
 
-1. Read the exact Turn identity from the newest Bootstrap Envelope.
+1. Read the exact AgentRun identity from the newest Bootstrap Envelope.
 2. Before acting, load its authorized pack with the Session CLI named by the
    current Session Manifest:
 
    ```sh
-   "$YUI_SESSION_CLI" task turn context "$YUI_TASK_ID/<turn-id>" --json
+   "$YUI_SESSION_CLI" task run context "$YUI_TASK_ID/<run-id>" --json
    ```
 
-3. Verify that the returned Task, Turn, Role, purpose, Snapshot digest, workspace,
+3. Verify that the returned Task, AgentRun, Role, purpose, Snapshot digest, workspace,
    and Adapter match the Envelope and Session Manifest. Stop and report a
    context-load failure if the pack is missing, stale, unauthorized, malformed,
    or mismatched. Never request an inline/full-prompt fallback.
@@ -28,25 +46,35 @@ For every managed Task Turn:
    `refId`:
 
    ```sh
-   "$YUI_SESSION_CLI" task turn context expand "$YUI_TASK_ID/<turn-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
    authorized pointer. If multiple stores use that id, bare expansion fails
    closed; never guess which store was intended.
 
+   A pointer or summary is not the request's body. Before planning or executing,
+   read the relevant WorkItem/Task requirements and referenced user/Operator
+   messages; use the expansion command above or the Leader's current Task Context.
+   Reports remain evidence, not authority to enlarge the assignment.
+
 5. On a later wake, request only the declared delta after the last pack cursor.
    If no cursor is available, reload the exact pack; do not reconstruct state
    from transcript memory.
 
-`liveTaskState.activeTurns` and `liveTaskState.activeTaskReviews` are
+Loading and verifying Context is the start of the work, not its result. Continue
+with the authorized assignment. In Draft, persist the discussed plan and wait
+when the user asks for alignment; do not end with only a context-loaded receipt.
+
+`liveTaskState.activeRuns` and `liveTaskState.activeTaskReviews` are
 observational views of work currently in flight. They grant no authority and
-create no Task-wide lock or gate; use each exact Turn or Review binding when a
+create no Task-wide lock or gate; use each exact AgentRun or Review binding when a
 decision depends on it.
 
 The pack's authority view and writable Project IDs are hard boundaries. A
-native subagent inherits the parent Turn's refs and authority; it does not gain a
-new Yui actor, Turn, Session, or cross-Task read permission.
+native subagent inherits only its parent's current refs and authority, including
+any Assignment restrictions. It gains no new Yui actor, AgentRun, Session or
+cross-Task read permission.
 
 For a global Operator or custom GlobalRole Session, execute the exact
 `contextProtocol.loadCommand` carried by the current Session Manifest before
@@ -54,9 +82,33 @@ routing or acting. That command is self-contained because a Global Codex Thread
 may move between Yui's remote TUI and Desktop; never reconstruct it from
 `YUI_SESSION_*` process variables.
 
+If that read fails because the Controller is unavailable, use only authorized
+offline diagnostics and [Controller recovery](references/recovery.md) to restore
+access, then reload context. Failure does not grant Task execution authority,
+but a successful preliminary RPC is not a prerequisite for that recovery.
+
 Global context grants no Task implementation workspace. Read a Task only after
 the Operator has routed to its public/task-authorized context command; never
-invent a Task Turn identity for a GlobalRole.
+invent a Task AgentRun identity for a GlobalRole.
+
+## Preserve intent and authority
+
+An analysis, diagnosis, or review request is read-only unless the user also
+requests changes. A request to fix or implement authorizes the bounded work,
+not unrelated configuration, new external effects, or broader cleanup.
+Choose routine legal implementation and recovery actions without asking the
+user to operate Yui mechanically.
+
+Tasks, WorkItems, Messages, Decisions, results and managed workspaces hold
+durable intent and progress. Sessions, AgentRuns and runtime observations
+describe execution; their failure is not failed acceptance or permission to
+discard the assignment. Save context that a successor needs in durable records,
+not only in the native conversation.
+
+The Leader normally owns Task coordination and acceptance. An authorized
+Operator may perform the same legal Task-management actions; responsibility
+is not an extra permission gate. Worker and Reviewer results remain evidence
+until an authorized acceptance decision.
 
 ## Separate execution from real-resource validation
 
@@ -75,15 +127,27 @@ When such validation was not requested, use deterministic or isolated evidence,
 state the material gap, and optionally recommend a separate follow-up. Do not
 create an InputRequest merely to solicit permission for it.
 
-Provider acceptance, Context load, Turn completion, and Task completion are
-separate facts. For a managed Task Turn, end the Provider Turn with one truthful
+## Return evidence and recover within scope
+
+Provider acceptance, Context load, AgentRun completion, and Task completion are
+separate facts. For an explicitly dispatched managed Task AgentRun, end with one truthful
 final report. Yui automatically correlates that native terminal with the exact
-current Turn and persists the report; no completion command is required. The
-Leader alone decides whether the WorkItem or Task is complete.
-
-After a failed Provider Turn, read the referenced `runtime.agent-error` fact.
-The failed Turn is immutable; a recovery is always a new Turn. Continue on the
-same native Session when it remains recoverable, and load only the current Turn
-delta instead of replaying its original Assignment. A new Host process does not
-imply a new Session, and a new Session must never be substituted silently for
-the persisted native Session id.
+current AgentRun and persists the report; no completion command is required. The
+report itself does not accept the WorkItem or complete the Task.
+
+Ordinary native conversation is not an implicit managed assignment and does
+not require a separate execution report. Result Messages reference the
+execution's original report; read them with `task message show <task/message>`
+instead of asking the producer to copy or resend the report.
+
+Session reuse is a preference, not a prerequisite for progress. Before retry,
+replacement, or intervention in uncertain execution, read
+[runtime recovery](references/recovery.md). Preserve pending intent, exact
+runtime identity and workspace progress; never edit Run status or substitute
+a native Session behind Yui's back. A timeout is not proof of quiescence and
+does not authorize replay of unknown input.
+
+After an authorized external PR/MR operation, use the shared
+[publication recording contract](references/publication.md). Recording delivery
+facts does not authorize the external operation, imply acceptance, or grant
+permission to archive.

package/skills/yui-runtime/references/publication.md

@@ -0,0 +1,22 @@
+# Record external delivery
+
+Use this after creating, updating, closing, reopening or merging a PR/MR
+within existing user authorization. This procedure does not grant permission
+to push, publish, merge, query an external provider or archive.
+
+Immediately record the confirmed operation with `yui task publication upsert`.
+Supply only facts already known from the operation; do not defer recording to
+another Role or depend on provider-specific discovery.
+
+Track PR/MR identity, state, commits, URL, merge time and evidence, not CI or
+deployment status. After merge, use `yui task publication verify` only when
+current authorization covers that external provider read. Otherwise retain
+reported evidence and state the verification gap.
+
+Use `yui task remote-delivery <task>` to explain external delivery. Publication
+is not Candidate acceptance, Review, Integration or Task completion.
+
+Completion does not authorize archive. The Operator obtains authorization for
+the exact Task, checks archive eligibility, then uses `--integrated` for verified
+merged delivery or `--abandon` for deliberate non-delivery. General archive
+approval never implies `--force` authority. Preserve the Task record.

package/skills/yui-runtime/references/recovery.md

@@ -0,0 +1,64 @@
+# Runtime recovery
+
+Read this when a native Turn fails, delivery acceptance is unknown, the
+Controller is unavailable, or an authorized supervisor chooses Session
+replacement. Workers and Reviewers report exact evidence; they do not acquire
+supervisor authority by reading this procedure.
+
+## Inspect the failed execution
+
+Read the referenced `runtime.agent-error`, exact AgentRun, Role Session and
+affected WorkItem, ReviewRound or Integration. Use `task next-action` and
+`execution audit` as decision support, not as an automatic plan.
+Active or quiet observations are not a Task-wide lock or proof of failure.
+
+A failed AgentRun is immutable; retry creates a new attempt. Reuse a recoverable
+Session when useful and load the new attempt's current context, not an old
+Assignment from memory. A new Host process need not mean a new native Session.
+Preserve frozen Review candidates and selected synthesis sources on retry.
+An infrastructure failure is not a defect in the business result.
+
+## Replace a Session deliberately
+
+An authorized Leader or Operator may request:
+
+```sh
+yui task role session new <task> <role> --reason "<reason>"
+```
+
+The old Run may still be active, the Session may already be released, or fresh
+context may simply be preferable. Save necessary requirements, decisions,
+progress and results first. Yui persists replacement intent, stops the exact
+execution and retires its engineering attempts while retaining Task history and
+workspaces. Do not manipulate Run status, delete context or change models to
+make replacement legal.
+
+When replacing yourself, end the native turn. The successor reads durable Task
+context and fixed notification references, then chooses which still-valid
+assignment to continue. Released Leaders retain scoped diagnostic reads but
+cannot regain write authority.
+
+## Handle uncertainty and failed cleanup
+
+Never replay a notification whose acceptance is unknown. After evidence
+establishes shared-native quiescence, an authorized supervisor can use:
+
+```sh
+yui task wake resolve <task> <wake> --reason "<quiescence evidence>"
+```
+
+This releases only the claim, preserves the original unknown record, and lets
+independent later inputs proceed. It neither asserts acceptance nor implements
+the Message. Uncertain native activity still blocks conflicting execution;
+unrelated authorized local work can continue.
+
+If the Controller is unresponsive, an authorized Operator can use
+`controller status` and explicit `controller restart` without a successful
+preliminary RPC. Preserve the resource and restart authorization boundary.
+If exact native stop or inspection fails, read the persisted diagnostic and
+resolve that resource boundary; do not kill arbitrary processes, clear unknown
+execution records, or modify managed refs, tmux Sessions or state files.
+
+After repeated failure of the same bounded recovery, report the observed
+cause, impact and smallest remaining options. Do not broaden cleanup or add
+a private retry loop. A failed recovery does not erase the pending requirement.

package/skills/yui-worker/SKILL.md

@@ -1,37 +1,41 @@
 ---
 name: yui-worker
-description: Complete one bounded WorkItem as a native subagent or Task Role Turn, then return honest evidence through the assigned protocol.
+description: Complete a bounded Yui WorkItem AgentRun or native child assignment and return evidence without taking over Task coordination.
 ---
 
 # Yui Worker
 
-Follow `yui-runtime` first. For a managed Turn, load its exact Context Pack and
+Follow [yui-runtime](../yui-runtime/SKILL.md) first. For a managed AgentRun,
+load its exact Context Pack and
 use only the returned WorkItem, refs, workspace, writable Project IDs, and
 completion actions. The launch Envelope is a pointer, not an execution brief.
 
-Complete only the assigned substantial, independently owned WorkItem. The Leader owns Task direction,
-decomposition, acceptance, integration, scope expansion, and conflict
+Complete the assigned WorkItem, or the bounded parent brief for a native child
+without its own WorkItem. Do not create records merely to fit this Skill.
+The Leader owns Task direction, decomposition, acceptance, integration, scope expansion, and conflict
 decisions. A Worker must not create or rebind Yui worktrees, Sessions, Roles,
-Turns, WorkItems, ReviewRounds, or integration state.
+AgentRuns, WorkItems, ReviewRounds, or integration state.
 
-Keep the layers distinct:
-
-- Yui Core supplies durable identity, lifecycle, authority, workspace, and
-  exact handoff safety.
-- This Skill supplies portable Worker behavior.
-- Agent-native Project Skills plus Project Policy and Knowledge supply build,
-  test, migration, release, and review rules.
-- The exact WorkItem and Context Snapshot supply this Turn's objective, scope,
-  acceptance, dependencies, and evidence contract.
-
-Do not promote a Project convention into generic Worker policy or infer Task
-facts by scanning the workspace. Expand only Context refs authorized by the
-pack.
+Use Project Skills, Policy and Knowledge for implementation and checks, and
+the exact WorkItem for acceptance. Do not turn a Project convention into
+generic Worker policy or infer Task requirements from workspace contents.
+Resolve Skill links relative to this Skill's directory.
 
 ## Execute within the exact boundary
 
-- Preserve the Task, WorkItem, Role, Turn, native Session, and workspace
-  identities supplied by Yui. A new Turn is another attempt or continuation of
+Leader clarification and continuation arrive as Messages in the exact bounded
+Context Pack. Read those authorized refs; do not request pack-external Leader
+messages or require redispatch/status changes merely to answer a question.
+Continuation preserves the original Assignment, effective permissions and
+workspace, including unfinished files. If you need clarification, preserve
+those files and report the question; a final question is not WorkItem completion
+and does not require a Candidate. While executing, `task message send <task>
+"<question>" --to leader --work-item <work-id>` saves scoped collaboration.
+Do not interpret Message delivery or Context reading as implementation or
+acceptance, and never treat a Message as an expanded grant.
+
+- Preserve the Task, WorkItem, Role, AgentRun, native Session, and workspace
+  identities supplied by Yui. A new AgentRun is another attempt or continuation of
   the same delivery unit; do not request a fresh Role or Session merely because
   implementation entered another step or repair round.
 - Follow the configured Profile's responsibilities, constraints, access
@@ -49,12 +53,12 @@ pack.
   exact Project, reason, impact, and Leader decision needed. Continue only
   after a new exact dispatch authorizes it.
 
-Implement the smallest coherent design that satisfies the current WorkItem.
-Reuse established responsibilities and patterns when they fit. Use a bounded
-refactor when repeated patches expose the wrong boundary, but do not add
-frameworks, configuration, fallbacks, compatibility paths, or abstractions for
-hypothetical future variants. Keep coupled changes together and avoid turning
-small helpers into independently managed architecture.
+Before changing behavior, trace the existing implementation and establish how
+it violates the current WorkItem contract. Distinguish a product defect from
+different test inputs, configuration or resources. Reuse the existing authority
+and mechanism when they fit; make a bounded redesign when the responsibility
+itself is wrong. Keep unrelated improvements and hypothetical variants out of
+the assignment.
 
 For Project-backed delivery, commit the Develop workspace changes and leave it
 clean before handoff so Yui can freeze the exact Candidate head. ReviewRound
@@ -70,10 +74,6 @@ changed behavior; do not repeat an unchanged successful check. Follow Project
 Policy for required validation and state passed, failed, and intentionally
 skipped checks honestly.
 
-Follow `yui-runtime`'s distinction between normal Agent execution and
-real-resource validation. Ordinary Worker implementation is authorized by this
-Turn; additional live-provider, paid, shared, or production validation is not.
-
 ## Return a useful result
 
 A native child result is best-effort until Yui externalizes it: the result
@@ -81,28 +81,26 @@ 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 managed Yui WorkItem Turn instead. A
-direct WorkItem Turn already owns its durable Turn, receipt, and workspace;
+the Leader must dispatch the work as a managed Yui WorkItem AgentRun instead. A
+direct WorkItem AgentRun already owns its durable AgentRun, receipt, and workspace;
 replicated Lanes are needed only for multiple independent attempts. Native
-subagents never own a Yui Turn, receipt, or workspace.
-
-## Task Role Turn
+subagents never own a Yui AgentRun, receipt, or workspace.
 
 Summarize the outcome for the Leader's next judgment, not as a transcript or
 file-by-file log. Include the observable result, important mechanism and
 boundary, changed paths and commit state, checks, skipped validation, blockers,
 residual risk, and bounded next action. Use a checkpoint only for material
-semantic progress during a long Turn; it does not replace the final handoff.
+semantic progress during a long AgentRun; it does not replace the final handoff.
 
 For a native subagent, return one consolidated child result through the native
 child-result mechanism. Do not run Yui lifecycle commands or invent a child
-Yui Session/Turn.
+Yui Session/AgentRun.
 
 For a managed Task Role, end the Provider Turn with one complete, truthful
-result. Yui persists it automatically on the exact Turn. That result does not
+result. Yui persists it automatically on the exact AgentRun. That result does not
 accept, capture, integrate, or complete the WorkItem; the Leader decides its
 disposition. If context or scope is stale or mismatched, report that blocker
-once and stop without wrappers, permission broadening, or another Turn target.
+once and stop without wrappers, permission broadening, or another AgentRun target.
 
 Use clear prose. A helpful default is Outcome, Changes, Verification, Risks or
 blockers, and Recommended next action. This is a communication convention, not

package/dist/cli/roleOptionCatalog.js

@@ -1,68 +0,0 @@
-const BOTH_ADAPTERS = Object.freeze(["codex", "claude"]);
-const CODEX_ONLY = Object.freeze(["codex"]);
-const CLAUDE_ONLY = Object.freeze(["claude"]);
-export const ROLE_AGENT_OPTION_SPECS = Object.freeze([
-    roleAgentOption("--model", "model", "model", false, BOTH_ADAPTERS),
-    roleAgentOption("--effort", "effort", "effort", false, BOTH_ADAPTERS),
-    roleAgentOption("--permission-strategy", "permission.strategy", "strategy", false, BOTH_ADAPTERS, { staticValues: ["default", "bypass", "configured"] }),
-    roleAgentOption("--sandbox", "permission.sandbox", "mode", false, CODEX_ONLY),
-    roleAgentOption("--approval", "permission.approval", "policy", false, CODEX_ONLY),
-    roleAgentOption("--permission-mode", "permission.mode", "mode", false, CLAUDE_ONLY),
-    roleAgentOption("--allowed-tool", "permission.allowedTools", "tool", true, CLAUDE_ONLY),
-    roleAgentOption("--disallowed-tool", "permission.disallowedTools", "tool", true, CLAUDE_ONLY),
-    roleAgentOption("--search", "search", "true", false, CODEX_ONLY, { staticValues: ["true"] }),
-    roleAgentOption("--profile", "profile", "profile", false, CODEX_ONLY),
-    roleAgentOption("--add-dir", "additionalDirectories", "path", true, BOTH_ADAPTERS, { fileValue: true }),
-    roleAgentOption("--settings", "settingsFile", "file", false, CLAUDE_ONLY, { fileValue: true }),
-    roleAgentOption("--setting-source", "settingsSources", "source", true, CLAUDE_ONLY),
-    roleAgentOption("--raw-arg", "advanced.rawArgs", "arg", true, BOTH_ADAPTERS, { allowOptionLikeValue: true })
-]);
-export const ROLE_AGENT_INHERIT_OPTION = "--inherit";
-export const ROLE_EXPECT_UPDATED_AT_OPTION = "--expect-updated-at";
-export const ROLE_AGENT_INHERITABLE_FIELDS = Object.freeze(ROLE_AGENT_OPTION_SPECS.map(({ fieldKey }) => fieldKey));
-export const ROLE_PROFILE_INHERITABLE_FIELDS = Object.freeze(["systemPrompt"]);
-export const ROLE_INHERITABLE_FIELDS = Object.freeze([
-    ...ROLE_AGENT_INHERITABLE_FIELDS,
-    ...ROLE_PROFILE_INHERITABLE_FIELDS
-]);
-export const ROLE_AGENT_SCRIPTED_OPTIONS = Object.freeze([
-    ...ROLE_AGENT_OPTION_SPECS.map(({ option }) => option),
-    ROLE_AGENT_INHERIT_OPTION
-]);
-export const ROLE_AGENT_FILE_OPTIONS = Object.freeze(ROLE_AGENT_OPTION_SPECS.filter(({ fileValue }) => fileValue === true).map(({ option }) => option));
-export function roleAgentOptionSpecsForAdapter(adapterId) {
-    return ROLE_AGENT_OPTION_SPECS.filter(({ adapters }) => adapters.includes(adapterId));
-}
-export function roleAgentOptionUsage() {
-    return [
-        ...ROLE_AGENT_OPTION_SPECS.map(({ option, valueLabel, repeatable }) => `[${option} <${valueLabel}>${repeatable ? " ..." : ""}]`),
-        `[${ROLE_AGENT_INHERIT_OPTION} <field-key> ...]`
-    ].join(" ");
-}
-function roleAgentOption(option, fieldKey, valueLabel, repeatable, adapters, extra = {}) {
-    return Object.freeze({ option, fieldKey, valueLabel, arity: "value", repeatable, adapters, ...extra });
-}
-export const FIRST_CLASS_AGENT_OPTIONS = Object.freeze([
-    Object.freeze({ id: "codex", label: "Codex" }),
-    Object.freeze({ id: "claude", label: "Claude" })
-]);
-export function orderRoleOptions(roles) {
-    return [...roles].sort((left, right) => {
-        const rank = roleRank(left) - roleRank(right);
-        if (rank !== 0)
-            return rank;
-        return roleName(left).localeCompare(roleName(right));
-    });
-}
-function roleRank(role) {
-    const kind = role.kind?.toLowerCase();
-    const name = roleName(role).toLowerCase();
-    if (kind === "operator" || name === "operator")
-        return 0;
-    if (kind === "leader" || name === "leader")
-        return 1;
-    return 2;
-}
-function roleName(role) {
-    return role.name ?? role.id ?? "";
-}

package/dist/context/sourceTurnContext.js

@@ -1,30 +0,0 @@
-import { MAX_TURN_RESULT_OUTPUT_BYTES } from "../domain/agentResultTransport.js";
-export const MAX_SYNTHESIS_SOURCE_TURNS = 8;
-export const MAX_CONTEXT_SOURCE_TURNS = MAX_SYNTHESIS_SOURCE_TURNS + 1;
-export const MAX_CONTEXT_SOURCE_TURN_BYTES = MAX_CONTEXT_SOURCE_TURNS * (MAX_TURN_RESULT_OUTPUT_BYTES + 16 * 1024);
-/**
- * Frozen input for synthesis. The main Agent needs the producer identity and
- * exact result, not another copy of its prompt history, launch configuration,
- * or workspace descriptor.
- */
-export function sourceTurnContextValue(turn) {
-    if (turn.result === undefined) {
-        throw new Error(`Source Turn has no result: ${turn.id}.`);
-    }
-    return Object.freeze({
-        schemaVersion: 1,
-        id: turn.id,
-        taskId: turn.taskId,
-        roleName: turn.roleName,
-        purpose: turn.purpose,
-        ...(turn.workItemId === undefined ? {} : { workItemId: turn.workItemId }),
-        ...(turn.reviewRoundId === undefined ? {} : { reviewRoundId: turn.reviewRoundId }),
-        ...(turn.executionGroupId === undefined
-            ? {}
-            : { executionGroupId: turn.executionGroupId }),
-        ...(turn.executionLaneId === undefined ? {} : { executionLaneId: turn.executionLaneId }),
-        result: turn.result,
-        createdAt: turn.createdAt,
-        updatedAt: turn.updatedAt
-    });
-}