@zq-silk/yui 0.6.7 → 0.6.9

package/dist/storage/taskStore.js

@@ -1,6 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { validateConfiguredAgent } from "../agent/agent.js";
 import { validateCapabilityGrant } from "../grant/capabilityGrant.js";
@@ -1735,11 +1735,56 @@ export class StorageCancelledError extends Error {
     constructor(message) { super(message); this.name = "StorageCancelledError"; }
 }
 export function resolveYuiHome(env) {
-    return env.YUI_HOME === undefined || env.YUI_HOME.length === 0
+    const requested = env.YUI_HOME === undefined || env.YUI_HOME.length === 0
         ? join(homedir(), ".yui")
         : resolve(env.YUI_HOME);
+    return canonicalizeYuiHome(requested);
 }
 export function ensureYuiHome(rootDir) { mkdirSync(rootDir, { recursive: true, mode: 0o700 }); }
+/**
+ * YUI_HOME is a runtime identity, not only a storage path. Resolve every
+ * existing symlink component before Controller/tmux namespaces or exact
+ * descriptors derive identity from it. A Home may not exist before `setup`,
+ * so retain proven-missing trailing components below the longest existing
+ * physical ancestor. Existing-but-unresolvable paths fail closed.
+ */
+function canonicalizeYuiHome(value) {
+    const absolute = resolve(value);
+    let current = absolute;
+    const trailing = [];
+    for (;;) {
+        try {
+            const physical = realpathSync(current);
+            return trailing.length === 0 ? physical : join(physical, ...trailing);
+        }
+        catch (realpathError) {
+            if (!isErrno(realpathError, "ENOENT")) {
+                throw unstableYuiHome(absolute, realpathError);
+            }
+            try {
+                lstatSync(current);
+            }
+            catch (lstatError) {
+                if (!isErrno(lstatError, "ENOENT")) {
+                    throw unstableYuiHome(absolute, lstatError);
+                }
+                const parent = dirname(current);
+                if (parent === current)
+                    return absolute;
+                trailing.unshift(basename(current));
+                current = parent;
+                continue;
+            }
+            throw unstableYuiHome(absolute, realpathError);
+        }
+    }
+}
+function unstableYuiHome(path, cause) {
+    return new Error(`YUI_HOME cannot be resolved to a stable physical path: ${path}.`, { cause });
+}
+function isErrno(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
 function emptyState() {
     return {
         schemaVersion: CURRENT_STORAGE_STATE_SCHEMA_VERSION,

package/dist/task/nextAction.js

@@ -244,7 +244,7 @@ export function projectNextAction(facts) {
                 },
                 {
                     kind: "native-subagent",
-                    reason: "Use one native implementer subagent when one bounded implementation pass benefits from parallel attention.",
+                    reason: "Use native implementer subagents when bounded work benefits from specialist attention or parallel fan-out inside the Leader Session.",
                     refs
                 }
             ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/skills/yui-leader/SKILL.md

@@ -38,21 +38,24 @@ Choose the executor in this order:
 
 1. **Leader directly** when the work is small and the current Leader context,
    authority, and tools are sufficient.
-2. **At most one native implementer subagent** when one bounded implementation
-   pass benefits from parallel attention or a specialist available inside the
-   current Agent. Give it one explicit Profile, one writable workspace, and one
-   result contract.
-3. **Task Role AgentRun** only when the work genuinely needs independent
-   parallel ownership, different credentials or authority, a provider/model
-   capability unavailable to the current Agent, or an independently managed
-   Session and durable Run lifecycle.
+2. **Native subagents** when bounded implementation or research benefits from
+   specialist attention or parallel fan-out inside the current Agent Session.
+   Give each child an explicit Profile, workspace access, and result contract.
+3. **Task Role AgentRun** when the work genuinely needs independent durable
+   ownership, different credentials or authority, a provider/model capability
+   unavailable to the current Agent, or an independently managed Session and
+   Run lifecycle.
 
 Do not dispatch a Task Role merely to obtain a fresh context, run a command,
 perform a routine small edit, or add an intermediate review. Direct and native
 execution add no Worker Role, Worker Yui Session, or Worker AgentRun. The exact
-Leader Run fence stays active until a native child hands back its result; the
+Leader Run fence stays active while native child work is outstanding; the
 WorkItem and its workspace remain the durable delivery boundary.
 
+Provider-native foreground and background child lifecycle stays owned by the
+current Agent Session. Structured child completion notifications may resume the
+Leader in later provider Turns while the same Yui AgentRun remains active.
+
 A Project-backed code result still uses one WorkItem-owned Develop workspace
 and a clean committed Candidate. The fast path compresses orchestration, not
 delivery evidence: Candidate, ChangeSet, committed Integration, acceptance,
@@ -84,11 +87,11 @@ WorkItem while its delivery scope remains open. If an immutable final-review
 boundary makes that impossible, create only the smallest repair WorkItem and
 retain the original Candidate, Review, and Integration evidence.
 
-Native and managed waits use different fences. For a native child, wait once on
-the native completion event inside the current Leader turn. Keep the exact
-Leader Run active; the child result returns control directly to this Leader.
-Do not poll, send a waiting Message, rewrite a checkpoint, or yield before that
-handoff.
+Native and managed waits use different fences. For native children, let the
+provider deliver structured completion notifications and continue the parent
+Agent. The exact Leader Run stays active across intermediate provider Turn
+boundaries while native children remain active. Do not poll, send a waiting
+Message, rewrite a checkpoint, or yield merely to preserve that native wait.
 
 For a managed Task Role or Reviewer Run, persist a necessary changed checkpoint,
 yield the active Leader Run, and stop the turn. Its durable mailbox result or an
@@ -344,12 +347,12 @@ hint only if this Agent's native child API supports that override; otherwise
 inherit the actual runtime setting. Never claim a model that cannot be
 confirmed.
 
-Create and communicate with the child through the native Agent tools. Yui does
-not create, address, resume, or terminate that child. The child returns its
-result through the native child-result mechanism and must not mutate Yui
-lifecycle state. Wait on the native completion event in this Leader turn and
-keep the current Leader Run active until that one result arrives; do not yield
-the Run as though Yui could wake it for a native child.
+Create and communicate with children through the native Agent tools. Yui does
+not create, address, resume, or terminate those children; it observes their
+structured lifecycle so the parent AgentRun can span the provider Turns needed
+to receive their results. Children must not mutate Yui lifecycle state. Let the
+provider's native completion mechanism return results to the Leader, then
+synthesize them before deciding the next Yui workflow outcome.
 
 Review the returned work and run proportionate checks. Record each round in the
 WorkItem summary; preserve earlier round facts when updating it:
@@ -617,9 +620,10 @@ evidence; truthfully surface the blocker through the supported provider failure
 boundary. Do not add a fallback protocol.
 
 Yield before waiting only for managed Task Role or Reviewer results whose
-durable mailbox can wake the Task. Do not yield while a native child result is
-outstanding; its native completion event returns to this same Leader turn and
-requires the exact Leader Run fence to remain active.
+durable mailbox can wake the Task. Do not yield merely because native child
+results are outstanding: the provider owns their completion notifications, and
+Yui keeps this AgentRun active across intermediate provider Turns. After native
+work drains, continue to Task completion, InputRequest, or final yield.
 
 Complete only after required WorkItems are accepted, Role work is terminal,
 latest isolated results are integrated or deliberately abandoned, and user

package/skills/yui-operator/SKILL.md

@@ -162,11 +162,13 @@ Do not pre-split WorkItems or decide their dependsOn, execution path,
 acceptance, or Integration; the Leader owns WorkItem creation, replacement,
 parallel dispatch, dependency and conflict resolution inside the one Task.
 
-The Leader chooses among direct execution, a native subagent, and a Task Role
-AgentRun. A native subagent is created inside the Leader conversation, inherits
-the Leader Agent, ignores Task Role Agent bindings, and has no Yui launch
-command. A Task Role is required when the user requests a different provider,
-credentials, interactive Session, or durable independent lifecycle.
+The Leader chooses among direct execution, native subagents, and a Task Role
+AgentRun. Native subagents are created inside the Leader Session, inherit the
+Leader Agent, ignore Task Role Agent bindings, and have no Yui launch command.
+Their structured lifecycle and completion notifications may span provider
+Turns inside the same Yui AgentRun. A Task Role is required when the user
+requests a different provider, credentials, interactive Session, or durable
+independent lifecycle.
 
 When the user requires a specific Leader or Worker provider, inspect Roles
 before routing: