@zq-silk/yui 0.15.7 → 0.15.9

package/dist/controller/sessionNotify.js

@@ -13,20 +13,17 @@ export async function runSessionNotifyCommand(payloadArgument, environment = pro
     if (params.scope === "global")
         return;
     const home = requireText(environment.YUI_HOME, "YUI_HOME");
-    // A Codex process outlives its Turn, so the notify envelope cannot say which
-    // Turn or runtime generation is current. Durable Session state answers both;
-    // the envelope's runtime generation id is used only before a Session has been projected.
-    const current = currentNotifyGeneration(home, params);
-    const enqueued = new FileRuntimeEventInbox(home).enqueueTurnTerminal({
+    // The caller reports native identity; durable state supplies the current AgentRun.
+    const current = currentNotifyRun(home, params);
+    const enqueued = new FileRuntimeEventInbox(home).enqueueRunTerminal({
         scope: params.scope,
         ...(params.scope === "task" ? { taskId: params.taskId } : {}),
         roleName: params.roleName,
         agentId: params.agentId,
         adapterId: params.adapterId,
-        ...(current.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: current.runtimeGenerationId }),
         nativeSessionId: params.nativeSessionId,
         nativeTurnId: params.nativeTurnId,
-        ...(current.turnId === undefined ? {} : { turnId: current.turnId }),
+        ...(current.runId === undefined ? {} : { runId: current.runId }),
         ...(params.title === undefined ? {} : { title: params.title }),
         providerStatus: "completed",
         outcome: params.outcome
@@ -45,34 +42,32 @@ export async function runSessionNotifyCommand(payloadArgument, environment = pro
                 roleName: params.roleName
             })
     }, { timeoutMs: 100 }).catch(() => { });
-    if (enqueued.created && shouldSetThreadName(home, params, current.turnId)) {
+    if (enqueued.created && shouldSetThreadName(home, params, current.runId)) {
         const request = threadNameRequest(params, environment);
         if (request !== null)
             await setThreadName(request).catch(() => { });
     }
 }
 /**
- * Reads the durable runtime generation and active Turn for the notifying
- * Session. The envelope's runtime generation id only applies before Yui has projected a
- * Session for this Role, which is the one moment durable state cannot answer.
+ * Resolve the active AgentRun only when the notifying native Session matches.
  */
-function currentNotifyGeneration(home, params) {
+function currentNotifyRun(home, params) {
     if (params.scope !== "task" || params.taskId === undefined) {
-        return params.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: params.runtimeGenerationId };
+        return {};
     }
     try {
         const store = openCurrentTaskStore(home);
         const session = store.getTaskRoleSessionSet(params.taskId, params.roleName)
             ?.sessions[params.agentId];
-        const activeTurn = store.getActiveTurn(params.taskId, params.roleName);
-        const runtimeGenerationId = session?.runtimeGenerationId ?? params.runtimeGenerationId;
+        const activeRun = store.getActiveRun(params.taskId, params.roleName);
+        if (session?.nativeSessionId !== params.nativeSessionId)
+            return {};
         return {
-            ...(runtimeGenerationId === undefined ? {} : { runtimeGenerationId }),
-            ...(activeTurn === null ? {} : { turnId: activeTurn.id })
+            ...(activeRun === null ? {} : { runId: activeRun.id })
         };
     }
     catch {
-        return params.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: params.runtimeGenerationId };
+        return {};
     }
 }
 export function parseCodexSessionNotification(payloadArgument, environment) {
@@ -95,9 +90,6 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
         roleName: requireText(environment.YUI_ROLE, "YUI_ROLE"),
         agentId: requireText(environment.YUI_AGENT_ID, "YUI_AGENT_ID"),
         adapterId: requireCodexAdapter(environment.YUI_ADAPTER_ID),
-        ...(environment.YUI_RUNTIME_GENERATION_ID === undefined
-            ? {}
-            : { runtimeGenerationId: requireText(environment.YUI_RUNTIME_GENERATION_ID, "YUI_RUNTIME_GENERATION_ID") }),
         nativeSessionId,
         nativeTurnId,
         ...(title === undefined ? {} : { title }),
@@ -138,14 +130,14 @@ function requireText(value, label) {
         throw new Error(`${label} is invalid.`);
     return text;
 }
-function shouldSetThreadName(home, params, turnId) {
+function shouldSetThreadName(home, params, runId) {
     if (params.scope !== "task"
         || params.title === undefined
-        || turnId === undefined)
+        || runId === undefined)
         return false;
     try {
         const store = openCurrentTaskStore(home);
-        return store.getTurn(params.taskId, turnId)?.mode === "new";
+        return store.getRun(params.taskId, runId)?.mode === "new";
     }
     catch {
         return false;

package/dist/controller/sessionOwnerReconciliation.js

@@ -1,8 +1,16 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createTaskEvent } from "../event/taskEvent.js";
-import { createSessionOwnerIdentity, discoverProviderRootByLaunchEnv, isLinuxProcessLive, listLaunchFencedProcesses, listOwnedProcessTree, readLinuxProcessIdentity, reconcileSessionOwners, terminateSessionOwners } from "../runtime/index.js";
-import { removeRuntimeStopReceipt, writeRuntimeStopReceipt } from "../runtime/runtimeStopReceipt.js";
+import { createSessionOwnerIdentity, isLinuxProcessLive, listOwnedProcessTree, readLinuxProcessIdentity, reconcileSessionOwners, terminateSessionOwners } from "../runtime/index.js";
+import { sessionOwnerProcessKey } from "../runtime/sessionOwnerIdentity.js";
+import { AGENT_HOST_CONTROL_PROTOCOL, sendAgentHostCancelControl } from "../runtime/agentHost.js";
+import { settleProviderTurn, cancelQuiescentProviderInput, clearProviderGoal } from "../runtime/providerRuntimeIdentity.js";
+import { updateTaskRoleProviderRuntime, taskRoleControlTarget } from "../executor/agentExecutor.js";
+import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
+import { stopCodexNativeSession } from "../runtime/nativeSessionControl.js";
+import { routeRoleEvent } from "../scheduler/operatorEvent.js";
+import { redactAgentErrorText } from "../runtime/agentError.js";
+import { runtimeCleanupDisposition, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { tmuxSocketDirectory } from "../tmux/tmuxSocketEndpoint.js";
 import { yuiTmuxServerName, yuiTmuxSessionName, yuiTmuxTarget } from "../tmux/tmuxManager.js";
 /**
@@ -16,29 +24,33 @@ export class SessionOwnerReconciliation {
     #environment;
     #tmux;
     #onWarning;
+    #cancelInput;
+    #nativeConnection;
+    #stopNative;
     constructor(deps) {
         this.#home = deps.home;
         this.#store = deps.store;
         this.#environment = deps.environment ?? process.env;
         this.#tmux = deps.tmux;
         this.#onWarning = deps.onWarning ?? (() => undefined);
+        this.#cancelInput = deps.cancelInput ?? sendAgentHostCancelControl;
+        this.#nativeConnection = deps.nativeConnection ?? ((taskId, roleName) => new FileRoleLaunchPlanner(this.#home, this.#store, { environment: this.#environment })
+            .planNativeControl(taskId, roleName));
+        this.#stopNative = deps.stopNative ?? stopCodexNativeSession;
     }
     /**
-     * Persists the exact physical owner identity after a host created a new
-     * Provider process. The Provider root is attributed by the exact
-     * YUI_RUNTIME_GENERATION_ID environment fence; the tmux pane PID is only a weaker
-     * fallback when the fence cannot be read.
+     * Capture the created pane's concrete process identity. No inherited
+     * environment marker is used to discover or claim other applications.
      */
     recordHostOwner(input) {
-        const discovered = discoverProviderRootByLaunchEnv(input.runtimeGenerationId);
-        const fallback = discovered === undefined && input.panePid !== undefined
+        const observed = input.panePid !== undefined
             ? readLinuxProcessIdentity(input.panePid)
             : undefined;
-        const root = discovered ?? (fallback === undefined
+        const root = observed === undefined
             ? undefined
-            : { pid: fallback.pid, identity: fallback });
+            : { pid: observed.pid, identity: observed };
         if (root === undefined) {
-            this.#onWarning(`Session owner identity could not attribute a Provider root for launch ${input.runtimeGenerationId}; `
+            this.#onWarning(`Session owner identity could not read the Host process for ${input.owner.roleName}; `
                 + "no owner record was written.");
             return;
         }
@@ -52,7 +64,6 @@ export class SessionOwnerReconciliation {
             },
             agentId: input.agentId,
             adapterId: input.adapterId,
-            runtimeGenerationId: input.runtimeGenerationId,
             ...(input.nativeSessionId === undefined
                 ? {}
                 : { nativeSessionId: input.nativeSessionId }),
@@ -74,7 +85,7 @@ export class SessionOwnerReconciliation {
                 ...(root.identity.processSessionId === undefined
                     ? {}
                     : { processSessionId: root.identity.processSessionId }),
-                attribution: discovered === undefined ? "pane-pid" : "launch-env"
+                attribution: "pane-pid"
             },
             ...(input.runtimeRoot === undefined ? {} : { runtimeRoot: input.runtimeRoot }),
             recordedAt: new Date()
@@ -98,7 +109,7 @@ export class SessionOwnerReconciliation {
                     return undefined;
                 }
             },
-            lastStopOutcome: (taskId, roleName, runtimeGenerationId) => (lastSessionTerminationOutcome(this.#store, taskId, roleName, runtimeGenerationId)),
+            lastStopOutcome: (taskId, roleName) => (lastSessionTerminationOutcome(this.#store, taskId, roleName)),
             now: new Date()
         });
     }
@@ -108,7 +119,27 @@ export class SessionOwnerReconciliation {
      */
     async terminateOwner(owner, options = {}) {
         const records = this.#store.listSessionOwnersForOwner(owner);
-        const ports = {
+        // Killing a proxy is not cancelling its remote Turn. Settle the exact
+        // owned native input before any Host signal or owner-record removal.
+        try {
+            await this.#quiesceInput(owner);
+        }
+        catch (error) {
+            this.#recordTerminationEvent({ owner, stage: "stop-blocked",
+                detail: redactAgentErrorText(error instanceof Error ? error.message : String(error)).slice(0, 2000),
+                at: new Date() });
+            throw error;
+        }
+        const result = await terminateSessionOwners(owner, records, this.#terminationPorts(), options);
+        if (result.outcome === "stop-confirmed") {
+            for (const record of result.confirmed) {
+                this.#store.removeSessionOwner(sessionOwnerProcessKey(record));
+            }
+        }
+        return result;
+    }
+    #terminationPorts() {
+        return {
             gracefulStop: async (target) => {
                 if (this.#tmux === undefined)
                     return false;
@@ -130,52 +161,149 @@ export class SessionOwnerReconciliation {
                     return false;
                 }
             },
-            listLaunchFencedProcesses: (runtimeGenerationId) => listLaunchFencedProcesses(runtimeGenerationId),
             signalProcess: (pid, signal) => process.kill(pid, signal),
-            signalProcessGroup: (processGroupId, signal) => {
-                try {
-                    process.kill(-processGroupId, signal);
-                }
-                catch (error) {
-                    if (error.code !== "ESRCH")
-                        throw error;
-                }
-            },
             sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
             emit: (event) => this.#recordTerminationEvent(event),
             now: () => new Date()
         };
-        const result = await terminateSessionOwners(owner, records, ports, options);
-        if (result.outcome === "stop-confirmed") {
-            for (const record of result.confirmed) {
-                this.#store.removeSessionOwner(record.runtimeGenerationId);
-                removeRuntimeStopReceipt(this.#home, record.runtimeGenerationId);
+    }
+    async #quiesceInput(owner) {
+        if (owner.scope !== "task")
+            return;
+        if (runtimeCleanupDisposition(this.#store.getWorkMailbox(runtimeLifecycleTarget(owner))) === "detach-host")
+            return;
+        const set = this.#store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+        const binding = set?.providerBinding;
+        const input = binding?.run;
+        const unsettled = input != null && ["submitting", "accepted", "delivery-unknown"].includes(input.status);
+        const hasGoal = binding?.goal != null && binding.goal.status !== "complete";
+        const selected = taskRoleControlTarget(set);
+        if (set == null || (!unsettled && !hasGoal && selected?.adapterId !== "codex"))
+            return;
+        if (selected === undefined) {
+            throw new Error("Cannot identify the native execution to stop.");
+        }
+        const request = this.#store.listEvents(owner.taskId).filter(event => ["runtime.session-replacement-requested", "runtime.session-stop-requested"].includes(event.type)
+            && event.payload.roleName === owner.roleName
+            && event.payload.nativeSessionId === selected.nativeSessionId).at(-1);
+        const operatorStop = this.#store.getTask(owner.taskId)?.executionGate.state === "stopped"
+            || (request !== undefined && ["user", "operator"].includes(request.payload.requestedBy));
+        if (binding?.authority.owner === "human" && !operatorStop) {
+            throw new Error("This native Session is under human control; Operator/user must request its stop or replacement.");
+        }
+        let terminal;
+        try {
+            const result = unsettled && binding?.authority.owner === "controller" && binding.authority.holderId !== undefined ? await this.#cancelInput({
+                home: this.#home, scope: "task", taskId: owner.taskId, roleName: owner.roleName,
+                control: {
+                    protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "cancel",
+                    nativeSessionId: selected.nativeSessionId,
+                    attemptId: input.attemptId, authority: {
+                        epoch: binding.authority.epoch, owner: "controller", holderId: binding.authority.holderId
+                    }
+                }
+            }) : undefined;
+            const proof = result?.cancellation?.terminal;
+            if (result?.cancellation?.status !== "unknown" && proof?.clientOwned
+                && proof.attemptId === input?.attemptId && proof.nativeSessionId === selected.nativeSessionId
+                && (input?.nativeTurnId === undefined || proof.nativeTurnId === input.nativeTurnId))
+                terminal = proof;
+        }
+        catch {
+            // Recovery follows the recorded native identity, not the availability of
+            // the disposable Host which used to own its control socket.
+        }
+        if (terminal === undefined || hasGoal || selected.adapterId === "codex") {
+            if (selected.adapterId === "codex") {
+                await this.#stopNative(this.#nativeConnection(owner.taskId, owner.roleName), {
+                    conversationId: selected.nativeSessionId,
+                    nativeTurnId: unsettled && terminal === undefined ? input?.nativeTurnId : undefined,
+                    clearGoal: true
+                });
+            }
+            else if (selected.adapterId === "claude") {
+                const records = this.#store.listSessionOwnersForOwner(owner);
+                const children = records.filter(record => record.nativeSessionId === selected.nativeSessionId
+                    && record.providerRoot.attribution === "owned-child");
+                if (children.length > 0) {
+                    const stopped = await terminateSessionOwners(owner, children, this.#terminationPorts());
+                    if (stopped.outcome !== "stop-confirmed")
+                        throw new Error("Dedicated native execution is still draining; no resource was released.");
+                }
+                else if (selected.status !== "ended"
+                    || records.some(ownerRootIsLive)
+                    || this.#tmux?.probeRoleStatus(owner.taskId, owner.roleName) !== "exited") {
+                    throw new Error("Native process custody is unavailable; inspect the exact local execution before reusing its workspace.");
+                }
+            }
+            else {
+                throw new Error("This Provider has no detached native control proof; inspect its execution resources before replacement.");
             }
         }
-        return result;
+        this.#store.transaction(tx => {
+            const current = tx.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+            const provider = current?.providerBinding;
+            if (current == null || provider?.run?.attemptId !== input?.attemptId
+                || (selected.fromBinding
+                    ? current.providerBinding?.conversations.find(entry => entry.status === "current")?.conversationId
+                    : current.sessions[current.activeAgentId]?.nativeSessionId) !== selected.nativeSessionId
+                || provider?.authority.epoch !== binding?.authority.epoch) {
+                throw new Error("Native input identity changed while confirming its stop.");
+            }
+            if (provider != null && (provider.run != null && ["submitting", "accepted", "delivery-unknown"].includes(provider.run.status)
+                || hasGoal || selected.adapterId === "codex")) {
+                const now = new Date();
+                let stopped = provider;
+                if (unsettled && input != null) {
+                    stopped = terminal !== undefined && provider.run?.status === "accepted"
+                        ? settleProviderTurn(provider, { attemptId: input.attemptId, nativeTurnId: terminal.nativeTurnId,
+                            status: terminal.status, settledAt: now.toISOString() })
+                        : cancelQuiescentProviderInput(provider, { attemptId: input.attemptId, cancelledAt: now.toISOString(),
+                            reason: "Explicit Session stop; native execution quiescence independently verified." });
+                }
+                if (hasGoal || selected.adapterId === "codex")
+                    stopped = clearProviderGoal(stopped);
+                tx.saveTaskRoleSessionSet(updateTaskRoleProviderRuntime(current, stopped, now));
+                tx.saveEvent(owner.taskId, createTaskEvent(tx.nextEventId(owner.taskId), owner.taskId, "runtime.input-stop-confirmed", {
+                    roleName: owner.roleName, ...(input == null ? {} : { attemptId: input.attemptId }),
+                    nativeSessionId: selected.nativeSessionId, status: stopped.run?.status ?? "quiescent",
+                    evidence: terminal === undefined ? "native-resource-inspection" : "native-terminal",
+                    ...(input?.nativeTurnId === undefined ? {} : { nativeTurnId: input.nativeTurnId })
+                }, now));
+            }
+            else if (selected.adapterId === "codex") {
+                tx.saveEvent(owner.taskId, createTaskEvent(tx.nextEventId(owner.taskId), owner.taskId, "runtime.input-stop-confirmed", {
+                    roleName: owner.roleName, nativeSessionId: selected.nativeSessionId,
+                    status: "quiescent", evidence: "native-resource-inspection"
+                }, new Date()));
+            }
+        });
     }
     #recordTerminationEvent(event) {
         const owner = event.owner;
-        if (event.stage === "stop-requested" && event.runtimeGenerationId !== undefined) {
-            writeRuntimeStopReceipt(this.#home, event.runtimeGenerationId, event.at);
-        }
         if (owner.scope !== "task")
             return;
         try {
-            this.#store.saveEvent(owner.taskId, createTaskEvent(this.#store.nextEventId(owner.taskId), owner.taskId, "runtime.session-termination", {
+            const last = this.#store.listEvents(owner.taskId).filter(entry => entry.type === "runtime.session-termination" && entry.payload.roleName === owner.roleName).at(-1);
+            if (event.stage === "stop-blocked" && last?.payload.outcome === event.stage
+                && last.payload.detail === event.detail)
+                return;
+            const fact = createTaskEvent(this.#store.nextEventId(owner.taskId), owner.taskId, "runtime.session-termination", {
                 roleName: owner.roleName,
-                runtimeGenerationId: event.runtimeGenerationId ?? "",
                 nativeSessionId: event.nativeSessionId ?? "",
                 outcome: event.stage,
                 ...(event.detail === undefined ? {} : { detail: event.detail })
-            }, event.at));
+            }, event.at);
+            this.#store.saveEvent(owner.taskId, fact);
+            if (event.stage === "stop-blocked")
+                routeRoleEvent(this.#store, fact, owner.roleName, "session-recovery-blocked", event.at);
         }
         catch (error) {
             this.#onWarning(`Session termination event could not be persisted: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
 }
