termdock 1.4.178 → 1.4.180

package/dist/client/sw-notifications.js

@@ -17,6 +17,7 @@ self.addEventListener('push', (event) => {
     data: {
       url: payload.url || '/',
       sessionId: payload.sessionId,
+      targetPeerId: payload.targetPeerId,
     },
   };
   event.waitUntil((async () => {
@@ -60,35 +61,13 @@ self.addEventListener('push', (event) => {
 self.addEventListener('pushsubscriptionchange', (event) => {
   event.waitUntil((async () => {
     try {
-      const statusResponse = await fetch('/api/notifications/status', { credentials: 'same-origin' });
-      if (statusResponse.ok) {
-        const status = await statusResponse.json();
-        const subscription = event.newSubscription || await self.registration.pushManager.getSubscription();
-        if (subscription) {
-          const tokenResponse = await fetch('/api/csrf-token', { credentials: 'same-origin' });
-          if (tokenResponse.ok) {
-            const { csrfToken } = await tokenResponse.json();
-            await fetch('/api/notifications/subscribe', {
-              method: 'POST',
-              credentials: 'same-origin',
-              headers: {
-                'Content-Type': 'application/json',
-                'X-XSRF-TOKEN': csrfToken,
-              },
-              body: JSON.stringify({
-                subscription: subscription.toJSON(),
-                aiEnabled: status.subscription?.aiEnabled !== false,
-                exitEnabled: status.subscription?.exitEnabled === true,
-                alertStyle: status.subscription?.alertStyle || 'normal',
-                locale: status.subscription?.locale || 'zh-CN',
-              }),
-            });
-          }
-        }
+      let subscription = event.newSubscription || await self.registration.pushManager.getSubscription();
+      if (!subscription && event.oldSubscription?.options) {
+        subscription = await self.registration.pushManager.subscribe(event.oldSubscription.options);
       }
-    } catch {
-      // App foreground reconciliation is the fallback for browsers that do not
-      // permit re-subscription inside pushsubscriptionchange.
+      if (subscription) await self.termdockBackground?.renewSubscriptions(subscription.toJSON());
+    } catch (error) {
+      console.warn('Background encrypted subscription sync failed', error);
     }
     const windows = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
     for (const client of windows) {
@@ -98,20 +77,8 @@ self.addEventListener('pushsubscriptionchange', (event) => {
 });
 
 async function reportNotificationClick(stage, traceId, data = {}) {
-  try {
-    await fetch('/api/client-log', {
-      method: 'POST',
-      credentials: 'same-origin',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        level: 'info',
-        message: `PWA_NOTIFICATION_CLICK ${stage}`,
-        data: { traceId, ts: Date.now(), ...data },
-      }),
-    });
-  } catch {
-    // Diagnostics must never interfere with notification navigation.
-  }
+  try { await self.termdockBackground?.reportClick(stage, traceId, data); }
+  catch { console.debug(`PWA_NOTIFICATION_CLICK ${stage}`, { traceId, ...data }); }
 }
 
 const NOTIFICATION_TARGET_CACHE = 'termdock-notification-target-v1';
@@ -176,6 +143,7 @@ self.addEventListener('notificationclick', (event) => {
 
   event.waitUntil((async () => {
     await reportNotificationClick('sw-click-start', traceId, {
+      targetPeerId: data.targetPeerId,
       sessionId: data.sessionId || null,
       url: data.url || null,
       tag: event.notification.tag || null,
@@ -254,5 +222,5 @@ self.addEventListener('notificationclick', (event) => {
         resultUrl: openedClient?.url || null,
       });
     }
-  })());
+  })().finally(() => self.termdockBackground?.flushLogs().catch(() => {})));
 });

package/dist/client/sw.js

@@ -1 +1 @@
-if(!self.define){let e,s={};const i=(i,n)=>(i=new URL(i+".js",n).href,s[i]||new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=i,e.onload=s,document.head.appendChild(e)}else e=i,importScripts(i),s()}).then(()=>{let e=s[i];if(!e)throw new Error(`Module ${i} didn’t register its module`);return e}));self.define=(n,a)=>{const c=e||("document"in self?document.currentScript.src:"")||location.href;if(s[c])return;let o={};const r=e=>i(e,c),t={module:{uri:c},exports:o,require:r};s[c]=Promise.all(n.map(e=>t[e]||r(e))).then(e=>(a(...e),o))}}define(["./workbox-9845bf53"],function(e){"use strict";importScripts("sw-notifications.js","sw-secure-api.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"index.html",revision:"ca66dd41431972ae5897439615539f92"},{url:"assets/app-B42CoF1r.js",revision:null},{url:"assets/react-XDCjal2T.js",revision:null},{url:"assets/dnd-BCFAPC0L.js",revision:null},{url:"assets/terminal-C7X98Amf.js",revision:null},{url:"assets/index-C4Ny0NDQ.css",revision:null},{url:"icons/agents/opencode.svg",revision:"851c2931d95821ba2b39b68587b48976"},{url:"icons/agents/kimi.svg",revision:"5366c710f4f763022fe159a69cf17409"},{url:"icons/agents/grok.svg",revision:"cd745b0b964545bc7a6b4f36021c3298"},{url:"icons/agents/goose.svg",revision:"c79b927278983c19098d77b4b0c11ab3"},{url:"icons/agents/gemini.svg",revision:"7a64f6d6f80a908255e9c0256903882e"},{url:"icons/agents/droid.svg",revision:"f28723b8c5c115e0908ba3c72613e256"},{url:"icons/agents/cursor.svg",revision:"a1528f3d3cda497f75a5db28defb19de"},{url:"icons/agents/copilot.svg",revision:"dd52e96c1eac0b6ec4bedcd0ddd3b52d"},{url:"icons/agents/codex.svg",revision:"608e55babb0b217e1f2da287342b46d3"},{url:"icons/agents/claude.svg",revision:"08af0225b7acdd8e8f573f3247e5e1c3"},{url:"icons/agents/amp.svg",revision:"af12f8b33faa81e4d46ea7b93c7e43f3"},{url:"apple-touch-icon-180x180.png",revision:"628c2e2f28a9b545aa57be1352025643"},{url:"favicon.ico",revision:"2994debfa6f59a0898e24eb0c54d64b5"},{url:"maskable-icon-512x512.png",revision:"4d489331fd81f0713c400b26426442b9"},{url:"pwa-192x192.png",revision:"4d6f899888cfb8ccd7a1fd3c9e583ad2"},{url:"pwa-512x512.png",revision:"0885dd7ec8932e7f878b013d51a380a4"},{url:"robots.txt",revision:"d9339907142917dee4aac78494ac9cfe"},{url:"sw-notifications.js",revision:"051f4ad0b9931c67d8094c2db255ac34"},{url:"sw-secure-api.js",revision:"739c54d3fc8f4cbb87bab12b6b8a8160"},{url:"manifest.webmanifest",revision:"83f9a43b74c236012adafb077fb6d774"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("index.html"),{denylist:[/^\/api\//,/^\/health$/]})),e.registerRoute(/\/assets\/.*\.(?:js|css)$/,new e.CacheFirst({cacheName:"termdock-lazy-assets-v1",plugins:[new e.CacheableResponsePlugin({statuses:[0,200]}),new e.ExpirationPlugin({maxEntries:96,maxAgeSeconds:2592e3})]}),"GET"),e.registerRoute(/\/fonts\/terminal\/[^/]+-[a-f0-9]{12}\.woff2$/,new e.CacheFirst({cacheName:"termdock-fonts-v2",plugins:[new e.CacheableResponsePlugin({statuses:[0,200]}),new e.ExpirationPlugin({maxEntries:384,maxAgeSeconds:2592e3})]}),"GET"),e.registerRoute(/\/fonts\/.*\.(?:woff2|ttf)$/,new e.StaleWhileRevalidate({cacheName:"termdock-fonts-v1",plugins:[new e.ExpirationPlugin({maxEntries:24,maxAgeSeconds:2592e3})]}),"GET")});
+if(!self.define){let e,s={};const n=(n,i)=>(n=new URL(n+".js",i).href,s[n]||new Promise(s=>{if("document"in self){const e=document.createElement("script");e.src=n,e.onload=s,document.head.appendChild(e)}else e=n,importScripts(n),s()}).then(()=>{let e=s[n];if(!e)throw new Error(`Module ${n} didn’t register its module`);return e}));self.define=(i,a)=>{const o=e||("document"in self?document.currentScript.src:"")||location.href;if(s[o])return;let c={};const r=e=>n(e,o),t={module:{uri:o},exports:c,require:r};s[o]=Promise.all(i.map(e=>t[e]||r(e))).then(e=>(a(...e),c))}}define(["./workbox-9845bf53"],function(e){"use strict";importScripts("sw-encrypted-background.js","sw-notifications.js","sw-secure-api.js","sw-downloads.js"),self.addEventListener("message",e=>{e.data&&"SKIP_WAITING"===e.data.type&&self.skipWaiting()}),e.clientsClaim(),e.precacheAndRoute([{url:"index.html",revision:"1d87402f5f09e34eb3f563b011b5205f"},{url:"assets/app-Djvvt1Mi.js",revision:null},{url:"assets/react-XDCjal2T.js",revision:null},{url:"assets/dnd-BCFAPC0L.js",revision:null},{url:"assets/terminal-C7X98Amf.js",revision:null},{url:"assets/index-PWu1VEN_.css",revision:null},{url:"icons/agents/opencode.svg",revision:"851c2931d95821ba2b39b68587b48976"},{url:"icons/agents/kimi.svg",revision:"5366c710f4f763022fe159a69cf17409"},{url:"icons/agents/grok.svg",revision:"cd745b0b964545bc7a6b4f36021c3298"},{url:"icons/agents/goose.svg",revision:"c79b927278983c19098d77b4b0c11ab3"},{url:"icons/agents/gemini.svg",revision:"7a64f6d6f80a908255e9c0256903882e"},{url:"icons/agents/droid.svg",revision:"f28723b8c5c115e0908ba3c72613e256"},{url:"icons/agents/cursor.svg",revision:"a1528f3d3cda497f75a5db28defb19de"},{url:"icons/agents/copilot.svg",revision:"dd52e96c1eac0b6ec4bedcd0ddd3b52d"},{url:"icons/agents/codex.svg",revision:"608e55babb0b217e1f2da287342b46d3"},{url:"icons/agents/claude.svg",revision:"08af0225b7acdd8e8f573f3247e5e1c3"},{url:"icons/agents/amp.svg",revision:"af12f8b33faa81e4d46ea7b93c7e43f3"},{url:"apple-touch-icon-180x180.png",revision:"628c2e2f28a9b545aa57be1352025643"},{url:"favicon.ico",revision:"2994debfa6f59a0898e24eb0c54d64b5"},{url:"maskable-icon-512x512.png",revision:"4d489331fd81f0713c400b26426442b9"},{url:"pwa-192x192.png",revision:"4d6f899888cfb8ccd7a1fd3c9e583ad2"},{url:"pwa-512x512.png",revision:"0885dd7ec8932e7f878b013d51a380a4"},{url:"robots.txt",revision:"d9339907142917dee4aac78494ac9cfe"},{url:"sw-downloads.js",revision:"29b4d23945d109a334e1c3902a8cf02a"},{url:"sw-notifications.js",revision:"a5a2b585a4336d66519195e5e63aee2d"},{url:"sw-secure-api.js",revision:"739c54d3fc8f4cbb87bab12b6b8a8160"},{url:"manifest.webmanifest",revision:"83f9a43b74c236012adafb077fb6d774"}],{}),e.cleanupOutdatedCaches(),e.registerRoute(new e.NavigationRoute(e.createHandlerBoundToURL("index.html"),{denylist:[/^\/api\//,/^\/__termdock-download\//,/^\/health$/]})),e.registerRoute(/\/assets\/.*\.(?:js|css)$/,new e.CacheFirst({cacheName:"termdock-lazy-assets-v1",plugins:[new e.CacheableResponsePlugin({statuses:[0,200]}),new e.ExpirationPlugin({maxEntries:96,maxAgeSeconds:2592e3})]}),"GET"),e.registerRoute(/\/fonts\/terminal\/[^/]+-[a-f0-9]{12}\.woff2$/,new e.CacheFirst({cacheName:"termdock-fonts-v2",plugins:[new e.CacheableResponsePlugin({statuses:[0,200]}),new e.ExpirationPlugin({maxEntries:384,maxAgeSeconds:2592e3})]}),"GET"),e.registerRoute(/\/fonts\/.*\.(?:woff2|ttf)$/,new e.StaleWhileRevalidate({cacheName:"termdock-fonts-v1",plugins:[new e.ExpirationPlugin({maxEntries:24,maxAgeSeconds:2592e3})]}),"GET")});

package/dist/server/agent/collaborationCli.js

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { COLLAB_LIMITS, CollaborationError } from './collaborationProtocol.js';
 export const COLLAB_HELP = `td collab — durable messages; no agent-specific hooks required
   status | capabilities
+  rebind [--pane %3] (explicitly bind this peer to its current Agent; resumes queued delivery)
   send <session-id> <message> | reply <message-id> <message> | handoff <session-id> <message>
     --group <id> --thread <id> --idempotency-key <key>
     --file <path> | --stdin (instead of inline body; -- ends option parsing)
@@ -29,7 +30,7 @@ Idempotency retention: 7 days. read/ACK/result never imply each other.
 Inbox defaults to unread first, newest 50; cursor/consumer mode reads oldest unseen first.
 Reading never advances a consumer or marks messages read automatically.`;
 const BOOLEAN_OPTIONS = new Set(['json', 'jsonl', 'text', 'unread', 'follow', 'stdin', 'receipt-only', 'help']);
-const VALUE_OPTIONS = new Set(['group', 'thread', 'idempotency-key', 'file', 'wait-until', 'timeout', 'expect-reply', 'response-kind', 'metadata', 'task-envelope', 'expires-at', 'since', 'after-id', 'cursor', 'consumer', 'limit', 'from', 'kind', 'name', 'cwd', 'task']);
+const VALUE_OPTIONS = new Set(['group', 'thread', 'idempotency-key', 'file', 'wait-until', 'timeout', 'expect-reply', 'response-kind', 'metadata', 'task-envelope', 'expires-at', 'since', 'after-id', 'cursor', 'consumer', 'limit', 'from', 'kind', 'name', 'cwd', 'task', 'pane']);
 export function parseCollaborationCommand(argv) {
     const options = {};
     const positional = [];
@@ -60,8 +61,10 @@ export function parseCollaborationCommand(argv) {
             positional.push(value);
     }
     const action = (options.help ? 'help' : positional.shift() ?? 'status');
-    if (!['status', 'inbox', 'send', 'handoff', 'reply', 'add', 'remove', 'spawn', 'message', 'cursor', 'capabilities', 'help'].includes(action))
+    if (!['status', 'inbox', 'send', 'handoff', 'reply', 'add', 'remove', 'spawn', 'message', 'cursor', 'rebind', 'capabilities', 'help'].includes(action))
         throw new Error('Unknown collaboration command; see td collab --help');
+    if (options.pane && !/^%\d+$/.test(String(options.pane)))
+        throw new Error('pane must be a tmux pane id such as %3');
     if (['json', 'jsonl', 'text'].filter((key) => options[key]).length > 1)
         throw new Error('Choose one output format');
     if (options['wait-until'] && !['queued', 'delivered', 'read'].includes(String(options['wait-until'])))
@@ -107,7 +110,7 @@ export function parseCollaborationCommand(argv) {
         throw new Error(`Unexpected arguments for ${action}`);
     const allowed = new Set(['json', 'jsonl', 'text', 'help']);
     const byAction = {
-        status: [], capabilities: [], help: [...BOOLEAN_OPTIONS, ...VALUE_OPTIONS],
+        status: [], capabilities: [], rebind: ['pane'], help: [...BOOLEAN_OPTIONS, ...VALUE_OPTIONS],
         send: ['group', 'thread', 'idempotency-key', 'file', 'stdin', 'wait-until', 'timeout', 'expect-reply', 'response-kind', 'metadata', 'task-envelope', 'expires-at', 'kind'],
         handoff: ['group', 'thread', 'idempotency-key', 'file', 'stdin', 'wait-until', 'timeout', 'expect-reply', 'response-kind', 'metadata', 'task-envelope', 'expires-at'],
         reply: ['idempotency-key', 'file', 'stdin', 'wait-until', 'timeout', 'expect-reply', 'response-kind', 'metadata', 'task-envelope', 'expires-at'],
@@ -187,6 +190,10 @@ export async function executeCollaborationCommand(command, context, io) {
             output(await request('GET', command.action === 'status' ? '/peers' : '/capabilities'));
             return 0;
         }
+        if (command.action === 'rebind') {
+            output(await request('POST', '/route/rebind', { pane: o.pane ?? null }));
+            return 0;
+        }
         if (command.action === 'inbox') {
             let cursor = o.cursor;
             do {

package/dist/server/agent/collaborationDeliveryWorker.js

@@ -0,0 +1,154 @@
+export class CollaborationDeliveryWorker {
+    options;
+    running = new Map();
+    states = new Map();
+    failures = new Map();
+    submitted = new Set();
+    timer = null;
+    ticking = null;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => { void this.tick(); }, 2_000);
+        this.timer.unref?.();
+        void this.tick();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    state(id) {
+        const state = this.states.get(id);
+        return state && Date.now() - state.checkedAt < 15_000 ? state
+            : { state: 'recovering', reason: 'ROUTE_NOT_CHECKED', checkedAt: state?.checkedAt ?? null };
+    }
+    wake(id) {
+        void this.run(id).catch(this.options.onError);
+    }
+    tick() {
+        if (this.ticking)
+            return this.ticking;
+        this.ticking = this.tickOnce().finally(() => { this.ticking = null; });
+        return this.ticking;
+    }
+    async tickOnce() {
+        try {
+            const ids = [...new Set([...this.options.peers(), ...this.options.store.pendingRecipients()])].filter(this.options.isLocal);
+            // Bound process probes/attachments while keeping a broken peer from
+            // serially blocking the entire queue.
+            let cursor = 0;
+            await Promise.all(Array.from({ length: Math.min(4, ids.length) }, async () => {
+                while (cursor < ids.length)
+                    await this.run(ids[cursor++]).catch(this.options.onError);
+            }));
+        }
+        catch (error) {
+            this.options.onError(error);
+        }
+    }
+    run(id) {
+        const running = this.running.get(id);
+        if (running)
+            return running;
+        if (!this.options.isLocal(id))
+            return Promise.resolve();
+        const operation = Promise.resolve().then(() => this.deliver(id)).finally(() => {
+            if (this.running.get(id) === operation)
+                this.running.delete(id);
+        });
+        this.running.set(id, operation);
+        return operation;
+    }
+    reconfigure(id, configure) {
+        const previous = this.running.get(id) ?? Promise.resolve();
+        const operation = previous.catch(() => undefined).then(async () => {
+            await configure();
+            this.failures.delete(id);
+            this.states.delete(id);
+            for (const message of this.options.store.inbox(id, { pendingOnly: true, limit: 200 })) {
+                const diagnostic = this.options.store.diagnostic(message.id);
+                if (diagnostic)
+                    this.options.store.recordTransport(message.id, { ...diagnostic, next_retry_at: null, last_error: null });
+            }
+        }).finally(() => {
+            if (this.running.get(id) === operation)
+                this.running.delete(id);
+        });
+        this.running.set(id, operation);
+        return operation;
+    }
+    async deliver(id) {
+        const { store } = this.options;
+        const first = store.inbox(id, { pendingOnly: true, limit: 1 })[0];
+        if (!first && Date.now() - (this.states.get(id)?.checkedAt ?? 0) < 5_000)
+            return;
+        if (first && this.submitted.has(first.id)) {
+            this.complete(id, first);
+            return;
+        }
+        if (first && (store.diagnostic(first.id)?.next_retry_at ?? 0) > Date.now())
+            return;
+        this.states.set(id, { state: 'recovering', reason: null, checkedAt: Date.now() });
+        let route;
+        try {
+            route = await this.options.resolve(id);
+        }
+        catch (error) {
+            route = { state: 'unavailable', reason: `ROUTE_RECOVERY_FAILED: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        this.states.set(id, { state: route.state, reason: route.reason ?? null, checkedAt: Date.now() });
+        // Re-read after asynchronous recovery: a consumer may have read the
+        // message, or its TTL may have elapsed while tmux was being inspected.
+        const pending = store.inbox(id, { pendingOnly: true, limit: 1 });
+        if (!pending.length)
+            return;
+        if (route.state !== 'ready' || !route.write) {
+            this.retry(id, pending, route.reason ?? route.state, false);
+            return;
+        }
+        const message = pending[0];
+        if (!this.submitted.has(message.id)) {
+            store.recordTransport(message.id, {
+                relay_online: null, peer_reachable: true,
+                attempt_count: (store.diagnostic(message.id)?.attempt_count ?? 0) + 1,
+                next_retry_at: Date.now() + 2_000, last_error: 'DELIVERY_IN_PROGRESS', checked_at: Date.now(),
+            });
+            try {
+                await route.write(pending);
+            }
+            catch (error) {
+                this.retry(id, pending, `TERMINAL_WRITE_FAILED: ${error instanceof Error ? error.message : String(error)}`, true);
+                return;
+            }
+            this.submitted.add(message.id);
+        }
+        // If persistence fails after writing, the in-process guard avoids a
+        // second write on retry. Across a crash, transport is at-least-once.
+        this.complete(id, message);
+    }
+    complete(id, message) {
+        const { store } = this.options;
+        store.markDelivered([message.id]);
+        this.submitted.delete(message.id);
+        store.recordTransport(message.id, {
+            relay_online: null, peer_reachable: true, attempt_count: store.diagnostic(message.id)?.attempt_count ?? 1,
+            next_retry_at: null, last_error: null, checked_at: Date.now(),
+        });
+        this.failures.delete(id);
+    }
+    retry(id, messages, reason, reachable) {
+        const failures = (this.failures.get(id) ?? 0) + 1;
+        this.failures.set(id, failures);
+        const next = Date.now() + Math.min(30_000, 2_000 * 2 ** Math.min(failures - 1, 4));
+        for (const message of messages)
+            this.options.store.recordTransport(message.id, {
+                relay_online: null, peer_reachable: reachable,
+                attempt_count: this.options.store.diagnostic(message.id)?.attempt_count ?? 0,
+                next_retry_at: next, last_error: reason, checked_at: Date.now(),
+            });
+    }
+}

package/dist/server/agent/collaborationRoutes.js

@@ -1,19 +1,28 @@
 import { Router } from 'express';
 import { COLLAB_LIMITS, CollaborationError, extrasFromBody } from './collaborationProtocol.js';
-export function collaborationRoutes({ store, resolveSession, deliver }) {
+export function collaborationRoutes({ store, resolveSession, deliver, rebind }) {
     const router = Router();
-    const run = (handler) => (req, res) => {
+    const run = (handler) => async (req, res) => {
         try {
             const sessionId = resolveSession((req.method === 'GET' ? req.query : req.body) ?? {});
             if (!sessionId)
                 throw new CollaborationError('SESSION_NOT_FOUND', 'Run inside a Termdock managed session', 404);
-            handler(req, res, sessionId);
+            await handler(req, res, sessionId);
         }
         catch (error) {
             res.status(error instanceof CollaborationError ? error.httpStatus : 400).json({ ok: false,
                 code: error instanceof CollaborationError ? error.code : 'COLLABORATION_ERROR', error: error instanceof Error ? error.message : String(error) });
         }
     };
+    router.post('/route/rebind', run(async (req, res, sessionId) => {
+        if (!rebind)
+            throw new CollaborationError('ROUTE_REBIND_UNAVAILABLE', 'Route rebinding is not available');
+        const pane = req.body.pane;
+        if (pane !== undefined && pane !== null && (typeof pane !== 'string' || !/^%\d+$/.test(pane))) {
+            throw new CollaborationError('INVALID_PANE', 'pane must be a tmux pane id such as %3');
+        }
+        res.json({ ok: true, route: await rebind(sessionId, pane ?? null) });
+    }));
     const ownMessage = (id, sessionId, recipientOnly = false) => {
         const message = store.getMessage(id);
         if (!message || (message.toSessionId !== sessionId && (recipientOnly || message.fromSessionId !== sessionId)))
@@ -27,11 +36,13 @@ export function collaborationRoutes({ store, resolveSession, deliver }) {
     };
     router.get('/capabilities', run((_req, res) => {
         res.json({ protocol_version: 2, limits: COLLAB_LIMITS,
+            routing: { background_recovery: true, explicit_rebind: Boolean(rebind), fixed_tmux_pane: true },
             statuses: ['pending', 'delivered', 'read', 'failed', 'expired'], queued_status: 'pending',
             semantics: { delivered: 'written to terminal; no application acknowledgement implied', read: 'explicit consumer acknowledgement',
                 ack: 'explicit response_kind=ack', result: 'explicit response_kind=result; inspect task.status and evidence',
                 done: 'adapter reports turn ended, never proof of task completion', heartbeat: 'null unless explicitly observed',
-                timeout: 'stops waiting, does not cancel delivery' } });
+                timeout: 'stops waiting, does not cancel delivery',
+                retry: 'same message id may be submitted again after a crash or uncertain transport result; consumers deduplicate by message id' } });
     }));
     router.post('/send', run((req, res, sessionId) => {
         const target = typeof req.body.targetSessionId === 'string' ? req.body.targetSessionId.trim() : '';

package/dist/server/agent/collaborationRouting.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export class CollaborationRoutingStore {
+    file;
+    bindings = new Map();
+    loadError = null;
+    constructor(file) {
+        this.file = file;
+        try {
+            const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (data.version !== 1 || !Array.isArray(data.bindings))
+                throw new Error('Invalid collaboration routing store');
+            for (const binding of data.bindings) {
+                if (!binding || typeof binding.sessionId !== 'string' || !['shell', 'tmux'].includes(binding.mode)
+                    || ![binding.backendSessionId, binding.tmuxSessionName, binding.agentSlug, binding.nativeSessionId].every((value) => value === null || typeof value === 'string')
+                    || (binding.pane !== null && (!binding.pane || !Number.isInteger(binding.pane.serverPid) || !Number.isInteger(binding.pane.panePid)
+                        || !/^%\d+$/.test(binding.pane.paneId) || !/^\$\d+$/.test(binding.pane.sessionId) || typeof binding.pane.agentSlug !== 'string'))) {
+                    throw new Error('Invalid collaboration binding');
+                }
+                this.bindings.set(binding.sessionId, binding);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                this.bindings.clear();
+                this.loadError = error;
+            }
+        }
+    }
+    get(id) {
+        const binding = this.bindings.get(id);
+        return binding ? structuredClone(binding) : null;
+    }
+    assertReadable() {
+        if (this.loadError)
+            throw new Error('COLLABORATION_ROUTING_STORE_UNREADABLE', { cause: this.loadError });
+    }
+    ownerOfBackend(id) {
+        return [...this.bindings.values()].find((binding) => binding.backendSessionId === id)?.sessionId ?? null;
+    }
+    bind(binding) {
+        this.assertReadable();
+        const owner = binding.backendSessionId ? this.ownerOfBackend(binding.backendSessionId) : null;
+        if (owner && owner !== binding.sessionId)
+            throw new Error('BACKEND_ALREADY_BOUND');
+        if (JSON.stringify(this.bindings.get(binding.sessionId)) === JSON.stringify(binding))
+            return;
+        const next = new Map(this.bindings);
+        next.set(binding.sessionId, structuredClone(binding));
+        this.persist(next);
+    }
+    remove(id) {
+        if (!this.bindings.has(id))
+            return;
+        const next = new Map(this.bindings);
+        next.delete(id);
+        this.persist(next);
+    }
+    persist(next) {
+        this.assertReadable();
+        fs.mkdirSync(path.dirname(this.file), { recursive: true });
+        const temporary = `${this.file}.${process.pid}.tmp`;
+        fs.writeFileSync(temporary, JSON.stringify({ version: 1, bindings: [...next.values()] }), { mode: 0o600 });
+        fs.renameSync(temporary, this.file);
+        this.bindings = next;
+    }
+}
+// Once pinned, changing the active pane cannot change the recipient. A reused
+// tmux name/pane after a server restart must not inherit an old peer's inbox.
+export function selectCollaborationPane(binding, panes) {
+    if (binding.pane) {
+        const previous = binding.pane;
+        const pane = panes.find((candidate) => candidate.serverPid === previous.serverPid
+            && candidate.sessionId === previous.sessionId && candidate.paneId === previous.paneId && candidate.panePid === previous.panePid);
+        if (!pane)
+            return { state: 'identity-mismatch', reason: 'TMUX_PANE_CHANGED' };
+        if (!pane.agentSlug)
+            return { state: 'agent-exited', reason: 'AGENT_NOT_RUNNING' };
+        if (pane.agentSlug !== previous.agentSlug || (previous.nativeSessionId && pane.nativeSessionId && previous.nativeSessionId !== pane.nativeSessionId)) {
+            return { state: 'identity-mismatch', reason: 'AGENT_IDENTITY_CHANGED' };
+        }
+        return { state: 'ready', pane };
+    }
+    const candidates = panes.filter((pane) => pane.agentSlug && (!binding.agentSlug || binding.agentSlug === pane.agentSlug)
+        && (!binding.nativeSessionId || !pane.nativeSessionId || binding.nativeSessionId === pane.nativeSessionId));
+    const exact = binding.nativeSessionId ? candidates.filter((pane) => pane.nativeSessionId === binding.nativeSessionId) : [];
+    const matches = exact.length ? exact : candidates;
+    if (matches.length === 1)
+        return { state: 'ready', pane: matches[0] };
+    if (!matches.length && panes.some((pane) => pane.agentSlug))
+        return { state: 'identity-mismatch', reason: 'AGENT_IDENTITY_CHANGED' };
+    return matches.length > 1 ? { state: 'ambiguous', reason: 'MULTIPLE_AGENT_PANES' }
+        : { state: 'agent-exited', reason: 'AGENT_NOT_RUNNING_OR_IDENTITY_CHANGED' };
+}

package/dist/server/agent/collaborationStore.js

@@ -160,6 +160,10 @@ export class CollaborationStore {
         this.expire();
         return this.document.messages.filter((message) => message.toSessionId === sessionId && message.status === 'pending').length;
     }
+    pendingRecipients() {
+        this.expire();
+        return [...new Set(this.document.messages.filter((message) => message.status === 'pending').map((message) => message.toSessionId))];
+    }
     markDelivered(messageIds) {
         return this.updateStatus(messageIds, 'delivered');
     }
@@ -249,7 +253,8 @@ export class CollaborationStore {
     expire() {
         let changed = false;
         for (const message of this.document.messages)
-            if (message.status === 'pending' && message.expiresAt && message.expiresAt <= Date.now()) {
+            if (message.status === 'pending' && message.expiresAt && message.expiresAt <= Date.now()
+                && this.document.transport?.[message.id]?.last_error !== 'DELIVERY_IN_PROGRESS') {
                 message.status = 'expired';
                 message.failureReason = 'MESSAGE_EXPIRED';
                 changed = true;

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -0,0 +1,10 @@
+import { buildBracketedSubmitBytes } from './promptDelivery.js';
+export async function writeCollaborationTmuxPane(run, pane, prompt) {
+    const identity = (await run(['display-message', '-p', '-t', pane.paneId,
+        '#{pid}:#{session_id}:#{pane_id}:#{pane_pid}'])).trim();
+    if (identity !== `${pane.serverPid}:${pane.sessionId}:${pane.paneId}:${pane.panePid}`)
+        throw new Error('TMUX_PANE_CHANGED');
+    // A fixed pane target is independent of the current window, keyboard focus
+    // and browser presence. One invocation preserves the bracketed submit bytes.
+    await run(['send-keys', '-t', pane.paneId, '-l', '--', buildBracketedSubmitBytes(prompt)]);
+}

package/dist/server/agent/sessionBindingRecovery.js

@@ -0,0 +1,80 @@
+export function resolveCollaborationSessionId(input, records, routing) {
+    const sessionId = typeof input.sessionId === 'string' ? input.sessionId.trim() : '';
+    if (sessionId && records.some((record) => record.sessionId === sessionId))
+        return sessionId;
+    const backendSessionId = typeof input.backendSessionId === 'string' ? input.backendSessionId.trim() : '';
+    if (backendSessionId) {
+        const owner = routing.ownerOfBackend(backendSessionId);
+        if (owner && records.some((record) => record.sessionId === owner))
+            return owner;
+        const resolved = records.find((record) => record.backendSessionId === backendSessionId)?.sessionId;
+        if (resolved)
+            return resolved;
+    }
+    const tmuxSessionName = typeof input.tmuxSessionName === 'string' ? input.tmuxSessionName.trim() : '';
+    if (!tmuxSessionName)
+        return null;
+    const bound = records.find((record) => routing.get(record.sessionId)?.tmuxSessionName === tmuxSessionName);
+    if (bound)
+        return bound.sessionId;
+    return records.find((record) => record.tmuxSessionName === tmuxSessionName)?.sessionId ?? null;
+}
+export function resolveCollaborationBackend(record, records, backends, routing) {
+    routing.assertReadable();
+    const binding = routing.get(record.sessionId);
+    const target = binding ? { ...record, mode: binding.mode, tmuxSessionName: binding.tmuxSessionName,
+        backendSessionId: binding.backendSessionId,
+        agentResume: binding.agentSlug ? { slug: binding.agentSlug, sessionId: binding.nativeSessionId } : record.agentResume } : record;
+    const existing = target.backendSessionId ? backends.get(target.backendSessionId) : null;
+    const recovered = existing && existing.mode === target.mode && existing.tmuxSessionName === target.tmuxSessionName
+        ? [target.backendSessionId, existing]
+        : recoverSessionBinding({ ...target, backendSessionId: null }, records, backends, binding);
+    if (!recovered)
+        return null;
+    const [id, backend] = recovered;
+    if (backend.mode !== 'shell' && backend.mode !== 'tmux')
+        return null;
+    const owner = routing.ownerOfBackend(id);
+    if (owner && owner !== record.sessionId)
+        return null;
+    if (records.some((other) => other.sessionId !== record.sessionId && other.backendSessionId === id))
+        return null;
+    routing.bind({ sessionId: record.sessionId, backendSessionId: id, mode: backend.mode,
+        tmuxSessionName: backend.tmuxSessionName,
+        agentSlug: binding?.agentSlug ?? backend.agent?.slug ?? record.agentResume?.slug ?? null,
+        nativeSessionId: binding?.nativeSessionId ?? backend.agentSession?.sessionId ?? record.agentResume?.sessionId ?? null,
+        pane: binding?.pane ?? null });
+    return recovered;
+}
+// Match live runtime evidence, never the search index or a title/cwd heuristic.
+export function recoverSessionBinding(record, records, backends, binding) {
+    if (binding && binding.sessionId !== record.sessionId)
+        return null;
+    if (record.backendSessionId && backends.has(record.backendSessionId))
+        return null;
+    const nativeSessionId = binding?.nativeSessionId ?? record.agentResume?.sessionId;
+    const agentSlug = binding?.agentSlug ?? record.agentResume?.slug;
+    const candidates = [...backends].filter(([id, backend]) => {
+        if (records.some((other) => other.sessionId !== record.sessionId && other.backendSessionId === id))
+            return false;
+        if (backend.mode !== record.mode)
+            return false;
+        if (record.tmuxSessionName && backend.tmuxSessionName !== record.tmuxSessionName)
+            return false;
+        const nativeId = backend.agentSession?.sessionId;
+        const slug = backend.agent?.slug;
+        if (agentSlug && slug && agentSlug !== slug)
+            return false;
+        if (nativeSessionId && nativeId && nativeSessionId !== nativeId)
+            return false;
+        if (record.agentResume && slug && record.agentResume.slug !== slug)
+            return false;
+        if (record.agentResume?.sessionId && nativeId && record.agentResume.sessionId !== nativeId)
+            return false;
+        const tmuxMatch = record.mode === 'tmux' && Boolean(record.tmuxSessionName)
+            && backend.tmuxSessionName === record.tmuxSessionName;
+        const nativeMatch = Boolean(nativeId) && nativeSessionId === nativeId && agentSlug === slug;
+        return tmuxMatch || nativeMatch;
+    });
+    return candidates.length === 1 ? candidates[0] : null;
+}

package/dist/server/cli.js

@@ -1255,9 +1255,12 @@ async function runCollab(command) {
     }
     const backendSessionId = process.env.TERMDOCK_BACKEND_SESSION_ID?.trim() || null;
     let tmuxSessionName = null;
-    if (!backendSessionId && process.env.TMUX) {
+    if (process.env.TMUX) {
         try {
-            const { stdout } = await execFileAsync(process.env.TMUX_BIN || 'tmux', ['display-message', '-p', '#S'], {
+            const paneId = process.env.TMUX_PANE?.trim();
+            const { stdout } = await execFileAsync(process.env.TMUX_BIN || 'tmux', [
+                'display-message', '-p', ...(/^%\d+$/.test(paneId ?? '') ? ['-t', paneId] : []), '#S',
+            ], {
                 timeout: 2_000,
                 maxBuffer: 16 * 1024,
             });
@@ -1266,15 +1269,16 @@ async function runCollab(command) {
                 tmuxSessionName = detected;
         }
         catch {
-            // The explicit backend id remains the primary path; tmux is a fallback
-            // for managed panes whose inner shell predates the attach wrapper env.
+            // Keep a working backend context if tmux inspection fails. A surviving
+            // pane may retain an obsolete backend id after TD reattaches it, so
+            // send both identities whenever tmux inspection succeeds.
         }
     }
     if (!backendSessionId && !tmuxSessionName) {
         console.error(JSON.stringify({ ok: false, code: 'SESSION_NOT_FOUND', error: 'td collab must run inside a Termdock-managed Session.' }));
         process.exit(1);
     }
-    const context = backendSessionId ? { backendSessionId } : { tmuxSessionName };
+    const context = { backendSessionId, tmuxSessionName };
     const baseUrl = runningState.localUrl
         ?? `${runningState.scheme ?? 'http'}://${runningState.host === '0.0.0.0' ? 'localhost' : runningState.host}:${runningState.port}`;
     process.exitCode = await executeCollaborationCommand(command, Object.fromEntries(Object.entries(context).filter((entry) => typeof entry[1] === 'string')), { request: (method, endpoint, body, timeout) => method === 'GET'