loadtoagent 1.3.1 → 1.3.3

package/renderer/terminal.js

@@ -633,7 +633,7 @@
   }
 
   const {
-    createXtermHost, fitEntry, ensureSessionTerminal, ensureRemoteTerminal, hideScreens, renderSessions, renderTmuxResources, renderTarget, showSelection, selectSession, selectTmux, selectTmuxById, renderAll, refreshSessions, createTerminal, captureRemote, startCapture, stopCapture, sendCommand, sendSignal, openTmuxModal, closeTmuxModal, refreshSnapshot, attachTmux, manageTmux,
+    createXtermHost, fitEntry, ensureSessionTerminal, ensureRemoteTerminal, hideScreens, linkedAgentSession, isAiTerminalSession, renderSessions, renderTmuxResources, renderTarget, showSelection, selectSession, selectTmux, selectTmuxById, renderAll, refreshSessions, createTerminal, captureRemote, startCapture, stopCapture, sendCommand, sendSignal, openTmuxModal, closeTmuxModal, refreshSnapshot, attachTmux, manageTmux,
   } = window.LoadToAgentTerminalWorkbench({
     $, state, notice, setConnectionState, currentSession, currentTmux, saveCurrentDraft, restoreCurrentDraft,
     renderHistoryPanel, terminalTypeMark, terminalTypeLabel, xtermOptions, preferredWorkspace, firstDistro, guarded,
@@ -678,6 +678,7 @@
       moveSessionByOffset,
       setTerminalFontSize,
       toggleTerminalFocusMode,
+      isAiTerminalSession,
     });
   }
 
@@ -773,6 +774,13 @@
       state.wslDistros = Array.isArray(environments) ? environments : [];
       state.initialized = true;
       configurePlatform();
