@zq-silk/yui 2.8.1 → 2.10.0

package/skills/yui-runtime/SKILL.md

@@ -130,9 +130,10 @@ For every explicitly dispatched managed Task AgentRun:
    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.
+5. On a later wake, refresh current Task facts separately from frozen Run refs.
+   Use a Run delta only against its exact declared Snapshot lineage; `deltaRefs`
+   is a hint, not a complete patch. If no baseline is available, reload the
+   exact pack; do not reconstruct state from transcript memory.
 
 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
@@ -190,11 +191,13 @@ 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 a bounded
-`pending` discovery page, not Message bodies, Profile bodies, recent history or
-accumulated retry details. The Manifest retains the exact Role profile.
+`pending` discovery page of current-turn and available input, not Message bodies,
+Profile bodies, historical receipt debt or accumulated retry details. Its
+`historyCount` is a separate absence-of-handling-evidence count, not new work.
+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>`
+page's `nextCursor` using `role message list <role> --current --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.
@@ -213,13 +216,24 @@ explicit new control attempt; uncertainty does not.
 
 ## Handle your own inbox in the current turn
 
+For an automatic delivery naming an exact Message or wake, use that entry
+directly: read its original, claim it, and record its semantic disposition
+before ending this turn. Do not first enumerate history to rediscover it.
 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,
+off, use `yui inbox list --view current --json` to discover current-turn and
+available 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.
 
+`--view history` discovers old missing receipts explicitly; default `--view all`
+prioritizes current inputs and labels each entry's category. Never treat an
+absent historical ACK as proof that its work was not done. Read history when a
+specific reminder, recovery or user request calls for it, not every turn.
+Current correlation reuses exact delivery/continuation/control identities;
+active claims retain their observed native attempt when available. Missing
+historical correlation is not reconstructed from timestamps or final text.
+
 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
@@ -240,6 +254,33 @@ identity. A native child gains no separate actor or inbox.
    Record an obsolete notification as requiring no further action only after
    checking its originals and current facts, never based solely on age.
 
+An input can be settled as executed, legally routed/delegated, a necessary user
+question raised, or superseded/no action after inspecting authoritative
+originals. Put that concrete disposition and useful Task/InputRequest/result/
+Publication references in `--reason`. Routing may be complete while the Task
+is still running; do not hold the input until all downstream work finishes.
+For supersession, identify the later source, not merely its age.
+
+At an exact native terminal, engineering checks for unacknowledged inputs
+correlated to that turn and emits at most one existing notification. This is
+missing-evidence detection, never semantic ACK or proof of absent effects.
+Reminder-only turns do not generate another reminder. The retained originals
+remain inspectable if the bounded reminder is also missed; do not start a
+private polling/retry loop or copy the business input to obtain another turn.
+Task Assignment checks go to Leader for inspection and existing handoff or
+retirement, not automatic Worker/Reviewer replay. Exact terminal can end an
+active-consumption notification reservation without acknowledging its input;
+it does not infer or release an uncertain native writer.
+
+For obsolete Global input that was conclusively not submitted, use
+`yui inbox retire <entry> --request-id <stable-id> --reason "<disposition>"`
+after inspecting the original and current facts. Retirement preserves the
+original target, claim and explicit management evidence; it is not ACK.
+Accepted input uses normal claim/ack reconciliation. Unknown/pending control,
+transport acceptance and interrupt-then ownership cannot be retired through
+this operation. Task Messages retain the existing Leader `task message retire`
+and exact-Assignment handoff paths.
+
 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
@@ -247,6 +288,13 @@ 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.
+After legal Session replacement, initialization can arrive before old handling
+is settled. This recovery notification is not the original business input or
+an acknowledgement. Read the current inbox and prior effects first. For
+`claimed-by-previous-session`, retain the original claim: do not claim again.
+Finish only the still-authorized handling and use a new stable ack request ID
+with a concrete disposition; the receipt retains both the old claimant and
+the current acknowledging actor. New queued input remains separate.
 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
