loadtoagent 1.0.0 → 1.3.1

package/src/agentMonitor/claudeParser.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const path = require('path');
+const { createExecutionTracker } = require('./executionActivity');
 
 function createClaudeParser(dependencies) {
   const {
@@ -18,6 +19,8 @@ function createClaudeParser(dependencies) {
     sumUsage,
     timestamp,
     trimSession,
+    assistantRequestsUserResponse,
+    isUserInputTool,
   } = dependencies;
 
   function normalizeUsage(raw = {}) {
@@ -30,18 +33,27 @@ function createClaudeParser(dependencies) {
     });
   }
 
+  function utilityKind(value) {
+    const raw = compactText(value, 12000);
+    if (/^Extract durable memory candidates from this Claude Code transcript tail/i.test(raw)
+      || /^You are a memory extraction/i.test(raw)) return 'memory-extraction';
+    if (/^Reply with exactly OK\. Do not use tools\.?$/i.test(raw)) return 'authentication-check';
+    if (/^Approved command prefix saved:/i.test(raw)) return 'command-approval';
+    return '';
+  }
+
   function visibleUserText(value) {
     const raw = compactText(value, 12000);
     if (!raw) return '';
     const objective = raw.match(/<objective>\s*([\s\S]*?)\s*<\/objective>/i);
     if (objective) return compactText(objective[1], 6000);
     if (/^<(?:local-command-[^>]+|command-name|command-message|system-reminder|task-notification)>/i.test(raw)) return '';
-    if (/^Extract durable memory candidates from this Claude Code transcript tail/i.test(raw)) return '';
+    if (utilityKind(raw)) return '';
     if (/^(?:Updated task #\d+|Your questions have been answered:)/i.test(raw)) return '';
     return raw;
   }
 
-  function recordContent(session, row, item, index) {
+  function recordContent(session, state, row, item, index) {
     const kind = item && item.type;
     const id = `${row.uuid || row.requestId || session.externalId}:${index}`;
     if (kind === 'text' && item.text) {
@@ -49,6 +61,10 @@ function createClaudeParser(dependencies) {
       if (text) addMessage(session, { id, role: row.message.role, text, timestamp: row.timestamp });
     } else if (kind === 'tool_use') {
       const name = item.name || 'tool';
+      const callId = item.id || id;
+      const args = item.input && typeof item.input === 'object' ? item.input : {};
+      state.toolCalls.set(String(callId), { name, args });
+      state.executionTracker.recordCall({ name, callId, args, rawInput: item.input, at: row.timestamp });
       addMessage(session, {
         id,
         role: 'tool',
@@ -68,6 +84,15 @@ function createClaudeParser(dependencies) {
         timestamp: row.timestamp,
       });
     } else if (kind === 'tool_result') {
+      const call = state.toolCalls.get(String(item.tool_use_id || ''));
+      state.executionTracker.recordOutput({
+        name: call && call.name,
+        callId: item.tool_use_id,
+        args: call && call.args || {},
+        output: item.content || item,
+        at: row.timestamp,
+        isError: item.is_error === true,
+      });
       settleLifecycle(session, item.tool_use_id, item.is_error ? 'failed' : 'done', row.timestamp);
       addLifecycle(session, {
         id: `result:${item.tool_use_id || id}`,
@@ -106,19 +131,47 @@ 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.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.forEach((item, index) => recordContent(session, row, item, index));
+    content.forEach((item, index) => {
+      if (internalUserRow && (!item.type || item.type === 'text')) return;
+      recordContent(session, state, row, item, index);
+    });
     if (role === 'user') {
-      const visibleUser = visibleUserText(content
+      content.filter(item => item && item.type === 'tool_result')
+        .forEach(item => state.pendingUserInputCalls.delete(String(item.tool_use_id || '')));
+      const rawUser = content
         .filter(item => !item.type || item.type === 'text')
         .map(item => typeof item === 'string' ? item : item.text)
         .filter(Boolean)
-        .join('\n'));
-      if (visibleUser) state.latestUser = visibleUser;
+        .join('\n');
+      if (!internalUserRow) {
+        const detectedUtility = utilityKind(rawUser);
+        if (detectedUtility) session.utilityKind = detectedUtility;
+        const visibleUser = visibleUserText(rawUser);
+        if (visibleUser) {
+          session.utilityKind = '';
+          state.latestUser = visibleUser;
+          state.lastConversationRole = 'user';
+        }
+      }
+    }
+    if (role === 'assistant') {
+      const assistantText = compactText(content
+        .filter(item => item && item.type === 'text')
+        .map(item => item.text)
+        .filter(Boolean)
+        .join('\n'), 6000);
+      if (assistantText) {
+        state.lastAssistantText = assistantText;
+        state.lastConversationRole = 'assistant';
+      }
+      content.filter(item => item && item.type === 'tool_use' && isUserInputTool(item.name))
+        .forEach(item => state.pendingUserInputCalls.add(String(item.id || item.name)));
     }
     if (role === 'assistant' && row.message.usage) {
       const key = row.requestId || row.message.id || row.uuid;
@@ -134,14 +187,38 @@ function createClaudeParser(dependencies) {
       requestUsage: new Map(),
       latestUser: '',
       lastRole: '',
+      lastConversationRole: '',
+      lastAssistantText: '',
+      pendingUserInputCalls: new Set(),
+      toolCalls: new Map(),
+      executionTracker: createExecutionTracker({ compactText, timestamp }),
       latestTs: session.updatedAt,
       lastTurnFinished: false,
     };
     for (const row of rows) {
       state.latestTs = timestamp(row.timestamp, state.latestTs);
+      if (row.cwd && !session.originCwd) session.originCwd = row.cwd;
       if (row.cwd && !session.cwd) session.cwd = row.cwd;
       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 detectedUtility = utilityKind(row.content);
+        if (detectedUtility) session.utilityKind = detectedUtility;
+        const visibleUser = visibleUserText(row.content);
+        const queueTitle = /^\//.test(visibleUser)
+          ? compactText(visibleUser.split(/\r?\n/)[0], 6000)
+          : visibleUser;
+        if (queueTitle) {
+          session.utilityKind = '';
+          state.latestUser = queueTitle;
+          state.lastRole = 'user';
+          state.lastConversationRole = 'user';
+        }
+      }
+      if (row.type === 'last-prompt' && !state.latestUser && row.lastPrompt) {
+        const visibleUser = visibleUserText(row.lastPrompt);
+        if (visibleUser) state.latestUser = visibleUser;
+      }
       if (row.type === 'system' && row.subtype === 'init') {
         session.model = row.model || session.model;
         addLifecycle(session, {
@@ -164,13 +241,25 @@ 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 인증 점검' : '');
     session.title = compactText(state.latestUser, 180)
+      || utilityTitle
       || (session.depth ? `Claude ${session.agentName}` : 'Claude 세션');
     const currentInput = session.turnUsage.input + session.turnUsage.cachedInput
       + session.turnUsage.cacheWrite + session.turnUsage.output + session.turnUsage.reasoning;
     session.context = contextInfo(currentInput, modelContextWindow('claude', session.model, 0));
     const age = Date.now() - fileInfo.mtimeMs;
-    if (age < ACTIVE_THRESHOLD_MS && !state.lastTurnFinished) {
+    const pendingUserInput = state.pendingUserInputCalls.size > 0;
+    const conversationalInput = state.lastConversationRole === 'assistant'
+      && assistantRequestsUserResponse(state.lastAssistantText)
+      && (state.lastTurnFinished || age >= ACTIVE_THRESHOLD_MS);
+    if (!session.depth && (pendingUserInput || conversationalInput)) {
+      session.status = 'waiting';
+      session.statusDetail = pendingUserInput ? '선택 또는 입력 대기' : '답변 또는 선택 대기';
+    } else if (age < ACTIVE_THRESHOLD_MS && !state.lastTurnFinished) {
       session.status = 'running';
       session.statusDetail = state.lastRole === 'user' ? '응답 생성 중' : '도구 실행 또는 스트리밍 중';
     } else if (state.lastRole === 'user' && age < STALE_TURN_THRESHOLD_MS) {

package/src/agentMonitor/codexParser.js

@@ -2,6 +2,7 @@
 
 const path = require('path');
 const { createCodexCollaboration } = require('./codexCollaboration');
+const { createExecutionTracker } = require('./executionActivity');
 
 const COLLABORATION_TOOLS = new Set([
   'spawn_agent',
@@ -26,10 +27,12 @@ function createCodexParser(dependencies) {
     },
     textOps: {
       agentEnvelope,
+      assistantRequestsUserResponse,
       codexContentText,
       codexVisibleUserText,
       compactText,
       encryptedCollaborationText,
+      isUserInputTool,
       jsonObject,
     },
     collaborationOps: {
@@ -52,6 +55,7 @@ function createCodexParser(dependencies) {
     const session = baseSession('codex', externalId, fileInfo.file, fileInfo);
     session.truncated = parsed.truncated;
     session.cwd = meta.cwd || '';
+    session.originCwd = meta.cwd || '';
     session.model = meta.model || '';
     session.branch = meta.git && meta.git.branch || '';
     session.startedAt = timestamp(meta.timestamp || (metaRow && metaRow.timestamp), session.updatedAt);
@@ -82,14 +86,19 @@ function createCodexParser(dependencies) {
     return {
       latestUser: '',
       latestInternalGoal: '',
+      goalContexts: new Set(),
       latestDelegationNarration: '',
       activeTurn: false,
       lastTurnCompleted: false,
       lastFinalAnswer: '',
+      lastAssistantText: '',
+      lastConversationRole: '',
+      pendingUserInputCalls: new Set(),
       latestTs: session.updatedAt,
       observedWindow: Number(meta.context_window || 0),
       messageObservations: new Map(),
       collaboration: createCodexCollaboration(session, { compactText, timestamp }),
+      executionTracker: createExecutionTracker({ compactText, timestamp }),
       sessionStartedMs: Date.parse(session.startedAt || '') || 0,
     };
   }
@@ -153,7 +162,11 @@ function createCodexParser(dependencies) {
       settleRunningLifecycle(session, payload.completed_at || row.timestamp);
       session.completedAt = timestamp(payload.completed_at || row.timestamp, session.updatedAt);
       session.completionObserved = true;
-      if (payload.last_agent_message) state.lastFinalAnswer = compactText(payload.last_agent_message, 6000);
+      if (payload.last_agent_message) {
+        state.lastFinalAnswer = compactText(payload.last_agent_message, 6000);
+        state.lastAssistantText = state.lastFinalAnswer;
+        state.lastConversationRole = 'assistant';
+      }
       addLifecycle(session, {
         id: payload.turn_id,
         type: 'turn-complete',
@@ -170,15 +183,21 @@ function createCodexParser(dependencies) {
       if (!text) return;
       if (/<codex_internal_context(?:\s|>)/i.test(rawUser)) {
         state.latestInternalGoal = text;
+        if (/<codex_internal_context[^>]*\bsource=["']goal["']/i.test(rawUser)) state.goalContexts.add(`${row.timestamp || ''}:${text}`);
         return;
       }
       state.latestUser = text;
+      state.lastConversationRole = 'user';
       const key = `u:${payload.client_id || row.timestamp}:${text}`;
       addCodexMessage(session, state.messageObservations, { id: key, role: 'user', text, timestamp: row.timestamp }, 'event');
     } else if (payload.type === 'agent_message') {
       const text = compactText(payload.message);
       if (text) state.latestDelegationNarration = text;
       if (payload.phase === 'final_answer') state.lastFinalAnswer = text;
+      if (text) {
+        state.lastAssistantText = text;
+        state.lastConversationRole = 'assistant';
+      }
       const key = `a:${row.timestamp}:${text}`;
       addCodexMessage(session, state.messageObservations, { id: key, role: 'assistant', text, timestamp: row.timestamp }, 'event');
     } else if (payload.type === 'agent_reasoning') {
@@ -264,6 +283,14 @@ function createCodexParser(dependencies) {
     const collaborationTool = payload.namespace === 'collaboration' || COLLABORATION_TOOLS.has(name);
     if (collaborationTool && !timing.ownCollaborationRow) return;
     state.collaboration.calls.set(String(callId || ''), { name, args, timestamp: row.timestamp });
+    state.executionTracker.recordCall({
+      name,
+      callId,
+      args,
+      rawInput: payload.arguments || payload.input,
+      at: row.timestamp,
+    });
+    if (isUserInputTool(name)) state.pendingUserInputCalls.add(String(callId || name));
 
     let collaborationMessageProtected = false;
     if (collaborationTool) {
@@ -299,6 +326,15 @@ function createCodexParser(dependencies) {
   function processToolOutput(session, state, row, payload) {
     settleLifecycle(session, payload.call_id, 'done', row.timestamp);
     const call = state.collaboration.calls.get(String(payload.call_id || ''));
+    state.executionTracker.recordOutput({
+      name: call && call.name,
+      callId: payload.call_id,
+      args: call && call.args || {},
+      output: payload.output,
+      at: row.timestamp,
+      isError: payload.is_error === true || payload.status === 'failed',
+    });
+    state.pendingUserInputCalls.delete(String(payload.call_id || ''));
     const output = jsonObject(payload.output);
     if (call && call.name === 'spawn_agent') {
       const record = state.collaboration.ensureSpawn(payload.call_id);
@@ -356,10 +392,18 @@ function createCodexParser(dependencies) {
     if (!text) return;
     if (role === 'user' && /<codex_internal_context(?:\s|>)/i.test(rawText)) {
       state.latestInternalGoal = text;
+      if (/<codex_internal_context[^>]*\bsource=["']goal["']/i.test(rawText)) state.goalContexts.add(`${row.timestamp || ''}:${text}`);
       return;
     }
-    if (role === 'user') state.latestUser = text;
-    if (role === 'assistant') state.latestDelegationNarration = text;
+    if (role === 'user') {
+      state.latestUser = text;
+      state.lastConversationRole = 'user';
+    }
+    if (role === 'assistant') {
+      state.latestDelegationNarration = text;
+      state.lastAssistantText = text;
+      state.lastConversationRole = 'assistant';
+    }
     const key = payload.id || `message:${role}:${row.timestamp}:${text.slice(0, 80)}`;
     addCodexMessage(session, state.messageObservations, { id: key, role, text, timestamp: row.timestamp }, 'response');
   }
@@ -386,6 +430,7 @@ function createCodexParser(dependencies) {
     };
     if (row.type === 'turn_context') {
       session.model = payload.model || session.model;
+      if (payload.cwd && !session.originCwd) session.originCwd = payload.cwd;
       session.cwd = payload.cwd || session.cwd;
     } else if (row.type === 'world_state') {
       const retainedText = payload.state && payload.state.environments && payload.state.environments.subagents;
@@ -408,15 +453,25 @@ function createCodexParser(dependencies) {
       ? (session.taskName || `${session.agentName} 서브에이전트`)
       : (compactText(state.latestUser || state.latestInternalGoal, 180) || 'GPT 작업 세션');
     session.result = state.lastFinalAnswer;
+    if (!session.depth && state.goalContexts.size) session.loop = { kind: 'goal', iteration: state.goalContexts.size };
     const collaboration = state.collaboration.finalize(session.collaboration.retainedAgents);
     session.collaboration.spawns = collaboration.spawns;
     session.collaboration.communications = collaboration.communications;
+    session.executions = state.executionTracker.finalize();
     const windowInfo = modelContextWindow('codex', session.model, state.observedWindow);
     session.context = contextInfo(session.turnUsage.total || session.turnUsage.input, windowInfo);
 
     if (session.status !== 'failed') {
       const turnAge = Date.now() - fileInfo.mtimeMs;
-      if (state.activeTurn && turnAge < STALE_TURN_THRESHOLD_MS) {
+      const pendingUserInput = state.pendingUserInputCalls.size > 0;
+      const conversationalInput = state.lastConversationRole === 'assistant'
+        && assistantRequestsUserResponse(state.lastAssistantText || state.lastFinalAnswer)
+        && (state.lastTurnCompleted || turnAge >= ACTIVE_THRESHOLD_MS);
+      if (!session.depth && (pendingUserInput || conversationalInput)) {
+        session.status = 'waiting';
+        session.statusDetail = pendingUserInput ? '선택 또는 입력 대기' : '답변 또는 선택 대기';
+        session.statusObserved = true;
+      } else if (state.activeTurn && turnAge < STALE_TURN_THRESHOLD_MS) {
         session.status = 'running';
         session.statusDetail = '턴 실행 중';
         session.statusObserved = true;

package/src/agentMonitor/executionActivity.js

@@ -0,0 +1,282 @@
+'use strict';
+
+const SHELL_TOOLS = new Set([
+  'bash',
+  'cmd',
+  'exec_command',
+  'powershell',
+  'pwsh',
+  'shell',
+  'shell_command',
+  'terminal',
+]);
+
+const CONTINUATION_TOOLS = new Set([
+  'bashoutput',
+  'taskoutput',
+  'wait',
+  'write_stdin',
+]);
+
+function toolName(value) {
+  return String(value || '').trim().toLowerCase().split(/[.:/]/).filter(Boolean).pop() || '';
+}
+
+function outputText(value, seen = new Set()) {
+  if (typeof value === 'string') return value;
+  if (value == null || typeof value === 'number' || typeof value === 'boolean') return value == null ? '' : String(value);
+  if (seen.has(value)) return '';
+  if (typeof value !== 'object') return '';
+  seen.add(value);
+  if (Array.isArray(value)) return value.map(item => outputText(item, seen)).filter(Boolean).join('\n');
+  return [
+    value.text,
+    value.input_text,
+    value.output_text,
+    value.message,
+    value.content,
+    value.output,
+    value.error,
+  ].map(item => outputText(item, seen)).filter(Boolean).join('\n');
+}
+
+function quotedProperty(source, key) {
+  const pattern = new RegExp(`\\b${key}\\s*:\\s*("(?:\\\\.|[^"\\\\])*"|'(?:\\\\.|[^'\\\\])*'|\`(?:\\\\.|[^\`\\\\])*\`)`, 'm');
+  const match = String(source || '').match(pattern);
+  if (!match) return '';
+  const literal = match[1];
+  if (literal.startsWith('"')) {
+    try {
+      return JSON.parse(literal);
+    } catch (_invalidStringLiteral) {
+      return literal.slice(1, -1);
+    }
+  }
+  return literal.slice(1, -1)
+    .replace(/\\([\\'`])/g, '$1')
+    .replace(/\\n/g, '\n')
+    .replace(/\\r/g, '\r')
+    .replace(/\\t/g, '\t');
+}
+
+function booleanProperty(source, key) {
+  const match = String(source || '').match(new RegExp(`\\b${key}\\s*:\\s*(true|false)`, 'i'));
+  return match ? match[1].toLowerCase() === 'true' : null;
+}
+
+function scalarProperty(source, key) {
+  const quoted = quotedProperty(source, key);
+  if (quoted) return quoted;
+  const match = String(source || '').match(new RegExp(`\\b${key}\\s*:\\s*([A-Za-z0-9._:-]+)`, 'i'));
+  return match ? match[1] : '';
+}
+
+function nestedToolName(name, rawInput) {
+  const normalizedName = toolName(name);
+  if (normalizedName !== 'exec') return normalizedName;
+  const match = String(rawInput || '').match(/tools\.(exec_command|write_stdin|wait)\s*\(/);
+  return match ? match[1] : normalizedName;
+}
+
+function executionInput(name, args = {}, rawInput = '') {
+  const normalizedName = toolName(name);
+  const source = String(rawInput || '');
+  const nestedExec = normalizedName === 'exec' && /tools\.exec_command\s*\(/.test(source);
+  const shell = SHELL_TOOLS.has(normalizedName) || nestedExec;
+  const runInBackground = args.run_in_background === true
+    || args.background === true
+    || args.detach === true
+    || booleanProperty(source, 'run_in_background') === true
+    || booleanProperty(source, 'background') === true;
+  if (!shell && !runInBackground) return null;
+  if (/^(?:task|agent|spawn_agent)$/.test(normalizedName)) return null;
+  const command = args.command || args.cmd || args.script
+    || quotedProperty(source, 'cmd') || quotedProperty(source, 'command');
+  const cwd = args.workdir || args.cwd
+    || quotedProperty(source, 'workdir') || quotedProperty(source, 'cwd');
+  const description = args.description || quotedProperty(source, 'description');
+  return {
+    kind: shell ? 'shell' : 'background',
+    mode: runInBackground ? 'background' : 'foreground',
+    command: String(command || ''),
+    cwd: String(cwd || ''),
+    description: String(description || ''),
+    tool: nestedExec ? 'exec_command' : normalizedName,
+  };
+}
+
+function runtimeLabel(activity) {
+  const value = `${activity.tool || ''} ${activity.command || ''}`.toLowerCase();
+  if (/\bpowershell\b|\bpwsh\b/.test(value)) return 'PowerShell';
+  if (/\bcmd(?:\.exe)?\b/.test(value)) return 'Command Prompt';
+  if (/\bbash\b/.test(value)) return 'Bash';
+  return activity.kind === 'shell' ? 'Shell' : 'Background';
+}
+
+function firstCommandLine(value, fallback = '') {
+  return String(value || '').split(/\r?\n/).map(line => line.trim()).find(Boolean) || fallback;
+}
+
+function runtimeHandle(value) {
+  const text = outputText(value);
+  const patterns = [
+    { type: 'cell', pattern: /(?:cell(?:\s+id)?|cell_id)[\s:=`"']+([A-Za-z0-9._:-]+)/i },
+    { type: 'session', pattern: /(?:session(?:\s+id)?|session_id)[\s:=`"']+([A-Za-z0-9._:-]+)/i },
+    { type: 'task', pattern: /(?:background(?:\s+(?:task|command))?(?:\s+with)?(?:\s+id)?|task_id)[\s:=`"']+([A-Za-z0-9._:-]+)/i },
+  ];
+  for (const candidate of patterns) {
+    const match = text.match(candidate.pattern);
+    if (match) return { type: candidate.type, id: match[1].replace(/[.,;]+$/, '') };
+  }
+  return null;
+}
+
+function handleFromArgs(args = {}) {
+  const values = [
+    ['cell', args.cell_id || args.cellId],
+    ['session', args.session_id || args.sessionId],
+    ['task', args.task_id || args.taskId || args.bash_id || args.shell_id],
+  ];
+  const found = values.find(([, value]) => value != null && String(value));
+  return found ? { type: found[0], id: String(found[1]) } : null;
+}
+
+function exitCode(value) {
+  const text = outputText(value);
+  const match = text.match(/^\s*(?:exit\s+code|exit_code)\s*[:=]\s*(-?\d+)\b/im)
+    || text.match(/\b(?:process|command)\s+exited\s+with\s+(?:exit\s+)?code\s+(-?\d+)\b/i);
+  return match ? Number(match[1]) : null;
+}
+
+function outputStatus(value, explicitError = false) {
+  const text = outputText(value);
+  const firstLine = text.split(/\r?\n/).map(line => line.trim().toLowerCase()).find(Boolean) || '';
+  if (firstLine.startsWith('script failed')) return 'failed';
+  if (firstLine.startsWith('script completed')) return 'completed';
+  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';
+  return 'completed';
+}
+
+function createExecutionTracker(options = {}) {
+  const compactText = options.compactText || (value => String(value || ''));
+  const timestamp = options.timestamp || (value => value || null);
+  const activities = [];
+  const byCallId = new Map();
+  const byHandle = new Map();
+  const continuations = new Map();
+
+  function registerHandle(activity, handle) {
+    if (!activity || !handle || !handle.id) return;
+    activity.backgroundId = handle.id;
+    activity.backgroundIdType = handle.type;
+    activity.mode = 'background';
+    byHandle.set(`${handle.type}:${handle.id}`, activity);
+    byHandle.set(handle.id, activity);
+  }
+
+  function recordCall({ name, callId, args = {}, rawInput = '', at }) {
+    const normalizedName = nestedToolName(name, rawInput);
+    const effectiveArgs = args && typeof args === 'object' && !Array.isArray(args) ? { ...args } : {};
+    if (normalizedName === 'wait' && !effectiveArgs.cell_id) effectiveArgs.cell_id = scalarProperty(rawInput, 'cell_id');
+    if (normalizedName === 'write_stdin' && !effectiveArgs.session_id) effectiveArgs.session_id = scalarProperty(rawInput, 'session_id');
+    if (CONTINUATION_TOOLS.has(normalizedName)) {
+      continuations.set(String(callId || ''), { name: normalizedName, args: effectiveArgs });
+      return null;
+    }
+    const input = executionInput(normalizedName, effectiveArgs, rawInput);
+    if (!input) return null;
+    const startedAt = timestamp(at, null);
+    const activity = {
+      id: String(callId || `execution:${activities.length}`),
+      callId: String(callId || ''),
+      kind: input.kind,
+      mode: input.mode,
+      tool: input.tool,
+      runtime: '',
+      label: compactText(input.description || firstCommandLine(input.command, input.kind === 'shell' ? '셸 명령' : '백그라운드 작업'), 180),
+      command: compactText(input.command, 1200),
+      cwd: compactText(input.cwd, 360),
+      status: 'running',
+      statusDetail: input.mode === 'background' ? '백그라운드 실행 시작' : '포그라운드 실행 시작',
+      output: '',
+      backgroundId: '',
+      backgroundIdType: '',
+      exitCode: null,
+      startedAt,
+      updatedAt: startedAt,
+      completedAt: null,
+      source: 'tool-call',
+    };
+    activity.runtime = runtimeLabel(activity);
+    activities.push(activity);
+    if (activity.callId) byCallId.set(activity.callId, activity);
+    const requestedHandle = handleFromArgs(effectiveArgs);
+    if (requestedHandle) registerHandle(activity, requestedHandle);
+    return activity;
+  }
+
+  function findContinuation(args = {}) {
+    const handle = handleFromArgs(args);
+    if (handle) return byHandle.get(`${handle.type}:${handle.id}`) || byHandle.get(handle.id) || null;
+    return [...activities].reverse().find(activity => activity.mode === 'background' && activity.status === 'running') || null;
+  }
+
+  function recordOutput({ name, callId, args = {}, output, at, isError = false }) {
+    const pendingContinuation = continuations.get(String(callId || ''));
+    const normalizedName = pendingContinuation && pendingContinuation.name || toolName(name);
+    const effectiveArgs = pendingContinuation && pendingContinuation.args || args;
+    const continuation = CONTINUATION_TOOLS.has(normalizedName);
+    const activity = continuation ? findContinuation(effectiveArgs) : byCallId.get(String(callId || ''));
+    if (!activity) {
+      continuations.delete(String(callId || ''));
+      return null;
+    }
+    const status = outputStatus(output, isError);
+    const observedOutput = compactText(outputText(output), 2400);
+    const argumentHandle = handleFromArgs(effectiveArgs);
+    const handle = argumentHandle || (status === 'running' ? runtimeHandle(output) : null);
+    if (handle && (status === 'running' || continuation || activity.mode === 'background')) registerHandle(activity, handle);
+    const code = exitCode(output);
+    activity.status = status;
+    if (observedOutput) {
+      activity.output = continuation && activity.output
+        ? compactText(`${activity.output}\n${observedOutput}`, 2400)
+        : observedOutput;
+    }
+    activity.exitCode = code;
+    activity.updatedAt = timestamp(at, activity.updatedAt);
+    if (status === 'running') {
+      activity.mode = 'background';
+      activity.statusDetail = handle && handle.id
+        ? `백그라운드 ${handle.type} ${handle.id}`
+        : '백그라운드에서 계속 실행 중';
+    } else {
+      activity.completedAt = activity.updatedAt;
+      activity.statusDetail = status === 'failed'
+        ? (code == null ? '실행 실패' : `종료 코드 ${code}`)
+        : (code == null ? '실행 완료' : `종료 코드 ${code}`);
+    }
+    continuations.delete(String(callId || ''));
+    return activity;
+  }
+
+  function finalize(limit = 120) {
+    return activities.slice(-limit).map(activity => ({ ...activity }));
+  }
+
+  return { activities, recordCall, recordOutput, finalize };
+}
+
+module.exports = {
+  CONTINUATION_TOOLS,
+  SHELL_TOOLS,
+  createExecutionTracker,
+  executionInput,
+  outputStatus,
+  outputText,
+  runtimeHandle,
+  toolName,
+};