loadtoagent 1.3.1 → 1.3.2

package/README.ko.md

@@ -70,14 +70,14 @@ LoadToAgent는 시작할 때 현재 패키지 버전과 GitHub의 최신 정식
 - macOS 또는 Windows
 - npm으로 설치할 때만 Node.js 18 이상
 - Claude Code, Codex CLI, Gemini CLI, Grok CLI 중 하나 이상 설치 및 로그인
-- tmux 작업 지도를 사용할 때만 tmux 필요
+- tmux 터미널 관리를 사용할 때만 tmux 필요
 
 ## 처음 10분 사용법
 
 1. **홈**에서 `새 AI 작업`을 누르고 할 일과 작업 폴더를 고릅니다. 설치된 AI가 없으면 화면의 공식 설치 안내를 먼저 따르세요.
 2. **진행 중**에서 초록 상태의 AI를 확인합니다. 도움 AI를 함께 쓰는 작업은 접힌 `상세 흐름 보기`에서 펼칠 수 있습니다.
-3. **내 확인 필요**에 숫자가 생기면 답변이나 선택이 필요한 작업부터 처리합니다.
-4. 작업 카드를 열어 **대화·진행 과정·사용량**을 확인하고, 연결된 작업은 **세션 터미널**에서 이어서 입력합니다.
+3. **확인할 일**에 숫자가 생기면 내 응답이 필요한 작업과 상태 위험 신호를 구분해 확인합니다.
+4. 작업 카드를 열어 **대화·진행 과정·사용량**을 확인하고, 연결된 작업은 **AI 세션 터미널**에서 이어서 입력합니다.
 
 홈의 `10분 시작 가이드`도 같은 네 단계를 직접 눌러 연습하게 해 줍니다. 완료 상태는 이 컴퓨터에 저장되며 언제든 다시 펼칠 수 있습니다.
 
@@ -87,18 +87,20 @@ LoadToAgent는 시작할 때 현재 패키지 버전과 GitHub의 최신 정식
 |---|---|
 | AI 작업 지도 | Claude, Codex, Gemini, Grok별 실시간 작업 |
 | 연결 관계 | 사용자 요청, 선택한 메인 AI, 직접 나눠 맡긴 도움 AI |
-| 실행 단위 | AI가 시작한 포그라운드 셸·백그라운드 셸·백그라운드 작업의 명령, 작업 폴더, 실행 ID와 현재 상태 |
-| 운영 현황·확인함 | 실패·정체·컨텍스트 위험과 승인·결정·입력 요청을 우선순위로 모아 즉시 처리 |
+| 명령·백그라운드 실행 | AI가 시작한 일반 명령과 백그라운드 명령의 내용, 작업 폴더, 실행 ID와 현재 상태 |
+| 응답·상태 확인함 | 최근 24시간 세션에서 내 응답이 필요한 요청과 현재 실행의 실패·지연·일시정지 위험만 확인 |
 | 작업 상세 | 대화, 도구 호출, 진행 과정, 모델, 작업 폴더, 상태 |
-| 관리 요약 | 체크포인트, 관측 신뢰도, 완료 요약, 산출물과 검증 결과, 실행 제어 |
+| 관리 요약 | 최근 실행 이벤트, 상태 정보 확인 수준, 완료 신호, 로그에서 찾은 산출물 후보와 테스트 기록, 실행 제어 |
 | 토큰 | 입력·출력·캐시·추론·전체 사용량과 보고된 컨텍스트 점유율 |
-| 세션 터미널 | 선택한 AI의 이전 대화와 기존 PTY·tmux 화면을 나란히 보며 같은 세션에 이어서 입력 |
-| tmux 작업 | macOS 또는 Windows WSL의 세션 → 창 → 패널 → AI 프로세스 관계 |
+| AI 세션 터미널 | 선택한 AI의 이전 대화와 기존 PTY·tmux 화면을 나란히 보며 같은 세션에 이어서 입력 |
+| tmux 터미널 관리 | macOS 또는 Windows WSL의 tmux 세션 → 창 → 패널 → AI 프로세스 관계 |
 
-스케줄·루프, 세션 터미널, tmux 작업은 왼쪽의 **고급 도구** 아래에 모여 있어 일상적인 관제 흐름을 방해하지 않습니다.
+예약·실행 단계, AI 세션 터미널, tmux 터미널 관리는 왼쪽의 **고급 도구** 아래에 모여 있어 일상적인 관제 흐름을 방해하지 않습니다.
 
 LoadToAgent는 `직접 입력 가능`, `브리지 연결 후 입력 가능`, `원래 앱에서 계속해야 하는 보기 전용`, `종료된 세션`을 구분합니다. 임의의 외부 창에 키 입력을 보내지 않습니다.
 
+홈과 세션 목록은 현재 실행 중이거나 마지막 활동이 24시간 이내인 세션을 표시합니다. **확인할 일**에는 이 최근 세션 중 실제 응답 요청 또는 현재 실행의 실패·지연·일시정지 위험 신호만 포함하며, 정보 확인 수준이 낮다는 이유만으로는 포함하지 않습니다.
+
 ## 연결된 터미널 사용
 
 LoadToAgent 앱을 열어 둔 뒤 인증된 로컬 브리지로 AI CLI를 시작합니다.

package/docs/PROVIDER-CONTRACTS.md

