@zq-silk/yui 2.6.0 → 2.8.0

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](../yui-runtime/SKILL.md) first and load the exact current
+Follow [yui-runtime](../yui-runtime/SKILL.md) first, including its per-turn
+version/availability check and conditional full reload, 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.
@@ -51,6 +52,12 @@ execution a scoped question may be sent with `task message send <task> "<questio
 
 ## Separate infrastructure failure from review judgment
 
+At useful review boundaries and before reporting, apply **yui-runtime**'s
+own-inbox flow for current-ReviewRound clarification. Read complete originals,
+claim before handling, and ack after disposition. These messages supplement
+the frozen pack; they cannot replace its Candidate, expand review scope, or
+turn acknowledgement into a review verdict.
+
 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:
@@ -83,6 +90,35 @@ request a follow-up Round yourself.
 Use Project Skills, Policy and Knowledge for project-specific checks. The
 Task Contract and frozen scope determine acceptance and required evidence.
 
+## Derive scenarios, then inspect the complete candidate
+
+Read the frozen Task/WorkItem requirements, non-goals and applicable decisions
+before using the author's explanation. The frozen Brief is a summary and material
+index, not the contract body. Follow its relevant same-Task commit-pinned artifact
+references with `task artifact read <task> <path> <commit>`; expand Context pointers
+and their content pages as required. A path in prose grants no additional access.
+Report missing or conflicting evidence instead of replacing it with a newer head.
+
+Derive observable expectations from requirements and independent contracts, not
+from the current implementation or its mocks. Trace the complete authorized
+change and necessary callers, consumers, state and side effects. Select
+complementary perspectives according to risk: user paths, producer/consumer
+contracts, state/data invariants, failure and partial recovery, authorization,
+and whether verification tests the actual contract. Multiple perspectives do
+not require multiple Agents or every perspective on every task.
+
+Turn applicable perspectives into concrete scenarios, expected behavior and
+evidence. Challenge important assumptions with the smallest reachable
+counterexample; check normal controls and non-goals too. A shared assumption
+between a mock and implementation is not independent confirmation. Reuse valid
+checks; do not run external-resource validation without its exact authorization.
+Stop neither at the changed lines nor after finding a few defects.
+
+For an ordinary full re-review, inspect the current complete frozen candidate
+and requirements, using the repair delta, prior finding dispositions and still
+applicable evidence as guidance, not a scope ceiling. An explicitly assigned
+Delta Recheck retains its narrower equivalence contract above.
+
 Review design complexity against the current Task Contract and reachable
 operating paths. Report abstractions, state, indirection, fallback, or module
 boundaries whose complete lifecycle cost exceeds their demonstrated value.
@@ -110,6 +146,12 @@ frozen Review or its original report.
 
 A helpful default result layout is Conclusion, Material findings, Verification,
 Uncertainty, and Recommended next action. Markdown or JSON are both acceptable.
+Include a short account of the perspectives/scenarios actually inspected and
+material unexamined risks, not a copied checklist. Each confirmed finding should
+identify its trigger, violated expectation, impact and supporting evidence;
+merge one root cause without losing its affected entry points. Distinguish
+uncertain reachability or missing verification from a confirmed defect. There
+is no finding quota, mandatory perspective count or claim of exhaustive coverage.
 Yui preserves the original text and does not parse a verdict or reject it for
 missing headings, field names, or formatting. Follow `yui-runtime`'s optional
 `Yui-Summary:` first-line convention for attributed notification text; retain

package/skills/yui-reviewer/VERSION

@@ -0,0 +1 @@
+3

package/skills/yui-runtime/SKILL.md

@@ -16,16 +16,34 @@ workspace layout, native transcript, or an earlier AgentRun.
 
 ## Enter through the current context
 
-Stable instructions and dynamic facts have different lifetimes. On first entry,
-new Session, Manifest/version change, or missing instructions (including after
-compaction/recovery), read the exact Session Manifest and fully load its profile
-and named Skills: `yui-runtime` plus the referenced `yui-leader`, `yui-worker`,
-`yui-reviewer`, `yui-operator`, or custom Role Skills. Resolve IDs to paths and
-versions through that Manifest, never another installed namesake. If those exact
-same-version instructions are already fully available in current context, apply
-them without mechanically rereading. Same Session, prior delivery, and prior
-reads do not prove availability. The short Manifest pointer remains a recovery
-entry, not a cache or authority receipt.
+Stable instructions and dynamic facts have different lifetimes. At the start of
+**every turn**, run the Manifest's `contextProtocol.skillCheckCommand`.
+For an older Manifest, use `yui session skills --json` through the Session's
+CLI/Home; a Global Manifest's self-contained `loadCommand` also checks current
+Skills and works without the launching shell's environment (for example Desktop).
+This lightweight read checks the applicable Skills' current stable paths,
+internal `VERSION` files and readability without loading their bodies. Its
+current paths supersede frozen-package paths in an older Session Manifest.
+Skill versions are independent of npm versions, Session revisions and Task
+Snapshots. A version observation is never evidence that instructions were read.
+
+On first entry, version change, new/restored Session, Host recovery, or missing,
+compacted or uncertain instructions, read the exact Session Manifest's profile
+and fully load the current `yui-runtime` plus the applicable Role/custom Skills
+from the check result, including necessary references. If their versions are
+unchanged **and** their full instructions are still available in current context,
+reuse them without rereading all bodies. Do not infer availability from the same
+Session, an earlier read, successful delivery or an unchanged version. Native
+children without their own managed identity use their parent's checked paths
+and inherited scope, never impersonate its Session.
+
+Historical frozen packages remain audit evidence only. Missing or damaged
+historical Skill evidence alone does not revoke a valid Session or block its
+messages, and current source cannot prove a historical load. A missing/unreadable
+current entry or version is a concrete installation/configuration error: report
+the path and legal recovery action, preserve input and authority, and check again
+after repair. Never clear identity, change Session or replay unknown input as a
+Skill-loading workaround. CLI/Home protocol and storage checks still apply.
 
 Refresh dynamic Task/Session facts before the relevant decision regardless of
 instruction reuse. Leader notifications use the Manifest's `currentCommand`;
@@ -41,7 +59,12 @@ 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.
+authority merely because the Task becomes active. An explicit, legal same-result
+implementation or delivery follow-up may instead authorize the current Leader
+to reopen its own completed, unarchived Task; follow the
+[post-completion routing boundary](references/publication.md#post-completion-routing-boundary).
+Queries, discussion, ordinary notifications and Session recovery grant no such
+authority, and reopening never lifts an independent execution stop.
 Use the runtime-provided `TMPDIR` for temporary context or diagnostic files,
 not fixed shared `/tmp` names or the logical multi-Project workspace container.
 Save durable reports in Task artifacts/results before releasing their temporary
@@ -56,6 +79,15 @@ installation with the same protocol and storage versions. If the entry or Home
 is wrong or unavailable, report that fact and use the explicitly authorized
 entry/environment; do not guess another installation or clear Session identity.
 
+Desktop commands may carry only `CODEX_THREAD_ID`. The CLI resolves that native
+identity in the selected Home's current Session registry before routing Task or
+Global operations. Environment and Manifest values are location hints, not
+continuing grants. Conflicting, unregistered, replaced or revoked identities
+do not become public-user callers; a plain user terminal has no managed/native
+identity. `inbox list` reports the resolved current identity. Do not add or clear
+environment fields to repair a mismatch. Without a Manifest environment pointer,
+`session skills` returns current Skill paths and the Session's captured profile.
+
 For every explicitly dispatched managed Task AgentRun:
 
 1. Read the exact AgentRun identity from the newest Bootstrap Envelope.
@@ -70,8 +102,15 @@ For every explicitly dispatched managed Task AgentRun:
    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.
-4. Use the pack's `pointers` (including each pointer's summary) first. They are
-   the single readable-ref inventory; `deltaRefs` contains only changed identities.
+4. Use the entry's `pointers` (including each pointer's summary) first. They are
+   a bounded window into the frozen readable-ref inventory. `pointerPage`
+   reports total/complete/nextCursor; discover further relevant refs with
+   `task run context <task>/<run> --view refs [--cursor <cursor>]`.
+   `deltaRefs` samples changed identities, with `deltaRefsTotal` reporting coverage.
+   `--view full` explicitly reads the complete pack when needed; do not load or
+   traverse every historical reference merely to make an entry window complete.
+   If `input.directiveOmitted` is true, read the complete assigned input with
+   `--view input` before acting; its entry summary is not the instruction body.
    Expand only an authorized ref when
    its full value is needed, selecting it by the pointer's exact `store` and
    `refId`:
@@ -150,13 +189,20 @@ TUI, with the configured Agent, permissions and workspace unchanged. A live
 unmanaged Session is not silently replaced or adopted; use an explicit Session
 lifecycle action before enabling controlled delivery.
 
-Context reads never consume queue entries. Global Context returns bounded
-`pending` and `recent` discovery pages, not Message bodies. Read a referenced
+Context reads never consume queue entries. Global Context returns a bounded
+`pending` discovery page, not Message bodies, Profile bodies, recent history or
+accumulated retry details. The Manifest retains the exact Role profile.
+Read a referenced
 original with `role message show <role> <message-id> --json`. Follow a pending
 page's `nextCursor` using `role message list <role> --pending --cursor <cursor>`
 when it is incomplete; accepted delivery does not erase the Message from the
 separate all-message list. Native/transport acceptance is not implementation, and
 `interrupt-requested` is not a stopped Turn or stopped background resources.
+`role message list <role> --diagnostics` projects repeated classified failures
+from original evidence with first/latest occurrence, count and recovery evidence.
+`--diagnostic <key>` pages the original affected observations. Counts cover
+distinct observations, not repeated polling of one identity. A recovery notice
+is neither an input acknowledgement nor proof that prior effects were undone.
 Saving a Task Message or Brief is not notification delivery to Operator. A
 Task Role uses the existing Task InputRequest path for a genuinely missing
 user decision, not global Role input controls or fabricated progress questions.
@@ -165,6 +211,83 @@ then handoff. An accepted or unconfirmed steer must not be submitted again by
 changing its request id or composing then. A conclusive rejection permits an
 explicit new control attempt; uncertainty does not.
 
+## Handle your own inbox in the current turn
+
+After loading authorized context, at useful work boundaries and before handing
+off, use `yui inbox list --json` to discover pending input addressed to your
+current managed identity. This applies to Operator, custom GlobalRole, Leader,
+Worker and Reviewer. Do not poll an empty inbox or create another model turn.
+No target Role, Task or native Session is supplied: Yui resolves your current
+identity. A native child gains no separate actor or inbox.
+
+1. Read the selected `yui inbox show <entry> --json`. Reads never consume input.
+   Follow `nextCursor` and all `contentPage` pages using the rules below.
+2. Before processing, reserve exact entries with
+   `yui inbox claim <entry> [<entry> ...] --request-id <stable-id> --json`.
+   At most 16 entries are allowed, with independent per-entry results. Retain
+   each successful returned ID and request ID; do not replay successful items
+   when another item fails. A changed pending window requires a fresh list.
+3. Read complete originals and referenced results, then handle the request
+   within its existing authority. Leader notification-window claims move one exact pending window
+   into a durable wake: use the returned `originals` command, follow every
+   relevant original Message/Run reference, and use its returned wake ID for
+   acknowledgement. Later arrivals remain in the next pending window.
+   Assignment inbox reads (including a managed Leader Assignment) expose only
+   messages for the current Assignment;
+   they supplement the frozen pack without expanding it or changing candidates.
+4. Only after handling, explicitly acknowledge each successful item:
+   `yui inbox ack <returned-entry> --request-id <stable-id> --reason "<disposition>" --json`.
+   Record an obsolete notification as requiring no further action only after
+   checking its originals and current facts, never based solely on age.
+
+Claiming prevents ordinary automatic delivery; it is not processing completion.
+Acknowledgement records Agent handling, not Host acceptance, result acceptance,
+Task completion, publication or archive. Never acknowledge merely to empty the
+list. On failure or interruption, leave the claim unacknowledged; it remains
+discoverable and does not expire or replay automatically. A current rightful
+successor must inspect original input and prior effects before finishing and
+acknowledging a retained claim. Never replay uncertain external actions.
+For an exact-Session input already claimed by its selected Session, a rightful
+successor may explicitly settle that handling after inspecting the original
+and prior effects. This preserves the original target and claim; it grants no
+permission to submit or execute the input in a different Session.
+An Assignment change does not inherit handling authority. If the original Run
+stopped before acknowledgement, ask the Leader to inspect its exact native
+terminal and use the existing `task message handoff` to the current authorized
+Assignment. The original claim remains; handoff never resubmits it automatically.
+If that Assignment is obsolete, the Leader may inspect the original and prior
+effects, then explicitly use `task message retire <task/message> --reason "<disposition>"`.
+Retirement preserves the original claim and records the management decision;
+it neither fabricates an acknowledgement nor proves native execution stopped.
+An unfinished claim fences its Assignment, not unrelated work of the same Role.
+
+In-flight, unknown, not-yet-delivered explicit interrupt-then and
+unsettled steer inputs retain their existing owner/receipt and report a bounded
+reason instead of being taken over. Use existing exact-receipt recovery when
+needed; do not change request IDs, clear identity, or copy input to bypass it.
+A steer with no control receipt was not submitted; it may be explicitly handled
+and acknowledged in its authorized inbox, without converting it into a queue.
+An accepted notification still follows its normal handling path, not another
+native delivery. Accepted Global inputs, delivered Leader windows and current
+Assignment continuations remain in the inbox until explicitly handled. Claim the
+received entry, inspect its originals and existing effects, then ack with a
+concrete disposition (including result or effect receipt references when useful).
+This claim never sends the input again. A current rightful successor may settle
+an accepted Global input or Leader window while retaining the original delivery
+target; it must inspect prior effects first. Pending/unknown acceptance stays
+blocked and cannot use claim as a replay path.
+
+An ack belongs to the exact original and revision: fixed windows pin
+`message.updated` event identities, including same-timestamp edits. A later
+revision still needs its own handling. Before Task completion, settle handled
+user-input windows; native acceptance or a terminal does not settle them.
+Original Messages, wake windows and handling receipts remain readable after
+acknowledgement. Lost context, Session continuation and installation upgrades
+do not reset receipts. If ack fails after an external effect, read back the
+original claim and the external receipt before retrying the same ack; do not
+repeat the effect. This is durable handling evidence, not arbitrary external
+exactly-once execution.
+
 ## Read bounded information completely when required
 
 Structured CLI results live in the top-level `data`, not a JSON-encoded
@@ -176,6 +299,12 @@ family, then `task context inspect <task> --store <store> --ref <refId>
 --digest <digest>` to read its exact current value. Common Task lists use the
 same `items`, `total`, `complete`, and `nextCursor` contract. Do not treat the
 first page or a summary as complete requirements.
+The 32 KiB compact-JSON read budget includes nested data, cursors and structure;
+summaries are at most 512 UTF-8 bytes. Current Task Message discovery excludes
+explicit acknowledgements and retirements, not uncertain delivery. Use
+`--view current` for its continuation and the default all view for history.
+Skill checks remain metadata-only; unusually large checks use the same explicit
+document pagination. A small default window is not a request to fetch all history.
 
 Long detail reads return `contentPage` instead of the ordinary value (under
 `data.context` for Run context/expand, `data.contextDelta` for Run Context delta). Repeat the same read with

package/skills/yui-runtime/VERSION

@@ -0,0 +1 @@
+6

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

@@ -8,9 +8,19 @@ to push, publish, merge, query an external provider or archive.
 
 An explicit user request to continue implementation or delivery of the same
 completed, unarchived result authorizes its necessary reopening within that
-request's scope. The Operator need not ask the user to additionally say “reopen.”
-Read the original completion, fixed heads/reports, Publication and current
-authority first, then use the existing two operations:
+request's scope. The current matching Leader may call `task reopen <task>` for
+its own Task and continue that request; an Operator handoff is not mandatory,
+and neither Role needs the user to additionally say “reopen.” Read the original
+completion, fixed heads/reports, Publication, new request and current authority
+first. Inspect the reopen result and current Context before executing; delivery
+still requires the current Session's delivery authority, legal workspace and an
+enabled execution gate.
+
+If the Leader already received the request, use its original durable input and
+continue after reopening; do not resend it or create a self-wake. Preserve a
+direct-conversation request and its boundaries in Task records when needed,
+without impersonating user/Operator input. When the Operator or user is routing
+new input, use the existing two operations:
 
 ```sh
 yui task reopen <task>