@@ -276,6 +324,12 @@ 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 explicitly released Leader notification (`notification.resolved` with
+`released-without-replay`) can be claimed for evidence inspection and settlement
+after verified native stop. Its original delivery status stays unknown or
+unaccepted; handling it cannot retarget Session-specific instructions or
+authorize re-executing unknown effects. If a required fact or user decision is
+unavailable, preserve the claim and report that exact boundary.
 
 An ack belongs to the exact original and revision: fixed windows pin
 `message.updated` event identities, including same-timestamp edits. A later
@@ -290,6 +344,11 @@ exactly-once execution.
 
 ## Read bounded information completely when required
 
+For apparent conflicts, stage handoffs or incremental maintenance, read
+[current intent and temporal reads](references/context-ordering.md).
+It distinguishes stage progression from independent constraints and explains
+source attribution, Brief guards, fixed delta windows and bounded recovery.
+
 Structured CLI results live in the top-level `data`, not a JSON-encoded
 `output` string. Task current Context includes bounded current facts and
 message references; it does not include event or terminal Run history.

package/skills/yui-runtime/VERSION

@@ -1 +1 @@
-6
+10

package/skills/yui-runtime/references/context-ordering.md

@@ -0,0 +1,103 @@
+# Current intent, provenance and temporal reads
+
+Use this when a handoff, changed requirement, stale summary or incremental read
+appears to conflict with earlier material. Core supplies facts and source
+relations; the Agent decides meaning within its existing authority.
+
+## Resolve the apparent conflict
+
+Read the current Task view first, then the relevant exact original sources:
+Task requirements, `phase.activation.source` event and its linked Message,
+current request, Brief, and the Session's actual authority. The `phase` and
+`caller` projections are observations, not permission granted by a summary.
+Do not fetch all history merely because the sources differ.
+
+Classify the difference before deciding:
+
+- **Stage progression:** an earlier “discuss only” limits that planning stage.
+  A later explicit request to start the same work, legally adopted Activation,
+  enabled gate and delivery-authorized Session establish the next stage.
+  Continue without asking for the same authorization again. The old words stay
+  in the audit trail; they are not a fresh stop.
+- **Same-scope replacement:** a later authoritative original can replace the
+  particular requirement it changes. Explain the scope of that replacement in
+  Brief; preserve unchanged requirements and the original references.
+- **Independent restriction:** “do not publish”, resource limits, material
+  exclusions and unrelated prohibitions remain unless explicitly changed by an
+  authorized source. Development authorization is not release authorization.
+- **Actual contradiction or missing evidence:** read the exact source and
+  current facts first. If the material ambiguity remains, request only the
+  missing user decision; do not fabricate provenance or resolve it by timestamp.
+
+Active lifecycle alone never authorizes implementation of a new analysis-only
+request. An old planning Session never promotes itself. Stop, archive,
+Assignment, workspace and grant boundaries remain independent checks.
+
+An activation event's `sourceText` is exact text supplied by the recorded
+caller; `leader-attested-native-input` explicitly identifies the Leader's
+capture, not a Provider-verified user message. Read it as attributed evidence
+together with the adopted request. `sourceMessageId` names the original shared
+Message; its body digest detects edits, while handling receipts do not change
+the source body. Missing/changed/unavailable provenance is visible and calls for
+an exact-source read, not an automatic prohibition or an automatic grant.
+Do not select whichever summary arrived last as the winning authority.
+
+`phaseRelation: recorded-before-activation-request` is recording order only.
+It does not declare every old requirement superseded. A delayed result or an
+acknowledged Message retains its original scope, source and version.
+`revised-after-activation-request` means an existing Message was edited after
+that boundary; its old ID must not hide the new revision.
+
+## Keep the shared working summary current
+
+Description owns the goal and durable boundaries; Brief owns the current
+semantic interpretation, progress, blockers, next action and original refs.
+Core owns lifecycle, gate, Activation, Session and operation facts. Do not
+manually mirror them into a competing state machine.
+
+At a changed requirement, phase handoff, resolved blocker, meaningful result or
+completion, reconcile affected Brief fields. Routine unchanged steps need no
+write. `phase.brief.refresh-needed` is a mechanical hint, not a semantic verdict
+or completion gate. Compare originals before editing.
+
+Read `task brief show <task>`; update with its `writeGuard` as
+`task brief update <task> --if-current <writeGuard> ...`. A new semantic event,
+Brief edit or changed Task boundary invalidates the guard even at the same
+timestamp. On rejection, reread current facts and reconcile only the intended
+fields; do not blindly copy an old summary under a newly read guard.
+An old Session still cannot write through this operation.
+
+## Maintain a baseline and incremental history
+
+For current Task facts, retain `coreCursor` from `task context <task>`.
+`task context delta <task> --after <coreCursor>` returns **event history**, not
+a replacement current view. Retain the same `--after` on every continuation;
+use `--continuation` until `complete: true`, then advance to `throughCursor`.
+The window's upper bound is fixed. Later arrivals belong to the next read.
+
+Deduplicate by source Home + Task + event ID, and process numeric event order
+within that stream. `createdAt` is occurrence/recording metadata, not a global
+causal clock; native acceptance, delivery and acknowledgement are separate
+facts. Never apply a late event's old payload over a newer current record.
+Re-read affected current refs with their digest when making a decision.
+An empty delta preserves the baseline; `stateChanged` can still require a
+current read because not every shared fact is a Task event.
+
+Cursors from another Home/Task, incompatible or invalid continuations, missing
+baselines and source changes require a fresh bounded current read. Do not join
+pages from different windows or versions. A failed original-detail digest
+requires rediscovery; a content page must be reassembled only with its own
+source digest. None of these reads consumes input or permits replay.
+
+Frozen Run context is a different stream. Keep its exact Snapshot and
+Assignment. `deltaRefs` is a launch hint, not a complete patch. The explicit
+Run delta reports complete changed `refs` and `removedRefs` against its named
+parent Snapshot, with large documents paginated. Apply removals only to that
+frozen inventory; an empty delta is a no-op. Mutable Task facts and current
+inbox clarifications must be refreshed separately within read scope; they
+never expand the frozen Assignment or change a Review candidate.
+
+Focused wakes use exact input refs, including delayed and same-timestamp
+inputs. Timestamp-window discovery is under `--history` (or a historical wake
+without refs), not new delivery authority. Original event and Message reads
+remain available without rewriting or replaying them.

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

