@zq-silk/yui 2.20.0 → 2.22.0

package/skills/yui-operator/references/routing.md

@@ -0,0 +1,57 @@
+# Select the owning outcome
+
+Read when Task identity is missing or ambiguous, creating a new Task, or deciding
+whether a changed requirement belongs to an existing outcome. An exact known Task
+uses its current context directly, not a catalog search.
+
+When input names a Task (including an exact Task notice), start with its current
+Context and referenced originals; do not rediscover it through Project/Task
+catalogs. Otherwise use `yui task list --json` with Project/status/search
+filters to locate the bounded outcome, and `yui project list` only when Project
+identity is needed. Read `yui task context <candidate-task-id>` before routing.
+
+Task listing is bounded: follow `nextCursor` with the same filters only when
+more candidates are needed, never traverse all pages by default.
+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.
+
+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. Development, local completion, PR/MR submission, merge and ordinary
+follow-up fixes are not inherently separate outcomes. Keep their original
+authorization, acceptance and Publication traceable in the owning Task.
+
+Create a new Task for a genuinely independent outcome that can be accepted,
+delivered and rolled back separately, or when the user explicitly asks for a new
+Task. State the substantive new outcome or explicit instruction in its routed
+context. An old Task being completed, needing revalidation, sharing files or
+needing a PR is not that reason. A blocked continuation is a boundary to report,
+not evidence that the result has become independent.
+
+Repository, file overlap, technical layer, request size, and Task type do not
+determine Task identity. They also do not determine WorkItem count. Let
+isolated workspaces and Integration handle independent Git changes.
+
+Keep the Task title concise and put detailed intent, constraints, and evidence
+in its description or routed Message.
+
+Resolve all known Projects before repository-backed execution. A stable Project
+checkout is read-only reference state, not the Task base authority. Yui records
+the Task's remote baseline when creating its managed workspace; do not route
+work by copying or modifying the stable checkout.
+
+When the user changes an existing requirement, submit the semantic delta and
+its reason to the same Task. Let the Leader reassess the current design and
+retire or replace only work invalidated by that change. Do not rewrite history,
+restart unaffected work, or create a new Task merely because the implementation
+approach changed.
+
+Do not create WorkItems at routing time. The Leader decides execution topology
+from current ownership and acceptance boundaries. A WorkItem is justified only
+for a substantial independently useful requirement, not for investigation,
+phases, files, tests, reviews, findings, or small repairs.

package/skills/yui-operator/references/submission.md

@@ -0,0 +1,56 @@
+# Submit intent without starting unrequested work
+
+Read before creating/submitting a Task request or requesting Draft activation.
+A routing operation is not implementation or resumption by the Task Leader.
+
+Treat Task creation and Task submission as separate user-authorized actions.
+When the user asks only to add, create, register, or record a Task, create the
+Draft and write all known requirements into its metadata, then stop. Do not
+submit a `discuss` or `develop` Message, request activation, start a Leader
+Session, or create execution resources. A detailed or immediately actionable
+requirement, or the user's desire for its eventual completion, is not permission
+to start it. Report that the Task is a Draft and has not started, and explain
+that the user can explicitly ask to discuss/plan it or to develop/implement it.
+
+Start the corresponding route only when the user's current request contains
+that additional intent: discussion or planning authorizes `discuss`;
+development, implementation, fixing, continuing execution, or immediate
+progress authorizes `develop` or the applicable lifecycle continuation. Do not
+weaken explicit intent merely because the request also says “create a Task.”
+The examples below are separate operations, never an automatic
+create/submit/activate sequence.
+
+Discussion does not authorize delivery; follow the Leader's
+[planning and activation boundary](../../yui-leader/references/planning.md) before
+activation. Simple queries and record-only input need no reopening. An authorized
+same-result follow-up or explicitly identified unfulfilled commitment can require
+tracked diagnosis, evidence handoff, coordination or delivery after reopening;
+diagnosis remains read-only unless changes are requested. First read
+[same-Task delivery](task-delivery.md), not Draft activation.
+
+```sh
+yui operator submit "<related request and delta>" --task <task-id> --intent discuss
+yui task create "<independent outcome>" \
+  --project <project> --base <project>=<ref>
+yui operator submit "<request and routing context>" --task <new-task-id> --intent develop
+yui task activation request <new-task-id> --request-id <id> --environment <plan>
+```
+
+Inspect an existing request before creating another. `task activate <task-id>`
+can adopt an eligible request in the foreground; it never activates a Draft
+without a recorded request and environment plan.
+
+After the user has authorized a submission, choose its intent explicitly; it is
+never inferred by the CLI from the message text. `discuss` (the CLI default when
+`operator submit` is already being invoked) routes the Draft to planning;
+`record` saves the message without waking the Leader; `develop` asks an unplanned
+Draft to activate now, and reports the exact next step when it cannot (already
+planned → request activation explicitly; execution stopped → start it first).
+The CLI default is not permission for the Operator to invoke submission after a
+creation-only request. Pass `--request-id <key>` to make a submission idempotent:
+retrying the same key returns the original message and routing instead of
+creating a duplicate, and the same key with different text is refused as a
+conflict.
+
+For quote-sensitive text, nested JSON or long bodies, read
+[Safe body transport](body-transport.md) before constructing the submission.

package/skills/yui-operator/references/task-delivery.md