@@ -30,8 +40,9 @@ intact. The Leader must assess the new request and separately accept any new
 result, not pretend old validation proves changed work. Reopen does not replay
 historical Messages/Runs, change the Role's Agent/model/permissions, or lift an
 independent execution stop. Queries, ordinary record/discussion input and Session
-recovery do not authorize resumption. Cancelled intent needs its own explicit
-restoration authority; archived Tasks cannot reopen. A stopped gate still needs
+recovery do not authorize resumption. Cancelled intent needs explicit
+user/Operator restoration authority and cannot be restored by the Leader;
+archived Tasks cannot reopen. A stopped gate still needs
 the separately authorized start/cleanup path.
 
 These are two atomic operations, not one transaction. Read the reopen result and

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

@@ -143,11 +143,30 @@ 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.
 
-Breaking upgrades require a clean runtime environment; Yui does not discover,
-convert or inherit historical Hosts and processes. Storage migration is a
-separate explicit operation, not proof of runtime continuity. Do not interpret
-missing compatibility diagnostics as permission to reuse an old process,
-discard pending intent or bypass exact ownership and stop confirmation.
+Compatible upgrades preserve logical Sessions. Build generations and historical
+Skill packages are provenance, not continuation gates. Load current stable
+Skills and current authority; never change a user's model, account, native
+permissions or workspace to make an upgrade work.
+
+Within Host control/event v1, status advertises `controlCapabilities` and the
+loaded `hostImplementation`, independently of `endpointImplementation`. Missing
+capabilities or `eventDelivery` are unreported, not healthy. A Controller must
+not repeatedly send an unsupported `reconcile-turn`; the existing raw Inbox
+still permits exact event consumption without executing the input again.
+Current Hosts retain unpersisted original facts during a filesystem failure;
+keep that process alive until persistence recovers. Those volatile bytes cannot
+be recovered after process loss merely by restarting the Controller.
+
+Program/storage upgrade success does not mean Host replacement succeeded.
+Compatible live Hosts may continue, including busy ones. A new Host may resume
+the same native Session only through the existing authorized lifecycle after
+exact execution, background resources and writer release are proven. An idle
+status, a stopped proxy or a missing control field is insufficient. Unknown
+effects preserve the original Session, input and resources; do not force-kill,
+replay, hot-replace loaded modules or silently create a new Session. Existing
+explicit stop/replacement authority is separate from an ordinary upgrade.
+Unsupported protocols require an explicit bounded recovery plan, not arbitrary
+historical Host adoption. Storage migration remains independently fenced.
 
 After repeated failure of the same bounded recovery, report the observed
 cause, impact and smallest remaining options. Do not broaden cleanup or add

package/skills/yui-worker/SKILL.md

@@ -5,7 +5,8 @@ description: Complete a bounded Yui WorkItem AgentRun or native child assignment
 
 # Yui Worker
 
-Follow [yui-runtime](../yui-runtime/SKILL.md) first. For a managed AgentRun,
+Follow [yui-runtime](../yui-runtime/SKILL.md) first, including its per-turn
+version/availability check and conditional full reload. 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.
@@ -23,6 +24,12 @@ Resolve Skill links relative to this Skill's directory.
 
 ## Execute within the exact boundary
 
+Use **yui-runtime**'s own-inbox flow at useful work boundaries and before the
+final report. Current-Assignment `inbox show` is an authorized way to read new
+directed clarification during this turn without redispatch. Claim before
+handling and ack only after disposition; never use it to read another
+Assignment, expand Project permissions, or accept your own result.
+
 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.

package/skills/yui-worker/VERSION

@@ -0,0 +1 @@
+2