termdock 1.4.344 → 1.4.346

package/dist/server/agent/sessionLaunchDiagnostics.js

@@ -1,5 +1,6 @@
 import { CollaborationError } from './collaborationProtocol.js';
 import { TerminalInputTargetChangedError } from './terminalInput.js';
+import { IntegrationShellWaitError } from './integrationShellWait.js';
 export function beginLaunchDiagnostics(operation_id, generation, kind) {
     const now = Date.now();
     return { operation_id, generation, kind, phase: 'configuration', updated_at: now,
@@ -22,5 +23,6 @@ export function launchFailure(current, error, error_code) {
             : typeof value?.code === 'string' && standard.has(value.code) ? value.code
                 : typeof value?.message === 'string' && standard.has(value.message) ? value.message : 'UNCLASSIFIED_LAUNCH_ERROR';
     return { ...current, updated_at: Date.now(), error_code, reason_code,
+        ...(error instanceof IntegrationShellWaitError ? { shell_check: structuredClone(error.shellEvidence) } : {}),
         ...(error instanceof TerminalInputTargetChangedError ? { target_change: error.evidence } : {}) };
 }

package/dist/server/agent/sessionLaunchState.js

@@ -6,6 +6,7 @@ export function mergeSessionLaunchState(candidate, current, change) {
         return current ? { ...candidate,
             agentLaunchGeneration: current.agentLaunchGeneration ?? null,
             agentLaunchCheck: current.agentLaunchCheck ?? null,
+            agentNativeIdentity: current.agentNativeIdentity ?? null,
         } : candidate;
     if (!current || (current.agentLaunchGeneration ?? null) !== change.expectedGeneration
         || (current.agentLaunchCheck?.id ?? null) !== change.expectedCheckId) {
@@ -16,5 +17,38 @@ export function mergeSessionLaunchState(candidate, current, change) {
             check_phase: 'launch_state_commit', checked_at: Date.now(),
         });
     }
-    return { ...candidate, agentLaunchGeneration: change.generation, agentLaunchCheck: change.check };
+    return { ...candidate, agentLaunchGeneration: change.generation, agentLaunchCheck: change.check,
+        agentNativeIdentity: change.nativeIdentity === undefined ? current.agentNativeIdentity ?? null : change.nativeIdentity };
+}
+/** A file watcher can finish reading an old snapshot after an in-memory launch
+ * or deletion. It must not revert server-owned fields or resurrect that ID. */
+export function mergeReloadedSessionState(disk, beforeRead, current) {
+    const before = new Map(beforeRead.map(record => [record.sessionId, record]));
+    const live = new Map(current.map(record => [record.sessionId, record]));
+    const result = [];
+    const seen = new Set();
+    for (const candidate of disk) {
+        const id = candidate.sessionId, now = live.get(id), old = before.get(id);
+        if (seen.has(id) || old && !now)
+            continue;
+        seen.add(id);
+        result.push(now ? JSON.stringify(now) !== JSON.stringify(old) ? now
+            : mergeSessionLaunchState(candidate, now) : candidate);
+    }
+    for (const record of current) {
+        if (!seen.has(record.sessionId) && (JSON.stringify(record) !== JSON.stringify(before.get(record.sessionId))
+            || record.agentLaunchGeneration || record.agentNativeIdentity))
+            result.push(record);
+    }
+    return result;
+}
+/** Serialize durable global snapshots, taking a fresh value when each write
+ * acquires the queue. A delayed old rename must not overwrite a later launch. */
+export function createSessionStateWriter(current, write) {
+    let pending = Promise.resolve();
+    return () => {
+        const next = pending.catch(() => undefined).then(() => write(structuredClone(current())));
+        pending = next;
+        return next;
+    };
 }

package/dist/server/federation/invitations.js

@@ -84,6 +84,20 @@ export class InvitationStore {
             }
         }
     }
