@maudecode/talaria-web 1.16.1 → 1.18.0

package/dist/sessions/completions.d.ts

@@ -1,31 +1,43 @@
 import type { SidecarLike } from '../sidecar/client.js';
 import type { SessionChannels, StreamRegistry } from './streams.js';
-import type { SessionStore } from './store.js';
+import { type SessionStore } from './store.js';
 import type { Session } from './session.js';
 import type { BackgroundActivity } from './background-tasks.js';
 type Dict = Record<string, unknown>;
 export declare const COMPLETION_POLL_MS = 1000;
+interface StartedTurn {
+    _status?: number;
+    error?: string;
+    stream_id?: string;
+    retryable?: boolean;
+}
 export interface CompletionDrainDeps {
     sidecar: () => SidecarLike | null;
+    /** The base Hermes home: every profile under it has its background processes recovered in a new sidecar (TAL-533). */
+    baseHome: string;
     profileHome: (profile: string | null) => string;
     activeProfile: () => string;
     store: SessionStore;
     channels: SessionChannels;
     registry: StreamRegistry;
-    /** Start a server-side turn; `_status` 409 means a turn is already active. */
-    startTurn: (session: Session, prompt: string) => {
-        _status?: number;
-        error?: string;
-        stream_id?: string;
-    };
+    /** Start a server-side turn; `_status` 409 means a turn is already active, or with `retryable` that the Agent runtime is stale. */
+    startTurn: (session: Session, prompt: string) => StartedTurn | Promise<StartedTurn>;
     now: () => number;
     log: (line: string) => void;
     pollMs?: number;
+    /** TAL-576: the profile's authoritative config file (`AgentConfig.path`); `<home>/config.yaml` when absent. */
+    configPath?: (profileHome: string) => string;
     /** TAL-372: each routed completion settles its background record. */
     background?: Pick<BackgroundActivity, 'recordEvent'>;
 }
 /** Python `format_wakeup_prompt` for plain completion events; async delegations use the sidecar formatter. */
 export declare function formatWakeupPrompt(evt: Dict): string | null;
+/**
+ * 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 declare function deliveryKey(evt: Dict, processId: string): string;
 export declare class CompletionDrain {
     private readonly deps;
     private timer;
@@ -37,6 +49,16 @@ export declare class CompletionDrain {
     private readonly retryTimers;
     private readonly lastEmitAt;
     private readonly pendingEmit;
+    /** The handshake of the sidecar whose process registry already recovered every profile's checkpoint. */
+    private recoveredFor;
+    private recoveryWarnedFor;
+    private lastDrainError;
+    private heldResumed;
+    private readonly drains;
+    /** Admitted wakeups whose release could not be written: never delivered again, and the release is retried. */
+    private readonly unreleased;
+    /** TAL-576: wakeups held while their session is paused. */
+    private readonly heldWakeups;
     constructor(deps: CompletionDrainDeps);
     start(): void;
     stop(): void;