-/** Projects every durable Role runtime generation for reconciliation. */
+/** Projects every durable Role runtime for reconciliation. */
 export function durableSessionFacts(store) {
     const facts = [];
     for (const task of store.listTasks()) {
@@ -187,7 +315,6 @@ export function durableSessionFacts(store) {
                     roleName: set.owner.roleName,
                     agentId,
                     adapterId: session.adapterId,
-                    ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                     ...(session.nativeSessionId === undefined
                         ? {}
                         : { nativeSessionId: session.nativeSessionId }),
@@ -202,7 +329,6 @@ export function durableSessionFacts(store) {
                     roleName: set.owner.roleName,
                     agentId: history.agentId,
                     adapterId: history.adapterId,
-                    ...(history.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: history.runtimeGenerationId }),
                     ...(history.nativeSessionId === undefined
                         ? {}
                         : { nativeSessionId: history.nativeSessionId }),
@@ -219,7 +345,6 @@ export function durableSessionFacts(store) {
                 roleName: set.owner.roleName,
                 agentId,
                 adapterId: session.adapterId,
-                ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
@@ -234,7 +359,6 @@ export function durableSessionFacts(store) {
                 roleName: set.owner.roleName,
                 agentId: session.agentId,
                 adapterId: session.adapterId,
-                ...(session.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: session.runtimeGenerationId }),
                 ...(session.nativeSessionId === undefined
                     ? {}
                     : { nativeSessionId: session.nativeSessionId }),
@@ -296,8 +420,8 @@ export function observeSessionOwnerPhysical(record) {
         childCount: Math.max(0, tree.length - 1)
     };
 }
-/** Reads the latest termination outcome recorded for one generation. */
-export function lastSessionTerminationOutcome(store, taskId, roleName, runtimeGenerationId) {
+/** Reads the latest termination outcome recorded for one Role. */
+export function lastSessionTerminationOutcome(store, taskId, roleName) {
     if (taskId === undefined)
         return undefined;
     let latest;
@@ -306,12 +430,6 @@ export function lastSessionTerminationOutcome(store, taskId, roleName, runtimeGe
             continue;
         if (event.payload.roleName !== roleName)
             continue;
-        if (runtimeGenerationId !== ""
-            && event.payload.runtimeGenerationId !== undefined
-            && event.payload.runtimeGenerationId !== ""
-            && event.payload.runtimeGenerationId !== runtimeGenerationId) {
-            continue;
-        }
         latest = event.payload.outcome;
     }
     return latest;