@@ -11,17 +11,19 @@ LoadToAgent는 제공사별 이벤트를 아래 공통 단계로 정규화합니
 제공사별 원본 세션은 화면에 전달되기 전에 다음 관리 정보로 보강됩니다.
 
 - `attention`: 승인·결정·입력·오류·일시정지처럼 사용자 조치가 필요한 이유와 관측 신뢰도
-- `progress`: 현재 단계, 완료율, 최근 체크포인트, 막힘 사유와 마지막 활동 시각
-- `health`: 실패, 정체, 장시간 대기, 컨텍스트 위험, 반복 실패, 고아 에이전트 신호
+- `progress`: 최근 실행 이벤트 중 완료로 기록된 수, 최근 체크포인트, 막힘 사유와 마지막 활동 시각. 화면의 비율은 전체 계획 진척도가 아닙니다.
+- `health`: 실패, 새 활동 없음, 장시간 응답 대기, AI 기억 한도, 반복 실패, 부모 연결 정보 누락 신호
 - `controlCapabilities`: 실제 연결과 관리 실행 상태에 근거한 응답·중지·일시정지·재개·재시도·재배정 가능 여부
-- `evidence`: 상태·계층·완료 판단이 직접 관측인지 추론인지와 근거 출처
-- `outcome`: 완료 요약, 감지된 파일·테스트·커밋, 검증 이벤트와 완료 관측 여부
+- `evidence`: 상태·부모/도움 AI 관계·완료 신호가 직접 확인인지 활동 기록 추정인지와 정보 출처. 확인 수준은 결과 품질의 신뢰도가 아닙니다.
+- `outcome`: 완료 요약, 로그에서 찾은 파일·테스트·커밋 후보, 테스트 관련 로그와 완료 신호 수신 여부. 파일 존재나 결과 정확성을 독립 검증한 값이 아닙니다.
 
 관측 이벤트가 없는 값은 사실로 단정하지 않고 `inferred` 또는 `unverified`로 표시합니다. 시간 기반 건강 신호는 매분 다시 계산됩니다.
 
-## 셸·백그라운드 실행 계약
+화면의 최근 세션 기준은 마지막 활동 후 24시간입니다. 실행 중인 세션은 마지막 활동 시각과 관계없이 계속 표시합니다. `확인할 일`은 이 범위 안의 실제 응답 요청과 현재 실행 위험만 집계하며, 오래된 세션이나 단순한 낮은 확인 수준은 제외합니다.
 
-- 각 AI 세션은 `executions`에 자신이 시작한 셸과 백그라운드 실행을 별도 실행 단위로 보관합니다. 서브에이전트 세션과 섞어 세지 않습니다.
+## 명령·백그라운드 실행 계약
+
+- 각 AI 세션은 `executions`에 자신이 시작한 일반 명령과 백그라운드 명령을 별도 기록으로 보관합니다. 도움 AI 세션과 섞어 세지 않습니다.
 - 공통 필드는 `kind(shell|background)`, `mode(foreground|background)`, `status(running|completed|failed)`, 명령, 작업 폴더, 호출 ID, 시작·갱신·완료 시각입니다.
 - Codex는 `shell_command`, `exec_command`와 `custom_tool_call: exec` 안의 `tools.exec_command(...)`를 인식합니다. 장기 실행이 반환한 cell/session ID는 후속 `wait`·`write_stdin` 호출과 연결합니다.
 - Claude는 `Bash` 계열의 `run_in_background`와 후속 `TaskOutput`·`BashOutput`을 같은 실행으로 연결합니다. Gemini/Grok의 구조화 `tool_use`·`tool_result`에서도 셸 도구를 같은 계약으로 정규화합니다.

package/main.js

@@ -10,7 +10,7 @@ const { execFileSync } = require('child_process');
 const { AgentRunner, probeProviders } = require('./src/agentRunner');
 const { providerList, blankUsage } = require('./src/providerRegistry');
 const { TerminalManager } = require('./src/terminalManager');
-const { TerminalHostClient, launchTerminalHost } = require('./src/terminalHost');
+const { TerminalHostClient, launchTerminalHost, resolveTerminalHostExecutable } = require('./src/terminalHost');
 const { TmuxController } = require('./src/tmuxController');
 const { normalizeWslList } = require('./src/tmuxMonitor');
 const { UpdateManager } = require('./src/updateManager');
@@ -59,6 +59,9 @@ const MAIN_COPY = {
     pickWorkspace: '작업 폴더 선택',
     attentionTitle: '내 확인이 필요합니다',
     attentionBody: '{provider} · {title}',
+    terminalHostReconnecting: '터미널 연결을 자동으로 복구하는 중입니다.',
+    terminalHostReconnected: '터미널 연결을 복구했습니다.',
+    terminalHostReconnectFailed: '터미널 연결을 복구하지 못했습니다: {reason}',
   },
   en: {
     trayTooltip: 'LoadToAgent · {count} background terminals',
@@ -69,6 +72,9 @@ const MAIN_COPY = {
     pickWorkspace: 'Choose workspace',
     attentionTitle: 'Your review is needed',
     attentionBody: '{provider} · {title}',
+    terminalHostReconnecting: 'Restoring the terminal connection automatically.',
+    terminalHostReconnected: 'Terminal connection restored.',
+    terminalHostReconnectFailed: 'Could not restore the terminal connection: {reason}',
   },
   'zh-CN': {
     trayTooltip: 'LoadToAgent · {count} 个后台终端',
@@ -79,6 +85,9 @@ const MAIN_COPY = {
     pickWorkspace: '选择工作文件夹',
     attentionTitle: '需要你的确认',
     attentionBody: '{provider} · {title}',
+    terminalHostReconnecting: '正在自动恢复终端连接。',
+    terminalHostReconnected: '终端连接已恢复。',
+    terminalHostReconnectFailed: '无法恢复终端连接：{reason}',
   },
 };
 let lastSnapshot = {
@@ -388,7 +397,7 @@ async function setupRuntime() {
     : new TerminalHostClient({
       discoveryFile: terminalHostFile,
       spawnHost: () => launchTerminalHost({
-        executable: process.execPath,
+        executable: resolveTerminalHostExecutable({ isPackaged: app.isPackaged }),
         script: path.join(__dirname, 'src', 'terminalHostDaemon.js'),
         storeFile: terminalStoreFile,
         discoveryFile: terminalHostFile,
@@ -426,7 +435,20 @@ async function setupRuntime() {
     if (monitorWorker) monitorWorker.postMessage({ type: 'bridge-presence', bridges: bridgePresence() });
   });
   terminalManager.on('disconnect', () => {
-    sendTerminal('terminals:error', { id: '', message: '터미널 호스트 연결이 끊어졌습니다. 프로그램을 다시 시작하면 실행 중인 세션에 다시 연결합니다.' });
+    sendTerminal('terminals:connection', { state: 'reconnecting', message: mainText('terminalHostReconnecting') });
+  });
+  terminalManager.on('reconnect', payload => {
+    const sessions = visibleTerminalSessions(payload?.sessions || terminalManager.list());
+    sendTerminal('terminals:state', { change: 'reconnected', session: null, sessions });
+    sendTerminal('terminals:connection', { state: 'connected', message: mainText('terminalHostReconnected') });
+    updateBackgroundTrayMenu();
+    if (monitorWorker) monitorWorker.postMessage({ type: 'bridge-presence', bridges: bridgePresence() });
+  });
+  terminalManager.on('reconnect-error', error => {
+    sendTerminal('terminals:connection', {
+      state: 'failed',
+      message: mainText('terminalHostReconnectFailed', { reason: error?.message || String(error) }),
+    });
   });
   await terminalManager.connect();
   availability = probeProviders();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loadtoagent",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "A local desktop dashboard for Claude, Codex, Gemini, and Grok sessions.",
   "main": "main.js",
   "author": "wincube AX",

package/preload.js

@@ -35,9 +35,9 @@ contextBridge.exposeInMainWorld('loadtoagent', {
   wslDistros: () => ipcRenderer.invoke('wsl:list-distros'),
   terminalGet: id => ipcRenderer.invoke('terminals:get', id),
   terminalCreate: options => ipcRenderer.invoke('terminals:create', options),
-  terminalWrite: (id, data) => ipcRenderer.send('terminals:write', id, data),
+  terminalWrite: (id, data) => ipcRenderer.invoke('terminals:write', id, data),
   terminalCommand: (id, command) => ipcRenderer.invoke('terminals:command', id, command),
-  terminalResize: (id, cols, rows) => ipcRenderer.send('terminals:resize', id, cols, rows),
+  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),
   terminalClose: id => ipcRenderer.invoke('terminals:close', id),
@@ -68,6 +68,11 @@ contextBridge.exposeInMainWorld('loadtoagent', {
     ipcRenderer.on('terminals:error', handler);
     return () => ipcRenderer.removeListener('terminals:error', handler);
   },
+  onTerminalConnection: callback => {
+    const handler = (_event, payload) => callback(payload);
+    ipcRenderer.on('terminals:connection', handler);
+    return () => ipcRenderer.removeListener('terminals:connection', handler);
+  },
   onSnapshot: callback => {
     const handler = (_event, snapshot) => callback(snapshot);
     ipcRenderer.on('agents:snapshot', handler);

package/renderer/app-dashboard.js

@@ -18,6 +18,12 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     isRuntimeLoopSession = () => false,
   } = context;
 
+  function displaySessions() {
+    return visibleSessions().filter((session) => (
+      typeof context.isRecentSession !== "function" || context.isRecentSession(session)
+    ));
+  }
+
   function renderProviderRail() {
     $("#providerRail").innerHTML = visibleProviders()
       .map((provider) => {
@@ -62,7 +68,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     const projects = new Map();
     const saved = state.workspaces.map((item) => ({ ...item, key: normalizedProjectPath(item.path) }));
     saved.forEach((item) => projects.set(item.key, { path: item.path, name: item.name || projectName(item.path), saved: true, count: 0 }));
-    visibleSessions().filter((session) => !session.parentId && !isProjectlessSession(session)).forEach((session) => {
+    displaySessions().filter((session) => !session.parentId && !isProjectlessSession(session)).forEach((session) => {
       const originPath = sessionOriginPath(session);
       if (!originPath) return;
       const owner = saved
@@ -104,7 +110,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
 
   function renderWorkspaces() {
     const lists = [$("#workspaceList"), $("#mobileWorkspaceList")].filter(Boolean);
-    const rootSessions = visibleSessions().filter((session) => !session.parentId);
+    const rootSessions = displaySessions().filter((session) => !session.parentId);
     const projects = observedProjects();
     const projectlessCount = rootSessions.filter(isProjectlessSession).length;
     const savedWorkspaceExists = state.workspace === "all"
@@ -149,15 +155,15 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
   }
 
   function renderGlobalStats() {
-    const sessions = visibleSessions();
+    const sessions = displaySessions();
     const totals = {
       active: sessions.filter((session) => session.status === "running" || session.status === "starting").length,
-      waiting: sessions.filter((session) => session.attention?.required).length,
+      waiting: sessions.filter((session) => context.matchesManagementFilter?.(session, "attention")).length,
       usage: { total: sessions.reduce((sum, session) => sum + Number(session.usage && session.usage.total || 0), 0) },
     };
     const rootCount = sessions.filter((session) => !session.parentId).length;
-    const criticalCount = sessions.filter((session) => session.health?.level === "critical").length;
-    const riskCount = sessions.filter((session) => session.health?.level === "warning" || Number(session.context?.percent || 0) >= 75).length;
+    const criticalCount = sessions.filter((session) => context.matchesManagementFilter?.(session, "critical")).length;
+    const riskCount = sessions.filter((session) => context.matchesManagementFilter?.(session, "warning")).length;
     const items = [
       [window.LoadToAgentI18n.t("ui.all_tasks"), rootCount, window.LoadToAgentI18n.t("ui.items"), ""],
       [window.LoadToAgentI18n.t("ui.ai_working_now"), totals.active || 0, window.LoadToAgentI18n.t("ui.items"), "live"],
@@ -177,7 +183,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
     $("#navAllCount").textContent = rootCount;
     const activeRootCount = sessions.filter((session) => !session.parentId && ["running", "starting"].includes(session.status)).length;
     $("#navActiveCount").textContent = activeRootCount;
-    const reviewCount = sessions.filter((session) => context.managementBucket?.(session) !== "healthy").length;
+    const reviewCount = sessions.filter((session) => context.needsManagementReview?.(session)).length;
     $("#navWaitingCount").textContent = reviewCount;
     const scheduledCount = (state.snapshot?.automations || [])
       .filter((item) => isProviderVisible(item.provider || "codex")).length;
@@ -201,7 +207,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
       }[button.dataset.view];
       const label = t(key);
       const count = navCounts[button.dataset.view];
-      const unitKey = { all: "tasks", active: "tasks", waiting: "tasks", runtime: "runs", terminal: "sessions", tmux: "groups" }[button.dataset.view];
+      const unitKey = { all: "tasks", active: "tasks", waiting: "items", runtime: "runs", terminal: "sessions", tmux: "sessions" }[button.dataset.view];
       const unit = unitKey ? t(`quality.unit.${unitKey}`) : "";
       const accessibleLabel = Number.isFinite(count) ? t("quality.nav_count_detailed", { label, count, unit }) : label;
       button.setAttribute("aria-label", accessibleLabel);
@@ -341,7 +347,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
   function renderProviderOverview() {
     pruneProviderFilters();
     const summaries = (state.snapshot && state.snapshot.summary && state.snapshot.summary.providers) || state.providers;
-    const sessions = visibleSessions();
+    const sessions = displaySessions();
     const visibleSummaries = summaries.filter((provider) => isProviderVisible(provider.id));
     const overviewTabStopId = state.providerFilters.size ? [...state.providerFilters][0] : visibleSummaries[0]?.id;
     $("#providerOverview").innerHTML = visibleSummaries
@@ -418,10 +424,10 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
   }
 
   function filteredSessions() {
-    const allSessions = [...visibleSessions()];
+    const allSessions = displaySessions();
     let sessions = state.view === "waiting" ? allSessions : allSessions.filter((session) => !session.parentId);
     if (state.view === "active") sessions = sessions.filter((session) => session.status === "running" || session.status === "starting");
-    if (state.view === "waiting") sessions = sessions.filter((session) => session.attention?.required || ["critical", "warning", "unknown"].includes(session.health?.level) || !session.health);
+    if (state.view === "waiting") sessions = sessions.filter((session) => context.needsManagementReview?.(session));
     if (state.providerFilters.size) sessions = sessions.filter((session) => state.providerFilters.has(session.provider));
     sessions = sessions.filter(matchesWorkspaceFilter);
     const query = state.search.replace(/\s+/g, " ").trim().toLowerCase();
@@ -445,7 +451,7 @@ window.LoadToAgentAppFactories.createDashboard = function createDashboard(contex
   }
 
   function graphFilteredSessions() {
-    let sessions = [...visibleSessions()];
+    let sessions = displaySessions();
     if (state.providerFilters.size) sessions = sessions.filter((session) => state.providerFilters.has(session.provider));
     sessions = sessions.filter(matchesWorkspaceFilter);
     const query = state.search.replace(/\s+/g, " ").trim().toLowerCase();

package/renderer/app-graph-view.js

@@ -33,7 +33,7 @@ window.LoadToAgentAppFactories.createGraphView = function createGraphView(contex
   } = context;
   const t = (key, params) => window.LoadToAgentI18n.t(key, params);
   const statusLabel = (status) => ({
-    starting: t("ui.preparing"), running: t("ui.working"), waiting: t("app.nav.needs_review"), idle: t("ui.idle"),
+    starting: t("ui.preparing"), running: t("ui.working"), waiting: t("ui.waiting_for_review"), idle: t("ui.idle"),
     completed: t("ui.completed"), failed: t("ui.problem"), cancelled: t("ui.stopped"),
   })[status] || STATUS[status] || status;
 

package/renderer/app-management.js

@@ -10,6 +10,33 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
   const healthLabel = level => t(`management.health.${level || "unknown"}`);
   const signalLabel = code => t(`management.signal.${code || "low-confidence"}`);
   const evidenceLabel = value => t(`management.evidence.${value || "unverified"}`);
+  const RECENT_SESSION_WINDOW_MS = 24 * 60 * 60 * 1000;
+  const ALWAYS_VISIBLE_STATUSES = new Set(["starting", "running"]);
+  const CURRENT_RISK_STATUSES = new Set(["starting", "running", "waiting", "paused", "failed"]);
+  const RESPONSE_ATTENTION_KINDS = new Set(["approval", "decision", "input", "response"]);
+  const needsUserResponse = session => Boolean(
+    session.attention?.required && RESPONSE_ATTENTION_KINDS.has(session.attention.kind),
+  );
+  const sessionActivityTimestamp = session => Math.max(0, ...[
+    session.health?.lastActivityAt,
+    session.attention?.requestedAt,
+    session.updatedAt,
+    session.completedAt,
+    session.startedAt,
+  ].map(value => Date.parse(value || 0)).filter(Number.isFinite));
+  const isRecentSession = (session, now = Date.now()) => {
+    if (ALWAYS_VISIBLE_STATUSES.has(session.status)) return true;
+    const activityAt = sessionActivityTimestamp(session);
+    return Boolean(activityAt && Math.max(0, Number(now) - activityAt) <= RECENT_SESSION_WINDOW_MS);
+  };
+  const hasCurrentRisk = (session, now = Date.now()) => Boolean(
+    isRecentSession(session, now)
+    && CURRENT_RISK_STATUSES.has(session.status)
+    && ["critical", "warning"].includes(session.health?.level),
+  );
+  const needsManagementReview = (session, now = Date.now()) => Boolean(
+    isRecentSession(session, now) && (needsUserResponse(session) || hasCurrentRisk(session, now)),
+  );
   const prioritySummary = value => {
     const lines = String(value || "")
       .replace(/```[\s\S]*?```/g, " ")
@@ -37,22 +64,32 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
     return readablePreview(firstSentence || t("management.signal_unavailable"), 104).text;
   };
 
-  function managementBucket(session) {
-    if (session.health?.level === "critical") return "critical";
-    if (session.health?.level === "warning") return "warning";
-    if (session.attention?.required) return "attention";
-    if (!session.health || session.health.level === "unknown") return "unknown";
-    return session.health.level === "healthy" ? "healthy" : "unknown";
+  function managementBucket(session, now = Date.now()) {
+    if (!needsManagementReview(session, now)) return "healthy";
+    if (hasCurrentRisk(session, now) && session.health?.level === "critical") return "critical";
+    if (hasCurrentRisk(session, now) && session.health?.level === "warning") return "warning";
+    if (needsUserResponse(session)) return "attention";
+    return "healthy";
+  }
+
+  function matchesManagementFilter(session, filter, now = Date.now()) {
+    if (filter === "critical") return hasCurrentRisk(session, now) && session.health?.level === "critical";
+    if (filter === "warning") return hasCurrentRisk(session, now) && session.health?.level === "warning";
+    if (filter === "attention") return isRecentSession(session, now) && needsUserResponse(session);
+    return needsManagementReview(session, now);
   }
 
   function progressHtml(session, compactView = false) {
     const progress = session.progress || { percent: 0, checkpoints: [] };
     const checkpoints = compactView ? [] : (progress.checkpoints || []).slice(-8);
+    const completed = Number(progress.completedSteps || 0);
+    const total = Number(progress.totalSteps || 0);
+    const loggedRatio = total ? Math.round(completed / total * 100) : 0;
     return `<section class="management-progress" data-progress-stage="${esc(progress.stage || "idle")}">
       <header><span>${esc(t("management.progress"))}</span><b>${esc(t("management.progress_steps", {
-        completed: progress.completedSteps || 0, total: progress.totalSteps || 0,
-      }))}</b><strong>${Number(progress.percent || 0)}%</strong></header>
-      <div class="management-progress-track" role="progressbar" aria-label="${esc(t("management.progress"))}" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${Number(progress.percent || 0)}"><i style="width:${Math.max(0, Math.min(100, Number(progress.percent || 0)))}%"></i></div>
+        completed, total,
+      }))}</b><strong>${completed}/${total}</strong></header>
+      <div class="management-progress-track" role="progressbar" aria-label="${esc(t("management.progress_steps", { completed, total }))}" aria-valuemin="0" aria-valuemax="${Math.max(1, total)}" aria-valuenow="${completed}"><i style="width:${Math.max(0, Math.min(100, loggedRatio))}%"></i></div>
       <p><b>${esc(progress.currentStep || t("management.no_current_step"))}</b><span>${esc(progress.lastActivityAt ? t("management.last_signal", { time: timeAgo(progress.lastActivityAt) }) : t("management.signal_unavailable"))}</span></p>
       ${progress.blocker ? `<aside><span>${esc(t("management.blocker"))}</span><b>${esc(progress.blocker)}</b></aside>` : ""}
       ${checkpoints.length ? `<ol class="management-checkpoints">${checkpoints.map(row => `<li class="${esc(row.status)}"><i></i><div><b>${esc(row.label)}</b>${row.detail ? `<small>${esc(row.detail)}</small>` : ""}</div><span>${esc(row.timestamp ? timeAgo(row.timestamp) : "")}</span></li>`).join("")}</ol>` : ""}
@@ -63,7 +100,7 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
     const health = session.health || { level: "unknown", signals: [] };
     const signals = health.signals || [];
     return `<section class="management-health ${esc(health.level || "unknown")}">
-      <header><span>${esc(t("management.health_title"))}</span><b>${esc(healthLabel(health.level))}</b><strong>${Number(health.score == null ? 0 : health.score)}</strong></header>
+      <header><span>${esc(t("management.health_title"))}</span><b>${esc(healthLabel(health.level))}</b><strong>${esc(t("common.count", { count: signals.length }))}</strong></header>
       ${signals.length
         ? `<ul>${signals.slice(0, compactView ? 2 : 8).map(signal => `<li class="${esc(signal.severity)}"><i></i><b>${esc(signalLabel(signal.code))}</b>${signal.detail ? `<span title="${esc(signal.detail)}">${esc(signal.detail)}</span>` : ""}</li>`).join("")}</ul>`
         : `<p>${esc(t("management.no_health_signals"))}</p>`}
@@ -92,7 +129,10 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
     if (!attention.required) return "";
     const controls = session.controlCapabilities || {};
     const buttons = [];
-    if (controls.sendInstruction && ["approval", "decision"].includes(attention.kind)) {
+    // A yes/no approval message is only safe for explicit approval requests.
+    // Decisions may require selecting a concrete option, so those use the
+    // normal instruction composer instead of a misleading generic approval.
+    if (controls.sendInstruction && attention.kind === "approval") {
       buttons.push(`<button type="button" class="approve" data-attention-session-id="${esc(session.id)}" data-attention-quick="${esc(t("management.quick.approve_text"))}">${esc(t("management.approve"))}</button>`);
       buttons.push(`<button type="button" data-attention-session-id="${esc(session.id)}" data-attention-quick="${esc(t("management.quick.deny_text"))}">${esc(t("management.deny"))}</button>`);
     }
@@ -103,10 +143,19 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
   function attentionCardHtml(session) {
     const provider = providerInfo(session.provider);
     const attention = session.attention || {};
+    const health = session.health || { level: "unknown", signals: [] };
     const evidence = session.evidence || {};
+    const cardLabel = attention.required ? attentionLabel(attention.kind) : healthLabel(health.level);
+    const statusSignals = (health.signals || []).map(signal => {
+      const label = signalLabel(signal.code);
+      return signal.detail ? `${label} · ${signal.detail}` : label;
+    }).join(" / ");
+    const reason = attention.required
+      ? (attention.summary || session.statusDetail || t("management.response_needed"))
+      : (statusSignals || session.statusDetail || t("management.signal_unavailable"));
     return `<article class="attention-card ${esc(attention.kind || "response")}" data-management-session="${esc(session.id)}" style="--management-provider:${provider.accent}">
-      <header><span class="provider-mark">${esc(provider.mark)}</span><div><small>${esc(provider.label)} · ${esc(attentionLabel(attention.kind))}</small><h3>${esc(session.title)}</h3></div><em class="confidence ${esc(evidence.confidence || "low")}">${esc(evidenceLabel(evidence.confidence))}</em></header>
-      <div class="attention-reason"><span>${esc(t("management.requested_action"))}</span><p>${esc(attention.summary || session.statusDetail || t("management.response_needed"))}</p><small>${esc(attention.requestedAt ? timeAgo(attention.requestedAt) : t("management.signal_unavailable"))}</small></div>
+      <header><span class="provider-mark">${esc(provider.mark)}</span><div><small>${esc(provider.label)} · ${esc(cardLabel)}</small><h3>${esc(session.title)}</h3></div><em class="confidence ${esc(evidence.confidence || "low")}">${esc(evidenceLabel(evidence.confidence))}</em></header>
+      <div class="attention-reason"><span>${esc(t(attention.required ? "management.requested_action" : "management.health_title"))}</span><p>${esc(reason)}</p><small>${esc(attention.requestedAt ? timeAgo(attention.requestedAt) : health.lastActivityAt ? timeAgo(health.lastActivityAt) : t("management.signal_unavailable"))}</small></div>
       ${progressHtml(session, true)}
       ${healthHtml(session, true)}
       ${quickActionsHtml(session)}
@@ -118,22 +167,20 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
   function renderAttentionInbox() {
     const section = $("#attentionInbox");
     if (!section) return 0;
-    const reviewSessions = context.filteredSessions().filter(session => managementBucket(session) !== "healthy");
-    const filter = ["critical", "warning", "attention", "unknown"].includes(state.managementFilter) ? state.managementFilter : "all";
-    const sessions = filter === "all" ? reviewSessions : reviewSessions.filter(session => managementBucket(session) === filter);
-    const counts = reviewSessions.reduce((output, session) => {
-      const key = managementBucket(session);
-      output[key] = (output[key] || 0) + 1;
-      return output;
-    }, { critical: 0, warning: 0, attention: 0, unknown: 0 });
+    const reviewSessions = context.filteredSessions().filter(needsManagementReview);
+    const filter = ["critical", "warning", "attention"].includes(state.managementFilter) ? state.managementFilter : "all";
+    const sessions = reviewSessions.filter(session => filter === "all" || matchesManagementFilter(session, filter));
+    const counts = {
+      critical: reviewSessions.filter(session => matchesManagementFilter(session, "critical")).length,
+      warning: reviewSessions.filter(session => matchesManagementFilter(session, "warning")).length,
+      attention: reviewSessions.filter(session => matchesManagementFilter(session, "attention")).length,
+    };
     const filterButton = (value, label, count) => `<button type="button" data-management-inbox-filter="${value}" aria-pressed="${filter === value ? "true" : "false"}"><i></i><span>${esc(label)}</span><b>${count}</b></button>`;
     section.innerHTML = `<header class="attention-inbox-head"><div><p>${esc(t("management.inbox_eyebrow"))}</p><h2>${esc(t("management.inbox_title"))}</h2><span>${esc(t("management.inbox_description"))}</span></div><strong>${sessions.length}</strong></header>
       <div class="attention-inbox-summary" role="toolbar" aria-label="${esc(t("management.operations_severity_buckets"))}">
-        ${filterButton("all", t("management.filter_all"), reviewSessions.length)}
-        ${filterButton("critical", t("management.health.critical"), counts.critical)}
-        ${filterButton("warning", t("management.health.warning"), counts.warning)}
-        ${filterButton("attention", t("management.health.attention"), counts.attention)}
-        ${filterButton("unknown", t("management.health.unknown"), counts.unknown)}
+        <div class="management-filter-all">${filterButton("all", t("management.filter_all"), reviewSessions.length)}</div>
+        <div class="management-filter-group response" role="group" aria-label="${esc(t("management.filter_group_response"))}"><small>${esc(t("management.filter_group_response"))}</small>${filterButton("attention", t("management.health.attention"), counts.attention)}</div>
+        <div class="management-filter-group risk" role="group" aria-label="${esc(t("management.filter_group_risk"))}"><small>${esc(t("management.filter_group_risk"))}</small>${filterButton("critical", t("management.health.critical"), counts.critical)}${filterButton("warning", t("management.health.warning"), counts.warning)}</div>
       </div>
       <div class="attention-card-list">${sessions.length ? sessions.map(attentionCardHtml).join("") : `<div class="management-empty"><b>${esc(t("management.inbox_empty"))}</b><span>${esc(t("management.inbox_empty_detail"))}</span></div>`}</div>`;
     return sessions.length;
@@ -145,17 +192,13 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
     const sessions = typeof context.graphFilteredSessions === "function"
       ? context.graphFilteredSessions()
       : (state.snapshot?.sessions || []);
-    const critical = sessions.filter(session => session.health?.level === "critical");
-    const warning = sessions.filter(session => session.health?.level === "warning");
-    const attention = sessions.filter(session => session.attention?.required);
-    const flaggedIds = new Set([...critical, ...warning].map(session => session.id));
-    const attentionOnly = attention.filter(session => !flaggedIds.has(session.id));
-    attentionOnly.forEach(session => flaggedIds.add(session.id));
-    const unknown = sessions.filter(session => !flaggedIds.has(session.id) && (!session.health || session.health.level === "unknown" || !["healthy", "critical", "warning"].includes(session.health.level)));
-    unknown.forEach(session => flaggedIds.add(session.id));
-    const healthy = sessions.filter(session => !flaggedIds.has(session.id) && session.health?.level === "healthy");
-    const priority = [...new Map([...critical, ...warning, ...attentionOnly, ...unknown].map(session => [session.id, session])).values()].slice(0, 4);
-    const reviewCount = critical.length + warning.length + attentionOnly.length + unknown.length;
+    const critical = sessions.filter(session => matchesManagementFilter(session, "critical"));
+    const warning = sessions.filter(session => matchesManagementFilter(session, "warning"));
+    const responses = sessions.filter(session => matchesManagementFilter(session, "attention"));
+    const flaggedIds = new Set([...critical, ...warning, ...responses].map(session => session.id));
+    const clear = sessions.filter(session => !flaggedIds.has(session.id));
+    const priority = [...new Map([...critical, ...warning, ...responses].map(session => [session.id, session])).values()].slice(0, 4);
+    const reviewCount = flaggedIds.size;
     section.innerHTML = `<header>
       <div class="operations-heading">
         <span class="operations-signal" aria-hidden="true">!</span>
@@ -164,16 +207,16 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
       <div class="operations-review-total"><strong>${reviewCount}</strong><span>${esc(t("management.operations_review_count"))}</span></div>
       </header>
       <div class="operations-metrics" aria-label="${esc(t("management.operations_severity_buckets"))}">
-        <button type="button" data-management-filter="critical"><span>${esc(t("management.health.critical"))}</span><b>${critical.length}</b></button>
-        <button type="button" data-management-filter="warning"><span>${esc(t("management.health.warning"))}</span><b>${warning.length}</b></button>
-        <button type="button" data-management-filter="attention"><span>${esc(t("management.health.attention"))}</span><b>${attentionOnly.length}</b></button>
-        <button type="button" data-management-filter="unknown"><span>${esc(t("management.health.unknown"))}</span><b>${unknown.length}</b></button>
-        <div><span>${esc(t("management.health.healthy"))}</span><b>${healthy.length}</b></div>
+        <button type="button" data-management-filter="critical" data-management-metric="critical"><span>${esc(t("management.health.critical"))}</span><b>${critical.length}</b></button>
+        <button type="button" data-management-filter="warning" data-management-metric="warning"><span>${esc(t("management.health.warning"))}</span><b>${warning.length}</b></button>
+        <button type="button" data-management-filter="attention" data-management-metric="attention"><span>${esc(t("management.health.attention"))}</span><b>${responses.length}</b></button>
+        <div data-management-metric="clear"><span>${esc(t("management.recent_clear"))}</span><b>${clear.length}</b></div>
       </div>
       ${priority.length ? `<div class="operations-priority">${priority.map(session => {
         const health = session.health || {};
-        const summary = prioritySummary((health.signals || []).map(signal => signalLabel(signal.code)).join(" · ")
-          || session.attention?.summary
+        const responseSummary = needsUserResponse(session) ? session.attention?.summary : "";
+        const summary = prioritySummary(responseSummary
+          || (health.signals || []).map(signal => signalLabel(signal.code)).join(" · ")
           || t("management.signal_unavailable"));
         return `<button type="button" data-open-session="${esc(session.id)}"><i class="${esc(managementBucket(session))}"></i><span><b>${esc(session.title)}</b><small>${esc(summary)}</small></span><em>${esc(timeAgo(health.lastActivityAt || session.updatedAt))}</em></button>`;
       }).join("")}</div>${reviewCount > priority.length ? `<div class="operations-more"><button type="button" data-management-filter="all"><span>${esc(t("management.operations_view_all"))}</span><b>${reviewCount}</b><i aria-hidden="true">→</i></button></div>` : ""}` : `<p class="operations-clear">${esc(t("management.operations_clear"))}</p>`}`;
@@ -191,7 +234,7 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
       ${session.attention?.required ? `<section class="management-attention-detail"><header><span>${esc(attentionLabel(session.attention.kind))}</span><b>${esc(session.attention.summary)}</b></header>${quickActionsHtml(session)}${controls.sendInstruction ? context.agentCommandComposer(session) : ""}</section>` : ""}
       ${progressHtml(session)}
       ${healthHtml(session)}
-      <section class="management-artifacts"><header><span>${esc(t("management.artifacts"))}</span><b>${esc(t("common.items", { count: (outcome.artifacts || []).length }))}</b></header>${outcome.artifacts?.length ? `<ul>${outcome.artifacts.map(item => `<li><i>${esc(item.kind)}</i><b title="${esc(item.value)}">${esc(item.value)}</b><span>${esc(item.verified ? t("management.verified") : t("management.detected"))}</span></li>`).join("")}</ul>` : `<p>${esc(t("management.no_artifacts"))}</p>`}</section>
+      <section class="management-artifacts"><header><span>${esc(t("management.artifacts"))}</span><b>${esc(t("common.items", { count: (outcome.artifacts || []).length }))}</b></header>${outcome.artifacts?.length ? `<ul>${outcome.artifacts.map(item => `<li><i>${esc(item.kind)}</i><b title="${esc(item.value)}">${esc(item.value)}</b><span>${esc(t("management.detected"))}</span></li>`).join("")}</ul>` : `<p>${esc(t("management.no_artifacts"))}</p>`}</section>
       <section class="management-checks"><header><span>${esc(t("management.verification_checks"))}</span><b>${esc(t("common.items", { count: (outcome.checks || []).length }))}</b></header>${outcome.checks?.length ? `<ul>${outcome.checks.map(check => `<li class="${esc(check.status)}"><i></i><b>${esc(check.label)}</b><span>${esc(t(`management.check.${check.status}`))}</span></li>`).join("")}</ul>` : `<p>${esc(t("management.no_checks"))}</p>`}</section>
       <section class="management-evidence"><header><span>${esc(t("management.evidence_title"))}</span><b>${esc(evidenceLabel(evidence.confidence))}</b></header><dl><div><dt>${esc(t("management.evidence_status"))}</dt><dd>${esc(evidenceLabel(evidence.status))}</dd></div><div><dt>${esc(t("management.evidence_hierarchy"))}</dt><dd>${esc(evidenceLabel(evidence.hierarchy))}</dd></div><div><dt>${esc(t("management.evidence_completion"))}</dt><dd>${esc(evidenceLabel(evidence.completion))}</dd></div></dl><p>${esc((evidence.sources || []).join(" · ") || t("management.signal_unavailable"))}</p></section>
       <section class="management-controls"><header><span>${esc(t("management.controls"))}</span><b>${esc(t("management.controls_description"))}</b></header>${controlButtonsHtml(session)}</section>
@@ -199,7 +242,10 @@ window.LoadToAgentAppFactories.createManagement = function createManagement(cont
   }
 
   return {
+    isRecentSession,
     managementBucket,
+    matchesManagementFilter,
+    needsManagementReview,
     attentionCardHtml,
     controlButtonsHtml,
     healthHtml,

package/renderer/app-run-modal.js

@@ -83,7 +83,7 @@ window.LoadToAgentAppFactories.createRunModal = function createRunModal(context
         const active = path === selected;
         return `<button type="button" data-run-workspace="${esc(path)}" class="${active ? "selected" : ""}" title="${esc(path)}" aria-pressed="${active ? "true" : "false"}">
         <span aria-hidden="true">⌘</span>
-        ${esc(workspace.name || path.split(/[\\/]/).filter(Boolean).pop() || window.LoadToAgentI18n.t("ui.workspaces"))}
+        ${esc(workspace.name || path.split(/[\\/]/).filter(Boolean).pop() || window.LoadToAgentI18n.t("ui.work_folder"))}
         </button>`;
       })
       .join("");

package/renderer/app.js

@@ -156,7 +156,7 @@ window.LoadToAgentAppFactories.createCore = function createCore(context = {}) {
     get: (_target, property) => keys[property] ? t(keys[property]) : undefined,
   });
   const STATUS = localizedLookup({
-    starting: "ui.preparing", running: "ui.working", paused: "management.status.paused", waiting: "app.nav.needs_review", idle: "ui.idle",
+    starting: "ui.preparing", running: "ui.working", paused: "management.status.paused", waiting: "ui.waiting_for_review", idle: "ui.idle",
     completed: "ui.completed", failed: "ui.problem", cancelled: "ui.stopped",
   });
   const VIEW_TITLES = localizedLookup({