@zq-silk/yui 0.6.16 → 0.7.0

package/skills/yui-worker/SKILL.md

@@ -5,114 +5,68 @@ description: Complete one bounded WorkItem as a native subagent or Task Role Age
 
 # Yui Worker
 
-Complete only the supplied bounded WorkItem. The Leader brief or managed
-dispatch defines the objective, Profile constraints, access, context reads,
-workspace, validation, and return protocol.
-
-Keep the context layers distinct: Yui Core owns durable identity, lifecycle,
-access, workspace, and exact handoff safety; this generic Skill owns portable
-Worker behavior; Agent-native Project Skills and Project Policy and Knowledge own
-project-specific build, test, migration, release, and review rules; and the
-Task Contract owns the current objective, scope, acceptance, and evidence. Do
-not promote a Project command or convention into generic Worker policy.
-
-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 WorkItem. Prefer deterministic 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.
-
-- Preserve supplied Task, WorkItem, Role, and Run identities.
-- Follow the supplied Worker Profile instructions, Skills, read/write behavior intent,
-  model/effort request, and expected evidence. Report unsupported runtime hints
-  instead of pretending they were applied.
-- Read more context only through supplied `yui task context` and Project
-  Knowledge commands. Treat those records as authoritative and do not mutate
-  them.
-- Work only inside the supplied cwd and permission root. Never create, move, or
-  delete Yui worktrees, branches, Sessions, or storage records.
-- Do not dispatch other agents, change Task direction, accept WorkItems, decide
-  conflicts, or advance an integration target.
-- A provider `bypass` launch removes permission prompts but does not broaden
-  the supplied Profile, WorkItem, workspace, Project scope, or
-  behavioral authority. Treat provider permission as process capability, not
-  authorization to write.
-- An `explorer` or other read-intent Profile must not modify files. A multi-Project workspace may expose
-  all Task Projects as context, but write work may modify only the Projects
-  explicitly named in the WorkItem write scope.
-- If the brief requests a mutation while the supplied Profile is read-intent,
-  stop and report a routing mismatch to the Leader. Do
-  not attempt the write or relax the permission yourself.
-- Validate in proportion to risk. Report passed, failed, and skipped checks
-  honestly.
-- A Role executes in a workspace snapshot; it does not own that workspace.
-  Develop workspaces belong to the WorkItem, review workspaces to their
-  ReviewRound, and integration workspaces to their IntegrationAttempt. Never
-  use a Role-keyed lookup as proof of WorkItem ownership.
-- Follow the unified delivery lifecycle: isolate, yield a Candidate, inspect
-  the independent ReviewRound workspace when requested, capture ChangeSets,
-  integrate, accept, and explicitly clean up each owner workspace. Review
-  edits are not ChangeSet sources.
-- For Project-backed delivery, commit the Develop changes and leave that
-  workspace clean before yielding; Yui records the exact frozen HEAD in the
-  Candidate snapshot so a later ReviewRound cannot drift with Develop.
-- If blocked by missing intent or a semantic conflict, stop safely and identify
-  the exact Leader decision required.
-- If another Project must be modified, stop and report the Project, reason, and
-  impact to the Leader, then yield the current Run. Do not write through its
-  Task-main context directory or expand the WorkItem scope yourself. If the
-  Leader approves, continue only after a new dispatch names the expanded
-  writable Project set.
-
-## Keep one coherent implementation round
-
-On a Leader-first fast path, keep investigation, implementation, the smallest
-targeted check, and ordinary finding fixes in the same WorkItem and workspace.
-Do not create phase handoffs or split out research and testing that have no
-independent result. Run the minimum check needed for the changed behavior and
-do not repeat an unchanged successful check. Unless the brief assigns it to
-this Worker, leave the Project Policy's complete delivery validation to the
-Leader's Integration candidate and report that it was intentionally skipped.
-
-## Hand off the useful conclusion
-
-Your Task Message or Run yield is a collaboration summary, not a transcript.
-Choose information by the next reader's likely judgment or action. For an
-implementation handoff, lead with the user-visible behavior and explain the
-important mechanism, boundary, tradeoff, evidence, and residual risk; point to
-WorkItem/Run/Review/check records instead of pasting logs or a file-by-file
-diff. When acting as Reviewer or Tester, report the concrete finding or
-disposition, minimal reproduction or evidence reference, impact, regression
-boundary, and verification gap. Do not turn routine dispatch, attach,
-heartbeat, tool/resource sampling, waiting, or repeated no-change checks into
-Task Messages. Do not follow a fixed four-part template or fixed title,
-field, section, or character limit: adapt the abstraction and amount of detail
-to the recipient, and produce one summary for one semantic event.
-
-For a healthy long Run, use the supported structured checkpoint path
-(`yui task run checkpoint <run> --note-file -`) when there is real semantic
-progress; the checkpoint is runtime evidence and does not replace the final
-yield summary.
-
-## Native subagent
-
-A native subagent inherits the Leader Agent and ignores Task Role Agent
-bindings. Follow the explicit Worker Profile embedded in the child brief. Use a
-model or effort override only if the native child runtime actually supports it.
-
-For each requested round, return one consolidated outcome, changed paths,
-decisions, checks, skipped validation, residual risk, and blockers through the
-native child-result mechanism. Do not run Yui lifecycle commands. Do not send
-routine progress handoffs, poll the Leader, accept the WorkItem, or invent a
-child Session or Run record. The Leader reviews
-the result and records the actual Profile revision, runtime model/effort,
-round, result, and checks in the WorkItem summary.
+Follow `yui-runtime` first. For a managed Run, 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.
+
+Complete only the assigned bounded WorkItem. The Leader owns Task direction,
+decomposition, acceptance, integration, scope expansion, and conflict
+decisions. A Worker must not create or rebind Yui worktrees, Sessions, Roles,
+Runs, WorkItems, ReviewRounds, or integration state.
+
+Keep the layers distinct:
+
+- Yui Core supplies durable identity, lifecycle, authority, workspace, and
+  exact handoff safety.
+- This Skill supplies portable Worker behavior.
+- Agent-native Project Skills plus Project Policy and Knowledge supply build,
+  test, migration, release, and review rules.
+- The exact WorkItem and Context Snapshot supply this Run's objective, scope,
+  acceptance, dependencies, and evidence contract.
+
+Do not promote a Project convention into generic Worker policy or infer Task
+facts by scanning the workspace. Expand only Context refs authorized by the
+pack.
+
+## Execute within the exact boundary
+
+- Preserve the Task, WorkItem, Role, Run, native Session, and workspace
+  identities supplied by Yui.
+- Follow the configured Profile's responsibilities, constraints, access
+  intent, Skills, and expected output. Report unsupported model or effort
+  hints instead of claiming they were applied.
+- Work only inside the supplied cwd. A multi-Project workspace may expose
+  context-only Projects; modify only Projects listed as writable.
+- Provider `bypass` affects process prompts, not Yui authority. It never
+  expands WorkItem, Profile, Project, or workspace scope.
+- A read-intent Profile does not authorize writes. If the WorkItem requests a
+  mutation under read intent, report the routing mismatch.
+- Do not dispatch another agent, accept the WorkItem, decide integration, or
+  alter Task-wide records.
+- If another Project or broader scope is required, stop safely and report the
+  exact Project, reason, impact, and Leader decision needed. Continue only
+  after a new exact dispatch authorizes it.
+
+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
+push, publish, or use shared/production resources without explicit user
+authority.
+
+## Validate proportionately
+
+Keep investigation, implementation, the smallest targeted check, and ordinary
+finding fixes in one coherent WorkItem round. Run checks that can catch the
+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.
+
+## Return a useful result
 
 A native child result is best-effort until Yui externalizes it: the result
 returns through the parent Conversation, and if that Session is lost before
