@wjarka/cezarion 0.14.6 → 0.14.7

package/dist/workflows/run.js

@@ -1,3 +1,5 @@
+import { ciWaitRequestSchema, ciWaitResultSchema } from '../contract/index.js';
+import { acquireCiResources } from '../ci-wait/resources.js';
 import { workerContextHash, workerWorkflowHash, workerStepIdentity, captureWorkerAccount, boundWorkerAccountEnv, WorkerIdentityError } from '../delegation/execution-identity.js';
 import { buildChildEnv } from '../core/agent-env.js';
 import { randomUUID } from 'node:crypto';
@@ -27,7 +29,7 @@ import { autosaveCommit, createWorktree, resolveBaseRef, worktreeDiff, worktreeS
 import { getHeadCommit, getRepoInfo } from '../server/git.js';
 import { ensureOwnedWorkspace, verifyOwnedWorkspace } from '../delegation/workspace.js';
 import { verifyWorkerContext } from '../delegation/context.js';
-import { enqueueAgentInput, nextAgentInput } from '../delegation/input.js';
+import { enqueueAgentInput, agentInputBatch } from '../delegation/input.js';
 import { parseDelegationEffort } from '../delegation/effort.js';
 import { DelegationPolicyError } from '../delegation/policy.js';
 import { reconcileWorkerWait } from '../delegation/wait.js';
@@ -477,6 +479,14 @@ export class RunManager {
         if (this.executions.get(runId) === execution)
             this.executions.delete(runId);
         execution.resolve();
+        if (!this.disposed) {
+            try {
+                this.queueCiWake(runId);
+            }
+            catch {
+                this.retryCiAdmission(runId);
+            }
+        }
         if (!this.disposed && this.store.getRun(runId)?.stopping)
             this.store.updateRun(runId, { stopping: undefined });
         if (!this.disposed)
@@ -572,6 +582,13 @@ export class RunManager {
     /** Durable monitoring subset. Only the configured number receives the waiting-slot exemption. */
     monitoring = new Set();
     /** Separate from human waiting: these resumes MUST reacquire scheduler capacity. */
+    ciWakeQueuedAt = new Map();
+    ciWakeAdmitted = new Set();
+    ciWatches = new Map();
+    ciRegistrations = new Map();
+    ciRetries = new Map();
+    ciResources;
+    ciSupervisor;
     workerWaiting = new Set();
     workerWakeAdmitted = new Set();
     workerWakeQueuedAt = new Map();
@@ -580,6 +597,8 @@ export class RunManager {
     recovering = false;
     disposed = false;
     onDelegationRun = (run) => {
+        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)
@@ -647,6 +666,8 @@ export class RunManager {
         this.repoRoot = repoRoot;
         this.dataDir = join(repoRoot, '.ai/cezar');
         this.semaphore = options.semaphore ?? new WorkspaceSemaphore();
+        this.ciResources = acquireCiResources(this.semaphore);
+        this.ciSupervisor = this.ciResources.supervisor;
         this.offSemaphore = this.semaphore.register({
             busySlots: () => this.busySlots(),
             pump: () => this.pump(),
@@ -672,6 +693,16 @@ export class RunManager {
      */
     dispose() {
         this.disposed = true;
+        for (const task of this.ciWatches.values())
+            task.abort.abort();
+        this.ciWatches.clear();
+        for (const task of this.ciRegistrations.values())
+            task.abort.abort();
+        this.ciRegistrations.clear();
+        for (const timer of this.ciRetries.values())
+            clearTimeout(timer);
+        this.ciRetries.clear();
+        this.ciResources.release();
         this.delegationProvisioner = undefined;
         this.finalizedWorkers.clear();
         for (const settle of this.terminationWaiters)
@@ -687,6 +718,8 @@ export class RunManager {
         this.offSemaphore();
         clearInterval(this.queueWatchdog);
         for (const [runId, state] of this.active) {
+            state.revokeCiTools?.();
+            state.revokeCiTools = undefined;
             state.revokeDelegation?.();
             state.revokeDelegation = undefined;
             this.clearIdleTimer(state);
@@ -917,6 +950,196 @@ export class RunManager {
         state.revokeDelegation = session?.revoke;
         return session;
     }
+    /** Provision the same capability and descriptor on every start, Continue and recovered launch. */
+    async provisionCiSession(runId, state) {
+        state.revokeCiTools?.();
+        state.revokeCiTools = undefined;
+        state.ciGeneration = randomUUID();
+        state.ciTurnId = randomUUID();
+        const generation = state.ciGeneration;
+        const controller = await this.ciResources.controller();
+        if (!controller || this.disposed || state.cancelled || this.active.get(runId) !== state)
+            return;
+        const provisioned = controller.provision((request, signal) => this.registerCiWait(runId, request, generation, signal));
+        state.revokeCiTools = provisioned.revoke;
+        return provisioned;
+    }
+    /** Trusted capability callbacks supply run identity; the model supplies only a PR and deadline. */
+    async registerCiWait(runId, request, generation, capabilitySignal) {
+        const parsed = ciWaitRequestSchema.parse(request);
+        const state = this.active.get(runId);
+        const authorized = () => {
+            const run = this.store.getRun(runId);
+            return !this.disposed && !capabilitySignal?.aborted && !!run && ['running', 'waiting'].includes(run.status) && !run.stopping &&
+                this.active.get(runId) === state && !!state?.session?.open && !state.cancelled && !state.finishRequested &&
+                state.ciGeneration === generation && !state.pendingHumanAsk && !this.hasUnansweredHumanAsk(runId) &&
+                !this.workerWait(runId) && !this.workerExecutionStopped(runId) && !this.executionBlockedByRootFinish(run);
+        };
+        if (!authorized() || !state)
+            throw Object.assign(new Error('Run cannot register a CI wait in its current state'), { code: 'unauthorized' });
+        const current = this.store.getRun(runId)?.ciWait;
+        if (current) {
+            if (current.prUrl.toLowerCase() === parsed.pr.replace(/\/$/, '').toLowerCase() && current.timeoutSeconds === parsed.timeout_seconds)
+                return current;
+            throw Object.assign(new Error('wait_conflict: a different CI wait is already registered'), { code: 'wait_conflict' });
+        }
+        const pending = this.ciRegistrations.get(runId);
+        if (pending) {
+            if (pending.pr === parsed.pr && pending.seconds === parsed.timeout_seconds)
+                return pending.promise;
+            throw Object.assign(new Error('wait_conflict: a different CI registration is already in progress'), { code: 'wait_conflict' });
+        }
+        const turnId = state.ciTurnId ??= randomUUID();
+        const abort = new AbortController();
+        const signal = capabilitySignal ? AbortSignal.any([abort.signal, capabilitySignal]) : abort.signal;
+        const promise = (async () => {
+            const identity = await this.ciSupervisor.resolve(parsed.pr, signal);
+            if (signal.aborted || !authorized() || state.ciTurnId !== turnId)
+                throw Object.assign(new Error('Run cannot register a CI wait after interruption'), { code: 'unauthorized' });
+            const registeredAt = new Date().toISOString();
+            const wait = { ...identity, id: randomUUID(), generation, turnId, timeoutSeconds: parsed.timeout_seconds,
+                registeredAt, deadline: new Date(Date.now() + parsed.timeout_seconds * 1000).toISOString(), phase: 'registered' };
+            try {
+                this.store.commitCiWait(runId, wait);
+            }
+            catch {
+                throw Object.assign(new Error('CI registration could not be saved; retry when storage is writable'), { code: 'persistence' });
+            }
+            this.startCiWatch(runId, wait);
+            if (state.atTurnBoundary === state.session || this.waiting.has(runId))
+                this.parkCiWait(runId, state);
+            return this.store.getRun(runId).ciWait ?? wait;
+        })();
+        this.ciRegistrations.set(runId, { abort, pr: parsed.pr, seconds: parsed.timeout_seconds, promise });
+        try {
+            return await promise;
+        }
+        finally {
+            if (this.ciRegistrations.get(runId)?.abort === abort)
+                this.ciRegistrations.delete(runId);
+        }
+    }
+    startCiWatch(runId, wait) {
+        if (this.disposed || this.ciWatches.has(runId) || wait.result)
+            return;
+        const abort = new AbortController();
+        const watch = { id: wait.id, abort };
+        this.ciWatches.set(runId, watch);
+        const current = () => !this.disposed && !abort.signal.aborted && this.ciWatches.get(runId) === watch &&
+            this.store.getRun(runId)?.ciWait?.id === wait.id;
+        const settle = (result) => {
+            if (!current())
+                return;
+            try {
+                const latest = this.store.getRun(runId)?.ciWait;
+                if (!latest || latest.id !== wait.id)
+                    return;
+                const parsed = ciWaitResultSchema.safeParse(result);
+                const validated = parsed.success ? parsed.data : { outcome: 'error', headSha: wait.headSha,
+                    observedAt: new Date().toISOString(), checks: [], totalChecks: 0, truncated: false,
+                    diagnostic: 'CI watcher returned an invalid observation; inspect the PR and register a new wait.' };
+                const settled = { ...latest, phase: 'wake-pending', result: validated, wakeId: wait.id };
+                const input = { id: wait.id, parentRunId: runId, source: 'lifecycle', createdAt: new Date().toISOString(),
+                    text: `CI wait observation ${wait.id} for ${wait.prUrl}. External data follows: ${JSON.stringify(validated)}. This observation is not merge approval or task completion. Reported checks may not include every expected workflow. Duplicate observations retain this ID.` };
+                this.store.commitCiWait(runId, settled, input);
+                this.ciWatches.delete(runId);
+                try {
+                    this.queueCiWake(runId);
+                }
+                catch {
+                    this.retryCiAdmission(runId);
+                }
+            }
+            catch {
+                // A failed durable checkpoint may not drop the accepted intent or publish a false result.
+                if (!current())
+                    return;
+                console.warn('[cez] CI wait checkpoint unavailable; retaining result for retry.');
+                const timer = setTimeout(() => { this.ciRetries.delete(runId); settle(result); }, 1000);
+                timer.unref();
+                this.ciRetries.set(runId, timer);
+            }
+        };
+        void this.ciSupervisor.watch(wait, abort.signal).then(settle, () => settle({ outcome: 'error', headSha: wait.headSha,
+            observedAt: new Date().toISOString(), checks: [], totalChecks: 0, truncated: false,
+            diagnostic: 'CI watcher unavailable; inspect the pull request and retry the wait.' }));
+    }
+    retryCiAdmission(runId) {
+        if (this.disposed || this.ciRetries.has(runId) || !this.store.getRun(runId)?.ciWait)
+            return;
+        const timer = setTimeout(() => {
+            this.ciRetries.delete(runId);
+            try {
+                this.queueCiWake(runId);
+            }
+            catch {
+                this.retryCiAdmission(runId);
+            }
+        }, 1000);
+        timer.unref();
+        this.ciRetries.set(runId, timer);
+    }
+    parkCiWait(runId, state) {
+        const wait = this.store.getRun(runId)?.ciWait;
+        if (!wait || !state.session?.open || state.cancelled || state.pendingHumanAsk || this.ciWakeAdmitted.has(runId))
+            return false;
+        if (wait.phase === 'registered')
+            this.store.commitCiWait(runId, { ...wait, phase: 'parked' });
+        this.clearIdleTimer(state);
+        this.clearMonitoringWakeTimer(state, runId);
+        this.waiting.add(runId);
+        this.monitoring.add(runId);
+        this.store.updateRun(runId, { status: 'running', activity: 'monitoring', monitoringWakeAt: undefined });
+        if (state.currentStepId)
+            this.store.updateStep(runId, state.currentStepId, { status: 'running' });
+        this.queueCiWake(runId);
+        this.releaseSlot();
+        return true;
+    }
+    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 ||
+            this.hasPendingHumanAsk(runId) || this.workerExecutionStopped(runId) || this.executionBlockedByRootFinish(run))
+            return;
+        const state = this.active.get(runId);
+        if (state) {
+            if (!this.monitoring.has(runId) || state.atTurnBoundary !== state.session || state.pendingHumanAsk)
+                return;
+            this.ciWakeQueuedAt.set(runId, Date.now());
+            if (!this.queue.includes(runId))
+                this.queue.push(runId);
+        }
+        else if (!this.isActive(runId)) {
+            // No live session: create a scheduler-owned continuation, never a direct provider call.
+            this.store.updateRun(runId, { status: 'waiting', activity: undefined });
+            const resumed = this.continueRun(runId, { text: 'Resume to receive the queued CI observation. End this opening turn so Cezar can deliver it; do not poll CI.' }, true);
+            if (!resumed.ok) {
+                this.store.appendEvent(runId, { type: 'note', message: `CI result retained; continuation unavailable: ${resumed.error ?? 'unknown'}` });
+                return;
+            }
+            this.ciWakeQueuedAt.set(runId, Date.now());
+        }
+        this.releaseSlot();
+    }
+    withdrawCiWait(runId, message) {
+        this.ciRegistrations.get(runId)?.abort.abort();
+        this.ciRegistrations.delete(runId);
+        this.store.commitCiWaitWithdrawal(runId, message);
+        this.ciWatches.get(runId)?.abort.abort();
+        this.ciWatches.delete(runId);
+        const timer = this.ciRetries.get(runId);
+        if (timer)
+            clearTimeout(timer);
+        this.ciRetries.delete(runId);
+        if (this.ciWakeQueuedAt.delete(runId) && this.active.has(runId)) {
+            const index = this.queue.indexOf(runId);
+            if (index >= 0)
+                this.queue.splice(index, 1);
+        }
+        this.ciWakeAdmitted.delete(runId);
+    }
     /** Snapshot of the actual active session, never guessed from partial run settings. */
     delegationExecutionSettings(runId) {
         const state = this.active.get(runId);
@@ -1117,7 +1340,7 @@ export class RunManager {
         const head = this.queue[0];
         if (!head)
             return null;
-        const wakeQueuedAt = this.workerWakeQueuedAt.get(head);
+        const wakeQueuedAt = this.workerWakeQueuedAt.get(head) ?? this.ciWakeQueuedAt.get(head);
         if (wakeQueuedAt !== undefined)
             return wakeQueuedAt;
         const createdAt = this.store.getRun(head)?.createdAt;
@@ -1196,13 +1419,16 @@ export class RunManager {
                 // Only pay for the config read when something is actually held: a queued record may name
                 // no runner, and then the account it would use is the configured default.
                 const defaultRunner = anyHold ? (await loadConfig(this.repoRoot)).defaultRunner : undefined;
-                while (this.queue.length > 0 && capacity()) {
+                // 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();
+                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).
                     const next = this.queue.findIndex((id) => {
                         const queued = this.store.getRun(id);
-                        return !queued || this.historyDeletionPending(id) || ((!this.executions.get(id)?.admitted || this.active.has(id)) && !this.executionBlockedByRootFinish(queued) &&
-                            (!anyHold || !accountHeldFor(queued, holds, defaultRunner ?? 'claude')));
+                        return (capacity() || chargedCiWake(id)) && (!queued || this.historyDeletionPending(id) || ((!this.executions.get(id)?.admitted || this.active.has(id)) && !this.executionBlockedByRootFinish(queued) &&
+                            (!anyHold || !accountHeldFor(queued, holds, defaultRunner ?? 'claude'))));
                     });
                     if (next === -1)
                         break; // every queued run has a durable reason to remain held
@@ -1226,6 +1452,19 @@ export class RunManager {
                     const runId = this.queue.splice(next, 1)[0];
                     if (!runId)
                         break;
+                    if (this.ciWakeQueuedAt.has(runId) && this.active.has(runId)) {
+                        this.ciWakeQueuedAt.delete(runId);
+                        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);
+                        }
+                        continue;
+                    }
+                    if (this.ciWakeQueuedAt.delete(runId))
+                        this.ciWakeAdmitted.add(runId);
                     if (this.workerWakeQueuedAt.has(runId) && this.active.has(runId)) {
                         this.workerWakeQueuedAt.delete(runId);
                         const state = this.active.get(runId);
@@ -1476,6 +1715,15 @@ export class RunManager {
                         this.continueRun(run.id, {}, true);
                     continue;
                 }
+                if (run.ciWait && !this.hasPendingHumanAsk(run.id)) {
+                    if (run.ciWait.phase === 'registered')
+                        this.store.commitCiWait(run.id, { ...run.ciWait, phase: 'parked' });
+                    this.store.updateRun(run.id, { status: 'running', activity: 'monitoring', monitoringWakeAt: undefined });
+                    this.startCiWatch(run.id, this.store.getRun(run.id).ciWait);
+                    continue;
+                }
+                if (run.ciWait)
+                    this.withdrawCiWait(run.id);
                 if (run.status === 'queued') {
                     await this.reviveQueuedRun(run, 'cezar restarted');
                     continue;
@@ -1573,6 +1821,12 @@ export class RunManager {
             this.recovering = false;
         }
         this.reconcileWorkerWaits();
+        for (const run of this.store.listRuns()) {
+            if (run.ciWait && !['running', 'waiting', 'queued'].includes(run.status))
+                this.withdrawCiWait(run.id);
+            else if (run.ciWait)
+                this.queueCiWake(run.id);
+        }
         this.reconcileAutoResumes();
         void this.pump();
     }
@@ -1589,7 +1843,7 @@ export class RunManager {
     }
     isDisposedDelegatedRun(runId) {
         const role = this.store.getRun(runId)?.delegation?.role;
-        return this.disposed && (role === 'root' || role === 'worker');
+        return this.disposed && (role === 'root' || role === 'worker' || !!this.store.getRun(runId)?.ciWait);
     }
     /** Shutdown is not completion. Explicit terminal controls retain their precedence. */
     preserveRunAfterDisposal(runId, state) {
@@ -1599,6 +1853,7 @@ export class RunManager {
     dropActive(runId) {
         const state = this.active.get(runId);
         state?.releaseRepoRoot?.();
+        state?.revokeCiTools?.();
         if (state) {
             state.releaseRepoRoot = undefined;
             this.clearIdleTimer(state);
@@ -1608,9 +1863,17 @@ export class RunManager {
         this.monitoring.delete(runId);
         this.workerWaiting.delete(runId);
         this.workerWakeAdmitted.delete(runId);
+        this.ciWakeAdmitted.delete(runId);
+        if (this.ciWakeQueuedAt.delete(runId)) {
+            const index = this.queue.indexOf(runId);
+            if (index >= 0)
+                this.queue.splice(index, 1);
+        }
         if (state)
             this.clearMonitoringWakeTimer(state, runId);
         this.active.delete(runId);
+        if (!this.disposed && this.store.getRun(runId)?.ciWait)
+            this.queueCiWake(runId);
         if (!this.executions.has(runId) && this.store.getRun(runId)?.stopping)
             this.store.updateRun(runId, { stopping: undefined });
         this.memoryPausing.delete(runId);
@@ -2062,6 +2325,8 @@ export class RunManager {
                 this.store.commitWorkerExecutionComplete(runId, proof.generation);
             }
         }
+        const hadCiWait = !!this.store.getRun(runId)?.ciWait;
+        this.withdrawCiWait(runId);
         const cancelledFinish = this.store.commitRootFinishCancellation(runId);
         this.withdrawWorkerWait(runId);
         // Still waiting in the queue: just drop it there.
@@ -2087,7 +2352,7 @@ export class RunManager {
             if (cancelledFinish)
                 return true;
             const run = this.store.getRun(runId);
-            if (run?.delegation && ['queued', 'running', 'waiting'].includes(run.status)) {
+            if (run && (run.delegation || hadCiWait) && ['queued', 'running', 'waiting'].includes(run.status)) {
                 this.store.updateRun(runId, { status: 'cancelled', finishedAt: new Date().toISOString() });
                 return true;
             }
@@ -2096,6 +2361,8 @@ export class RunManager {
         state.cancelled = true;
         this.store.updateRun(runId, { stopping: true });
         this.store.flush();
+        state.revokeCiTools?.();
+        state.revokeCiTools = undefined;
         state.revokeDelegation?.();
         state.revokeDelegation = undefined;
         this.clearIdleTimer(state);
@@ -2251,7 +2518,9 @@ export class RunManager {
         if (!run || run.stopping || this.workerExecutionStopped(runId) || this.executionBlockedByRootFinish(run))
             return null;
         const message = this.toQueuedMessage(runId, content);
-        if (this.workerWait(runId))
+        if (run.ciWait)
+            this.withdrawCiWait(runId, message);
+        else if (this.workerWait(runId))
             this.withdrawWorkerWait(runId, message);
         else
             this.store.updateRun(runId, { queuedMessages: [...(run.queuedMessages ?? []), message] });
@@ -2381,8 +2650,10 @@ export class RunManager {
             return false;
         // The pending maps were removed only AFTER hydration. This entry therefore
         // needs live delivery, never a second fold into the already-created opening.
-        const message = this.workerWait(runId) ? this.toQueuedMessage(runId, content) : undefined;
-        if (message)
+        const message = this.workerWait(runId) || run.ciWait ? this.toQueuedMessage(runId, content) : undefined;
+        if (run.ciWait)
+            this.withdrawCiWait(runId, message);
+        else if (message)
             this.withdrawWorkerWait(runId, message);
         const pending = this.deferredMessages.get(runId) ?? [];
         pending.push({ content, ...(message ? { messageId: message.id } : {}) });
@@ -2533,10 +2804,9 @@ export class RunManager {
         const parsed = workerWaitRequestSchema.parse(request);
         const run = this.store.getRun(parentId);
         const state = this.active.get(parentId);
-        if (run?.delegation?.role !== 'root' || run.delegation.historyDeletion || !['running', 'waiting'].includes(run.status) ||
-            !state?.session?.open || state.cancelled || state.pendingHumanAsk || this.hasPendingHumanAsk(parentId) || run.delegation.wait || run.delegation.finishRequestedAt) {
-            throw new DelegationPolicyError('incompatible_state', 'parent cannot register a worker wait');
-        }
+        this.assertCanRegisterWorkerWait(parentId);
+        if (run?.delegation?.role !== 'root' || !state)
+            throw new DelegationPolicyError('denied_scope', 'Only a parent may wait for owned workers');
         for (const id of parsed.workerIds) {
             const worker = this.store.getRun(id);
             if (worker?.delegation?.role !== 'worker' || worker.delegation.parentRunId !== parentId ||
@@ -2553,15 +2823,45 @@ export class RunManager {
             this.parkWorkerWait(parentId, state);
         return this.workerWait(parentId);
     }
+    assertCanRegisterWorkerWait(runId) {
+        const run = this.store.getRun(runId);
+        const state = this.active.get(runId);
+        const refuse = (message) => { throw new DelegationPolicyError('incompatible_state', message); };
+        if (!run?.delegation || run.delegation.role === 'invalid')
+            refuse('Worker waits require an owned worker or parent run');
+        if (this.historyDeletionPending(runId))
+            refuse('History deletion is pending; finish deletion before registering a wait');
+        if (this.executionBlockedByRootFinish(run))
+            refuse('Parent finish is pending; a finishing parent cannot register a wait');
+        if (state?.pendingHumanAsk || this.hasUnansweredHumanAsk(runId))
+            refuse('A human question is pending; answer it before registering a wait');
+        if (run?.ciWait)
+            refuse('A CI wait is already active; finish or withdraw it before registering a worker wait');
+        const wait = this.workerWait(runId);
+        if (wait)
+            refuse(`Wait ${wait.id} is already active; keep it or run worker cancel-wait ${wait.id} before registering another`);
+        if (!['running', 'waiting'].includes(run.status) || !state?.session?.open || state.cancelled) {
+            refuse(`Run is ${run.status} with no available active session; register a wait from an executing parent or worker`);
+        }
+    }
+    /** An answer already executing in this generation is not an unanswered question.
+     * Keep the durable checkpoint at turn-end for crash recovery, and match its exact
+     * sequence so it can never hide a newer question. */
+    hasUnansweredHumanAsk(runId) {
+        const seq = this.pendingHumanAskSeq(runId);
+        const state = this.active.get(runId);
+        return seq !== undefined && !(state?.session?.open && !state.cancelled && state.openingAnswerAskSeq === seq);
+    }
     /** Both roles can select their own requests without acquiring worker-management authority. */
     registerRequestWait(runId, request) {
         const parsed = requestWaitRequestSchema.parse(request);
         this.reconcileWorkerWaits();
         const run = this.store.getRun(runId);
         const state = this.active.get(runId);
+        this.assertCanRegisterWorkerWait(runId);
         if (!run?.delegation || run.delegation.role === 'invalid' || this.historyDeletionPending(runId) ||
             this.executionBlockedByRootFinish(run) || !['running', 'waiting'].includes(run.status) ||
-            !state?.session?.open || state.cancelled || state.pendingHumanAsk || this.hasPendingHumanAsk(runId) || run.delegation.wait) {
+            !state?.session?.open || state.cancelled) {
             throw new DelegationPolicyError('incompatible_state', 'run cannot register a request wait');
         }
         const root = run.delegation.role === 'root' ? run : this.store.getRun(run.delegation.parentRunId);
@@ -2592,6 +2892,12 @@ export class RunManager {
             this.executionBlockedByRootFinish(run) || !['queued', 'running', 'waiting'].includes(run.status) ||
             this.workerExecutionStopped(runId) || this.hasPendingHumanAsk(runId))
             return;
+        // Retain conversation input until the registered CI wait receives scheduler admission.
+        // Converting this monitor into a worker wake would strand both admission paths.
+        if (run.ciWait) {
+            this.queueCiWake(runId);
+            return;
+        }
         const input = run.agentInputs?.find(entry => entry.conversation && !entry.deliveredAt);
         if (!input)
             return;
@@ -2788,14 +3094,19 @@ export class RunManager {
                 const root = parent.delegation.role === 'root' ? parent : this.store.getRun(parent.delegation.parentRunId);
                 const requests = root?.delegation?.role === 'root' ? root.delegation.conversation?.outcomes ?? [] : [];
                 let next = reconcileWorkerWait(selected, outcomes, now, requests);
-                const incoming = parent.agentInputs?.find(input => input.conversation && !input.deliveredAt &&
+                // The opening prompt (also during recovery) and a reserved submission are
+                // already being processed. Their delayed receipts cannot interrupt a wait
+                // registered by that very turn. Only inputs still awaiting a turn can.
+                const flight = this.active.get(parent.id)?.agentInputFlight;
+                const pendingInputs = parent.agentInputs?.filter(input => !input.deliveredAt &&
+                    input.id !== parent.continuationMessage?.agentInputId && !flight?.inputIds.includes(input.id)) ?? [];
+                const incoming = pendingInputs.find(input => input.conversation &&
                     !(input.conversation.kind === 'reply' && input.conversation.requestId && wait.requestIds?.includes(input.conversation.requestId)));
                 if (incoming && next.phase !== 'wake-pending')
                     next = { ...next, phase: 'wake-pending', reason: 'message', wakeId: incoming.id };
                 // A full queue of selected replies still needs admission. Use the last
                 // already accepted input as the checkpoint rather than adding a 33rd input.
                 // Its content is preserved; delivery includes the wait receipt separately.
-                const pendingInputs = parent.agentInputs?.filter(input => !input.deliveredAt) ?? [];
                 if (next.phase === 'wake-pending' && pendingInputs.length >= 32 &&
                     !parent.agentInputs?.some(input => input.id === next.wakeId)) {
                     next = { ...next, wakeId: pendingInputs.at(-1).id };
@@ -2989,11 +3300,11 @@ export class RunManager {
             this.flushAgentInputs(runId);
     }
     /** Reservation is synchronous; only an acknowledged transport may checkpoint delivery. */
-    submitAgentInput(runId, state, content, inputId) {
+    submitAgentInput(runId, state, content, inputIds = []) {
         const session = state.session;
         if (!session?.open || state.agentInputFlight || state.cancelled || state.finishRequested || state.agentInputError || state.pendingHumanAsk)
             return false;
-        const flight = { session, inputId };
+        const flight = { session, inputIds };
         state.agentInputFlight = flight;
         const current = () => !this.disposed && this.active.get(runId) === state && state.session === session &&
             state.agentInputFlight === flight && !state.cancelled && !state.finishRequested && !this.workerExecutionStopped(runId) &&
@@ -3036,13 +3347,24 @@ export class RunManager {
             if (!current())
                 return;
             try {
-                if (inputId) {
+                if (inputIds.length) {
                     const queue = this.store.getRun(runId)?.agentInputs ?? [];
-                    if (!queue.some(input => input.id === inputId && !input.deliveredAt))
+                    if (!queue.some(input => inputIds.includes(input.id) && !input.deliveredAt))
                         return;
-                    this.store.commitAgentInputs(runId, queue.map(input => input.id === inputId
-                        ? { ...input, deliveredAt: new Date().toISOString() } : input));
-                    if (this.workerWait(runId)?.wakeId === inputId)
+                    const ciWakeId = this.store.getRun(runId)?.ciWait?.wakeId;
+                    if (ciWakeId && inputIds.includes(ciWakeId)) {
+                        // CI lifecycle input owns its turn; never retire a conversation batch with it.
+                        if (inputIds.length !== 1)
+                            throw new Error('CI observation must be delivered separately');
+                        this.store.commitCiWaitDelivery(runId, ciWakeId);
+                        this.ciWakeAdmitted.delete(runId);
+                    }
+                    else {
+                        const deliveredAt = new Date().toISOString();
+                        this.store.commitAgentInputs(runId, queue.map(input => inputIds.includes(input.id) && !input.deliveredAt
+                            ? { ...input, deliveredAt } : input));
+                    }
+                    if (inputIds.includes(this.workerWait(runId)?.wakeId ?? ''))
                         this.withdrawWorkerWait(runId);
                     this.reconcileWorkerWaits();
                 }
@@ -3059,7 +3381,7 @@ export class RunManager {
                 return;
             if (this.flushAgentInputs(runId))
                 return;
-            if (state.atTurnBoundary !== session || state.pendingHumanAsk || this.workerWait(runId) || this.hasQueuedAgentInputs(runId))
+            if (state.atTurnBoundary !== session || state.pendingHumanAsk || this.workerWait(runId) || this.store.getRun(runId)?.ciWait || this.hasQueuedAgentInputs(runId))
                 return;
             if (state.doneAtBoundary === session) {
                 if (this.deferParentCompletion(runId))
@@ -3105,8 +3427,10 @@ export class RunManager {
         deliveries?.add(flight.settled);
         void flight.settled.then(() => deliveries?.delete(flight.settled));
         this.resumeParkedRun(runId, state);
-        if (inputId && this.workerWait(runId)?.wakeId === inputId)
+        if (inputIds.includes(this.workerWait(runId)?.wakeId ?? ''))
             state.workerWakeTurn = session;
+        if (inputIds.includes(this.store.getRun(runId)?.ciWait?.wakeId ?? ''))
+            state.ciWakeTurn = session;
         return true;
     }
     /** False leaves the durable entry untouched. No human-answer/slash-expansion fallback. */
@@ -3119,9 +3443,23 @@ export class RunManager {
             (this.workerWait(runId)?.phase === 'registered') ||
             (this.workerWait(runId)?.phase === 'wake-pending' && !this.workerWakeAdmitted.has(runId)))
             return false;
-        const input = nextAgentInput(run.agentInputs ?? [], state.pendingHumanAsk);
-        if (!input)
+        if (state.pendingHumanAsk || this.hasUnansweredHumanAsk(runId))
+            return false;
+        // The opening prompt already carries this input. It must not be resubmitted
+        // by a readiness callback before the first successful turn checkpoints it.
+        if (state.openingAgentInputId)
             return false;
+        if (run.ciWait) {
+            if (!this.ciWakeAdmitted.has(runId) || state.atTurnBoundary !== state.session)
+                return false;
+            // Preserve CI admission and atomic retirement; conversations batch on the next turn.
+            const input = run.agentInputs?.find(entry => entry.id === run.ciWait?.wakeId && !entry.deliveredAt);
+            return !!input && this.submitAgentInput(runId, state, [{ type: 'text', text: this.formatAgentInput(runId, input) }], [input.id]);
+        }
+        const batch = agentInputBatch(run.agentInputs ?? [], input => this.formatAgentInput(runId, input));
+        return !!batch && this.submitAgentInput(runId, state, [{ type: 'text', text: batch.text }], batch.inputs.map(input => input.id));
+    }
+    formatAgentInput(runId, input) {
         const attribution = input.conversation;
         const text = attribution
             ? `Agent conversation ${JSON.stringify({ id: input.id, ...attribution })}${this.workerWait(runId)?.reason === 'message' ? `; interrupted wait ${this.workerWait(runId).id} to receive this message; outstanding requests remain pending` : ''}\n${input.text}`
@@ -3129,7 +3467,12 @@ export class RunManager {
         const wait = this.workerWait(runId);
         const receipt = wait?.wakeId === input.id && wait.wakeId !== wait.id && wait.reason !== 'message'
             ? `\nWait ${wait.id} (${wait.reason}); request outcomes: ${JSON.stringify(wait.requestOutcomes ?? [])}; worker outcomes: ${JSON.stringify(wait.outcomes.map(outcome => ({ ...outcome, ...(outcome.summary ? { summary: outcome.summary.slice(0, 256) } : {}) })))}. This is not review approval.` : '';
-        return this.submitAgentInput(runId, state, [{ type: 'text', text: text + receipt }], input.id);
+        return text + receipt + this.agentInputOutcomeText(input);
+    }
+    agentInputOutcomeText(input) {
+        const root = this.store.getRun(input.parentRunId);
+        const outcome = input.conversation && root?.delegation?.role === 'root' ? root.delegation.conversation?.outcomes.find(entry => entry.requestId === (input.conversation?.requestId ?? input.id)) : undefined;
+        return outcome ? `\nRequest outcome: ${outcome.status}. This delivery does not reopen the settled request.` : '';
     }
     /** Deliver anything `deferMessage` buffered, once the session is live. */
     flushDeferred(runId) {
@@ -3208,6 +3551,8 @@ export class RunManager {
         const run = this.store.getRun(runId);
         if (!run || run.stopping || this.workerExecutionStopped(runId) || this.executionBlockedByRootFinish(run))
             return false;
+        if (!userAuthored && run.ciWait)
+            return false;
         const text = content
             .filter((b) => b.type === 'text')
             .map((b) => b.text)
@@ -3217,7 +3562,10 @@ export class RunManager {
         // these as user attachments (vs. agent tool screenshots) on disk (#357).
         const persisted = userAuthored ? this.persistPastedAttachments(runId, content) : [];
         const images = persisted.map((saved) => saved.url);
+        const ciHumanMessage = userAuthored && run.ciWait
+            ? { id: randomUUID(), text, images, createdAt: new Date().toISOString() } : undefined;
         if (userAuthored) {
+            this.withdrawCiWait(runId, ciHumanMessage);
             this.withdrawWorkerWait(runId);
             this.store.appendEvent(runId, {
                 type: 'user-message',
@@ -3240,6 +3588,8 @@ export class RunManager {
             : this.submitAgentInput(runId, state, deliverable);
         if (delivered) {
             if (userAuthored) {
+                if (ciHumanMessage)
+                    this.store.commitQueuedMessageDelivery(runId, ciHumanMessage.id);
                 if (answeringAskSeq !== undefined) {
                     this.store.appendEvent(runId, { type: 'human-input-delivered', askSeq: answeringAskSeq });
                 }
@@ -3264,6 +3614,7 @@ export class RunManager {
         const state = this.active.get(runId);
         if (decision.action === 'session' && state?.session) {
             try {
+                this.withdrawCiWait(runId);
                 this.withdrawWorkerWait(runId);
             }
             catch {
@@ -3348,7 +3699,7 @@ export class RunManager {
     continueRun(runId, opts = {}, 
     /** Restart recovery may discover several interrupted tasks at once. Those
      *  continuations are queued; an explicit user Continue remains immediate. */
-    deferForCapacity = false) {
+    deferForCapacity = false, conversation) {
         if (agentModelsLocked(this.repoRoot) && (opts.model?.trim() || opts.effort?.trim())) {
             return { ok: false, error: AGENT_MODELS_LOCKED_ERROR };
         }
@@ -3357,6 +3708,9 @@ export class RunManager {
         const run = this.store.getRun(runId);
         if (!run)
             return { ok: false, error: 'not found' };
+        if (conversation && (!deferForCapacity || run.delegation?.role !== 'worker' || run.delegation.parentRunId !== conversation.rootId ||
+            !['done', 'review', 'failed'].includes(run.status)))
+            return { ok: false, error: 'Only a settled owned worker can be resumed by its parent message' };
         if (run.stopping)
             return { ok: false, error: 'run is still stopping' };
         if (this.historyDeletionPending(runId))
@@ -3397,15 +3751,17 @@ export class RunManager {
         if (this.executionBlockedByRootFinish(run))
             return { ok: false, error: 'parent finish is pending' };
         const answers = deferForCapacity ? [run.continuationMessage, ...(run.queuedMessages ?? [])] : [opts];
-        if (pendingHumanAsk && ((deferForCapacity && run.continuationMessage?.origin !== 'human') ||
+        if (pendingHumanAsk && (conversation || (deferForCapacity && run.continuationMessage?.origin !== 'human') ||
             !answers.some(answer => answer?.text?.trim() || answer?.images?.length))) {
             return { ok: false, error: 'pending human question requires an explicit answer' };
         }
+        // A disconnected CI monitor has durable intent but no live session to receive human input.
+        const disconnectedCiWait = !!run.ciWait && !this.isActive(runId) && !hasRegisteredRunProcess(runId);
         // `review` is continuable too — that's the "Send back" path (spec 009).
-        if (!['done', 'failed', 'cancelled', 'review'].includes(run.status) && !(pendingHumanAsk && run.status === 'waiting') &&
+        if (!disconnectedCiWait && !['done', 'failed', 'cancelled', 'review'].includes(run.status) && !(pendingHumanAsk && run.status === 'waiting') &&
             !(run.status === 'waiting' && !this.isActive(runId) && ((!hasRegisteredRunProcess(runId) &&
                 (run.delegation === undefined || run.delegation.role === 'root')) ||
-                (deferForCapacity && run.delegation?.role === 'worker' && !!this.workerWait(runId))))) {
+                (deferForCapacity && run.delegation?.role === 'worker' && (!!this.workerWait(runId) || !!run.ciWait))))) {
             return { ok: false, error: `cannot continue a ${run.status} run` };
         }
         const sessionStep = [...run.steps].reverse().find((s) => s.sessionId);
@@ -3532,6 +3888,7 @@ export class RunManager {
         // bound UNATTENDED resumes.
         this.clearAutoResume(runId);
         if (!deferForCapacity) {
+            this.withdrawCiWait(runId);
             this.withdrawWorkerWait(runId);
             this.resetParentCompletion(runId);
         }
@@ -3542,7 +3899,7 @@ export class RunManager {
         const continuationStep = { id: stepId, name: 'Continue', kind: 'agent', synthetic: 'continuation' };
         if (run.delegation?.role !== 'worker')
             this.store.addStep(runId, continuationStep);
-        const recovered = deferForCapacity ? run.continuationMessage : undefined;
+        const recovered = deferForCapacity && !conversation ? run.continuationMessage : undefined;
         const message = recovered ?? this.toQueuedMessage(runId, [
             ...(opts.text?.trim() ? [{ type: 'text', text: opts.text.trim() }] : []),
             ...(opts.images ?? []),
@@ -3552,6 +3909,7 @@ export class RunManager {
         // and the original prompt/URLs must reach disk before the first startup await.
         const acceptedPatch = {
             continuationMessage: { ...message, id: stepId, text: prompt,
+                ...(conversation ? { agentInputId: conversation.input.id } : {}),
                 origin: recovered ? recovered.origin : deferForCapacity ? 'lifecycle' : 'human' },
             status: deferForCapacity ? 'queued' : 'running',
             error: undefined,
@@ -3563,7 +3921,7 @@ export class RunManager {
         };
         if (run.delegation?.role === 'worker') {
             try {
-                this.store.commitWorkerContinuation(runId, acceptedPatch, continuationStep);
+                this.store.commitWorkerContinuation(runId, acceptedPatch, continuationStep, conversation);
             }
             catch {
                 // No session or async launch exists yet. Release the private execution
@@ -3725,6 +4083,12 @@ export class RunManager {
         // blocks before they reach the model). An image ALSO rides along as a base64 block so the
         // model can view it; a file (#950) has nothing to view and travels as its path alone.
         const checkpoint = record?.continuationMessage;
+        state.openingAgentInputId = checkpoint?.agentInputId;
+        const openingInput = record?.agentInputs?.find(input => input.id === checkpoint?.agentInputId);
+        // Hydration has already included later human updates and task edits. Append
+        // the current obligation outcome without replacing that composed prompt.
+        if (openingInput)
+            prompt += this.agentInputOutcomeText(openingInput);
         const saved = this.readPersistedAttachments(runId, checkpoint?.id === stepId ? checkpoint.images ?? [] : [], 'continuation');
         const openingImages = [...(images.length ? contentBlocksOf(images) : saved.blocks), ...persistedImages];
         const attachments = [...saved.attachments, ...persistedAttachments];
@@ -3737,6 +4101,7 @@ export class RunManager {
                 ...(attachments.length ? { images: attachments.map((saved) => saved.url) } : {}),
             });
         let openingAnswerAskSeq = checkpoint?.origin === 'human' ? this.pendingHumanAskSeq(runId) : undefined;
+        state.openingAnswerAskSeq = openingAnswerAskSeq;
         state.pendingHumanAsk = openingAnswerAskSeq === undefined && this.hasPendingHumanAsk(runId);
         let stepCost = 0;
         let turnText = '';
@@ -3787,13 +4152,40 @@ export class RunManager {
                 sawClaudeScheduleWakeup = true;
             if (event.type === 'turn-end') {
                 state.workerWakeTurn = undefined;
+                state.ciWakeTurn = undefined;
                 state.atTurnBoundary = state.session;
+                state.ciTurnId = randomUUID();
                 // A completed turn acknowledges the opening payload. Until then a restart
                 // must replay it, including a crash after startSession but before delivery.
                 if (!state.cancelled) {
+                    if (state.openingAgentInputId && state.session?.open) {
+                        const id = state.openingAgentInputId;
+                        const deliveredAt = new Date().toISOString();
+                        try {
+                            this.store.commitAgentInputs(runId, (this.store.getRun(runId)?.agentInputs ?? []).map(input => input.id === id && !input.deliveredAt ? { ...input, deliveredAt } : input), id);
+                        }
+                        catch (error) {
+                            state.agentInputError = `agent input delivery checkpoint failed: ${error instanceof Error ? error.message : String(error)}`;
+                            try {
+                                state.session.interrupt();
+                            }
+                            finally {
+                                try {
+                                    this.store.appendEvent(runId, { type: 'error', message: state.agentInputError });
+                                }
+                                catch {
+                                    console.error(`[cez] ${state.agentInputError}`);
+                                }
+                            }
+                            return;
+                        }
+                        state.openingAgentInputId = undefined;
+                        this.reconcileWorkerWaits();
+                    }
                     if (openingAnswerAskSeq !== undefined && state.session?.open) {
                         this.store.appendEvent(runId, { type: 'human-input-delivered', askSeq: openingAnswerAskSeq });
                         openingAnswerAskSeq = undefined;
+                        state.openingAnswerAskSeq = undefined;
                     }
                     this.store.updateRun(runId, { continuationMessage: undefined });
                     this.store.flush();
@@ -3824,8 +4216,9 @@ export class RunManager {
                 this.store.updateRun(runId, { invalidAsk: !ask && askNotes.length > 0 ? true : undefined });
                 if (ask)
                     this.prepareHumanAsk(runId, state);
-                const completionBlocked = !!done && this.deferParentCompletion(runId);
-                const workerWaitParked = completionBlocked || (!!sessionOpen && this.parkWorkerWait(runId, state));
+                const ciWaitParked = !!sessionOpen && this.parkCiWait(runId, state);
+                const completionBlocked = !ciWaitParked && !!done && this.deferParentCompletion(runId);
+                const workerWaitParked = ciWaitParked || completionBlocked || (!!sessionOpen && this.parkWorkerWait(runId, state));
                 state.doneAtBoundary = done ? state.session : undefined;
                 state.parkAfterAck = sessionOpen && state.session ? { session: state.session, monitoring: !!monitoring } : undefined;
                 const agentInputDelivered = !ask && !workerWaitParked && this.flushAgentInputs(runId);
@@ -4030,6 +4423,7 @@ export class RunManager {
             throw new Error('Worker stopped before launch');
         }
         const delegation = this.provisionSession(runId, state);
+        const ciTools = await this.provisionCiSession(runId, state);
         try {
             session = runner.startSession({
                 // The Continue step is a fresh agent session on the same run — the
@@ -4044,7 +4438,8 @@ export class RunManager {
                 allowedTools: grants.allowedTools,
                 bashAllowlist: grants.bashAllowlist,
                 additionalDirectories: agentDirectories(join(this.dataDir, 'runs'), continueProfile.env),
-                env: { ...continueProfile.env, ...delegation?.env },
+                env: { ...continueProfile.env, ...delegation?.env, ...ciTools?.env },
+                ...(ciTools ? { cezarTools: ciTools.descriptor } : {}),
                 ...(delegation ? { restrictNativeDelegation: delegation.restrictNativeDelegation } : {}),
                 model: continueModel,
                 effort: continueEffort,
@@ -4060,6 +4455,8 @@ export class RunManager {
             });
         }
         catch (error) {
+            ciTools?.revoke();
+            state.revokeCiTools = undefined;
             delegation?.revoke();
             state.revokeDelegation = undefined;
             throw error;
@@ -4080,6 +4477,10 @@ export class RunManager {
             if (this.preserveRunAfterDisposal(runId, state))
                 return;
             this.persistWorkerAssistantResult(runId, stepId, result.text);
+            if (this.store.getRun(runId)?.ciWait && !state.cancelled) {
+                this.store.updateRun(runId, { status: 'running', activity: 'monitoring' });
+                return;
+            }
             if (sessionError || state.agentInputError)
                 throw new Error(sessionError ?? state.agentInputError);
             if (!state.cancelled) {
@@ -4149,6 +4550,10 @@ export class RunManager {
             if (this.preserveRunAfterDisposal(runId, state))
                 return;
             // Keep the provider failure that triggered teardown, even if teardown rejects.
+            if (this.store.getRun(runId)?.ciWait && !state.cancelled) {
+                this.store.updateRun(runId, { status: 'running', activity: 'monitoring' });
+                return;
+            }
             const message = sessionError ?? state.agentInputError ?? (err instanceof Error ? err.message : String(err));
             sink.sessionEnded('error', message);
             this.store.updateStep(runId, stepId, { status: 'failed', error: message, finishedAt: finishedAt() });
@@ -4162,6 +4567,8 @@ export class RunManager {
             this.store.appendEvent(runId, { type: 'lifecycle', message: `continue failed — ${message}` });
         }
         finally {
+            ciTools?.revoke();
+            state.revokeCiTools = undefined;
             delegation?.revoke();
             state.revokeDelegation = undefined;
             this.recordUsagePeaks(runId);
@@ -4463,6 +4870,11 @@ export class RunManager {
                     this.requeueWhileHeld(runId, workflow, input, taskBackend, state, i);
                     return;
                 }
+                if (this.store.getRun(runId)?.ciWait && !state.cancelled) {
+                    this.store.updateRun(runId, { status: 'running', activity: 'monitoring' });
+                    this.dropActive(runId);
+                    return;
+                }
                 if (failure) {
                     this.finishStep(runId, step.id, 'failed', failure, emit);
                     runError = `step "${step.id}" failed: ${failure}`;
@@ -4671,7 +5083,9 @@ export class RunManager {
                 sawClaudeScheduleWakeup = true;
             if (event.type === 'turn-end') {
                 state.workerWakeTurn = undefined;
+                state.ciWakeTurn = undefined;
                 state.atTurnBoundary = state.session;
+                state.ciTurnId = randomUUID();
                 // v2 `turn.completed` already flushed the coalescers; the v1 turn
                 // boundary flushes again (idempotent) as a backstop.
                 sink.flushAll();
@@ -4680,7 +5094,7 @@ export class RunManager {
                 const done = interactive && sessionOpen && DONE_MARKER_RE.test(turnText.trimEnd());
                 // `CEZ:ASK` → the user is blocked; wins over `CEZ:MONITORING`, loses to
                 // `CEZ:DONE` (#473).
-                const askTurn = resolveAskTurn(turnText, completedAssistantText, Boolean((interactive || this.workerWait(runId)) && sessionOpen) && !done);
+                const askTurn = resolveAskTurn(turnText, completedAssistantText, Boolean((interactive || this.workerWait(runId) || this.store.getRun(runId)?.ciWait) && sessionOpen) && !done);
                 const { ask, notes: askNotes } = askTurn;
                 discardQueuedMessagesOnAsk(state.session, askTurn);
                 const monitoring = !this.parentCompletionAttention(runId) &&
@@ -4698,8 +5112,9 @@ export class RunManager {
                 this.store.updateRun(runId, { invalidAsk: !ask && askNotes.length > 0 ? true : undefined });
                 if (ask)
                     this.prepareHumanAsk(runId, state);
-                const completionBlocked = !!done && this.deferParentCompletion(runId);
-                const workerWaitParked = completionBlocked || (!!sessionOpen && this.parkWorkerWait(runId, state));
+                const ciWaitParked = !!sessionOpen && this.parkCiWait(runId, state);
+                const completionBlocked = !ciWaitParked && !!done && this.deferParentCompletion(runId);
+                const workerWaitParked = ciWaitParked || completionBlocked || (!!sessionOpen && this.parkWorkerWait(runId, state));
                 state.doneAtBoundary = done ? state.session : undefined;
                 state.parkAfterAck = interactive && sessionOpen && state.session ? { session: state.session, monitoring: !!monitoring } : undefined;
                 const agentInputDelivered = !ask && !workerWaitParked && this.flushAgentInputs(runId);
@@ -4820,6 +5235,7 @@ export class RunManager {
         state.currentStepId = step.id;
         this.beginUsageInvocation(runId, state, step.id);
         const delegation = this.provisionSession(runId, state);
+        const ciTools = await this.provisionCiSession(runId, state);
         try {
             if (this.workerExecutionStopped(runId)) {
                 state.cancelled = true;
@@ -4838,7 +5254,8 @@ export class RunManager {
                 bashAllowlist: grants.bashAllowlist,
                 // The handoff file lives outside the worktree — grant access.
                 additionalDirectories: agentDirectories(join(this.dataDir, 'runs'), stepProfile.env),
-                env: { ...stepProfile.env, ...delegation?.env },
+                env: { ...stepProfile.env, ...delegation?.env, ...ciTools?.env },
+                ...(ciTools ? { cezarTools: ciTools.descriptor } : {}),
                 ...(delegation ? { restrictNativeDelegation: delegation.restrictNativeDelegation } : {}),
                 model: backendModel,
                 effort: effectiveEffort,
@@ -4848,7 +5265,7 @@ export class RunManager {
             }, onEvent, {
                 autoEndAfterFirstTurn: !interactive,
                 shouldAutoEnd: () => this.active.get(runId) !== state || state.session !== session ||
-                    (!this.workerWait(runId) && !this.parentCompletionPending(runId) && state.workerWakeTurn !== session && !state.agentInputFlight),
+                    (!this.workerWait(runId) && !this.store.getRun(runId)?.ciWait && !this.parentCompletionPending(runId) && state.workerWakeTurn !== session && state.ciWakeTurn !== session && !state.agentInputFlight),
                 onUiEvent: (event) => {
                     completedAssistantText = appendCompletedAssistantText(completedAssistantText, event);
                     this.handleRunnerUiEvent(runId, state, sink, event);
@@ -4857,6 +5274,8 @@ export class RunManager {
             });
         }
         catch (err) {
+            ciTools?.revoke();
+            state.revokeCiTools = undefined;
             delegation?.revoke();
             state.revokeDelegation = undefined;
             state.currentStepId = undefined;
@@ -4906,6 +5325,8 @@ export class RunManager {
             return message;
         }
         finally {
+            ciTools?.revoke();
+            state.revokeCiTools = undefined;
             delegation?.revoke();
             state.revokeDelegation = undefined;
             this.recordUsagePeaks(runId);
@@ -4921,6 +5342,7 @@ export class RunManager {
                     this.queue.splice(at, 1);
             }
             state.workerWakeTurn = undefined;
+            state.ciWakeTurn = undefined;
             state.atTurnBoundary = undefined;
             state.doneAtBoundary = undefined;
             state.parkAfterAck = undefined;
@@ -4962,6 +5384,7 @@ export class RunManager {
     /** Ask precedence also releases an admitted but not yet delivered worker wake.
      * Its durable input/wait remain queued until an actual human answer. */
     prepareHumanAsk(runId, state) {
+        this.withdrawCiWait(runId);
         state.pendingHumanAsk = true;
         this.workerWaiting.delete(runId);
         this.workerWakeAdmitted.delete(runId);
@@ -5426,6 +5849,10 @@ export class RunManager {
         const run = this.store.getRun(runId);
         if (!run || run.stopping || this.workerExecutionStopped(runId) || this.executionBlockedByRootFinish(run))
             return;
+        if (run.ciWait) {
+            this.clearMonitoringWakeTimer(state, runId);
+            return;
+        }
         const minutes = this.semaphore.monitoringWakeIntervalMinutes();
         if (minutes === null) {
             this.clearMonitoringWakeTimer(state, runId);