@@ -67,9 +67,49 @@ whose result is delivered; do not duplicate the same PR/MR across Tasks to
 substitute for missing ownership or acceptance evidence.
 
 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.
+deployment status. Verification is tool-neutral: the Leader may use any available
+CLI or API within the existing external-read authority. No particular brand,
+installation or second gh/glab query is required. A summary saying "merged" is
+reported evidence, not a tool observation; `upsert --verified` is refused.
+
+First record the exact local candidate, PR/MR URL (including its service host)
+and target branch. Inspect that object with an authorized tool, checking the
+repository, PR/MR identity, target branch, remote source head and integrated
+commit against the actual output. Then use
+`task publication verify <task>/<publication> --observation '<json>'`.
+The JSON fields are `taskId`, `publicationId`, `projectId`, `provider`,
+`repository`, `externalKind`, `externalId`, `externalUrl`, `targetBranch`,
+`localCommit`, `state`, `headCommit`, `remoteCommit` (required for merged),
+`observedAt`, `tool`, `command`, `output`, and optionally `mergedAt`.
+Use full lowercase SHAs and ISO timestamps; `output` is a sanitized relevant
+tool-response excerpt, not an unsupported conclusion or credentials. `command`
+describes the exact CLI query or API request; Yui does not execute it.
+Read the original output and resolve ambiguous/conflicting results before
+asserting a known state. Do not fabricate evidence or normalize failure into merge.
+
+The observation must name the current immutable Publication, match its candidate,
+URL and target, and be recorded within 24 hours without future dating. The tool
+read may precede the first upsert or a title-only update: these are bookkeeping,
+not changes to the observed object. Observations must not predate the latest
+material change in the immutable lineage (candidate, object, target or remote
+facts), including a changed-then-restored candidate. When only bookkeeping has
+changed, read the current record and bind the same actual result to its current
+ID; do not repeat the external query just for that update.
+Identical immediate retries reuse the saved receipt.
+Later candidate/URL/target changes invalidate verification; use fresh evidence,
+not an old JSON edited to look current. Inspect `publication show` after an
+uncertain save before retrying. Original records and their full evidence remain.
+These are caller-attested tool facts: Core checks exact binding and freshness,
+not the semantic truth of arbitrary output. It trusts the authorized Leader's
+inspection, not the executable's brand.
+
+Without `--observation`, `verify` uses the optional gh/glab adapter and performs
+an external read, requiring that read's existing authority. Missing adapters
+are not missing user authorization when another authorized tool is available.
+If no usable evidence or authorized read exists, retain reported evidence and
+state that specific gap. A recorded verification is fixed evidence, not live
+monitoring; no clock-based re-query is required just to archive it. Known later
+changes must be recorded as successors before relying on delivery.
 
 Preserve each completion head as that acceptance's evidence. After an authorized
 reopen, finish the new work and record its own completion; retain the earlier
