loadtoagent 1.1.0 → 1.3.1

package/src/agentMonitor/genericParser.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const path = require('path');
+const { createExecutionTracker } = require('./executionActivity');
 
 const TOOL_START_PATTERN = /tool_use|tool-call|tool_start/;
 const TOOL_END_PATTERN = /tool_result|tool-result|tool_end/;
@@ -22,6 +23,8 @@ function createGenericParser(dependencies) {
     sumUsage,
     timestamp,
     trimSession,
+    assistantRequestsUserResponse,
+    isUserInputTool,
   } = dependencies;
 
   function normalizeUsage(raw = {}) {
@@ -72,6 +75,7 @@ function createGenericParser(dependencies) {
     const session = baseSession(provider, externalId, fileInfo.file, fileInfo);
     session.truncated = parsed.truncated;
     session.cwd = root.cwd || root.projectPath || root.project_path || '';
+    session.originCwd = session.cwd;
     session.model = root.model || root.modelId || '';
     session.startedAt = timestamp(root.startTime || root.startedAt || root.created_at, session.updatedAt);
     session.parentId = root.parent_session_id ? `${provider}:${root.parent_session_id}` : null;
@@ -79,8 +83,12 @@ function createGenericParser(dependencies) {
     return { rows, root, session };
   }
 
-  function recordToolStart(session, event) {
+  function recordToolStart(session, state, event) {
     const tool = event.tool_name || event.name || event.tool || 'tool';
+    const callId = event.tool_call_id || event.tool_use_id || event.id;
+    const args = event.parameters || event.args || event.input || {};
+    state.toolCalls.set(String(callId || ''), { name: tool, args });
+    state.executionTracker.recordCall({ name: tool, callId, args, rawInput: args, at: event.timestamp });
     addMessage(session, {
       id: event.id,
       role: 'tool',
@@ -99,8 +107,17 @@ function createGenericParser(dependencies) {
     });
   }
 
-  function recordToolEnd(session, event) {
+  function recordToolEnd(session, state, event) {
     const callId = event.tool_call_id || event.tool_use_id || event.id;
+    const call = state.toolCalls.get(String(callId || ''));
+    state.executionTracker.recordOutput({
+      name: call && call.name,
+      callId,
+      args: call && call.args || {},
+      output: event.output || event.result || event.content || event,
+      at: event.timestamp,
+      isError: Boolean(event.error),
+    });
     settleLifecycle(session, callId, event.error ? 'failed' : 'done', event.timestamp);
     addLifecycle(session, {
       id: `result:${event.id || event.tool_call_id}`,
@@ -112,7 +129,13 @@ function createGenericParser(dependencies) {
   }
 
   function processEvents(session, events) {
-    const state = { running: false, failed: false };
+    const state = {
+      running: false,
+      failed: false,
+      pendingUserInputCalls: new Set(),
+      toolCalls: new Map(),
+      executionTracker: createExecutionTracker({ compactText, timestamp }),
+    };
     for (const event of events) {
       const type = String(event.type || event.event || event.kind || '').toLowerCase();
       if (type === 'init') {
@@ -127,10 +150,15 @@ function createGenericParser(dependencies) {
         });
       }
       if (TOOL_START_PATTERN.test(type)) {
-        recordToolStart(session, event);
+        recordToolStart(session, state, event);
         state.running = true;
+        const toolName = event.tool_name || event.name || event.tool;
+        if (isUserInputTool(toolName)) state.pendingUserInputCalls.add(String(event.id || toolName));
+      }
+      if (TOOL_END_PATTERN.test(type)) {
+        recordToolEnd(session, state, event);
+        state.pendingUserInputCalls.delete(String(event.tool_call_id || event.tool_use_id || event.id || ''));
       }
-      if (TOOL_END_PATTERN.test(type)) recordToolEnd(session, event);
       if (type === 'result' || /session_end|completed/.test(type)) state.running = false;
       if (type === 'error' || event.error) state.failed = true;
       const usage = normalizeUsage(event);
@@ -194,10 +222,17 @@ function createGenericParser(dependencies) {
         usages.push(usage);
       }
     }
-    [...messages.values()]
-      .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || a.order - b.order)
-      .forEach(message => addMessage(session, message));
-    return { firstUser, usages };
+    const orderedMessages = [...messages.values()]
+      .sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || a.order - b.order);
+    orderedMessages.forEach(message => addMessage(session, message));
+    const lastConversation = [...orderedMessages].reverse()
+      .find(message => message.role === 'assistant' || message.role === 'user');
+    return {
+      firstUser,
+      usages,
+      lastConversationRole: lastConversation && lastConversation.role || '',
+      lastAssistantText: lastConversation && lastConversation.role === 'assistant' ? lastConversation.text : '',
+    };
   }
 
   function finalizeSession(session, provider, root, eventState, messageState, fileInfo) {
@@ -208,15 +243,23 @@ function createGenericParser(dependencies) {
     const context = modelContextWindow(provider, session.model, root.context_window || root.contextWindow);
     session.context = contextInfo(session.turnUsage.total || session.usage.total, context);
     const age = Date.now() - fileInfo.mtimeMs;
+    const pendingUserInput = eventState.pendingUserInputCalls.size > 0;
+    const conversationalInput = messageState.lastConversationRole === 'assistant'
+      && assistantRequestsUserResponse(messageState.lastAssistantText);
     session.status = eventState.failed
       ? 'failed'
-      : ((eventState.running && age < STALE_TURN_THRESHOLD_MS) || age < ACTIVE_THRESHOLD_MS
+      : (pendingUserInput || (!eventState.running && conversationalInput)
+        ? 'waiting'
+        : ((eventState.running && age < STALE_TURN_THRESHOLD_MS) || age < ACTIVE_THRESHOLD_MS
         ? 'running'
-        : 'idle');
+        : 'idle'));
     session.statusDetail = eventState.failed
       ? '오류 발생'
-      : (session.status === 'running' ? '실시간 이벤트 수신 중' : '다음 요청 대기');
-    session.statusObserved = eventState.running;
+      : (session.status === 'waiting'
+        ? (pendingUserInput ? '선택 또는 입력 대기' : '답변 또는 선택 대기')
+        : (session.status === 'running' ? '실시간 이벤트 수신 중' : '다음 요청 대기'));
+    session.statusObserved = eventState.running || session.status === 'waiting';
+    session.executions = eventState.executionTracker.finalize();
     trimSession(session);
     return session;
   }

package/src/agentMonitor/hierarchy.js

@@ -18,6 +18,22 @@ function createHierarchyAttacher(dependencies) {
       const parent = byId.get(session.parentId);
       if (parent && !parent.childIds.includes(session.id)) parent.childIds.push(session.id);
     }
+    const inheritOrigin = (session, seen = new Set()) => {
+      if (!session || !session.parentId || seen.has(session.id)) return;
+      seen.add(session.id);
+      const parent = byId.get(session.parentId);
+      if (!parent) return;
+      inheritOrigin(parent, seen);
+      const hadOrigin = Boolean(session.originCwd || session.cwd);
+      if (!session.cwd) session.cwd = parent.cwd;
+      if (!session.originCwd) session.originCwd = parent.originCwd || parent.cwd;
+      if (!hadOrigin) {
+        session.workspace = parent.workspace;
+        session.projectless = parent.projectless;
+      }
+      if (!session.environment) session.environment = parent.environment;
+    };
+    for (const session of sessions) inheritOrigin(session);
     return byId;
   }
 
@@ -57,6 +73,7 @@ function createHierarchyAttacher(dependencies) {
     child.clientKind = parent.clientKind;
     child.model = parent.model;
     child.cwd = parent.cwd;
+    child.originCwd = parent.originCwd || parent.cwd;
     child.workspace = parent.workspace;
     child.projectless = parent.projectless;
     child.environment = parent.environment;

package/src/agentMonitor/responseIntent.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const USER_INPUT_TOOL_PATTERN = /^(?:request_user_input|ask_user_question|askuserquestion|request_input|get_user_input)$/i;
+
+function isUserInputTool(name) {
+  return USER_INPUT_TOOL_PATTERN.test(String(name || '').trim());
+}
+
+function conversationalTail(value) {
+  const text = String(value || '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/~~~[\s\S]*?~~~/g, ' ')
+    .replace(/`[^`\r\n]*`/g, ' ')
+    .replace(/^\s*>.*$/gm, ' ')
+    .replace(/!?(?:\[[^\]]*\])\([^\s)]+(?:\s+"[^"]*")?\)/g, '$1')
+    .replace(/https?:\/\/\S+/g, ' ')
+    .replace(/[ \t]+/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+  return text.slice(-1600).trim();
+}
+
+function assistantRequestsUserResponse(value) {
+  const tail = conversationalTail(value);
+  if (!tail) return false;
+
+  // A question at the end of the final prose is the strongest provider-neutral signal.
+  if (/[?？]\s*(?:["')\]}>*_~]|>)*\s*$/.test(tail)) return true;
+
+  const koreanRequest = /(?:선택|골라|알려|말씀|답변|확인|결정|지정|입력|보내|첨부|업로드|제공)(?:해|하여|해서|해\s*)?(?:주세요|주십시오|주실래요|바랍니다)(?:[.!:：]|\s|$)/.test(tail);
+  const englishRequest = [
+    // A polite request may follow introductory prose, so "please"/"kindly"
+    // is a strong signal wherever it appears.
+    /\b(?:please|kindly)\s+(?:choose|select|confirm|tell\s+me|let\s+me\s+know|provide|send|share|enter|upload|attach)\b/i,
+    // Bare imperatives are requests only at the beginning of prose or a new
+    // sentence. This avoids treating technical words such as "resend" or a
+    // Korean completion report containing "attach" as user-input requests.
+    /(?:^|[\r\n]+|[.!?]\s+)\s*(?:choose|select|confirm|tell\s+me|let\s+me\s+know|provide|send|share|enter|upload|attach)\b/i,
+    /(?:^|[\r\n]+|[.!?]\s+)\s*(?:can|could|would|will)\s+you\s+(?:choose|select|confirm|provide|send|share|enter|upload|attach)\b/i,
+  ].some(pattern => pattern.test(tail));
+  const chineseRequest = /(?:请选择|请确认|请提供|请告诉|请回复|请上传)/.test(tail);
+  const directRequest = koreanRequest || englishRequest || chineseRequest;
+  if (!directRequest) return false;
+
+  // Ignore common courtesy offers that do not block the task.
+  if (/(?:궁금한|추가 질문|도움이 필요).{0,30}(?:알려|말씀).{0,12}주세요[.!]?$/i.test(tail)) return false;
+  if (/let me know if (?:you have|there are) (?:any )?(?:questions|issues)[.!]?$/i.test(tail)) return false;
+  return true;
+}
+
+module.exports = { assistantRequestsUserResponse, isUserInputTool };

package/src/agentMonitor.js

@@ -14,6 +14,7 @@ const { createCodexParser } = require('./agentMonitor/codexParser');
 const { createClaudeParser } = require('./agentMonitor/claudeParser');
 const { createGenericParser } = require('./agentMonitor/genericParser');
 const { createHierarchyAttacher } = require('./agentMonitor/hierarchy');
+const { assistantRequestsUserResponse, isUserInputTool } = require('./agentMonitor/responseIntent');
 const {
   MAX_FILES_PER_PROVIDER,
   readJson,
@@ -178,10 +179,12 @@ function baseSession(provider, externalId, file, stat) {
     title: '제목을 불러오는 중',
     model: '',
     cwd: '',
+    originCwd: '',
     branch: '',
     source: 'local-history',
     sourceLabel: '로컬 세션',
     clientKind: '',
+    utilityKind: '',
     status: 'idle',
     statusDetail: '',
     statusObserved: false,
@@ -198,6 +201,7 @@ function baseSession(provider, externalId, file, stat) {
     context: { used: 0, window: 0, percent: 0, source: 'unknown' },
     messages: [],
     lifecycle: [],
+    executions: [],
     childIds: [],
     collaboration: {
       capacity: { totalThreads: 0, subagents: 0, source: 'unknown' },
@@ -207,6 +211,7 @@ function baseSession(provider, externalId, file, stat) {
       retainedObserved: false,
       metrics: null,
     },
+    loop: null,
   };
 }
 
@@ -234,6 +239,8 @@ const parseClaude = createClaudeParser({
   sumUsage,
   timestamp,
   trimSession,
+  assistantRequestsUserResponse,
+  isUserInputTool,
 });
 
 function codexUsage(raw = {}) {
@@ -258,6 +265,7 @@ function codexVisibleUserText(value) {
   if (objective) return compactText(objective[1], 6000);
   const desktopRequest = raw.match(/##\s*My request for Codex:\s*([\s\S]*?)(?:\n{2,}<image\b|$)/i);
   if (desktopRequest) return compactText(desktopRequest[1], 6000);
+  if (/^<(?:subagent_notification|task_notification|task-notification|agent_notification|collaboration_notification)(?:\s|>)/i.test(raw)) return '';
   if (/^<(?:permissions instructions|app-context|environment_context|skills_instructions|plugins_instructions|apps_instructions|multi_agent_mode|collaboration_mode)>/i.test(raw)) return '';
   if (/^<skill(?:\s|>)/i.test(raw)) return '';
   if (/^#\s*Codex desktop context/i.test(raw)) return '';
@@ -302,6 +310,7 @@ const parseCodex = createCodexParser({
   textOps: {
     agentEnvelope, codexContentText, codexVisibleUserText,
     compactText, encryptedCollaborationText, jsonObject,
+    assistantRequestsUserResponse, isUserInputTool,
   },
   collaborationOps: {
     collaborationCapacity, collaborationTaskName,
@@ -328,6 +337,8 @@ const parseGeneric = createGenericParser({
   sumUsage,
   timestamp,
   trimSession,
+  assistantRequestsUserResponse,
+  isUserInputTool,
 });
 
 function contextInfo(used, windowInfo) {
@@ -363,6 +374,7 @@ function parseManagedSession(runDir) {
     sourceLabel: 'LoadToAgent 실행',
     statusObserved: true,
   };
+  session.originCwd = session.originCwd || meta.cwd || session.cwd || '';
   session.usage = finalizeUsage(session.usage);
   session.turnUsage = finalizeUsage(session.turnUsage);
   const window = modelContextWindow(session.provider, session.model, session.context && session.context.window);
@@ -378,8 +390,9 @@ function workspaceLabel(cwd) {
 }
 
 function isProjectlessSession(session) {
-  if (!session || !session.cwd) return true;
-  const normalized = String(session.cwd).replace(/\\/g, '/').replace(/\/+$/, '');
+  const cwd = session && (session.originCwd || session.cwd);
+  if (!cwd) return true;
+  const normalized = String(cwd).replace(/\\/g, '/').replace(/\/+$/, '');
   return session.provider === 'codex'
     && session.clientKind === 'codex-desktop'
     && /(?:^|\/)Documents\/Codex\/\d{4}-\d{2}-\d{2}\/new-chat$/i.test(normalized);
@@ -528,6 +541,10 @@ class AgentMonitor extends EventEmitter {
             const value = this.parseFile(info, parser);
             if (!value) continue;
             const copy = structuredClone(value);
+            // Provider health checks and detached memory extraction turns are
+            // implementation details, not user work. Keep them out of the
+            // dashboard and runtime-link candidate pool entirely.
+            if (copy.utilityKind) continue;
             copy.environment = { kind: history.kind, distro: history.distro, label: history.label, home: history.home };
             if (history.kind === 'wsl') copy.sourceLabel = history.label;
             sessions.push(copy);
@@ -548,8 +565,9 @@ class AgentMonitor extends EventEmitter {
       for (const session of managed) byId.set(session.id, session);
       const merged = [...byId.values()]
         .map(session => {
+          const originCwd = session.originCwd || session.cwd || '';
           const projectless = isProjectlessSession(session);
-          return { ...session, projectless, workspace: projectless ? '프로젝트 없음' : workspaceLabel(session.cwd) };
+          return { ...session, originCwd, projectless, workspace: projectless ? '프로젝트 없음' : workspaceLabel(originCwd) };
         })
         .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
       attachHierarchy(merged);

package/src/agentRunner.js

@@ -385,7 +385,7 @@ class AgentRunner extends EventEmitter {
       if (run.stopping) {
         state.status = 'cancelled';
         state.statusDetail = '사용자가 중지함';
-      } else if (state.status === 'running' || state.status === 'starting') {
+      } else if (state.status === 'running' || state.status === 'starting' || state.status === 'paused') {
         state.status = code === 0 ? 'completed' : 'failed';
         state.statusDetail = code === 0 ? '작업 완료' : `CLI 종료 코드 ${code}${signal ? ` · ${signal}` : ''}`;
       }
@@ -450,10 +450,75 @@ class AgentRunner extends EventEmitter {
     if (process.platform === 'win32') {
       execFile('taskkill', ['/PID', String(run.child.pid), '/T', '/F'], { windowsHide: true }, () => {});
     } else {
+      if (run.state.status === 'paused') runBestEffort('runner-stop-resume', () => process.kill(run.child.pid, 'SIGCONT'));
       runBestEffort('runner-stop', () => run.child.kill('SIGTERM'));
     }
     return { ok: true };
   }
+
+  retry(id) {
+    const runIdValue = String(id || '');
+    if (!/^[a-z0-9-]{4,120}$/i.test(runIdValue)) return { ok: false, error: '다시 실행할 작업 ID가 올바르지 않습니다.' };
+    if (this.active.has(runIdValue)) return { ok: false, error: '아직 실행 중인 작업은 다시 실행할 수 없습니다.' };
+    const file = path.join(this.runsDir, runIdValue, 'meta.json');
+    let meta;
+    try {
+      meta = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch (_unavailableRunMetadata) {
+      return { ok: false, error: '이전 실행 설정을 찾을 수 없습니다.' };
+    }
+    const result = this.start({
+      provider: meta.provider,
+      prompt: meta.prompt,
+      cwd: meta.cwd,
+      model: meta.model,
+      allowWrites: Boolean(meta.allowWrites),
+    });
+    return result && result.ok ? { ...result, retriedFrom: runIdValue } : result;
+  }
+
+  setPaused(id, paused) {
+    const run = this.active.get(String(id || ''));
+    if (!run) return Promise.resolve({ ok: false, error: '실행 중인 작업을 찾을 수 없습니다.' });
+    if (paused && run.state.status === 'paused') return Promise.resolve({ ok: true, status: 'paused' });
+    if (!paused && run.state.status !== 'paused') return Promise.resolve({ ok: true, status: run.state.status });
+    const applyState = () => {
+      run.state.status = paused ? 'paused' : 'running';
+      run.state.statusDetail = paused ? '사용자가 실행을 일시정지함' : '사용자가 실행을 다시 시작함';
+      addLifecycle(run.state, paused ? 'process-pause' : 'process-resume', paused ? '실행 일시정지' : '실행 다시 시작', {
+        id: `${paused ? 'pause' : 'resume'}:${Date.now()}`,
+        status: paused ? 'done' : 'running',
+      });
+      run.state.updatedAt = new Date().toISOString();
+      this.persist(run);
+      this.emit('changed', { runId: run.id, state: run.state });
+      return { ok: true, status: run.state.status };
+    };
+    if (process.platform !== 'win32') {
+      try {
+        process.kill(run.child.pid, paused ? 'SIGSTOP' : 'SIGCONT');
+        return Promise.resolve(applyState());
+      } catch (error) {
+        return Promise.resolve({ ok: false, error: error.message });
+      }
+    }
+    const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+    const powershell = path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    const command = `${paused ? 'Suspend' : 'Resume'}-Process -Id ${Number(run.child.pid)} -ErrorAction Stop`;
+    return new Promise(resolve => {
+      execFile(powershell, ['-NoProfile', '-NonInteractive', '-Command', command], { windowsHide: true }, error => {
+        resolve(error ? { ok: false, error: error.message } : applyState());
+      });
+    });
+  }
+
+  pause(id) {
+    return this.setPaused(id, true);
+  }
+
+  resume(id) {
+    return this.setPaused(id, false);
+  }
 }
 
 module.exports = {

package/src/attentionNotifier.js

@@ -7,24 +7,28 @@ class AttentionNotifier {
     this.copy = options.copy || (() => ({ title: '내 확인이 필요합니다', body: '응답이나 선택을 기다리는 AI 세션이 있습니다.' }));
     this.onOpen = options.onOpen || (() => {});
     this.onFallback = options.onFallback || (() => {});
-    this.waitingIds = null;
+    this.attentionIds = null;
     this.notifications = new Set();
   }
 
   sync(snapshot) {
-    const waiting = (snapshot && Array.isArray(snapshot.sessions) ? snapshot.sessions : [])
-      .filter(session => session && session.id && session.status === 'waiting');
-    const nextIds = new Set(waiting.map(session => String(session.id)));
+    const needsAttention = (snapshot && Array.isArray(snapshot.sessions) ? snapshot.sessions : [])
+      .filter(session => session && session.id && (
+        session.attention?.required
+        || session.health?.level === 'critical'
+        || session.status === 'waiting'
+      ));
+    const nextIds = new Set(needsAttention.map(session => String(session.id)));
 
-    if (this.waitingIds === null) {
-      this.waitingIds = nextIds;
+    if (this.attentionIds === null) {
+      this.attentionIds = nextIds;
       return [];
     }
 
-    const newlyWaiting = waiting.filter(session => !this.waitingIds.has(String(session.id)));
-    this.waitingIds = nextIds;
-    newlyWaiting.forEach(session => this.notify(session));
-    return newlyWaiting.map(session => String(session.id));
+    const newlyActionable = needsAttention.filter(session => !this.attentionIds.has(String(session.id)));
+    this.attentionIds = nextIds;
+    newlyActionable.forEach(session => this.notify(session));
+    return newlyActionable.map(session => String(session.id));
   }
 
   notify(session) {