@zq-silk/yui 2.5.0 → 2.7.1

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
@@ -165,6 +188,66 @@ 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, previously 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
+inbox delivery. Original Messages, wake windows and handling receipts remain
+readable after acknowledgement.
+
 ## Read bounded information completely when required
 
 Structured CLI results live in the top-level `data`, not a JSON-encoded

package/skills/yui-runtime/VERSION

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

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

@@ -93,6 +93,15 @@ 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.
 
+Native internal retries are not failed terminals: observe without submitting
+another input. A missing automatic retry record is not evidence of exhausted
+budget or a damaged Session. An explicit `task run retry <task>/<run>` can
+continue from the current exact failed Turn even without an earlier automatic
+chain. Codex `systemError` alone does not require replacement; the normal
+submission path checks that the latest Turn is that failed Turn and background
+execution is empty. Missing or changed proof is a refusal, not permission to
+replay, change models or silently replace the Session.
+
 ## Replace a Session deliberately
 
 An authorized Leader or Operator may request:

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