termdock 1.4.299 → 1.4.301

package/dist/server/routes/terminal.js

@@ -1,3 +1,6 @@
+import { collaborationSessionDisplayName } from '../utils/sessionDisplayName.js';
+import { integrationError } from '../agent/integrationStore.js';
+import { integrationLaunchCommand } from '../agent/integrationSessions.js';
 import { ensureTeam } from '../agent/collaborationTeam.js';
 import { androidRecordings } from '../android/recording.js';
 import { assertPeerRegistrationAuthority } from '../agent/collaborationPeerTransport.js';
@@ -26,7 +29,7 @@ import { gitStatusCache } from '../utils/gitStatus.js';
 import { getPtyHostManager } from '../ptyhost/manager.js';
 import { pathValidator } from '../utils/pathValidator.js';
 import { TERMINAL, TMUX } from '../config.js';
-import { localAccessManager } from '../utils/localAccess.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, normalizeAndroidPanel, 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';
@@ -51,6 +54,7 @@ import { CollaborationStore } from '../agent/collaborationStore.js';
 import { COLLAB_NAME_FORBIDDEN, formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
 import { ambiguousIdMessage } from '../agent/collaborationProtocol.js';
 import { buildCollaborationSpawnCommand, resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
+import { resolveCollaborationLaunch, launchProfileKey } from '../agent/collaborationLaunchProfiles.js';
 import { SessionSearchStore } from '../agent/sessionSearchStore.js';
 import { NativeSessionSearch } from '../agent/nativeSessionSearch.js';
 import { CollaborationError } from '../agent/collaborationProtocol.js';
@@ -435,7 +439,16 @@ async function flushClientStateBroadcast() {
         }
     }
 }