+    listPending() {
+        const now = this.now();
+        return this.read().filter(i => i.consumedAt === undefined && i.invitationExpiresAt > now && (i.expiresAt === undefined || i.expiresAt > now))
+            .map(({ hash, scope, actions, label, expiresAt, createdAt, invitationExpiresAt }) => ({ id: hash, scope, actions, ...(label ? { label } : {}), ...(expiresAt === undefined ? {} : { expiresAt }), createdAt, invitationExpiresAt }));
+    }
+    revoke(id) {
+        const current = this.read();
+        const index = current.findIndex(i => i.hash === id && i.consumedAt === undefined);
+        if (index < 0)
+            return false;
+        current.splice(index, 1);
+        this.save(current);
+        return true;
+    }
     create(issuerId, input) {
         requireValid(identity(issuerId));
         validateInvitation(input);
@@ -103,7 +117,7 @@ export class InvitationStore {
         const invitation = { ...structuredClone(input), ...(input.label ? { label: input.label.trim() } : {}), hash: this.hash(code), issuerId, createdAt: now, invitationExpiresAt: now + TTL };
         current.push(invitation);
         this.save(current);
-        return { code, expiresAt: invitation.invitationExpiresAt };
+        return { invitationId: invitation.hash, code, expiresAt: invitation.invitationExpiresAt };
     }
     consume(code, subjectId, issuerAllowed) {
         if (!/^[A-Za-z0-9_-]{43}$/.test(code) || !identity(subjectId))

package/dist/server/federation/runtime.js

@@ -496,7 +496,11 @@ export async function createFederationRuntime(app, directory, handlers, options
                     }
                     else if (packet.type === 'grants-list') {
                         check('authorization.manage');
-                        send({ type: 'result', id: packet.id, grants: store.list(), deviceProfiles: deviceProfiles.list(), subjectLabels: { ...invitations.subjectLabels(), ...deviceNames.list() } });
+                        send({ type: 'result', id: packet.id, grants: store.list(), invitations: invitations.listPending(), deviceProfiles: deviceProfiles.list(), subjectLabels: { ...invitations.subjectLabels(), ...deviceNames.list() } });
+                    }
+                    else if (packet.type === 'invite-revoke') {
+                        check('authorization.manage');
+                        send({ type: 'result', id: packet.id, revoked: typeof packet.invitationId === 'string' && invitations.revoke(packet.invitationId) });
                     }
                     else if (packet.type === 'grant') {
                         check('authorization.manage');

package/dist/server/routes/terminal.js

@@ -4,7 +4,7 @@ import { isConfirmedEmptyTmuxServer } from '../utils/tmuxEmptyServerProbe.js';
 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 { nativeIdentityDirectory, readNativeProcessIdentity, resolveProfileNativeIdentity } from '../agent/nativeProcessIdentity.js';
 import { closeSessionRuntime, foregroundProcessInstance, processStartIdentity } from '../agent/sessionManagement.js';
 import { releaseSessionRuntime } from '../agent/sessionLifecycle.js';
 import { resumeConfigurationFingerprint } from '../agent/sessionResumeConfiguration.js';
@@ -59,7 +59,8 @@ import { assessAgentResourceBudget, collectHostResourceSnapshot, configuredAgent
 import { AutomationStore, normalizeAutomationSchedule } from '../agent/automationStore.js';
 import { writeBracketedPrompt, canDeliverPromptToAgent } from '../agent/promptDelivery.js';
 import { captureTerminalInputGuard, captureRuntimeInputGuard, waitAndWriteTerminalInput } from '../agent/terminalInput.js';
-import { mergeSessionLaunchState } from '../agent/sessionLaunchState.js';
+import { createSessionStateWriter, mergeReloadedSessionState, mergeSessionLaunchState } from '../agent/sessionLaunchState.js';
+import { waitForIntegrationShell, IntegrationShellWaitError } from '../agent/integrationShellWait.js';
 import { agentLaunchBlockReason, normalizeAgentLaunchCheck } from '../agent/agentLaunchCheck.js';
 import { prepareSupervisionEnable } from '../utils/enableSupervision.js';
 import { buildServerHealthState, dismissServerHealth } from '../utils/serverHealth.js';
@@ -531,12 +532,14 @@ async function migrateFromClientStatesFile() {
         return null;
     }
 }
-async function loadGlobalSessionStateFromDisk() {
+async function loadGlobalSessionStateFromDisk(reload = false) {
+    const beforeRead = structuredClone(globalSessionState.sessions);
     try {
         const data = await readJsonFileIfExists(GLOBAL_SESSION_STATE_FILE);
         if (data) {
+            const sessions = deduplicateGlobalSessions((data.sessions || []).map(s => normalizePersistedClientSession(s)).filter((s) => s !== null));
             globalSessionState = {
-                sessions: deduplicateGlobalSessions((data.sessions || []).map(s => normalizePersistedClientSession(s)).filter((s) => s !== null)),
+                sessions: reload ? mergeReloadedSessionState(sessions, beforeRead, globalSessionState.sessions) : sessions,
                 updatedAt: typeof data.updatedAt === 'number' ? data.updatedAt : Date.now(),
             };
             console.log(`[session-persist] Loaded ${globalSessionState.sessions.length} sessions from global state`);
@@ -587,7 +590,7 @@ async function persistTmuxRecoveryState() {
 async function reloadGlobalSessionStateFromDisk(source) {
     try {
         const previous = JSON.stringify(globalSessionState);
-        await loadGlobalSessionStateFromDisk();
+        await loadGlobalSessionStateFromDisk(true);
         const next = JSON.stringify(globalSessionState);
         if (previous === next) {
             return;
@@ -637,12 +640,13 @@ async function watchGlobalSessionStateFile() {
         reportFailure('[session-persist] Failed to watch global state file:', error);
     }
 }
+const writeGlobalSessionState = createSessionStateWriter(() => globalSessionState, snapshot => writeJsonFile(GLOBAL_SESSION_STATE_FILE, snapshot));
 function schedulePersistGlobalState() {
     if (persistGlobalStateTimer)
         clearTimeout(persistGlobalStateTimer);
     persistGlobalStateTimer = setTimeout(() => {
         try {
-            void writeJsonFile(GLOBAL_SESSION_STATE_FILE, globalSessionState).catch((error) => {
+            void writeGlobalSessionState().catch((error) => {
                 console.warn('[session-persist] Failed to persist global state:', getErrorMessage(error));
             });
         }
@@ -657,7 +661,7 @@ async function persistGlobalStateNow(strict = false) {
         persistGlobalStateTimer = null;
     }
     try {
-        await writeJsonFile(GLOBAL_SESSION_STATE_FILE, globalSessionState);
+        await writeGlobalSessionState();
     }
     catch (error) {
         console.warn('[session-persist] Failed to persist global state:', getErrorMessage(error));
@@ -1002,6 +1006,8 @@ function normalizePersistedClientSession(input) {
         agentLaunchCheck: normalizeAgentLaunchCheck(candidate.agentLaunchCheck),
         agentLaunchGeneration: typeof candidate.agentLaunchGeneration === 'string' ? candidate.agentLaunchGeneration
             : normalizeAgentLaunchCheck(candidate.agentLaunchCheck)?.id ?? null,
+        agentNativeIdentity: nativeIdentityDirectory(candidate.agentNativeIdentity)
+            ? { kind: 'linux-flock-owner', directory: nativeIdentityDirectory(candidate.agentNativeIdentity) } : null,
     };
 }
 function generateTmuxSessionName() {
@@ -1485,14 +1491,18 @@ function searchMetadataForBackend(backendSessionId, session) {
         updatedAt: session.lastActivity,
     };
 }
-async function beginAgentLaunchCheck(frontendSessionId, agentSlug, nativeSessionId = null) {
+async function beginAgentLaunchCheck(frontendSessionId, agentSlug, nativeSessionId = null, nativeIdentity) {
     const record = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
     if (!record)
         throw new Error('SESSION_REMOVED');
     const id = randomUUID();
     const updated = upsertGlobalSessionRecord(record, { expectedGeneration: record.agentLaunchGeneration ?? null,
         expectedCheckId: record.agentLaunchCheck?.id ?? null, generation: id,
-        check: { id, agentSlug, nativeSessionId, deadline: Date.now() + 120_000 } });
+        check: { id, agentSlug, nativeSessionId, deadline: Date.now() + 120_000 },
+        nativeIdentity: nativeIdentity === undefined
+            ? record.agentResume?.slug === agentSlug || collaborationRouting.get(frontendSessionId)?.agentSlug === agentSlug
+                ? record.agentNativeIdentity ?? null : null
+            : nativeIdentity });
     // Capture the guard before persistence yields. The launch command must use
     // this exact generation, even if another launch occurs during an await.
     const assertCurrent = terminalInputGuard(updated);
@@ -1711,7 +1721,7 @@ function formatLocalCollaborationMessages(frontendSessionId, messages) {
  *  agent-keyed selector can never reach it. Delivery still needs an agent (the
  *  confirm gate and prompt formatting assume a TUI); driving a terminal —
  *  run/capture — is a shell operation and works on any pane. */
-async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false, nativeProcessIdentity = false, freshProcess = false, describeNativeFailure = false) {
+async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false, nativeProcessIdentity = false, freshProcess = false, describeNativeFailure = false, identityOverride) {
     if (!binding.tmuxSessionName)
         return { state: 'offline', reason: 'TMUX_BINDING_MISSING' };
     const name = `=${binding.tmuxSessionName}`;
@@ -1737,7 +1747,7 @@ async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane =
         // pane_current_command alone cannot prove an exact resumed conversation.
         const program = await resolveTmuxPaneProgram(pane, true, nativeProcessIdentity || freshProcess);
         const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
-        const identity = nativeProcessIdentity ? await observeProgramNativeIdentity(agent, program)
+        const identity = nativeProcessIdentity ? await observeProgramNativeIdentity(agent, program, identityOverride ?? globalSessionState.sessions.find(record => record.sessionId === binding.sessionId)?.agentNativeIdentity ?? undefined)
             : { nativeId: agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null, failure: null, source: null };
         if (identity.failure && !describeNativeFailure)
             integrationError(identity.failure === 'NATIVE_SESSION_IDENTITY_CONFLICT'
@@ -2050,6 +2060,37 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
 async function integrationPaneIsIdleShell(pane) {
     return (await inspectIntegrationShell(pane)).confirmed;
 }
+function integrationNativeIdentity(record) {
+    if (!record.profile.nativeIdentity)
+        return undefined;
+    if (process.platform !== 'linux')
+        integrationError('SESSION_PROFILE_NATIVE_IDENTITY_UNSUPPORTED', 'Profile writer-lock identity requires Linux', 409);
+    const config = resolveProfileNativeIdentity(record.profile.nativeIdentity, record.cwd);
+    if (!config)
+        integrationError('INVALID_NATIVE_IDENTITY_CONFIG', 'Stored native identity scope is invalid', 409);
+    return config;
+}
+async function waitForOwnedIntegrationShell(record, expected) {
+    return waitForIntegrationShell({ expected, async observe() {
+            const terminal = integrationTerminalRecord(record);
+            if (!terminal)
+                return { binding: null, confirmed: false, agent: false, reason: 'RUNTIME_NOT_REGISTERED', pgid: null, tpgid: null };
+            const layout = await getTmuxLayout(terminal.tmuxSessionName);
+            if (layout.windows.flatMap(window => window.panes).length !== 1) {
+                return { binding: null, confirmed: false, agent: false, reason: 'MULTIPLE_TERMINAL_PANES', pgid: null, tpgid: null };
+            }
+            const inspected = await inspectCollaborationTmux({ sessionId: record.session_id, backendSessionId: terminal.backendSessionId,
+                mode: 'tmux', tmuxSessionName: terminal.tmuxSessionName, agentSlug: null, nativeSessionId: null, pane: expected }, null, true, false, true);
+            const pane = inspected.pane;
+            if (inspected.state !== 'ready' || !pane)
+                return { binding: null, confirmed: false, agent: false,
+                    reason: inspected.reason ?? 'PANE_UNCONFIRMED', pgid: null, tpgid: null };
+            const shell = await inspectIntegrationShell(pane);
+            return { binding: { serverPid: pane.serverPid, sessionId: pane.sessionId, paneId: pane.paneId, panePid: pane.panePid,
+                    agentSlug: '', nativeSessionId: null }, confirmed: shell.confirmed, agent: !!pane.agentSlug,
+                reason: pane.isShell ? shell.failure : 'PANE_NOT_SHELL', pgid: shell.pgid, tpgid: shell.tpgid };
+        } });
+}
 async function inspectIntegrationShell(pane) {
     if (!pane.isShell)
         return { confirmed: false, failure: null, pgid: null, tpgid: null };
@@ -2157,7 +2198,7 @@ async function observeIntegrationCloseTarget(record) {
         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);
+        const identity = await observeProgramNativeIdentity(agent, program, integrationNativeIdentity(record));
         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';
@@ -2246,7 +2287,7 @@ export const integrationSessionAdapter = {
         if (!agent || !command)
             integrationError('EXACT_RESUME_UNSUPPORTED', 'Agent must support exact native recovery', 409);
         return { version: 1, slug: agent.slug, aliases: agent.aliases, capabilities: agent.capabilities ?? [],
-            resume: getPluginResumeConfig(agent.slug) ?? command, nativeIdentity: getPluginNativeIdentityConfig(agent.slug) ?? null };
+            resume: getPluginResumeConfig(agent.slug) ?? command, nativeIdentity: integrationNativeIdentity(record) ?? getPluginNativeIdentityConfig(agent.slug) ?? null };
     },
     async runtimePresent(record) {
         if (integrationTerminalRecord(record))
@@ -2303,7 +2344,7 @@ export const integrationSessionAdapter = {
         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, undefined, false, true);
+        const inspected = await inspectCollaborationTmux(binding, undefined, false, true, false, false, integrationNativeIdentity(record));
         if (inspected.state === 'offline')
             return { exists: false, running: false, shell: false, agentSlug: null, nativeId: null };
         if (inspected.state !== 'ready' || !inspected.pane)
@@ -2443,7 +2484,7 @@ async function assertIntegrationNativeResumeAvailable(record) {
             return Promise.all(layout.windows.flatMap(window => window.panes).map(async (pane) => {
                 const program = await resolveTmuxPaneProgram(pane, true, true);
                 const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
-                const identity = await observeProgramNativeIdentity(agent, program);
+                const identity = await observeProgramNativeIdentity(agent, program, globalSessionState.sessions.find(record => record.sessionId === candidate.sessionId)?.agentNativeIdentity ?? integrationNativeIdentity(record));
                 const shell = await inspectIntegrationShell({ panePid: pane.pid,
                     isShell: !agent && shellNamesBackend.has(normalizeProgramName(program?.command ?? '')?.toLowerCase() ?? '') });
                 return { confirmed: !identity.failure && (shell.confirmed || program?.source === 'tmux-tty' && Boolean(program.rawArgs)),
@@ -2512,13 +2553,17 @@ async function launchIntegrationTerminal(record, restoring, prepared, progress,
             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);
+        if (inspected.state !== 'ready' || !inspected.pane)
+            throw new IntegrationShellWaitError('SESSION_TARGET_NOT_SHELL', {
+                samples: 1, waited_ms: 0, reason: inspected.reason ?? 'PANE_UNCONFIRMED', binding: null, pgid: null, tpgid: null
+            });
         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 };
         progress?.('binding_persist');
         prepared(pinned); // Must persist before the command enters the terminal.
+        progress?.('runtime_shell_wait');
+        await waitForOwnedIntegrationShell(record, pinned);
         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);
@@ -2540,17 +2585,14 @@ async function launchIntegrationTerminal(record, restoring, prepared, progress,
             await assertIntegrationNativeResumeAvailable(record);
         }
         progress?.('runtime_verify');
-        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);
+        await waitForOwnedIntegrationShell(record, pinned);
         // 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;
         progress?.('launch_intent');
-        const launchGuard = await beginAgentLaunchCheck(record.session_id, record.agent_slug, restoring ? record.agent_native_session_id : null);
+        const launchGuard = await beginAgentLaunchCheck(record.session_id, record.agent_slug, restoring ? record.agent_native_session_id : null, integrationNativeIdentity(record) ?? null);
         await writeAutomaticTerminalPrompt(record.session_id, integrationLaunchCommand(record, restoring), progress, launchGuard);
         broadcastClientState();
     });
@@ -3172,10 +3214,22 @@ async function observeTmuxServerGeneration(liveTmuxSessions, authoritativeTmuxLi
         return;
     }
     const liveSessionNames = new Set(liveTmuxSessions.map((session) => session.name));
+    const liveTmuxByName = new Map(liveTmuxSessions.map(session => [session.name, session]));
+    const restoredSessionIds = new Set();
     const candidates = globalSessionState.sessions.flatMap((record) => {
         if (record.mode !== 'tmux' || !record.tmuxSessionName)
             return [];
         const backend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
+        const live = liveTmuxByName.get(record.tmuxSessionName);
+        // rawArgs comes from the refreshed foreground probe, not persisted tmux
+        // options. A live shell alone does not prove its Agent was restored.
+        const liveAgent = live?.rawArgs
+            ? detectAgentFromCommand(live.rawArgs, agentCustomCommands())
+            : null;
+        if (live && record.agentResume?.slug
+            && (liveAgent?.slug === record.agentResume.slug || backend?.agent?.slug === record.agentResume.slug)) {
+            restoredSessionIds.add(record.sessionId);
+        }
         return [{
                 sessionId: record.sessionId,
                 tmuxSessionName: record.tmuxSessionName,
@@ -3191,6 +3245,7 @@ async function observeTmuxServerGeneration(liveTmuxSessions, authoritativeTmuxLi
         liveSessionNames,
         intentionallyDeleting: intentionallyDeletingTmuxSessions,
         existingIncident: tmuxRecoveryState.incident,
+        restoredSessionIds,
         // Apply acknowledgements before rearming sessions observed alive in this scan.
         dismissedSessionIds: new Set(tmuxRecoveryState.dismissedSessionIds),
     });
@@ -3200,7 +3255,7 @@ async function observeTmuxServerGeneration(liveTmuxSessions, authoritativeTmuxLi
         tmuxRecoveryState.incident = incident;
         changed = true;
         if (incident) {
-            console.error(`[tmux-recovery] shared server loss detected; ${incident.affectedSessionIds.length} Agent session(s) can be restored`);
+            console.warn(`[tmux-recovery] session recovery pending; ${incident.affectedSessionIds.length} Agent session(s) can be restored`);
         }
     }
     if (currentServerPid !== null && currentServerPid !== tmuxRecoveryState.lastServerPid) {
@@ -3227,7 +3282,6 @@ async function buildSessionInventory() {
             liveTmuxSessions = [];
         }
     }
-    await observeTmuxServerGeneration(liveTmuxSessions, authoritativeTmuxList);
     const refreshedTmuxSessions = await Promise.all(liveTmuxSessions.map(async (tmux) => {
         if (!isTermdockManagedTmuxSession(tmux)) {
             return tmux;
@@ -3253,6 +3307,7 @@ async function buildSessionInventory() {
             return tmux;
         }
     }));
+    await observeTmuxServerGeneration(refreshedTmuxSessions, authoritativeTmuxList);
     const liveTmuxByName = new Map(refreshedTmuxSessions.map((session) => [session.name, session]));
     let synchronizedPersistedFields = false;
     globalSessionState = {
@@ -4519,9 +4574,9 @@ async function resolveTmuxPaneProgram(pane, requireArgs = false, refreshTty = fa
     }
     return { command, source: 'tmux-pane', rawArgs: null };
 }
-async function observeProgramNativeIdentity(agent, program) {
+async function observeProgramNativeIdentity(agent, program, override) {
     const fromArgs = agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null;
-    const config = agent ? getPluginNativeIdentityConfig(agent.slug) : undefined;
+    const config = agent ? override ?? getPluginNativeIdentityConfig(agent.slug) : undefined;
     if (config && program?.processPid) {
         const proof = await readNativeProcessIdentity(program.processPid, config, program.processComm, program.rawArgs ?? undefined);
         if (proof.outcome === 'ambiguous' || proof.outcome === 'process_changed' || proof.outcome === 'unconfirmed')
@@ -4533,7 +4588,11 @@ async function observeProgramNativeIdentity(agent, program) {
                 return { nativeId: null, source: null, failure: 'NATIVE_SESSION_IDENTITY_CONFLICT' };
             return { nativeId: proof.nativeId, source: 'linux-flock-owner', failure: null };
         }
+        if (override)
+            return { nativeId: null, source: null, failure: 'NATIVE_SESSION_OWNERSHIP_UNCONFIRMED' };
     }
+    if (override && agent)
+        return { nativeId: null, source: null, failure: 'NATIVE_SESSION_OWNERSHIP_UNCONFIRMED' };
     return { nativeId: fromArgs, source: fromArgs ? 'argv' : null, failure: null };
 }
 /**

package/dist/server/utils/tmuxRecovery.js

@@ -20,25 +20,32 @@ export function detectTmuxRecoveryIncident(input) {
     // A failed/disabled inventory is an unknown observation, never evidence of loss.
     if (!input.authoritativeTmuxList)
         return input.existingIncident ?? null;
-    if (input.existingIncident)
-        return input.existingIncident;
     const intentionallyDeleting = input.intentionallyDeleting ?? new Set();
     const recoverable = input.candidates.filter((candidate) => candidate.resumable
         && !input.dismissedSessionIds?.has(candidate.sessionId)
+        && !input.restoredSessionIds?.has(candidate.sessionId)
         && !intentionallyDeleting.has(candidate.tmuxSessionName));
     const missing = recoverable.filter((candidate) => !input.liveSessionNames.has(candidate.tmuxSessionName));
-    if (recoverable.length === 0)
-        return null;
-    const knownTmuxCount = input.candidates.filter((candidate) => !intentionallyDeleting.has(candidate.tmuxSessionName)).length;
-    const serverGenerationChanged = input.previousServerPid !== null
-        && input.currentServerPid !== input.previousServerPid;
-    const bulkLoss = knownTmuxCount >= 2
-        && input.liveSessionNames.size === 0
-        && missing.length >= 1;
-    if (!serverGenerationChanged && !bulkLoss && missing.length === 0)
-        return null;
-    const affected = serverGenerationChanged ? recoverable : missing;
-    if (affected.length === 0)
+    const existingIncident = input.existingIncident;
+    if (existingIncident) {
+        const eligibleIds = new Set(recoverable.map(candidate => candidate.sessionId));
+        // A recreated shell still needs recovery. Only a verified running Agent,
+        // removed record or explicit acknowledgement can retire its old entry.
+        const affectedSessionIds = Array.from(new Set([
+            ...existingIncident.affectedSessionIds.filter(id => eligibleIds.has(id)),
+            ...missing.map(candidate => candidate.sessionId),
+        ]));
+        if (affectedSessionIds.length === 0)
+            return null;
+        if (affectedSessionIds.length === existingIncident.affectedSessionIds.length
+            && affectedSessionIds.every((id, index) => id === existingIncident.affectedSessionIds[index])) {
+            return existingIncident;
+        }
+        return { ...existingIncident, affectedSessionIds };
+    }
+    // A PID change is diagnostic context, not proof of session loss or a crash.
+    // Require an actually missing session before creating a recovery incident.
+    if (missing.length === 0)
         return null;
     const now = input.now ?? Date.now();
     return {
@@ -46,7 +53,7 @@ export function detectTmuxRecoveryIncident(input) {
         detectedAt: now,
         previousServerPid: input.previousServerPid,
         currentServerPid: input.currentServerPid,
-        affectedSessionIds: affected.map((candidate) => candidate.sessionId),
+        affectedSessionIds: missing.map((candidate) => candidate.sessionId),
     };
 }
 // A dismissed loss stays acknowledged until that session is observed alive

package/docs/integrations.md

@@ -1354,3 +1354,32 @@ flock-owner 身份独立核验出原 agent slug 与原生 UUID。目标元组会
 fail-closed，旧绑定与原消息保留，`session get` 仍报告身份错误；不会按 tmux 名称、PID
 缓存、cwd、argv 中的 resume 参数或显示名猜测认领。此 capability 不新增权限；仅通过
 `session.read` 认证的所属 principal 可触发其自身记录的对账。
+
+## 1.4.346：启动磁盘重载、原 shell 核验与独立原生目录
+
+最低 CLI / 实际服务均为 **1.4.346**。通过所属 principal 的 `capabilities` 回读：
+
+- `session_launch_reload_fence=true`：服务运行期间的磁盘重载保留当前服务生成的 launch token、已解除的一次性 check 和显式原生目录。读取期间新增的会话不会消失，已删除的会话不会由旧读盘复活；全局状态写入串行，并在执行写入时采集当前快照。服务首次启动仍加载磁盘记录。这修复了磁盘 watch 路径绕过元数据 upsert 保护的缺口，不把每一例历史 `TERMINAL_INPUT_TARGET_CHANGED` 都归因为此。
+- `session_shell_startup_wait=true`：启动前先记录唯一原 pane 身份，再最多等待 5 秒核实该 shell 的前台关系和合格 shell 参数。只观察同一 tmux server/session/pane/PID，采样使用新鲜进程证据；承载改变、pane 不唯一或已有 Agent 时拒绝。不输入探针、不清理画面、不重建承载、不发送额外回车，也不把 shell 核验当成应用 input-ready。
+- `session_profile_native_identity=true`：当前仅 Linux 支持 profile 级只读 writer-lock 目录，覆盖该受管会话的插件缺省目录，不改变共享插件配置。三个字段分别有同名 `_min_version` 字段，值为 `1.4.346`。能力支持不等于 principal 已被授予权限。
+
+本机管理员可在现有完整 policy 的目标 `launchProfiles` 中加：
+
+```json
+"nativeIdentity": {
+  "kind": "linux-flock-owner",
+  "directory": "{cwd}/.agent-home/cli/thread-writer-locks"
+}
+```
+
+目录是示例，必须按实际 Agent 的持锁协议填写。支持管理员指定的绝对目录、`~/` 目录，以及仅以前缀 `{cwd}/` 锚定的模板；模板不允许 `..` 或其它变量，解析后的目录须在 TD 服务用户 home 内。调用现有 `td integration update --file <完整policy.json>`，不增加权限、不重建 principal 或凭据。CLI 在旧服务/非 Linux 服务上拒绝该配置，不能静默忽略。原有不配置此项的 profile 保持插件缺省行为。
+
+wrapper 负责实际设置 Agent 自己的数据目录、准备 hooks/参数，并最终运行真正的 Agent；这个字段只声明 TD 的核验目录，不设置环境、不执行脚本、不创建目录，不自动读取 `TRAECLI_HOME` 等私有变量。TD 仍检查目录与文件权限、进程 starttime、前台关系、实际 FD/inode 和当前内核 flock，要求唯一 native UUID。显式 profile 目录不可证明时不降级到 argv/hook/旧 UUID，多个持锁 UUID 仍拒绝。目录语义纳入恢复配置指纹，保存至启动代次；服务重启、metadata 更新、check 解除不会丢失它。
+
+该配置只用于之后创建的 session；旧 session 保留原 profile 快照，policy update 不迁移旧记录或修改运行 Agent。不要为旧未知结果自动 create 新 ID 或 retry-cold。原 UUID 恢复、重复 owner 保护、关闭仍遵守现有身份/代次/幂等门禁；独立数据目录不构成对同 UID 进程的安全隔离。
+
+启动失败管理员用 `td integration diagnostics <原TD-ID>` 回读；shell 等待失败新增 `shell_check={samples,waited_ms,reason,binding,pgid,tpgid}`，不包含 argv/env/终端正文。`SESSION_TARGET_NOT_SHELL` 表示有限核验未通过，不表示 wrapper 已执行；`paste/submit=not_attempted` 与后续 `runtime_present` 现场回读分开保存。失败不自动再次启动，只有符合原 `session retry-cold` 所有条件才可明确重试。
+
+用 stdin 文件给启动命令附带业务 prompt 是接入方的 bootstrap：TD 不为其中业务副作用提供消息幂等或执行确认；无 TD message 历史也不等于没有业务执行。冷启动与精确 resume 应分开处理，恢复时不得重放初始业务文件。host 收取 final/hook receipt 是 host 侧证据，不伪造成 TD 明确 reply。仍只粘贴一次、等待 50ms、写一次 CR。
+
+回归包含确定性交错的旧读盘覆盖/串行写入/删除不复活、同 pane shell 初始化等待与超时/换 pane/已有 Agent 拒绝、CLI 对旧服务拒绝，以及 Linux 真实 tmux/内核 flock 的独立目录核验。私有 TraeX/DevBox 的启动兼容仍需接入方维护窗实机验证；维护机合成测试不冒充该项通过。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.344",
+  "version": "1.4.346",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.344",
+  "version": "1.4.346",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-ObG1OGq7e7fMFQmYoPxPp3jRodEusYHulVNa5mT1aW8=",
-  "serverBundleHash": "sha256-Ln+odmvyZxmEopnizE6Y2RlGc4cLxM5xteZJrN6nbRY=",
-  "clientBundleHash": "sha256-9mUE4GR3rOA1F3MoVEnmhS4q7PvQbqF2Shdl5wlbbrk=",
+  "serverBundleHash": "sha256-14J5QvRzetON18qbhx5HXdLAx08WrjndjMlOCMpgfOc=",
+  "clientBundleHash": "sha256-kn3Tg+BTj+H4rZe0g9OE5JUEQNsBGiUSGew8Epm5A38=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/dist/client/assets/CollaborationTaskContent-D_5vDZEM.js

@@ -1,2 +0,0 @@
-import{bA as r}from"./app-VY9J50Vn.js";import{b as m}from"./dnd-BCFAPC0L.js";import{b as n}from"./RightSidebar-CdEMgc2G.js";import"./react-XDCjal2T.js";import"./terminal-Dea8wJF3.js";import"./App-7PpqNtmr.js";import"./gestureArbiter-ZMwmrdcg.js";import"./triangle-alert-oEokybAQ.js";import"./referenceLongPress-Bi1LDzVG.js";import"./DiffReview-BshWCx_C.js";import"./sparkles-CzTc2Jfu.js";import"./DiffViewer--QG609jF.js";import"./ChangeWalkthroughPanel-DMX0seQh.js";function g({content:o}){const e=m.useMemo(()=>n(o.split(`
-`),null,null),[o]);return r.jsx("div",{className:"min-w-0 space-y-3 break-words text-sm leading-6 text-foreground [&_h1]:text-lg [&_h2]:text-base [&_h3]:text-sm [&_pre]:max-w-full [&_table]:text-xs",children:e.map((t,i)=>r.jsx("div",{className:"min-w-0",children:typeof t.content=="function"?t.content(null):t.content},i))})}export{g as default};