loadtoagent 1.3.4 → 1.3.6

package/renderer/styles-readability.css

@@ -474,14 +474,7 @@ body :is(input, textarea)::placeholder {
 }
 
 .terminal-session-row {
-  grid-template-columns: minmax(0, 1fr) 44px;
-  gap: 7px;
-}
-
-.terminal-reorder-actions button {
-  min-width: 44px;
-  min-height: 44px;
-  font-size: 16px;
+  grid-template-columns: minmax(0, 1fr);
 }
 
 .terminal-font-controls {
@@ -914,7 +907,6 @@ body :is(
   .terminal-workspace-actions,
   .terminal-key-actions,
   .terminal-tmux-tools,
-  .terminal-reorder-actions,
   .tmux-section-actions,
   .tmux-pane-actions,
   .run-modal-actions,

package/renderer/styles-responsive-shell.css

@@ -399,10 +399,17 @@
   }
 
   .chat-progress-updates,
-  .chat-turn-waiting {
+  .chat-turn-waiting,
+  .subagent-call-moment,
+  .subagent-call-event {
     margin-left: 0;
   }
 
+  .subagent-call-moment,
+  .subagent-call-event {
+    width: 100%;
+  }
+
   .json-object>div {
     grid-template-columns: 1fr;
   }
@@ -475,6 +482,20 @@
     border-radius: 7px;
   }
 
+  .subagent-call-event {
+    grid-template-columns: 32px minmax(0,1fr);
+  }
+
+  .subagent-call-anchor {
+    grid-template-columns: 26px minmax(0,1fr);
+    padding: 9px 10px;
+  }
+
+  .subagent-call-action {
+    grid-column: 2;
+    justify-items: start;
+  }
+
   .main-stage {
     padding-right: 11px;
     padding-left: 11px;

package/renderer/styles-terminal.css

@@ -421,35 +421,8 @@
 
 .terminal-session-row {
   display: grid;
-  grid-template-columns: minmax(0,1fr) 26px;
+  grid-template-columns: minmax(0,1fr);
   align-items: stretch;
-  gap: 4px;
-}
-
-.terminal-reorder-actions {
-  display: grid;
-  gap: 4px;
-}
-
-.terminal-reorder-actions button {
-  min-width: 26px;
-  padding: 0;
-  border: 1px solid #243946;
-  border-radius: 7px;
-  background: #101a24;
-  color: #7f91a3;
-  cursor: pointer;
-}
-
-.terminal-reorder-actions button:hover:not(:disabled),
-.terminal-reorder-actions button:focus-visible {
-  border-color: #397766;
-  color: #70e6bd;
-}
-
-.terminal-reorder-actions button:disabled {
-  opacity: .3;
-  cursor: default;
 }
 
 .terminal-session-item:hover {
@@ -1395,7 +1368,7 @@
   cursor: grab;
   position: relative;
   display: grid;
-  grid-template-columns: 38px minmax(0,1fr) 8px;
+  grid-template-columns: 12px 38px minmax(0,1fr) auto;
   gap: 10px;
   min-height: 72px;
   padding: 10px 9px;
@@ -1406,6 +1379,23 @@
   transition: transform var(--motion-fast) var(--motion-ease),background-color var(--motion-fast) ease,border-color var(--motion-fast) ease,color var(--motion-fast) ease,box-shadow var(--motion-medium) ease,opacity var(--motion-fast) ease;
 }
 
+.terminal-session-drag-handle {
+  width: 3px;
+  height: 3px;
+  justify-self: center;
+  border-radius: 50%;
+  background: #607281;
+  box-shadow: 0 -5px #607281,0 5px #607281;
+  transition: background-color var(--motion-fast) ease,box-shadow var(--motion-fast) ease;
+}
+
+.terminal-session-item:hover .terminal-session-drag-handle,
+.terminal-session-item:focus-visible .terminal-session-drag-handle,
+.terminal-session-item.dragging .terminal-session-drag-handle {
+  background: #68dcb6;
+  box-shadow: 0 -5px #68dcb6,0 5px #68dcb6;
+}
+
 .terminal-session-item.dragging {
   opacity: .45;
   cursor: grabbing;
@@ -1468,10 +1458,10 @@ body[data-current-view="terminal"] .topbar h1 {
 .terminal-resource-head>div span { margin-top: 5px; color: #93a6b2; font-size: 12px; }
 .terminal-resource-live { font-size: 12px; }
 .terminal-session-list { gap: 9px; padding: 12px; }
-.terminal-session-row { grid-template-columns: minmax(0,1fr) 28px; gap: 5px; }
+.terminal-session-row { grid-template-columns: minmax(0,1fr); }
 
 .terminal-session-item {
-  grid-template-columns: 42px minmax(0,1fr) auto;
+  grid-template-columns: 12px 42px minmax(0,1fr) auto;
   gap: 11px;
   min-height: 86px;
   padding: 11px 10px;

package/renderer/styles-workflow-map.css

@@ -610,6 +610,10 @@
   border-color: rgba(230,104,112,.4);
 }
 
+.execution-activity-card.unverified {
+  border-color: rgba(229,184,95,.34);
+}
+
 .execution-activity-icon {
   width: 36px;
   height: 36px;
@@ -716,6 +720,10 @@
   background: #e26972;
 }
 
+.execution-activity-card.unverified .execution-activity-state>span:first-child i {
+  background: #d6b36c;
+}
+
 .execution-activity-state b {
   color: #c6d2d7;
   font-size: 12px;

package/renderer/terminal-events.js

@@ -93,19 +93,6 @@ window.LoadToAgentTerminalEvents = function bindTerminalEvents(context) {
       });
     };
     sessionList.addEventListener('click', event => {
-      const move = event.target.closest('[data-session-move][data-session-move-id]');
-      if (move) {
-        const changed = moveSessionByOffset(move.dataset.sessionMoveId, Number(move.dataset.sessionMove));
-        if (!changed) return;
-        renderAll();
-        requestAnimationFrame(() => {
-          const next = sessionList.querySelector(`[data-session-move-id="${CSS.escape(move.dataset.sessionMoveId)}"][data-session-move="${CSS.escape(move.dataset.sessionMove)}"]`);
-          if (next && !next.disabled) next.focus();
-          else sessionList.querySelector(`[data-terminal-id="${CSS.escape(move.dataset.sessionMoveId)}"]`)?.focus();
-        });
-        notice(window.LoadToAgentI18n.t('terminal.reordered'), 'success');
-        return;
-      }
       if (state.sessionDragJustEnded) return;
       const item = event.target.closest('[data-terminal-id]');
       if (item) selectSession(item.dataset.terminalId);

package/renderer/terminal-workbench.js

@@ -178,14 +178,11 @@ window.LoadToAgentTerminalWorkbench = function createModule(context) {
           aria-grabbed="false"
           aria-describedby="terminalReorderHelp"
           title="${esc(session.cwd || window.LoadToAgentI18n.t('terminal.reorder_hint'))}">
+          <span class="terminal-session-drag-handle" aria-hidden="true"></span>
           <span class="terminal-session-icon">${esc(terminalTypeMark(session))}</span>
           <span><b>${esc(session.title)}</b><small>${esc(terminalTypeLabel(session))}${session.background ? ` · ${t('terminal.background_kept')}` : ''}${session.recoveredAfterHostRestart ? ` · ${t('terminal.recovered_after_host_restart')}` : ''}</small><em>${esc(session.cwd || session.distro || `PID ${session.pid || '--'}`)}</em><span class="sr-only">${index + 1}/${general.length}</span></span>
           <span class="terminal-session-status" data-status="${esc(presentation.tone)}"><i></i>${esc(presentation.label)}</span>
         </button>
-        <span class="terminal-reorder-actions" aria-label="${esc(window.LoadToAgentI18n.t('terminal.reorder_group', { title: session.title }))}">
-          <button type="button" data-session-move="-1" data-session-move-id="${esc(session.id)}" aria-label="${esc(window.LoadToAgentI18n.t('terminal.move_up', { title: session.title }))}" ${index === 0 ? 'disabled' : ''}>↑</button>
-          <button type="button" data-session-move="1" data-session-move-id="${esc(session.id)}" aria-label="${esc(window.LoadToAgentI18n.t('terminal.move_down', { title: session.title }))}" ${index === general.length - 1 ? 'disabled' : ''}>↓</button>
-        </span>
       </div>`;
     }).join('') : `<div class="terminal-resource-empty">${t('terminal.empty.general')}</div>`;
   }

package/src/agentMonitor/claudeParser.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const path = require('path');
-const { createExecutionTracker } = require('./executionActivity');
+const { createExecutionTracker, reconcileExecutionActivities } = require('./executionActivity');
 
 function createClaudeParser(dependencies) {
   const {
@@ -23,6 +23,34 @@ function createClaudeParser(dependencies) {
     isUserInputTool,
   } = dependencies;
 
+  function taskNotification(value) {
+    const text = String(value || '');
+    if (!/<task-notification\b/i.test(text)) return null;
+    const field = name => {
+      const match = text.match(new RegExp(`<${name}>([\\s\\S]*?)<\\/${name}>`, 'i'));
+      return match ? match[1].trim() : '';
+    };
+    const taskId = field('task-id');
+    const toolUseId = field('tool-use-id');
+    const status = field('status').toLowerCase();
+    if (!taskId && !toolUseId) return null;
+    return { taskId, toolUseId, status, text };
+  }
+
+  function recordTaskNotification(state, value, at) {
+    const notification = taskNotification(value);
+    if (!notification || !/^(?:completed|failed|error|cancelled)$/.test(notification.status)) return null;
+    state.executionTracker.recordOutput({
+      name: 'bash',
+      callId: notification.toolUseId,
+      args: { task_id: notification.taskId },
+      output: notification.text,
+      at,
+      isError: /^(?:failed|error)$/.test(notification.status),
+    });
+    return notification;
+  }
+
   function normalizeUsage(raw = {}) {
     return finalizeUsage({
       input: raw.input_tokens,
@@ -53,6 +81,136 @@ function createClaudeParser(dependencies) {
     return raw;
   }
 
+  function isClaudeAgentTool(name) {
+    return /^(?:Agent|Task)$/i.test(String(name || ''));
+  }
+
+  function addClaudeCommunication(session, event) {
+    const communications = session.collaboration.communications;
+    const row = {
+      id: String(event.id || `claude-communication:${communications.length}`),
+      kind: event.kind || 'message',
+      label: compactText(event.label || '메시지', 100),
+      from: compactText(event.from, 180),
+      to: compactText(event.to, 180),
+      taskName: compactText(event.taskName, 180),
+      childId: compactText(event.childId, 180),
+      text: compactText(event.text, 6000),
+      protected: false,
+      assignmentSource: compactText(event.assignmentSource, 80),
+      timestamp: timestamp(event.timestamp, session.updatedAt),
+    };
+    if (!communications.some(item => item.id === row.id)) communications.push(row);
+  }
+
+  function findClaudeSpawn(session, callId) {
+    return session.collaboration.spawns.find(record => record.callId === String(callId || ''));
+  }
+
+  function recordClaudeAgentCall(session, state, row, callId, args) {
+    const prompt = compactText(args.prompt || args.message, 6000);
+    const taskName = compactText(args.description || args.name || args.subagent_type, 180);
+    const record = {
+      callId: String(callId || `claude-spawn:${session.collaboration.spawns.length}`),
+      taskName,
+      agentPath: '',
+      childId: '',
+      assignment: prompt,
+      assignmentObserved: Boolean(prompt),
+      assignmentProtected: false,
+      assignmentSource: prompt ? 'claude-agent-prompt' : 'unavailable',
+      assignmentContext: '',
+      sharedGoal: compactText(state.latestUser, 6000),
+      status: 'requested',
+      startedAt: timestamp(row.timestamp, session.updatedAt),
+      completedAt: null,
+      result: '',
+      agentName: compactText(args.subagent_type, 120),
+      currentlyRetained: false,
+    };
+    session.collaboration.spawns.push(record);
+    addClaudeCommunication(session, {
+      id: `assign:${record.callId}`,
+      kind: 'assignment',
+      label: '새 작업 배정',
+      from: session.agentPath || session.id,
+      to: record.taskName,
+      taskName: record.taskName,
+      text: record.assignment,
+      assignmentSource: record.assignmentSource,
+      timestamp: row.timestamp,
+    });
+  }
+
+  function updateClaudeSpawn(session, callId, details = {}) {
+    const record = findClaudeSpawn(session, callId);
+    if (!record) return;
+    const childExternalId = compactText(details.childExternalId, 180);
+    if (childExternalId) {
+      record.childId = `claude:${childExternalId}`;
+      record.agentPath = record.childId;
+    }
+    if (details.status) record.status = details.status;
+    if (details.completedAt) record.completedAt = timestamp(details.completedAt, record.completedAt || session.updatedAt);
+    if (details.result) record.result = compactText(details.result, 6000);
+    for (const communication of session.collaboration.communications) {
+      if (communication.taskName !== record.taskName || communication.childId) continue;
+      communication.childId = record.childId;
+      communication.to = record.agentPath || communication.to;
+    }
+    if ((record.status === 'running' || record.childId) && !session.collaboration.communications.some(item => item.id === `started:${record.callId}`)) {
+      addClaudeCommunication(session, {
+        id: `started:${record.callId}`,
+        kind: 'started',
+        label: '서브에이전트 실행 시작',
+        from: 'Claude 런타임',
+        to: record.agentPath || record.taskName,
+        taskName: record.taskName,
+        childId: record.childId,
+        timestamp: record.startedAt,
+      });
+    }
+    if (record.completedAt && !session.collaboration.communications.some(item => item.id === `result:${record.callId}`)) {
+      addClaudeCommunication(session, {
+        id: `result:${record.callId}`,
+        kind: 'result',
+        label: '결과 반환 확인',
+        from: record.agentPath || record.taskName,
+        to: session.agentPath || session.id,
+        taskName: record.taskName,
+        childId: record.childId,
+        text: record.result,
+        timestamp: record.completedAt,
+      });
+    }
+  }
+
+  function recordClaudeAgentToolResult(session, state, item, at) {
+    const call = state.toolCalls.get(String(item.tool_use_id || ''));
+    if (!call || !isClaudeAgentTool(call.name)) return;
+    const output = compactText(item.content || item, 12000);
+    const agentId = output.match(/\bagentId:\s*([A-Za-z0-9_-]+)/i);
+    const launched = /agent launched successfully|working in the background/i.test(output);
+    const failed = item.is_error === true;
+    updateClaudeSpawn(session, item.tool_use_id, {
+      childExternalId: agentId && agentId[1],
+      status: failed ? 'failed' : (launched ? 'running' : 'completed'),
+      completedAt: launched ? null : at,
+      result: launched ? '' : output,
+    });
+  }
+
+  function recordClaudeTaskCompletion(session, notification, at) {
+    if (!notification) return;
+    const resultMatch = notification.text.match(/<result>([\s\S]*?)<\/result>/i);
+    updateClaudeSpawn(session, notification.toolUseId, {
+      childExternalId: notification.taskId,
+      status: notification.status === 'completed' ? 'completed' : notification.status,
+      completedAt: at,
+      result: resultMatch ? resultMatch[1].trim() : '',
+    });
+  }
+
   function recordContent(session, state, row, item, index) {
     const kind = item && item.type;
     const id = `${row.uuid || row.requestId || session.externalId}:${index}`;
@@ -64,6 +222,7 @@ function createClaudeParser(dependencies) {
       const callId = item.id || id;
       const args = item.input && typeof item.input === 'object' ? item.input : {};
       state.toolCalls.set(String(callId), { name, args });
+      if (isClaudeAgentTool(name)) recordClaudeAgentCall(session, state, row, callId, args);
       state.executionTracker.recordCall({ name, callId, args, rawInput: item.input, at: row.timestamp });
       addMessage(session, {
         id,
@@ -93,6 +252,7 @@ function createClaudeParser(dependencies) {
         at: row.timestamp,
         isError: item.is_error === true,
       });
+      recordClaudeAgentToolResult(session, state, item, row.timestamp);
       settleLifecycle(session, item.tool_use_id, item.is_error ? 'failed' : 'done', row.timestamp);
       addLifecycle(session, {
         id: `result:${item.tool_use_id || id}`,
@@ -136,11 +296,18 @@ function createClaudeParser(dependencies) {
   function processMessageRow(session, state, row) {
     const role = row.message.role === 'assistant' ? 'assistant' : 'user';
     const internalUserRow = role === 'user' && Boolean(row.isMeta || row.sourceToolUseID);
+    state.lastTurnFinished = false;
     state.lastRole = role;
     if (row.message.model) session.model = row.message.model;
     const content = Array.isArray(row.message.content)
       ? row.message.content
       : [{ type: 'text', text: row.message.content }];
+    content.filter(item => item && (!item.type || item.type === 'text'))
+      .forEach((item) => {
+        const notification = recordTaskNotification(state, typeof item === 'string' ? item : item.text, row.timestamp);
+        recordClaudeTaskCompletion(session, notification, row.timestamp);
+      });
+    if (session.depth && role === 'user') state.subagentCompletedAt = null;
     content.forEach((item, index) => {
       if (internalUserRow && (!item.type || item.type === 'text')) return;
       recordContent(session, state, row, item, index);
@@ -176,6 +343,10 @@ function createClaudeParser(dependencies) {
       }
       content.filter(item => item && item.type === 'tool_use' && isUserInputTool(item.name))
         .forEach(item => state.pendingUserInputCalls.add(String(item.id || item.name)));
+      if (String(row.message.stop_reason || '').toLowerCase() === 'end_turn') {
+        state.lastTurnFinished = true;
+        if (session.depth) state.subagentCompletedAt = timestamp(row.timestamp, state.latestTs);
+      }
     }
     if (role === 'assistant' && row.message.usage) {
       const key = row.requestId || row.message.id || row.uuid;
@@ -198,6 +369,7 @@ function createClaudeParser(dependencies) {
       executionTracker: createExecutionTracker({ compactText, timestamp }),
       latestTs: session.updatedAt,
       lastTurnFinished: false,
+      subagentCompletedAt: null,
     };
     for (const row of rows) {
       state.latestTs = timestamp(row.timestamp, state.latestTs);
@@ -206,6 +378,8 @@ function createClaudeParser(dependencies) {
       if (row.gitBranch) session.branch = row.gitBranch;
       if (row.agentId && session.depth) session.agentName = row.agentId;
       if (row.type === 'queue-operation' && row.operation === 'enqueue' && row.content) {
+        const notification = recordTaskNotification(state, row.content, row.timestamp);
+        recordClaudeTaskCompletion(session, notification, row.timestamp);
         const detectedUtility = utilityKind(row.content);
         if (detectedUtility) session.utilityKind = detectedUtility;
         const visibleUser = visibleUserText(row.content);
@@ -245,7 +419,6 @@ function createClaudeParser(dependencies) {
     session.updatedAt = state.latestTs;
     session.startedAt = timestamp(parsed.rows[0].timestamp, session.updatedAt);
     session.usage = sumUsage([...state.requestUsage.values()]);
-    session.executions = state.executionTracker.finalize();
     const utilityTitle = session.utilityKind === 'memory-extraction'
       ? 'Claude 백그라운드 메모리 추출'
       : (session.utilityKind === 'authentication-check' ? 'Claude 인증 점검' : '');
@@ -260,10 +433,17 @@ function createClaudeParser(dependencies) {
     const conversationalInput = state.lastConversationRole === 'assistant'
       && assistantRequestsUserResponse(state.lastAssistantText)
       && (state.lastTurnFinished || age >= ACTIVE_THRESHOLD_MS);
-    if (!session.depth && (pendingUserInput || conversationalInput)) {
+    if (session.depth && state.subagentCompletedAt) {
+      session.status = 'completed';
+      session.statusDetail = '작업 완료';
+      session.completedAt = state.subagentCompletedAt;
+      session.completionObserved = true;
+      session.statusObserved = false;
+      session.result = state.lastAssistantText || session.result;
+    } else if (!session.depth && (pendingUserInput || conversationalInput)) {
       session.status = 'waiting';
       session.statusDetail = pendingUserInput ? '선택 또는 입력 대기' : '답변 또는 선택 대기';
-    } else if (age < ACTIVE_THRESHOLD_MS && !state.lastTurnFinished) {
+    } else if (age < STALE_TURN_THRESHOLD_MS && !state.lastTurnFinished) {
       session.status = 'running';
       session.statusDetail = state.lastRole === 'user' ? '응답 생성 중' : '도구 실행 또는 스트리밍 중';
     } else if (state.lastRole === 'user' && age < STALE_TURN_THRESHOLD_MS) {
@@ -273,6 +453,11 @@ function createClaudeParser(dependencies) {
       session.status = 'idle';
       session.statusDetail = state.lastRole === 'user' ? '마지막 응답 기록이 종료됨' : '다음 요청 대기';
     }
+    session.executions = reconcileExecutionActivities(state.executionTracker.finalize(), {
+      staleAfterMs: STALE_TURN_THRESHOLD_MS,
+      turnFinished: state.lastTurnFinished,
+      waitingForUser: session.status === 'waiting',
+    });
     session.statusObserved = age < ACTIVE_THRESHOLD_MS;
     trimSession(session);
     return session;

package/src/agentMonitor/codexCollaboration.js

@@ -18,6 +18,7 @@ function createCodexCollaboration(session, dependencies) {
         assignmentObserved: false,
         assignmentProtected: false,
         assignmentSource: 'unavailable',
+        assignmentContext: '',
         sharedGoal: '',
         status: 'requested',
         startedAt: null,

package/src/agentMonitor/codexParser.js

@@ -232,20 +232,21 @@ function createCodexParser(dependencies) {
         : record.agentPath;
       record.assignmentProtected = messageProtected;
       const directAssignment = rawMessage && !messageProtected ? rawMessage : '';
-      record.assignment = directAssignment || (messageProtected ? state.latestDelegationNarration : '');
-      record.assignmentObserved = Boolean(record.assignment);
-      record.assignmentSource = directAssignment ? 'spawn-message' : (record.assignment ? 'parent-narration' : 'unavailable');
+      record.assignment = directAssignment;
+      record.assignmentObserved = Boolean(directAssignment);
+      record.assignmentSource = directAssignment ? 'spawn-message' : (messageProtected ? 'protected' : 'unavailable');
+      record.assignmentContext = messageProtected ? compactText(state.latestDelegationNarration, 6000) : '';
       record.sharedGoal = compactText(state.latestUser, 6000);
       record.startedAt = timestamp(row.timestamp, record.startedAt || session.updatedAt);
       state.collaboration.addCommunication({
         id: `assign:${callId}`,
         kind: 'assignment',
-        label: record.assignmentSource === 'parent-narration' ? '메인 AI 작업 지시' : '새 작업 배정',
+        label: '새 작업 배정',
         from: session.agentPath || '/root',
         to: record.agentPath,
         taskName: record.taskName,
         text: record.assignment,
-        protected: record.assignmentProtected && !record.assignment,
+        protected: record.assignmentProtected,
         assignmentSource: record.assignmentSource,
         timestamp: row.timestamp,
       });

package/src/agentMonitor/executionActivity.js

@@ -156,7 +156,7 @@ function outputStatus(value, explicitError = false) {
   if (firstLine.startsWith('script running')) return 'running';
   const code = exitCode(text);
   if (explicitError || (code != null && code !== 0) || /(?:script|command|process)\s+failed|isError["':\s]+true|fatal error/i.test(text)) return 'failed';
-  if (/(?:script|command|process)\s+(?:is\s+)?(?:still\s+)?running|running\s+in\s+(?:the\s+)?background|background\s+(?:task|command)|yielded/i.test(text)) return 'running';
+  if (/^(?:command|process)\s+(?:is\s+)?(?:still\s+)?running\b|\brunning\s+in\s+(?:the\s+)?background\b|^background\s+(?:task|command)\b.*\brunning\b|\byielded\b/i.test(firstLine)) return 'running';
   return 'completed';
 }
 
@@ -270,6 +270,30 @@ function createExecutionTracker(options = {}) {
   return { activities, recordCall, recordOutput, finalize };
 }
 
+function reconcileExecutionActivities(activities = [], options = {}) {
+  const now = Number.isFinite(Number(options.now)) ? Number(options.now) : Date.now();
+  const staleAfterMs = Math.max(0, Number(options.staleAfterMs || 0));
+  const turnSettled = Boolean(options.turnFinished || options.waitingForUser);
+  return activities.map((activity) => {
+    if (!activity || activity.status !== 'running') return activity;
+    const observedAt = Date.parse(activity.updatedAt || activity.startedAt || 0);
+    const observationAge = Number.isFinite(observedAt) ? Math.max(0, now - observedAt) : Number.POSITIVE_INFINITY;
+    const foregroundEnded = activity.mode !== 'background' && turnSettled;
+    const backgroundUnobserved = activity.mode === 'background'
+      && staleAfterMs > 0
+      && observationAge >= staleAfterMs;
+    if (!foregroundEnded && !backgroundUnobserved) return activity;
+    return {
+      ...activity,
+      status: 'unverified',
+      statusDetail: foregroundEnded
+        ? '턴 종료 후 실행 상태 미확인'
+        : '최근 실행 신호 없음',
+      completedAt: null,
+    };
+  });
+}
+
 module.exports = {
   CONTINUATION_TOOLS,
   SHELL_TOOLS,
@@ -277,6 +301,7 @@ module.exports = {
   executionInput,
   outputStatus,
   outputText,
+  reconcileExecutionActivities,
   runtimeHandle,
   toolName,
 };

package/src/agentMonitor/hierarchy.js

@@ -45,8 +45,8 @@ function createHierarchyAttacher(dependencies) {
   }
 
   function createHistoryChild(parent, record) {
-    const externalId = String(record.childId || `${parent.externalId}:spawn:${record.callId}`).replace(/^codex:/, '');
-    const child = baseSession('codex', externalId, '', {
+    const externalId = String(record.childId || `${parent.externalId}:spawn:${record.callId}`).replace(/^(?:codex|claude):/, '');
+    const child = baseSession(parent.provider, externalId, '', {
       mtimeMs: Date.parse(record.completedAt || record.startedAt || parent.updatedAt) || Date.now(),
     });
     child.id = record.childId || child.id;
@@ -69,7 +69,7 @@ function createHierarchyAttacher(dependencies) {
     child.completionObserved = child.status === 'completed';
     child.result = record.result || '';
     child.source = 'collaboration-history';
-    child.sourceLabel = 'Codex 협업 이벤트';
+    child.sourceLabel = parent.provider === 'claude' ? 'Claude 협업 이벤트' : 'Codex 협업 이벤트';
     child.clientKind = parent.clientKind;
     child.model = parent.model;
     child.cwd = parent.cwd;
@@ -131,6 +131,7 @@ function createHierarchyAttacher(dependencies) {
       assignmentObserved: record.assignmentObserved,
       assignmentProtected: record.assignmentProtected,
       assignmentSource: record.assignmentSource,
+      assignmentContext: record.assignmentContext || '',
       sharedGoal: record.sharedGoal || child.sharedGoal || parent.title,
       result: record.result,
       startedAt: record.startedAt,
@@ -151,6 +152,7 @@ function createHierarchyAttacher(dependencies) {
       assignmentObserved: false,
       assignmentProtected: false,
       assignmentSource: 'unavailable',
+      assignmentContext: '',
       sharedGoal: child.sharedGoal || parent.title,
       status: child.status === 'completed' ? 'completed' : (child.status === 'running' ? 'running' : 'idle'),
       startedAt: child.startedAt,
@@ -169,6 +171,7 @@ function createHierarchyAttacher(dependencies) {
       assignmentObserved: false,
       assignmentProtected: true,
       assignmentSource: 'unavailable',
+      assignmentContext: '',
       sharedGoal: child.sharedGoal || parent.title,
       result: child.result || '',
       startedAt: child.startedAt,

package/src/agentMonitor.js

@@ -492,10 +492,17 @@ class AgentMonitor extends EventEmitter {
 
   parseFile(info, parser, variant = '') {
     const key = `${info.file}|${info.mtimeMs}|${info.size}|${variant}`;
-    const cached = this.parseCache.get(key);
-    if (cached) return cached;
+    const cachedEntry = this.parseCache.get(key);
+    const cached = cachedEntry && cachedEntry.value || cachedEntry;
+    const parsedAt = Number(cachedEntry && cachedEntry.parsedAt || 0);
+    const timeSensitive = Boolean(cached && (
+      cached.status === 'running'
+      || cached.status === 'starting'
+      || (cached.executions || []).some(execution => execution.status === 'running')
+    ));
+    if (cached && (!timeSensitive || Date.now() - parsedAt < ACTIVE_THRESHOLD_MS)) return cached;
     const value = parser(info);
-    if (value) this.parseCache.set(key, value);
+    if (value) this.parseCache.set(key, { value, parsedAt: Date.now() });
     if (this.parseCache.size > 500) {
       const keep = [...this.parseCache.entries()].slice(-300);
       this.parseCache = new Map(keep);

package/src/contracts.js

@@ -42,7 +42,7 @@
  * @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 Logged regular and background command runs 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'|'unverified',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. `unverified` means the last running observation is no longer fresh enough to claim current liveness.
  * @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.

package/src/monitorWorker.js

@@ -107,6 +107,7 @@ function cardCollaboration(value) {
       assignmentObserved: Boolean(record.assignmentObserved),
       assignmentProtected: Boolean(record.assignmentProtected),
       assignmentSource: clip(record.assignmentSource, 80),
+      assignmentContext: clip(record.assignmentContext, 1200),
       sharedGoal: clip(record.sharedGoal, 1200),
       status: record.status,
       startedAt: record.startedAt,
@@ -194,6 +195,7 @@ function cardSession(session) {
       assignmentObserved: Boolean(session.delegation.assignmentObserved),
       assignmentProtected: Boolean(session.delegation.assignmentProtected),
       assignmentSource: clip(session.delegation.assignmentSource, 80),
+      assignmentContext: clip(session.delegation.assignmentContext, 1200),
       sharedGoal: clip(session.delegation.sharedGoal, 1200),
       result: clip(session.delegation.result, 1200),
       startedAt: session.delegation.startedAt,