@maudecode/talaria-web 1.17.2 → 1.19.0

package/dist/sessions/completions.js

@@ -7,14 +7,30 @@
  * redelivered at turn teardown with a bounded retry budget).
  */
 import { randomUUID } from 'node:crypto';
+import { readFileSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { SessionNotFound } from './store.js';
 import { str } from '../util.js';
-import { batchUpdate, recordBackgroundUpdate } from './background-updates.js';
+import { expandDotenv, parseDotenv } from '../cli/dotenv.js';
+import { isDict, messageText } from './merge.js';
+import { batchUpdate, recordBackgroundUpdate, completionAccepted } from './background-updates.js';
+import { backgroundEventKind } from './background-events.js';
+import { HeldWakeups, deliveredPerProcess, heldKey, mergeWakeups, poolRecovery, wakeupPaused } from './wakeup-pause.js';
 export const COMPLETION_POLL_MS = 1000;
 const EMIT_COALESCE_WINDOW_S = 1;
 const WAKEUP_RETRY_SECONDS = 30;
 const WAKEUP_RETRY_MAX_ATTEMPTS = 5;
 const WAKEUP_BATCH_MAX_CHARS = 24_000;
+/** A session with held wakeups rechecks its pause at least this often (a credential edit has no deadline). */
+const HELD_RECHECK_SECONDS = 300;
 const DELIVERY_CONSUMER = 'webui';
+const canonicalHome = (home) => { try {
+    return realpathSync(home);
+}
+catch {
+    return resolve(home);
+} };
+const completionKey = (home, event) => event.type === 'async_delegation' && event.delegation_id && !event.task_failure_notice ? JSON.stringify([canonicalHome(home), str(event.delegation_id)]) : '';
 /** Python `format_wakeup_prompt` for plain completion events; async delegations use the sidecar formatter. */
 export function formatWakeupPrompt(evt) {
     const type = str(evt.type ?? 'completion');
@@ -31,12 +47,22 @@ export function formatWakeupPrompt(evt) {
             body += `\n(${str(evt.suppressed)} earlier matches were suppressed by rate limit)`;
         return body + ']';
     }
-    if (type !== 'completion')
+    if (backgroundEventKind(evt) !== 'completion')
         return null;
     if (!(sid || cmd || 'exit_code' in evt || evt.output))
         return null;
     return `[IMPORTANT: Background process ${sid} completed (exit_code=${str(evt.exit_code ?? '?')}).\nCommand: ${cmd}\nOutput:\n${truncate(evt.output, 4000)}]`;
 }
+/**
+ * TAL-724: an event's delivery identity, the `process_id` of its wakeup entry. A completion (an event with no type is one) or
+ * an async delegation is its process: one exit can be enqueued twice when a kill races the reader thread. The Agent enqueues
+ * each watch event once, and one process raises several, so each is its own delivery; its event keeps the process id.
+ */
+export function deliveryKey(evt, processId) {
+    return !processId || deliveredPerProcess(evt) ? processId : `${processId}:${str(evt.type)}:${randomUUID()}`;
+}
+/** Only a process's exit is consumed by the agent's own wait or poll (TAL-532); its watch events and delegations are not. */
+const isCompletion = (e) => Boolean(e.process_id) && str(e.event?.type ?? 'completion') === 'completion';
 export class CompletionDrain {
     deps;
     timer = null;
@@ -52,8 +78,28 @@ export class CompletionDrain {
     recoveredFor = null;
     recoveryWarnedFor = null;
     lastDrainError = null;
+    heldResumed = false;
+    drains = new Map();
+    /** Admitted wakeups whose release could not be written: never delivered again, and the release is retried. */
+    unreleased = new Map();
+    /** TAL-576: wakeups held while their session is paused. */
+    heldWakeups;
+    /** Waiting requires an unadmitted result, not an admitted turn's outstanding ledger acknowledgement. */
+    async pendingDelegations(sid) {
+        try {
+            const session = (await this.deps.store.get(sid)), home = this.ownerHome(session);
+            return new Set((await this.heldWakeups.get(sid)).filter((entry) => {
+                const key = completionKey(home, entry.event ?? {});
+                return Boolean(key) && !completionAccepted(session, key);
+            }).map((entry) => str(entry.event?.delegation_id)).filter(Boolean));
+        }
+        catch {
+            return new Set();
+        }
+    }
     constructor(deps) {
         this.deps = deps;
+        this.heldWakeups = new HeldWakeups(deps.documents);
     }
     start() {
         if (this.timer || this.stopped)
@@ -107,7 +153,19 @@ export class CompletionDrain {
                 this.recoveryWarnedFor = describe;
             }
         }
-        const { events } = await sidecar.call('process.drain', { profile_home: this.deps.profileHome(this.deps.activeProfile()), max_events: 256 });
+        // TAL-576: whether or not every profile recovered, the sessions left holding wakeups resume once a sidecar answers.
+        if (!this.heldResumed)
+            (await this.resumeHeld());
+        // The drain is sidecar-wide; an active profile whose home escapes the profiles root (`profileHome` throws) scopes it
+        // to the base home instead of stalling every other profile's completions.
+        let scope;
+        try {
+            scope = this.deps.profileHome(this.deps.activeProfile());
+        }
+        catch {
+            scope = this.deps.baseHome;
+        }
+        const { events } = await sidecar.call('process.drain', { profile_home: scope, max_events: 256 });
         let routed = 0;
         const unrouted = [];
         for (const evt of events) {
@@ -130,19 +188,19 @@ export class CompletionDrain {
         }
         return routed;
     }
-    resolveTarget(evt) {
+    async resolveTarget(evt) {
         const sessionKey = str(evt.session_key).trim();
         const origin = str(evt.origin_ui_session_id).trim();
-        const live = (sid) => { if (!sid)
+        const live = async (sid) => { if (!sid)
             return ''; try {
-            this.deps.store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false });
+            (await this.deps.store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false }));
             return sid;
         }
         catch {
             return '';
         } };
-        const resolved = live(sessionKey);
-        const owner = live(origin);
+        const resolved = (await live(sessionKey));
+        const owner = (await live(origin));
         if (!owner)
             return resolved;
         if (resolved && resolved !== owner)
@@ -156,7 +214,8 @@ export class CompletionDrain {
         return false;
     }
     async wakeupPrompt(evt) {
-        if (evt.type === 'async_delegation') {
+        const kind = backgroundEventKind(evt);
+        if (kind === 'delegation' || kind === 'progress') {
             const sidecar = this.deps.sidecar();
             if (!sidecar)
                 return '';
@@ -169,30 +228,178 @@ export class CompletionDrain {
         }
         return (formatWakeupPrompt(evt) ?? '').trim();
     }
+    /** The session's owning profile home; a session without a profile belongs to the root profile (`profilesMatch`). */
+    ownerHome(session) { return this.deps.profileHome(session.profile ?? 'default'); }
+    /** A profile's config; null when it cannot be read. */
+    async profileConfig(home) {
+        try {
+            return (await this.deps.readConfig?.(home)) ?? {};
+        }
+        catch {
+            return null;
+        }
+    }
+    /** The owning profile's `delegation.surface_child_process_notifications`; off, the Agent's default, when it cannot be read. */
+    async surfacesChildProcesses(sid) {
+        let config;
+        try {
+            config = await this.profileConfig(this.ownerHome((await this.deps.store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false }))));
+        }
+        catch {
+            return false;
+        }
+        return isDict(config?.delegation) && config.delegation.surface_child_process_notifications === true;
+    }
+    /**
+     * TAL-907 (Agent `_load_background_notifications_mode`): `HERMES_BACKGROUND_NOTIFICATIONS` from the profile's `.env`
+     * (which overrides the shell, as in the Agent) or the server environment, else `display.background_process_notifications`
+     * (YAML `false` is off). Only `off` changes Web delivery; null when the setting cannot be read.
+     */
+    async notificationsOff(home) {
+        let mode;
+        try {
+            mode = expandDotenv(parseDotenv(readFileSync(join(home, '.env'), 'utf8')), this.deps.env ?? {}).HERMES_BACKGROUND_NOTIFICATIONS?.trim();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                return null;
+        }
+        mode ||= this.deps.env?.HERMES_BACKGROUND_NOTIFICATIONS?.trim();
+        if (!mode) {
+            const config = await this.profileConfig(home);
+            if (!config)
+                return null;
+            mode = isDict(config.display) ? config.display.background_process_notifications : undefined;
+        }
+        return mode === false || str(mode).trim().toLowerCase() === 'off';
+    }
+    async isReadOnly(session) { return await this.deps.isReadOnly?.(session) ?? session.read_only; }
+    /** Hand durable results back without acknowledging delivery or mutating the canonical session. */
+    async relinquish(sid, session, entries, claims = []) {
+        try {
+            if (!(await this.settleClaims(this.ownerHome(session), 'process.defer_delivery', claims)))
+                throw new Error('delivery claim could not be returned');
+            const events = entries.flatMap((e) => e.event?.type === 'async_delegation' ? [e.event] : []);
+            if (events.length) {
+                const sidecar = this.deps.sidecar();
+                if (!sidecar)
+                    throw new Error('sidecar unavailable');
+                await sidecar.call('process.requeue', { events });
+            }
+            this.deferred.delete(sid);
+            this.pendingSessions.delete(sid);
+            this.retryAttempts.delete(sid);
+            const timer = this.retryTimers.get(sid);
+            if (timer)
+                clearTimeout(timer);
+            this.retryTimers.delete(sid);
+            await this.release(sid);
+        }
+        catch (error) {
+            for (const entry of entries)
+                this.defer(sid, entry);
+            this.scheduleRetry(sid);
+            this.deps.log(`[webui] WARNING: completion hand-back failed for ${sid}: ${error.message}`);
+        }
+    }
     /** Python `_process_one`; returns false when the event has no owning WebUI session. */
     async processOne(evt) {
         const processId = str(evt.process_id).trim();
-        const sid = this.resolveTarget(evt);
+        const sid = (await this.resolveTarget(evt));
         if (!sid)
             return false;
+        let owner;
+        let home;
+        let homeError = '';
+        try {
+            owner = (await this.deps.store.get(sid));
+        }
+        catch {
+            return false;
+        }
+        try {
+            home = this.ownerHome(owner);
+        }
+        catch (error) {
+            home = '';
+            homeError = error.message;
+        }
+        if (home && (await this.isReadOnly(owner)))
+            return false;
+        // Reconciliation needs positive profile proof; live events retain the existing admission deferral on home errors.
+        if (evt.reconciliation_profile_home && (!home || canonicalHome(str(evt.reconciliation_profile_home)) !== canonicalHome(home)))
+            return false;
+        if (evt.reconciliation_profile_home && completionAccepted(owner, completionKey(home, evt)))
+            return true;
         if (evt.consumed === true)
             return true;
+        // TAL-933 (Agent `should_surface_notification`): a subagent's own process notices stay out of the parent chat unless
+        // the session's profile opts in. Dropped, not consumed, as in the Agent: an exit nobody read still reaches the parent
+        // as the child's `unread_completions`.
+        if (evt.child_process === true && !(await this.surfacesChildProcesses(sid)))
+            return true;
         const seen = this.seen.get(sid) ?? new Set();
         this.seen.set(sid, seen);
-        if (processId && seen.has(processId))
+        // Only a per-process delivery can repeat: a watch event's key is unique, so remembering it would only grow `seen`.
+        if (processId && deliveredPerProcess(evt)) {
+            if (seen.has(processId))
+                return true;
+        }
+        const prompt = await this.wakeupPrompt(evt);
+        if ((await this.isReadOnly(owner))) {
+            if (home)
+                return false;
+            this.defer(sid, { process_id: deliveryKey(evt, processId), wakeup_prompt: prompt, event: evt });
+            this.scheduleRetry(sid);
+            this.deps.log(`[webui] WARNING: server-side wakeup retained for session ${sid}: ${homeError || 'ownership home unavailable'}; retrying`);
+            return true;
+        }
+        if (evt.reconciliation_profile_home && evt.delegation_id && prompt.includes(str(evt.delegation_id))) {
+            // Upgrade a proven pre-receipt Web turn; typed Agent bookkeeping alone never qualifies.
+            const previous = owner.messages.find((m) => m._source === 'process_wakeup' && m._turn_id && messageText(m.content) === prompt);
+            const turnId = str(previous?._turn_id) || (owner.pending_user_source === 'process_wakeup' && owner.pending_user_message === prompt ? str(owner.active_stream_id) : '');
+            if (turnId) {
+                const receipts = isDict(owner.extra.completion_acceptances) ? owner.extra.completion_acceptances : {};
+                owner.extra.completion_acceptances = { ...receipts, [completionKey(home, evt)]: turnId };
+                await this.deps.store.save(owner, { touchUpdatedAt: false });
+                return true;
+            }
+        }
+        // The formatter awaits the sidecar; another drain may have retained this event meanwhile.
+        if (processId && deliveredPerProcess(evt) && seen.has(processId))
             return true;
-        if (processId)
+        const entry = { process_id: deliveryKey(evt, processId), wakeup_prompt: prompt, event: evt };
+        if (prompt && evt.type === 'async_delegation')
+            this.defer(sid, entry);
+        if (prompt && evt.type === 'async_delegation' && !evt.task_failure_notice) {
+            try {
+                // Busy, Stop, sealed and provider-paused entries survive either process restarting.
+                await this.heldWakeups.hold(sid, [entry]);
+                recordBackgroundUpdate(owner, `delegation:${str(evt.delegation_id)}`, batchUpdate([{ event: evt, prompt }]));
+                await this.deps.store.save(owner, { touchUpdatedAt: false });
+            }
+            catch (error) {
+                this.scheduleRetry(sid);
+                this.deps.log(`[webui] WARNING: failed to persist delegation wakeup for session ${sid}; retained in memory for retry: ${error.message}`);
+                return true;
+            }
+        }
+        if (processId && deliveredPerProcess(evt))
             seen.add(processId);
         this.pendingSessions.add(sid);
-        const prompt = await this.wakeupPrompt(evt);
-        this.deps.background?.recordEvent(sid, evt, prompt);
-        this.emitCoalesced(sid, this.buildPayload(evt, sid, prompt));
+        await this.deps.background?.recordEvent(sid, evt, prompt);
+        if (backgroundEventKind(evt) !== 'progress')
+            this.emitCoalesced(sid, this.buildPayload(evt, sid, prompt));
         if (!prompt)
             return true;
-        if (this.hasActiveTurn(sid))
-            this.recordDeferred(sid, processId, prompt, evt);
+        if (evt.type === 'async_delegation') {
+            if (!this.hasActiveTurn(sid))
+                await this.drainDeferred(sid);
+        }
+        else if (this.hasActiveTurn(sid))
+            this.defer(sid, entry);
         else
-            await this.startWakeup(sid, [{ process_id: processId, wakeup_prompt: prompt, event: evt }]);
+            await this.startWakeup(sid, [entry]);
         return true;
     }
     buildPayload(evt, sid, prompt) {
@@ -243,21 +450,26 @@ export class CompletionDrain {
         this.pendingEmit.set(sid, { payload, timer });
     }
     recordDeferred(sid, processId, prompt, event) {
-        if (!sid || !prompt)
+        this.defer(sid, { process_id: deliveryKey(event ?? {}, processId), wakeup_prompt: prompt, ...(event ? { event } : {}) });
+    }
+    /** Re-deferring keeps an entry's delivery identity, so its held copy and this one stay one wakeup. */
+    defer(sid, entry) {
+        if (!sid || !entry.wakeup_prompt)
             return;
         const entries = this.deferred.get(sid) ?? [];
-        if (processId && entries.some((e) => e.process_id === processId))
+        if (entries.some((e) => heldKey(e) === heldKey(entry)))
             return;
-        entries.push({ process_id: processId, wakeup_prompt: prompt, ...(event ? { event } : {}) });
+        entries.push(entry);
         this.deferred.set(sid, entries);
         this.pendingSessions.add(sid);
     }
     deferredCount(sid) { return this.deferred.get(sid)?.length ?? 0; }
-    async markConsumed(processIds) {
+    /** Delivering a process's exit consumes it; a watch event leaves the exit to be delivered (TAL-724). */
+    async markConsumed(entries) {
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return;
-        for (const pid of processIds.filter(Boolean)) {
+        for (const pid of new Set(entries.filter(isCompletion).map((e) => e.process_id))) {
             try {
                 await sidecar.call('process.mark_consumed', { process_id: pid });
             }
@@ -269,10 +481,12 @@ export class CompletionDrain {
      * another consumer delivered (or holds) it, so it leaves the batch; a sidecar failure returns null so the caller keeps
      * every entry pending. Claims are taken at delivery, never while deferred, so a long turn cannot outlive the lease.
      */
-    async claimBatch(home, batched) {
+    async claimBatch(home, batched, session) {
         const deliver = [];
         const held = [];
         for (const entry of batched) {
+            if ((await this.isReadOnly(session)))
+                break;
             if (entry.event?.type !== 'async_delegation') {
                 deliver.push(entry);
                 continue;
@@ -282,7 +496,10 @@ export class CompletionDrain {
             try {
                 if (!sidecar)
                     throw new Error('sidecar unavailable');
-                claimId = (await sidecar.call('process.claim_delivery', { profile_home: home, event: entry.event, consumer: DELIVERY_CONSUMER })).claim_id;
+                const claim = await sidecar.call('process.claim_delivery', { profile_home: home, event: entry.event, consumer: DELIVERY_CONSUMER });
+                if (claim.retryable)
+                    throw new Error('another consumer holds the pending result');
+                claimId = claim.claim_id;
             }
             catch (error) {
                 await this.settleClaims(home, 'process.release_delivery', held);
@@ -305,15 +522,18 @@ export class CompletionDrain {
     async settleClaims(home, method, held) {
         const sidecar = this.deps.sidecar();
         if (!sidecar)
-            return;
+            return held.length === 0;
+        let ok = true;
         for (const claim of held) {
             try {
                 await sidecar.call(method, { profile_home: home, event: claim.event, claim_id: claim.claim_id });
             }
             catch (error) {
+                ok = false;
                 this.deps.log(`[webui] WARNING: ${method} failed for ${str(claim.event.delegation_id)}: ${error.message}`);
             }
         }
+        return ok;
     }
     scheduleRetry(sid) {
         const attempts = (this.retryAttempts.get(sid) ?? 0) + 1;
@@ -322,24 +542,159 @@ export class CompletionDrain {
             this.deps.log(`[webui] WARNING: server-side wakeup retry budget exhausted for session ${sid}; deferred entries wait for the next turn teardown`);
             return;
         }
+        this.scheduleDrain(sid, WAKEUP_RETRY_SECONDS);
+    }
+    scheduleDrain(sid, delaySeconds) {
         const existing = this.retryTimers.get(sid);
         if (existing)
             clearTimeout(existing);
-        const timer = setTimeout(() => { this.retryTimers.delete(sid); void this.drainDeferred(sid); }, WAKEUP_RETRY_SECONDS * 1000);
+        const timer = setTimeout(() => { this.retryTimers.delete(sid); void this.drainDeferred(sid); }, Math.max(0, delaySeconds) * 1000);
         timer.unref();
         this.retryTimers.set(sid, timer);
     }
+    /** TAL-576: `usage.pool` for the provider whose pool ran dry, through `poolRecovery`; null when the sidecar cannot say. */
+    async poolRecovery(home, session) {
+        const sidecar = this.deps.sidecar();
+        const pause = session.process_wakeup_pause;
+        const provider = str(isDict(pause) ? pause.pool_provider : '').trim() || str(session.model_provider).trim();
+        if (!sidecar || !provider)
+            return null;
+        try {
+            return poolRecovery((await sidecar.call('usage.pool', { profile_home: home, provider })).entries, this.deps.now());
+        }
+        catch {
+            return null;
+        }
+    }
+    /** A restarted server resumes every session it left holding wakeups (`startWakeup` drops a deleted session's). */
+    async resumeHeld() {
+        let sids;
+        try {
+            sids = (await this.heldWakeups.sessions());
+        }
+        catch (error) {
+            this.deps.log(`[webui] WARNING: held wakeups unreadable; retrying: ${error.message}`);
+            return;
+        }
+        this.heldResumed = true;
+        for (const sid of sids)
+            void this.drainDeferred(sid);
+    }
+    async held(sid) {
+        if (this.unreleased.has(sid))
+            (await this.release(sid, []));
+        const done = new Set((this.unreleased.get(sid) ?? []).map(heldKey));
+        try {
+            return (await this.heldWakeups.get(sid)).filter((e) => !done.has(heldKey(e)));
+        }
+        catch (error) {
+            // An unreadable store is unknown, not empty: recheck later rather than leave the session dormant.
+            this.scheduleDrain(sid, HELD_RECHECK_SECONDS);
+            this.deps.log(`[webui] WARNING: held wakeups unreadable for session ${sid}; retrying: ${error.message}`);
+            return [];
+        }
+    }
+    /** A session whose file is gone was deleted; any other load failure keeps its wakeups. */
+    async deleted(sid, error) {
+        return error instanceof SessionNotFound && !await this.deps.store.exists(sid);
+    }
+    /** Admitted or settled wakeups (every one, with none given) leave the held file. */
+    async release(sid, entries) {
+        // Earlier releases that could not be written go with this one.
+        const batch = entries ? mergeWakeups([...(this.unreleased.get(sid) ?? [])], entries) : undefined;
+        try {
+            await this.heldWakeups.release(sid, batch);
+            this.unreleased.delete(sid);
+        }
+        catch (error) {
+            if (batch)
+                this.unreleased.set(sid, batch);
+            this.deps.log(`[webui] WARNING: failed to release held wakeups for session ${sid}; they are not delivered again: ${error.message}`);
+        }
+    }
+    async saveSession(sid, session) {
+        try {
+            (await this.deps.store.save(session, { touchUpdatedAt: false }));
+        }
+        catch (error) {
+            this.deps.log(`[webui] WARNING: failed to save wakeup pause for session ${sid}: ${error.message}`);
+        }
+    }
+    /**
+     * TAL-576: while the provider has no usable credentials no wakeup turn starts. The entries are held until a turn
+     * admits them, and a timer rechecks the pause at the pool's earliest retry deadline, at least every five minutes.
+     * Returns whether the wakeup is handled here (held, or dropped with its deleted session).
+     */
+    async holdWhilePaused(sid, session, home, batched) {
+        if ((await this.isReadOnly(session))) {
+            await this.relinquish(sid, session, batched);
+            return true;
+        }
+        const pause = session.process_wakeup_pause;
+        if (!wakeupPaused(session, home, this.deps.configPath?.(home))) {
+            if (pause !== session.process_wakeup_pause)
+                (await this.saveSession(sid, session));
+            return false;
+        }
+        const recovery = await this.poolRecovery(home, session);
+        // A turn that succeeded or a provider switched during the lookup lifted the pause already.
+        // A deleted session owns no turn; a transient load failure holds the wakeups for the next recheck.
+        let current = null;
+        try {
+            current = (await this.deps.store.get(sid));
+        }
+        catch (error) {
+            if ((await this.deleted(sid, error))) {
+                (await this.release(sid));
+                return true;
+            }
+        }
+        if (current) {
+            if ((await this.isReadOnly(current))) {
+                await this.relinquish(sid, current, batched);
+                return true;
+            }
+            const before = current.process_wakeup_pause;
+            if (recovery === true)
+                current.process_wakeup_pause = null;
+            if (recovery === true || !wakeupPaused(current, home, this.deps.configPath?.(home))) {
+                if (before !== current.process_wakeup_pause)
+                    (await this.saveSession(sid, current));
+                return false;
+            }
+        }
+        try {
+            (await this.heldWakeups.hold(sid, batched));
+        }
+        catch (error) {
+            for (const e of batched)
+                this.defer(sid, e);
+            this.deps.log(`[webui] WARNING: failed to persist held wakeups for session ${sid}; kept in memory: ${error.message}`);
+        }
+        this.retryAttempts.delete(sid);
+        this.scheduleDrain(sid, typeof recovery === 'number' ? Math.min(recovery - this.deps.now(), HELD_RECHECK_SECONDS) : HELD_RECHECK_SECONDS);
+        this.deps.log(`[webui] server-side wakeup paused for session ${sid}: provider credential pool is empty`);
+        return true;
+    }
     /** Python `_start_server_side_wakeup_turn`: one batched turn; 409 re-defers, other failures re-defer with a timed retry. */
-    async startWakeup(sid, batched) {
+    async startWakeup(sid, wakeups) {
+        let batched = wakeups;
         const redefer = (entries) => { for (const e of entries)
-            this.recordDeferred(sid, e.process_id, e.wakeup_prompt, e.event); };
+            this.defer(sid, e); };
         let session;
         try {
-            session = this.deps.store.get(sid);
+            session = (await this.deps.store.get(sid));
         }
-        catch {
+        catch (error) {
+            // A deleted session owns no turn: its wakeups, held ones included, go with it.
+            if ((await this.deleted(sid, error))) {
+                (await this.release(sid));
+                this.deps.log(`[webui] server-side wakeup dropped for deleted session ${sid}`);
+                return false;
+            }
             redefer(batched);
-            this.deps.log(`[webui] WARNING: server-side wakeup retained for session ${sid}: session unavailable`);
+            this.scheduleRetry(sid);
+            this.deps.log(`[webui] WARNING: server-side wakeup retained for session ${sid}: session unavailable; retrying`);
             return false;
         }
         if (session.pre_compression_snapshot) {
@@ -348,17 +703,75 @@ export class CompletionDrain {
             return false;
         }
         // TAL-534: the delegation's ledger row lives in the session's own profile, whichever profile is active now.
-        const home = this.deps.profileHome(session.profile ?? this.deps.activeProfile());
-        const claimed = await this.claimBatch(home, batched);
+        let home;
+        try {
+            home = this.ownerHome(session);
+        }
+        catch (error) {
+            redefer(batched);
+            this.deps.log(`[webui] WARNING: server-side wakeup retained for session ${sid}: ${error.message}`);
+            return false;
+        }
+        if ((await this.isReadOnly(session))) {
+            await this.relinquish(sid, session, batched);
+            return false;
+        }
+        const accepted = batched.filter((e) => completionAccepted(session, completionKey(home, e.event ?? {})));
+        if (accepted.length) {
+            // A crash may have saved admission before acknowledging the Agent. Finish that handshake without a new turn.
+            const claims = await this.claimBatch(home, accepted, session);
+            if (claims && (await this.isReadOnly(session))) {
+                await this.relinquish(sid, session, batched, claims.held);
+                return false;
+            }
+            if (!claims || !(await this.settleClaims(home, 'process.complete_delivery', claims.held))) {
+                redefer(batched);
+                this.scheduleRetry(sid);
+                return false;
+            }
+            await this.release(sid, accepted);
+            batched = batched.filter((e) => !accepted.includes(e));
+        }
+        if (!batched.length)
+            return false;
+        // TAL-907: `off` mutes process-driven wakeups at delivery, so a deferred or held wakeup follows the current setting; the
+        // drained event's record and status row are its whole delivery. A subagent result is not a process notification and
+        // still lands, as in the Agent. A setting that cannot be read retains the wakeups rather than start a turn.
+        const muted = batched.filter((e) => e.event?.type !== 'async_delegation');
+        if (muted.length) {
+            const off = await this.notificationsOff(home);
+            if (off === null) {
+                redefer(batched);
+                this.scheduleRetry(sid);
+                this.deps.log(`[webui] WARNING: server-side wakeup retained for session ${sid}: background_process_notifications is unreadable; retrying`);
+                return false;
+            }
+            if (off) {
+                await this.release(sid, muted);
+                batched = batched.filter((e) => !muted.includes(e));
+                if (!batched.length) {
+                    this.retryAttempts.delete(sid);
+                    return false;
+                }
+            }
+        }
+        if (await this.holdWhilePaused(sid, session, home, batched))
+            return false;
+        const claimed = await this.claimBatch(home, batched, session);
         if (!claimed) {
             redefer(batched);
             this.scheduleRetry(sid);
             return false;
         }
         const { deliver, held } = claimed;
+        if ((await this.isReadOnly(session))) {
+            await this.relinquish(sid, session, batched, held);
+            return false;
+        }
         // Entries another consumer already delivered are done here too.
         if (!deliver.length) {
-            await this.markConsumed(batched.map((e) => e.process_id));
+            (await this.release(sid, batched));
+            await this.markConsumed(batched);
             return true;
         }
         // A wakeup that does not start hands its claims back, so those rows stay pending for the retry or the next restart.
@@ -366,7 +779,7 @@ export class CompletionDrain {
         const prompt = deliver.length === 1 ? deliver[0].wakeup_prompt : deliver.map((e) => e.wakeup_prompt).join('\n\n');
         let resp;
         try {
-            resp = this.deps.startTurn(session, prompt);
+            resp = await this.deps.startTurn(session, prompt, deliver.map((e) => completionKey(home, e.event ?? {})).filter(Boolean), batchUpdate(deliver.map((e) => ({ event: e.event ?? {}, prompt: e.wakeup_prompt }))));
         }
         catch (error) {
             await giveBack();
@@ -374,9 +787,16 @@ export class CompletionDrain {
             this.deps.log(`[webui] WARNING: server-side wakeup turn raised for session ${sid}: ${error.message}`);
             return false;
         }
+        if ((await this.isReadOnly(session))) {
+            await this.relinquish(sid, session, batched, held);
+            return false;
+        }
         const status = resp._status ?? (resp.stream_id ? 200 : 500);
+        // A busy session redelivers at its turn teardown; a stale runtime admits no turn, so it is retried on a timer (TAL-577).
         if (status === 409) {
             await giveBack('process.defer_delivery');
+            if (resp.retryable)
+                this.scheduleRetry(sid);
             return false;
         }
         if (status >= 400) {
@@ -387,8 +807,14 @@ export class CompletionDrain {
         }
         this.retryAttempts.delete(sid);
         recordBackgroundUpdate(session, str(resp.stream_id), batchUpdate(deliver.map((e) => ({ event: e.event ?? {}, prompt: e.wakeup_prompt }))));
-        await this.settleClaims(home, 'process.complete_delivery', held);
-        await this.markConsumed(batched.map((e) => e.process_id));
+        await this.saveSession(sid, session);
+        if (await this.settleClaims(home, 'process.complete_delivery', held))
+            (await this.release(sid, batched));
+        else {
+            redefer(deliver);
+            this.scheduleRetry(sid);
+        }
+        await this.markConsumed(batched);
         this.deps.log(`[webui] server-side wakeup turn started for session ${sid} (stream_id=${str(resp.stream_id)})`);
         return true;
     }
@@ -399,7 +825,7 @@ export class CompletionDrain {
      * A failed check delivers everything rather than lose a result.
      */
     async alreadyConsumed(entries) {
-        const completions = entries.filter((e) => e.process_id && str(e.event?.type ?? 'completion') === 'completion');
+        const completions = entries.filter(isCompletion);
         const sidecar = this.deps.sidecar();
         if (!completions.length || !sidecar)
             return new Set();
@@ -411,20 +837,31 @@ export class CompletionDrain {
             return new Set();
         }
     }
-    /** Python `drain_deferred_wakeups_for_session`: turn-teardown idle hook; only the last active stream's teardown fires. */
-    async drainDeferred(sid) {
+    /**
+     * Python `drain_deferred_wakeups_for_session`: turn-teardown idle hook; only the last active stream's teardown fires.
+     * TAL-576: one drain per session at a time, so two never copy the same held wakeups before either admits them.
+     */
+    drainDeferred(sid) {
+        const run = (this.drains.get(sid) ?? Promise.resolve(0)).catch(() => 0).then(async () => (await this.drainDeferredNow(sid)));
+        this.drains.set(sid, run);
+        void run.finally(() => { if (this.drains.get(sid) === run)
+            this.drains.delete(sid); }).catch(() => undefined);
+        return run;
+    }
+    async drainDeferredNow(sid) {
         if (!sid || this.hasActiveTurn(sid))
             return 0;
-        const entries = this.deferred.get(sid);
-        if (!entries?.length)
+        const entries = mergeWakeups([...(this.deferred.get(sid) ?? [])], (await this.held(sid)));
+        if (!entries.length)
             return 0;
         this.deferred.delete(sid);
         this.pendingSessions.delete(sid);
         const prompted = entries.filter((e) => e.wakeup_prompt.trim());
         const held = await this.alreadyConsumed(prompted);
         if (held.size) {
+            await this.release(sid, [...held]);
             const ids = [...held].map((e) => e.process_id);
-            await this.markConsumed(ids);
+            await this.markConsumed([...held]);
             this.deps.log(`[webui] dropped ${String(held.size)} deferred wakeup(s) already consumed by the agent's own turn for session ${sid}: ${ids.join(', ')}`);
         }
         const pending = prompted.filter((e) => !held.has(e));
@@ -437,7 +874,7 @@ export class CompletionDrain {
         for (const entry of pending) {
             const size = entry.wakeup_prompt.length;
             if (batch.length && total + size > WAKEUP_BATCH_MAX_CHARS) {
-                this.recordDeferred(sid, entry.process_id, entry.wakeup_prompt, entry.event);
+                this.defer(sid, entry);
                 continue;
             }
             batch.push(entry);