loadtoagent 1.3.10 → 1.3.12

package/README.ko.md

@@ -70,7 +70,7 @@ LoadToAgent는 시작할 때 현재 패키지 버전과 GitHub의 최신 정식
 - macOS 또는 Windows
 - npm으로 설치할 때만 Node.js 18 이상
 - Claude Code, Codex CLI, Gemini CLI, Grok CLI 중 하나 이상 설치 및 로그인
-- tmux 터미널 관리를 사용할 때만 tmux 필요
+- macOS의 지속형 AI 세션 또는 Windows WSL 관리형 세션에는 tmux 필요. Windows 네이티브 AI 세션과 일반 명령창은 기존 직접 PTY 방식을 사용합니다.
 
 ## 처음 10분 사용법
 
@@ -130,9 +130,11 @@ loadtoagent run grok
 loadtoagent run claude -- --model claude-sonnet-4-6
 ```
 
-이제 외부 터미널과 LoadToAgent 대시보드가 같은 LoadToAgent 전용 PTY를 조작합니다. AI 카드에서 `터미널에서 열기`를 누르면 새 셸을 만들지 않고 정확히 연결된 기존 터미널을 열며, 왼쪽에는 해당 세션의 이전 대화가 계속 표시됩니다. 터미널 탭을 바꿔도 PTY 출력은 지워지지 않고, 최신 대화 기록도 자동으로 갱신됩니다. 다른 곳에서 임의로 시작한 세션은 계속 볼 수 있지만, 원래 앱이 지원하는 연결 방식이 없으면 보기 전용으로 유지됩니다.
+이제 외부 터미널과 LoadToAgent 대시보드가 같은 LoadToAgent 전용 세션을 조작합니다. AI 카드에서 `터미널에서 열기`를 누르면 새 셸을 만들지 않고 정확히 연결된 기존 터미널을 열며, 왼쪽에는 해당 세션의 이전 대화가 계속 표시됩니다. 터미널 탭을 바꿔도 출력은 지워지지 않고, 최신 대화 기록도 자동으로 갱신됩니다. 다른 곳에서 임의로 시작한 세션은 계속 볼 수 있지만, 원래 앱이 지원하는 연결 방식이 없으면 보기 전용으로 유지됩니다.
 
-LoadToAgent가 연 터미널은 실행 중·유휴·자연 종료·시작 실패 등 상태와 관계없이 사용자가 `세션 종료`를 누를 때까지 세션 터미널 목록과 출력이 유지됩니다. 실행 중인 터미널이 하나라도 있을 때 창의 `X`를 누르면 시스템 트레이로 숨습니다. 트레이에서 `프로그램 끝내기`를 선택해 대시보드를 완전히 종료해도, 별도의 인증된 로컬 터미널 호스트가 살아 있는 PTY를 계속 유지합니다. 다음 실행에서는 같은 세션 ID·프로세스·출력에 다시 연결됩니다. 사용자가 `세션 종료`를 누르거나 터미널이 자연 종료되거나 운영체제 세션·터미널 호스트 자체가 끝날 때만 실행 중인 터미널이 종료됩니다.
+macOS와 WSL의 지속형 AI 터미널은 개인 tmux와 분리된 `tmux -L loadtoagent` 서버에서 실행됩니다. `터미널 화면 닫기`는 attach 화면만 분리하고 AI 작업은 백그라운드에서 계속합니다. 목록의 `기존 작업 다시 연결`은 새 AI 대화를 만들지 않고 같은 tmux 세션과 LoadToAgent 세션 ID에 다시 붙습니다. `AI 세션 종료`는 실제 tmux 작업을 끝내되 확인할 수 있도록 기록을 남기며, 중지된 기록은 별도로 제거할 수 있습니다.
+
+대시보드나 터미널 호스트가 예기치 않게 끝나도 tmux 작업이 살아 있으면 다음 실행에서 같은 세션으로 복구합니다. 저장된 tmux가 사라졌다면 중복 AI 대화를 자동 생성하지 않고 `작업 중지됨`으로 표시합니다. Windows 네이티브 AI 세션과 일반 명령창은 기존 직접 PTY/터미널 호스트 방식을 유지합니다. 두 방식 모두 실행 중·분리됨·자연 종료·시작 실패 기록은 사용자가 명시적으로 제거할 때까지 세션 터미널 목록에 남습니다.
 
 ## 로컬 퍼스트와 보안
 
@@ -156,6 +158,7 @@ npm test
 
 ```bash
 npm run test:terminal
+npm run test:terminal:managed
 npm run test:bridge
 npm run test:tmux -- macOS
 npm run test:visual

package/README.md

