@zq-silk/yui 0.14.0 → 0.14.2

package/skills/yui-reviewer/SKILL.md

@@ -30,6 +30,21 @@ 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.
+
 ## Separate infrastructure failure from review judgment
 
 Verify the exact Turn identity, Context Pack, frozen head, and ReviewRound-owned
@@ -38,20 +53,13 @@ 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 only the exact infrastructure diagnosis, with no semantic findings or
-  checks, through the assigned Review Turn;
+- return the exact infrastructure diagnosis through the assigned Review Turn;
 - do not recommend a Repair WorkItem—the Leader must recover the same frozen
-  review boundary with `task review force-fresh` when Yui proves the outcome
-  non-semantic;
+  review boundary with Yui's projected same-Round `task review retry` or exact
+  `task turn retry`;
 - if any candidate inspection or Reviewer output did occur, report it
-  explicitly. Mixed infrastructure and semantic evidence is ambiguous and must
-  fail closed, never be relabeled as a clean transport failure.
-
-Yui derives `semantic`, `non-semantic`, or `ambiguous` from the immutable
-Round, Turn receipt, completion Event, and finding evidence. Never write or
-simulate a classification field. A non-semantic attempt cannot satisfy
-acceptance; an ambiguous attempt requires
-Leader diagnosis before another review or repair decision.
+  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
 handles new user input or advances Task main while this Review is running. Do
@@ -59,15 +67,10 @@ not switch to the newer head, cancel the current inspection, or claim the
 result covers anything beyond the frozen candidate.
 
 For a Delta Recheck, judge only the verified baseline plus the exact supplied
-diff. Return exactly one explicit disposition with reasoning:
-
-- `equivalent-and-accepted` when the new candidate preserves the accepted
-  semantics and evidence;
-- `finding` for a reachable material defect;
-- `requires-full-review` when equivalence cannot be established.
-
-Never create or request a follow-up Round yourself: `requires-full-review`, a
-finding, and every uncertainty return to the Leader for routing.
+diff. State clearly whether the new candidate remains equivalent, has a
+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
@@ -75,18 +78,17 @@ 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.
 
-Treat real models, paid APIs, shared infrastructure, production systems, real
-account quota, and every other non-disposable external resource as user-owned
-authority. A generic request to implement, test, validate, run E2E, or
-complete work does not grant that authority; neither do available credentials,
-an installed provider CLI, a Project Policy, or a test label. Unless the user
-proactively names the concrete real-resource validation, skip it without
-creating an InputRequest or blocking the ReviewRound. Prefer existing
-deterministic evidence, mocks, and isolated resources, then report the
-verification gap and an optional follow-up. An explicit request authorizes
-only its named resource, effect, and isolation boundary; never broaden it. A
-real Agent may develop or review code, but that does not authorize a real
-provider/model test.
+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.
+Do not demand generic frameworks, exhaustive edge handling, or speculative
+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.
 
 Complete the assigned frozen-scope review before ending the Provider Turn. Accumulate all
 reachable findings, verification gaps, checks actually run, and bounded next
@@ -96,6 +98,11 @@ 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.
 
+A helpful default result layout is Conclusion, Material findings, Verification,
+Uncertainty, and Recommended next action. Markdown or JSON are both acceptable.
+Yui preserves the original text and does not parse, normalize, or reject it for
+missing headings, field names, or formatting.
+
 For normal software delivery, follow the applicable Project Policy. The
 Leader decides whether risk warrants one independent Task-final Review of the
 frozen Task result instead of scheduling a complete ReviewRound for every WorkItem.

package/skills/yui-runtime/SKILL.md

@@ -39,21 +39,42 @@ For every managed Task Turn:
    If no cursor is available, reload the exact pack; do not reconstruct state
    from transcript memory.
 
+`liveTaskState.activeTurns` 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
+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.
 
-For a global Operator or custom GlobalRole Session, load the stable authorized view
-before routing or acting:
-
-```sh
-"$YUI_SESSION_CLI" session context "$YUI_ROLE" --json
-```
+For a global Operator or custom GlobalRole Session, execute the exact
+`contextProtocol.loadCommand` carried by the current Session Manifest before
+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.
 
 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.
 
+## Separate execution from real-resource validation
+
+The current Leader and configured Worker, Reviewer, Operator, custom Role, and
+native child Agents are normal execution resources. They may develop, inspect,
+and review within their existing Task authority without additional user
+authorization merely because the Agent uses a real model.
+
+Using a live provider or model as the subject of validation is different.
+Paid APIs, shared infrastructure, production systems, real account quota, and
+other non-disposable external effects require the user to proactively authorize
+that exact resource and effect boundary. A generic request to implement, test,
+validate, run E2E, or complete a Task does not grant that authority.
+
+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
 final report. Yui automatically correlates that native terminal with the exact

package/skills/yui-worker/SKILL.md

@@ -49,6 +49,13 @@ 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.
+
 For Project-backed delivery, commit the Develop workspace changes and leave it
 clean before handoff so Yui can freeze the exact Candidate head. ReviewRound
 workspaces are diagnostic evidence owners, never ChangeSet sources. Do not
@@ -63,10 +70,9 @@ changed behavior; do not repeat an unchanged successful check. Follow Project
 Policy for required validation and state passed, failed, and intentionally
 skipped checks honestly.
 
-Real models, paid APIs, shared infrastructure, production systems, and account
-quota remain user-owned authority. A generic request to implement or test does
-not authorize them. Prefer deterministic fakes and isolated resources, and
-report the remaining verification gap without blocking ordinary delivery.
+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
 
@@ -75,8 +81,10 @@ 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 Yui WorkItem/ExecutionGroup instead —
-native subagents never own a Yui Turn, receipt, or workspace.
+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;
+replicated Lanes are needed only for multiple independent attempts. Native
+subagents never own a Yui Turn, receipt, or workspace.
 
 ## Task Role Turn
 
@@ -96,5 +104,10 @@ 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.
 
+Use clear prose. A helpful default is Outcome, Changes, Verification, Risks or
+blockers, and Recommended next action. This is a communication convention, not
+a protocol: Yui preserves the original text and does not parse, normalize, or
+reject it for missing headings or invalid JSON.
+
 Leave managed workspaces intact after handoff. Their owner lifecycle and
 cleanup belong to the Leader and Yui Core.