@zq-silk/yui 0.15.9 → 0.15.12

package/skills/yui-leader/references/integration.md

@@ -11,7 +11,7 @@ before acceptance:
 ```sh
 yui task work capture <work-id>
 yui task integration start <task> --project <project> \
-  --change-set <change-set-id> \
+  --work-item <work-id> --strategy <ff|cherry-pick|merge|manual> \
   --check "<Project Policy command>"
 yui task work accept <work-id> --summary "<decision and evidence>"
 ```
@@ -20,7 +20,23 @@ These are distinct decisions; confirm Integration succeeded before acceptance.
 Preserve each managed workspace's owner and the Task's recorded base. Do not
 silently advance that base because a remote branch moved.
 
-## Finish the same attempt
+## Resolve ordinary Git conflicts yourself
+
+`conflicted` is an engineering step owned by the Leader, not a request for
+user authorization. Read both sides' intent and the current Task contract,
+inspect the exact Integration source, target and workspace, resolve and stage
+the files there, then run `integration continue`. No preceding
+`resolve --option manual-resolution` is required for an ordinary conflict.
+Core completes the matching Git operation, records the candidate, runs or
+recovers its exact checks and advances the original target by CAS.
+
+Do not close the Task execution gate, stop unrelated work, create an
+InputRequest or end in passive waiting merely because Git conflicted.
+Escalate only a real product choice, changed scope, unavailable external fact
+or new authority. The explicit `manual` strategy still requires a recorded
+resolution rationale; it is not the ordinary conflict path.
+
+## Continue from exact evidence
 
 For direct Integration checks running as a DurableJob, Job success is not
 the final target update. Read the terminal result, then use:
@@ -32,8 +48,42 @@ yui task integration continue <task>/<integration>
 This also applies when no manual conflict resolution was needed. Do not start
 a duplicate Integration or wait for an empty queue to finalize it.
 
+Resume interrupted Git/Job work on this attempt when its source/candidate and
+Job identities can be proved. A clean HEAD, leftover REBASE_HEAD or successful
+Job alone does not prove source application or target advancement. Read
+diagnostics when evidence is missing or the source, workspace, candidate,
+target or check conditions changed. Never blindly replay a finished rebase
+or repeat a successful unchanged check.
+
 Resolve failures using the exact conflict or check evidence and the supplied
 Integration workspace. Never bypass compare-and-swap, update managed refs by
 hand, or create a replacement WorkItem for ordinary Integration correction.
 Recheck changed behavior or unresolved failures; do not rerun unchanged
 successful validation without a current reason.
+
+## Abandon an unprovable attempt without discarding delivery
+
+If this attempt cannot safely continue, preserve its candidate, modifications,
+logs and successful evidence, then formally `integration abort --reason ...`
+(or reject a pending resolution). A failed attempt does not require keeping
+the same ID forever or repairing a shared installation before any delivery.
+Choose a new Integration or another already-authorized delivery path.
+
+For `validating`, `abort` checks the exact target and Jobs under the same Git
+fence as `continue`. An unadvanced target can be abandoned despite changed
+check conditions. If CAS already advanced the target, the action records
+`committed` instead of pretending delivery was aborted. Read the returned
+outcome. A concurrent operation, unknown Job, or ambiguous target requires
+inspection, not a forced status change or rollback of current Project policy.
+
+Formal abort preserves history and workspaces. It is not Git abort, branch
+deletion, target advancement, or proof that a Job/process has stopped.
+Inspect all Jobs owned by the exact attempt, including an unbound Job;
+cancel and establish quiescence by exact identity before reusing or cleaning
+resources. Successful Job evidence and Task acceptance remain separate.
+
+Direct Task-main delivery is an alternative only when current delivery
+authority, ownership and the Task contract already permit it, with no other
+writer or active check using that workspace. Do not edit managed refs or the
+control-plane DB, modify another owner's workspace, upgrade shared tools,
+or expand publication authority to work around an Integration failure.

package/skills/yui-operator/SKILL.md

