@zq-silk/yui 0.6.4 → 0.6.6

package/dist/controller/runtimeEventProcessor.js

@@ -6,6 +6,7 @@ export class FileRuntimeEventProcessor {
     observer;
     options;
     drivers;
+    drainLaneCursor = 0;
     constructor(inbox, observer, options = {}) {
         this.inbox = inbox;
         this.observer = observer;
@@ -25,39 +26,62 @@ export class FileRuntimeEventProcessor {
         }
         const coalesced = coalesceRuntimeProgress(events);
         const maximum = positiveInteger(this.options.maxEventsPerDrain, DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN);
-        const selected = selectDrainBatch(coalesced, maximum);
+        const selection = selectDrainBatch(coalesced, maximum, this.drainLaneCursor);
+        this.drainLaneCursor = selection.nextLaneCursor;
+        const selected = selection.candidates;
+        const failedTaskIds = new Set();
         let stateTransactions = 0;
         if (selected.length > 0 && this.observer.withRuntimeEventTransaction !== undefined) {
-            try {
-                stateTransactions += 1;
-                const folded = this.observer.withRuntimeEventTransaction(() => (selected.map((candidate) => this.foldOne(candidate, now))));
-                for (const result of folded) {
-                    this.finalizeOne(result, acknowledgedEventIds, deferred, failed);
-                }
-            }
-            catch {
-                // A failed aggregate transaction commits nothing. Retry each candidate
-                // independently so one bad event cannot strand unrelated facts.
-                for (const candidate of selected) {
-                    try {
-                        stateTransactions += 1;
-                        const folded = this.observer.withRuntimeEventTransaction(() => (this.foldOne(candidate, now)));
-                        this.finalizeOne(folded, acknowledgedEventIds, deferred, failed);
+            let offset = 0;
+            while (offset < selected.length) {
+                const wave = selectTaskOrderedWave(selected, offset, failedTaskIds);
+                offset = wave.nextOffset;
+                if (wave.candidates.length === 0)
+                    continue;
+                try {
+                    stateTransactions += 1;
+                    const folded = this.observer.withRuntimeEventTransaction(() => (wave.candidates.map((candidate) => this.foldOne(candidate, now))));
+                    for (const result of folded) {
+                        const failure = this.finalizeOne(result, acknowledgedEventIds, deferred);
+                        if (failure !== undefined) {
+                            recordDrainFailure(failure, failed, failedTaskIds);
+                        }
                     }
-                    catch (candidateError) {
-                        failed.push({ eventId: candidate.event.id, error: candidateError });
+                }
+                catch {
+                    // A failed aggregate transaction commits nothing. Retry each candidate
+                    // independently so one bad event cannot strand unrelated Tasks.
+                    for (const candidate of wave.candidates) {
+                        if (isTaskCandidateBlocked(candidate.event, failedTaskIds))
+                            continue;
+                        try {
+                            stateTransactions += 1;
+                            const folded = this.observer.withRuntimeEventTransaction(() => (this.foldOne(candidate, now)));
+                            const failure = this.finalizeOne(folded, acknowledgedEventIds, deferred);
+                            if (failure !== undefined) {
+                                recordDrainFailure(failure, failed, failedTaskIds);
+                            }
+                        }
+                        catch (candidateError) {
+                            recordDrainFailure(candidateDrainFailure(candidate.event, candidateError), failed, failedTaskIds);
+                        }
                     }
                 }
             }
         }
         else {
             for (const candidate of selected) {
+                if (isTaskCandidateBlocked(candidate.event, failedTaskIds))
+                    continue;
                 try {
                     const folded = this.foldOne(candidate, now);
-                    this.finalizeOne(folded, acknowledgedEventIds, deferred, failed);
+                    const failure = this.finalizeOne(folded, acknowledgedEventIds, deferred);
+                    if (failure !== undefined) {
+                        recordDrainFailure(failure, failed, failedTaskIds);
+                    }
                 }
                 catch (error) {
-                    failed.push({ eventId: candidate.event.id, error });
+                    recordDrainFailure(candidateDrainFailure(candidate.event, error), failed, failedTaskIds);
                 }
             }
         }
@@ -117,13 +141,13 @@ export class FileRuntimeEventProcessor {
         }
         return this.observer.observeRuntimeObservation?.(event.observation, now) ?? "obsolete";
     }
-    finalizeOne(folded, acknowledged, deferred, failed) {
+    finalizeOne(folded, acknowledged, deferred) {
         const { candidate, outcome } = folded;
         try {
             if (outcome === "deferred") {
                 deferred.push(candidate.event);
                 this.acknowledge(candidate.representedEventIds.filter((id) => id !== candidate.event.id), acknowledged);
-                return;
+                return undefined;
             }
             if (folded.notifyTaskRuntime) {
                 const event = candidate.event;
@@ -158,9 +182,10 @@ export class FileRuntimeEventProcessor {
                 }
             }
             this.acknowledge(candidate.representedEventIds, acknowledged);
+            return undefined;
         }
         catch (error) {
-            failed.push({ eventId: candidate.event.id, error });
+            return candidateDrainFailure(candidate.event, error);
         }
     }
     /**
@@ -331,11 +356,62 @@ export function coalesceRuntimeProgress(events, instrumentation = {}) {
     flush();
     return result;
 }
-function selectDrainBatch(events, maximum) {
-    // A batch is always an arrival-order prefix. Drain-time coalescing bounds
-    // worker folds without allowing a later semantic fact to
-    // overtake an earlier progress fence from another Run.
-    return events.slice(0, maximum);
+function selectDrainBatch(events, maximum, laneCursor = 0) {
+    // Select one candidate per Task per round. A poison prefix from one Task
+    // therefore cannot consume the whole bounded batch before a later Task gets
+    // a chance to fold. Each lane itself remains in arrival order, preserving
+    // the same-Task semantic fence; only cross-Task order is interleaved.
+    const lanes = new Map();
+    for (const candidate of events) {
+        const key = drainLaneKey(candidate.event);
+        const lane = lanes.get(key);
+        if (lane === undefined)
+            lanes.set(key, [candidate]);
+        else
+            lane.push(candidate);
+    }
+    const laneStates = [...lanes.values()].map((candidates) => ({
+        candidates,
+        offset: 0
+    }));
+    if (laneStates.length === 0) {
+        return { candidates: [], nextLaneCursor: 0 };
+    }
+    const startLane = positiveModulo(laneCursor, laneStates.length);
+    const selected = [];
+    let lastLane = startLane;
+    while (selected.length < maximum) {
+        let progressed = false;
+        for (let laneOffset = 0; laneOffset < laneStates.length; laneOffset += 1) {
+            const laneIndex = (startLane + laneOffset) % laneStates.length;
+            const lane = laneStates[laneIndex];
+            const candidate = lane.candidates[lane.offset];
+            if (candidate === undefined)
+                continue;
+            lane.offset += 1;
+            selected.push(candidate);
+            lastLane = laneIndex;
+            progressed = true;
+            if (selected.length >= maximum)
+                break;
+        }
+        // Every non-empty lane advances its offset when selected. Keep this
+        // guard explicit so malformed/empty input cannot create a zero-progress
+        // drain loop.
+        if (!progressed)
+            break;
+    }
+    return {
+        candidates: selected,
+        nextLaneCursor: (lastLane + 1) % laneStates.length
+    };
+}
+function positiveModulo(value, modulus) {
+    return ((value % modulus) + modulus) % modulus;
+}
+function drainLaneKey(event) {
+    const taskId = candidateTaskId(event);
+    return taskId === undefined ? "global" : `task:${taskId}`;
 }
 function progressStreamKey(event) {
     const { fence, payload } = event.observation;
@@ -362,7 +438,7 @@ function emptyDrainFailure(error) {
     return {
         acknowledgedEventIds: [],
         deferred: [],
-        failed: [{ error }],
+        failed: [{ scope: "unknown", error }],
         remainingEventCount: 0,
         metrics: {
             listedEventCount: 0,
@@ -388,6 +464,64 @@ function isObsoleteRuntimeTurnObservation(value) {
         && value !== null
         && value.disposition === "obsolete";
 }
+function candidateDrainFailure(event, error) {
+    const eventId = nonEmptyString(event.id);
+    if (event.scope === "task") {
+        const taskId = nonEmptyString(event.taskId);
+        if (eventId === undefined || taskId === undefined) {
+            // A Task failure must carry a durable inbox fence. If an injected port
+            // violates that parsed-event contract, do not incorrectly isolate it.
+            return {
+                ...(eventId === undefined ? {} : { eventId }),
+                scope: "unknown",
+                error
+            };
+        }
+        return { eventId, scope: "task", taskId, error };
+    }
+    return {
+        ...(eventId === undefined ? {} : { eventId }),
+        scope: "global",
+        error
+    };
+}
+function selectTaskOrderedWave(candidates, offset, failedTaskIds) {
+    const selected = [];
+    const selectedTaskIds = new Set();
+    let nextOffset = offset;
+    while (nextOffset < candidates.length) {
+        const candidate = candidates[nextOffset];
+        const taskId = candidateTaskId(candidate.event);
+        if (taskId !== undefined && failedTaskIds.has(taskId)) {
+            nextOffset += 1;
+            continue;
+        }
+        if (taskId !== undefined && selectedTaskIds.has(taskId))
+            break;
+        selected.push(candidate);
+        if (taskId !== undefined)
+            selectedTaskIds.add(taskId);
+        nextOffset += 1;
+    }
+    return { candidates: selected, nextOffset };
+}
+function recordDrainFailure(failure, failed, failedTaskIds) {
+    failed.push(failure);
+    if (failure.scope === "task")
+        failedTaskIds.add(failure.taskId);
+}
+function isTaskCandidateBlocked(event, failedTaskIds) {
+    const taskId = candidateTaskId(event);
+    return taskId !== undefined && failedTaskIds.has(taskId);
+}
+function candidateTaskId(event) {
+    if (event.scope !== "task" || nonEmptyString(event.id) === undefined)
+        return undefined;
+    return nonEmptyString(event.taskId);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 /**
  * Build an {@link AsyncRuntimeTurnEventObserver} that forwards every fold to the
  * worker-hosted adapter via {@link AsyncObserverInvoker}. The adapter's fold
@@ -416,6 +550,7 @@ export class AsyncRuntimeEventProcessor {
     observer;
     options;
     drivers;
+    drainLaneCursor = 0;
     constructor(inbox, observer, options = {}) {
         this.inbox = inbox;
         this.observer = observer;
@@ -435,9 +570,14 @@ export class AsyncRuntimeEventProcessor {
         }
         const coalesced = coalesceRuntimeProgress(events);
         const maximum = positiveInteger(this.options.maxEventsPerDrain, DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN);
-        const selected = selectDrainBatch(coalesced, maximum);
+        const selection = selectDrainBatch(coalesced, maximum, this.drainLaneCursor);
+        this.drainLaneCursor = selection.nextLaneCursor;
+        const selected = selection.candidates;
+        const failedTaskIds = new Set();
         for (const candidate of selected) {
             const event = candidate.event;
+            if (isTaskCandidateBlocked(event, failedTaskIds))
+                continue;
             try {
                 let outcome = "applied";
                 if (event.type === "native-turn-completed") {
@@ -460,7 +600,7 @@ export class AsyncRuntimeEventProcessor {
                 this.acknowledge(candidate.representedEventIds, acknowledgedEventIds);
             }
             catch (error) {
-                failed.push({ eventId: event.id, error });
+                recordDrainFailure(candidateDrainFailure(event, error), failed, failedTaskIds);
             }
         }
         const acknowledged = new Set(acknowledgedEventIds);

package/dist/coordination/keyedWorkQueue.js

@@ -0,0 +1,189 @@
+/**
+ * A FIFO work queue that coalesces signals by key.
+ *
+ * At most one item for a key can be processing. Signals received while that
+ * key is processing mark it dirty, causing exactly one replay at the FIFO tail
+ * after the current item is done. Different keys can be leased concurrently by
+ * multiple consumers.
+ *
+ * shutdown() is graceful: it stops accepting signals but preserves all work
+ * accepted before shutdown, including dirty replays. abortPending() instead
+ * drops queued work and dirty replays while allowing leased items to finish.
+ * Consumers must complete every leased item. drain() only waits for an idle
+ * queue; it does not close the queue or process work itself.
+ */
+export class KeyedWorkQueue {
+    #states = new Map();
+    #ready = [];
+    #takeWaiters = [];
+    #drainWaiters = [];
+    #readyHead = 0;
+    #takeWaiterHead = 0;
+    #closed = false;
+    #aborted = false;
+    #closeCompletion;
+    /**
+     * Adds or coalesces a key. Returns false after either stop mode has started.
+     */
+    signal(key) {
+        if (this.#closed)
+            return false;
+        const state = this.#states.get(key);
+        if (state === undefined) {
+            this.#states.set(key, { phase: "queued" });
+            this.#ready.push(key);
+            this.#dispatchReadyWork();
+            return true;
+        }
+        if (state.phase === "processing")
+            state.dirty = true;
+        return true;
+    }
+    /**
+     * Leases the next ready key. It returns undefined after graceful shutdown
+     * has drained, or immediately after pending work has been aborted.
+     */
+    take() {
+        if (this.#aborted)
+            return Promise.resolve(undefined);
+        if (this.#hasReadyWork()) {
+            return Promise.resolve(this.#leaseReadyWork());
+        }
+        if (this.#closed && this.#states.size === 0) {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve) => {
+            this.#takeWaiters.push(resolve);
+        });
+    }
+    /**
+     * Resolves the next time no key is queued or processing. Later signals may
+     * make the queue non-idle again unless shutdown() has already started.
+     */
+    drain() {
+        if (this.#states.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this.#drainWaiters.push(resolve);
+        });
+    }
+    /**
+     * Stops accepting signals and resolves after all previously accepted work
+     * has been completed. Calling shutdown repeatedly returns the same promise.
+     */
+    shutdown() {
+        const stopped = this.#beginClose();
+        this.#settleIdleWaiters();
+        return stopped;
+    }
+    /**
+     * Stops accepting signals, drops queued keys and dirty replays, and resolves
+     * after already leased items are completed. Pending and later take() calls
+     * receive undefined. Repeated calls are idempotent.
+     */
+    abortPending() {
+        const stopped = this.#beginClose();
+        if (this.#aborted)
+            return stopped;
+        this.#aborted = true;
+        for (const [key, state] of this.#states) {
+            if (state.phase === "queued") {
+                this.#states.delete(key);
+            }
+            else {
+                state.dirty = false;
+            }
+        }
+        this.#ready.length = 0;
+        this.#readyHead = 0;
+        this.#resolveTakeWaiters();
+        this.#settleIdleWaiters();
+        return stopped;
+    }
+    #hasReadyWork() {
+        return this.#readyHead < this.#ready.length;
+    }
+    #hasTakeWaiter() {
+        return this.#takeWaiterHead < this.#takeWaiters.length;
+    }
+    #leaseReadyWork() {
+        const key = this.#ready[this.#readyHead++];
+        if (!this.#hasReadyWork()) {
+            this.#ready.length = 0;
+            this.#readyHead = 0;
+        }
+        const state = this.#states.get(key);
+        if (state?.phase !== "queued") {
+            throw new Error("Keyed work queue invariant failed: ready key was not queued.");
+        }
+        const token = Symbol("keyed-work-item");
+        this.#states.set(key, { phase: "processing", dirty: false, token });
+        let completed = false;
+        return {
+            key,
+            done: () => {
+                if (completed)
+                    throw new Error("Keyed work item was already completed.");
+                completed = true;
+                this.#complete(key, token);
+            }
+        };
+    }
+    #complete(key, token) {
+        const state = this.#states.get(key);
+        if (state?.phase !== "processing" || state.token !== token) {
+            throw new Error("Keyed work queue invariant failed: completed lease is not active.");
+        }
+        if (state.dirty && !this.#aborted) {
+            this.#states.set(key, { phase: "queued" });
+            this.#ready.push(key);
+            this.#dispatchReadyWork();
+            return;
+        }
+        this.#states.delete(key);
+        this.#settleIdleWaiters();
+    }
+    #dispatchReadyWork() {
+        while (this.#hasReadyWork() && this.#hasTakeWaiter()) {
+            const resolve = this.#takeWaiters[this.#takeWaiterHead++];
+            const item = this.#leaseReadyWork();
+            resolve(item);
+        }
+        if (!this.#hasTakeWaiter()) {
+            this.#takeWaiters.length = 0;
+            this.#takeWaiterHead = 0;
+        }
+    }
+    #settleIdleWaiters() {
+        if (this.#states.size !== 0)
+            return;
+        const drains = this.#drainWaiters.splice(0);
+        for (const resolve of drains)
+            resolve();
+        if (!this.#closed)
+            return;
+        this.#resolveTakeWaiters();
+        this.#closeCompletion?.resolve();
+    }
+    #beginClose() {
+        if (this.#closeCompletion === undefined) {
+            this.#closeCompletion = completion();
+            this.#closed = true;
+        }
+        return this.#closeCompletion.promise;
+    }
+    #resolveTakeWaiters() {
+        while (this.#hasTakeWaiter()) {
+            this.#takeWaiters[this.#takeWaiterHead++](undefined);
+        }
+        this.#takeWaiters.length = 0;
+        this.#takeWaiterHead = 0;
+    }
+}
+function completion() {
+    let resolve;
+    const promise = new Promise((done) => {
+        resolve = done;
+    });
+    return { promise, resolve };
+}

package/dist/runtime/runtimeSessionCandidate.js

@@ -0,0 +1,43 @@
+import { activeRoleAgentSession } from "../executor/agentExecutor.js";
+/** Exact completed-Task cleanup contract shared by projection writers/readers. */
+export function runtimeSessionRequiresCleanup(input) {
+    if (input.status === "stopped" || input.status === "broken")
+        return false;
+    return input.status === "running" || input.launchId !== undefined;
+}
+/** Projects only the current active Agent Session; stopped history disappears. */
+export function projectRuntimeSessionCandidate(sessions) {
+    const active = activeRoleAgentSession(sessions);
+    if (active === null || active.status === "stopped")
+        return null;
+    return {
+        owner: sessions.owner.scope === "task"
+            ? {
+                scope: "task",
+                taskId: sessions.owner.taskId,
+                roleName: sessions.owner.roleName
+            }
+            : { scope: "global", roleName: sessions.owner.roleName },
+        agentId: active.agentId,
+        adapterId: active.adapterId,
+        nativeSessionId: active.nativeSessionId,
+        ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
+        status: active.status,
+        sessionUpdatedAt: active.updatedAt,
+        cleanupRequired: runtimeSessionRequiresCleanup(active)
+    };
+}
+/** Deterministic owner order shared by all storage backends. */
+export function compareRuntimeSessionCandidates(left, right) {
+    if (left.owner.scope !== right.owner.scope) {
+        // Preserve the historical adapter contract: Task owners precede the
+        // bounded global Role set.
+        return left.owner.scope === "task" ? -1 : 1;
+    }
+    if (left.owner.scope === "task" && right.owner.scope === "task") {
+        const task = left.owner.taskId.localeCompare(right.owner.taskId, undefined, { numeric: true });
+        if (task !== 0)
+            return task;
+    }
+    return left.owner.roleName.localeCompare(right.owner.roleName, undefined, { numeric: true });
+}

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,4 +1,4 @@
-import { selectedSchedulerRoles, selectedSchedulerTasks } from "./ports.js";
+import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
 import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
@@ -11,9 +11,7 @@ import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
  */
 export async function processActiveRoleRunDeliveries(store, delivery, now, selection) {
     const results = [];
-    for (const task of selectedSchedulerTasks(store, selection)) {
-        if (task.status !== "active")
-            continue;
+    for (const task of selectedActiveSchedulerTasks(store, selection)) {
         for (const role of selectedSchedulerRoles(store, task.id, selection)) {
             const run = store.getActiveAgentRun(task.id, role.name);
             // A crash after a Leader wake is durably claimed but before tmux input

package/dist/scheduler/activeTaskProgress.js

@@ -1,4 +1,4 @@
-import { selectedSchedulerTasks, isSchedulerTaskWorkspaceReady } from "./ports.js";
+import { selectedActiveSchedulerTasks, isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { queueLeaderWakeup } from "./wakeupQueue.js";
 import { projectTaskExecution } from "./taskExecutionProjection.js";
 import { collectTaskActionability, computeActionabilityDigest, decideOrphanWake } from "./actionability.js";
@@ -17,9 +17,7 @@ import { collectTaskActionability, computeActionabilityDigest, decideOrphanWake
  */
 export function repairOrphanedActiveTasks(store, now, selection) {
     const repaired = [];
-    for (const task of selectedSchedulerTasks(store, selection)) {
-        if (task.status !== "active")
-            continue;
+    for (const task of selectedActiveSchedulerTasks(store, selection)) {
         const roles = store.listRoles(task.id);
         const activeRuns = roles.flatMap((role) => {
             const run = store.getActiveAgentRun(task.id, role.name);

package/dist/scheduler/leaderWakeupProcessor.js

@@ -11,8 +11,10 @@ import { RuntimeLaunchError } from "../runtime/ports.js";
 export async function processLeaderWakeups(store, delivery, now, selection) {
     const results = [];
     const wakeups = selection === undefined || selection.full
-        ? store.listPendingWakeups()
+        ? store.listPendingWakeups().filter((wakeup) => (!selection?.blockedTaskIds?.has(wakeup.taskId)))
         : [...selection.taskIds].flatMap((taskId) => {
+            if (selection.blockedTaskIds?.has(taskId))
+                return [];
             const wakeup = store.getPendingWakeup(taskId);
             return wakeup === null ? [] : [wakeup];
         });

package/dist/scheduler/ports.js

@@ -4,15 +4,48 @@ export function isSchedulerTaskWorkspaceReady(task, workspace) {
 }
 /** Resolves Tasks without a global scan for a dirty reconciliation pass. */
 export function selectedSchedulerTasks(store, selection) {
-    if (selection === undefined || selection.full)
-        return [...store.listTasks()];
+    if (selection === undefined || selection.full) {
+        return [...store.listTasks()].filter((task) => (!selection?.blockedTaskIds?.has(task.id)));
+    }
     return [...selection.taskIds].flatMap((taskId) => {
+        if (selection.blockedTaskIds?.has(taskId))
+            return [];
         const task = store.getTask(taskId);
         return task === null ? [] : [task];
     });
 }
+/**
+ * Resolves only active Tasks for Controller execution phases. Full passes use
+ * the durable active index, so terminal history never enters Role, delivery,
+ * workspace, or liveness projections. Dirty passes keep their exact-key
+ * semantics and simply discard a Task that is no longer active.
+ */
+export function selectedActiveSchedulerTasks(store, selection) {
+    if (selection === undefined || selection.full) {
+        const indexedTaskIds = store.listActiveTaskIds?.();
+        if (indexedTaskIds === undefined) {
+            return store.listTasks().filter((task) => (task.status === "active"
+                && !selection?.blockedTaskIds?.has(task.id)));
+        }
+        return [...indexedTaskIds].flatMap((taskId) => {
+            if (selection?.blockedTaskIds?.has(taskId))
+                return [];
+            const task = store.getTask(taskId);
+            return task?.status === "active" ? [task] : [];
+        });
+    }
+    const taskIds = selection.taskIds;
+    return [...taskIds].flatMap((taskId) => {
+        if (selection.blockedTaskIds?.has(taskId))
+            return [];
+        const task = store.getTask(taskId);
+        return task?.status === "active" ? [task] : [];
+    });
+}
 /** Resolves either every Role in a selected Task or only explicit Role keys. */
 export function selectedSchedulerRoles(store, taskId, selection) {
+    if (selection?.blockedTaskIds?.has(taskId))
+        return [];
     if (selection === undefined
         || selection.full
         || selection.allRoleTaskIds.has(taskId)) {