termdock 1.4.314 → 1.4.315

package/dist/server/agent/integrationSessions.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { cleanMemberName } from './collaborationRoutes.js';
 import path from 'node:path';
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { atomicJson, integrationError } from './integrationStore.js';
@@ -22,8 +23,8 @@ function startupInput(record, now) {
     return condition ? { state: 'pending', deadline: now + (condition.timeoutMs ?? 120000), matched_since: null, observed_at: null } : undefined;
 }
 export function publicIntegrationSession(record) {
-    const { profile: _, deadline: _deadline, launch_submitted: _submitted, startup_condition: _condition, restore_diagnostics: diagnostics, launch_diagnostics: launchDiagnostics, launch_diagnostics_history: _history, message_history_seen: _messages, ...publicRecord } = record;
-    return { ...publicRecord, ...(diagnostics ? { restore_diagnostics_available: true } : {}),
+    const { profile: _, deadline: _deadline, launch_submitted: _submitted, startup_condition: _condition, restore_diagnostics: diagnostics, launch_diagnostics: launchDiagnostics, launch_diagnostics_history: _history, message_history_seen: _messages, close_intent: _closeIntent, ...publicRecord } = record;
+    return { ...publicRecord, close_pending: !!_closeIntent, ...(diagnostics ? { restore_diagnostics_available: true } : {}),
         ...(launchDiagnostics ? { launch_diagnostics_available: true } : {}) };
 }
 export function permittedCwd(profile, cwd) {
@@ -60,6 +61,7 @@ export class IntegrationSessions {
     lifecycle = new SessionLifecycleCoordinator();
     mutations = new Map();
     coldRetries = new Set();
+    closingOperations = new Set();
     timers = new Set();
     stopObservation;
     stopDeliveryGuard;
@@ -84,7 +86,7 @@ export class IntegrationSessions {
             record.runtime_present ??= null;
         }
         for (const record of this.doc.sessions)
-            if (['starting', 'restoring', 'binding_pending'].includes(record.state) || record.state === 'releasing' || record.startup_input?.state === 'pending')
+            if (['starting', 'restoring', 'binding_pending'].includes(record.state) || ['releasing', 'closing'].includes(record.state) || record.startup_input?.state === 'pending')
                 this.scheduleRefresh(record);
         // A pre-restart partial match cannot prove continuity of the live screen.
         for (const record of this.doc.sessions)
@@ -245,8 +247,14 @@ export class IntegrationSessions {
     }
     assertRuntimeMessage(id) {
         const record = this.doc.sessions.find(s => s.session_id === id);
+        if (this.closingOperations.has(id))
+            integrationError('SESSION_OPERATION_IN_PROGRESS', 'Session close preflight is in progress', 409);
         if (this.coldRetries.has(id) || record?.cold_retry_pending)
             integrationError('SESSION_OPERATION_IN_PROGRESS', 'Cold retry must finish or be reconciled before sending', 409);
+        if (record?.state === 'closing' && !record.operation_uncertain)
+            integrationError('SESSION_OPERATION_IN_PROGRESS', 'Session close is in progress', 409);
+        if (record?.close_intent)
+            integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Close outcome requires reconciliation', 409);
         assertMessageRuntime(record);
         // Durable, conservative latch before admission; even a later enqueue
         // failure cannot make a previously attempted business request disappear.
@@ -301,6 +309,7 @@ export class IntegrationSessions {
             const request = this.request(principal, key, ['retry-cold', id, generation]);
             if (request.previous)
                 return this.replayRequest(principal, id, request.previous);
+            this.assertManagementSettled(this.lookup(principal, id));
             if (!this.adapter.retryCold || !this.adapter.messageHistory)
                 integrationError('SESSION_COLD_RETRY_UNSUPPORTED', 'Runtime adapter does not support verified cold retry', 409);
             if (this.pending.has(id))
@@ -308,6 +317,7 @@ export class IntegrationSessions {
             this.coldRetries.add(id);
             try {
                 const record = await this.get(principal, id);
+                this.assertManagementSettled(record);
                 assertReleaseGeneration(record, generation);
                 if (record.cold_retry_pending || record.operation_uncertain)
                     integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Reconcile prior lifecycle outcome before cold retry', 409);
@@ -373,6 +383,7 @@ export class IntegrationSessions {
         let releaseNative;
         try {
             const record = await this.get(principal, id);
+            this.assertManagementSettled(record);
             if (record.cold_retry_pending)
                 integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Reconcile the cold retry before native restore', 409);
             if (!record.agent_native_session_id)
@@ -448,6 +459,7 @@ export class IntegrationSessions {
             const record = structuredClone(this.doc.sessions.find(s => s.session_id === id));
             if (!record)
                 return integrationError('INTEGRATION_SESSION_NOT_FOUND', 'Recovery record does not exist', 404);
+            this.assertManagementSettled(record);
             assertReleaseGeneration(record, generation);
             if (this.pending.has(id) || record.operation_uncertain || ['starting', 'restoring', 'binding_pending', 'releasing'].includes(record.state)) {
                 integrationError('SESSION_OPERATION_IN_PROGRESS', 'Resolve the current lifecycle operation before clearing startup input conditions', 409);
@@ -469,6 +481,7 @@ export class IntegrationSessions {
             const record = structuredClone(this.doc.sessions.find(s => s.session_id === id));
             if (!record)
                 return integrationError('INTEGRATION_SESSION_NOT_FOUND', 'Recovery record does not exist', 404);
+            this.assertManagementSettled(record);
             assertReleaseGeneration(record, generation);
             if (this.pending.has(id) || ['starting', 'restoring', 'binding_pending', 'releasing'].includes(record.state))
                 integrationError('SESSION_OPERATION_IN_PROGRESS', 'Resolve the current operation before confirming compatibility', 409);
@@ -481,16 +494,145 @@ export class IntegrationSessions {
             return record;
         });
     }
+    assertManagementSettled(record) {
+        if (record.state === 'closed')
+            integrationError('SESSION_CLOSED', 'Explicitly closed sessions cannot be restored or restarted', 409);
+        if (record.state === 'closing' && !record.operation_uncertain)
+            integrationError('SESSION_OPERATION_IN_PROGRESS', 'Session close is in progress', 409);
+        if (record.close_intent || record.state === 'closing')
+            integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Reconcile the pending close before any lifecycle operation', 409);
+        if (record.rename_pending)
+            integrationError('SESSION_RENAME_SYNC_PENDING', 'Read session get to reconcile the pending name update', 409);
+    }
+    assertManagementIdle(record) {
+        if (this.pending.has(record.session_id) || record.cold_retry_pending || record.operation_uncertain || ['starting', 'restoring', 'binding_pending', 'releasing', 'closing'].includes(record.state)) {
+            integrationError('SESSION_OPERATION_IN_PROGRESS', 'Resolve the current lifecycle operation first', 409);
+        }
+    }
+    async rename(principal, id, generation, value, key) {
+        if (typeof value !== 'string')
+            integrationError('INVALID_NAME', 'name must be non-empty text up to 80 characters');
+        const name = cleanMemberName(value);
+        if (!name)
+            integrationError('INVALID_NAME', 'name must be non-empty text up to 80 characters');
+        return this.mutate(principal, key, ['rename', id, generation, name], () => this.lifecycle.run(id, async () => {
+            const request = this.request(principal, key, ['rename', id, generation, name]);
+            if (request.previous)
+                return this.replayRequest(principal, id, request.previous);
+            if (!this.adapter.rename)
+                integrationError('SESSION_RENAME_UNSUPPORTED', 'Runtime adapter does not support renaming', 409);
+            const record = await this.get(principal, id);
+            assertReleaseGeneration(record, generation);
+            if (record.close_intent || record.rename_pending)
+                integrationError('SESSION_OPERATION_IN_PROGRESS', 'Resolve the pending management operation first', 409);
+            this.assertManagementIdle(record);
+            await this.adapter.prepareRename?.(record);
+            record.name = name;
+            record.name_updated_at = Date.now();
+            record.updated_at = record.name_updated_at;
+            record.generation = generation + 1;
+            record.name_generation = record.generation;
+            record.name_operation_id = record.operation_id;
+            record.rename_pending = true;
+            this.doc.requests[request.scoped] = { hash: request.hash, sessionId: id, operationId: record.operation_id, generation: record.generation };
+            try {
+                this.saveRecord(record);
+            }
+            catch (error) {
+                delete this.doc.requests[request.scoped];
+                throw error;
+            }
+            try {
+                await this.adapter.rename(record);
+                record.rename_pending = false;
+                this.saveRecord(record);
+            }
+            catch { /* Durable intent is retried by get/restart; no runtime is created. */ }
+            return this.lookup(principal, id);
+        }));
+    }
+    async closeSession(principal, id, generation, key) {
+        return this.mutate(principal, key, ['close', id, generation], () => this.lifecycle.run(id, async () => {
+            const request = this.request(principal, key, ['close', id, generation]);
+            if (request.previous)
+                return this.replayRequest(principal, id, request.previous);
+            this.closingOperations.add(id);
+            try {
+                if (!this.adapter.prepareClose || !this.adapter.closeRuntime || !this.adapter.runtimePresent)
+                    integrationError('SESSION_CLOSE_UNSUPPORTED', 'Runtime adapter does not support closing', 409);
+                const record = await this.get(principal, id);
+                assertReleaseGeneration(record, generation);
+                if (record.close_intent || record.rename_pending)
+                    integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Read session get to reconcile prior management intent', 409);
+                this.assertManagementIdle(record);
+                if (record.state === 'closed') {
+                    if (await this.adapter.runtimePresent(record))
+                        integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Unexpected runtime exists for a closed record', 409);
+                    this.doc.requests[request.scoped] = { hash: request.hash, sessionId: id, operationId: record.operation_id, generation: record.generation };
+                    try {
+                        this.save();
+                    }
+                    catch (error) {
+                        delete this.doc.requests[request.scoped];
+                        throw error;
+                    }
+                    return record;
+                }
+                if (this.adapter.pendingMessages?.(id))
+                    integrationError('SESSION_PENDING_MESSAGES', 'Pending messages must be resolved before closing', 409);
+                const target = await this.adapter.prepareClose(record);
+                record.operation_id = randomUUID();
+                record.generation = generation + 1;
+                record.state = 'closing';
+                record.close_intent = { operation_id: record.operation_id, target };
+                record.error_code = null;
+                record.operation_uncertain = false;
+                record.updated_at = Date.now();
+                this.doc.requests[request.scoped] = { hash: request.hash, sessionId: id, operationId: record.operation_id, generation: record.generation };
+                try {
+                    this.saveRecord(record);
+                }
+                catch (error) {
+                    delete this.doc.requests[request.scoped];
+                    throw error;
+                }
+                try {
+                    await this.adapter.closeRuntime(record, false);
+                    if (await this.adapter.runtimePresent(record))
+                        integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Runtime removal cannot be confirmed', 409);
+                    record.state = 'closed';
+                    record.runtime_present = false;
+                    record.terminal_binding = null;
+                    record.startup_input = undefined;
+                    record.close_intent = undefined;
+                }
+                catch (error) {
+                    record.state = 'failed';
+                    record.operation_uncertain = true;
+                    record.runtime_present = null;
+                    record.error_code = typeof error.code === 'string' ? error.code : 'SESSION_CLOSE_FAILED';
+                }
+                record.updated_at = Date.now();
+                this.saveRecord(record);
+                return record;
+            }
+            finally {
+                this.closingOperations.delete(id);
+            }
+        }));
+    }
     async release(principal, id, generation, key) {
         return this.mutate(principal, key, ['release', id, generation], () => this.lifecycle.run(id, async () => {
             const request = this.request(principal, key, ['release', id, generation]);
             if (request.previous)
                 return this.replayRequest(principal, id, request.previous);
+            this.assertManagementSettled(this.lookup(principal, id));
             if (!this.adapter.release || !this.adapter.runtimePresent)
                 integrationError('SESSION_RELEASE_UNSUPPORTED', 'Runtime adapter does not support release', 409);
             if (this.pending.has(id))
                 integrationError('SESSION_OPERATION_IN_PROGRESS', 'Launch is in progress', 409);
             const record = await this.get(principal, id);
+            this.assertManagementSettled(record);
             assertReleaseGeneration(record, generation);
             if (record.state !== 'released') {
                 assertReleaseFacts(record, await this.adapter.inspect(record));
@@ -552,6 +694,52 @@ export class IntegrationSessions {
         const record = structuredClone(this.doc.sessions.find(s => s.session_id === id));
         if (!record)
             return;
+        if (record.rename_pending) {
+            if (this.lifecycle.active(id))
+                return;
+            try {
+                await this.lifecycle.run(id, async () => {
+                    if (!this.adapter.rename)
+                        return;
+                    await this.adapter.rename(record);
+                    if (JSON.stringify(this.doc.sessions.find(s => s.session_id === id)) !== JSON.stringify(record))
+                        return;
+                    record.rename_pending = false;
+                    this.saveRecord(record);
+                });
+            }
+            catch { /* Keep the persisted intent for a later get/restart. */ }
+            return;
+        }
+        if (record.state === 'closed' || record.state === 'closing' || record.close_intent) {
+            if (this.lifecycle.active(id))
+                return;
+            try {
+                if (record.state !== 'closed') {
+                    if (!this.adapter.closeRuntime)
+                        integrationError('SESSION_CLOSE_UNSUPPORTED', 'Close reconciliation is unavailable', 409);
+                    await this.adapter.closeRuntime(record, true);
+                }
+                if (!this.adapter.runtimePresent || await this.adapter.runtimePresent(record))
+                    integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Runtime exists for a closed or closing session', 409);
+                const next = { ...record, state: 'closed', runtime_present: false, terminal_binding: null, close_intent: undefined,
+                    operation_uncertain: false, error_code: null, startup_input: undefined };
+                if (JSON.stringify(this.doc.sessions.find(s => s.session_id === id)) !== JSON.stringify(record))
+                    return;
+                if (JSON.stringify(next) !== JSON.stringify(record))
+                    this.saveRecord({ ...next, updated_at: Date.now() });
+            }
+            catch (error) {
+                if (JSON.stringify(this.doc.sessions.find(s => s.session_id === id)) !== JSON.stringify(record))
+                    return;
+                // Keep closed terminal, and keep unresolved intent fenced. Never kill on refresh.
+                const next = { ...record, runtime_present: null, operation_uncertain: true,
+                    error_code: typeof error.code === 'string' ? error.code : 'OPERATION_OUTCOME_UNCONFIRMED' };
+                if (JSON.stringify(next) !== JSON.stringify(record))
+                    this.saveRecord({ ...next, updated_at: Date.now() });
+            }
+            return;
+        }
         if (record.cold_retry_pending && (this.lifecycle.active(id) || this.pending.has(id)))
             return;
         if (record.state === 'released' || record.state === 'releasing' || record.operation_uncertain) {
@@ -688,6 +876,12 @@ export class IntegrationSessions {
         const existing = this.doc.sessions.find(record => record.session_id === id);
         if (!existing)
             return null;
+        if (this.closingOperations.has(id))
+            return { allowed: false, reason: 'SESSION_OPERATION_IN_PROGRESS' };
+        if (existing.state === 'closed')
+            return { allowed: false, reason: 'SESSION_CLOSED' };
+        if (existing.close_intent || existing.state === 'closing')
+            return { allowed: false, reason: 'SESSION_OPERATION_IN_PROGRESS' };
         if (existing.state === 'released' || existing.state === 'releasing' || existing.operation_uncertain)
             return { allowed: false, reason: existing.state === 'released' ? 'SESSION_RELEASED' : 'SESSION_OPERATION_IN_PROGRESS' };
         if (!existing.startup_input)

package/dist/server/agent/integrationStore.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { CollaborationError } from './collaborationProtocol.js';
 export const INTEGRATION_PROTOCOL = 1;
-export const INTEGRATION_OPERATIONS = ['message.send', 'message.read', 'task.read', 'task.create', 'task.configure', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore', 'session.release'];
+export const INTEGRATION_OPERATIONS = ['message.send', 'message.read', 'task.read', 'task.create', 'task.configure', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore', 'session.release', 'session.rename', 'session.close'];
 export function integrationError(code, message, status = 400) { throw new CollaborationError(code, message, status); }
 export function atomicJson(file, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });

package/dist/server/agent/sessionLifecycle.js

@@ -50,6 +50,10 @@ export function assertReleaseFacts(record, facts) {
 export function assertMessageRuntime(record) {
     if (!record)
         return;
+    if (record.state === 'closed')
+        fail('SESSION_CLOSED', 'Session was explicitly closed; it cannot be sent to or restored');
+    if (record.state === 'closing')
+        fail('SESSION_OPERATION_IN_PROGRESS', 'Session close is in progress');
     if (record.state === 'released')
         fail('SESSION_RELEASED', 'Runtime was released; explicitly restore this session before sending');
     if (record.state === 'releasing')

package/dist/server/agent/sessionManagement.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { CollaborationError } from './collaborationProtocol.js';
+const fail = (code, message) => { throw new CollaborationError(code, message, 409); };
+/** Read the live foreground process instance, not a historical PID. */
+export async function foregroundProcessInstance(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return fail('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Foreground process is unavailable');
+    try {
+        if (process.platform === 'linux') {
+            const stat = await fs.readFile(`/proc/${pid}/stat`, 'utf8');
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            if (fields[0] === 'Z' || Number(fields[2]) <= 0 || fields[2] !== fields[5] || !/^\d+$/.test(fields[19]))
+                throw new Error();
+            return `linux:${fields[19]}`;
+        }
+        if (process.platform === 'darwin') {
+            const { stdout } = await promisify(execFile)('ps', ['-p', String(pid), '-o', 'pgid=,tpgid=,stat=,lstart='], { timeout: 2000 });
+            const match = stdout.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+            if (!match || Number(match[1]) < 1 || match[1] !== match[2] || match[3].startsWith('Z'))
+                throw new Error();
+            return `darwin:${match[4]}`;
+        }
+    }
+    catch { /* Never fall back to PID existence. */ }
+    return fail('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Current foreground process instance cannot be verified');
+}
+/** A missing PID is absence; inaccessible identity remains an error. */
+export async function processStartIdentity(pid) {
+    if (process.platform === 'linux') {
+        try {
+            const stat = await fs.readFile(`/proc/${pid}/stat`, 'utf8');
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            if (fields[0] === 'Z')
+                return null;
+            if (!/^\d+$/.test(fields[19]))
+                throw new Error();
+            return `linux:${fields[19]}`;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+        }
+    }
+    else if (process.platform === 'darwin') {
+        try {
+            const { stdout } = await promisify(execFile)('ps', ['-p', String(pid), '-o', 'stat=,lstart='], { timeout: 2000 });
+            const match = stdout.trim().match(/^(\S+)\s+(.+)$/);
+            if (match)
+                return match[1].startsWith('Z') ? null : `darwin:${match[2]}`;
+        }
+        catch {
+            try {
+                process.kill(pid, 0);
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    return null;
+            }
+        }
+    }
+    return fail('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Process disappearance cannot be verified');
+}
+/** Restart reconciliation never issues termination. External tmux/process
+ * changes are outside the service lock; final fresh checks reduce, not erase,
+ * that race. The exact tmux session ID is used for teardown. */
+export async function closeSessionRuntime(adapter, target, reconcile) {
+    await adapter.barrier(async () => {
+        if (adapter.pendingMessages())
+            fail('SESSION_PENDING_MESSAGES', 'Pending messages must be resolved before closing');
+        if (await adapter.exists()) {
+            if (reconcile)
+                fail('OPERATION_OUTCOME_UNCONFIRMED', 'Runtime still exists; reconciliation will not terminate a process');
+            if (!target || JSON.stringify(await adapter.observe()) !== JSON.stringify(target))
+                fail('SESSION_CLOSE_TARGET_CHANGED', 'Runtime or process instance changed after close intent');
+            await adapter.destroy(target);
+            const deadline = Date.now() + 2000;
+            // Observe actual disappearance; do not issue repeated termination.
+            while (await adapter.exists() && Date.now() < deadline)
+                await new Promise(resolve => setTimeout(resolve, 50));
+        }
+        if (await adapter.exists())
+            fail('OPERATION_OUTCOME_UNCONFIRMED', 'Runtime absence cannot be confirmed');
+        await adapter.forgetRuntime();
+    });
+}

package/dist/server/routes/terminal.js

@@ -2,6 +2,7 @@ import { collaborationSessionDisplayName } from '../utils/sessionDisplayName.js'
 import { integrationError } from '../agent/integrationStore.js';
 import { assertNativeResumeAvailable, collectNativeResumeOwnerCandidates } from '../agent/nativeResumeOwner.js';
 import { readNativeProcessIdentity } from '../agent/nativeProcessIdentity.js';
+import { closeSessionRuntime, foregroundProcessInstance, processStartIdentity } from '../agent/sessionManagement.js';
 import { releaseSessionRuntime } from '../agent/sessionLifecycle.js';
 import { resumeConfigurationFingerprint } from '../agent/sessionResumeConfiguration.js';
 import { integrationLaunchCommand } from '../agent/integrationSessions.js';
@@ -629,7 +630,7 @@ function schedulePersistGlobalState() {
         }
     }, 200);
 }
-async function persistGlobalStateNow() {
+async function persistGlobalStateNow(strict = false) {
     if (persistGlobalStateTimer) {
         clearTimeout(persistGlobalStateTimer);
         persistGlobalStateTimer = null;
@@ -639,6 +640,8 @@ async function persistGlobalStateNow() {
     }
     catch (error) {
         console.warn('[session-persist] Failed to persist global state:', getErrorMessage(error));
+        if (strict)
+            throw error;
     }
 }
 // 进程退出前立即刷盘，避免 tsx watch 重启导致状态丢失
@@ -1980,10 +1983,129 @@ async function integrationTmuxPresent(record) {
         throw error;
     }
 }
+async function verifyIntegrationRuntimeOwnership(record) {
+    await integrationSessionAdapter.prepareRelease(record);
+    const terminal = integrationTerminalRecord(record);
+    if (terminal && globalSessionState.sessions.some(other => other.sessionId !== record.session_id
+        && (other.tmuxSessionName === terminal.tmuxSessionName || terminal.backendSessionId && other.backendSessionId === terminal.backendSessionId))) {
+        integrationError('SESSION_IDENTITY_MISMATCH', 'Runtime has another logical owner', 409);
+    }
+}
+async function forgetIntegrationRuntime(record) {
+    if (await integrationTmuxPresent(record))
+        integrationError('OPERATION_OUTCOME_UNCONFIRMED', 'Owned tmux still exists', 409);
+    await verifyIntegrationRuntimeOwnership(record);
+    for (const [id, backend] of terminalSessions)
+        if (backend.mode === 'tmux' && backend.tmuxSessionName === `wt-integration-${record.session_id}`)
+            cleanupSession(id, { killProcess: true });
+    removeGlobalSessionRecord(record.session_id);
+    collaborationStore.archiveSession(record.session_id);
+    collaborationRouting.remove(record.session_id);
+    await persistGlobalStateNow(true);
+    broadcastClientState();
+}
+async function observeIntegrationCloseTarget(record) {
+    await verifyIntegrationRuntimeOwnership(record);
+    const terminal = integrationTerminalRecord(record);
+    if (!terminal || !record.terminal_binding)
+        integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Original runtime binding is unavailable', 409);
+    const inspected = await inspectCollaborationTmux({ 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 }, undefined, false, true);
+    if (inspected.state !== 'ready' || !inspected.pane)
+        integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Original pinned pane cannot be verified', 409);
+    const layout = await getTmuxLayout(terminal.tmuxSessionName);
+    const panes = layout.windows.flatMap(window => window.panes);
+    if (panes.length !== 1 || layout.activePaneId !== record.terminal_binding.paneId)
+        integrationError('SESSION_IDENTITY_MISMATCH', 'Only the single original owned pane can be closed', 409);
+    const pane = panes[0];
+    const paneOwners = (await runTmux(['list-panes', '-a', '-F', '#{session_id} #{pane_id}'])).trim().split('\n');
+    if (paneOwners.some(line => { const [owner, id] = line.trim().split(/\s+/); return id === pane.id && owner !== record.terminal_binding.sessionId; }))
+        integrationError('SESSION_SCOPE_CONFLICT', 'Owned pane is linked into another tmux session', 409);
+    if (process.platform === 'linux')
+        await getProcessSnapshot(true);
+    const program = await resolveTmuxPaneProgram(pane, true, true);
+    const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
+    let kind, pid, nativeId = null;
+    if (agent) {
+        if (!record.agent_native_session_id || agent.slug !== record.agent_slug || program?.source !== 'tmux-tty' || !program.processPid) {
+            integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'A running Agent requires a live exact native identity', 409);
+        }
+        const identity = await observeProgramNativeIdentity(agent, program);
+        if (identity.failure || identity.nativeId !== record.agent_native_session_id)
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Current Agent native identity differs from the owned record', 409);
+        kind = 'agent';
+        pid = program.processPid;
+        nativeId = identity.nativeId;
+    }
+    else {
+        if (!await integrationPaneIsIdleShell(inspected.pane))
+            integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Current runtime is not a verified foreground shell', 409);
+        kind = 'shell';
+        pid = pane.pid;
+    }
+    const serverStart = await processStartIdentity(record.terminal_binding.serverPid);
+    if (!serverStart)
+        integrationError('SESSION_CLOSE_TARGET_UNCONFIRMED', 'Current tmux server instance is unavailable', 409);
+    return { binding: { ...record.terminal_binding }, tmux_server_start_id: serverStart, kind, process_pid: pid,
+        process_start_id: await foregroundProcessInstance(pid), native_id: nativeId };
+}
 export const integrationSessionAdapter = {
     subscribe(listener) { integrationSessionObservers.add(listener); return () => { integrationSessionObservers.delete(listener); }; },
     registerDeliveryGuard(guard) { integrationDeliveryGuard = guard; return () => { if (integrationDeliveryGuard === guard)
         integrationDeliveryGuard = undefined; }; },
+    async prepareRename(record) {
+        await verifyIntegrationRuntimeOwnership(record);
+        if (!integrationTerminalRecord(record) && await integrationTmuxPresent(record))
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Live tmux lacks its owned terminal registration', 409);
+    },
+    async rename(record) {
+        await integrationSessionAdapter.prepareRename(record);
+        const terminal = integrationTerminalRecord(record);
+        if (!terminal)
+            return; // Metadata survives released/closed; never recreate a runtime.
+        if (!record.name)
+            integrationError('INVALID_NAME', 'Missing persistent display name');
+        if (await integrationTmuxPresent(record))
+            await setTmuxOption(terminal.tmuxSessionName, '@termdock-friendly-name', record.name);
+        upsertGlobalSessionRecord({ ...terminal, name: record.name, customName: true, autoTitle: null });
+        await persistGlobalStateNow(true);
+        await getSessionInventorySnapshot({ refresh: true });
+        broadcastClientState();
+    },
+    async prepareClose(record) {
+        if (collaborationStore.pendingCount(record.session_id))
+            integrationError('SESSION_PENDING_MESSAGES', 'Pending messages must be resolved before closing', 409);
+        await verifyIntegrationRuntimeOwnership(record);
+        return await integrationTmuxPresent(record) ? observeIntegrationCloseTarget(record) : null;
+    },
+    async closeRuntime(record, reconcile) {
+        await closeSessionRuntime({
+            barrier: action => collaborationDeliveryWorker.reconfigure(record.session_id, action),
+            async exists() {
+                if (await integrationTmuxPresent(record))
+                    return true;
+                const target = record.close_intent?.target;
+                return !!target && await processStartIdentity(target.process_pid) === target.process_start_id;
+            },
+            pendingMessages: () => collaborationStore.pendingCount(record.session_id),
+            observe: () => observeIntegrationCloseTarget(record),
+            async destroy(target) {
+                // Kill by immutable tmux session ID, not by a potentially reused name.
+                // No process-group kill or application prompt is sent.
+                if (JSON.stringify(await observeIntegrationCloseTarget(record)) !== JSON.stringify(target))
+                    integrationError('SESSION_CLOSE_TARGET_CHANGED', 'Close target changed before teardown', 409);
+                intentionallyDeletingTmuxSessions.add(`wt-integration-${record.session_id}`);
+                try {
+                    await runTmux(['kill-session', '-t', target.binding.sessionId]);
+                }
+                finally {
+                    intentionallyDeletingTmuxSessions.delete(`wt-integration-${record.session_id}`);
+                }
+            },
+            forgetRuntime: () => forgetIntegrationRuntime(record),
+        }, record.close_intent?.target ?? null, reconcile);
+    },
     pendingMessages(id) { return collaborationStore.pendingCount(id); },
     messageHistory(id) { return collaborationStore.hasTerminalMessageHistory(id); },
     async prepareRelease(record) {
@@ -2186,7 +2308,7 @@ async function launchIntegrationTerminal(record, restoring, prepared, progress,
         }
         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 });
+            name: record.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);