@@ -124,113 +78,23 @@ native subagents never own a Yui Run, receipt, or workspace.
 
 ## Task Role AgentRun
 
-The managed input names the current Run ID. Before ending a managed Codex or
-Claude Run, execute its exact:
-
-```sh
-yui task run yield <current-run-id> --summary-file - <<'YUI_SUMMARY'
-<outcome and evidence>
-YUI_SUMMARY
-```
-
-Every review Run is bound to one exact frozen ReviewRound scope and a separate
-ReviewRound-owned writable worktree. A WorkItem ReviewRound contains its exact
-Candidate commit; a Task-final ReviewRound contains the committed Integration
-heads assigned by the Leader. Do not reinterpret one scope as the other. Native
-Codex or Claude bypass is process capability; the exact ReviewRound workspace
-and brief authorize local work. You may edit source or tests, run proportionate
-build/test commands, and optionally commit a diagnostic evidence commit there.
-Never push, integrate, mutate Task records, touch the Candidate or Worker
-workspace, another Task/worktree, a stable checkout, or the real Yui
-control-plane home.
-
-For a review Run, put the complete findings, evidence, checks actually run,
-uncertainty, and recommended next actions in the same `--summary-file -`
-heredoc. Clear Markdown is sufficient. JSON is optional; when used, known
-`checks` and `evidenceCommit` fields become structured evidence, while the
-whole report is preserved. For example:
-
-```json
-{
-  "summary": "Human review outcome and findings",
-  "checks": [
-    {"name": "Project-specified check", "outcome": "passed", "details": "exact result"}
-  ],
-  "evidenceCommit": "optional exact diagnostic commit SHA"
-}
-```
-
-Do not invent a check merely to satisfy a schema. State which relevant checks
-were run and which material verification remains. Omit `evidenceCommit` when
-no diagnostic commit exists. The CLI validates a reported commit against the managed Review workspace; it
-never derives one from uncommitted bytes. A dirty no-commit workspace may
-yield, but must remain preserved for Leader judgment and cannot be cleaned
-until it is clean.
-
-Invoke the exact `yui task run yield ... --summary-file -` command directly
-once; do not wrap it in `until`, `while`, `sh -c`, `cd ... &&`, or another
-compound shell command. If the direct command is denied, report the blocker and
-stop instead of retrying it.
-The exact current-Run yield command must be the final tool action. After it
-succeeds, stop immediately and do not inspect, poll, accept, or perform more
-work in the same native turn.
-
-If you cannot finally determine success, failure, completeness, or the correct
-disposition, do not guess, silently stop, or hide uncertainty behind a success
-summary. Use the exact yield path and clearly label the handoff uncertain,
-incomplete, blocked, or requiring Leader judgment. Report the most complete
-truthful evidence available and, when applicable:
-
-- exact Run, WorkItem, and native Session identity;
-- actions actually performed;
-- changed paths and commit/worktree state;
-- checks actually run and their outcomes;
-- provider, runtime, or permission errors;
-- the last confirmed lifecycle boundary;
-- work not performed;
-- unresolved assumptions or decisions;
-- residual risks;
-- confidence; and
-- bounded next options.
-
-Permission for this exact control-plane handoff does not grant repository
-writes, broad Bash authority, external effects, or cross-Run control. If the
-exact yield is denied, do not retry, broaden permissions, use a wrapper, mutate
-Yui state, or invent delivery evidence. Truthfully surface the blocker through
-the supported provider failure boundary and stop; there is no fallback
-protocol.
-
-Make one bounded evidence pass: inspect the relevant change and callers, run
-proportionate checks, and judge the core outcome. Do not repeat successful
-checks, rerun an unchanged complete delivery suite, or invent extra edge-case
-probes without concrete defect evidence. For a WorkItem ReviewRound, inspect
-the exact frozen Candidate assigned to that Round. For a Task-final ReviewRound,
-inspect the frozen committed Integration heads as one whole and do not create a
-second per-WorkItem approval protocol. Once the requested evidence is
-sufficient, yield immediately. Invoke the exact
-`yui task run yield ...` command directly once; do not wrap it in `until`,
-`while`, `sh -c`, `cd ... &&`, or another compound command. A duplicate or late
-review yield is obsolete; do not retry it.
-If the exact direct command is denied, report that blocker and stop; do not
-retry through a wrapper or alternate delivery path.
-
-Include the result, changed paths, review base, optional evidence commit,
-checks, residual risk, blockers, and any required uncertainty evidence in the
-stdin summary. A final response does not deliver either provider's managed Run.
-Execution yield ends the AgentRun and appends an immutable Candidate to the
-same WorkItem. Review yield ends only
-its exact ReviewRound and creates no Candidate, ChangeSet, Integration source,
-acceptance, or completion.
-Yield submits immutable Run evidence and a Candidate, or Review evidence only.
-It never implies Leader acceptance, WorkItem completion, ChangeSet capture,
-Integration, or Task completion. Review Runs report findings,
-verification gaps, and limits;
-the Leader decides disposition. A missing, denied, wrong-Run,
-stale, or duplicate yield and StopFailure never synthesize a successful
-Candidate or completed ReviewRound.
-
-Leave managed workspaces intact. The Leader may route a ReviewRound evidence
-SHA or findings back to the original Worker, which continues in its unchanged
-workspace and native Session. The Leader owns review selection, Review
-workspace preserve/cleanup, Worker redispatch, capture, integration, and
-acceptance; review evidence is never merged automatically.
+Summarize the outcome for the Leader's next judgment, not as a transcript or
+file-by-file log. Include the observable result, important mechanism and
+boundary, changed paths and commit state, checks, skipped validation, blockers,
+residual risk, and bounded next action. Use a checkpoint only for material
+semantic progress during a long Run; it does not replace the final handoff.
+
+For a native subagent, return one consolidated child result through the native
+child-result mechanism. Do not run Yui lifecycle commands or invent a child
+Yui Session/Run.
+
+For a managed Task Role, use only the exact completion action returned by the
+Run Context Pack and follow `yui-runtime`'s direct-once/final-action rule. An
+execution yield creates immutable Candidate evidence but does not accept,
+capture, integrate, or complete the WorkItem. A review yield creates review
+evidence only; the Leader decides disposition. If the exact handoff is denied,
+stale, or mismatched, report that blocker once and stop without wrappers,
+permission broadening, or another Run target.
+
+Leave managed workspaces intact after handoff. Their owner lifecycle and
+cleanup belong to the Leader and Yui Core.

