@zq-silk/yui 0.2.0 → 0.4.2

package/dist/scheduler/operatorNotification.js

@@ -1,11 +1,53 @@
+export const CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION = 1;
 export function createLeaderRecoveryNotification(taskId, message, now, existing) {
     const timestamp = now.toISOString();
     return {
-        schemaVersion: 1,
+        schemaVersion: CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION,
         taskId: requiredText(taskId, "Task id"),
         type: "leader-recovery-failed",
         message: requiredText(message, "Operator notification message"),
-        createdAt: existing?.createdAt ?? timestamp,
+        createdAt: existing?.type === "leader-recovery-failed"
+            ? existing.createdAt
+            : timestamp,
+        updatedAt: timestamp
+    };
+}
+export function createTaskTerminalNotification(taskId, status, by, summary, now) {
+    const timestamp = now.toISOString();
+    return {
+        schemaVersion: CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION,
+        taskId: requiredText(taskId, "Task id"),
+        type: "task-terminal",
+        status,
+        by,
+        summary: requiredText(summary, "Task terminal summary"),
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+}
+export function createLeaderStallNotification(taskId, runId, progressAt, evidenceKey, now, existing) {
+    const timestamp = now.toISOString();
+    const previous = existing?.type === "leader-stalled"
+        && existing.runId === runId
+        && existing.progressAt === progressAt
+        ? existing
+        : undefined;
+    return {
+        schemaVersion: CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION,
+        taskId: requiredText(taskId, "Task id"),
+        type: "leader-stalled",
+        message: requiredText([
+            `Leader Run ${runId} is truly stalled for Task ${taskId}.`,
+            `lastProgressAt=${progressAt}`,
+            `classification=truly-stalled`,
+            `evidence=${evidenceKey}`,
+            "Inspect the Task context and decide whether to continue, reset, retry, change Agent, or request user input; Controller performed no automatic action."
+        ].join(" "), "Operator notification message"),
+        runId: requiredText(runId, "Leader Run id"),
+        progressAt: requiredText(progressAt, "Leader progress timestamp"),
+        classification: "truly-stalled",
+        evidenceKey: requiredText(evidenceKey, "Leader stall evidence"),
+        createdAt: previous?.createdAt ?? timestamp,
         updatedAt: timestamp
     };
 }

package/dist/scheduler/ports.js

@@ -1 +1,28 @@
-export {};
+import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
+export function isSchedulerTaskWorkspaceReady(task, workspace) {
+    return isTaskOwnedWorkspace(workspace, task.id, task.cwd, task.projectBindings.map(({ projectId, directory }) => ({ projectId, directory })));
+}
+/** Resolves Tasks without a global scan for a dirty reconciliation pass. */
+export function selectedSchedulerTasks(store, selection) {
+    if (selection === undefined || selection.full)
+        return [...store.listTasks()];
+    return [...selection.taskIds].flatMap((taskId) => {
+        const task = store.getTask(taskId);
+        return task === null ? [] : [task];
+    });
+}
+/** Resolves either every Role in a selected Task or only explicit Role keys. */
+export function selectedSchedulerRoles(store, taskId, selection) {
+    if (selection === undefined
+        || selection.full
+        || selection.allRoleTaskIds.has(taskId)) {
+        return [...store.listRoles(taskId)];
+    }
+    const names = selection.rolesByTask.get(taskId);
+    if (names === undefined)
+        return [];
+    return [...names].flatMap((roleName) => {
+        const role = store.getRole(taskId, roleName);
+        return role === null ? [] : [role];
+    });
+}

package/dist/scheduler/roleRunLiveness.js

@@ -1,41 +1,147 @@
+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";
 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
  * failed, then the Leader is durably queued. No TTL, cooldown, or schedules.
  */
-export async function reconcileExitedRoleRuns(store, delivery, now) {
+export async function reconcileExitedRoleRuns(store, delivery, now, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence) {
     const failed = [];
-    for (const task of store.listTasks()) {
-        for (const role of store.listRoles(task.id)) {
-            const run = store.getActiveAgentRun(task.id, role.name);
-            if (run === null)
-                continue;
-            const session = store.getRoleSession(task.id, role.name);
-            const status = await delivery.inspectRole({
-                taskId: task.id,
-                roleName: role.name,
-                agentId: role.activeAgentId,
-                adapterId: role.adapterId,
-                ...(session?.nativeSessionId === undefined
-                    ? {}
-                    : { nativeSessionId: session.nativeSessionId })
-            });
-            if (status === "present")
-                continue;
-            store.saveExitedRoleRun({
+    const candidates = selectedSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
+        const run = store.getActiveAgentRun(task.id, role.name);
+        if (run === null)
+            return [];
+        const session = store.getRoleSession(task.id, role.name, run.effective.agentId);
+        return [{
                 task,
                 role,
                 run,
                 session,
-                summary: EXITED_ROLE_RUN_SUMMARY,
-                now
-            });
-            failed.push(run.id);
-            if (task.status === "active") {
-                queueLeaderWakeup(store, task.id, role.name === "leader" ? "leader-run-failed" : "role-run-failed", now);
+                inspection: {
+                    taskId: task.id,
+                    roleName: role.name,
+                    agentId: run.effective.agentId,
+                    adapterId: run.effective.adapterId,
+                    runId: run.id,
+                    progressAt: run.deliveredAt ?? run.createdAt,
+                    ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                    ...(session?.nativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: session.nativeSessionId })
+                }
+            }];
+    })));
+    if (candidates.length === 0)
+        return failed;
+    const completing = new Set(store.listPendingRuntimeTurnCompletions().map((completion) => (`${completion.taskId}\0${completion.roleName}\0${completion.runId}`)));
+    const eligible = candidates.filter(({ task, role, run }) => (!excludedRunRefs.has(formatTaskRecordReference(task.id, run.id, "agentRun"))
+        && !completing.has(`${task.id}\0${role.name}\0${run.id}`)));
+    // Build one complete provider inventory for every active Run, including
+    // delivery-uncertain and completion-pending Runs. The stall phase reuses
+    // this snapshot so one scheduler pass never probes the same pane twice.
+    const batchSnapshot = liveStatuses !== undefined
+        && candidates.every(({ task, role }) => liveStatuses.has(`${task.id}\0${role.name}`))
+        ? {
+            statuses: liveStatuses,
+            resources: resourceEvidence ?? new Map()
+        }
+        : await inspectRoleStatuses(delivery, candidates, candidates.flatMap(({ task, role, run, session }) => (isResourceCandidate(task, run, now)
+            ? [{
+                    taskId: task.id,
+                    roleName: role.name,
+                    runId: run.id,
+                    agentId: run.effective.agentId,
+                    adapterId: run.effective.adapterId,
+                    progressAt: currentRoleRunProgressAt(store, task.id, role.name, run).progressAt,
+                    ...(session?.nativeSessionId === undefined
+                        ? {}
+                        : { nativeSessionId: session.nativeSessionId }),
+                    ...(session?.launchId === undefined ? {} : { launchId: session.launchId })
+                }]
+            : [])));
+    if (liveStatuses !== undefined) {
+        for (const [key, status] of batchSnapshot.statuses)
+            liveStatuses.set(key, status);
+    }
+    if (resourceEvidence !== undefined) {
+        for (const [key, resource] of batchSnapshot.resources) {
+            const candidate = candidates.find(({ task, role }) => (`${task.id}\0${role.name}` === key));
+            if (candidate !== undefined) {
+                // Keep only the exact Run key. A task/role or bare-Run fallback can
+                // bridge an asynchronous sample from a prior generation.
+                resourceEvidence.set(`${key}\0${candidate.run.id}`, resource);
             }
         }
     }
+    for (const { task, role, run, session, inspection } of eligible) {
+        const status = batchSnapshot.statuses.get(`${task.id}\0${role.name}`);
+        if (status === undefined)
+            throw new Error("Role liveness snapshot is incomplete.");
+        if (status === "present")
+            continue;
+        const persisted = store.saveExitedRoleRun({
+            task,
+            role,
+            run,
+            session,
+            summary: EXITED_ROLE_RUN_SUMMARY,
+            now
+        });
+        if (persisted === "state-changed")
+            continue;
+        delivery.forgetPrepared?.({
+            taskId: task.id,
+            roleName: role.name,
+            runId: run.id
+        });
+        failed.push(formatTaskRecordReference(task.id, run.id, "agentRun"));
+        // Compatibility for narrow in-memory/custom ports that predate the
+        // adapter's atomic failure+wake transition. Production returns
+        // "failed" and already enqueued this wake in the same transaction.
+        if (persisted === undefined && task.status === "active") {
+            queueLeaderWakeup(store, task.id, role.name === "leader" ? "leader-run-failed" : "role-run-failed", now);
+        }
+    }
     return failed;
 }