+      if (!state.resizeObserver && 'ResizeObserver' in window) {
+        state.resizeObserver = new ResizeObserver(() => {
+          const entry = currentSession() ? state.terminals.get(state.selectedId) : state.remoteTerminal;
+          fitEntry(entry, state.selectedId || '');
+        });
+        state.resizeObserver.observe($('#terminalViewport'));
+      }
       syncTerminalViewControls();
       renderAll();
     })().catch(error => {

package/src/contracts.js

@@ -42,15 +42,15 @@
  * @property {TokenUsage} usage
  * @property {Array<Object>} messages
  * @property {Array<Object>} lifecycle
- * @property {Array<{id:string,kind:'shell'|'background',mode:'foreground'|'background',tool:string,runtime:string,label:string,command:string,cwd:string,status:'running'|'completed'|'failed',statusDetail:string,output:string,backgroundId:string,exitCode:number|null,startedAt:string|null,updatedAt:string|null,completedAt:string|null}>} executions Observed shell and background execution units owned by this AI session.
+ * @property {Array<{id:string,kind:'shell'|'background',mode:'foreground'|'background',tool:string,runtime:string,label:string,command:string,cwd:string,status:'running'|'completed'|'failed',statusDetail:string,output:string,backgroundId:string,exitCode:number|null,startedAt:string|null,updatedAt:string|null,completedAt:string|null}>} executions Logged regular and background command runs owned by this AI session.
  * @property {CollaborationSummary|null} collaboration
  * @property {{kind:string,iteration:number,phase?:string}|boolean|null} loop Safe execution-loop metadata; internal goal text is never included.
  * @property {{required:boolean,kind:string,summary:string,requestedAt:string|null,source:string,confidence:string}} attention Actionable reason why the session needs the user.
- * @property {{stage:string,percent:number,completedSteps:number,failedSteps:number,totalSteps:number,currentStep:string,blocker:string,lastActivityAt:string|null,source:string,checkpoints:Array<Object>}} progress Structured progress reconstructed from lifecycle events.
- * @property {{level:string,score:number,signals:Array<Object>,lastActivityAt:string|null,ageSeconds:number|null}} health Stalls, failures, context pressure, and hierarchy anomalies.
+ * @property {{stage:string,percent:number,completedSteps:number,failedSteps:number,totalSteps:number,currentStep:string,blocker:string,lastActivityAt:string|null,source:string,checkpoints:Array<Object>}} progress Recent lifecycle-event completion ratio; it is not whole-plan progress.
+ * @property {{level:string,score:number,signals:Array<Object>,lastActivityAt:string|null,ageSeconds:number|null}} health Detected status signals. The legacy score is internal and is not presented as a validated health metric.
  * @property {{managed:boolean,respond:boolean,approve:boolean,deny:boolean,sendInstruction:boolean,stop:boolean,pause:boolean,resume:boolean,retry:boolean,reassign:boolean,openOrigin:boolean}} controlCapabilities Safe provider-aware actions available for this session.
- * @property {{confidence:string,status:string,hierarchy:string,completion:string,sources:Array<string>}} evidence Observation provenance and confidence.
- * @property {{status:string,summary:string,verified:boolean,verification:string,completedAt:string|null,artifacts:Array<Object>,checks:Array<Object>}} outcome Completion summary, artifacts, and verification evidence.
+ * @property {{confidence:string,status:string,hierarchy:string,completion:string,sources:Array<string>}} evidence Confirmation method for status, hierarchy, and completion signals; not result-quality confidence.
+ * @property {{status:string,summary:string,verified:boolean,verification:string,completedAt:string|null,artifacts:Array<Object>,checks:Array<Object>}} outcome Completion summary, log-derived artifact candidates and test records, plus whether a completion signal was received.
  */
 
 /**

package/src/ipc/registerTerminalIpc.js

@@ -19,25 +19,17 @@ function registerTerminalIpc({ ipcMain, requireTrustedSender, trustedSender, man
     if (options && options.type === 'agent' && !isProviderVisible(options.provider)) throw new Error('설정에서 숨긴 AI는 실행할 수 없습니다.');
     return requireManager(manager).create(options || {});
   });
-  ipcMain.on('terminals:write', (event, id, data) => {
-    if (!trustedSender(event) || !manager()) return;
-    try {
-      Promise.resolve(manager().write(id, data)).catch(error => sendError({ id: String(id || ''), message: error.message }));
-    } catch (error) {
-      sendError({ id: String(id || ''), message: error.message });
-    }
+  ipcMain.handle('terminals:write', (event, id, data) => {
+    requireTrustedSender(event);
+    return requireManager(manager).write(id, data);
   });
   ipcMain.handle('terminals:command', (event, id, command) => {
     requireTrustedSender(event);
     return requireManager(manager).command(id, command);
   });
-  ipcMain.on('terminals:resize', (event, id, cols, rows) => {
-    if (!trustedSender(event) || !manager()) return;
-    try {
-      Promise.resolve(manager().resize(id, cols, rows)).catch(error => sendError({ id: String(id || ''), message: error.message }));
-    } catch (error) {
-      sendError({ id: String(id || ''), message: error.message });
-    }
+  ipcMain.handle('terminals:resize', (event, id, cols, rows) => {
+    requireTrustedSender(event);
+    return requireManager(manager).resize(id, cols, rows);
   });
   for (const operation of ['signal', 'restart', 'close']) {
     ipcMain.handle(`terminals:${operation}`, (event, ...args) => {

package/src/sessionIntelligence.js

@@ -6,7 +6,10 @@ const FAILURE_PATTERN = /(?:error|failed|failure|fatal|exception|오류|실패)/
 const PERMISSION_PATTERN = /(?:permission|approve|approval|권한|승인)/i;
 const DECISION_PATTERN = /(?:choose|select|decision|선택|결정|골라)/i;
 const INPUT_PATTERN = /(?:input|reply|answer|confirm|provide|입력|답변|확인|알려|제공)/i;
-const TEST_PATTERN = /(?:test|spec|검증|테스트)/i;
+const TEST_PATTERN = /(?:^|[^A-Za-z0-9])(?:tests?|testing|specs?|pytest|vitest|jest|mocha)(?=$|[^A-Za-z0-9])|검증|테스트/i;
+const FAILED_CHECK_STATUSES = new Set(['failed', 'failure', 'error', 'errored']);
+const RUNNING_CHECK_STATUSES = new Set(['running', 'pending', 'started', 'starting', 'in-progress', 'in_progress']);
+const PASSED_CHECK_STATUSES = new Set(['passed', 'completed', 'complete', 'done', 'success', 'succeeded']);
 
 function text(value, limit = 1200) {
   const output = String(value == null ? '' : value).replace(/\s+/g, ' ').trim();
@@ -33,6 +36,14 @@ function latestMeaningfulText(session) {
   return text((preferred || fallback || {}).text || session.statusDetail || session.result || '', 360);
 }
 
+function checkStatus(value) {
+  const status = String(value || '').trim().toLowerCase();
+  if (FAILED_CHECK_STATUSES.has(status)) return 'failed';
+  if (RUNNING_CHECK_STATUSES.has(status)) return 'running';
+  if (PASSED_CHECK_STATUSES.has(status)) return 'passed';
+  return 'unknown';
+}
+
 function controlCapabilities(session) {
   const live = LIVE_STATUSES.has(session.status);
   const managed = Boolean(session.runId);
@@ -129,7 +140,10 @@ function extractArtifacts(session) {
   const filePattern = /(?:[A-Za-z]:\\|\/)?(?:[\w.@-]+[\\/])+[\w.@()+-]+\.[A-Za-z0-9]{1,12}/g;
   for (const match of body.match(filePattern) || []) add(TEST_PATTERN.test(match) ? 'test' : 'file', match, false);
   if (/(?:commit|커밋)/i.test(body)) {
-    for (const match of body.match(/\b[0-9a-f]{7,40}\b/gi) || []) add('commit', match, true);
+    // A hash mentioned in a log is only a candidate reference. Confirming that
+    // the commit exists belongs to repository verification, which this view
+    // intentionally does not perform.
+    for (const match of body.match(/\b[0-9a-f]{7,40}\b/gi) || []) add('commit', match, false);
   }
   return artifacts;
 }
@@ -141,7 +155,7 @@ function outcomeFor(session, evidence) {
     .slice(-12)
     .map(row => ({
       label: text(row.label || row.detail || 'Test', 180),
-      status: row.status === 'failed' ? 'failed' : row.status === 'running' ? 'running' : 'passed',
+      status: checkStatus(row.status),
       timestamp: row.completedAt || row.timestamp || null,
     }));
   const latestAssistant = [...(session.messages || [])].reverse().find(row => row && row.role === 'assistant' && text(row.text));
@@ -209,7 +223,7 @@ function healthFor(session, sessions, attention, progress, evidence, nowValue) {
   const rank = { info: 1, warning: 2, critical: 3 };
   const max = signals.reduce((value, signal) => Math.max(value, rank[signal.severity] || 0), 0);
   return {
-    level: max >= 3 ? 'critical' : max === 2 ? 'warning' : attention.required ? 'attention' : max === 1 ? 'unknown' : 'healthy',
+    level: max >= 3 ? 'critical' : max === 2 ? 'warning' : max === 1 ? 'unknown' : 'healthy',
     score: Math.max(0, 100 - signals.reduce((sum, signal) => sum + (signal.severity === 'critical' ? 35 : signal.severity === 'warning' ? 18 : 5), 0)),
     signals,
     lastActivityAt: progress.lastActivityAt,

package/src/terminalHost.js

@@ -43,9 +43,15 @@ class TerminalHostServer {
     this.server = null;
     this.clients = new Set();
     this.shutdownTimer = null;
+    this.idleShutdownMs = Number.isFinite(Number(options.idleShutdownMs))
+      ? Math.max(0, Number(options.idleShutdownMs))
+      : 1_500;
     this.onShutdown = typeof options.onShutdown === 'function' ? options.onShutdown : () => {};
     this.onManagerData = payload => this.broadcast({ type: 'event', event: 'data', payload });
-    this.onManagerState = payload => this.broadcast({ type: 'event', event: 'state', payload });
+    this.onManagerState = payload => {
+      this.broadcast({ type: 'event', event: 'state', payload });
+      this.scheduleShutdownIfIdle();
+    };
   }
 
   info() {
@@ -79,6 +85,7 @@ class TerminalHostServer {
           safeWriteJson(this.discoveryFile, this.info());
           this.manager.on('data', this.onManagerData);
           this.manager.on('state', this.onManagerState);
+          this.scheduleShutdownIfIdle();
           resolve(this.info());
         } catch (error) {
           fail(error);
@@ -88,6 +95,7 @@ class TerminalHostServer {
   }
 
   accept(socket) {
+    this.cancelIdleShutdown();
     socket.setNoDelay(true);
     const client = {
       socket,
@@ -139,22 +147,12 @@ class TerminalHostServer {
       client.authenticated = true;
       clearTimeout(client.authTimer);
       client.authTimer = null;
-      if (this.shutdownTimer) {
-        clearTimeout(this.shutdownTimer);
-        this.shutdownTimer = null;
-      }
+      this.cancelIdleShutdown();
       sendFrame(client.socket, { type: 'ready', sessions: this.manager.list() });
       return;
     }
     if (message.type === 'control' && message.operation === 'shutdown-if-idle') {
-      if (activeSessions(this.manager).length === 0 && !this.shutdownTimer) {
-        this.shutdownTimer = setTimeout(() => {
-          this.shutdownTimer = null;
-          const connectedClients = [...this.clients].filter(entry => entry.authenticated && !entry.socket.destroyed);
-          if (activeSessions(this.manager).length === 0 && connectedClients.length === 0) this.onShutdown();
-        }, 1_500);
-        if (typeof this.shutdownTimer.unref === 'function') this.shutdownTimer.unref();
-      }
+      this.scheduleShutdownIfIdle();
       return;
     }
     if (message.type !== 'request' || !HOST_OPERATIONS.has(message.operation)) {
@@ -175,6 +173,28 @@ class TerminalHostServer {
   detach(client) {
     if (client.authTimer) clearTimeout(client.authTimer);
     this.clients.delete(client);
+    this.scheduleShutdownIfIdle();
+  }
+
+  cancelIdleShutdown() {
+    if (!this.shutdownTimer) return;
+    clearTimeout(this.shutdownTimer);
+    this.shutdownTimer = null;
+  }
+
+  scheduleShutdownIfIdle() {
+    const connectedClients = [...this.clients].filter(entry => entry.authenticated && !entry.socket.destroyed);
+    if (activeSessions(this.manager).length > 0 || connectedClients.length > 0) {
+      this.cancelIdleShutdown();
+      return;
+    }
+    if (this.shutdownTimer) return;
+    this.shutdownTimer = setTimeout(() => {
+      this.shutdownTimer = null;
+      const activeClients = [...this.clients].filter(entry => entry.authenticated && !entry.socket.destroyed);
+      if (activeSessions(this.manager).length === 0 && activeClients.length === 0) this.onShutdown();
+    }, this.idleShutdownMs);
+    if (typeof this.shutdownTimer.unref === 'function') this.shutdownTimer.unref();
   }
 
   dispose() {
@@ -217,6 +237,26 @@ function launchTerminalHost(options = {}) {
   return child.pid;
 }
 
+function resolveTerminalHostExecutable(options = {}) {
+  const platform = options.platform || process.platform;
+  const executable = String(options.executable || process.execPath);
+  if (platform !== 'darwin' || !options.isPackaged) return executable;
+  const targetPath = path.posix;
+  const resolvedExecutable = targetPath.resolve(executable);
+  const productName = targetPath.basename(resolvedExecutable);
+  const helper = targetPath.resolve(
+    targetPath.dirname(resolvedExecutable),
+    '..',
+    'Frameworks',
+    `${productName} Helper.app`,
+    'Contents',
+    'MacOS',
+    `${productName} Helper`,
+  );
+  const fileSystem = options.fileSystem || fs;
+  return fileSystem.existsSync(helper) ? helper : executable;
+}
+
 class TerminalHostClient extends EventEmitter {
   constructor(options = {}) {
     super();
@@ -231,16 +271,31 @@ class TerminalHostClient extends EventEmitter {
     this.sequence = 0;
     this.pending = new Map();
     this.handshake = null;
+    this.connectPromise = null;
+    this.connectGeneration = 0;
   }
 
-  async connect() {
+  connect() {
+    if (this.connected && this.socket && !this.socket.destroyed) return Promise.resolve(this);
+    if (this.connectPromise) return this.connectPromise;
     this.disposed = false;
+    const generation = ++this.connectGeneration;
+    const connecting = this.connectLoop(generation);
+    const tracked = connecting.finally(() => {
+      if (this.connectPromise === tracked) this.connectPromise = null;
+    });
+    this.connectPromise = tracked;
+    return this.connectPromise;
+  }
+
+  async connectLoop(generation) {
     const deadline = Date.now() + this.connectTimeoutMs;
     let launched = false;
     let lastError = null;
-    while (Date.now() < deadline) {
+    while (!this.disposed && generation === this.connectGeneration && Date.now() < deadline) {
       try {
         await this.connectExisting();
+        if (this.disposed || generation !== this.connectGeneration) throw new Error('터미널 호스트 재연결이 취소되었습니다.');
         return this;
       } catch (error) {
         lastError = error;
@@ -253,6 +308,7 @@ class TerminalHostClient extends EventEmitter {
       }
       await new Promise(resolve => setTimeout(resolve, 120));
     }
+    if (this.disposed || generation !== this.connectGeneration) throw new Error('터미널 호스트 재연결이 취소되었습니다.');
     throw new Error(`터미널 호스트에 연결하지 못했습니다: ${lastError?.message || '시간 초과'}`);
   }
 
@@ -272,15 +328,19 @@ class TerminalHostClient extends EventEmitter {
       };
       socket.setNoDelay(true);
       socket.on('connect', () => sendFrame(socket, { type: 'authenticate', token: discovery.token }));
-      socket.on('data', chunk => this.consume(chunk));
-      socket.on('error', error => {
-        if (this.handshake) this.handshake.reject(error);
-      });
-      socket.on('close', () => this.handleDisconnect());
+      socket.on('data', chunk => this.consume(chunk, socket));
+      socket.on('error', error => this.handleSocketError(socket, error));
+      socket.on('close', () => this.handleDisconnect(socket));
     });
   }
 
-  consume(chunk) {
+  handleSocketError(socket, error) {
+    if (socket && socket !== this.socket) return;
+    if (this.handshake) this.handshake.reject(error);
+  }
+
+  consume(chunk, socket = this.socket) {
+    if (socket && socket !== this.socket) return;
     this.buffer += chunk.toString('utf8');
     if (this.buffer.length > MAX_FRAME_CHARS) {
       this.socket?.destroy(new Error('터미널 호스트 응답이 너무 큽니다.'));
@@ -313,7 +373,8 @@ class TerminalHostClient extends EventEmitter {
     }
   }
 
-  handleDisconnect() {
+  handleDisconnect(socket = this.socket) {
+    if (socket && socket !== this.socket) return;
     const wasConnected = this.connected;
     this.connected = false;
     if (this.handshake) this.handshake.reject(new Error('터미널 호스트 연결이 닫혔습니다.'));
@@ -323,19 +384,30 @@ class TerminalHostClient extends EventEmitter {
     }
     this.pending.clear();
     this.socket = null;
-    if (wasConnected && !this.disposed) this.emit('disconnect');
+    if (wasConnected && !this.disposed) {
+      this.emit('disconnect');
+      this.connect()
+        .then(() => this.emit('reconnect', { sessions: this.list() }))
+        .catch(error => {
+          if (!this.disposed) this.emit('reconnect-error', error);
+        });
+    }
   }
 
   resetSocket() {
-    if (this.socket) this.socket.destroy();
+    const socket = this.socket;
     this.socket = null;
     this.connected = false;
     this.buffer = '';
+    if (socket) socket.destroy();
   }
 
-  request(operation, ...args) {
+  async request(operation, ...args) {
+    if (!this.connected || !this.socket || this.socket.destroyed) {
+      await this.connect();
+    }
     if (!this.connected || !this.socket || this.socket.destroyed) {
-      return Promise.reject(new Error('터미널 호스트에 연결되어 있지 않습니다.'));
+      throw new Error('터미널 호스트에 연결되어 있지 않습니다.');
     }
     const requestId = String(++this.sequence);
     return new Promise((resolve, reject) => {
@@ -360,6 +432,7 @@ class TerminalHostClient extends EventEmitter {
 
   dispose({ shutdownIfIdle = false } = {}) {
     this.disposed = true;
+    this.connectGeneration += 1;
     if (this.socket && !this.socket.destroyed) {
       if (shutdownIfIdle) sendFrame(this.socket, { type: 'control', operation: 'shutdown-if-idle' });
       this.socket.end();
@@ -378,4 +451,5 @@ module.exports = {
   TERMINAL_HOST_PROTOCOL,
   readHostDiscovery,
   launchTerminalHost,
+  resolveTerminalHostExecutable,
 };

package/src/terminalHostDaemon.js

@@ -23,6 +23,7 @@ function parseConfig(argv = process.argv.slice(2)) {
 async function run(config = parseConfig()) {
   process.title = 'LoadToAgent Terminal Host';
   const manager = new TerminalManager({ storeFile: config.storeFile });
+  manager.recoverPersistedSessions();
   let stopping = false;
   let host = null;
   let bridge = null;

package/src/terminalManager.js

@@ -208,6 +208,8 @@ function publicSession(session, includeReplay = false) {
     provider: session.options.provider,
     bridgeId: session.options.bridgeId,
     background: session.options.type === 'agent',
+    recoveredAfterHostRestart: Boolean(session.recoveredAfterHostRestart),
+    recoverySkippedReason: session.recoverySkippedReason || '',
     pid: session.pid,
     status: session.status,
     createdAt: session.createdAt,
@@ -261,6 +263,14 @@ function persistedSession(session) {
   };
 }
 
+function hasSafeAgentResume(options = {}) {
+  if (options.type !== 'agent') return true;
+  const args = Array.isArray(options.args) ? options.args.map(value => String(value || '')) : [];
+  if (options.provider === 'codex') return args[0] === 'resume' && Boolean(args[1]);
+  const resumeIndex = args.indexOf('--resume');
+  return resumeIndex >= 0 && Boolean(args[resumeIndex + 1]);
+}
+
 class TerminalManager extends EventEmitter {
   constructor(options = {}) {
     super();
@@ -316,6 +326,9 @@ class TerminalManager extends EventEmitter {
           replay: String(value.replay || '').slice(-MAX_REPLAY_CHARS),
           process: null,
           generation: 0,
+          recoveryPending: value.status === 'running' || value.status === 'starting',
+          recoveredAfterHostRestart: false,
+          recoverySkippedReason: '',
         });
       }
     } catch (error) {
@@ -358,6 +371,35 @@ class TerminalManager extends EventEmitter {
     return this.ptyModule;
   }
 
+  recoverPersistedSessions() {
+    const recovered = [];
+    for (const session of this.sessions.values()) {
+      if (!session.recoveryPending) continue;
+      session.recoveryPending = false;
+      if (!hasSafeAgentResume(session.options)) {
+        session.status = 'exited';
+        session.pid = null;
+        session.recoveredAfterHostRestart = false;
+        session.recoverySkippedReason = 'unsafe-agent-restart';
+        const skippedMessage = '\r\n[LoadToAgent] 이 터미널은 재개할 기존 AI 세션 ID가 없어, 새 AI 대화를 만들 수 있어 자동 재개하지 않았습니다.\r\n';
+        session.replay = `${session.replay}${skippedMessage}`.slice(-MAX_REPLAY_CHARS);
+        continue;
+      }
+      session.recoveredAfterHostRestart = true;
+      session.recoverySkippedReason = '';
+      const message = '\r\n[LoadToAgent] 터미널 호스트 중단 뒤 새 프로세스로 복구했습니다. 이전 셸의 메모리 상태는 이어지지 않습니다.\r\n';
+      session.replay = `${session.replay}${message}`.slice(-MAX_REPLAY_CHARS);
+      try {
+        this.spawn(session);
+      } catch (_recoveryFailed) {
+        session.recoveredAfterHostRestart = false;
+      }
+      recovered.push(publicSession(session, true));
+    }
+    this.persistNow();
+    return recovered;
+  }
+
   create(rawOptions = {}) {
     if (this.sessions.size >= MAX_SESSIONS) throw new Error(`동시에 열 수 있는 터미널은 최대 ${MAX_SESSIONS}개입니다.`);
     const options = normalizeLaunchOptions(rawOptions, this.platform);
@@ -381,6 +423,9 @@ class TerminalManager extends EventEmitter {
       replay: '',
       process: null,
       generation: 0,
+      recoveryPending: false,
+      recoveredAfterHostRestart: false,
+      recoverySkippedReason: '',
     };
     this.sessions.set(id, session);
     try {
@@ -435,15 +480,18 @@ class TerminalManager extends EventEmitter {
         processHandle.__loadtoagentExited = true;
         if (session.generation !== generation) return;
         session.process = null;
+        session.pid = null;
         session.status = 'exited';
         session.exitCode = Number.isFinite(event.exitCode) ? event.exitCode : null;
         session.signal = Number.isFinite(event.signal) ? event.signal : null;
         session.updatedAt = new Date().toISOString();
+        this.persistNow();
         this.emitState('updated', session);
       });
       this.emitState('updated', session);
     } catch (error) {
       session.process = null;
+      session.pid = null;
       session.status = 'failed';
       session.updatedAt = new Date().toISOString();
       const failureMessage = `\r\n[LoadToAgent] 터미널을 시작하지 못했습니다: ${error.message}\r\n`;
@@ -516,10 +564,12 @@ class TerminalManager extends EventEmitter {
     const session = this.required(id);
     if (session.process) {
       const handle = session.process;
+      const pid = session.pid;
       session.process = null;
       session.generation += 1;
-      this.killTree(handle, session.pid);
+      this.killTree(handle, pid);
     }
+    session.pid = null;
     session.status = 'exited';
     session.updatedAt = new Date().toISOString();
     this.emitState('updated', session);
@@ -529,12 +579,16 @@ class TerminalManager extends EventEmitter {
 
   restart(id) {
     const session = this.required(id);
+    session.recoveredAfterHostRestart = false;
+    session.recoverySkippedReason = '';
     if (session.process) {
       const handle = session.process;
+      const pid = session.pid;
       session.process = null;
       session.generation += 1;
-      this.killTree(handle, session.pid);
+      this.killTree(handle, pid);
     }
+    session.pid = null;
     session.replay = '';
     this.spawn(session);
     return publicSession(session, true);
@@ -544,10 +598,12 @@ class TerminalManager extends EventEmitter {
     const session = this.required(id);
     if (session.process) {
       const handle = session.process;
+      const pid = session.pid;
       session.process = null;
       session.generation += 1;
-      this.killTree(handle, session.pid);
+      this.killTree(handle, pid);
     }
+    session.pid = null;
     session.status = 'exited';
     session.updatedAt = new Date().toISOString();
     this.sessions.delete(session.id);
@@ -560,13 +616,14 @@ class TerminalManager extends EventEmitter {
     if (preserveSessions) {
       const now = new Date().toISOString();
       for (const session of this.sessions.values()) {
+        const shouldRecover = session.status === 'running' || session.status === 'starting';
         if (session.process) {
           const handle = session.process;
           session.process = null;
           session.generation += 1;
           this.killTree(handle, session.pid);
         }
-        if (session.status === 'running' || session.status === 'starting') session.status = 'exited';
+        if (shouldRecover) session.status = 'running';
         session.pid = null;
         session.updatedAt = now;
       }