@@ -38,11 +38,22 @@ Inspect current Projects, Tasks, and relevant Task context before routing:
 
 ```sh
 yui project list
-yui task list
-yui task input list
+yui task list --view compact --json
 yui task context <candidate-task-id>
 ```
 
+Use the bounded catalog for discovery, not the detailed legacy list or an
+unconditional traversal of every page. Filter by Project/status/search when
+useful; follow `nextCursor` with the same filters only when more candidates
+are needed. Attention counts cover the authorized catalog before ordinary
+filters and pagination. Follow a category's `--attention` query to enumerate
+its affected Tasks, clearing ordinary filters and retaining its `all` flag.
+`executionSignals` are conservative raw inspection
+candidates (including live Runs and open work), not a computed failure or
+execution status. Inspect the selected Task's Context and original Messages
+before routing or deciding; a summary/ref is not the requirement or report.
+The existing detailed list remains available to explicit legacy consumers.
+
 Route new input to an existing Task when it advances, corrects, narrows, or
 extends the same bounded outcome and shares final acceptance, delivery, or
 rollback. Create a new Task only when the new outcome can succeed, fail,
@@ -192,7 +203,12 @@ yui task input cancel <task> <input> --reason "<Leader-owned decision>"
 After an authorized PR/MR operation or before archive, read
 [publication and archive boundaries](../yui-runtime/references/publication.md).
 Record confirmed delivery facts promptly. Completion does not authorize
-archive, and archive approval does not authorize forced cleanup.
+archive, and ordinary archive approval does not authorize `--force`.
+When the user explicitly authorizes force archive for an eligible terminal
+Task, archive even if delivery proof or cleanup is incomplete. Report the
+warnings and retained resources without claiming merge verification or physical
+quiescence. Force archive is not permission to delete dirty/uncertain resources,
+kill unrelated execution, abandon delivery or rewrite historical evidence.
 
 ## Recover from evidence, not from imagined states
 

package/skills/yui-reviewer/SKILL.md

@@ -60,6 +60,10 @@ binding fails before review begins:
   explicitly so the Leader can judge what remains useful. Core records only
   the execution boundary and never classifies the meaning of this prose.
 
+If the current retry projection says infrastructure recovery is already
+waiting or in flight, report that fact without recommending another dispatch.
+Do not manage the retry yourself or reinterpret its preserved candidate.
+
 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

package/skills/yui-runtime/SKILL.md

@@ -91,6 +91,40 @@ 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 AgentRun identity for a GlobalRole.
 
+A GlobalRole's durable input uses the same three actions as a Task Role,
+addressed by the Role's own name instead of a Task. The local-user Web surface
+exposes this contract. The current public CLI catalog does not register the
+top-level `role` path, even though its handlers implement `yui role message
+queue|steer` and `yui role interrupt`; CLI routing rejects these commands as
+unknown. Report this availability gap when it prevents authorized work. Do not
+invent another command, fabricate Task/Run ownership or borrow the browser's
+user authority to bypass a managed Session boundary.
+
+Queue and steer
+save an owned Message; bare interrupt records a control request, not a new
+Message. Each uses a stable request id and that Role's own Session; none fabricates a Task or
+runId to reuse Task-scoped delivery. `queue` delivers at the Role's next legal
+opportunity and is idempotent by request id. `steer` and `interrupt` affect only
+the exact current native Turn — a stale `--expected-target`, an incapable plan,
+or an unproven delivery leaves the Message saved and reports the reason, and
+`interrupt` stops only through the Provider's native cancel with an optional
+`--then-message` naming one already-saved GlobalRole Message. When the Role holds
+no live managed Turn, a steer or interrupt is `NO_ACTIVE_TURN` and never falls
+back to another action.
+
+New controlled Global Sessions use the existing Host console, not the native
+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. Read the referenced Message in full
+from Session Context. Native/transport acceptance is not implementation, and
+`interrupt-requested` is not a stopped Turn or stopped background resources.
+Only an exact terminal and the original Session/writer boundary can release a
+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.
+
 ## Preserve intent and authority
 
 An analysis, diagnosis, or review request is read-only unless the user also