@@ -88,7 +128,7 @@ rewrite completion, or mark a merge verified to bridge an evidence gap.
 
 Adoption records a fixed decision, not remote verification or publication
 authority. The verify operation observes the exact Publication candidate through
-its provider and records contrary head/state facts as reported successors,
+an authorized tool or the optional adapter and records contrary head/state facts as reported successors,
 invalidating previous verification. Metadata and verification updates may retain
 adoption while the candidate is unchanged; a changed candidate needs a new
 decision. Archived history is read-only to these adopt/verify operations.

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

@@ -122,6 +122,27 @@ context and fixed notification references, then chooses which still-valid
 assignment to continue. Released Leaders retain scoped diagnostic reads but
 cannot regain write authority.
 
+Leader initialization is delivered separately from old inbox handling and
+new queued business. A retained claim cannot block this lifecycle notification.
+The current Leader reads `yui inbox list --view history --json`, then the exact originals and
+prior effects. Claims survive unchanged; use `inbox ack` only after actual
+handling, with the successor's own disposition. Do not claim an already-claimed
+entry again. Repeated reconciliation or Controller restart does not settle
+anything or repeatedly wake an idle handler.
+
+A legally started GlobalRole successor with claims from a previous Session
+receives one Session-pinned recovery Message in its existing inbox. It requests
+the same inspection, not replay of those Messages. A stopped Global Session
+is not started by this notice. Worker/Reviewer Assignment changes still require
+the existing explicit handoff or retirement; no bulk transfer is implied.
+
+Replacement waits for exact native/resource stop and writer release. Missing
+proof requires repairing that observation or a genuinely missing user decision,
+not a timeout, another name, force-ACK or record deletion. Uncertain old
+notification submissions are released from scheduling without replay, retaining
+their fixed wakes and `notification.resolved` evidence. They become explicitly
+inspectable/settleable, not automatically accepted or resubmitted.
+
 ## Handle uncertainty and failed cleanup
 
 Never replay a notification whose acceptance is unknown. After evidence

package/skills/yui-worker/SKILL.md

@@ -29,6 +29,11 @@ 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.
+For delayed or conflicting material, follow Runtime's
+[temporal read contract](../yui-runtime/references/context-ordering.md).
+Refresh relevant current originals without replacing the frozen Assignment.
+Report genuine scope conflicts to Leader; older stage-only wording is not a
+new prohibition after a legally authorized handoff.
 
 Leader clarification and continuation arrive as Messages in the exact bounded
 Context Pack. Read those authorized refs; do not request pack-external Leader

package/skills/yui-worker/VERSION

@@ -1 +1 @@
-2
+3