@wjarka/cezarion 0.14.9-dev.1009 → 0.14.9-dev.1011

package/dist/workflows/run.js

@@ -1313,7 +1313,7 @@ export class RunManager {
     }
     parkCiWait(runId, state) {
         const wait = this.store.getRun(runId)?.ciWait;
-        if (!wait || !state.session?.open || state.cancelled || state.pendingHumanAsk || this.ciWakeAdmitted.has(runId))
+        if (!wait || !state.session?.open || state.cancelled || state.pendingHumanAsk)
             return false;
         if (wait.phase === 'registered')
             this.store.commitCiWait(runId, { ...wait, phase: 'parked' });
@@ -1331,10 +1331,21 @@ export class RunManager {
     queueCiWake(runId) {
         const run = this.store.getRun(runId);
         const wait = run?.ciWait;
-        if (this.disposed || this.recovering || !run || !wait?.result || !wait.wakeId || this.ciWakeQueuedAt.has(runId) ||
-            this.ciWakeAdmitted.has(runId) || !['running', 'waiting', 'queued'].includes(run.status) || run.stopping ||
+        if (this.disposed || this.recovering || !run || !wait?.result || !wait.wakeId ||
+            !['running', 'waiting', 'queued'].includes(run.status) || run.stopping ||
             this.hasPendingHumanAsk(runId) || this.workerExecutionStopped(runId) || this.executionBlockedByRootFinish(run))
             return;
+        // Settlement ends the watcher. Keep a bounded-rate wake source until ACK,
+        // withdrawal or termination, including refusals with no runner-ready callback.
+        this.retryCiAdmission(runId);
+        if (this.ciWakeAdmitted.has(runId)) {
+            this.flushAgentInputs(runId);
+            return;
+        }
+        if (this.ciWakeQueuedAt.has(runId)) {
+            this.releaseSlot();
+            return;
+        }
         const state = this.active.get(runId);
         if (state) {
             if (!this.monitoring.has(runId) || state.atTurnBoundary !== state.session || state.pendingHumanAsk)
@@ -1581,7 +1592,9 @@ export class RunManager {
      */
     busySlots() {
         const ordinaryWaiting = this.waiting.size - this.monitoring.size;
-        const exemptMonitoring = Math.min(this.monitoring.size, this.semaphore.maxMonitoringSessions());
+        // An admitted CI wake reserves its slot while remaining visibly parked until ACK.
+        const admittedMonitoring = [...this.ciWakeAdmitted].filter(id => this.monitoring.has(id)).length;
+        const exemptMonitoring = Math.min(this.monitoring.size - admittedMonitoring, this.semaphore.maxMonitoringSessions());
         return this.active.size + this.starting.size - ordinaryWaiting - exemptMonitoring - this.workerWaiting.size;
     }
     /** Epoch ms of this manager's oldest queued run (the semaphore's fairness
@@ -1673,7 +1686,7 @@ export class RunManager {
                 const defaultRunner = anyHold ? (await loadConfig(this.repoRoot)).defaultRunner : undefined;
                 // Removing one monitor above the exemption cap needs no new slot: it already holds one.
                 const chargedCiWake = (id) => this.ciWakeQueuedAt.has(id) && this.monitoring.has(id) &&
-                    this.monitoring.size > this.semaphore.maxMonitoringSessions();
+                    this.monitoring.size - [...this.ciWakeAdmitted].filter(id => this.monitoring.has(id)).length > this.semaphore.maxMonitoringSessions();
                 while (this.queue.length > 0) {
                     // FIFO among the runs that CAN start; a held one keeps its place in the queue rather
                     // than being dequeued and re-queued (which would churn its position and its record).
@@ -1717,10 +1730,16 @@ export class RunManager {
                         const state = this.active.get(runId);
                         if (!state.pendingHumanAsk && this.store.getRun(runId)?.ciWait?.result && state.atTurnBoundary === state.session) {
                             this.ciWakeAdmitted.add(runId);
-                            this.waiting.delete(runId);
-                            this.monitoring.delete(runId);
                             this.flushAgentInputs(runId);
                         }
+                        else if (this.store.getRun(runId)?.ciWait?.result) {
+                            // The runner may lose its boundary between queueing and admission.
+                            // Retain the wake, but do not spin on it in this pump pass.
+                            this.ciWakeQueuedAt.set(runId, Date.now());
+                            this.queue.push(runId);
+                            this.retryCiAdmission(runId);
+                            break;
+                        }
                         continue;
                     }
                     if (this.ciWakeQueuedAt.delete(runId))
@@ -4208,6 +4227,13 @@ export class RunManager {
                             throw new Error('CI observation must be delivered separately');
                         this.store.commitCiWaitDelivery(runId, ciWakeId);
                         this.ciWakeAdmitted.delete(runId);
+                        const retry = this.ciRetries.get(runId);
+                        if (retry)
+                            clearTimeout(retry);
+                        this.ciRetries.delete(runId);
+                        this.waiting.delete(runId);
+                        this.monitoring.delete(runId);
+                        this.store.updateRun(runId, { status: 'running', activity: undefined });
                     }
                     else {
                         const deliveredAt = new Date().toISOString();
@@ -4376,6 +4402,10 @@ export class RunManager {
         this.workerWaiting.delete(runId);
         this.clearIdleTimer(state);
         this.clearMonitoringWakeTimer(state, runId);
+        // A CI command can emit activity before its transport ACK. Keep its park
+        // until the durable delivery checkpoint; admission already reserves capacity.
+        if (this.store.getRun(runId)?.ciWait && this.ciWakeAdmitted.has(runId))
+            return;
         this.waiting.delete(runId);
         this.monitoring.delete(runId);
         this.store.updateRun(runId, { status: 'running', activity: undefined });