@wjarka/cezarion 0.14.9-dev.1020 → 0.14.9-dev.1027

package/dist/workflows/run.d.ts

@@ -330,6 +330,8 @@ export declare class RunManager {
     private readonly workerWaitTimers;
     private readonly inboxClaimTimers;
     private reconcilingWorkers;
+    private reconcilingFamily;
+    private readonly pendingReconciliations;
     private recovering;
     /** Quiet window before unread input is resubmitted or left unconfirmed (#505). */
     private readonly unreadInputGraceMs;
@@ -880,7 +882,8 @@ export declare class RunManager {
     /** Request deadlines share the existing reconciliation timer registry, never a polling loop. */
     private reconcileConversations;
     /** Authority and wait live on disk; these collections are admission/timer caches only. */
-    reconcileWorkerWaits(): void;
+    reconcileWorkerWaits(familyRootId?: string): void;
+    private reconcileWorkerFamily;
     queueWorkerWake(parentId: string): void;
     /** Shared turn-end path; asks win, worker waits precede DONE/monitoring/nudges. */
     private parkWorkerWait;

package/dist/workflows/run.js

@@ -814,19 +814,24 @@ export class RunManager {
     workerWaitTimers = new Map();
     inboxClaimTimers = new Map();
     reconcilingWorkers = false;
+    reconcilingFamily;
+    pendingReconciliations = new Set();
     recovering = false;
     /** Quiet window before unread input is resubmitted or left unconfirmed (#505). */
     unreadInputGraceMs;
     disposed = false;
-    onDelegationRun = (run) => {
+    onDelegationRun = (run, source) => {
         if (!this.disposed && !['queued', 'running', 'waiting'].includes(run.status))
             this.withdrawCiWait(run.id);
         if (run.delegation && !['queued', 'running', 'waiting'].includes(run.status))
             this.active.get(run.id)?.revokeDelegation?.();
-        if (this.disposed || this.recovering || this.reconcilingWorkers)
+        // Cleanup checkpoints emit terminal records too. With delegation disabled,
+        // these observations must not replay the project's conversation histories.
+        if (this.disposed || this.recovering || (source === 'delegation-checkpoint' && process.env.CEZ_DELEGATION !== '1'))
             return;
-        if (run.delegation && !['queued', 'running', 'waiting'].includes(run.status))
-            this.reconcileWorkerWaits();
+        if (run.delegation && run.delegation.role !== 'invalid' && !['queued', 'running', 'waiting'].includes(run.status)) {
+            this.reconcileWorkerWaits(run.delegation.role === 'root' ? run.id : run.delegation.parentRunId);
+        }
     };
     pendingJobs = new Map();
     /** Interrupted agent turns recovered after a process restart. Unlike an
@@ -3613,9 +3618,9 @@ export class RunManager {
         }
     }
     /** Request deadlines share the existing reconciliation timer registry, never a polling loop. */
-    reconcileConversations() {
+    reconcileConversations(family) {
         const now = new Date().toISOString();
-        for (const root of this.store.listRuns()) {
+        for (const root of family) {
             if (root.delegation?.role !== 'root' || !root.delegation.conversation)
                 continue;
             const next = reconcileConversationState(root, this.store.listRuns(), now, run => run.delegation?.role === 'worker' ? this.store.readWorkerExecution(run.id)?.phase === 'complete' : !this.isActive(run.id));
@@ -3653,13 +3658,33 @@ export class RunManager {
         }
     }
     /** Authority and wait live on disk; these collections are admission/timer caches only. */
-    reconcileWorkerWaits() {
-        if (this.disposed || this.reconcilingWorkers)
+    reconcileWorkerWaits(familyRootId) {
+        if (this.disposed)
+            return;
+        if (this.reconcilingWorkers) {
+            // The current pass already observes its own writes. A different family
+            // (or an explicit global pass) must not disappear behind the recursion guard.
+            if (this.reconcilingFamily !== undefined && this.reconcilingFamily !== familyRootId) {
+                this.pendingReconciliations.add(familyRootId);
+            }
             return;
+        }
+        this.pendingReconciliations.add(familyRootId);
+        for (const pending of this.pendingReconciliations) {
+            this.pendingReconciliations.delete(pending);
+            if (this.disposed)
+                break;
+            this.reconcileWorkerFamily(pending);
+        }
+    }
+    reconcileWorkerFamily(familyRootId) {
         this.reconcilingWorkers = true;
+        this.reconcilingFamily = familyRootId;
         try {
-            this.reconcileConversations();
-            for (const parent of this.store.listRuns()) {
+            const inFamily = (run) => familyRootId === undefined || run.id === familyRootId ||
+                (run.delegation?.role === 'worker' && run.delegation.parentRunId === familyRootId);
+            this.reconcileConversations(this.store.listRuns().filter(inFamily));
+            for (const parent of this.store.listRuns().filter(inFamily)) {
                 if (!parent.delegation || parent.delegation.role === 'invalid' || this.historyDeletionPending(parent.id))
                     continue;
                 if (parent.status === 'cancelled' && parent.delegation.role === 'root' && parent.delegation.finishRequestedAt) {
@@ -3806,6 +3831,7 @@ export class RunManager {
         }
         finally {
             this.reconcilingWorkers = false;
+            this.reconcilingFamily = undefined;
         }
     }
     queueWorkerWake(parentId) {