termdock 1.4.363 → 1.4.365

package/dist/server/federation/runtime.js

@@ -22,6 +22,7 @@ import { socketDuplex } from './socketDuplex.js';
 import { markEncryptedRequest } from './requestContext.js';
 import { readTerminalHandshakeDimensions } from '../utils/terminalHandshakeDimensions.js';
 import { openAccessAllowed } from './openAccess.js';
+import { relayPasswordConfigured, requireRelayPassword } from './relaySecurity.js';
 import { isAuthEnabled, getPasswordCredentialFingerprint, getPasswordVerifier, getLoginBlockMs, recordLoginFailure, recordLoginSuccess } from '../utils/authProtection.js';
 import { MAX_OPEN_SECURE_SOCKETS, MAX_SERVER_HTTP_REQUESTS } from './streamLimits.js';
 import { MAX_TRANSFER_WINDOW, TRANSFER_CHUNK_BYTES, TransferWindow, transferWindow } from './transferWindow.js';
@@ -152,7 +153,7 @@ export async function createFederationRuntime(app, directory, handlers, options
     async function acceptDuplex(duplex, context = {}) {
         let collaborationRpc;
         let unregisterCollaboration;
-        const open = (action) => openAccessAllowed(context.allowOpenAccess === true, isAuthEnabled(), action);
+        const open = (action) => openAccessAllowed(!context.relayed && context.allowOpenAccess === true, isAuthEnabled(), action);
         const stableSessionId = (id) => {
             try {
                 const resolved = options.resolveSessionId?.(id);
@@ -163,6 +164,8 @@ export async function createFederationRuntime(app, directory, handlers, options
             }
         };
         const allowed = (subjectId, action, sessionId) => {
+            if (context.relayed && !relayPasswordConfigured())
+                return false;
             if (open(action) || store.authorize({ subjectId, serviceId, action, sessionId }).allowed)
                 return true;
             // The wire may still carry the transient backend PTY id while the grant
@@ -172,10 +175,10 @@ export async function createFederationRuntime(app, directory, handlers, options
             const stable = stableSessionId(sessionId);
             return stable !== undefined && store.authorize({ subjectId, serviceId, action, sessionId: stable }).allowed;
         };
-        const resources = (subjectId) => mergeShareResources(store.listEffective({ subjectId, serviceId }).map(g => g.resources));
+        const resources = (subjectId) => mergeShareResources(context.relayed && !relayPasswordConfigured() ? [] : store.listEffective({ subjectId, serviceId }).map(g => g.resources));
         const androidAllowed = (subjectId, serial, control = false) => full(subjectId) || (control ? androidRouteAccess(resources(subjectId).android, serial) === 'control' : !!androidRouteAccess(resources(subjectId).android, serial));
         const computerAllowed = (subjectId, target) => full(subjectId) || !!computerResource(resources(subjectId), target.host, target.protocol, target.port);
-        const full = (subjectId) => open() || store.hasFullServiceAccess({ subjectId, serviceId });
+        const full = (subjectId) => (!context.relayed || relayPasswordConfigured()) && (open() || store.hasFullServiceAccess({ subjectId, serviceId }));
         let channel;
         const operations = new Map();
         const sockets = new Map();
@@ -190,6 +193,8 @@ export async function createFederationRuntime(app, directory, handlers, options
             const check = (action, sessionId) => { if (!allowed(subjectId, action, sessionId))
                 throw new Error('AUTHORIZATION_DENIED'); };
             const httpAllowed = (head) => {
+                if (context.relayed)
+                    requireRelayPassword();
                 if (typeof head.method !== 'string' || typeof head.path !== 'string' || !isBusinessApiPath(head.method, head.path))
                     throw new Error('API_NOT_ALLOWED');
                 const policy = resolveAccessRequest(head.method, head.path);
@@ -275,6 +280,10 @@ export async function createFederationRuntime(app, directory, handlers, options
                 }
             }
             revokeTimer = setInterval(() => {
+                if (context.relayed && !relayPasswordConfigured()) {
+                    duplex.close?.(new Error('TARGET_PASSWORD_REQUIRED'));
+                    return;
+                }
                 for (const { socket: logical, sessionId, android, computer, computerTarget, computerControl } of sockets.values()) {
                     if (android || computer) {
                         if (android ? !androidAllowed(subjectId, android) : !computerTarget || !computerAllowed(subjectId, computerTarget) || (computerControl && !full(subjectId) && !resources(subjectId).computers?.some(c => c.host.toLowerCase() === computerTarget.host.toLowerCase() && c.protocol === computerTarget.protocol && c.port === computerTarget.port && c.access === 'control')))
@@ -300,6 +309,8 @@ export async function createFederationRuntime(app, directory, handlers, options
                 try {
                     if (packet.id.length > 128)
                         throw new Error('INVALID_ID');
+                    if (context.relayed)
+                        requireRelayPassword();
                     if (collaborationRpc?.accept(packet))
                         continue;
                     if (packet.type === 'collaboration-connect') {

package/dist/server/federation/selfRelay.js

@@ -6,6 +6,7 @@ import { RelayClient } from './relay.js';
 import { openServiceSocket } from './serviceTransport.js';
 import { serviceEndpoint, normalizeServiceAddress } from './connectionModel.js';
 import { connectCollaborationRpc } from '../agent/collaborationPeerTransport.js';
+import { relayPasswordConfigured, requireRelayPassword } from './relaySecurity.js';
 function relayEndpoint(origin, selfRelayToken) {
     const url = serviceEndpoint(origin, 'relay');
     url.searchParams.set('selfRelayToken', selfRelayToken);
@@ -115,8 +116,11 @@ export class DesktopSelfRelay {
         try {
             if (this.stopped || state.stopped)
                 return;
-            const client = new RelayClient(upstream, { targets: new Map([[this.options.serviceId,
-                        (signal) => openServiceSocket(serviceEndpoint(typeof this.options.localOrigin === 'function' ? this.options.localOrigin() : this.options.localOrigin).href, { ca: this.options.localCa }, { signal: AbortSignal.any([signal, state.lifetime.signal]) })]]) });
+            const client = new RelayClient(upstream, { routeTtlMs: 4000, isPasswordProtected: () => relayPasswordConfigured(), targets: new Map([[this.options.serviceId,
+                        (signal) => {
+                            requireRelayPassword();
+                            return openServiceSocket(serviceEndpoint(typeof this.options.localOrigin === 'function' ? this.options.localOrigin() : this.options.localOrigin, 'relay-target').href, { ca: this.options.localCa }, { signal: AbortSignal.any([signal, state.lifetime.signal]) });
+                        }]]) });
             state.client = client;
             await new Promise(resolve => {
                 if (upstream.readyState !== WebSocket.OPEN)

package/dist/server/federation/serviceTransport.js

@@ -33,7 +33,7 @@ export async function createServiceSocket(address, trust = {}, options = {}) {
     const url = new URL(address);
     const origin = normalizeServiceAddress(url.origin.replace(/^wss:/, 'https:').replace(/^ws:/, 'http:'));
     if (!['wss:', 'ws:'].includes(url.protocol) || url.username || url.password || url.hash
-        || !['/api/federation/secure', '/api/federation/relay'].includes(url.pathname)
+        || !['/api/federation/secure', '/api/federation/relay', '/api/federation/relay-target'].includes(url.pathname)
         || [...url.searchParams.keys()].length > 1
         || [...url.searchParams.keys()].some(key => url.pathname !== '/api/federation/relay' || !['routeToken', 'selfRelayToken'].includes(key))
         || url.search && Object.keys(options.headers || {}).some(key => key.toLowerCase() === 'authorization'))

package/dist/server/routes/filesystem.js

@@ -1554,8 +1554,19 @@ function searchEntryMatches(rootPath, candidatePath, queryLower) {
     if (!queryLower)
         return false;
     const name = path.basename(candidatePath).toLowerCase();
-    const relative = path.relative(rootPath, candidatePath) || name;
-    return name.includes(queryLower) || toSearchPath(relative).includes(queryLower) || toSearchPath(candidatePath).includes(queryLower);
+    const relative = toSearchPath(path.relative(rootPath, candidatePath) || name);
+    if (relative.includes(queryLower) || toSearchPath(candidatePath).includes(queryLower))
+        return true;
+    // Match abbreviations in order, within the search scope. Including the root
+    // here would let unrelated ancestor names turn every file into a match.
+    let offset = 0;
+    for (const char of queryLower) {
+        const index = relative.indexOf(char, offset);
+        if (index < 0)
+            return false;
+        offset = index + char.length;
+    }
+    return true;
 }
 function addSearchEntry(entries, entryPath, type) {
     if (entries.has(entryPath))
@@ -1651,6 +1662,7 @@ function addMatchingParentDirectories(rootPath, absoluteFilePath, queryLower, en
 }
 function searchWithRipgrep(rootPath, queryLower, showHidden, excludePatterns, signal) {
     return new Promise((resolve, reject) => {
+        throwIfAborted(signal, 'fs.search');
         const args = ['--files', '--color', 'never', '--no-messages', '--null'];
         if (showHidden)
             args.push('--hidden', '-g', '!.git/');
@@ -1674,6 +1686,8 @@ function searchWithRipgrep(rootPath, queryLower, showHidden, excludePatterns, si
         signal.addEventListener('abort', abortHandler);
         proc.stdout.setEncoding('utf8');
         proc.stdout.on('data', (chunk) => {
+            if (settled || signal.aborted)
+                return;
             stdout += chunk;
             let boundary = stdout.lastIndexOf('\0');
             if (boundary < 0)
@@ -1733,6 +1747,7 @@ async function searchWithFallback(rootPath, queryLower, showHidden, excludePatte
             continue;
         }
         for (const dirent of dirents) {
+            throwIfAborted(signal, 'fs.search');
             if (!showHidden && dirent.name.startsWith('.'))
                 continue;
             if (dirent.name === '.git')
@@ -1784,6 +1799,7 @@ function createSearchBatchEmitter(res) {
 }
 function streamSearchWithRipgrep(rootPath, queryLower, showHidden, excludePatterns, signal, res) {
     return new Promise((resolve, reject) => {
+        throwIfAborted(signal, 'fs.search');
         const args = ['--files', '--color', 'never', '--no-messages', '--null'];
         if (showHidden)
             args.push('--hidden', '-g', '!.git/');
@@ -1827,6 +1843,8 @@ function streamSearchWithRipgrep(rootPath, queryLower, showHidden, excludePatter
         signal.addEventListener('abort', abortHandler);
         proc.stdout.setEncoding('utf8');
         proc.stdout.on('data', (chunk) => {
+            if (settled || signal.aborted)
+                return;
             stdout += chunk;
             const boundary = stdout.lastIndexOf('\0');
             if (boundary < 0)
@@ -1886,6 +1904,7 @@ async function streamSearchWithFallback(rootPath, queryLower, showHidden, exclud
             continue;
         }
         for (const dirent of dirents) {
+            throwIfAborted(signal, 'fs.search');
             if (!showHidden && dirent.name.startsWith('.'))
                 continue;
             if (dirent.name === '.git')
@@ -1932,6 +1951,7 @@ function createContentBatchEmitter(res) {
 // "ripgrep required" error instead.
 function streamContentSearchWithRipgrep(rootPath, query, showHidden, excludePatterns, options, signal, res) {
     return new Promise((resolve, reject) => {
+        throwIfAborted(signal, 'fs.search');
         const args = [
             '--json',
             '--no-messages',
@@ -2021,6 +2041,8 @@ function streamContentSearchWithRipgrep(rootPath, query, showHidden, excludePatt
         };
         proc.stdout.setEncoding('utf8');
         proc.stdout.on('data', (chunk) => {
+            if (settled || signal.aborted)
+                return;
             stdout += chunk;
             let newlineIndex = stdout.indexOf('\n');
             while (newlineIndex >= 0) {
@@ -3002,6 +3024,11 @@ router.get('/search', async (req, res) => {
         });
     };
     req.on('close', () => controller.abort(new SupersededRequestError('fs.search')));
+    res.on('close', () => controller.abort(new SupersededRequestError('fs.search')));
+    controller.signal.addEventListener('abort', () => {
+        if (isResponseWritable(res))
+            res.end();
+    }, { once: true });
     registerIoSlot({ requestId, op: 'fs.search', action, slotId: requestSlotId, controller, path: requestedPath });
     try {
         if (!requestedPath) {

package/dist/server/routes/terminal.js

@@ -1,3 +1,6 @@
+import { TerminalOutputActivity } from '../utils/terminalOutputActivity.js';
+import { createTodoWebhookRouter } from '../todos/webhook.js';
+import { readCollectionOutputTime } from '../todos/tmuxOutput.js';
 import { sessionViewModeRoutes, SessionViewModeStore } from '../agent/sessionViewModeRoutes.js';
 import { incompleteOscSuffix } from '../utils/oscBuffer.js';
 import { terminalProgramStatus, PROGRAM_STATUS_REPLY } from '../shared/programStatus.js';
@@ -26,7 +29,6 @@ import { TerminalClientAttachment } from '../utils/terminalClientAttachment.js';
 import { TerminalPasteBuffer } from '../utils/terminalPasteBuffer.js';
 import { SharedSessionSampler, SharedSnapshotCache } from '../utils/sharedSampling.js';
 import { batchTmuxOptions, TmuxMetadataWriter } from '../utils/tmuxMetadataWriter.js';
-import { redrawTmuxClient } from '../utils/tmuxClientRedraw.js';
 import { TmuxDisplayGeometry } from '../utils/tmuxDisplayGeometry.js';
 import { TmuxInitialScreen } from '../utils/tmuxInitialScreen.js';
 import { readTmuxObserverSize } from '../utils/tmuxObserverSize.js';
@@ -47,7 +49,7 @@ import { getPtyHostManager } from '../ptyhost/manager.js';
 import { pathValidator } from '../utils/pathValidator.js';
 import { TERMINAL, TMUX } from '../config.js';
 import { localAccessManager, localAccessInterfaceUrl } from '../utils/localAccess.js';
-import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, getAutoRenameAgentsSetting, setAutoRenameAgentsSetting, getAutoRenameNamerSetting, setAutoRenameNamerSetting, getAutoRenameModelsSetting, setAutoRenameModelsSetting, getAutoRenameIntervalMinutesSetting, setAutoRenameIntervalMinutesSetting, getAutoRenamePromptPreferenceSetting, setAutoRenamePromptPreferenceSetting, getAutoRenamePromptPayloadCharsSetting, setAutoRenamePromptPayloadCharsSetting, getNewSessionAgentSlugSetting, setNewSessionAgentSlugSetting, getRunningSessionButtonEnabledSetting, getAttentionButtonEnabledSetting, getCollaborationPanelsSetting, setCollaborationPanelSetting, getAndroidPanelSetting, setAndroidPanelSetting, getRightSidebarTabsSetting, setRightSidebarTabsSetting, getCollaborationFloatingGroupIdSetting, setCollaborationFloatingGroupIdSetting, getServiceSwitcherExpandedSetting, setServiceSwitcherExpandedSetting, setRunningSessionButtonEnabledSetting, setAttentionButtonEnabledSetting, getFileSortModesSetting, getHideGitIgnoredRootsSetting, getGitIgnoreExceptionsSetting, setGitIgnoreExceptionsSetting, setHideGitIgnoredRootSetting, setFileSortModesSetting, setFileSortModeSetting, getNestedGitScanRootsSetting, setNestedGitScanRootSetting, getPinnedExplorerRootsSetting, setPinnedExplorerRootsSetting, setPinnedExplorerRootSetting, watchPinnedExplorerRootsSetting, getActiveGitReposSetting, setActiveGitRepoSetting, } from '../utils/settings.js';
+import { normalizeLocalAccessName, getLocaleSetting, setLocaleSetting, getContextDraftHeightSetting, setContextDraftHeightSetting, getAutoRenameAgentsSetting, setAutoRenameAgentsSetting, getAutoRenameNamerSetting, setAutoRenameNamerSetting, getAutoRenameModelsSetting, setAutoRenameModelsSetting, getAutoRenameIntervalMinutesSetting, setAutoRenameIntervalMinutesSetting, getAutoRenamePromptPreferenceSetting, setAutoRenamePromptPreferenceSetting, getAutoRenamePromptPayloadCharsSetting, setAutoRenamePromptPayloadCharsSetting, getNewSessionShortcutActionSetting, setNewSessionShortcutActionSetting, getNewSessionAgentSlugSetting, setNewSessionAgentSlugSetting, getRunningSessionButtonEnabledSetting, getAttentionButtonEnabledSetting, getCollaborationPanelsSetting, setCollaborationPanelSetting, getAndroidPanelSetting, setAndroidPanelSetting, getRightSidebarTabsSetting, setRightSidebarTabsSetting, getCollaborationFloatingGroupIdSetting, setCollaborationFloatingGroupIdSetting, getServiceSwitcherExpandedSetting, setServiceSwitcherExpandedSetting, setRunningSessionButtonEnabledSetting, setAttentionButtonEnabledSetting, getFileSortModesSetting, getHideGitIgnoredRootsSetting, getGitIgnoreExceptionsSetting, setGitIgnoreExceptionsSetting, setHideGitIgnoredRootSetting, setFileSortModesSetting, setFileSortModeSetting, getNestedGitScanRootsSetting, setNestedGitScanRootSetting, getPinnedExplorerRootsSetting, setPinnedExplorerRootsSetting, setPinnedExplorerRootSetting, watchPinnedExplorerRootsSetting, getActiveGitReposSetting, setActiveGitRepoSetting, } from '../utils/settings.js';
 import { loadContextDraft, saveContextDraft } from '../utils/contextDraft.js';
 import { getOnboardingServerUrl } from '../onboardingServer.js';
 import { inspectLinuxInotifyUsage, isWatchResourceExhaustion } from '../utils/fileWatchPolicy.js';
@@ -3436,6 +3438,7 @@ async function buildSessionInventory() {
     if (synchronizedPersistedFields) {
         schedulePersistGlobalState();
     }
+    const collectionSessions = todoStore.collectionSessions();
     const clientSessions = globalSessionState.sessions.map((session) => {
         const backendLive = !!session.backendSessionId && terminalSessions.has(session.backendSessionId);
         const tmuxLive = session.mode === 'tmux' && !!session.tmuxSessionName && liveTmuxByName.has(session.tmuxSessionName);
@@ -3462,6 +3465,7 @@ async function buildSessionInventory() {
         return {
             ...session,
             frontendSessionId: session.sessionId,
+            collectionRunId: collectionSessions.get(session.sessionId) ?? null,
             customName: session.customName === true,
             connected: backendLive,
             live,
@@ -5346,6 +5350,7 @@ function cleanupSession(sessionId, options) {
     const sampler = terminalSamplers.get(sessionId);
     sampler?.sampler.stop();
     terminalSamplers.delete(sessionId);
+    session.outputActivity?.dispose();
     session.dataDisposable?.dispose();
     session.exitDisposable?.dispose();
     cancelLongRunningAutoTitle(session);
@@ -5451,6 +5456,8 @@ function applyPtyResize(sessionId, session, cols, rows, source, originClientId)
     const cleanCols = Math.floor(cols);
     const cleanRows = Math.floor(rows);
     const changed = session.cols !== cleanCols || session.rows !== cleanRows;
+    if (!changed)
+        return true;
     try {
         session.ptyProcess.resize(cleanCols, cleanRows);
     }
@@ -5632,6 +5639,14 @@ function processSessionOutput(sessionId, session, data, opts) {
         session.lastActivity = Date.now();
         session.lastOutputAt = Date.now();
         session.hasWrittenData = true;
+        // Observe the persistent session PTY once, never each display client or replay.
+        if (data.length > 0 && terminalSessions.get(sessionId) === session) {
+            session.outputActivity ??= new TerminalOutputActivity(active => {
+                if (terminalSessions.get(sessionId) === session)
+                    broadcastEvent(sessionId, { type: 'terminal-output-activity', active });
+            });
+            session.outputActivity.record();
+        }
     }
     let seq;
     if (session.mode === 'shell') {
@@ -6655,7 +6670,129 @@ router.get('/session-inventory', async (_req, res) => {
         res.status(500).json({ error: errorMessage || 'Failed to build session inventory' });
     }
 });
+// Collection runtimes use the same inventory, pane writer and delivery barrier as normal sessions.
+const todoCollectionSessions = {
+    async observe(id) {
+        const record = globalSessionState.sessions.find(candidate => candidate.sessionId === id);
+        if (!record)
+            return null;
+        if (record.mode !== 'tmux' || !record.tmuxSessionName)
+            throw new TodoError('收集会话须为 tmux 终端', 409);
+        if (collaborationStore.list().some(group => group.sessionIds.includes(id)))
+            throw new TodoError('会话已加入协作组，不再自动回收或复用', 409);
+        let layout;
+        try {
+            layout = await getTmuxLayout(record.tmuxSessionName);
+        }
+        catch (error) {
+            if (isTmuxSessionMissingMessage(getErrorMessage(error)) || isTmuxServerMissingMessage(getErrorMessage(error)))
+                return null;
+            throw error;
+        }
+        const serverStart = layout.serverPid ? await processStartIdentity(layout.serverPid) : null;
+        if (!serverStart)
+            throw new Error('无法确认收集终端身份');
+        const existingBackend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
+        const backend = existingBackend ?? terminalSessions.get((await openInventorySession({}, { preferredFrontendSessionId: id, requireExisting: true, mode: 'tmux' })).terminalSession.sessionId);
+        if (!backend)
+            throw new Error('无法观测收集终端');
+        const current = globalSessionState.sessions.find(candidate => candidate.sessionId === id);
+        if (!current || current.tmuxSessionName !== record.tmuxSessionName)
+            throw new Error('收集终端已变化');
+        return { identity: JSON.stringify([layout.serverPid, serverStart, layout.sessionId,
+                layout.windows.flatMap(window => window.panes.map(pane => [pane.id, pane.pid])), current.backendSessionId,
+                backend.ptyProcess.pid, current.agentLaunchGeneration ?? null]),
+            ownershipIdentity: JSON.stringify([layout.serverPid, serverStart, layout.sessionId, layout.windows.flatMap(window => window.panes.map(pane => [pane.id, pane.pid]))]), lastOutputAt: await readCollectionOutputTime(runTmux, layout.sessionId, layout.windows.map(window => window.id)), observedAt: Date.now() };
+    },
+    async reuse(run, id, prompt, beforePrompt) {
+        await collaborationDeliveryWorker.reconfigure(id, async () => {
+            if (collaborationStore.pendingCount(id))
+                throw new TodoError('收集会话有待发送消息，请稍后重试', 409);
+            const target = await todoRuntime.target(id);
+            if (target.config.agentSlug !== run.config.agentSlug)
+                throw new TodoError('会话中的 Agent 已变化，请重新选择', 409);
+            const record = globalSessionState.sessions.find(candidate => candidate.sessionId === id);
+            const guard = terminalInputGuard(record), write = await automaticTerminalInput(record, guard);
+            if (beforePrompt) {
+                await write(beforePrompt);
+                const started = Date.now(), layout = await getTmuxLayout(record.tmuxSessionName);
+                // Submit reset separately, then give the terminal time to apply it before sending the collection prompt.
+                while (true) {
+                    guard();
+                    const backend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
+                    if (!backend)
+                        throw new Error('收集终端已关闭');
+                    const lastOutputAt = await readCollectionOutputTime(runTmux, layout.sessionId, layout.windows.map(window => window.id));
+                    if (Date.now() - Math.max(started, lastOutputAt) >= 1000)
+                        break;
+                    if (Date.now() - started > 30_000)
+                        throw new TodoError('复用前命令仍有输出，请检查终端后重试', 409);
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                }
+            }
+            guard();
+            await todoRuntime.target(id);
+            guard();
+            await write(prompt);
+        });
+    },
+    async close(id, expected) {
+        let closed = false;
+        await collaborationDeliveryWorker.reconfigure(id, async () => {
+            if (collaborationStore.pendingCount(id) || !todoStore.collectionSessions().has(id))
+                return;
+            const observed = await todoCollectionSessions.observe(id);
+            if (!observed || observed.identity !== expected.identity || observed.lastOutputAt !== expected.lastOutputAt)
+                return;
+            const record = globalSessionState.sessions.find(candidate => candidate.sessionId === id);
+            const backend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
+            if (!backend || !record.tmuxSessionName || !record.backendSessionId)
+                return;
+            const guard = terminalInputGuard(record), rawName = record.tmuxSessionName;
+            const immutableSessionId = JSON.parse(expected.identity)[2];
+            await enqueueTmuxIo(backend, async () => {
+                guard();
+                const identity = JSON.parse(expected.identity);
+                const layout = await getTmuxLayout(rawName);
+                if (layout.sessionId !== immutableSessionId || layout.serverPid !== identity[0]
+                    || await processStartIdentity(layout.serverPid) !== identity[1]
+                    || JSON.stringify(layout.windows.flatMap(window => window.panes.map(pane => [pane.id, pane.pid]))) !== JSON.stringify(identity[3]))
+                    return;
+                const lastOutputAt = await readCollectionOutputTime(runTmux, immutableSessionId, layout.windows.map(window => window.id));
+                guard();
+                if (lastOutputAt !== expected.lastOutputAt || !todoStore.collectionSessions().has(id)
+                    || collaborationStore.pendingCount(id) || collaborationStore.list().some(group => group.sessionIds.includes(id)))
+                    return;
+                intentionallyDeletingTmuxSessions.add(rawName);
+                try {
+                    await runTmux(['kill-session', '-t', immutableSessionId]);
+                }
+                finally {
+                    intentionallyDeletingTmuxSessions.delete(rawName);
+                }
+                archiveAgentResumeRecord(record, 'closed');
+                cleanupSession(record.backendSessionId, { killProcess: true });
+                dynamicTmuxMetadata.forget(rawName);
+                collaborationStore.archiveSession(id);
+                collaborationRouting.remove(id);
+                removeGlobalSessionRecord(id);
+                await persistGlobalStateNow();
+                broadcastClientState();
+                closed = true;
+            });
+        });
+        return closed;
+    },
+};
 const todoRuntime = {
+    collectionSessions: todoCollectionSessions,
+    async claimTarget(input) {
+        const record = globalSessionState.sessions.find(candidate => input.sessionId ? candidate.sessionId === input.sessionId : input.backendSessionId && candidate.backendSessionId === input.backendSessionId);
+        if (!record)
+            throw new TodoError('找不到当前 Agent 会话，请用 --session 指定会话 ID', 409);
+        const target = await todoRuntime.target(record.sessionId);
+        return { sessionId: record.sessionId, name: target.name, config: target.config };
+    },
     async target(id) {
         const record = globalSessionState.sessions.find(session => session.sessionId === id);
         if (!record)
@@ -6665,7 +6802,7 @@ const todoRuntime = {
         if (route.state !== 'ready' || route.isShell || !facts.agent)
             throw new TodoError('这个会话暂时无法接收待办，请先在终端启动 Agent', 409);
         const launcher = (await listDetectedAgentLaunchers()).find(agent => agent.slug === facts.agent.slug);
-        return { name: facts.name, config: { agentSlug: facts.agent.slug, command: launcher?.command ?? facts.agent.slug, cwd: record.cwd ?? '', prompt: '' } };
+        return { name: facts.name, mode: record.mode, config: { agentSlug: facts.agent.slug, command: launcher?.command ?? facts.agent.slug, cwd: record.cwd ?? '', prompt: '' } };
     },
     async deliver(run, prompt) {
         const route = await resolveCollaborationRoute(run.sessionId);
@@ -6687,6 +6824,12 @@ const todoRuntime = {
         });
         const sessionId = opened.session.sessionId;
         onSession(sessionId);
+        if (run.kind === 'collect') {
+            const observed = await todoCollectionSessions.observe(sessionId);
+            if (!observed)
+                throw new Error('收集终端已关闭');
+            todoStore.bindCollectionSession(sessionId, observed.ownershipIdentity);
+        }
         const launchGuard = await beginAgentLaunchCheck(sessionId, run.config.agentSlug);
         await writeAutomaticTerminalPrompt(sessionId, run.config.command, undefined, launchGuard);
         await deliverAutomationPromptWhenReady(opened.terminalSession.sessionId, prompt);
@@ -6694,6 +6837,7 @@ const todoRuntime = {
 };
 const todoRunner = new TodoRunner(todoStore, todoRuntime);
 router.use('/operations/todos', todoRoutes(todoStore, todoRunner, todoRuntime));
+export function todoWebhookRouter() { return createTodoWebhookRouter(todoStore, todoRunner); }
 router.get('/operations/automations', (_req, res) => {
     res.json({ automations: automationStore.list(), runs: automationStore.listRuns() });
 });
@@ -7716,6 +7860,7 @@ async function getSettingsPayload() {
         autoRenamePromptPreference: getAutoRenamePromptPreferenceSetting(),
         autoRenamePromptPayloadChars: getAutoRenamePromptPayloadCharsSetting(),
         newSessionAgentSlug: getNewSessionAgentSlugSetting(),
+        newSessionShortcutAction: getNewSessionShortcutActionSetting(),
         runningSessionButtonEnabled: getRunningSessionButtonEnabledSetting(),
         attentionButtonEnabled: getAttentionButtonEnabledSetting(),
         collaborationPanels: getCollaborationPanelsSetting(),
@@ -7863,6 +8008,11 @@ router.put('/settings', async (req, res) => {
         && body.autoRenamePromptPayloadChars <= 64_000) {
         setAutoRenamePromptPayloadCharsSetting(body.autoRenamePromptPayloadChars);
     }
+    if (Object.hasOwn(body, 'newSessionShortcutAction') && body.newSessionShortcutAction !== null
+        && body.newSessionShortcutAction !== 'agent' && body.newSessionShortcutAction !== 'terminal') {
+        res.status(400).json({ error: 'Unsupported new-session shortcut action' });
+        return;
+    }
     if (body.newSessionAgentSlug === null) {
         setNewSessionAgentSlugSetting(null);
     }
@@ -7874,6 +8024,9 @@ router.put('/settings', async (req, res) => {
         }
         setNewSessionAgentSlugSetting(slug);
     }
+    if (Object.hasOwn(body, 'newSessionShortcutAction')) {
+        setNewSessionShortcutActionSetting(body.newSessionShortcutAction);
+    }
     if (body.rightSidebarTabs && typeof body.rightSidebarTabs === 'object') {
         setRightSidebarTabsSetting(body.rightSidebarTabs);
     }
@@ -8563,6 +8716,7 @@ router.get('/:sessionId/stream', async (req, res) => {
     const ptyBackend = session.ptyBackend || 'unknown';
     writeSse(res, {
         type: 'connected',
+        terminalOutputActive: session.outputActivity?.active ?? false,
         runtime,
         ptyBackend,
         mode: session.mode,
@@ -9184,7 +9338,6 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
             attachment.close();
             initialScreen?.cancel();
             initialScreen = null;
-            displayGeometry.reset();
             delivery.setActive(false); // Discard only this observer's obsolete stream.
         }
         replayRequest = (async () => {
@@ -9268,14 +9421,18 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
                 replayOutOfWindow = true;
             }
             // Send connected event (after initial detection)
+            const connectedSize = displayGeometry ? await displayGeometry.readServerSize() : session;
+            if (ws.readyState !== ws.OPEN)
+                return;
             const runtime = globalThis.Bun ? 'bun' : 'node';
             ws.send(JSON.stringify({
                 type: 'connected',
+                terminalOutputActive: session.outputActivity?.active ?? false,
                 streamEpoch: TERMINAL_STREAM_EPOCH,
                 outputProtocol: options.flowControl ? 2 : undefined,
                 copyModeInput: ownTmux,
-                cols: displayGeometry?.size.cols ?? session.cols,
-                rows: displayGeometry?.size.rows ?? session.rows,
+                cols: connectedSize.cols,
+                rows: connectedSize.rows,
                 runtime,
                 ptyBackend: session.ptyBackend || 'unknown',
                 mode: session.mode,
@@ -9410,13 +9567,11 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
                         if (attachment) {
                             await enqueueTmuxIo(session, async () => {
                                 const result = await displayGeometry.resize(attachment, { cols, rows }, tmuxSizeOwnershipSupported);
-                                if (result.ok) {
+                                if (result.ok && result.changed) {
                                     session.lastActivity = Date.now();
                                     broadcastJsonWs(sessionId, {
                                         type: 'pty-size', cols: result.cols, rows: result.rows, source: `ws-resize:${clientId}`,
                                     }, clientId);
-                                    if (result.redraw)
-                                        await redrawTmuxClient(runTmux, session.tmuxSessionName, attachment.pid);
                                 }
                                 if (ws.readyState === ws.OPEN)
                                     ws.send(JSON.stringify({
@@ -9426,15 +9581,9 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
                             });
                             break;
                         }
-                        const sameSize = session.cols === Math.floor(cols) && session.rows === Math.floor(rows);
                         const ok = session.mode === 'tmux'
                             ? await enqueueTmuxIo(session, () => applyPtyResize(sessionId, session, cols, rows, `ws-resize:${clientId}`, clientId))
                             : applyPtyResize(sessionId, session, cols, rows, `ws-resize:${clientId}`, clientId);
-                        // Same-size requests explicitly recover the display; actual geometry
-                        // changes already cause tmux to redraw its attached client.
-                        if (ok && session.mode === 'tmux' && sameSize) {
-                            await enqueueTmuxIo(session, () => redrawTmuxClient(runTmux, session.tmuxSessionName, session.ptyProcess.pid));
-                        }
                         ws.send(JSON.stringify({
                             type: 'resize-ack',
                             seq: typeof msg.seq === 'number' ? msg.seq : undefined,

package/dist/server/todos/claimEligibility.js

@@ -0,0 +1,8 @@
+/** One predicate for source availability counts and atomic claim reservation. */
+export function canClaimTodo(todo, runs, now = Date.now()) {
+    if (todo.status !== 'open' || todo.autoProcessing?.state === 'pending')
+        return false;
+    if (todo.claim)
+        return todo.claim.expiresAt <= now && !runs.find(run => run.id === todo.claim.runId)?.result;
+    return !runs.some(run => run.kind === 'execute' && (run.todoId === todo.id || run.handoff?.todoIds.includes(todo.id)) && run.status !== 'failed');
+}