@@ -147,6 +181,14 @@ 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.
 
+Qualifying transient Provider failures have bounded Controller-owned recovery.
+Read the current `providerRetry`/`retry` projection before dispatching a manual
+successor. `waiting` and `in-flight` mean infrastructure recovery is already
+owned; do not add a private retry loop or resend the input. Only a proven native
+success resets that chain, and it never accepts a WorkItem or completes a Task.
+After recovery, inspect existing work and external receipts before continuing;
+the system's recovery instruction supplies no new user authority.
+
 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

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

@@ -13,6 +13,26 @@ 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.
 
+Keep the completion head as the original acceptance evidence. If an authorized
+post-completion integration produced a different publication candidate, record
+its exact local commit, then read `task publication diff <task>/<publication>`.
+Inspect the complete delta against the original acceptance, including removals,
+conflict resolutions and additional changes. Only when that candidate still
+satisfies the result and its relevant increments are accepted, record
+`task publication adopt <task>/<publication> --reviewed-diff <sha256> --acceptance <text>`.
+Explain the semantic judgment and verification/review evidence in the acceptance.
+When an existing Task Integration produced that exact candidate, include
+`--integration <id>` in diff and adopt to bind its committed evidence.
+Ancestry or Integration success alone is not acceptance; do not reopen the Task,
+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,
+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.
+
 Use `yui task remote-delivery <task>` to explain external delivery. Publication
 is not Candidate acceptance, Review, Integration or Task completion.
 
@@ -20,3 +40,25 @@ 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.
+
+With explicit force authorization for a completed or cancelled (retired) Task, use
+`yui task archive <task> (--integrated|--abandon) --force`. Force commits the
+archive and stops new Task scheduling before attempting safe foreground cleanup.
+Missing/stale delivery evidence, unresolved execution and cleanup errors become
+warnings with retained resource references; they do not block that commit.
+Authority, lifecycle, identity and mandatory audit persistence still fail closed.
+
+Force does not verify a merge, accept work, stop unknown execution, discard dirty
+data or imply abandonment. Keep the requested disposition and original
+Publication/completion evidence. Unverified local commits and resources that
+cannot be safely released stay owned and traceable. Late runtime events remain
+source evidence, not authority to resume or settle unknown input.
+
+Read `task show <task> --json` for `data.archive.warnings`,
+`data.archive.retainedResources` and `data.archive.cleanupEvents`;
+`task context` also retains the original records/events. A successful archive
+exit means `archived=true`, not that cleanup fully succeeded. `cleanupFinished`
+means the foreground pass finished, not that every resource was removed.
+If cleanup was interrupted, the Task stays archived. Repeating archive only
+reports current facts; use explicit, exact-owner resource operations after
+inspection instead of re-running broad cleanup. No background retry is implied.

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

@@ -12,6 +12,30 @@ 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.
 
+### Bounded infrastructure retry
+
+The Controller, not the Agent, counts and schedules qualifying transient
+Provider retries: at most five automatic executions after the initial failure,
+within one ten-minute recovery window. Native acceptance, activity and partial
+output do not reset that count. Unknown delivery remains fenced for exact
+readback; it is never replayed.
+
+Inspect the current projection in Context, or use
+`task role session retry <task> <role> show`; Global Sessions use
+`session retry <role> show`. While `waiting` or `in-flight`, do not dispatch a
+duplicate. A readable failed Run remains immutable evidence while its recovery
+successor handles the same responsibility and frozen Review boundary.
+
+`cancel` withdraws pending automatic recovery; `disable` additionally disables
+future automatic chains on that Provider binding. Neither stops an admitted
+native Turn. `enable` permits future failures to qualify, without replaying
+old failures. These controls require the existing user/supervisor authority.
+
+`exhausted`, `cancelled` and `needs-attention` preserve the error, input and
+work. Read their exact reason, then choose an authorized next action. Unsupported
+Hosts/Adapters or unprovable Session/background state do not trigger automatic
+replacement, cleanup, model switching or a new grant.
+
 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.