@@ -70,7 +70,7 @@ On startup, LoadToAgent compares its package version with the newest stable GitH
 - macOS or Windows
 - Node.js 18 or newer only when installing through npm
 - At least one installed and authenticated CLI: Claude Code, Codex CLI, Gemini CLI, or Grok CLI
-- tmux only if you want the optional tmux workspace map
+- tmux for persistent AI sessions on macOS or managed WSL sessions on Windows. Native Windows AI sessions and ordinary shells keep using the direct PTY backend.
 
 ## Your first 10 minutes
 
@@ -128,9 +128,11 @@ Arguments after `--` are passed to the provider CLI:
 loadtoagent run claude -- --model claude-sonnet-4-6
 ```
 
-The external terminal and LoadToAgent dashboard control the same LoadToAgent-owned PTY. Opening a terminal from an AI card reuses the exact connected terminal instead of creating a new shell, keeps its PTY output intact across UI navigation, and shows that session's prior conversation in a live side rail. Sessions started arbitrarily elsewhere remain visible but read-only unless the original app exposes a supported handoff.
+The external terminal and LoadToAgent dashboard control the same LoadToAgent-owned session. Opening a terminal from an AI card reuses the exact connected terminal instead of creating a new shell, keeps its output intact across UI navigation, and shows that session's prior conversation in a live side rail. Sessions started arbitrarily elsewhere remain visible but read-only unless the original app exposes a supported handoff.
 
-A terminal opened by LoadToAgent remains in the session-terminal list, with its output intact, whether it is running, idle, naturally exited, or failed to start. When any terminal is active, closing the window with `X` hides LoadToAgent in the system tray. An explicit `Quit app` closes the dashboard while a separate authenticated local terminal host keeps live PTYs running; the next launch reconnects to the same session ID, process, and output. A live terminal ends only when you choose `Close session`, the terminal exits naturally, or the operating-system session/terminal host itself stops.
+Persistent AI terminals on macOS and WSL run on the isolated `tmux -L loadtoagent` server, separate from your personal tmux server. `Close terminal view` detaches only the attached view while the AI keeps working in the background. `Reconnect existing work` attaches to that same tmux session and LoadToAgent session ID without starting another AI conversation. `End AI session` stops the tmux work but keeps its record for inspection; a stopped record can then be removed separately.
+
+If the dashboard or terminal host exits unexpectedly, the next host reconnects to the same session when its tmux work is still alive. If the stored tmux session is gone, LoadToAgent marks the record stopped instead of silently starting a duplicate conversation. Native Windows AI sessions and ordinary shells retain the direct PTY/terminal-host backend. In both backends, running, detached, naturally exited, and failed-start records remain in Session terminal until explicitly removed.
 
 ## Local-first by design
 
@@ -154,6 +156,7 @@ Additional checks and distributable builds:
 
 ```bash
 npm run test:terminal
+npm run test:terminal:managed
 npm run test:bridge
 npm run test:tmux -- macOS
 npm run test:visual

package/README.zh-CN.md

@@ -70,7 +70,7 @@ LoadToAgent 启动时会比较当前包版本与最新的稳定 GitHub Release
 - macOS 或 Windows
 - 仅通过 npm 安装时需要 Node.js 18 或更高版本
 - 至少安装并登录一个 CLI：Claude Code、Codex CLI、Gemini CLI 或 Grok CLI
-- 只有使用 tmux 工作区地图时才需要安装 tmux
+- macOS 持久 AI 会话或 Windows WSL 托管会话需要 tmux。Windows 原生 AI 会话和普通命令行仍使用直接 PTY 后端。
 
 ## 前 10 分钟上手
 
@@ -128,9 +128,11 @@ loadtoagent run grok
 loadtoagent run claude -- --model claude-sonnet-4-6
 ```
 
-外部终端与 LoadToAgent 仪表盘会共同控制同一个 LoadToAgent 专用 PTY。在其他地方启动的现有会话仍然可见，但除非原应用提供受支持的交接方式，否则会保持只读。
+外部终端与 LoadToAgent 仪表盘会共同控制同一个 LoadToAgent 专用会话。在 AI 卡片中打开终端时，会复用准确的现有终端和会话 ID，不会创建新的 Shell；切换页面时输出也会保留。在其他地方启动的现有会话仍然可见，但除非原应用提供受支持的交接方式，否则会保持只读。
 
-LoadToAgent 打开的终端无论处于运行、空闲、自然退出或启动失败状态，都会连同输出保留在会话终端列表中。只要有终端仍在运行，点击窗口的 `X` 就会把 LoadToAgent 隐藏到系统托盘。即使从托盘明确选择“退出应用”来关闭仪表盘，独立且经过认证的本地终端主机仍会继续维护活动 PTY；下次启动会重新连接到相同的会话 ID、进程和输出。只有选择“关闭会话”、终端自然退出，或操作系统会话/终端主机本身停止时，活动终端才会结束。
+macOS 和 WSL 的持久 AI 终端运行在隔离的 `tmux -L loadtoagent` 服务器中，不会混入个人 tmux。`关闭终端视图`只会分离当前 attach 画面，AI 工作仍在后台继续。`重新连接现有工作`会连接到相同的 tmux 会话和 LoadToAgent 会话 ID，不会创建新的 AI 对话。`结束 AI 会话`会停止实际 tmux 工作但保留记录，随后可以单独移除已停止的记录。
+
+即使仪表盘或终端主机意外退出，只要 tmux 工作仍然存在，下次启动就会恢复同一个会话。若保存的 tmux 会话已经消失，LoadToAgent 会将记录标记为已停止，而不会静默创建重复的 AI 对话。Windows 原生 AI 会话和普通命令行继续使用直接 PTY/终端主机方式。运行中、已分离、自然退出或启动失败的记录都会保留到用户明确移除为止。
 
 ## 本地优先与安全
 
@@ -154,6 +156,7 @@ npm test
 
 ```bash
 npm run test:terminal