@@ -37,7 +37,7 @@ Separate lifecycle, execution gate and Session authority:
 - A completed, unarchived Task has separate local acceptance and remote delivery
   facts. An explicit user request to continue the same result authorizes the
   necessary `task reopen` before submitting that bounded request. Follow the
-  [authorized two-step path](../../yui-runtime/references/publication.md#post-completion-routing-boundary);
+  [authorized two-step path](../../yui-runtime/references/completed-followup.md);
   do not require a second mechanical “reopen” confirmation.
   The current matching Leader may perform that reopen itself and continue
   an already-received request; it need not send the work back to Operator.
@@ -50,7 +50,10 @@ Use the existing reopen and submission operations, not an invented auto-reopen
 option or a new delivery Task. Reopening and saving input have separate receipts;
 inspect current state after a failure and retain the original request identity.
 Only a real missing authority, resource or unresolved execution boundary calls
-for escalation. Do not reopen for a query, implicitly restore cancelled intent,
+for escalation. Simple queries and ordinary reads stay completed. Tracked
+same-result diagnosis, evidence handoff or necessary coordination can instead
+follow the shared post-completion boundary; diagnosis remains read-only.
+Do not implicitly restore cancelled intent,
 use archived workspaces, restart a separate execution stop, or claim rejected
 input was saved.
 

package/skills/yui-operator/references/web-lifecycle.md

@@ -0,0 +1,19 @@
+# Web lifecycle
+
+For user-requested Web lifecycle operations, use `yui web`, `yui web --status`
+and `yui web --stop` with the current Operator identity and intended Home.
+Operator starts return a Controller-owned receipt without holding this turn
+open. Non-loopback binding requires `--auth-file <absolute-path>` containing
+an owner-only (0600) regular file with a unique 32–128 character printable ASCII
+password; browser username is `yui`. There is no default password.
+Honor the user's exact network exposure and credential scope. Never clear
+managed identity, impersonate a browser user, launch a bypass server or restart
+the Controller merely to open Web. Report actual access URLs and failures,
+never a wildcard address or an old snapshot as a working link. Explain that
+HTTP is unencrypted, and keep credentials out of messages, logs and URLs.
+Lifecycle authority does not authenticate visitors. On unknown startup outcome,
+inspect status before retrying; a running listener is not proof of remote reachability.
+Stopping Web closes browser connections without stopping Agents. Password
+rotation requires explicit stop/start; changing the file alone does not revoke
+the running credential. Controller recovery does not automatically reopen Web.
+

package/skills/yui-operator/scripts/verify-submission.mjs

@@ -0,0 +1,37 @@
+// Local, read-only transport comparison. This does not establish source
+// semantics, authority, downstream completion or permission to acknowledge.
+import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+
+try {
+  const args = process.argv.slice(2);
+  const [receiptFile, payloadFile, taskId, intent, submissionKey] = args;
+  if (args.length !== 5 || args.some(arg => !arg)
+    || !["record", "discuss", "develop"].includes(intent)) {
+    throw new Error("Usage: node verify-submission.mjs <receipt.json> <payload> <task-id> <record|discuss|develop> <request-id>");
+  }
+  const receiptText = readFileSync(receiptFile, "utf8");
+  let receipt;
+  try {
+    receipt = JSON.parse(receiptText);
+  } catch {
+    throw new Error("Invalid JSON receipt; retain the original file for inspection.");
+  }
+  const message = receipt?.data?.message;
+  if (receipt?.ok !== true || receipt.data?.taskId !== taskId
+    || message?.taskId !== taskId || message?.intent !== intent
+    || message?.submissionKey !== submissionKey
+    || typeof message?.id !== "string" || !message.id) {
+    throw new Error("Saved submission identity or intent mismatch; retain evidence and inspect, do not resubmit.");
+  }
+  const payload = readFileSync(payloadFile);
+  const bodySha256 = createHash("sha256").update(payload).digest("hex");
+  if (message.bodyBytes !== payload.length || message.bodySha256 !== bodySha256) {
+    throw new Error("Saved body checksum missing or mismatched; retain evidence and inspect the exact saved Message, do not resubmit.");
+  }
+  console.log(JSON.stringify({ ok: true, taskId, messageId: message.id,
+    intent, submissionKey, bodyBytes: payload.length, bodySha256 }));
+} catch (error) {
+  console.error(JSON.stringify({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+  process.exitCode = 1;
+}

package/skills/yui-reviewer/SKILL.md

@@ -32,8 +32,10 @@ frozen Project commits, and assigned workspace. Inspect those exact commits.
 For a Run-backed Candidate, read its frozen `source-run` reference whose
 `evidenceOf` names that Candidate, including every content page of the original
 report. A summary or a newer Run is not a replacement. Missing historical
-evidence is a bounded infrastructure diagnosis, not permission to read outside
-the inventory or require the Leader to manually copy a report.
+evidence is a bounded infrastructure diagnosis, not permission to replace the
+frozen source with a newer report. Relevant ordinary reads follow Runtime's
+resource access rules, but cannot reconstruct missing frozen evidence or widen
+this Review. Do not require the Leader to manually copy an accessible report.
 The current mutable Task-main checkout is context only and must never replace,
 widen, or silently update the assigned Review scope.
 

package/skills/yui-reviewer/VERSION

@@ -1 +1 @@
-5
+6