ftown 0.25.2 → 0.26.0

package/dist/mail-delivery.js

@@ -1,6 +1,8 @@
-import { createMailMessage } from './mail-store.js';
+import { createMailMessage, createNudgeToken } from './mail-store.js';
 import { HOOKED_SHELL_TYPES } from './harness-registry.js';
 import { createNativeMailWaker } from './native-mail.js';
+import { DIGEST_MAX, MAIL_TYPES_V2, MAX_WAKE_ATTEMPTS, NON_WAKING_MAIL_TYPES, } from './coordination/contract.js';
+export { MAIL_TYPES_V2, MAX_WAKE_ATTEMPTS, NON_WAKING_MAIL_TYPES };
 export const MAX_MAIL_BODY_LENGTH = 64 * 1024;
 export const MAX_MAIL_WAIT_SECONDS = 30;
 export const MAIL_NUDGE_DELAY_MS = 5_000;
@@ -40,7 +42,32 @@ export function parseNativeWakeRegistration(query) {
     }
     return { adapter, nativeSessionId };
 }
-export const MAIL_TYPES = ['message', 'task', 'result', 'escalation'];
+export const MAIL_TYPES = MAIL_TYPES_V2;
+const NUDGE_COUNT_ORDER = ['task', 'escalation', 'result', 'message'];
+export function countMailTypes(messages) {
+    const counts = {};
+    for (const msg of messages) {
+        if (NON_WAKING_MAIL_TYPES.has(msg.type))
+            continue;
+        counts[msg.type] = (counts[msg.type] ?? 0) + 1;
+    }
+    return counts;
+}
+export function formatNudgeText(counts, digest) {
+    const parts = [];
+    let total = 0;
+    for (const type of NUDGE_COUNT_ORDER) {
+        const count = counts[type] ?? 0;
+        if (count > 0) {
+            total += count;
+            parts.push(`${count} ${type}`);
+        }
+    }
+    const base = `[ftown] ${total} new mail (${parts.join(', ')}) — run: ftown harness mail read`;
+    const trimmedDigest = typeof digest === 'string' ? sanitizeMessageText(digest).slice(0, DIGEST_MAX) : '';
+    return trimmedDigest ? `${base} | ${trimmedDigest}` : base;
+}
+export const NUDGE_TEXT = formatNudgeText;
 // Composer TUIs detect pastes by input arrival rate; the submit CR must come well
 // after that window or it is treated as a pasted newline.
 const COMPOSER_PASTE_SETTLE_MS = 600;