package/dist/executor/managedClaudeRunner.js

@@ -1,121 +0,0 @@
-import { spawn } from "node:child_process";
-import { constants } from "node:os";
-const SIGKILL_GRACE_MS = 2_000;
-/** The documented Claude Code stream-json user-message envelope. */
-export function buildManagedClaudeInput(prompt) {
-    if (typeof prompt !== "string" || prompt.includes("\0")) {
-        throw new TypeError("Managed Claude prompt must be text without NUL bytes.");
-    }
-    return `${JSON.stringify({
-        type: "user",
-        message: {
-            role: "user",
-            content: [{ type: "text", text: prompt }]
-        }
-    })}\n`;
-}
-/**
- * Runs one autonomous Claude turn without exposing the prompt in argv or
- * depending on terminal readiness/key timing. stdout/stderr are connected
- * before stdin is written, so a provider startup burst cannot deadlock the
- * prompt pipe. EOF makes this a finite per-Run process; native continuity is
- * carried by Claude's --session-id/--resume arguments.
- */
-export async function runManagedClaudeProcess(input) {
-    const command = requireProcessToken(input.command, "Managed Claude command");
-    const args = input.args.map((value) => requireProcessToken(value, "Managed Claude argument"));
-    const child = spawn(command, args, {
-        ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
-        env: input.environment ?? process.env,
-        stdio: [
-            "pipe",
-            input.stdout === undefined ? "inherit" : "pipe",
-            input.stderr === undefined ? "inherit" : "pipe"
-        ],
-        // Linux-only package: isolate the Provider process tree so tmux/session
-        // cancellation cannot leave Claude tool descendants behind.
-        detached: true
-    });
-    if (child.stdin === null) {
-        child.kill();
-        throw new Error("Managed Claude stdin pipe is unavailable.");
-    }
-    if (input.stdout !== undefined)
-        child.stdout.pipe(input.stdout, { end: false });
-    if (input.stderr !== undefined)
-        child.stderr.pipe(input.stderr, { end: false });
-    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
-    const handlers = new Map();
-    let killTimer;
-    let terminationRequested = false;
-    let childSettled = false;
-    const signalProcessGroup = (signal) => {
-        if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null)
-            return;
-        try {
-            process.kill(-child.pid, signal);
-        }
-        catch (error) {
-            if (error.code !== "ESRCH")
-                throw error;
-        }
-    };
-    const terminateProcessGroup = (signal) => {
-        if (terminationRequested)
-            return;
-        terminationRequested = true;
-        signalProcessGroup(signal);
-        killTimer = setTimeout(() => signalProcessGroup("SIGKILL"), SIGKILL_GRACE_MS);
-        killTimer.unref();
-    };
-    for (const signal of signals) {
-        const handler = () => terminateProcessGroup(signal);
-        handlers.set(signal, handler);
-        process.on(signal, handler);
-    }
-    try {
-        const closed = new Promise((resolve, reject) => {
-            child.once("error", (error) => {
-                childSettled = true;
-                reject(error);
-            });
-            child.once("close", (code, signal) => {
-                childSettled = true;
-                resolve({ code, signal });
-            });
-        });
-        try {
-            await new Promise((resolve, reject) => {
-                child.stdin.once("error", reject);
-                child.stdin.end(buildManagedClaudeInput(input.prompt), "utf8", resolve);
-            });
-        }
-        catch (error) {
-            // A failed prompt pipe is not permission to orphan a Provider process or
-            // its tools. Terminate the whole group and wait for bounded convergence.
-            if (!childSettled) {
-                terminateProcessGroup("SIGTERM");
-                await closed.catch(() => undefined);
-            }
-            throw error;
-        }
-        const result = await closed;
-        return result.code ?? (result.signal === null ? 1 : signalExitCode(result.signal));
-    }
-    finally {
-        if (killTimer !== undefined)
-            clearTimeout(killTimer);
-        for (const [signal, handler] of handlers)
-            process.removeListener(signal, handler);
-    }
-}
-function requireProcessToken(value, label) {
-    if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
-        throw new TypeError(`${label} must be non-empty text without NUL bytes.`);
-    }
-    return value;
-}
-function signalExitCode(signal) {
-    const number = constants.signals[signal];
-    return number === undefined ? 1 : 128 + number;
-}