@@ -52,7 +74,10 @@ export declare class CompletionDrain {
     /** Python `_emit_bg_task_complete_events_coalesced`: first emit immediately, bursts flush the latest payload after 1 s of quiet. */
     private emitCoalesced;
     recordDeferred(sid: string, processId: string, prompt: string, event?: Dict): void;
+    /** Re-deferring keeps an entry's delivery identity, so its held copy and this one stay one wakeup. */
+    private defer;
     deferredCount(sid: string): number;
+    /** Delivering a process's exit consumes it; a watch event leaves the exit to be delivered (TAL-724). */
     private markConsumed;
     /**
      * TAL-459: claim each async delegation in the Agent's durable ledger right before delivering it. A refused claim means
@@ -66,12 +91,39 @@ export declare class CompletionDrain {
      * lease bounds a lost hand-back.
      */
     private settleClaims;
-    private profileHome;
     private scheduleRetry;
+    private scheduleDrain;
+    /** TAL-576: `usage.pool` for the provider whose pool ran dry, through `poolRecovery`; null when the sidecar cannot say. */
+    private poolRecovery;
+    /** A restarted server resumes every session it left holding wakeups (`startWakeup` drops a deleted session's). */
+    private resumeHeld;
+    private held;
+    /** A session whose file is gone was deleted; any other load failure keeps its wakeups. */
+    private deleted;
+    /** Admitted or settled wakeups (every one, with none given) leave the held file. */
+    private release;
+    private saveSession;
+    /**
+     * 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).
+     */
+    private holdWhilePaused;
     /** Python `_start_server_side_wakeup_turn`: one batched turn; 409 re-defers, other failures re-defer with a timed retry. */
     private startWakeup;
-    /** Python `drain_deferred_wakeups_for_session`: turn-teardown idle hook; only the last active stream's teardown fires. */
+    /**
+     * TAL-532: the deferred process completions the agent already holds from its own turn (wait/log or poll). Checked at
+     * delivery, not drain: the completion is usually drained seconds before the agent's wait returns. Only completions:
+     * consuming the exit says nothing about a watch match or notice, and async delegations settle in their delivery ledger.
+     * A failed check delivers everything rather than lose a result.
+     */
+    private alreadyConsumed;
+    /**
+     * 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: string): Promise<number>;
+    private drainDeferredNow;
     /** Reaper sweep: forget dedupe sets for sessions with nothing pending. */
     sweep(): void;
 }

package/dist/sessions/completions.js

@@ -7,13 +7,20 @@
  * 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 { SessionNotFound } from './store.js';
 import { str } from '../util.js';
