@zq-silk/yui 0.6.4 → 0.6.6

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -282,6 +282,9 @@ export class FileSchedulerStoreAdapter {
         return { timeZone: this.store.getConfig().timeZone };
     }
     listTasks() { return this.store.listTasks(); }
+    listActiveTaskIds() {
+        return [...this.store.listActiveTaskIds()].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
+    }
     getTask(taskId) { return this.store.getTask(taskId); }
     getTaskWorkspace(taskId) { return this.store.getTaskWorkspace(taskId); }
     getTaskBrief(taskId) { return this.store.getTaskBrief(taskId); }
@@ -298,10 +301,10 @@ export class FileSchedulerStoreAdapter {
         return this.store.getActiveAgentRun(taskId, roleName);
     }
     hasOpenInputRequest(taskId) {
-        return this.store.listInputRequests(taskId).some((request) => request.status === "open");
+        return this.store.listOpenInputRequests([taskId]).length > 0;
     }
-    listOpenInputRequests() {
-        return this.store.listAllInputRequests().filter((request) => request.status === "open");
+    listOpenInputRequests(taskIds) {
+        return this.store.listOpenInputRequests(taskIds);
     }
     getInputRequest(taskId, inputRequestId) {
         return this.store.getInputRequest(taskId, inputRequestId);
@@ -321,10 +324,11 @@ export class FileSchedulerStoreAdapter {
     }
     resolveExpiredInputRecommendations(now, taskIds) {
         return this.store.transaction((store) => {
-            const expired = store.listAllInputRequests().filter((request) => (request.status === "open"
-                && request.policy.kind === "recommended"
-                && Date.parse(request.policy.timeoutAt) <= now.getTime()
-                && (taskIds === undefined || taskIds.has(request.taskId))));
+            const selectedTaskIds = taskIds === undefined
+                ? undefined
+                : [...taskIds].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
+            const expired = store.listOpenInputRequests(selectedTaskIds).filter((request) => (request.policy.kind === "recommended"
+                && Date.parse(request.policy.timeoutAt) <= now.getTime()));
             const resolved = [];
             for (const request of expired) {
                 const task = store.getTask(request.taskId);
@@ -513,6 +517,7 @@ export class FileSchedulerStoreAdapter {
     }
     getWorkMailbox(target) { return this.store.getWorkMailbox(target); }
     listWorkMailboxes() { return this.store.listWorkMailboxes(); }
+    listReadyWorkMailboxes() { return this.store.listReadyWorkMailboxes(); }
     queueTaskProgress(taskId, reason, now) {
         this.store.transaction((store) => {
             enqueueWork(store, { kind: "task", taskId }, reason, now, [
@@ -523,8 +528,8 @@ export class FileSchedulerStoreAdapter {
     enqueueLeaderWakeup(taskId, reason, now) {
         return this.store.transaction((store) => (queueLeaderWakeup(store, taskId, reason, now)));
     }
-    listAllDurableJobs() {
-        return this.store.listAllDurableJobs();
+    listActiveDurableJobs() {
+        return this.store.listActiveDurableJobs();
     }
     /**
      * Apply one durable-job transition and, in the SAME transaction, enqueue
@@ -647,38 +652,24 @@ export class FileSchedulerStoreAdapter {
         });
     }
     listDormantRuntimeOwners() {
-        const taskOwners = this.store.listTasks().flatMap((task) => (this.store.listRoleSessionSets(task.id).flatMap((sessions) => {
-            const active = sessions.sessions[sessions.activeAgentId];
-            return active !== undefined
-                && active.status !== "stopped"
-                && !hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(sessions.owner)))
-                && this.store.getActiveAgentRun(task.id, sessions.owner.roleName) === null
-                ? [{
-                        owner: sessions.owner,
-                        agentId: active.agentId,
-                        adapterId: active.adapterId,
-                        nativeSessionId: active.nativeSessionId,
-                        ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
-                        sessionUpdatedAt: active.updatedAt
-                    }]
-                : [];
-        })));
-        const globalOwners = this.store.listGlobalRoleSessionSets().flatMap((sessions) => {
-            const active = sessions.sessions[sessions.activeAgentId];
-            return active !== undefined
-                && active.status !== "stopped"
-                && !hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(sessions.owner)))
-                ? [{
-                        owner: sessions.owner,
-                        agentId: active.agentId,
-                        adapterId: active.adapterId,
-                        nativeSessionId: active.nativeSessionId,
-                        ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
-                        sessionUpdatedAt: active.updatedAt
-                    }]
-                : [];
+        return this.listRuntimeSessionCandidates().flatMap((candidate) => {
+            if (hasRuntimeLifecycleWork(this.store.getWorkMailbox(runtimeLifecycleTarget(candidate.owner)))
+                || (candidate.owner.scope === "task"
+                    && this.store.getActiveAgentRun(candidate.owner.taskId, candidate.owner.roleName) !== null)) {
+                return [];
+            }
+            return [{
+                    owner: candidate.owner,
+                    agentId: candidate.agentId,
+                    adapterId: candidate.adapterId,
+                    nativeSessionId: candidate.nativeSessionId,
+                    ...(candidate.launchId === undefined ? {} : { launchId: candidate.launchId }),
+                    sessionUpdatedAt: candidate.sessionUpdatedAt
+                }];
         });
-        return [...taskOwners, ...globalOwners];
+    }
+    listRuntimeSessionCandidates(query = {}) {
+        return this.store.listRuntimeSessionCandidates(query);
     }
     markRuntimeOwnerStopped(candidate, now) {
         return this.store.transaction((store) => {
@@ -755,6 +746,10 @@ export class FileSchedulerStoreAdapter {
                 owner: "controller",
                 startedAt: input.now.toISOString()
             }), batchId, { type: "run", taskId: input.task.id, id: input.run.id });
+            // SQLite stores the durable Run row and its active pointer separately;
+            // FileTaskStore happens to persist both from saveActiveAgentRun. Keep
+            // the adapter contract backend-neutral and make the two writes atomic.
+            store.saveAgentRun(input.run);
             store.saveActiveAgentRun(input.run);
             store.saveWorkMailbox(claimed);
             store.saveRole(input.task.id, updateRoleStatus(role, "running", input.now));
@@ -1380,7 +1375,9 @@ export class FileSchedulerStoreAdapter {
                 nativeSessionId: input.nativeSessionId,
                 ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
                 policy: "fixed",
-                status: sessions.inFlight === null ? idleStatus : "running",
+                status: idleStatus === "stopped" || idleStatus === "broken"
+                    ? idleStatus
+                    : sessions.inFlight === null ? idleStatus : "running",
                 effective
             }, now);
             if (sessions.inFlight === null) {
@@ -1416,7 +1413,10 @@ export class FileSchedulerStoreAdapter {
                     runId: fence.runId,
                     turnId: input.turnId
                 }, now);
-                sessions = updateRoleAgentSessionStatus(sessions, input.agentId, "ready", now);
+                const settledStatus = sessions.sessions[input.agentId]?.status;
+                if (settledStatus !== "stopped" && settledStatus !== "broken") {
+                    sessions = updateRoleAgentSessionStatus(sessions, input.agentId, "ready", now);
+                }
                 store.saveTaskRoleSessionSet(sessions);
                 completeRuntimeHookReservation(store, owner, input.launchId);
                 return { session: sessions.sessions[input.agentId], duplicate: false };
@@ -1430,13 +1430,15 @@ export class FileSchedulerStoreAdapter {
             };
         });
     }
-    listPendingRuntimeTurnCompletions() {
-        return this.store.listTasks().flatMap((task) => (this.store.listRoleSessionSets(task.id).flatMap((sessions) => (sessions.pendingTurnCompletion === null ? [] : [sessions.pendingTurnCompletion]))));
+    listPendingRuntimeTurnCompletions(taskIds) {
+        return this.store.listPendingRuntimeTurnCompletions(taskIds);
     }
     /** Resolves only completions whose grace deadline has elapsed. */
     resolveDueRuntimeTurnCompletions(now, taskIds) {
-        const due = this.listPendingRuntimeTurnCompletions().filter((completion) => (Date.parse(completion.dueAt) <= now.getTime()
-            && (taskIds === undefined || taskIds.has(completion.taskId))));
+        const selectedTaskIds = taskIds === undefined
+            ? undefined
+            : [...taskIds].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
+        const due = this.listPendingRuntimeTurnCompletions(selectedTaskIds).filter((completion) => Date.parse(completion.dueAt) <= now.getTime());
         const finalized = [];
         for (const completion of due) {
             this.store.transaction((store) => {
@@ -1472,7 +1474,10 @@ export class FileSchedulerStoreAdapter {
                     runId: completion.runId,
                     turnId: completion.turnId
                 }, now);
-                settled = updateRoleAgentSessionStatus(settled, completion.agentId, "ready", now);
+                const settledStatus = settled.sessions[completion.agentId]?.status;
+                if (settledStatus !== "stopped" && settledStatus !== "broken") {
+                    settled = updateRoleAgentSessionStatus(settled, completion.agentId, "ready", now);
+                }
                 store.saveTaskRoleSessionSet(settled);
             });
         }
@@ -1506,6 +1511,8 @@ export class FileSchedulerStoreAdapter {
                 throw new Error("Runtime turn completion does not match the effective launch identity.");
             }
             const sessions = effectiveExisting?.status === "ready"
+                || effectiveExisting?.status === "stopped"
+                || effectiveExisting?.status === "broken"
                 ? current
                 : recordRoleAgentSession(current, {
                     agentId: input.agentId,
@@ -1816,8 +1823,8 @@ export class FileSchedulerStoreAdapter {
      * due. The Controller arms its deadline timer from this projection, so a
      * Controller restart resumes the same attempt lineage.
      */
-    listPendingProviderRetries() {
-        return this.store.listPendingProviderRetries();
+    listPendingProviderRetries(taskIds) {
+        return this.store.listPendingProviderRetries(taskIds);
     }
     /**
      * Issue 04: reopens each due retry on its original Native Session. A Run
@@ -1826,8 +1833,10 @@ export class FileSchedulerStoreAdapter {
      * re-pushes the exact same input in the same pass.
      */
     resolveDueProviderRetries(now, taskIds) {
-        const due = this.listPendingProviderRetries().filter((entry) => (Date.parse(entry.nextAttemptAt) <= now.getTime()
-            && (taskIds === undefined || taskIds.has(entry.taskId))));
+        const selectedTaskIds = taskIds === undefined
+            ? undefined
+            : [...taskIds].sort((left, right) => (left.localeCompare(right, undefined, { numeric: true })));
+        const due = this.listPendingProviderRetries(selectedTaskIds).filter((entry) => Date.parse(entry.nextAttemptAt) <= now.getTime());
         const reopened = [];
         for (const entry of due) {
             this.store.transaction((store) => {

package/dist/controller/jobSupervisor.js

@@ -3,13 +3,12 @@
  *
  * The supervisor is pure logic over injected ports. It is invoked from the
  * Controller scheduler pass and on Controller startup. Each pass reconciles
- * every job toward its correct state:
+ * only jobs that can still change under supervision:
  *
  *  queued  -> write spec, spawn detached runner, transition to running
  *  running -> harvest exit.json / liveness via pid+startIdentity /
  *             evidence ladder (exit.json -> checkpoint -> unknown) /
  *             stale heartbeat SIGTERM then SIGKILL escalation
- *  terminal + !wakeupNotified -> set flag + enqueue Leader wakeup
  *  cancelRequestedAt -> write cancel fence + SIGTERM
  */
 import { spawn } from "node:child_process";
@@ -41,7 +40,7 @@ export class DurableJobSupervisor {
         this.#onError = options.onError ?? (() => undefined);
     }
     reconcile(now) {
-        const jobs = this.#store.listAllDurableJobs();
+        const jobs = this.#store.listActiveDurableJobs();
         for (const job of jobs) {
             try {
                 this.#reconcileJob(job, now);
@@ -62,9 +61,6 @@ export class DurableJobSupervisor {
             this.#superviseRunning(job, now);
             return;
         }
-        if (isDurableJobTerminal(job.status) && job.wakeupNotified !== true) {
-            this.#notifyWakeup(job, now);
-        }
     }
     /** Composite key for the SIGKILL deadline map. */
     #sigkillKey(job) {
@@ -335,16 +331,6 @@ export class DurableJobSupervisor {
             outcome: job.result?.outcome ?? job.status
         });
     }
-    /**
-     * Recovery fallback for terminal jobs that reached their terminal state
-     * before the atomic wakeup composition existed (or whose wakeup was lost).
-     * The normal path (#harvestExit / #handleDeadProcess) already composes
-     * complete + wakeupNotified + enqueue in one transaction; this pass only
-     * fires for jobs that somehow slipped through without wakeupNotified.
-     */
-    #notifyWakeup(job, now) {
-        this.#store.transitionDurableJob(job.taskId, job.id, (current) => markDurableJobWakeupNotified(current, now), now, { reason: "job-finished", refs: wakeupRefs(job) });
-    }
 }
 function wakeupRefs(job) {
     const refs = [{ type: "task", id: job.taskId }];

package/dist/controller/resourceInventoryLinux.js

@@ -574,7 +574,9 @@ function loadHomeState(home, warnings, options) {
     }
     try {
         const store = (options.openCompatibleStore ?? openCompatibleFileTaskStore)(home);
-        const roles = store.listGlobalRoles().map((role) => {
+        const roles = [...store.listGlobalRoles()]
+            .sort((left, right) => numericCompare(left.name, right.name))
+            .map((role) => {
             const session = activeLiveRoleAgentSession(store.getGlobalRoleSessionSet(role.name));
             const binding = role.agentBindings[role.activeAgentId];
             const agentId = session?.effective.agentId ?? role.activeAgentId;
@@ -588,25 +590,73 @@ function loadHomeState(home, warnings, options) {
                 ...(session?.launchId === undefined ? {} : { launchId: session.launchId })
             };
         });
-        for (const task of store.listTasks()) {
-            for (const role of store.listRoles(task.id)) {
-                const session = activeLiveRoleAgentSession(store.getRoleSessionSet(task.id, role.name));
-                const binding = role.agentBindings[role.activeAgentId];
-                const run = store.getActiveAgentRun(task.id, role.name);
-                const agentId = session?.effective.agentId ?? role.activeAgentId;
-                const adapterId = session?.effective.adapterId ?? binding?.adapterId;
-                roles.push({
-                    ownerKind: "task-role",
-                    taskId: task.id,
-                    taskTitle: task.title,
-                    taskStatus: task.status,
-                    roleName: role.name,
-                    agentId,
-                    ...(adapterId === undefined ? {} : { adapterId }),
-                    ...(session === null ? {} : { nativeSessionId: session.nativeSessionId }),
-                    ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
-                    ...(run === null ? {} : { runId: run.id })
-                });
+        const appendTaskRole = (task, role) => {
+            const session = activeLiveRoleAgentSession(store.getRoleSessionSet(task.id, role.name));
+            const binding = role.agentBindings[role.activeAgentId];
+            const run = store.getActiveAgentRun(task.id, role.name);
+            const agentId = session?.effective.agentId ?? role.activeAgentId;
+            const adapterId = session?.effective.adapterId ?? binding?.adapterId;
+            roles.push({
+                ownerKind: "task-role",
+                taskId: task.id,
+                taskTitle: task.title,
+                taskStatus: task.status,
+                roleName: role.name,
+                agentId,
+                ...(adapterId === undefined ? {} : { adapterId }),
+                ...(session === null ? {} : { nativeSessionId: session.nativeSessionId }),
+                ...(session?.launchId === undefined ? {} : { launchId: session.launchId }),
+                ...(run === null ? {} : { runId: run.id })
+            });
+        };
+        // Layout-7 SQLite owns bounded active-Task and current-Session indexes.
+        // Use those indexes only as selectors, then point-read the authoritative
+        // Task/Role/Session/Run records so an index row cannot bypass ownership
+        // fences. The legacy File store intentionally retains its complete
+        // listTasks fallback because it has no equivalent active selector.
+        const hotStore = store;
+        const indexedTaskIds = hotStore.listActiveTaskIds === undefined
+            ? undefined
+            : [...new Set(hotStore.listActiveTaskIds())].sort(numericCompare);
+        if (indexedTaskIds === undefined) {
+            for (const task of store.listTasks()) {
+                for (const role of [...store.listRoles(task.id)].sort((left, right) => (numericCompare(left.name, right.name)))) {
+                    appendTaskRole(task, role);
+                }
+            }
+        }
+        else {
+            const sessionCandidates = typeof store.listRuntimeSessionCandidates === "function"
+                ? store.listRuntimeSessionCandidates({ scope: "task" })
+                : [];
+            const candidateRoles = new Map();
+            for (const candidate of sessionCandidates) {
+                if (candidate.owner.scope !== "task")
+                    continue;
+                const roleNames = candidateRoles.get(candidate.owner.taskId) ?? new Set();
+                roleNames.add(candidate.owner.roleName);
+                candidateRoles.set(candidate.owner.taskId, roleNames);
+            }
+            const activeTaskSet = new Set(indexedTaskIds);
+            const taskIds = [...new Set([
+                    ...indexedTaskIds,
+                    ...candidateRoles.keys()
+                ])].sort(numericCompare);
+            for (const taskId of taskIds) {
+                const task = store.getTask(taskId);
+                if (task === null)
+                    continue;
+                const rolesForTask = activeTaskSet.has(taskId) && task.status === "active"
+                    ? store.listRoles(taskId)
+                    : [...(candidateRoles.get(taskId) ?? [])]
+                        .sort(numericCompare)
+                        .flatMap((roleName) => {
+                        const role = store.getRole(taskId, roleName);
+                        return role === null ? [] : [role];
+                    });
+                for (const role of [...rolesForTask].sort((left, right) => (numericCompare(left.name, right.name)))) {
+                    appendTaskRole(task, role);
+                }
             }
         }
         return { storageStatus: schema.status, roles };
@@ -616,6 +666,9 @@ function loadHomeState(home, warnings, options) {
         return { storageStatus: "invalid", roles: [] };
     }
 }
+function numericCompare(left, right) {
+    return left.localeCompare(right, undefined, { numeric: true });
+}
 function inspectHomePanes(home, environment, warnings) {
     try {
         const executor = new NodeCommandExecutor();

package/dist/controller/runtime.js

@@ -373,6 +373,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         intervalMs: options.intervalMs
             ?? reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds),
         signalWindowMs: options.signalWindowMs,
+        taskConcurrency: options.taskConcurrency,
         deliveryRetryMs: options.deliveryRetryMs,
         deliveryRetryLimit: options.deliveryRetryLimit,
         now: options.now,