@zq-silk/yui 0.6.4 → 0.6.6

package/dist/scheduler/roleRunLiveness.js

@@ -1,4 +1,4 @@
-import { selectedSchedulerRoles, selectedSchedulerTasks } from "./ports.js";
+import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { queueLeaderWakeup } from "./wakeupQueue.js";
 import { currentRoleRunProgressAt, DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS } from "./roleRunStall.js";
@@ -7,9 +7,9 @@ export const EXITED_ROLE_RUN_SUMMARY = "The role's tmux session exited before th
  * 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, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence) {
+export async function reconcileExitedRoleRuns(store, delivery, now, selection, excludedRunRefs = new Set(), liveStatuses, resourceEvidence, targetedInventory = selection !== undefined && !selection.full) {
     const failed = [];
-    const candidates = selectedSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
+    const candidates = selectedActiveSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
         const run = store.getActiveAgentRun(task.id, role.name);
         if (run === null)
             return [];
@@ -35,32 +35,39 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
     })));
     if (candidates.length === 0)
         return failed;
-    const completing = new Set(store.listPendingRuntimeTurnCompletions().map((completion) => (`${completion.taskId}\0${completion.roleName}\0${completion.runId}`)));
+    const candidateTaskIds = [...new Set(candidates.map(({ task }) => task.id))]
+        .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
+    const completing = new Set(store.listPendingRuntimeTurnCompletions(candidateTaskIds).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.
+    // Full reconciliation builds one complete provider inventory for every
+    // active Run, including delivery-uncertain and completion-pending Runs.
+    // The stall phase reuses that snapshot so one full pass never probes the
+    // same pane twice. When targetedInventory is true, a dirty pass instead
+    // uses exact probes below; stall reconciliation intentionally does not run
+    // for that bounded selection.
     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 })
-                }]
-            : [])));
+        : await inspectRoleStatuses(delivery, candidates, !targetedInventory
+            ? 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 })
+                    }]
+                : []))
+            : [], targetedInventory);
     if (liveStatuses !== undefined) {
         for (const [key, status] of batchSnapshot.statuses)
             liveStatuses.set(key, status);
@@ -106,7 +113,22 @@ export async function reconcileExitedRoleRuns(store, delivery, now, selection, e
     }
     return failed;
 }
-async function inspectRoleStatuses(delivery, candidates, resourceInputs) {
+async function inspectRoleStatuses(delivery, candidates, resourceInputs, targeted) {
+    // Dirty reconciliation already owns exact Task/Role keys. Probe those keys
+    // directly so a concurrent dirty batch does not repeat the provider's
+    // global inventory (and its optional process-resource scan) once per Task.
+    // Full reconciliation retains the adapter's batch contract below.
+    if (targeted && delivery.inspectRole !== undefined) {
+        const statuses = new Map();
+        for (const candidate of candidates) {
+            const key = `${candidate.task.id}\0${candidate.role.name}`;
+            if (statuses.has(key)) {
+                throw new Error("Tmux Role targeted liveness selection is invalid.");
+            }
+            statuses.set(key, await delivery.inspectRole(candidate.inspection));
+        }
+        return { statuses, resources: new Map() };
+    }
     if (delivery.inspectRoles !== undefined) {
         return exactBatchInventory(await delivery.inspectRoles(candidates.map(({ inspection }) => inspection), resourceInputs), candidates);
     }

package/dist/scheduler/roleRunStall.js

@@ -1,4 +1,4 @@
-import { selectedSchedulerRoles, selectedSchedulerTasks } from "./ports.js";
+import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 /**
  * Default window of no durable progress before a live-but-idle Run becomes a
  * traceable needs-attention signal. It is deliberately long: a healthy Run that
@@ -187,7 +187,7 @@ export function latestRunProgressAt(events, runId) {
  * the provider-neutral fallback. Resource evidence carries this value as an
  * exact fence, but never advances it.
  */
-export function currentRoleRunProgressAt(store, taskId, roleName, run, events = store.listEvents?.(taskId) ?? []) {
+export function currentRoleRunProgressAt(store, taskId, roleName, run, events, progressFacts) {
     let richerProgress;
     try {
         richerProgress = store.getRunDurableProgress?.(taskId, roleName, run.id);
@@ -209,10 +209,28 @@ export function currentRoleRunProgressAt(store, taskId, roleName, run, events =
                 : { evidence: richerProgress.evidence })
         };
     }
+    // A present fold port is authoritative even when this Run has no entry. Do
+    // not evaluate a default history argument or fall back to listEvents in
+    // that case: an absent entry is the folded empty fact.
+    const folded = store.getRunProgressFacts !== undefined;
+    const foldedFacts = folded
+        ? progressFacts ?? store.getRunProgressFacts?.(taskId, run.id)
+        : undefined;
+    if (folded) {
+        const fallbackProgressAt = latestDurableProgressAt({
+            deliveredAt: run.deliveredAt,
+            latestCheckpointAt: foldedFacts?.latestCheckpointAt,
+            latestActivityAt: foldedFacts?.latestActivityAt
+        });
+        return { progressAt: fallbackProgressAt };
+    }
+    // Legacy ports retain the per-Run event-history fallback. Resolve the
+    // history only in this branch so fold-backed callers perform zero scans.
+    const history = events ?? store.listEvents?.(taskId) ?? [];
     const fallbackProgressAt = latestDurableProgressAt({
         deliveredAt: run.deliveredAt,
-        latestCheckpointAt: latestRunProgressAt(events, run.id),
-        latestActivityAt: latestRunActivityAt(events, run.id)
+        latestCheckpointAt: latestRunProgressAt(history, run.id),
+        latestActivityAt: latestRunActivityAt(history, run.id)
     });
     return {
         progressAt: fallbackProgressAt
@@ -227,13 +245,13 @@ export function latestRunDurableProgressAt(store, taskId, roleName, runId, preco
     const run = store.getAgentRun(taskId, runId);
     if (run === null || run.taskId !== taskId || run.roleName !== roleName)
         return null;
-    const events = store.listEvents(taskId);
     // The adapter folds checkpoint/activity once per revision. When the fold
     // port exists, a missing per-Run entry is an authoritative empty fold: use
     // its (possibly undefined) values directly and never re-scan the whole
     // history per candidate. Legacy callers without the port omit precomputed
     // and keep the per-candidate full-history scans.
     const folded = precomputed !== undefined;
+    const events = folded ? undefined : store.listEvents(taskId);
     const latestCheckpointAt = folded
         ? precomputed.latestCheckpointAt
         : latestRunProgressAt(events, run.id);
@@ -480,26 +498,25 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
     // existing mailbox work without manufacturing another episode.
     if (selection !== undefined && !selection.full)
         return [];
-    if (store.listEvents === undefined || store.recordRoleRunStall === undefined)
+    if ((store.getRunProgressFacts === undefined && store.listEvents === undefined)
+        || store.recordRoleRunStall === undefined)
         return [];
     // When the fold port exists, a missing per-Run entry is an authoritative
     // empty fold: the stall reconciliation must not re-scan the whole history
     // per candidate. Legacy stores without the port keep the per-candidate
     // scans.
     const foldPortPresent = store.getRunProgressFacts !== undefined;
-    const candidates = selectedSchedulerTasks(store, selection).flatMap((task) => (task.status !== "active"
-        ? []
-        : selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
-            const run = store.getActiveAgentRun(task.id, role.name);
-            if (run === null || run.status !== "active")
-                return [];
-            return [{
-                    task,
-                    role,
-                    run,
-                    session: store.getRoleSession(task.id, role.name, run.effective.agentId)
-                }];
-        })));
+    const candidates = selectedActiveSchedulerTasks(store, selection).flatMap((task) => (selectedSchedulerRoles(store, task.id, selection).flatMap((role) => {
+        const run = store.getActiveAgentRun(task.id, role.name);
+        if (run === null || run.status !== "active")
+            return [];
+        return [{
+                task,
+                role,
+                run,
+                session: store.getRoleSession(task.id, role.name, run.effective.agentId)
+            }];
+    })));
     const stallCandidates = candidates.filter(({ run }) => isStallCandidate(run, now, windowMs));
     if (stallCandidates.length === 0)
         return [];
@@ -617,15 +634,22 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             });
             continue;
         }
-        const events = store.listEvents(candidate.task.id);
-        const progressFacts = store.getRunProgressFacts?.(candidate.task.id, candidate.run.id);
+        // Fold-backed adapters expose an authoritative per-Run fact, so do not
+        // load the Task history just to satisfy currentRoleRunProgressAt or its
+        // fallback. Legacy ports retain one history read for these projections.
+        const progressFacts = foldPortPresent
+            ? store.getRunProgressFacts?.(candidate.task.id, candidate.run.id)
+            : undefined;
+        const events = foldPortPresent
+            ? undefined
+            : store.listEvents?.(candidate.task.id);
         // Before exact acceptance there is no execution progress clock. Keep the
         // delivery watch anchored to the Run creation/transport boundary even if
         // checkpoints, output, or related WorkItem/Review/Integration records are
         // newer; those facts are useful evidence but cannot prove provider
         // acceptance or reset delivery timeout. Once accepted, deliveredAt is the
         // semantic baseline and the durable fold may advance it.
-        const progress = currentRoleRunProgressAt(store, candidate.task.id, candidate.role.name, candidate.run, events);
+        const progress = currentRoleRunProgressAt(store, candidate.task.id, candidate.role.name, candidate.run, events, progressFacts);
         const progressAt = progress.progressAt;
         const evaluation = evaluateRoleRunStall({
             progressAt,
@@ -633,7 +657,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
             windowMs,
             lastAttentionProgressAt: foldPortPresent
                 ? progressFacts?.latestStall?.progressAt
-                : latestStallProgressAt(events, candidate.run.id)
+                : latestStallProgressAt(events ?? [], candidate.run.id)
         });
         const runAgentId = candidate.run.effective.agentId;
         const runAdapterId = candidate.run.effective.adapterId;
@@ -710,7 +734,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         const { candidate, progressAt } = current;
         const previous = foldPortPresent
             ? store.getRunProgressFacts?.(candidate.task.id, candidate.run.id)?.latestStall
-            : latestStallEvidenceKey(store.listEvents(candidate.task.id), candidate.run.id);
+            : latestStallEvidenceKey(store.listEvents?.(candidate.task.id) ?? [], candidate.run.id);
         if (previous !== undefined
             && Date.parse(progressAt) > Date.parse(previous.progressAt)) {
             // A new semantic progress point closes the previous episode first. It
@@ -784,7 +808,7 @@ export async function reconcileStalledRoleRuns(store, delivery, now, selection,
         const { candidate, progressAt } = current;
         const previous = foldPortPresent
             ? store.getRunProgressFacts?.(candidate.task.id, candidate.run.id)?.latestStall
-            : latestStallEvidenceKey(store.listEvents(candidate.task.id), candidate.run.id);
+            : latestStallEvidenceKey(store.listEvents?.(candidate.task.id) ?? [], candidate.run.id);
         if (previous !== undefined
             && Date.parse(progressAt) > Date.parse(previous.progressAt)) {
             store.recordRoleRunProgress?.({