+import { isDict } from './merge.js';
 import { batchUpdate, recordBackgroundUpdate } from './background-updates.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';
 /** Python `format_wakeup_prompt` for plain completion events; async delegations use the sidecar formatter. */
 export function formatWakeupPrompt(evt) {
@@ -37,6 +44,16 @@ export function formatWakeupPrompt(evt) {
         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;
@@ -48,8 +65,19 @@ export class CompletionDrain {
     retryTimers = new Map();
     lastEmitAt = new Map();
     pendingEmit = new Map();
+    /** The handshake of the sidecar whose process registry already recovered every profile's checkpoint. */
+    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;
     constructor(deps) {
         this.deps = deps;
+        this.heldWakeups = new HeldWakeups(join(deps.store.sessionDir, '_wakeup_held.json'));
     }
     start() {
         if (this.timer || this.stopped)
@@ -57,7 +85,13 @@ export class CompletionDrain {
         const tick = () => {
             if (this.stopped)
                 return;
-            void this.drainOnce().catch((error) => { this.deps.log(`[webui] WARNING: bg_task_complete drain failed: ${error.message}`); }).finally(() => {
+            // A lasting failure (an unrecoverable checkpoint fails every call in its home, TAL-533) is logged once, not every poll.
+            void this.drainOnce().then(() => { this.lastDrainError = null; }, (error) => {
+                const message = error.message;
+                if (message !== this.lastDrainError)
+                    this.deps.log(`[webui] WARNING: bg_task_complete drain failed: ${message}`);
+                this.lastDrainError = message;
+            }).finally(() => {
                 if (this.stopped)
                     return;
                 this.timer = setTimeout(tick, this.deps.pollMs ?? COMPLETION_POLL_MS);
@@ -82,7 +116,34 @@ export class CompletionDrain {
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return 0;
-        const { events } = await sidecar.call('process.drain', { profile_home: this.deps.profileHome(this.deps.activeProfile()), max_events: 256 });
+        // Each sidecar handshake is a fresh process registry: re-adopt every profile's checkpointed processes before the first
+        // drain, so one that exits in a profile nobody has used since the restart still reports its completion.
+        const describe = sidecar.describe;
+        if (describe && describe !== this.recoveredFor) {
+            try {
+                await sidecar.call('process.recover', { base_home: this.deps.baseHome });
+                this.recoveredFor = describe;
+            }
+            catch (error) {
+                // Retried on every pass; reported once per sidecar so a lasting failure does not flood the log.
+                if (this.recoveryWarnedFor !== describe)
+                    this.deps.log(`[webui] WARNING: background process recovery failed; retrying: ${error.message}`);
+                this.recoveryWarnedFor = describe;
+            }
+        }
+        // TAL-576: whether or not every profile recovered, the sessions left holding wakeups resume once a sidecar answers.
+        if (!this.heldResumed)
+            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) {
@@ -154,20 +215,23 @@ export class CompletionDrain {
             return true;
         const seen = this.seen.get(sid) ?? new Set();
         this.seen.set(sid, seen);
-        if (processId && seen.has(processId))
-            return true;
-        if (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;
             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)
             return true;
+        const entry = { process_id: deliveryKey(evt, processId), wakeup_prompt: prompt, event: evt };
         if (this.hasActiveTurn(sid))
-            this.recordDeferred(sid, processId, prompt, evt);
+            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) {
@@ -218,21 +282,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 });
             }
@@ -244,7 +313,7 @@ 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(batched) {
+    async claimBatch(home, batched) {
         const deliver = [];
         const held = [];
         for (const entry of batched) {
@@ -257,10 +326,10 @@ export class CompletionDrain {
             try {
                 if (!sidecar)
                     throw new Error('sidecar unavailable');
-                claimId = (await sidecar.call('process.claim_delivery', { profile_home: this.profileHome(), event: entry.event, consumer: DELIVERY_CONSUMER })).claim_id;
+                claimId = (await sidecar.call('process.claim_delivery', { profile_home: home, event: entry.event, consumer: DELIVERY_CONSUMER })).claim_id;
             }
             catch (error) {
-                await this.settleClaims('process.release_delivery', held);
+                await this.settleClaims(home, 'process.release_delivery', held);
                 this.deps.log(`[webui] WARNING: async delegation delivery claim failed for ${entry.process_id}: ${error.message}; kept pending`);
                 return null;
             }
@@ -277,20 +346,19 @@ export class CompletionDrain {
      * attempt spent), `release` when it failed (spends one; the Agent drops a row past its budget). Best effort: the Agent's
      * lease bounds a lost hand-back.
      */
-    async settleClaims(method, held) {
+    async settleClaims(home, method, held) {
         const sidecar = this.deps.sidecar();
         if (!sidecar)
             return;
         for (const claim of held) {
             try {
-                await sidecar.call(method, { profile_home: this.profileHome(), event: claim.event, claim_id: claim.claim_id });
+                await sidecar.call(method, { profile_home: home, event: claim.event, claim_id: claim.claim_id });
             }
             catch (error) {
                 this.deps.log(`[webui] WARNING: ${method} failed for ${str(claim.event.delegation_id)}: ${error.message}`);
             }
         }
     }
-    profileHome() { return this.deps.profileHome(this.deps.activeProfile()); }
     scheduleRetry(sid) {
         const attempts = (this.retryAttempts.get(sid) ?? 0) + 1;
         this.retryAttempts.set(sid, attempts);
@@ -298,24 +366,150 @@ 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). */
+    resumeHeld() {
+        let sids;
+        try {
+            sids = 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);
+    }
+    held(sid) {
+        if (this.unreleased.has(sid))
+            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)));
+        }
+        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. */
+    deleted(sid, error) {
+        return error instanceof SessionNotFound && !existsSync(this.deps.store.pathFor(sid));
+    }
+    /** Admitted or settled wakeups (every one, with none given) leave the held file. */
+    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);
+            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}`);
+        }
+    }
+    saveSession(sid, session) {
+        try {
+            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) {
+        const pause = session.process_wakeup_pause;
+        if (!wakeupPaused(session, home, this.deps.configPath?.(home))) {
+            if (pause !== session.process_wakeup_pause)
+                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 = this.deps.store.get(sid);
+        }
+        catch (error) {
+            if (this.deleted(sid, error)) {
+                this.release(sid);
+                return true;
+            }
+        }
+        if (current) {
+            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);
+                return false;
+            }
+        }
+        try {
+            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) {
         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);
         }
-        catch {
+        catch (error) {
+            // A deleted session owns no turn: its wakeups, held ones included, go with it.
+            if (this.deleted(sid, error)) {
+                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) {
@@ -323,7 +517,19 @@ export class CompletionDrain {
             this.deps.log(`[webui] WARNING: automatic wakeup retained: sealed snapshot ${sid} cannot own a turn`);
             return false;
         }
-        const claimed = await this.claimBatch(batched);
+        // 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());
+        }
+        catch (error) {
+            redefer(batched);
+            this.deps.log(`[webui] WARNING: server-side wakeup retained for session ${sid}: ${error.message}`);
+            return false;
+        }
+        if (await this.holdWhilePaused(sid, session, home, batched))
+            return false;
+        const claimed = await this.claimBatch(home, batched);
         if (!claimed) {
             redefer(batched);
             this.scheduleRetry(sid);
@@ -332,15 +538,16 @@ export class CompletionDrain {
         const { deliver, held } = claimed;
         // Entries another consumer already delivered are done here too.
         if (!deliver.length) {
-            await this.markConsumed(batched.map((e) => e.process_id));
+            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.
-        const giveBack = async (method = 'process.release_delivery') => { await this.settleClaims(method, held); redefer(deliver); };
+        const giveBack = async (method = 'process.release_delivery') => { await this.settleClaims(home, method, held); redefer(deliver); };
         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);
         }
         catch (error) {
             await giveBack();
@@ -349,8 +556,11 @@ export class CompletionDrain {
             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) {
@@ -360,22 +570,60 @@ 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('process.complete_delivery', held);
-        await this.markConsumed(batched.map((e) => e.process_id));
+        await this.settleClaims(home, 'process.complete_delivery', held);
+        await this.markConsumed(batched);
         this.deps.log(`[webui] server-side wakeup turn started for session ${sid} (stream_id=${str(resp.stream_id)})`);
         return true;
     }
-    /** Python `drain_deferred_wakeups_for_session`: turn-teardown idle hook; only the last active stream's teardown fires. */
-    async drainDeferred(sid) {
+    /**
+     * TAL-532: the deferred process completions the agent already holds from its own turn (wait/log or poll). Checked at
+     * delivery, not drain: the completion is usually drained seconds before the agent's wait returns. Only completions:
+     * consuming the exit says nothing about a watch match or notice, and async delegations settle in their delivery ledger.
+     * A failed check delivers everything rather than lose a result.
+     */
+    async alreadyConsumed(entries) {
+        const completions = entries.filter(isCompletion);
+        const sidecar = this.deps.sidecar();
+        if (!completions.length || !sidecar)
+            return new Set();
+        try {
+            const { consumed } = await sidecar.call('process.consumed', { process_ids: completions.map((e) => e.process_id) });
+            return new Set(completions.filter((e) => consumed.includes(e.process_id)));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    /**
+     * 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(() => 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) ?? [])], this.held(sid));
+        if (!entries.length)
             return 0;
         this.deferred.delete(sid);
         this.pendingSessions.delete(sid);
-        const pending = entries.filter((e) => e.wakeup_prompt.trim());
+        const prompted = entries.filter((e) => e.wakeup_prompt.trim());
+        const held = await this.alreadyConsumed(prompted);
+        if (held.size) {
+            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(', ')}`);
+        }
+        const pending = prompted.filter((e) => !held.has(e));
         if (!pending.length) {
             this.retryAttempts.delete(sid);
             return 0;
@@ -385,7 +633,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);