+npm run test:terminal:managed
 npm run test:bridge
 npm run test:tmux -- macOS
 npm run test:visual

package/bin/loadtoagent.js

@@ -140,7 +140,9 @@ function run(argv = process.argv.slice(2)) {
         process.stdin.on('data', data => writeFrame(socket, { type: 'input', data: Buffer.from(data).toString('base64') }));
         process.stdout.on('resize', sendResize);
       } else if (message.type === 'output') process.stdout.write(Buffer.from(String(message.data || ''), 'base64'));
-      else if (message.type === 'state' && (message.status === 'exited' || message.status === 'failed')) exitCode = Number(message.exitCode || 0);
+      else if (message.type === 'state' && ['detached', 'stopped', 'exited', 'failed'].includes(message.status)) {
+        exitCode = Number(message.exitCode || 0);
+      }
       else if (message.type === 'error') {
         process.stderr.write(`\nLoadToAgent: ${message.message}\n`);
         exitCode = 1;

package/docs/ARCHITECTURE.md

@@ -25,6 +25,13 @@ Recoverable main-process failures go through `src/diagnostics.js`. Expected
 best-effort cleanup is logged with an operation name, while user-visible IPC
 failures are returned to the renderer and shown near the initiating action.
 
+Persistent POSIX and WSL AI terminals use the managed-session contract in
+`docs/MANAGED-TERMINAL-SESSIONS.md`. The PTY is only an attach view over a
+session on the isolated `tmux -L loadtoagent` server. Session metadata persists
+independently, so a host restart reconnects to a live tmux session instead of
+starting a duplicate provider conversation. Native Windows and transient
+commands remain on the direct PTY backend.
+
 Regression tests are registered by feature suites in `scripts/tests/` and run
 through a shared harness. Electron integration scripts cover renderer events,
 responsive layouts, the terminal bridge, and real BrowserWindow interaction.

package/docs/MANAGED-TERMINAL-SESSIONS.md

@@ -0,0 +1,64 @@
+# Managed terminal sessions
+
+LoadToAgent separates an AI task from the terminal view attached to it. On
+macOS, Linux, and Windows WSL, every non-transient AI terminal is created in a
+named session on the isolated `tmux -L loadtoagent` server. The Electron PTY
+attaches to that session; it does not own the AI process.
+
+This boundary is intentionally limited to the Session terminal. The agent map,
+parent/subagent flow, monitoring parsers, and conversation UI continue to use
+their existing data contracts.
+
+## Invariants
+
+- Each managed session persists its backend, socket name, tmux session name,
+  provider arguments, working directory, and stable LoadToAgent session ID.
+- The socket and session names are validated and passed as separate process
+  arguments. Provider commands are not joined into an interpolated shell
+  string.
+- The isolated socket prevents LoadToAgent options and lifecycle commands from
+  modifying the user's default tmux server.
+- `window-size` is set to `largest` so an additional client does not shrink the
+  shared agent workspace unexpectedly.
+- Host recovery may attach only when the persisted tmux session still exists.
+  A missing session becomes `stopped`; recovery must never start a fresh,
+  duplicate AI conversation.
+- Store version 1 sessions migrate to the direct backend. They are not silently
+  converted into new tmux conversations.
+
+## Lifecycle
+
+| State or action | PTY attach view | tmux work | Saved record |
+|---|---|---|---|
+| `running` | Attached | Running | Kept |
+| Close terminal view / `detach` | Closed | Running | Kept as `detached` |
+| `reconnect` | Reattached | Same existing work | Same ID |
+| End AI session / `stop` | Closed | Stopped | Kept as `stopped` |
+| Remove record / `close` | Closed | Stopped | Removed |
+| Host crash | Lost | Unchanged | Reattached if tmux still exists |
+
+An attach process that exits naturally is also checked against tmux. If the
+session still exists, the record becomes `detached`; if the agent and tmux
+session ended, it becomes `stopped`.
+
+## Platform policy
+
+| Environment | Persistent AI terminal | Ordinary or transient terminal |
+|---|---|---|
+| macOS / Linux | Managed tmux | Direct PTY |
+| Windows with a selected WSL distro | Managed tmux inside that distro | Direct PTY where applicable |
+| Native Windows | Direct PTY | Direct PTY |
+
+The native Windows fallback is deliberate because tmux is not a native Windows
+runtime. It preserves existing ConPTY support while WSL receives the managed
+session semantics.
+
+## Verification
+
+`npm test` covers option normalization, store migration, isolated launch
+arguments, detach/reconnect/stop/close semantics, host recovery, natural attach
+exit, IPC, and renderer contracts.
+
+`npm run test:terminal:managed` uses the installed tmux and real Electron
+`node-pty` runtime to verify creation, output, detached background execution,
+same-ID reconnection, `window-size largest`, stopping, and record removal.

package/main.js

@@ -245,7 +245,11 @@ function createWindow() {
 
 function backgroundTerminalSessions() {
   if (!terminalManager) return [];
-  return terminalManager.list().filter(session => !session.transient && (session.status === 'running' || session.status === 'starting'));
+  return terminalManager.list().filter(session => !session.transient && (
+    session.status === 'running'
+    || session.status === 'starting'
+    || session.status === 'detached'
+  ));
 }
 
 function visibleTerminalSessions(sessions) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loadtoagent",
-  "version": "1.3.10",
+  "version": "1.3.12",
   "description": "A local desktop dashboard for Claude, Codex, Gemini, and Grok sessions.",
   "main": "main.js",
   "author": "wincube AX",
@@ -45,6 +45,7 @@
     "test": "node scripts/regression-test.js",
     "test:accuracy": "node scripts/accuracy-evaluation.js",
     "test:terminal": "electron scripts/terminal-integration-test.js",
+    "test:terminal:managed": "electron scripts/managed-tmux-integration-test.js",
     "test:terminal:mac-stress": "node scripts/mac-terminal-stress-check.js",
     "test:terminal-restart": "node scripts/terminal-restart-persistence-check.js",
     "test:bridge": "electron scripts/bridge-integration-test.js",

package/preload.js

@@ -40,6 +40,9 @@ contextBridge.exposeInMainWorld('loadtoagent', {
   terminalResize: (id, cols, rows) => ipcRenderer.invoke('terminals:resize', id, cols, rows),
   terminalSignal: (id, signal) => ipcRenderer.invoke('terminals:signal', id, signal),
   terminalRestart: id => ipcRenderer.invoke('terminals:restart', id),
+  terminalReconnect: id => ipcRenderer.invoke('terminals:reconnect', id),
+  terminalDetach: id => ipcRenderer.invoke('terminals:detach', id),
+  terminalStop: id => ipcRenderer.invoke('terminals:stop', id),
   terminalClose: id => ipcRenderer.invoke('terminals:close', id),
   tmuxSendText: options => ipcRenderer.invoke('tmux:send-text', options),
   tmuxSendKey: options => ipcRenderer.invoke('tmux:send-key', options),

package/renderer/app-agent-actions.js

@@ -164,15 +164,19 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
         };
     const { route, targetSession, targets, available: routeAvailable } = routeContext;
     const mode = routingEnabled && !routeAvailable ? "ended" : agentControlMode(targetSession, targets);
+    const inputMode = options.conversation
+      ? state.agentCommandInputModes.get(session.id) || "conversation"
+      : "terminal";
     const relayed = routingEnabled && route === "parent" && routeAvailable;
     const targetKey = agentCommandTargetKey(session, route);
     const savedTarget = state.agentCommandTargets.get(targetKey) || "";
     const relayTarget = relayed ? targets.find((target) => target.kind === "terminal") || targets[0] || null : null;
+    const automaticTarget = relayTarget || targets.find((item) => item.kind === "terminal") || targets[0] || null;
     const targetId = targets.some((target) => target.id === savedTarget)
       ? savedTarget
       : targets.length === 1
         ? targets[0].id
-        : relayTarget?.id || "";
+        : options.conversation ? automaticTarget?.id || "" : "";
     if (targetId) state.agentCommandTargets.set(targetKey, targetId);
     const target = targets.find((item) => item.id === targetId) || null;
     const draft = state.agentCommandDrafts.get(session.id) || "";
@@ -192,7 +196,7 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
               : mode === "connect"
                 ? t("agent.connect_status")
                 : window.LoadToAgentI18n.t("ui.ended_session");
-    const help = relayed
+    const controlHelp = relayed
       ? t("agent.route_parent_inline_help")
       : mode === "direct"
         ? t("agent.direct_help")
@@ -205,18 +209,13 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
               : mode === "connect"
                 ? t("agent.connect_help", { provider: targetSession.provider })
                 : agentResumeSupport(targetSession).reason || t("agent.resume_method_unknown");
-    const routePicker = routingEnabled
-      ? `<div class="agent-command-route" role="group" aria-label="${esc(t("agent.route_label"))}">
-        <span>${esc(t("agent.route_label"))}</span>
-        <div>${routeContext.options.map(option => `<button type="button" data-agent-command-session="${esc(session.id)}" data-agent-command-route="${esc(option.id)}"
-          aria-pressed="${option.id === route ? "true" : "false"}" ${option.available ? "" : "disabled"}>${esc(option.label)}</button>`).join("")}</div>
-        <small class="${routeAvailable ? "available" : "unavailable"}">${esc(t(routeAvailable
-          ? route === "direct" ? "agent.route_direct_available" : "agent.route_parent_available"
-          : route === "direct" ? "agent.route_direct_unavailable" : "agent.route_parent_unavailable"))}</small>
-      </div>`
-      : "";
+    const help = options.conversation
+      ? inputMode === "terminal"
+        ? t("agent.terminal_input_help", { target: target?.label || providerInfo(targetSession.provider).label })
+        : t("agent.ai_input_help", { provider: providerInfo(session.provider).label })
+      : controlHelp;
     const picker =
-      targets.length > 1 && !relayed
+      targets.length > 1 && !relayed && (!options.conversation || inputMode === "terminal")
         ? `<label class="agent-command-target">
       <span>${esc(t("agent.target_terminal"))}</span>
       <select data-agent-command-target="${esc(targetKey)}">
@@ -226,38 +225,78 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
       </label>`
         : "";
     const actions = relayed
-      ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending ? "agent.sending" : "agent.send_via_parent"))}</button>`
+      ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending
+        ? "agent.sending"
+        : inputMode === "terminal" ? "agent.send_terminal" : "agent.send_via_parent"))}</button>`
       : mode === "direct"