+async function inspectRoleStatuses(delivery, candidates, resourceInputs) {
+    if (delivery.inspectRoles !== undefined) {
+        return exactBatchInventory(await delivery.inspectRoles(candidates.map(({ inspection }) => inspection), resourceInputs), candidates);
+    }
+    const entries = [];
+    for (const candidate of candidates) {
+        entries.push([
+            `${candidate.task.id}\0${candidate.role.name}`,
+            await delivery.inspectRole(candidate.inspection)
+        ]);
+    }
+    return { statuses: new Map(entries), resources: new Map() };
+}
+function exactBatchInventory(batch, candidates) {
+    const expected = new Set(candidates.map(({ task, role }) => `${task.id}\0${role.name}`));
+    const statuses = new Map();
+    const resources = new Map();
+    for (const entry of batch) {
+        const key = `${entry.taskId}\0${entry.roleName}`;
+        if (!expected.has(key) || statuses.has(key)) {
+            throw new Error("Tmux Role batch liveness snapshot is invalid.");
+        }
+        statuses.set(key, entry.status);
+        if (entry.resource !== undefined)
+            resources.set(key, entry.resource);
+    }
+    if (statuses.size !== expected.size) {
+        throw new Error("Tmux Role batch liveness snapshot is incomplete.");
+    }
+    return { statuses, resources };
+}
+function isResourceCandidate(task, run, now) {
+    if (task.status !== "active" || run.status !== "active" || run.deliveredAt === undefined) {
+        return false;
+    }
+    const deliveredAt = Date.parse(run.deliveredAt);
+    return Number.isFinite(deliveredAt)
+        && now.getTime() - deliveredAt >= DEFAULT_EXECUTION_STALL_CANDIDATE_AGE_MS;
+}