+const integrationSessionObservers = new Set();
+let integrationDeliveryGuard;
+function notifyIntegrationSessions() { for (const listener of integrationSessionObservers) {
+    try {
+        listener();
+    }
+    catch { /* Observation failure does not affect terminal clients. */ }
+} }
 function broadcastClientState() {
+    notifyIntegrationSessions();
     if (broadcastClientStateTimer) {
         return;
     }
@@ -1401,7 +1414,12 @@ function orchestrationSessionSnapshot(record) {
         sessionId: record.sessionId,
         agentNativeSessionId: binding?.pane ? binding.pane.nativeSessionId : binding?.nativeSessionId ?? backend?.agentSession?.sessionId ?? record.agentResume?.sessionId ?? null,
         backendSessionId: backendId ?? null,
-        name: record.name,
+        name: collaborationSessionDisplayName({ ...record,
+            activeProgram: backend?.activeProgram?.command ?? record.activeProgram,
+            shellTitle: backend?.lastOscTitle ?? record.shellTitle,
+            cwd: backend?.cwd ?? record.cwd,
+            agent: agent ? { displayName: agent.displayName } : null,
+        }),
         cwd: backend?.cwd ?? record.cwd ?? '',
         agent: agent ? { slug: agent.slug, displayName: agent.displayName } : null,
         status: route.state === 'unchecked' && terminalConnected ? 'terminal-connected' : route.state,
@@ -1642,6 +1660,11 @@ async function resolveCollaborationRoute(frontendSessionId) {
     let record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
     if (!record)
         return { state: 'offline', reason: 'SESSION_REMOVED' };
+    if (record.tmuxSessionName?.startsWith('wt-integration-') && !integrationDeliveryGuard)
+        return { state: 'unavailable', reason: 'INTEGRATION_RUNTIME_UNAVAILABLE' };
+    const startup = await integrationDeliveryGuard?.(frontendSessionId);
+    if (startup && !startup.allowed)
+        return { state: 'recovering', reason: startup.reason ?? 'SESSION_STARTUP_INPUT_PENDING' };
     let backend = resolveOrchestrationBackend(record);
     let binding = collaborationRouting.get(frontendSessionId) ?? {
         sessionId: record.sessionId, backendSessionId: null, mode: record.mode, tmuxSessionName: record.tmuxSessionName,
@@ -1729,7 +1752,7 @@ function deliverCollaborationInboxWhenAgentReady(frontendSessionId) {
     collaborationDeliveryWorker.wake(frontendSessionId);
 }
 async function spawnCollaborationAgentSession(req, group, sourceSessionId, input, bootstrapRole) {
-    const agentSlug = typeof input.agentSlug === 'string' ? input.agentSlug.trim().toLowerCase() : '';
+    const { agentSlug, profile } = resolveCollaborationLaunch(group, input);
     const launchers = await listDetectedAgentLaunchers();
     const launcher = launchers.find((candidate) => candidate.slug === agentSlug);
     if (!launcher)
@@ -1751,7 +1774,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     }
     const requestedCwd = typeof input.cwd === 'string' ? input.cwd.trim() : '';
     const opened = await openInventorySession(req, {
-        name: requestedName || `${launcher.displayName} · ${group.name}`,
+        name: requestedName || `${profile?.name ?? launcher.displayName} · ${group.name}`,
         customName: true,
         mode,
         cwd: requestedCwd || fallbackRecord?.cwd || undefined,
@@ -1780,7 +1803,9 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     });
     if (bootstrapRole)
         collaborationStore.setRole({ groupId: group.id, sessionId: frontendSessionId, role: bootstrapRole });
-    writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: launcher.command })}\r`);
+    if (profile)
+        collaborationStore.setMemberLaunchProfile(group.id, frontendSessionId, profile);
+    writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: profile?.command ?? launcher.command })}\r`);
     const requestedTask = typeof input.task === 'string' ? input.task.trim().slice(0, 20_000) : '';
     collaborationStore.send({
         groupId: updatedGroup.id,
@@ -1792,7 +1817,154 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     setTimeout(() => {
         deliverCollaborationInboxWhenAgentReady(frontendSessionId);
     }, 300).unref?.();
-    return { group: updatedGroup, session: orchestrationSessionSnapshot(globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId)) };
+    return { group: collaborationStore.getGroup(group.id), session: orchestrationSessionSnapshot(globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId)) };
+}
+/** Restricted session adapter: only preconfigured argv and the exact owned
+ * terminal can be launched; no remote drive or arbitrary shell commands. */
+async function integrationPaneIsIdleShell(pane) {
+    if (!pane.isShell)
+        return false;
+    try {
+        const { stdout } = await execFileAsync('ps', ['-p', String(pane.panePid), '-o', 'pgid=,tpgid=,args='], { timeout: 3000, maxBuffer: 16384 });
+        const row = stdout.trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+        if (!row || row[1] !== row[2])
+            return false;
+        const argv = splitCommandToArgv(row[3]);
+        const command = normalizeProgramName(argv[0]?.replace(/^-/, ''))?.toLowerCase();
+        return !!command && shellNamesBackend.has(command) && argv.slice(1).every(arg => ['-l', '-i', '-il', '-li', '--login', '--interactive'].includes(arg));
+    }
+    catch {
+        return false;
+    }
+}
+function integrationTerminalRecord(record) {
+    const terminal = globalSessionState.sessions.find(s => s.sessionId === record.session_id);
+    if (terminal && (terminal.mode !== 'tmux' || terminal.tmuxSessionName !== `wt-integration-${record.session_id}`))
+        integrationError('SESSION_IDENTITY_MISMATCH', 'Owned TD terminal binding changed', 409);
+    return terminal;
+}
+export const integrationSessionAdapter = {
+    subscribe(listener) { integrationSessionObservers.add(listener); return () => { integrationSessionObservers.delete(listener); }; },
+    registerDeliveryGuard(guard) { integrationDeliveryGuard = guard; return () => { if (integrationDeliveryGuard === guard)
+        integrationDeliveryGuard = undefined; }; },
+    async capture(record) {
+        const observed = await integrationSessionAdapter.inspect(record);
+        if (!observed.exists || !observed.running || observed.agentSlug !== record.agent_slug || !record.terminal_binding
+            || record.agent_native_session_id && observed.nativeId && record.agent_native_session_id !== observed.nativeId) {
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Startup input observation requires the original Agent pane', 409);
+        }
+        return captureTmuxPaneText(runTmux, record.terminal_binding);
+    },
+    async inspect(record) {
+        const terminal = integrationTerminalRecord(record);
+        if (!terminal)
+            return { exists: false, running: false, shell: false, agentSlug: null, nativeId: null };
+        const binding = { sessionId: record.session_id, backendSessionId: terminal.backendSessionId,
+            mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: record.agent_slug,
+            nativeSessionId: record.agent_native_session_id, pane: record.terminal_binding ?? null };
+        const inspected = await inspectCollaborationTmux(binding);
+        if (inspected.state === 'offline')
+            return { exists: false, running: false, shell: false, agentSlug: null, nativeId: null };
+        if (inspected.state !== 'ready' || !inspected.pane)
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Owned tmux pane cannot be uniquely verified', 409);
+        const pane = inspected.pane;
+        const layout = await getTmuxLayout(terminal.tmuxSessionName);
+        if (layout.windows.flatMap(window => window.panes).length !== 1 || layout.activePaneId !== pane.paneId)
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Integration native binding requires the single owned pane', 409);
+        const backend = terminal.backendSessionId ? terminalSessions.get(terminal.backendSessionId) : null;
+        // Hook evidence is fresh process evidence only on the single owned pane.
+        // A recovered last-known UUID must not prove a new launch succeeded.
+        const nativeId = pane.agentSlug ? pane.nativeSessionId ?? (backend?.agent?.slug === pane.agentSlug && backend.agentSession?.rich && !backend.agentResumeRecovered ? backend.agentSession.sessionId : null) ?? null : null;
+        if (nativeId && (nativeId.length > 256 || /[\x00-\x1f\x7f]/.test(nativeId)))
+            integrationError('NATIVE_SESSION_ID_INVALID', 'Observed native session id is invalid', 409);
+        const route = collaborationRouting.get(record.session_id);
+        if (nativeId && (!record.agent_native_session_id || record.agent_native_session_id === nativeId) && route?.pane
+            && route.pane.paneId === pane.paneId && route.pane.panePid === pane.panePid && route.pane.serverPid === pane.serverPid && route.pane.sessionId === pane.sessionId
+            && route.pane.nativeSessionId !== nativeId)
+            collaborationRouting.bind({ ...route, nativeSessionId: nativeId, pane: { ...route.pane, nativeSessionId: nativeId } });
+        return { exists: true, running: Boolean(pane.agentSlug), shell: await integrationPaneIsIdleShell(pane), agentSlug: pane.agentSlug || null, nativeId };
+    },
+    async create(record, prepared) {
+        await listDetectedAgentLaunchers();
+        if (!agentBySlug(record.agent_slug))
+            integrationError('COLLAB_AGENT_UNAVAILABLE', 'Configured agent plugin is not installed');
+        if (integrationTerminalRecord(record))
+            integrationError('SESSION_CREATE_OUTCOME_UNKNOWN', 'Creation intent already has a terminal; inspect it instead of relaunching', 409);
+        await launchIntegrationTerminal(record, false, prepared);
+    },
+    async restore(record, prepared) {
+        await listDetectedAgentLaunchers();
+        const agent = agentBySlug(record.agent_slug);
+        if (!record.agent_native_session_id || !agent || !buildResumeCommand(agent, record.agent_native_session_id, null))
+            integrationError('EXACT_RESUME_UNSUPPORTED', 'Agent plugin must support exact native resume');
+        if (findActiveAgentResumeOwner('', { slug: record.agent_slug, nativeSessionId: record.agent_native_session_id, command: '' }))
+            integrationError('NATIVE_SESSION_ALREADY_RUNNING', 'Native Agent conversation is already running', 409);
+        await launchIntegrationTerminal(record, true, prepared);
+    },
+};
+async function launchIntegrationTerminal(record, restoring, prepared) {
+    await collaborationDeliveryWorker.reconfigure(record.session_id, async () => {
+        const group = collaborationStore.getGroup(record.group_id);
+        if (!group || group.deleted)
+            integrationError('TASK_GROUP_NOT_FOUND', 'Integration group no longer exists', 404);
+        const original = await integrationSessionAdapter.inspect(record);
+        if (!original.exists) {
+            let tmuxExists = false;
+            try {
+                await runTmux(['has-session', '-t', `=wt-integration-${record.session_id}`]);
+                tmuxExists = true;
+            }
+            catch (error) {
+                if (!/can't find session|no server running|no sessions|error connecting.*No such file/i.test(getErrorMessage(error)))
+                    throw error;
+            }
+            if (tmuxExists)
+                integrationError('SESSION_IDENTITY_MISMATCH', 'A terminal with this name exists without the owned binding', 409);
+        }
+        const opened = await openInventorySession({}, { preferredFrontendSessionId: record.session_id,
+            mode: 'tmux', tmuxSessionName: `wt-integration-${record.session_id}`, cwd: record.cwd,
+            name: `${record.agent_slug} · ${group.name}`, customName: true });
+        if (opened.session.sessionId !== record.session_id)
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Terminal id changed', 409);
+        const terminal = integrationTerminalRecord(record);
+        const backend = terminalSessions.get(opened.terminalSession.sessionId);
+        if (!backend)
+            integrationError('SESSION_BACKEND_UNAVAILABLE', 'Owned terminal backend is unavailable', 503);
+        const inspected = await inspectCollaborationTmux({ sessionId: record.session_id, backendSessionId: opened.terminalSession.sessionId,
+            mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: null, nativeSessionId: null,
+            // A recreated tmux may get a new pane only during explicit exact resume.
+            pane: original.exists ? record.terminal_binding ?? null : null }, null, true);
+        if (inspected.state !== 'ready' || !inspected.pane || !await integrationPaneIsIdleShell(inspected.pane))
+            integrationError('SESSION_TARGET_NOT_SHELL', 'Refusing to launch into an unverified shell', 409);
+        const pane = inspected.pane;
+        const pinned = { serverPid: pane.serverPid, sessionId: pane.sessionId,
+            paneId: pane.paneId, panePid: pane.panePid, agentSlug: record.agent_slug, nativeSessionId: record.agent_native_session_id };
+        prepared(pinned); // Must persist before the command enters the terminal.
+        collaborationRouting.bind({ sessionId: record.session_id, backendSessionId: opened.terminalSession.sessionId,
+            mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: record.agent_slug, nativeSessionId: record.agent_native_session_id, pane: pinned });
+        const latest = collaborationStore.getGroup(group.id);
+        if (!latest || latest.deleted)
+            integrationError('TASK_GROUP_NOT_FOUND', 'Integration group changed', 409);
+        collaborationStore.save({ id: latest.id, name: latest.name, sessionIds: [...new Set([...latest.sessionIds, record.session_id])] });
+        if (restoring)
+            upsertGlobalSessionRecord({ ...terminal, agentResume: { slug: record.agent_slug, sessionId: record.agent_native_session_id,
+                    launchArgv: [record.profile.executable, ...record.profile.argv], updatedAt: Date.now() } });
+        await persistGlobalStateNow();
+        // Recheck the actual pinned shell immediately before writing. This cannot
+        // use an active-pane target which might have changed during preparation.
+        const shell = await inspectCollaborationTmux({ sessionId: record.session_id, backendSessionId: opened.terminalSession.sessionId,
+            mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: null, nativeSessionId: null, pane: pinned });
+        if (shell.state !== 'ready' || !shell.pane || !await integrationPaneIsIdleShell(shell.pane))
+            integrationError('SESSION_TARGET_NOT_SHELL', 'Owned shell changed before launch', 409);
+        // This owned pane is a verified shell; clear stale rich state before a new
+        // process starts, so its new SessionStart must supply the native binding.
+        backend.agentSession = null;
+        backend.agent = null;
+        backend.agentResumeRecovered = false;
+        await runTmux(['send-keys', '-t', pinned.paneId, '-l', integrationLaunchCommand(record, restoring)]);
+        await runTmux(['send-keys', '-t', pinned.paneId, 'Enter']);
+        broadcastClientState();
+    });
 }
 const preparingTaskWorkers = new Map();
 /** Dedicated persistent terminals leave existing member sessions and the user's checkout untouched. */
@@ -1806,10 +1978,16 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
         if (!source || template.serviceId !== service.descriptor().serviceId)
             throw new Error('执行成员当前不可用，请协调者重新分派');
         const snapshot = orchestrationSessionSnapshot(source);
+        const inheritedProfile = collaborationStore.getGroup(task.groupId)?.memberLaunchProfiles?.[template.sessionId];
         const slug = snapshot.agent?.slug ?? source.agentResume?.slug;
         const launcher = (await listDetectedAgentLaunchers()).find(a => a.slug === slug);
         if (!launcher || !source.cwd)
             throw new Error('独立代码任务需要有项目目录的 Agent 成员，请选择可用成员');
+        if (inheritedProfile) {
+            if (inheritedProfile.agentSlug !== launcher.slug)
+                throw new Error('执行成员的启动方案与当前 Agent 不一致，请重新分派');
+            resolveCollaborationLaunch({ launchProfiles: [inheritedProfile] }, { launchProfileId: inheritedProfile.id, agentSlug: launcher.slug });
+        }
         const workspace = await prepareTaskWorkspace(task, source.cwd, dependencies, (dependency, repository) => importTaskDependency(task, dependency, repository, service, readDependency));
         await pathValidator.allowSessionCwd(workspace.cwd);
         const existing = globalSessionState.sessions.find(s => s.cwd === workspace.cwd);
@@ -1835,7 +2013,7 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
             const temporary = `${launchFile}.${process.pid}.tmp`;
             await fs.promises.writeFile(temporary, JSON.stringify({ sessionId: record.sessionId, backendId: opened.terminalSession.sessionId }), { mode: 0o600 });
             await fs.promises.rename(temporary, launchFile);
-            writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: launcher.command })}\r`);
+            writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: inheritedProfile?.command ?? launcher.command })}\r`);
         }
         const group = collaborationStore.getGroup(task.groupId);
         if (!group || group.deleted)