-        ? `<button type="button" data-agent-terminal-open="${esc(session.id)}" ${canSend ? "" : "disabled"}>${esc(t("agent.open_terminal"))}</button>
-      <button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending ? "agent.sending" : "agent.send_now"))}</button>`
+        ? `${options.conversation ? "" : `<button type="button" data-agent-terminal-open="${esc(session.id)}" ${canSend ? "" : "disabled"}>${esc(t("agent.open_terminal"))}</button>`}
+      <button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending
+          ? "agent.sending"
+          : inputMode === "terminal" ? "agent.send_terminal" : options.conversation ? "agent.send_request" : "agent.send_now"))}</button>`
         : mode === "resume"
-          ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending ? "agent.restoring" : "agent.restore_and_send"))}</button>`
+          ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending
+            ? "agent.restoring"
+            : options.conversation && inputMode === "terminal" ? "agent.send_terminal" : "agent.restore_and_send"))}</button>`
           : mode === "handoff"
-            ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending ? "agent.handing_off" : "agent.handoff_and_send"))}</button>`
+            ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending
+              ? "agent.handing_off"
+              : options.conversation && inputMode === "terminal" ? "agent.send_terminal" : "agent.handoff_and_send"))}</button>`
             : mode === "origin-resume"
-              ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending ? "agent.connecting" : "agent.background_and_send"))}</button>`
+              ? `<button type="submit" ${canSend ? "" : "disabled"}>${esc(t(sending
+                ? "agent.connecting"
+                : options.conversation && inputMode === "terminal" ? "agent.send_terminal" : "agent.background_and_send"))}</button>`
               : mode === "connect"
               ? `<button type="button" data-agent-bridge-copy="${esc(targetSession.provider)}">${esc(t("agent.copy_bridge"))}</button>`
                 : "";
     const editable = relayed || ["direct", "resume", "handoff", "origin-resume"].includes(mode);
-    const placeholder = editable ? t(options.conversation ? "agent.conversation_placeholder" : "agent.command_example") : status;
+    const placeholder = editable
+      ? t(options.conversation
+        ? inputMode === "terminal" ? "agent.terminal_placeholder" : "agent.conversation_placeholder"
+        : "agent.command_example")
+      : status;
     const availabilityClass = mode === "direct" ? "connected" : ["resume", "handoff", "origin-resume"].includes(mode) ? "resume-ready" : "unavailable";
-    return `<form class="agent-command-panel ${availabilityClass} control-${mode} ${options.conversation ? "conversation-composer" : ""}"
-      data-agent-command-form="${esc(session.id)}" data-agent-command-route-selected="${esc(route)}" data-agent-command-routing="${options.conversation ? "conversation" : "session"}">
+    const terminalAction = mode === "direct"
+      ? `<button type="button" data-agent-terminal-open="${esc(session.id)}" ${target ? "" : "disabled"}>${esc(t("agent.open_terminal"))}</button>`
+      : ["resume", "handoff", "origin-resume"].includes(mode)
+        ? `<button type="button" data-resume-agent="${esc(session.id)}">${esc(t("agent.reconnect_terminal"))}</button>`
+        : "";
+    const terminalDetail = mode === "direct"
+      ? t("agent.terminal_session_active", { target: target?.label || t("agent.choose_terminal") })
+      : mode === "ended" ? t("agent.terminal_unavailable") : controlHelp;
+    const terminalToggle = options.conversation && inputMode !== "terminal"
+      ? `<button class="conversation-terminal-toggle" type="button" data-agent-command-session="${esc(session.id)}"
+          data-agent-command-input-mode="terminal" aria-expanded="false" ${editable ? "" : "disabled"}>
+          <span aria-hidden="true">›_</span>${esc(t("agent.input_mode_terminal"))}
+        </button>`
+      : "";
+    const terminalExpanded = options.conversation && inputMode === "terminal"
+      ? `<div class="conversation-terminal-expanded ${mode === "direct" ? "connected" : ""}">
+          <button type="button" data-agent-command-session="${esc(session.id)}" data-agent-command-input-mode="conversation">
+            <span aria-hidden="true">←</span>${esc(t("agent.return_to_ai_input"))}
+          </button>
+          <span><b>${esc(t("agent.terminal_direct_input"))}</b><small>${esc(terminalDetail)}</small></span>
+          ${terminalAction}
+        </div>`
+      : "";
+    const form = `<form class="agent-command-panel ${availabilityClass} control-${mode} ${options.conversation ? "conversation-composer" : ""}"
+      data-agent-command-form="${esc(session.id)}" data-agent-command-route-selected="${esc(route)}"
+      data-agent-command-input-mode-selected="${esc(inputMode)}" data-agent-command-routing="${options.conversation ? "conversation" : "session"}">
       <header>
         <span class="agent-command-icon" aria-hidden="true">›_</span>
         <span><b>${esc(t(options.conversation ? "agent.conversation_title" : "agent.command_title"))}</b><small>${esc(status)}</small></span>
         <i class="${mode === "direct" ? "connected" : ""}" aria-hidden="true"></i>
       </header>
-      ${routePicker}
       ${picker}
       <label class="agent-command-input">
         <span class="sr-only">${esc(t("agent.command_sr"))}</span>
         <textarea data-agent-command-draft="${esc(session.id)}" maxlength="8000" rows="${options.conversation ? "2" : "3"}"
           placeholder="${esc(placeholder)}" ${editable ? "" : "disabled"}>${editable ? esc(draft) : ""}</textarea>
       </label>
-      <div class="agent-command-actions"><small aria-live="polite">${esc(help)}</small>${actions}</div>
+      <div class="agent-command-actions"><small aria-live="polite">${esc(help)}</small>${terminalToggle}${actions}</div>
     </form>`;
