ptbk 0.119.0-67 → 0.119.0-70

package/dist/engine/agenda.d.ts

@@ -870,6 +870,8 @@ export declare class Agenda {
      * concurrent units; the loop never waits for one of them.
      */
     private iteration;
+    /** Waits for scheduled work or an internal retry after the current evaluation has finished. */
+    private waitForNextWork;
     /** Whether the last loop wait was skipped by the operator. */
     private waiterSkipped;
     /**

package/dist/engine/agenda.js

@@ -1031,15 +1031,19 @@ export class Agenda {
     }
     /** Tells waiting chats about finished work, once each, also after a restart. */
     async deliverTaskNotifications() {
-        const waiting = this.taskControlStore.waiting();
+        // An active writer's source may be incomplete, or carry a completion stamp its check can still reject.
+        const waiting = this.taskControlStore.waiting().filter((notification) => !this.ownership.ownerOf(notification.source));
         if (!waiting.length)
             return;
         const { tasks } = await this.readQueue();
         for (const notification of waiting) {
+            // A run can acquire the source while the asynchronous queue scan is in progress.
+            if (this.ownership.ownerOf(notification.source))
+                continue;
             const task = tasks.find((candidate) => candidate.source.relativePath === notification.source);
             const result = this.recentResults.find((candidate) => nameKey(candidate.title) === nameKey(notification.task));
             const outcome = !task
-                ? 'its task no longer exists'
+                ? 'no longer exists'
                 : task.cycle > notification.cycle || task.status === 'done'
                     ? `is done${result?.summary ? `: ${result.summary}` : ''}${result?.commit ? ` (result commit ${result.commit.slice(0, 8)})` : ''}`
                     : task.status === 'cancelled'
@@ -2992,12 +2996,18 @@ export class Agenda {
             await this.runEngineUpdate();
             return;
         }
+        await this.waitForNextWork(evaluated);
+    }
+    /** Waits for scheduled work or an internal retry after the current evaluation has finished. */
+    async waitForNextWork(evaluated) {
+        const waitingForTools = this.tools.waiting;
         const waiting = evaluated.filter((item) => item.readiness.kind === 'waiting-until').map((item) => item.readiness.until);
-        const earliest = (times) => times.filter((until) => until > Date.now()).reduce((first, until) => (first === undefined || until < first ? until : first), undefined);
-        const nextTime = earliest([...waiting, ...(this.nextKnownTime ? [this.nextKnownTime] : [])]);
+        /** Internal deadlines can become due while evaluation runs; they still require a prompt next iteration. */
+        const earliest = (times) => times.filter(Number.isFinite).reduce((first, until) => (first === undefined || until < first ? until : first), undefined);
+        const nextTime = earliest([...waiting, ...(this.nextKnownTime ? [this.nextKnownTime] : [])].filter((until) => until > Date.now()));
         this.nextKnownTime = nextTime;
         // Internal retries (resumable runs, deferred claims, a failed brief's recheck) also wake the loop, without being
-        // presented as scheduled work.
+        // presented as scheduled work. Overdue retries must not fall through to the ten-minute idle wait.
         const wakeAt = earliest([...(nextTime ? [nextTime] : []), ...this.resumeAfter.values(), ...this.claimDeferred.values(), ...this.recoveryDue.values(), ...(this.reportRecheck ? [Date.parse(this.reportRecheck.nextAt)] : []), ...(this.updater.wakeAt() ? [this.updater.wakeAt()] : [])]);
         const blocked = evaluated.filter((item) => ['blocked', 'needs-recovery', 'failed'].includes(item.readiness.kind));
         const reason = this.executing
@@ -3010,7 +3020,7 @@ export class Agenda {
                         ? `No unfinished work. Waiting for tools: ${waitingForTools.reason}`
                         : (this.idleReason ?? 'No unfinished work.');
         this.phase = 'idle';
-        await this.wait(wakeAt ? Math.min(Math.max(1_000, wakeAt - Date.now()), IDLE_RECHECK_MS) : IDLE_RECHECK_MS, { kind: nextTime ? 'schedule' : 'idle', reason, skippable: false });
+        await this.wait(wakeAt !== undefined ? Math.min(Math.max(1_000, wakeAt - Date.now()), IDLE_RECHECK_MS) : IDLE_RECHECK_MS, { kind: nextTime ? 'schedule' : 'idle', reason, skippable: false });
     }
     /** Whether the last loop wait was skipped by the operator. */
     waiterSkipped = false;