@zq-silk/yui 0.2.0 → 0.4.2

package/dist/executor/executorRegistry.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { createPromptEnvelope, createSessionLaunchRequest } from "../runtime/index.js";
 /**
  * Scheduler-to-tmux adapter. It retains only in-process prepared launch data;
  * durable session identity remains owned by FileTaskStore.
@@ -7,55 +8,264 @@ export class ExecutorRegistry {
     planner;
     tmux;
     readiness;
+    runtimePorts;
     #prepared = new Map();
-    constructor(planner, tmux, readiness = agentComposerReadinessProbe) {
+    constructor(planner, tmux, readiness = agentProcessReadinessProbe, runtimePorts) {
         this.planner = planner;
         this.tmux = tmux;
         this.readiness = readiness;
+        this.runtimePorts = runtimePorts;
     }
     async prepareRoleSession(input) {
         if (input.mode === "resume" && !hasText(input.nativeSessionId)) {
             throw new Error("Role session resume requires a native session id.");
         }
-        const planned = this.planner.plan(input);
-        this.tmux.ensureRoleWindow(input.taskId, planned.role, planned.launch);
-        const delivery = {
+        let sessionStarted = false;
+        const deliveryBase = {
             deliveryId: preparedDeliveryId(input),
             taskId: input.taskId,
             roleName: input.roleName,
             agentId: input.agentId,
             adapterId: input.adapterId,
-            mode: input.mode
+            mode: input.mode,
+            ...(input.runId === undefined ? {} : { runId: input.runId })
+        };
+        const cached = this.#prepared.get(deliveryBase.deliveryId);
+        if (cached !== undefined)
+            return cached.delivery;
+        let binding;
+        let planned;
+        let session;
+        if (this.runtimePorts === undefined) {
+            planned = this.planner.plan(input);
+            sessionStarted = this.tmux.ensureRoleWindow(input.taskId, planned.role, planned.launch);
+            session = planned.session;
+        }
+        else {
+            const common = {
+                owner: { scope: "task", taskId: input.taskId, roleName: input.roleName },
+                agentId: input.agentId,
+                adapterId: input.adapterId,
+                effective: input.effective,
+                workspace: input.workspace,
+                ...(input.managedWorkspace === undefined
+                    ? {}
+                    : { managedWorkspace: input.managedWorkspace }),
+                ...(input.runtimePolicy === undefined
+                    ? {}
+                    : { runtimePolicy: input.runtimePolicy }),
+                ...(input.runId === undefined ? {} : { runId: input.runId })
+            };
+            if (this.runtimePorts.launchCoordinator !== undefined) {
+                binding = await this.runtimePorts.launchCoordinator.prepare(input.mode === "new"
+                    ? { ...common, mode: "new" }
+                    : {
+                        ...common,
+                        mode: "resume",
+                        nativeSessionId: input.nativeSessionId
+                    }, "deferred", undefined, input.beforeHostStart);
+            }
+            else {
+                const request = input.mode === "new"
+                    ? createSessionLaunchRequest({
+                        ...common,
+                        launchId: deliveryBase.deliveryId,
+                        mode: "new"
+                    })
+                    : createSessionLaunchRequest({
+                        ...common,
+                        launchId: deliveryBase.deliveryId,
+                        mode: "resume",
+                        nativeSessionId: input.nativeSessionId
+                    });
+                binding = request.mode === "new"
+                    ? await this.runtimePorts.sessionHost.start(request, input.beforeHostStart)
+                    : await this.runtimePorts.sessionHost.resume(request, input.beforeHostStart);
+            }
+            sessionStarted = binding.hostCreated === true;
+            session = binding.nativeSessionId === undefined
+                ? null
+                : {
+                    agentId: binding.agentId,
+                    adapterId: binding.adapterId,
+                    nativeSessionId: binding.nativeSessionId,
+                    status: "ready",
+                    effective: input.effective
+                };
+        }
+        const delivery = {
+            ...deliveryBase,
+            ...(binding === undefined ? {} : { launchId: binding.launchId }),
+            sessionStarted,
+            session,
+            ...(input.runId !== undefined
+                && ((sessionStarted
+                    && (planned?.initialPromptRunId ?? binding?.initialPromptRunId) === input.runId)
+                    || binding?.launchPromptUncertainRunId === input.runId)
+                ? { inputSubmittedAtLaunch: true }
+                : {})
         };
-        this.#prepared.set(delivery.deliveryId, planned);
+        this.#prepared.set(delivery.deliveryId, {
+            delivery,
+            session,
+            ...(planned === undefined ? {} : { planned }),
+            ...(binding === undefined ? {} : { binding })
+        });
         return delivery;
     }
     async waitUntilReady(delivery) {
-        const planned = this.requirePrepared(delivery);
-        this.tmux.waitUntilReady(delivery.taskId, delivery.roleName, this.readiness(delivery.adapterId));
-        return { prepared: delivery, session: planned.session };
+        const prepared = this.requirePrepared(delivery);
+        if (prepared.binding === undefined) {
+            this.tmux.waitUntilReady(delivery.taskId, delivery.roleName, this.readiness(delivery.adapterId));
+        }
+        return { prepared: delivery, session: prepared.session };
     }
     async sendOnce(input) {
-        this.requirePrepared(input.delivery.prepared);
-        return this.tmux.sendRoleInputOnce(input.delivery.prepared.taskId, input.delivery.prepared.roleName, input.receiptId, input.text, this.readiness(input.delivery.prepared.adapterId));
+        const prepared = this.requirePrepared(input.delivery.prepared);
+        if (prepared.binding !== undefined && this.runtimePorts !== undefined) {
+            const runId = input.delivery.prepared.runId;
+            if (runId === undefined) {
+                throw new Error("Runtime prompt delivery requires a Task-local Run id.");
+            }
+            const outcome = await this.runtimePorts.promptPush.tryPush({
+                binding: prepared.binding,
+                envelope: createPromptEnvelope({
+                    id: input.receiptId,
+                    source: {
+                        kind: "agent-run",
+                        taskId: input.delivery.prepared.taskId,
+                        localId: runId
+                    },
+                    text: input.text,
+                    createdAt: new Date()
+                })
+            });
+            if (outcome === "delivered") {
+                this.#prepared.delete(input.delivery.prepared.deliveryId);
+            }
+            return outcome === "delivered" ? "sent" : outcome;
+        }
+        const outcome = this.tmux.sendRoleInputOnce(input.delivery.prepared.taskId, input.delivery.prepared.roleName, input.receiptId, input.text, this.readiness(input.delivery.prepared.adapterId));
+        if (outcome === "sent" || outcome === "already-sent") {
+            this.#prepared.delete(input.delivery.prepared.deliveryId);
+        }
+        return outcome;
     }
     async notifyOperatorInputOnce(input) {
-        if (this.tmux.probeRoleStatus("operator", input.roleName) !== "running") {
-            return "unavailable";
+        const probe = this.readiness(input.adapterId, "operator");
+        return this.tmux.sendRoleInputOnceIfReadyAsync === undefined
+            ? this.tmux.sendRoleInputOnceIfReady("operator", input.roleName, input.receiptId, input.text, probe)
+            : this.tmux.sendRoleInputOnceIfReadyAsync("operator", input.roleName, input.receiptId, input.text, probe);
+    }
+    forgetPrepared(input) {
+        for (const [deliveryId, prepared] of this.#prepared) {
+            const delivery = prepared.delivery;
+            if (delivery.taskId !== input.taskId
+                || delivery.roleName !== input.roleName
+                || (input.runId !== undefined
+                    && delivery.runId !== input.runId)
+                || (input.launchId !== undefined
+                    && delivery.launchId !== input.launchId)) {
+                continue;
+            }
+            this.#prepared.delete(deliveryId);
         }
-        return this.tmux.sendRoleInputOnceIfReady("operator", input.roleName, input.receiptId, input.text, this.readiness(input.adapterId));
     }
     async inspectRole(input) {
-        return this.tmux.probeRoleStatus(input.taskId, input.roleName) === "running"
+        const status = this.tmux.probeRoleStatusAsync === undefined
+            ? this.tmux.probeRoleStatus(input.taskId, input.roleName)
+            : await this.tmux.probeRoleStatusAsync(input.taskId, input.roleName);
+        return status === "running"
             ? "present"
             : "absent";
     }
-    async findExistingReceipt(input) {
-        const planned = this.requirePrepared(input.delivery);
-        return this.tmux.hasDeliveryReceipt(input.delivery.taskId, input.delivery.roleName, input.receiptId) ? { prepared: input.delivery, session: planned.session } : null;
+    async inspectRoleReadiness(input) {
+        const status = await this.inspectRole(input);
+        if (status === "absent")
+            return "absent";
+        try {
+            const pane = this.tmux.inspectPaneAsync === undefined
+                ? this.tmux.inspectPane?.(input.taskId, input.roleName)
+                : await this.tmux.inspectPaneAsync(input.taskId, input.roleName);
+            if (pane === undefined)
+                return "busy";
+            return this.readiness(input.adapterId)(pane) ? "ready" : "busy";
+        }
+        catch {
+            // A pane can disappear between inventory and the targeted process snapshot; the
+            // ordinary liveness pass will classify it on the next reconciliation.
+            return "busy";
+        }
+    }
+    async inspectRoles(inputs, resourceInputs) {
+        if (this.tmux.inspectRolePaneInventory === undefined
+            && this.tmux.inspectRolePaneInventoryAsync === undefined) {
+            return Promise.all(inputs.map(async (input) => ({
+                taskId: input.taskId,
+                roleName: input.roleName,
+                status: await this.inspectRole(input)
+            })));
+        }
+        const inventory = this.tmux.inspectRolePaneInventoryAsync === undefined
+            ? this.tmux.inspectRolePaneInventory()
+            : await this.tmux.inspectRolePaneInventoryAsync();
+        let resources = new Map();
+        const requested = resourceInputs ?? inputs.map((input) => ({
+            taskId: input.taskId,
+            roleName: input.roleName,
+            ...(input.runId === undefined ? {} : { runId: input.runId }),
+            agentId: input.agentId,
+            adapterId: input.adapterId,
+            ...(input.nativeSessionId === undefined
+                ? {}
+                : { nativeSessionId: input.nativeSessionId }),
+            ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+            ...(input.progressAt === undefined ? {} : { progressAt: input.progressAt })
+        }));
+        if (this.runtimePorts?.roleResourceInventory !== undefined
+            && requested.length > 0) {
+            try {
+                for (const entry of await this.runtimePorts.roleResourceInventory(inventory, requested)) {
+                    const key = `${entry.taskId}\0${entry.roleName}`;
+                    if (!resources.has(key))
+                        resources.set(key, entry.resource);
+                }
+            }
+            catch {
+                // Resource evidence is advisory. A failed process snapshot must not
+                // turn the authoritative pane inventory into an absent observation.
+            }
+        }
+        const present = new Set(inventory
+            .filter((pane) => !pane.dead)
+            .map((pane) => `${pane.taskId}\0${pane.roleName}`));
+        return inputs.map((input) => {
+            const key = `${input.taskId}\0${input.roleName}`;
+            const resource = resources.get(key);
+            return {
+                taskId: input.taskId,
+                roleName: input.roleName,
+                status: present.has(key) ? "present" : "absent",
+                ...(resource === undefined ? {} : { resource })
+            };
+        });
     }
-    async stopTask(taskId) {
-        return this.tmux.stopTask(taskId);
+    async stopRole(taskId, roleName) {
+        const status = this.tmux.probeRoleStatusAsync === undefined
+            ? this.tmux.probeRoleStatus(taskId, roleName)
+            : await this.tmux.probeRoleStatusAsync(taskId, roleName);
+        if (status !== "running") {
+            this.forgetPrepared({ taskId, roleName });
+            return false;
+        }
+        if (this.tmux.killRoleAsync === undefined) {
+            this.tmux.killRole(taskId, roleName);
+        }
+        else {
+            await this.tmux.killRoleAsync(taskId, roleName);
+        }
+        this.forgetPrepared({ taskId, roleName });
+        return true;
     }
     requirePrepared(delivery) {
         const planned = this.#prepared.get(delivery.deliveryId);
@@ -65,23 +275,13 @@ export class ExecutorRegistry {
         return planned;
     }
 }
-export function agentComposerReadinessProbe(adapterId) {
-    switch (adapterId) {
-        case "codex":
-            return (pane) => {
-                const content = pane.content.replace(/\r/g, "");
-                return livePane(pane)
-                    && !/Press enter to continue|select.*update|update selector/i.test(content)
-                    && content.includes("OpenAI Codex")
-                    && content.includes("/model to change")
-                    && /(?:^|\n)\s*›\s*(?:$|\S)/u.test(content);
-            };
-        case "claude":
-            return (pane) => livePane(pane)
-                && /(?:^|\n)\s*❯\s*(?:$|\S)/u.test(pane.content.replace(/\r/g, ""));
-        default:
-            throw new Error(`No tmux readiness probe is registered for Agent adapter: ${adapterId}.`);
+export function agentProcessReadinessProbe(adapterId, _surface = "role") {
+    if (adapterId !== "codex" && adapterId !== "claude") {
+        throw new Error(`No tmux readiness probe is registered for Agent adapter: ${adapterId}.`);
     }
+    // Run state and receipt fences decide whether delivery is allowed. Provider
+    // terminal contents are display-only evidence and never lifecycle input.
+    return livePane;
 }
 function livePane(pane) {
     return !pane.dead && pane.pid !== undefined && pane.currentCommand.trim().length > 0;
@@ -92,7 +292,9 @@ function preparedDeliveryId(input) {
         input.roleName,
         input.agentId,
         input.adapterId,
+        input.effective,
         input.mode,
+        input.runId ?? null,
         input.nativeSessionId ?? null
     ])).digest("hex");
 }