@@ -1843,6 +2021,8 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
         if (!group.sessionIds.includes(record.sessionId))
             await service.save({ id: group.id, name: group.name,
                 sessionIds: [...group.sessionIds, record.sessionId], expectedUpdatedAt: group.updatedAt });
+        if (inheritedProfile)
+            collaborationStore.setMemberLaunchProfile(group.id, record.sessionId, inheritedProfile);
         return { sessionId: record.sessionId, workspace };
     })().finally(() => preparingTaskWorkers.delete(key));
     preparingTaskWorkers.set(key, operation);
@@ -3192,6 +3372,7 @@ function broadcastAgentStatus(sessionId, session, force = false) {
     if (!force && previousSnapshot === snapshot)
         return;
     lastAgentStatusSnapshots.set(sessionId, snapshot);
+    notifyIntegrationSessions();
     broadcastEvent(sessionId, payload);
     const previous = previousSnapshot
         ? JSON.parse(previousSnapshot)
@@ -5802,26 +5983,28 @@ router.post('/operations/collaboration-groups/:groupId/team', async (req, res) =
             return res.status(404).json({ error: '协作组不存在' });
         if (group.federated)
             throw new Error('跨服务组请先从成员设置添加 Agent');
-        const agentSlug = typeof req.body?.agentSlug === 'string' ? req.body.agentSlug : '';
+        const { agentSlug, profile } = resolveCollaborationLaunch(group, req.body ?? {});
         if (!(await listDetectedAgentLaunchers()).some(agent => agent.slug === agentSlug))
             throw new Error('所选 Agent 当前不可用');
         if (typeof req.body?.cwd !== 'string' || !req.body.cwd.trim())
             throw new Error('请选择工作目录');
         const cwd = await resolveWorkingDirectory(req, req.body.cwd);
         const previous = preparingTeams.get(group.id) ?? Promise.resolve();
-        const operation = previous.catch(() => { }).then(() => ensureTeam({ agentSlug, cwd,
+        const operation = previous.catch(() => { }).then(() => ensureTeam({ agentSlug, cwd, launchProfileKey: launchProfileKey(profile),
             members: () => {
                 const current = collaborationStore.getGroup(group.id);
                 if (!current || current.deleted)
                     throw new Error('协作组已删除');
+                if (profile && launchProfileKey(current.launchProfiles?.find(p => p.id === profile.id)) !== launchProfileKey(profile))
+                    throw new Error('启动方案已变更，请重新开始协作');
                 return globalSessionState.sessions.filter(record => current.sessionIds.includes(record.sessionId))
-                    .map(record => ({ id: record.sessionId, cwd: record.cwd, role: current.roles?.[record.sessionId], agentSlug: orchestrationSessionSnapshot(record).agent?.slug }));
+                    .map(record => ({ id: record.sessionId, cwd: record.cwd, role: current.roles?.[record.sessionId], agentSlug: orchestrationSessionSnapshot(record).agent?.slug, launchProfileKey: launchProfileKey(current.memberLaunchProfiles?.[record.sessionId]) }));
             },
             spawn: async (role) => {
                 const current = collaborationStore.getGroup(group.id);
                 if (!current || current.deleted)
                     throw new Error('协作组已删除');
-                const result = await spawnCollaborationAgentSession(req, current, null, { agentSlug, cwd, mode: 'tmux', name: role.startsWith('自动协调者') ? `协调 ${group.name}` : `执行与评审 ${group.name}` }, role);
+                const result = await spawnCollaborationAgentSession(req, current, null, { agentSlug, launchProfileId: profile?.id ?? '', cwd, mode: 'tmux', name: role.startsWith('自动协调者') ? `协调 ${group.name}` : `执行与评审 ${group.name}` }, role);
                 return result.session.sessionId;
             },
         }));
@@ -6633,7 +6816,7 @@ router.put('/toolbar-presets', (req, res) => {
 async function getSettingsPayload() {
     const localAccess = localAccessManager.getState();
     const interfaces = await Promise.all(localAccess.interfaces.map(async (entry) => {
-        const url = `${localAccess.httpsEnabled ? 'https' : 'http'}://${entry.address}:9834`;
+        const url = localAccessInterfaceUrl(localAccess.url, entry.address);
         const qrDataUrl = await QRCode.toDataURL(url, {
             margin: 1,
             width: 132,
@@ -6669,7 +6852,7 @@ async function getSettingsPayload() {
         localAccess: {
             ...localAccess,
             interfaces,
-            onboardingUrl: getOnboardingServerUrl() ?? null,
+            onboardingUrl: localAccess.status === 'loopback-only' ? null : getOnboardingServerUrl() ?? null,
         },
     };
 }

package/dist/server/utils/localAccess.js

@@ -11,7 +11,26 @@ function normalizeQuestionName(name) {
     return name.endsWith('.') ? name.slice(0, -1).toLowerCase() : name.toLowerCase();
 }
 export function isLoopbackHost(host) {
-    return LOCALHOST_NAMES.has(host) || host.startsWith('127.');
+    const normalized = host.replace(/^\[|\]$/g, '').toLowerCase();
+    return LOCALHOST_NAMES.has(normalized) || normalized.startsWith('127.') || normalized.startsWith('::ffff:127.');
+}
+export function localAccessOrigin(host, port, scheme) {
+    const hostname = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+    return new URL(`${scheme}://${hostname}:${port}`).origin;
+}
+export function localAccessInterfaceUrl(serviceUrl, address) {
+    const origin = new URL(serviceUrl);
+    origin.hostname = address.includes(':') && !address.startsWith('[') ? `[${address}]` : address;
+    return origin.origin;
+}
+function getBoundLanIPv4Interfaces(host) {
+    if (isLoopbackHost(host))
+        return [];
+    const interfaces = getLanIPv4Interfaces();
+    if (host === '0.0.0.0' || host === '::' || host === '[::]')
+        return interfaces;
+    const address = host.replace(/^::ffff:/, '');
+    return interfaces.filter((entry) => entry.address === address);
 }
 function interfaceLabel(name) {
     if (name === 'en0')
@@ -47,18 +66,19 @@ export function getLanIPv4Addresses() {
 }
 function buildState(setting, options, status, reason) {
     const hostname = hostnameForName(setting.name);
-    const interfaces = getLanIPv4Interfaces();
+    const interfaces = getBoundLanIPv4Interfaces(options.host);
     const lanAddresses = interfaces.map((entry) => entry.address);
     const onboardingHost = lanAddresses[0] ?? null;
-    const fallbackHostname = onboardingHost ?? hostname;
+    const wildcardHost = options.host === '0.0.0.0' || options.host === '::' || options.host === '[::]';
+    const fallbackHostname = onboardingHost ?? (wildcardHost ? hostname : options.host);
     return {
         name: setting.name,
         source: setting.source,
         hostname,
         fallbackHostname,
-        url: `${options.scheme}://${hostname}:${options.port}`,
-        fallbackUrl: `${options.scheme}://${fallbackHostname}:${options.port}`,
-        onboardingUrl: onboardingHost ? `http://${onboardingHost}:${options.onboardingPort ?? options.port}/ca` : null,
+        url: localAccessOrigin(hostname, options.port, options.scheme),
+        fallbackUrl: localAccessOrigin(fallbackHostname, options.port, options.scheme),
+        onboardingUrl: onboardingHost ? `${localAccessOrigin(onboardingHost, options.onboardingPort ?? options.port, 'http')}/ca` : null,
         status,
         reason,
         httpsEnabled: options.scheme === 'https',
@@ -84,7 +104,7 @@ export class LocalAccessManager {
         this.options = options;
         await this.stop();
         let setting = await getLocalAccessSettingAsync();
-        const lanAddresses = getLanIPv4Addresses();
+        const lanAddresses = getBoundLanIPv4Interfaces(options.host).map((entry) => entry.address);
         if (isLoopbackHost(options.host)) {
             this.state = buildState(setting, options, 'loopback-only', 'Server is bound to loopback only.');
             return this.state;

package/dist/server/utils/sessionDisplayName.js

@@ -0,0 +1,53 @@
+export const DEFAULT_SESSION_DISPLAY_SHELL_NAMES = new Set([
+    'bash',
+    'zsh',
+    'fish',
+    'sh',
+    'dash',
+    'ksh',
+    'tcsh',
+    'csh',
+    'nu',
+]);
+export function getCwdLeafName(cwd) {
+    if (!cwd)
+        return null;
+    if (cwd === '/')
+        return '/';
+    const segments = cwd.replace(/\/+$/, '').split('/');
+    return segments[segments.length - 1] || cwd;
+}
+export function getSessionDisplayLines(session, activeProgram, cwd, shellNames = DEFAULT_SESSION_DISPLAY_SHELL_NAMES, shellTitle = null, promptState = null) {
+    if (session.customName)
+        return { primary: session.name, secondary: getCwdLeafName(cwd) };
+    // Shell integration (OSC 2) provides real-time title: command name when running,
+    // cwd when idle. This is faster and more accurate than server-side process polling.
+    if (shellTitle) {
+        const cwdLeaf = getCwdLeafName(cwd);
+        const titleLooksLikeCwd = shellTitle === cwd || shellTitle === cwdLeaf;
+        // If the shell reports a running state, the title is the command name.
+        if (promptState !== 'idle' && !shellNames.has(shellTitle) && !titleLooksLikeCwd) {
+            return { primary: shellTitle, secondary: cwdLeaf };
+        }
+        // If idle, the title is typically the cwd — fall through to show cwd leaf.
+    }
+    if (activeProgram && !shellNames.has(activeProgram)) {
+        return { primary: activeProgram, secondary: getCwdLeafName(cwd) };
+    }
+    const dir = getCwdLeafName(cwd);
+    if (dir)
+        return { primary: dir, secondary: null };
+    return { primary: session.name, secondary: null };
+}
+export function getSessionDisplayName(session, activeProgram, cwd, shellNames = DEFAULT_SESSION_DISPLAY_SHELL_NAMES, shellTitle = null, promptState = null) {
+    return getSessionDisplayLines(session, activeProgram, cwd, shellNames, shellTitle, promptState).primary;
+}
+/** Resolve the same title hints the session sidebar uses, without exposing route IDs. */
+export function collaborationSessionDisplayName(session) {
+    const cwdLeaf = getCwdLeafName(session.cwd ?? null);
+    const title = session.shellTitle === session.cwd || session.shellTitle === cwdLeaf ? null : session.shellTitle ?? null;
+    const name = getSessionDisplayName(session, session.activeProgram ?? null, null, DEFAULT_SESSION_DISPLAY_SHELL_NAMES, title);
+    return !name.trim() || /^(?:tmux:|remote:|wt-)/i.test(name) || name === session.sessionId
+        ? session.agent?.displayName || cwdLeaf || '终端会话'
+        : name;
+}