@@ -85,14 +112,17 @@ export class MailDeliveryService {
     lastNudgeAt = new Map();
     agentBusySince = new Map();
     nativeLeases = new Map();
-    nativeBatches = new Map();
     selectionLocks = new Map();
     codexClaims = new Map();
     codexRetryAt = new Map();
+    batchAttempts = new Map();
+    museNativeTried = new Map();
     wakeLocks = new Map();
     wakeControllers = new Map();
     legacyReadyAt = new Map();
     lastInjection = new Map();
+    digestProvider = null;
+    eventSink = null;
     stopped = false;
     dependencyEpoch = 0;
     nativeWake;
@@ -120,11 +150,19 @@ export class MailDeliveryService {
             this.invalidateRecovery();
         this.runner = runner;
     }
+    setDigestProvider(p) {
+        this.digestProvider = p;
+    }
+    setEventSink(s) {
+        this.eventSink = s;
+    }
     invalidateRecovery() {
         this.dependencyEpoch++;
         for (const timer of this.nudgeTimers.values())
             this.clearTimeoutFn(timer);
         this.nudgeTimers.clear();
+        this.batchAttempts.clear();
+        this.museNativeTried.clear();
         for (const controller of this.wakeControllers.values())
             controller.abort();
     }
@@ -140,7 +178,7 @@ export class MailDeliveryService {
         if (!current() || !session || session.status !== 'running' || session.shellType === 'pi'
             || !runner.isRunning(sessionId))
             return;
-        const pending = await mailStore.listUndelivered(sessionId);
+        const pending = await mailStore.listUnnudgedWaking(sessionId);
         if (!current() || !pending.length || !runner.isRunning(sessionId))
             return;
         // Reads may have raced deletion/stop or an inbox drain. The wake path checks
@@ -167,9 +205,10 @@ export class MailDeliveryService {
             waiter.deliver([]);
         this.mailWaiters.clear();
         this.nativeLeases.clear();
-        this.nativeBatches.clear();
         this.legacyReadyAt.clear();
         this.codexRetryAt.clear();
+        this.batchAttempts.clear();
+        this.museNativeTried.clear();
         this.lastInjection.clear();
         for (const controller of this.wakeControllers.values())
             controller.abort();
@@ -218,7 +257,7 @@ export class MailDeliveryService {
     }
     available(sessionId, messages) {
         const claimed = this.codexClaims.get(sessionId);
-        return claimed ? messages.filter(message => message.id !== claimed) : messages;
+        return claimed?.size ? messages.filter(message => !claimed.has(message.id)) : messages;
     }
     /** Hook activity (UserPromptSubmit/PreToolUse/PostToolUse): the agent is mid-turn. */
     markAgentBusy(sessionId) {
@@ -240,8 +279,51 @@ export class MailDeliveryService {
         this.lastInjection.set(sessionId, { text, at: this.now() });
     }
     /** Let the API server record an opencode/claude-mod plugin handoff (mail handed to the plugin). */
-    notePluginHandoff(sessionId) {
+    async notePluginHandoff(sessionId) {
         this.recordInjection(sessionId, OPENCODE_MAIL_WAKE_TEXT);
+        const existingTimer = this.nudgeTimers.get(sessionId);
+        if (existingTimer) {
+            this.clearTimeoutFn(existingTimer);
+            this.nudgeTimers.delete(sessionId);
+        }
+        this.pendingNudgeFrom.delete(sessionId);
+        const mailStore = this.mailStore;
+        if (!mailStore)
+            return;
+        const token = createNudgeToken(this.now());
+        try {
+            const snapshot = await mailStore.listUnnudgedWaking(sessionId);
+            const undeliveredWaking = this.wakeLocks.has(sessionId)
+                ? (await mailStore.listUndelivered(sessionId)).filter((m) => !NON_WAKING_MAIL_TYPES.has(m.type))
+                : snapshot;
+            const batchIds = Array.from(new Set([...snapshot.map((m) => m.id), ...undeliveredWaking.map((m) => m.id)]));
+            if (batchIds.length === 0)
+                return;
+            await this.withSelection(sessionId, async () => {
+                await mailStore.markNudged(sessionId, batchIds, token);
+            });
+            const inFlightWake = this.wakeLocks.get(sessionId);
+            if (inFlightWake) {
+                void inFlightWake
+                    .then(async () => {
+                    const retryTimer = this.nudgeTimers.get(sessionId);
+                    if (retryTimer) {
+                        this.clearTimeoutFn(retryTimer);
+                        this.nudgeTimers.delete(sessionId);
+                    }
+                    this.pendingNudgeFrom.delete(sessionId);
+                    await this.withSelection(sessionId, async () => {
+                        await mailStore.markNudged(sessionId, batchIds, token);
+                    });
+                })
+                    .catch((err) => {
+                    console.error('[MailDelivery] Plugin handoff stamp failed:', err instanceof Error ? err.message : String(err));
+                });
+            }
+        }
+        catch (err) {
+            console.error('[MailDelivery] Plugin handoff stamp failed:', err instanceof Error ? err.message : String(err));
+        }
     }
     /**
      * Whether a UserPromptSubmit hook payload was submitted by ftown itself (bridge or installed plugin).
@@ -288,6 +370,7 @@ export class MailDeliveryService {
             this.recordInjection(session.id, line);
         if (!this.runner.write(session.id, line))
             return false;
+        options?.onFirstWrite?.();
         // Composer TUIs detect pastes by input arrival rate; the submit CR must come well
         // after that window or it is treated as a pasted newline.
         await this.delay(COMPOSER_PASTE_SETTLE_MS);
@@ -333,6 +416,17 @@ export class MailDeliveryService {
         const threadId = typeof body.threadId === 'string' && body.threadId.trim() ? body.threadId.trim() : undefined;
         const msg = createMailMessage({ from, fromName, to: session.id, type, threadId, body: text });
         await this.mailStore.append(msg);
+        if (this.eventSink) {
+            const sink = this.eventSink;
+            try {
+                void Promise.resolve(sink.onAccepted(msg, session)).catch((err) => {
+                    console.error('[MailDelivery] Event sink failed:', err instanceof Error ? err.message : String(err));
+                });
+            }
+            catch (err) {
+                console.error('[MailDelivery] Event sink failed:', err instanceof Error ? err.message : String(err));
+            }
+        }
         await this.notifyCommittedMail(session, fromName ?? from);
         return { ok: true, id: msg.id };
     }
@@ -358,7 +452,7 @@ export class MailDeliveryService {
                     waiter.deliver(marked);
                 }
             }
-            pending = (await mailStore.listUndelivered(session.id)).length > 0;
+            pending = (await mailStore.listUnnudgedWaking(session.id)).length > 0;
         });
         if (pending && (!hadWaiter || session.shellType === 'codex') && session.shellType !== 'pi') {
             const legacyDelay = HOOKED_SHELL_TYPES.has(session.shellType ?? 'claude')
@@ -505,24 +599,57 @@ export class MailDeliveryService {
             return;
         }
         if (!runner || !runner.isRunning(sessionId) || session.status !== 'running') {
-            this.codexRetryAt.set(sessionId, this.now() + MAIL_NUDGE_BUSY_RECHECK_MS);
-            this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_BUSY_RECHECK_MS);
+            const pending = await this.withSelection(sessionId, async () => current() ? this.available(sessionId, await mailStore.listUnnudgedWaking(sessionId)) : []);
+            if (!current() || !pending.length) {
+                this.pendingNudgeFrom.delete(sessionId);
+                this.codexRetryAt.delete(sessionId);
+                this.batchAttempts.delete(sessionId);
+                return;
+            }
+            const batchIds = pending.map((m) => m.id);
+            const batchKey = batchIds.slice().sort().join(',');
+            const prev = this.batchAttempts.get(sessionId);
+            const attempts = (prev?.key === batchKey ? prev.count : 0) + 1;
+            if (attempts >= MAX_WAKE_ATTEMPTS) {
+                const token = createNudgeToken(this.now());
+                await this.withSelection(sessionId, async () => {
+                    if (!current())
+                        return;
+                    await mailStore.markNudged(sessionId, batchIds, token);
+                });
+                this.batchAttempts.delete(sessionId);
+                this.codexRetryAt.delete(sessionId);
+                this.pendingNudgeFrom.delete(sessionId);
+            }
+            else {
+                this.batchAttempts.set(sessionId, { key: batchKey, count: attempts });
+                this.codexRetryAt.set(sessionId, this.now() + MAIL_NUDGE_BUSY_RECHECK_MS);
+                this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_BUSY_RECHECK_MS);
+            }
             return;
         }
-        const message = await this.withSelection(sessionId, async () => {
+        let claimSet;
+        const batch = await this.withSelection(sessionId, async () => {
             if (!current())
-                return undefined;
-            const pending = this.available(sessionId, await mailStore.listUndelivered(sessionId));
+                return [];
+            const pending = this.available(sessionId, await mailStore.listUnnudgedWaking(sessionId));
             if (!current() || !pending.length)
-                return undefined;
-            this.codexClaims.set(sessionId, pending[0].id);
-            return pending[0];
+                return [];
+            claimSet = new Set(pending.map(m => m.id));
+            this.codexClaims.set(sessionId, claimSet);
+            return pending;
         });
-        if (!message)
+        if (!batch.length || !claimSet) {
+            this.pendingNudgeFrom.delete(sessionId);
+            this.codexRetryAt.delete(sessionId);
+            this.batchAttempts.delete(sessionId);
             return;
+        }
+        const batchIds = batch.map(m => m.id);
+        const batchKey = batchIds.slice().sort().join(',');
         if (!current()) {
             await this.withSelection(sessionId, async () => {
-                if (this.codexClaims.get(sessionId) === message.id)
+                if (this.codexClaims.get(sessionId) === claimSet)
                     this.codexClaims.delete(sessionId);
             });
             return;
@@ -536,22 +663,25 @@ export class MailDeliveryService {
                 if (!current() || controller.signal.aborted)
                     return false;
                 const live = await store.loadSession(sessionId);
-                const pending = await mailStore.listUndelivered(sessionId);
+                const pending = await mailStore.listUnnudgedWaking(sessionId);
+                const pendingIds = new Set(pending.map(m => m.id));
                 return current() && !controller.signal.aborted && !!live && live.status === 'running'
                     && live.shellType === 'codex' && nativeIdentity(live) === identity && runner.isRunning(sessionId)
-                    && this.codexClaims.get(sessionId) === message.id && pending.some(m => m.id === message.id);
+                    && this.codexClaims.get(sessionId) === claimSet && batchIds.some(id => pendingIds.has(id));
             };
-            const wakeText = codexMailText(message);
+            const wakeText = batch.map(codexMailText).join('\n\n');
             // Recorded BEFORE the wake call: the prompt hook can fire before it resolves.
             this.recordInjection(sessionId, wakeText);
             const result = await this.nativeWake(session, wakeText, controller.signal, isCurrent)
                 .catch(() => ({ status: 'unknown' }));
             if (result.status === 'accepted' && current() && !controller.signal.aborted) {
+                const token = createNudgeToken(this.now());
                 accepted = await this.withSelection(sessionId, async () => {
-                    if (!current() || controller.signal.aborted || this.codexClaims.get(sessionId) !== message.id)
+                    if (!current() || controller.signal.aborted || this.codexClaims.get(sessionId) !== claimSet)
                         return false;
-                    const marked = await mailStore.markDelivered(sessionId, [message.id], 'cli');
-                    return marked.some(m => m.id === message.id);
+                    const marked = await mailStore.markDelivered(sessionId, batchIds, 'cli');
+                    await mailStore.markNudged(sessionId, batchIds, token);
+                    return marked.length > 0;
                 });
             }
         }
@@ -562,24 +692,44 @@ export class MailDeliveryService {
             if (this.wakeControllers.get(sessionId) === controller)
                 this.wakeControllers.delete(sessionId);
             await this.withSelection(sessionId, async () => {
-                if (this.codexClaims.get(sessionId) === message.id)
+                if (this.codexClaims.get(sessionId) === claimSet)
                     this.codexClaims.delete(sessionId);
             });
         }
         if (!current())
             return;
-        if (!accepted)
-            this.codexRetryAt.set(sessionId, this.now() + MAIL_NUDGE_BUSY_RECHECK_MS);
-        else
+        if (accepted) {
             this.codexRetryAt.delete(sessionId);
-        const pending = await mailStore.listUndelivered(sessionId);
+            this.batchAttempts.delete(sessionId);
+        }
+        else {
+            const prev = this.batchAttempts.get(sessionId);
+            const attempts = (prev?.key === batchKey ? prev.count : 0) + 1;
+            if (attempts >= MAX_WAKE_ATTEMPTS) {
+                const token = createNudgeToken(this.now());
+                await this.withSelection(sessionId, async () => {
+                    if (!current())
+                        return;
+                    await mailStore.markNudged(sessionId, batchIds, token);
+                });
+                this.batchAttempts.delete(sessionId);
+                this.codexRetryAt.delete(sessionId);
+            }
+            else {
+                this.batchAttempts.set(sessionId, { key: batchKey, count: attempts });
+                this.codexRetryAt.set(sessionId, this.now() + MAIL_NUDGE_BUSY_RECHECK_MS);
+            }
+        }
+        const remaining = await mailStore.listUnnudgedWaking(sessionId);
         if (!current())
             return;
-        if (pending.length)
+        if (remaining.length) {
             this.scheduleMailNudge(sessionId, fromLabel, accepted ? MAIL_NUDGE_DELAY_MS : MAIL_NUDGE_BUSY_RECHECK_MS);
+        }
         else {
             this.pendingNudgeFrom.delete(sessionId);
             this.codexRetryAt.delete(sessionId);
+            this.batchAttempts.delete(sessionId);
         }
     }
     async wakeSession(sessionId) {
@@ -588,13 +738,13 @@ export class MailDeliveryService {
         if (!current() || !store || !mailStore)
             return;
         const fromLabel = this.pendingNudgeFrom.get(sessionId) ?? 'ftown';
-        const undelivered = await mailStore.listUndelivered(sessionId);
+        const undelivered = await mailStore.listUnnudgedWaking(sessionId);
         if (!current())
             return;
         if (undelivered.length === 0) {
             this.pendingNudgeFrom.delete(sessionId);
-            this.nativeBatches.delete(sessionId);
             this.legacyReadyAt.delete(sessionId);
+            this.batchAttempts.delete(sessionId);
             return;
         }
         let session = await store.loadSession(sessionId);
@@ -617,55 +767,93 @@ export class MailDeliveryService {
             this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_BUSY_RECHECK_MS);
             return;
         }
+        let museStamped;
         if (session.shellType === 'muse') {
-            let identity = nativeIdentity(session);
-            const prior = this.nativeBatches.get(sessionId);
-            if (prior?.identity === identity && undelivered.every((message) => prior.ids.has(message.id)))
-                return;
             // A hook may have drained mail during the session lookup. Never wake for a stale snapshot.
             session = await store.loadSession(sessionId);
-            const pending = await mailStore.listUndelivered(sessionId);
+            const pending = await mailStore.listUnnudgedWaking(sessionId);
             if (!current() || !pending.length || !session || session.status !== 'running' || !runner.isRunning(sessionId))
                 return;
             if (session.shellType !== 'muse') {
                 this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_DELAY_MS);
                 return;
             }
-            identity = nativeIdentity(session);
-            const controller = new AbortController();
-            this.wakeControllers.set(sessionId, controller);
-            const isCurrent = async () => {
-                if (!current() || controller.signal.aborted)
-                    return false;
-                const live = await store.loadSession(sessionId);
-                const pending = await mailStore.listUndelivered(sessionId);
-                return current() && !controller.signal.aborted && !!live && live.status === 'running'
-                    && nativeIdentity(live) === identity && !this.isAgentRecentlyBusy(sessionId)
-                    && runner.isRunning(sessionId) && pending.some(message => undelivered.some(original => original.id === message.id));
-            };
-            let result;
-            // Recorded BEFORE the wake call: the prompt hook can fire before it resolves.
-            this.recordInjection(sessionId, MAIL_WAKE_TEXT);
-            try {
-                result = await this.nativeWake(session, MAIL_WAKE_TEXT, controller.signal, isCurrent).catch(() => ({ status: 'unknown' }));
-            }
-            finally {
-                if (this.wakeControllers.get(sessionId) === controller)
-                    this.wakeControllers.delete(sessionId);
-            }
-            if (!current())
-                return;
-            if (result.status === 'accepted' || result.status === 'unknown') {
-                this.nativeBatches.set(sessionId, { identity, ids: new Set(pending.map((message) => message.id)) });
-                return;
+            const batchIds = pending.map((message) => message.id);
+            const batchKey = batchIds.slice().sort().join(',');
+            if (this.museNativeTried.get(sessionId) !== batchKey) {
+                const museToken = createNudgeToken(this.now());
+                const stamped = await mailStore.markNudged(sessionId, batchIds, museToken);
+                if (!stamped.length) {
+                    this.pendingNudgeFrom.delete(sessionId);
+                    return;
+                }
+                if (!current()) {
+                    await mailStore.unmarkNudged(sessionId, batchIds, museToken);
+                    return;
+                }
+                this.museNativeTried.set(sessionId, batchKey);
+                const prev = this.batchAttempts.get(sessionId);
+                const museAttempts = (prev?.key === batchKey ? prev.count : 0) + 1;
+                this.batchAttempts.set(sessionId, { key: batchKey, count: museAttempts });
+                const identity = nativeIdentity(session);
+                const controller = new AbortController();
+                this.wakeControllers.set(sessionId, controller);
+                const isCurrent = async () => {
+                    if (!current() || controller.signal.aborted)
+                        return false;
+                    const live = await store.loadSession(sessionId);
+                    const currentPending = await mailStore.listUndelivered(sessionId);
+                    return current() && !controller.signal.aborted && !!live && live.status === 'running'
+                        && nativeIdentity(live) === identity && !this.isAgentRecentlyBusy(sessionId)
+                        && runner.isRunning(sessionId) && currentPending.some(message => batchIds.includes(message.id));
+                };
+                let result;
+                // Recorded BEFORE the wake call: the prompt hook can fire before it resolves.
+                this.recordInjection(sessionId, MAIL_WAKE_TEXT);
+                try {
+                    result = await this.nativeWake(session, MAIL_WAKE_TEXT, controller.signal, isCurrent).catch(() => ({ status: 'unknown' }));
+                }
+                finally {
+                    if (this.wakeControllers.get(sessionId) === controller)
+                        this.wakeControllers.delete(sessionId);
+                }
+                // Never unstamp after an accepted/unknown native wake, regardless of later busy/isCurrent checks.
+                if (result.status === 'accepted' || result.status === 'unknown') {
+                    this.pendingNudgeFrom.delete(sessionId);
+                    this.batchAttempts.delete(sessionId);
+                    return;
+                }
+                if (museAttempts >= MAX_WAKE_ATTEMPTS) {
+                    this.pendingNudgeFrom.delete(sessionId);
+                    this.batchAttempts.delete(sessionId);
+                    return;
+                }
+                if (!current() || !(await isCurrent())) {
+                    await mailStore.unmarkNudged(sessionId, batchIds, museToken);
+                    if (current() && runner.isRunning(sessionId)) {
+                        const live = await store.loadSession(sessionId);
+                        if (current() && live && live.status === 'running' && runner.isRunning(sessionId)) {
+                            this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_BUSY_RECHECK_MS);
+                        }
+                    }
+                    return;
+                }
+                museStamped = { batch: stamped, batchIds: stamped.map((m) => m.id), token: museToken };
             }
         }
+        const unstampMuse = async () => {
+            if (museStamped?.batchIds.length) {
+                await mailStore.unmarkNudged(sessionId, museStamped.batchIds, museStamped.token);
+            }
+        };
         const legacyWait = (this.legacyReadyAt.get(sessionId) ?? 0) - this.now();
         if (legacyWait > 0) {
+            await unstampMuse();
             this.scheduleMailNudge(sessionId, fromLabel, legacyWait);
             return;
         }
         if (this.isAgentRecentlyBusy(sessionId)) {
+            await unstampMuse();
             this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_BUSY_RECHECK_MS);
             return;
         }
@@ -677,40 +865,106 @@ export class MailDeliveryService {
             const sinceLast = this.now() - lastNudgeAt;
             if (sinceLast < MAIL_NUDGE_MIN_INTERVAL_MS) {
                 // Rate-limited: retry once the window reopens (mail may still be unread).
+                await unstampMuse();
                 this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_MIN_INTERVAL_MS - sinceLast);
                 return;
             }
         }
-        // The session isn't running (crashed/restarting): don't clear the pending
-        // marker. No timer is armed for this session at this point (the caller
-        // already removed it before invoking us), so clearing it here would lose
-        // the sender label until unrelated new mail happens to call
-        // scheduleMailNudge again. Keeping it means the next opportunity to
-        // re-check this session (new mail via acceptMail, or an external
-        // restart/idle hook re-invoking this nudge check) still knows who to
-        // credit.
+        let digest = null;
+        if (this.digestProvider) {
+            try {
+                digest = await this.digestProvider.digestFor(sessionId);
+            }
+            catch {
+                digest = null;
+            }
+            if (!current()) {
+                await unstampMuse();
+                return;
+            }
+        }
         // Recheck after native probing/rejection and before each legacy side effect.
-        const pending = await mailStore.listUndelivered(sessionId);
+        let pending;
+        if (museStamped) {
+            const stillUndelivered = new Set((await mailStore.listUndelivered(sessionId)).map((m) => m.id));
+            pending = museStamped.batch.filter((m) => stillUndelivered.has(m.id));
+        }
+        else {
+            pending = await mailStore.listUnnudgedWaking(sessionId);
+        }
         session = await store.loadSession(sessionId);
-        if (!current() || !pending.length || !session || session.status !== 'running' || !runner.isRunning(sessionId))
+        if (!current() || !pending.length || !session || session.status !== 'running' || !runner.isRunning(sessionId)) {
+            await unstampMuse();
             return;
+        }
         if (session.shellType === 'codex') {
+            await unstampMuse();
             this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_DELAY_MS);
             return;
         }
         const refreshedLease = this.pluginLeaseRemaining(session);
         if (refreshedLease > 0) {
+            await unstampMuse();
             this.scheduleMailNudge(sessionId, fromLabel, refreshedLease);
             return;
         }
         if (this.isAgentRecentlyBusy(sessionId)) {
+            await unstampMuse();
             this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_BUSY_RECHECK_MS);
             return;
         }
+        let activeBatch;
+        let batchIds;
+        let token;
+        if (museStamped) {
+            activeBatch = pending;
+            batchIds = museStamped.batchIds;
+            token = museStamped.token;
+        }
+        else {
+            token = createNudgeToken(this.now());
+            const requestedIds = pending.map((m) => m.id);
+            const stamped = await mailStore.markNudged(sessionId, requestedIds, token);
+            if (!stamped.length) {
+                await mailStore.unmarkNudged(sessionId, requestedIds, token);
+                this.pendingNudgeFrom.delete(sessionId);
+                return;
+            }
+            activeBatch = stamped;
+            batchIds = stamped.map((m) => m.id);
+        }
+        if (!current()) {
+            await mailStore.unmarkNudged(sessionId, batchIds, token);
+            return;
+        }
+        const batchKey = batchIds.slice().sort().join(',');
+        const prev = this.batchAttempts.get(sessionId);
+        const attempts = (prev?.key === batchKey ? prev.count : 0) + 1;
+        this.batchAttempts.set(sessionId, { key: batchKey, count: attempts });
+        const text = sanitizeMessageText(formatNudgeText(countMailTypes(activeBatch), digest));
+        let wroteToPty = false;
+        const injected = await this.injectPtyLine(session, 'ftown-mail', text, {
+            onFirstWrite: () => {
+                wroteToPty = true;
+            },
+        });
+        const deliveredToPty = wroteToPty || injected;
+        if (!deliveredToPty) {
+            if (attempts >= MAX_WAKE_ATTEMPTS) {
+                this.batchAttempts.delete(sessionId);
+                this.pendingNudgeFrom.delete(sessionId);
+                return;
+            }
+            await mailStore.unmarkNudged(sessionId, batchIds, token);
+            if (current())
+                this.scheduleMailNudge(sessionId, fromLabel, MAIL_NUDGE_DELAY_MS);
+            return;
+        }
+        this.batchAttempts.delete(sessionId);
         this.pendingNudgeFrom.delete(sessionId);
-        this.lastNudgeAt.set(sessionId, this.now());
-        const text = sanitizeMessageText(`You have new ftown mail from ${fromLabel} — run \`ftown harness mail read\` to read it.`);
-        await this.injectPtyLine(session, 'ftown-mail', text);
+        if (current()) {
+            this.lastNudgeAt.set(sessionId, this.now());
+        }
     }
     delay(ms) {
         return new Promise((resolve) => this.setTimeoutFn(resolve, ms));