@zq-silk/yui 0.6.8 → 0.6.9

package/dist/commands/taskCommands.js

@@ -1802,7 +1802,7 @@ function dispatchWork(args, store, options) {
         if (item.assignee === undefined) {
             throw usageError(`Work Item has no Task Role assignee: ${item.id}. `
                 + `The Task Leader must run "yui task work update ${item.id} running", `
-                + "then execute it directly or create a native subagent in the Leader conversation.");
+                + "then execute it directly or create native subagents in the Leader Session.");
         }
         if (expanding && taskActor(options, task.id) !== "leader") {
             throw usageError("Only the Task Leader may expand a running ExecutionGroup.");

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -26,7 +26,8 @@ import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
+import { projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
 /** Maps the authoritative FileTaskStore records to the scheduler's narrow port. */
 export class FileSchedulerStoreAdapter {
     store;
@@ -80,6 +81,13 @@ export class FileSchedulerStoreAdapter {
                 const classification = this.classifyRuntimeTurnCompleted(completed);
                 if (classification !== "apply")
                     return classification;
+                if (this.runtimeTurnHasActiveNativeSubagents(input)) {
+                    // This is an intermediate provider Turn boundary, not the end of the
+                    // durable Yui Run. The provider will deliver child completion
+                    // notifications as later native Turns in the same Run generation.
+                    outcome = this.validateCanonicalRunObservation(input, now);
+                    break;
+                }
                 const result = this.observeRuntimeTurnCompleted(completed, now);
                 outcome = result.disposition === "obsolete" ? "obsolete" : "applied";
                 break;
@@ -180,6 +188,14 @@ export class FileSchedulerStoreAdapter {
             return "applied";
         });
     }
+    runtimeTurnHasActiveNativeSubagents(input) {
+        const taskId = input.fence.taskId;
+        const run = this.store.getAgentRun(taskId, input.fence.runId);
+        if (run === null)
+            return false;
+        const projection = projectRuntimeTaskEvents(input.fence, run.createdAt, this.store.listEvents(taskId));
+        return Object.values(projection.operations).some(({ kind }) => kind === "subagent");
+    }
     validateCanonicalSessionObservation(input, now) {
         return this.store.transaction((store) => {
             const run = store.getAgentRun(input.fence.taskId, input.fence.runId);
@@ -1249,7 +1265,8 @@ export class FileSchedulerStoreAdapter {
         });
     }
     /**
-     * Fast hook path: durably records the native Turn boundary and a two-second
+     * Fast hook path: validates the native Turn boundary before it is either
+     * retained as an intermediate child wait or given a two-second workflow
      * closure deadline. It never performs tmux, workspace, or Controller I/O.
      */
     classifyRuntimeTurnCompleted(input) {
@@ -2808,8 +2825,13 @@ function runtimeObservationTelemetryEntry(input) {
 function compactedRuntimeObservationIds(events, incoming) {
     const existing = events.flatMap((event) => {
         const observation = runtimeObservationFromTaskEvent(event);
+        const matches = incoming.kind.startsWith("operation.")
+            ? observation !== null
+                && runtimeObservationRunFenceMatches(observation.fence, incoming.fence)
+            : observation !== null
+                && runtimeObservationFenceMatches(observation.fence, incoming.fence);
         return observation !== null
-            && runtimeObservationFenceMatches(observation.fence, incoming.fence)
+            && matches
             ? [{ event, observation }]
             : [];
     });
@@ -2838,7 +2860,8 @@ function compactedRuntimeObservationIds(events, incoming) {
                 && observation.payload.sourceId === incoming.payload.sourceId;
         }
         if (["turn.completed", "turn.failed", "turn.cancelled"].includes(incoming.kind)) {
-            return observation.kind.startsWith("operation.")
+            return (observation.kind.startsWith("operation.")
+                && observation.payload.operation !== "subagent")
                 || observation.kind === "turn.waiting"
                 || observation.kind === "turn.completed"
                 || observation.kind === "turn.failed"

package/dist/runtime/runtimeObservation.js

@@ -118,6 +118,28 @@ export function runtimeObservationFenceMatches(expected, actual) {
     }
     return true;
 }
+/**
+ * Matches observations that belong to one durable Run/session generation.
+ * A provider may advance its native Turn while background subagents from an
+ * earlier Turn are still active, so nativeTurnId is intentionally excluded.
+ */
+export function runtimeObservationRunFenceMatches(expected, actual) {
+    for (const field of [
+        "taskId",
+        "roleName",
+        "runId",
+        "agentId",
+        "driverId",
+        "launchId",
+        "sessionGenerationId",
+        "nativeSessionId",
+        "receiptId"
+    ]) {
+        if (expected[field] !== actual[field])
+            return false;
+    }
+    return true;
+}
 /** Compact TaskEvent payload used for durable state-boundary observations. */
 export function runtimeObservationTaskEventPayload(input) {
     const observation = createRuntimeObservation(input);

package/dist/runtime/runtimeProjection.js

@@ -1,4 +1,4 @@
-import { createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
+import { createRuntimeObservation, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches } from "./runtimeObservation.js";
 export function createRuntimeProjection(fence, createdAt) {
     const timestamp = requireTimestamp(createdAt);
     return Object.freeze({
@@ -20,7 +20,7 @@ export function createRuntimeProjection(fence, createdAt) {
 export function projectRuntimeTaskEvents(fence, createdAt, events) {
     const observations = events
         .map(runtimeObservationFromTaskEvent)
-        .filter((event) => (event !== null && runtimeObservationFenceMatches(fence, event.fence)))
+        .filter((event) => (event !== null && runtimeObservationRunFenceMatches(fence, event.fence)))
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
@@ -29,7 +29,7 @@ export function projectRuntimeTaskEvents(fence, createdAt, events) {
 }
 export function projectRuntimeObservation(current, raw) {
     const event = createRuntimeObservation(raw);
-    if (!runtimeObservationFenceMatches(current.fence, event.fence)) {
+    if (!runtimeObservationRunFenceMatches(current.fence, event.fence)) {
         throw new Error("Runtime observation fence does not match the projection.");
     }
     const at = event.receivedAt;
@@ -79,7 +79,10 @@ export function projectRuntimeObservation(current, raw) {
                 turn: "completed",
                 waitingReason: undefined,
                 waitId: undefined,
-                operations: Object.freeze({}),
+                // Tool operations belong to the completed native Turn. Provider-owned
+                // background subagents may legitimately outlive it and wake later
+                // native Turns inside the same durable Yui Run.
+                operations: activeSubagentOperations(current.operations),
                 stateSince: at
             }), "provider", at);
         case "turn.failed":
@@ -261,6 +264,9 @@ function dominantOperation(operations) {
         return "model";
     return null;
 }
+function activeSubagentOperations(operations) {
+    return Object.freeze(Object.fromEntries(Object.entries(operations).filter(([, operation]) => operation.kind === "subagent")));
+}
 function terminalTurn(current, fallback = "cancelled") {
     return current === "completed" || current === "failed" || current === "cancelled"
         ? current

package/dist/scheduler/leaderWakeupProcessor.js

@@ -410,7 +410,8 @@ function leaderWakeupInput(taskId, runId, reasons, projectBindings) {
             : `Project Policy references: ${projectBindings.map((binding) => `${binding.directory} (${binding.projectId})`).join(", ")}. Read each with yui project show <project>, then yui project knowledge list <project> and yui project knowledge show <project> <knowledge>.`,
         "Use narrower Task message, WorkItem, decision, milestone, and input commands only when a specific record needs closer inspection.",
         `When the requested outcome is finished and there are no active Worker Runs or unresolved inputs, complete the Task with yui task complete ${taskId} --summary-file - and a quoted heredoc containing the final outcome and evidence.`,
-        `Before ending this turn, if the Task was not completed and no InputRequest terminalized this Run, release the active fence with yui task run yield ${runId} --summary-file - and a quoted heredoc containing the current result or waiting state. In particular, yield before waiting for Worker results; do not end the native turn while this Run remains active. The yield command must be the final tool action: after it succeeds, stop immediately and do not inspect, poll, accept, or perform further work in the same native turn.`
+        "Provider-native subagents remain inside this Leader AgentRun. Yui observes their structured lifecycle and keeps the Run active across intermediate provider Turn boundaries while children remain active; let the provider deliver completion notifications and continue synthesis without polling or yielding merely for that native wait.",
+        `Before ending this turn, if the Task was not completed, no InputRequest terminalized this Run, and no provider-native child work remains active, release the active fence with yui task run yield ${runId} --summary-file - and a quoted heredoc containing the current result or waiting state. For managed Task Role or Reviewer results, checkpoint and yield before waiting so their durable mailbox can wake a later Leader Run. The yield command must be the final tool action: after it succeeds, stop immediately and do not inspect, poll, accept, or perform further work in the same native turn.`
     ];
     return lines.join("\n");
 }

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.8",
+  "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: