@zq-silk/yui 0.6.5 → 0.6.7

package/dist/storage/taskStore.js

@@ -10,8 +10,10 @@ import { resolveTimeZone } from "../output/timePresentation.js";
 import { mailboxTargetKey, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { validateInputRequest } from "../input/inputRequest.js";
 import { validateRoleSessionSet } from "../executor/agentExecutor.js";
+import { validatePendingTurnCompletion } from "../executor/turnCompletion.js";
 import { validateTaskMessage } from "../message/message.js";
 import { validateAgentRun } from "../run/agentRun.js";
+import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { FileSessionOwnerRegistry } from "../runtime/sessionOwnerRegistry.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
 import { validateReviewRound } from "../review/reviewRound.js";
@@ -387,6 +389,13 @@ export class FileTaskStore {
             .map((aggregate) => clone(aggregate.task))
             .sort((left, right) => numericCompare(left.id, right.id));
     }
+    listActiveTaskIds() {
+        // The file rollback backend has no catalog index, so it filters the loaded
+        // aggregate. Layout-7 Controller hot paths use SQLite's bounded selector.
+        return this.listTasks()
+            .filter((task) => task.status === "active")
+            .map((task) => task.id);
+    }
     getStateRevision() { return this.#state().revision; }
     getTask(id) { return optional(this.#state().tasks[id]?.task); }
     readNextActionFacts(taskId) {
@@ -592,12 +601,21 @@ export class FileTaskStore {
             .find((job) => job.idempotencyKey === key);
         return optional(found);
     }
-    listAllDurableJobs() {
+    listActiveDurableJobs() {
+        // The file rollback backend has no secondary indexes, so it filters its
+        // already-loaded aggregate here. Layout-7 Controller hot paths use the
+        // SQLite implementation below, whose status index avoids this history
+        // scan; the return contract and ordering stay identical across backends.
         const all = [];
         for (const aggregate of Object.values(this.#state().tasks)) {
-            all.push(...Object.values(aggregate.durableJobs));
+            for (const job of Object.values(aggregate.durableJobs)) {
+                if (job.status === "queued" || job.status === "running")
+                    all.push(job);
+            }
         }
-        return all.map((job) => clone(job));
+        return all
+            .map((job) => clone(job))
+            .sort((left, right) => numericCompare(`${left.taskId}/${left.id}`, `${right.taskId}/${right.id}`));
     }
     hasActiveDurableJobs() {
         for (const aggregate of Object.values(this.#state().tasks)) {
@@ -732,6 +750,56 @@ export class FileTaskStore {
     listRoleSessionSets(taskId) {
         return values(this.#requireTask(taskId).roleSessionSets, (set) => set.owner.roleName);
     }
+    listRuntimeSessionCandidates(query = {}) {
+        const state = this.#state();
+        const selectedTaskIds = query.taskIds === undefined
+            ? undefined
+            : [...new Set(query.taskIds)].sort(numericCompare);
+        const taskAggregates = query.scope === "global"
+            ? []
+            : selectedTaskIds === undefined
+                ? Object.values(state.tasks)
+                : selectedTaskIds.flatMap((taskId) => {
+                    const aggregate = state.tasks[taskId];
+                    return aggregate === undefined ? [] : [aggregate];
+                });
+        const candidates = [
+            ...taskAggregates.flatMap((task) => (Object.values(task.roleSessionSets).flatMap((sessions) => {
+                const candidate = projectRuntimeSessionCandidate(sessions);
+                return candidate === null ? [] : [candidate];
+            }))),
+            ...(query.scope === "task" || selectedTaskIds !== undefined
+                ? []
+                : Object.values(state.globalRoleSessionSets).flatMap((sessions) => {
+                    const candidate = projectRuntimeSessionCandidate(sessions);
+                    return candidate === null ? [] : [candidate];
+                }))
+        ];
+        return candidates
+            .filter((candidate) => !query.cleanupRequiredOnly || candidate.cleanupRequired)
+            .sort(compareRuntimeSessionCandidates);
+    }
+    listPendingRuntimeTurnCompletions(taskIds) {
+        const selectedTaskIds = taskIds === undefined
+            ? undefined
+            : [...new Set(taskIds)].sort(numericCompare);
+        if (selectedTaskIds?.length === 0)
+            return [];
+        const taskAggregates = selectedTaskIds === undefined
+            ? Object.values(this.#state().tasks)
+            : selectedTaskIds.flatMap((taskId) => {
+                const aggregate = this.#state().tasks[taskId];
+                return aggregate === undefined ? [] : [aggregate];
+            });
+        return taskAggregates.flatMap((aggregate) => (Object.values(aggregate.roleSessionSets).flatMap((sessions) => {
+            const pending = sessions.pendingTurnCompletion;
+            return pending === null || pending === undefined
+                ? []
+                : [validatePendingTurnCompletion(pending)];
+        }))).sort((left, right) => (numericCompare(left.taskId, right.taskId)
+            || numericCompare(left.roleName, right.roleName)
+            || numericCompare(left.runId, right.runId)));
+    }
     saveRoleSessionSet(sessions) {
         const stored = taskSessions(sessions);
         const taskId = stored.owner.taskId;
@@ -836,11 +904,17 @@ export class FileTaskStore {
     }
     getAgentRun(taskId, id) { return optional(this.#state().tasks[taskId]?.agentRuns[id]); }
     listAgentRuns(taskId) { return values(this.#requireTask(taskId).agentRuns, "id"); }
-    listPendingProviderRetries() {
+    listPendingProviderRetries(taskIds) {
         // The legacy File store can answer the empty case without a scan fallback.
         // If durable retry state exists, the db-only capability must fail closed
         // instead of silently losing the Controller's wake deadline.
-        for (const task of this.listTasks()) {
+        const tasks = taskIds === undefined
+            ? this.listTasks()
+            : [...new Set(taskIds)].sort(numericCompare).flatMap((taskId) => {
+                const task = this.getTask(taskId);
+                return task === null ? [] : [task];
+            });
+        for (const task of tasks) {
             if (task.status !== "active")
                 continue;
             for (const run of this.listAgentRuns(task.id)) {
@@ -1104,6 +1178,21 @@ export class FileTaskStore {
     listInputRequests(taskId) {
         return values(this.#requireTask(taskId).inputRequests, "id");
     }
+    listOpenInputRequests(taskIds) {
+        const state = this.#state();
+        const selected = taskIds === undefined
+            ? Object.values(state.tasks)
+            : [...new Set(taskIds)].sort(numericCompare).flatMap((taskId) => {
+                const aggregate = state.tasks[taskId];
+                return aggregate === undefined ? [] : [aggregate];
+            });
+        return selected
+            .flatMap((aggregate) => Object.values(aggregate.inputRequests))
+            .filter((request) => request.status === "open")
+            .map(clone)
+            .sort((left, right) => (numericCompare(left.taskId, right.taskId)
+            || numericCompare(left.id, right.id)));
+    }
     listAllInputRequests() {
         return Object.values(this.#state().tasks)
             .flatMap((aggregate) => Object.values(aggregate.inputRequests).map(clone))
@@ -1390,6 +1479,15 @@ export class FileTaskStore {
             .sort(([left], [right]) => left.localeCompare(right))
             .map(([, mailbox]) => clone(mailbox));
     }
+    listReadyWorkMailboxes() {
+        // The file rollback backend has no secondary indexes. It filters the
+        // in-memory aggregate while preserving the indexed SQLite contract's
+        // target-key order; production layout 7 uses the bounded SQLite query.
+        return Object.entries(this.#state().mailboxes)
+            .filter(([, mailbox]) => mailbox.processing !== null || mailbox.pending !== null)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([, mailbox]) => clone(mailbox));
+    }
     saveWorkMailbox(value) {
         let mailbox;
         try {
@@ -1410,7 +1508,7 @@ export class FileTaskStore {
         return pendingWakeupProjection(this.getWorkMailbox({ kind: "role", taskId, roleName: "leader" }));
     }
     listPendingWakeups() {
-        return this.listWorkMailboxes()
+        return this.listReadyWorkMailboxes()
             .flatMap((mailbox) => {
             const wakeup = pendingWakeupProjection(mailbox);
             return wakeup === null ? [] : [wakeup];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,