@zq-silk/yui 0.6.2 → 0.6.4

package/dist/runtime/sessionTerminationGuard.js

@@ -20,6 +20,14 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
     const pollMs = positiveDuration(options.pollMs, DEFAULT_TERMINATION_POLL_MS, "pollMs");
     const now = ports.now();
     ports.emit({ stage: "stop-requested", owner, at: now });
+    // A launch-fence scan is a point-in-time observation, not a durable owner
+    // inventory: /proc entries can disappear between the directory and
+    // environment reads. Retain every exact child identity observed during the
+    // stop so one later scan miss cannot be mistaken for physical zero.
+    const trackedChildren = new Map(records.map((record) => [record.launchId, new Map()]));
+    for (const record of records) {
+        refreshTrackedFencedChildren(record, ports, trackedChildren);
+    }
     let gracefulOk = true;
     try {
         gracefulOk = await ports.gracefulStop(owner);
@@ -50,7 +58,7 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
         };
     }
     // Bounded graceful grace: poll the exact owned trees for exit.
-    if (await waitForTreesAbsent(records, ports, gracefulGraceMs, pollMs)) {
+    if (await waitForTreesAbsent(records, ports, trackedChildren, gracefulGraceMs, pollMs)) {
         ports.emit({ stage: "stop-confirmed", owner, at: ports.now() });
         return {
             outcome: "stop-confirmed",
@@ -64,24 +72,24 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
     // safety requires pairing the PID with its start identity.
     ports.emit({ stage: "forced-stop", owner, at: ports.now() });
     for (const record of records) {
-        escalateRecord(record, ports, "SIGTERM");
+        escalateRecord(record, ports, trackedChildren, "SIGTERM");
     }
-    await waitForTreesAbsent(records, ports, forcedGraceMs, pollMs);
+    await waitForTreesAbsent(records, ports, trackedChildren, forcedGraceMs, pollMs);
     for (const record of records) {
-        escalateRecord(record, ports, "SIGKILL");
+        escalateRecord(record, ports, trackedChildren, "SIGKILL");
     }
-    await waitForTreesAbsent(records, ports, forcedGraceMs, pollMs);
+    await waitForTreesAbsent(records, ports, trackedChildren, forcedGraceMs, pollMs);
     const remaining = [];
     const confirmed = [];
     let verificationGap;
     for (const record of records) {
-        const verdict = treeVerdict(record, ports);
+        const verdict = treeVerdict(record, ports, trackedChildren);
         if (verdict.kind === "absent") {
             confirmed.push(record);
             continue;
         }
         if (verdict.kind === "gap") {
-            verificationGap = `/proc unreadable for pid ${record.providerRoot.pid}`;
+            verificationGap = `/proc unreadable for launch ${record.launchId}`;
             remaining.push({ record, detail: verificationGap });
             continue;
         }
@@ -137,19 +145,59 @@ function rootVerdict(record, ports) {
  * `/proc` is unreadable, because that would claim physical zero without
  * proof. The final verdict turns a persistent gap into `stop-blocked`.
  */
-function treeVerdict(record, ports) {
+function treeVerdict(record, ports, trackedChildren) {
+    const scanGap = refreshTrackedFencedChildren(record, ports, trackedChildren);
     const root = rootVerdict(record, ports);
-    if (root.kind === "live")
+    const children = trackedChildrenVerdict(record, ports, trackedChildren);
+    if (root.kind === "live" || children.kind === "live")
         return { kind: "live" };
-    // The root is gone or unreadable: a surviving child carrying the exact
-    // launch fence keeps the tree live. Children without the fence are
-    // unattributed and never block confirmation on their own.
-    const fencedChildren = ports
-        .listLaunchFencedProcesses(record.launchId)
-        .filter((pid) => pid !== record.providerRoot.pid);
-    if (fencedChildren.length > 0)
+    if (root.kind === "gap" || children.kind === "gap" || scanGap)
+        return { kind: "gap" };
+    return { kind: "absent" };
+}
+function refreshTrackedFencedChildren(record, ports, trackedChildren) {
+    const tracked = trackedChildren.get(record.launchId);
+    if (tracked === undefined)
+        return true;
+    let verificationGap = false;
+    for (const pid of ports.listLaunchFencedProcesses(record.launchId)) {
+        if (pid === record.providerRoot.pid)
+            continue;
+        const identity = ports.processIdentity(pid);
+        if (identity === undefined) {
+            if (ports.procEntryExists(pid))
+                verificationGap = true;
+            continue;
+        }
+        if (identity.state === "Z")
+            continue;
+        tracked.set(pid, identity.startIdentity);
+    }
+    return verificationGap;
+}
+function trackedChildrenVerdict(record, ports, trackedChildren) {
+    const tracked = trackedChildren.get(record.launchId);
+    if (tracked === undefined)
+        return { kind: "gap" };
+    let verificationGap = false;
+    for (const [pid, startIdentity] of tracked) {
+        const current = ports.processIdentity(pid);
+        if (current === undefined) {
+            if (ports.procEntryExists(pid)) {
+                verificationGap = true;
+            }
+            else {
+                tracked.delete(pid);
+            }
+            continue;
+        }
+        if (current.state === "Z" || current.startIdentity !== startIdentity) {
+            tracked.delete(pid);
+            continue;
+        }
         return { kind: "live" };
-    return root;
+    }
+    return verificationGap ? { kind: "gap" } : { kind: "absent" };
 }
 /**
  * Signals the exact root (only when its identity is verified) and, while the
@@ -157,7 +205,7 @@ function treeVerdict(record, ports) {
  * fenced child survives, each fenced child is signaled individually: the
  * group can no longer be proven ours once its leader is gone.
  */
-function escalateRecord(record, ports, signal) {
+function escalateRecord(record, ports, trackedChildren, signal) {
     const root = rootVerdict(record, ports);
     if (root.kind === "live") {
         try {
@@ -180,9 +228,17 @@ function escalateRecord(record, ports, signal) {
     }
     if (root.kind !== "absent")
         return;
-    for (const pid of ports.listLaunchFencedProcesses(record.launchId)) {
-        if (pid === record.providerRoot.pid)
+    refreshTrackedFencedChildren(record, ports, trackedChildren);
+    const tracked = trackedChildren.get(record.launchId);
+    if (tracked === undefined)
+        return;
+    for (const [pid, startIdentity] of tracked) {
+        const current = ports.processIdentity(pid);
+        if (current === undefined
+            || current.state === "Z"
+            || current.startIdentity !== startIdentity) {
             continue;
+        }
         try {
             ports.signalProcess(pid, signal);
         }
@@ -191,10 +247,10 @@ function escalateRecord(record, ports, signal) {
         }
     }
 }
-async function waitForTreesAbsent(records, ports, timeoutMs, pollMs) {
+async function waitForTreesAbsent(records, ports, trackedChildren, timeoutMs, pollMs) {
     const start = Date.now();
     for (;;) {
-        if (records.every((record) => treeVerdict(record, ports).kind === "absent")) {
+        if (records.every((record) => treeVerdict(record, ports, trackedChildren).kind === "absent")) {
             return true;
         }
         if (Date.now() - start >= timeoutMs)

package/dist/runtime/tmuxAdapters.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { createRuntimeBinding } from "./runtimeBinding.js";
 import { normalizeRuntimeOwner } from "./runtimeOwner.js";
+import { RuntimeHostContentionError } from "./ports.js";
 import { requireSafeIdentity } from "./validation.js";
 /**
  * Runtime lifecycle adapter for the current tmux host. The returned hostRef is
@@ -145,6 +146,40 @@ export class TmuxSessionHost {
     async #launchUnlocked(request, hostId, beforeHostStart) {
         // Validate generated identity before starting an external process.
         const bindingId = requireSafeIdentity(this.#createBindingId(), "Runtime binding id");
+        const writableHumanAttached = request.owner.scope === "task"
+            && request.runId !== undefined
+            && (this.tmux.hasWritableClientAsync !== undefined
+                ? await this.tmux.hasWritableClientAsync(hostId, request.owner.roleName)
+                : this.tmux.hasWritableClient?.(hostId, request.owner.roleName) === true);
+        if (writableHumanAttached) {
+            throw new RuntimeHostContentionError("writable-client", `A writable human is attached to ${request.owner.taskId}/${request.owner.roleName}.`);
+        }
+        if (request.owner.scope === "task"
+            && request.adapterId === "claude"
+            && request.runId !== undefined
+            && await probeRoleStatus(this.tmux, hostId, request.owner.roleName) === "running") {
+            // Managed Claude is process-per-Run. A live Role window here belongs to
+            // an earlier process (or to recovery of the exact reserved Run); never
+            // plan, persist pre-start state, or inject input into it. The coordinator
+            // decides between same-generation recovery and a retry after natural
+            // exit from the durable reservation identity.
+            return createRuntimeBinding({
+                id: bindingId,
+                launchId: request.launchId,
+                owner: request.owner,
+                agentId: request.agentId,
+                adapterId: request.adapterId,
+                hostRef: encodeHostRef({
+                    scope: request.owner.scope,
+                    hostId,
+                    roleName: request.owner.roleName
+                }),
+                hostCreated: false,
+                ...(request.mode === "resume"
+                    ? { nativeSessionId: request.nativeSessionId }
+                    : {})
+            });
+        }
         const input = {
             roleName: request.owner.roleName,
             agentId: request.agentId,

package/dist/scheduler/activeRoleRunDelivery.js

@@ -3,8 +3,7 @@ import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
-import { isPreInputReadinessSupported } from "../lifecycle/canonicalLifecycleEvent.js";
-import { preInputReadinessCapability } from "../lifecycle/providerLifecycleMapping.js";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -95,8 +94,9 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                         preStartFencePersisted = true;
                     }
                 });
-                // A fresh Codex host may already carry the exact Run prompt in its
-                // launch argv. Once preparation returns that transport fact, any
+                // A managed host may already have submitted the exact Run prompt as
+                // part of process launch. Once preparation returns that transport
+                // fact, any
                 // later readiness or aggregate-write failure is delivery uncertainty,
                 // not a launch failure: preserve the Run and its reservation for the
                 // matching provider Hook instead of terminalizing it.
@@ -109,9 +109,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 // pre-readiness Session falls back to the existing durable Session;
                 // fresh runtime-discovered providers intentionally persist `null`.
                 if (!preStartFencePersisted) {
-                    const preparedFenceSession = prepared.session === undefined
-                        ? existingSession
-                        : validateReadySession(role, run.effective, existingSession, run.mode, { prepared, session: prepared.session });
+                    const preparedFenceSession = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, run.mode, prepared, prepared.session);
                     preparedSession = preparedFenceSession;
                     store.saveRoleRunPrepared({
                         task,
@@ -125,7 +123,7 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 const ready = await delivery.waitUntilReady(prepared);
                 deliveryAttempted = deliveryAttempted
                     || ready.prepared.inputSubmittedAtLaunch === true;
-                const session = validateReadySession(role, run.effective, existingSession, run.mode, ready);
+                const session = validateLaunchSubmittedRecoverySession(role, run.effective, existingSession, run.mode, ready.prepared, ready.session);
                 preparedSession = session;
                 store.saveRoleRunPrepared({
                     task,
@@ -178,7 +176,8 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 // screen scrape, or pane/PID inference — and fails closed for a
                 // supported adapter whose readiness cannot be confirmed.
                 if (ready.prepared.sessionStarted
-                    && isPreInputReadinessSupported(preInputReadinessCapability(run.effective.adapterId))
+                    && builtinAgentDriverRegistry().requireByAdapterId(run.effective.adapterId)
+                        .capabilities.observation.preInputReadiness === "exact"
                     && !providerReadyForPush(store, {
                         taskId: task.id,
                         roleName: role.name,
@@ -232,14 +231,15 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                 if (error instanceof RuntimeLaunchError) {
                     const terminalFailure = roleRunDeliveryFailure(run, processing.batchId, existingSession, error.launchId);
                     if (error.retryable) {
+                        const writerAttached = error.reason === "writable-client";
                         results.push({
                             taskId: task.id,
                             roleName: role.name,
                             runId: run.id,
                             status: "skipped",
-                            reason: "runtime-unavailable",
+                            reason: writerAttached ? "writer-attached" : "runtime-unavailable",
                             error: message,
-                            terminalFailure
+                            ...(writerAttached ? {} : { terminalFailure })
                         });
                         continue;
                     }
@@ -364,8 +364,23 @@ function preflightSession(role, effective, existing, mode, preflight) {
         };
     return validateRoleSession(role, effective, existing, mode, session);
 }
-function validateReadySession(role, effective, existing, mode, ready) {
-    return validateRoleSession(role, effective, existing, mode, ready.session);
+/**
+ * A Controller restart can recover an exact launch-submitted Run while its
+ * finite provider process is still alive. The host intentionally does not
+ * re-plan or re-submit that Run and therefore may return no native identity;
+ * retain only the durable Session fenced to the same launch generation.
+ */
+function validateLaunchSubmittedRecoverySession(role, effective, existing, mode, prepared, session) {
+    if (session === null
+        && prepared.inputSubmittedAtLaunch === true
+        && prepared.sessionStarted === false
+        && existing?.launchId !== undefined
+        && existing.launchId === prepared.launchId) {
+        return validateRoleSession(role, effective, existing, mode, existing);
+    }
+    return session === undefined
+        ? existing
+        : validateRoleSession(role, effective, existing, mode, session);
 }
 function validateRoleSession(role, effective, existing, mode, session) {
     if (mode === "new" && session === null)

package/dist/scheduler/leaderWakeupProcessor.js

@@ -7,6 +7,7 @@ import { hasRuntimeLifecycleWork, runtimeLifecycleTarget } from "../runtime/life
 import { recordLeaderFailure } from "./leaderFailure.js";
 import { createLeaderRecoveryNotification } from "./operatorNotification.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
+import { RuntimeLaunchError } from "../runtime/ports.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
     const wakeups = selection === undefined || selection.full
@@ -152,8 +153,9 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
                     preStartFencePersisted = true;
                 }
             });
-            // A fresh Codex host may already carry the exact Run prompt in its
-            // launch argv. Once preparation returns that transport fact, any
+            // A managed host may already have submitted the exact Run prompt as
+            // part of process launch. Once preparation returns that transport
+            // fact, any
             // later readiness or aggregate-write failure is delivery uncertainty,
             // not a launch failure: preserve the Run and its reservation for the
             // matching provider Hook instead of terminalizing it.
@@ -262,6 +264,23 @@ export async function processLeaderWakeups(store, delivery, now, selection) {
             const detail = error instanceof Error ? error.message : String(error);
             const message = `Leader dispatch failed: ${detail}`;
             if (claimed && run !== null) {
+                // A finite managed provider from the preceding Run may still be
+                // exiting after its durable yield. Keep this newly-claimed Run as the
+                // sole owner of the Role mailbox; active-Run delivery will retry it
+                // after the old host disappears. This is runtime backpressure, not a
+                // Leader failure and not grounds for allocating another Run.
+                if (error instanceof RuntimeLaunchError && error.retryable) {
+                    results.push({
+                        taskId: task.id,
+                        runId: run.id,
+                        status: "skipped",
+                        reason: error.reason === "writable-client"
+                            ? "writer-attached"
+                            : "not-ready",
+                        error: message
+                    });
+                    continue;
+                }
                 // Once delivery begins, a send may have succeeded even when receipt
                 // observation or the aggregate write failed. Preserve the exact
                 // durable Run and let receipt-backed active delivery recover it.

package/dist/scheduler/roleRunLiveness.js

@@ -1,7 +1,7 @@
 import { selectedSchedulerRoles, selectedSchedulerTasks } from "./ports.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { queueLeaderWakeup } from "./wakeupQueue.js";
-import { currentRoleRunProgressAt, DEFAULT_EXECUTION_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
+import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
 export const EXITED_ROLE_RUN_SUMMARY = "The role's tmux session exited before the run yielded.";
 /**
  * Lightweight liveness only: an active AgentRun whose tmux role is absent is
@@ -143,5 +143,5 @@ function isResourceCandidate(task, run, now) {
     }
     const deliveredAt = Date.parse(run.deliveredAt);
     return Number.isFinite(deliveredAt)
-        && now.getTime() - deliveredAt >= DEFAULT_EXECUTION_STALL_CANDIDATE_AGE_MS;
+        && now.getTime() - deliveredAt >= DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS;
 }