@maudecode/talaria-web 1.18.0 → 1.19.0

package/dist/sessions/completions.js

@@ -7,12 +7,14 @@
  * redelivered at turn teardown with a bounded retry budget).
  */
 import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { SessionNotFound } from './store.js';
 import { str } from '../util.js';
-import { isDict } from './merge.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;
@@ -22,6 +24,13 @@ 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');
@@ -38,7 +47,7 @@ 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;
@@ -75,9 +84,22 @@ export class CompletionDrain {
     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(join(deps.store.sessionDir, '_wakeup_held.json'));
+        this.heldWakeups = new HeldWakeups(deps.documents);
     }
     start() {
         if (this.timer || this.stopped)
@@ -133,7 +155,7 @@ export class CompletionDrain {
         }
         // TAL-576: whether or not every profile recovered, the sessions left holding wakeups resume once a sidecar answers.
         if (!this.heldResumed)
-            this.resumeHeld();
+            (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;
@@ -166,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)
@@ -192,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 '';
@@ -205,30 +228,175 @@ 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);
         // 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;
-            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));
-        if (!prompt)
+        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;
         const entry = { process_id: deliveryKey(evt, processId), wakeup_prompt: prompt, event: evt };
-        if (this.hasActiveTurn(sid))
+        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);
+        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 (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, [entry]);
@@ -313,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;
@@ -326,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);
@@ -349,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;
@@ -391,10 +567,10 @@ export class CompletionDrain {
         }
     }
     /** A restarted server resumes every session it left holding wakeups (`startWakeup` drops a deleted session's). */
-    resumeHeld() {
+    async resumeHeld() {
         let sids;
         try {
-            sids = this.heldWakeups.sessions();
+            sids = (await this.heldWakeups.sessions());
         }
         catch (error) {
             this.deps.log(`[webui] WARNING: held wakeups unreadable; retrying: ${error.message}`);
@@ -404,12 +580,12 @@ export class CompletionDrain {
         for (const sid of sids)
             void this.drainDeferred(sid);
     }
-    held(sid) {
+    async held(sid) {
         if (this.unreleased.has(sid))
-            this.release(sid, []);
+            (await this.release(sid, []));
         const done = new Set((this.unreleased.get(sid) ?? []).map(heldKey));
         try {
-            return this.heldWakeups.get(sid).filter((e) => !done.has(heldKey(e)));
+            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.
@@ -419,15 +595,15 @@ export class CompletionDrain {
         }
     }
     /** A session whose file is gone was deleted; any other load failure keeps its wakeups. */
-    deleted(sid, error) {
-        return error instanceof SessionNotFound && !existsSync(this.deps.store.pathFor(sid));
+    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. */
-    release(sid, entries) {
+    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 {
-            this.heldWakeups.release(sid, batch);
+            await this.heldWakeups.release(sid, batch);
             this.unreleased.delete(sid);
         }
         catch (error) {
@@ -436,9 +612,9 @@ export class CompletionDrain {
             this.deps.log(`[webui] WARNING: failed to release held wakeups for session ${sid}; they are not delivered again: ${error.message}`);
         }
     }
-    saveSession(sid, session) {
+    async saveSession(sid, session) {
         try {
-            this.deps.store.save(session, { touchUpdatedAt: false });
+            (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}`);
@@ -450,10 +626,14 @@ export class CompletionDrain {
      * 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)
-                this.saveSession(sid, session);
+                (await this.saveSession(sid, session));
             return false;
         }
         const recovery = await this.poolRecovery(home, session);
@@ -461,26 +641,30 @@ export class CompletionDrain {
         // A deleted session owns no turn; a transient load failure holds the wakeups for the next recheck.
         let current = null;
         try {
-            current = this.deps.store.get(sid);
+            current = (await this.deps.store.get(sid));
         }
         catch (error) {
-            if (this.deleted(sid, error)) {
-                this.release(sid);
+            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)
-                    this.saveSession(sid, current);
+                    (await this.saveSession(sid, current));
                 return false;
             }
         }
         try {
-            this.heldWakeups.hold(sid, batched);
+            (await this.heldWakeups.hold(sid, batched));
         }
         catch (error) {
             for (const e of batched)
@@ -493,17 +677,18 @@ export class CompletionDrain {
         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.defer(sid, e); };
         let session;
         try {
-            session = this.deps.store.get(sid);
+            session = (await this.deps.store.get(sid));
         }
         catch (error) {
             // A deleted session owns no turn: its wakeups, held ones included, go with it.
-            if (this.deleted(sid, error)) {
-                this.release(sid);
+            if ((await this.deleted(sid, error))) {
+                (await this.release(sid));
                 this.deps.log(`[webui] server-side wakeup dropped for deleted session ${sid}`);
                 return false;
             }
@@ -520,25 +705,72 @@ export class CompletionDrain {
         // TAL-534: the delegation's ledger row lives in the session's own profile, whichever profile is active now.
         let home;
         try {
-            home = this.deps.profileHome(session.profile ?? this.deps.activeProfile());
+            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);
+        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) {
-            this.release(sid, batched);
+            (await this.release(sid, batched));
             await this.markConsumed(batched);
             return true;
         }
@@ -547,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 = await 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();
@@ -555,6 +787,10 @@ 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) {
@@ -570,9 +806,14 @@ export class CompletionDrain {
             return false;
         }
         this.retryAttempts.delete(sid);
-        this.release(sid, batched);
         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.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;
@@ -601,7 +842,7 @@ export class CompletionDrain {
      * 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(() => this.drainDeferredNow(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);
@@ -610,7 +851,7 @@ export class CompletionDrain {
     async drainDeferredNow(sid) {
         if (!sid || this.hasActiveTurn(sid))
             return 0;
-        const entries = mergeWakeups([...(this.deferred.get(sid) ?? [])], this.held(sid));
+        const entries = mergeWakeups([...(this.deferred.get(sid) ?? [])], (await this.held(sid)));
         if (!entries.length)
             return 0;
         this.deferred.delete(sid);
@@ -618,7 +859,7 @@ export class CompletionDrain {
         const prompted = entries.filter((e) => e.wakeup_prompt.trim());
         const held = await this.alreadyConsumed(prompted);
         if (held.size) {
-            this.release(sid, [...held]);
+            await this.release(sid, [...held]);
             const ids = [...held].map((e) => e.process_id);
             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(', ')}`);