+    return options.conversation
+      ? `<div class="conversation-composer-shell mode-${esc(inputMode)}">${terminalExpanded}${form}</div>`
+      : form;
   }
 
   function selectedSession() {
@@ -304,8 +343,10 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     if (state.agentCommandSending.has(sessionId)) return;
     const session = snapshotSession(sessionId);
     if (!session || !window.LoadToAgentTerminal) return context.toast(t("agent.latest_not_found"));
-    const conversationSubmission = form?.dataset.agentCommandRouting === "conversation";
-    const routingEnabled = conversationSubmission && Boolean(session.parentId);
+    const drawerSubmission = form?.dataset.agentCommandRouting === "conversation";
+    const inputMode = drawerSubmission ? form?.dataset.agentCommandInputModeSelected || "conversation" : "terminal";
+    const conversationSubmission = drawerSubmission && inputMode === "conversation";
+    const routingEnabled = drawerSubmission && Boolean(session.parentId);
     const requestedRoute = routingEnabled ? form?.dataset.agentCommandRouteSelected || selectedAgentCommandRoute(session) : "direct";
     const routeContext = routingEnabled
       ? routedAgentCommandContext(session, requestedRoute)
@@ -315,7 +356,7 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     if (routingEnabled && !["direct", "resume", "handoff", "origin-resume"].includes(mode)) return context.toast(t("agent.route_unavailable"));
     const input = form.querySelector("[data-agent-command-draft]");
     const command = String((input && input.value) || "").trim();
-    const routedCommand = routingEnabled && routeContext.route === "parent"
+    const routedCommand = conversationSubmission && routingEnabled && routeContext.route === "parent"
       ? t("agent.route_via_parent_prompt", {
           task: session.delegation?.taskName || session.taskName || session.agentName || session.title,
           message: command,
@@ -324,15 +365,17 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     if (mode === "resume" || mode === "handoff" || mode === "origin-resume") {
       if (input) state.agentCommandDrafts.set(sessionId, input.value);
       if (!command) return context.toast(t("agent.enter_command"));
-      if (conversationSubmission) {
+      if (drawerSubmission) {
         state.agentCommandSending.add(sessionId);
-        const pendingMessage = beginConversationMessage(session, command);
+        const pendingMessage = conversationSubmission ? beginConversationMessage(session, command) : null;
         try {
           await window.LoadToAgentTerminal.resumeForAgent(targetSession, routedCommand, true, { focus: false });
           state.agentCommandDrafts.delete(sessionId);
           if (input) input.value = "";
           updateConversationMessage(sessionId, pendingMessage, "awaiting");
-          context.toast(t(routingEnabled && routeContext.route === "parent" ? "agent.command_routed_via_parent" : "agent.command_sent_background"));
+          context.toast(t(routingEnabled && routeContext.route === "parent"
+            ? "agent.command_routed_via_parent"
+            : inputMode === "terminal" ? "agent.terminal_command_sent_background" : "agent.command_sent_background"));
         } catch (error) {
           updateConversationMessage(sessionId, pendingMessage, "failed", errorText(error, "agent.send_failed"));
           context.toast(errorText(error, "agent.send_failed"));
@@ -364,16 +407,18 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
       state.agentCommandDrafts.delete(sessionId);
       if (input) input.value = "";
       updateConversationMessage(sessionId, pendingMessage, "awaiting");
-      context.toast(t(routingEnabled && routeContext.route === "parent" ? "agent.command_routed_via_parent" : "agent.command_sent", { target: target.label }));
+      context.toast(t(routingEnabled && routeContext.route === "parent"
+        ? "agent.command_routed_via_parent"
+        : inputMode === "terminal" ? "agent.terminal_command_sent" : "agent.command_sent", { target: target.label }));
     } catch (error) {
       const latest = snapshotSession(targetSession.id) || targetSession;
       const support = agentResumeSupport(latest);
       const shouldRecover = support.supported
-        && (conversationSubmission || !agentCommandTargets(latest).length);
+        && (drawerSubmission || !agentCommandTargets(latest).length);
       if (shouldRecover) {
         try {
           state.agentCommandDrafts.set(sessionId, command);
-          await window.LoadToAgentTerminal.resumeForAgent(latest, routedCommand, true, { focus: conversationSubmission ? false : true });
+          await window.LoadToAgentTerminal.resumeForAgent(latest, routedCommand, true, { focus: drawerSubmission ? false : true });
           state.agentCommandDrafts.delete(sessionId);
           if (input) input.value = "";
           updateConversationMessage(sessionId, pendingMessage, "awaiting");
@@ -389,10 +434,12 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
       }
     } finally {
       state.agentCommandSending.delete(sessionId);
-      if (conversationSubmission) context.renderDrawer?.();
+      if (drawerSubmission) context.renderDrawer?.();
       if (submit && submit.isConnected) {
         submit.disabled = false;
-        submit.textContent = t(routingEnabled && routeContext.route === "parent" ? "agent.send_via_parent" : "agent.send_now");
+        submit.textContent = t(routingEnabled && routeContext.route === "parent"
+          ? "agent.send_via_parent"
+          : inputMode === "terminal" ? "agent.send_terminal" : drawerSubmission ? "agent.send_request" : "agent.send_now");
       }
     }
   }
@@ -404,6 +451,7 @@ window.LoadToAgentAppFactories.createAgentActions = function createAgentActions(
     const target = chosenAgentCommandTarget(session, routeContext.route);
     if (!target)
       return context.toast(t(routeContext.targets.length ? "agent.select_open_target" : "agent.no_writable_terminal"));
+    if ($("#detailDrawer").classList.contains("open")) context.closeDrawer?.(false);
     selectView(target.kind === "tmux" ? "tmux" : "terminal");
     try {
       await window.LoadToAgentTerminal.openForAgent(routeContext.targetSession, target.id, state.agentCommandDrafts.get(sessionId) || "");

package/renderer/app-dashboard.js

@@ -145,16 +145,53 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     return !isProjectlessSession(session) && projectContainsPath(state.workspace, sessionOriginPath(session));
   }
 
+  function unlinkedLiveTmuxSessions() {
+    const displayedSessionIds = new Set(displaySessions().map((session) => String(session.id || "")));
+    const allSessionsById = new Map((state.snapshot?.sessions || []).map((session) => [String(session.id || ""), session]));
+    const sessions = [];
+    for (const distro of state.snapshot?.tmux?.distros || []) {
+      for (const tmuxSession of distro.sessions || []) {
+        for (const window of tmuxSession.windows || []) {
+          for (const pane of window.panes || []) {
+            if (!pane.agent || pane.dead || !pane.cwd || !isProviderVisible(pane.agent.provider)) continue;
+            const linkedSessionId = String(pane.agent.linkedSessionId || "");
+            const linkedSession = linkedSessionId ? allSessionsById.get(linkedSessionId) : null;
+            if (linkedSessionId && displayedSessionIds.has(linkedSessionId)) continue;
+            // A tmux process can remain alive for days after its linked AI task
+            // becomes idle. Do not promote that stale shell back into the Home
+            // project count merely because the old conversation aged out of the
+            // recent-session list. A still-running linked task remains eligible.
+            if (linkedSession && !isControlRoomSession(linkedSession)) continue;
+            sessions.push({
+              id: `tmux:${pane.id}`,
+              provider: pane.agent.provider,
+              status: "running",
+              originCwd: pane.cwd,
+              cwd: pane.cwd,
+              workspace: tmuxSession.name,
+              title: pane.agent.title || tmuxSession.name,
+            });
+          }
+        }
+      }
+    }
+    return sessions;
+  }
+
   function renderWorkspaces() {
     const rootSessions = displaySessions().filter((session) => !session.parentId);
     const liveRootSessions = rootSessions.filter(isControlRoomSession);
+    const tmuxRootSessions = unlinkedLiveTmuxSessions();
+    const allLiveRootSessions = [...liveRootSessions, ...tmuxRootSessions];
     const projects = observedProjects(rootSessions);
-    const liveProjects = observedProjects(liveRootSessions);
+    const liveProjects = observedProjects(allLiveRootSessions)
+      .filter((project) => Number(project.count || 0) > 0);
     const projectlessCount = rootSessions.filter(isProjectlessSession).length;
     const liveProjectlessCount = liveRootSessions.filter(isProjectlessSession).length;
     const savedWorkspaceExists = state.workspace === "all"
       || (state.workspace === PROJECTLESS_WORKSPACE && projectlessCount > 0)
-      || projects.some((project) => normalizedProjectPath(project.path) === normalizedProjectPath(state.workspace));
+      || projects.some((project) => normalizedProjectPath(project.path) === normalizedProjectPath(state.workspace))
+      || liveProjects.some((project) => normalizedProjectPath(project.path) === normalizedProjectPath(state.workspace));
     if (!savedWorkspaceExists) state.workspace = "all";
     const projectButton = (item, compactClass = "") => `<button type="button" class="workspace-item observed-project ${compactClass} ${Number(item.liveCount || 0) ? "has-live-sessions" : ""} ${state.workspace === item.path ? "selected" : ""}"
       data-workspace="${esc(item.path)}" title="${esc(item.path)}"
@@ -188,7 +225,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     const desktopHtml =
       `<button type="button" class="workspace-item control-room-project-chip ${state.workspace === "all" ? "selected" : ""}"
         data-workspace="all" aria-pressed="${state.workspace === "all" ? "true" : "false"}">
-      <strong>${esc(t("control.all_projects"))}</strong><small>${liveRootSessions.length}</small>
+      <strong>${esc(t("control.all_projects"))}</strong><small>${allLiveRootSessions.length}</small>
       </button>` +
       liveProjects.map((item) => projectButton(item, "control-room-project-chip")).join("") +
       (liveProjectlessCount
@@ -636,6 +673,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     sessionWorkspaceLabel,
     controlRoomProject,
     matchesWorkspaceFilter,
+    unlinkedLiveTmuxSessions,
     renderWorkspaces,
     renderGlobalStats,
     formatBytes,

package/renderer/app-drawer-content.js

@@ -55,8 +55,11 @@ window.LoadToAgentAppFactories.createDrawerContent = function createDrawerConten
     const label = assistant ? options.assistantLabel : options.userLabel;
     const avatar = assistant ? providerInfo(session.provider).mark : "ME";
     const fullTime = new Date(message.timestamp).toLocaleString(uiLocale());
+    const workingIndicator = options.live
+      ? `<span class="chat-working-dots" aria-hidden="true"><i></i><i></i><i></i></span>`
+      : "";
     const answerKind = assistant && options.answerKind
-      ? `<span class="chat-answer-kind${options.live ? " is-live" : ""}">${esc(options.answerKind)}</span>`
+      ? `<span class="chat-answer-kind${options.live ? " is-live" : ""}">${esc(options.answerKind)}${workingIndicator}</span>`
       : "";
     const deliveryStatusKey = {
       sending: "drawer.message_sending",