loadtoagent 1.0.0 → 1.3.1

package/src/monitorWorker.js

@@ -6,7 +6,9 @@ const path = require('path');
 const { AgentMonitor, buildSummary } = require('./agentMonitor');
 const { TmuxMonitor, linkAgentSessions } = require('./tmuxMonitor');
 const { ProcessMonitor, applyRuntimePresence } = require('./processMonitor');
+const { scanCodexAutomationHomes } = require('./automationMonitor');
 const { reportRecoverableError } = require('./diagnostics');
+const { enrichSession } = require('./sessionIntelligence');
 
 const tmuxMonitor = new TmuxMonitor();
 tmuxMonitor.scan();
@@ -130,6 +132,30 @@ function cardCollaboration(value) {
   };
 }
 
+function cardExecutions(value) {
+  return (value || []).slice(-120).map(activity => ({
+    id: activity.id,
+    callId: activity.callId,
+    kind: activity.kind,
+    mode: activity.mode,
+    tool: clip(activity.tool, 80),
+    runtime: clip(activity.runtime, 80),
+    label: clip(activity.label, 180),
+    command: clip(activity.command, 1200),
+    cwd: clip(activity.cwd, 360),
+    status: activity.status,
+    statusDetail: clip(activity.statusDetail, 180),
+    output: clip(activity.output, 2400),
+    backgroundId: clip(activity.backgroundId, 180),
+    backgroundIdType: clip(activity.backgroundIdType, 40),
+    exitCode: activity.exitCode == null ? null : Number(activity.exitCode),
+    startedAt: activity.startedAt,
+    updatedAt: activity.updatedAt,
+    completedAt: activity.completedAt,
+    source: activity.source,
+  }));
+}
+
 function cardSession(session) {
   return {
     id: session.id,
@@ -146,6 +172,7 @@ function cardSession(session) {
     title: clip(session.title, 180),
     model: session.model,
     cwd: session.cwd,
+    originCwd: session.originCwd || session.cwd,
     branch: session.branch,
     workspace: session.workspace,
     projectless: Boolean(session.projectless),
@@ -179,25 +206,44 @@ function cardSession(session) {
     context: session.context,
     childIds: session.childIds,
     runtimePresence: session.runtimePresence || [],
+    loop: session.loop && typeof session.loop === 'object' ? {
+      kind: clip(session.loop.kind, 40),
+      iteration: Math.max(0, Number(session.loop.iteration || 0)),
+      phase: clip(session.loop.phase, 40),
+    } : (session.loop === true ? true : null),
     collaboration: cardCollaboration(session.collaboration),
+    executions: cardExecutions(session.executions),
+    attention: session.attention,
+    progress: session.progress,
+    health: session.health,
+    controlCapabilities: session.controlCapabilities,
+    evidence: session.evidence,
+    outcome: session.outcome,
     messages: selectCardMessages(session.messages),
     lifecycle: (session.lifecycle || []).slice(-2).map(cardLifecycle),
   };
 }
 
-function fingerprint(snapshot, tmux) {
+function fingerprint(snapshot, tmux, automations) {
   const sessions = snapshot.sessions.map(session => [
     session.id,
     session.updatedAt,
     session.status,
     session.usage && session.usage.total,
     session.context && session.context.used,
+    session.originCwd,
     session.workspace,
     Boolean(session.projectless),
+    session.loop && `${session.loop.kind || ''}:${session.loop.iteration || 0}:${session.loop.phase || ''}`,
     session.childIds && session.childIds.length,
     session.collaboration && session.collaboration.metrics && Object.values(session.collaboration.metrics).join(':'),
     session.collaboration && session.collaboration.communications && session.collaboration.communications.length,
     session.collaboration && session.collaboration.communications && session.collaboration.communications.at(-1) && session.collaboration.communications.at(-1).id,
+    (session.executions || []).map(activity => `${activity.id}:${activity.status}:${activity.mode}:${activity.backgroundId || ''}:${activity.updatedAt || ''}`).join(','),
+    session.attention && `${session.attention.kind}:${session.attention.required}`,
+    session.progress && `${session.progress.stage}:${session.progress.percent}:${session.progress.currentStep}`,
+    session.health && `${session.health.level}:${session.health.signals.map(signal => signal.code).join(',')}`,
+    session.outcome && `${session.outcome.status}:${session.outcome.artifacts.length}:${session.outcome.checks.length}`,
     (session.runtimePresence || []).map(item => `${item.id}:${item.pid}:${item.terminalId || ''}`).join(','),
   ]);
   const tmuxState = (tmux.distros || []).flatMap(distro => (distro.sessions || []).flatMap(tmuxSession => (tmuxSession.windows || []).flatMap(window => (window.panes || []).map(pane => [
@@ -214,21 +260,32 @@ function fingerprint(snapshot, tmux) {
     pane.agent && pane.agent.linkedSessionId,
     pane.agent && pane.agent.updatedAt,
   ]))));
-  return JSON.stringify([sessions, tmuxState]);
+  const automationState = (automations || []).map(item => [
+    item.id, item.name, item.status, item.rrule, item.nextRunAt, item.updatedAt, (item.cwds || []).join('|'),
+  ]);
+  return JSON.stringify([Math.floor(Date.now() / 60_000), sessions, tmuxState, automationState]);
 }
 
 monitor.on('snapshot', snapshot => {
   const tmuxBase = tmuxMonitor.scan();
-  monitor.setHistoryHomes(tmuxMonitor.historyHomes());
+  const historyHomes = tmuxMonitor.historyHomes();
+  monitor.setHistoryHomes(historyHomes);
   const tmux = linkAgentSessions(tmuxBase, snapshot.sessions);
   const processSnapshot = processMonitor.scan();
-  const sessions = applyRuntimePresence(snapshot.sessions, tmux, processSnapshot, Date.now(), currentBridges);
+  const observedSessions = applyRuntimePresence(snapshot.sessions, tmux, processSnapshot, Date.now(), currentBridges);
+  const sessions = observedSessions.map(session => enrichSession(session, observedSessions, Date.now()));
+  const localKind = process.platform === 'win32' ? 'windows' : (process.platform === 'darwin' ? 'macos' : 'linux');
+  const automations = scanCodexAutomationHomes({
+    homes: [{ home: workerData.home, kind: localKind, distro: '', label: 'Local' }, ...historyHomes],
+    now: new Date(snapshot.generatedAt),
+  });
   const runtimeSnapshot = {
     generatedAt: snapshot.generatedAt,
     sessions,
+    automations,
     summary: buildSummary(sessions, monitor.availability),
   };
-  const nextFingerprint = fingerprint(runtimeSnapshot, tmux);
+  const nextFingerprint = fingerprint(runtimeSnapshot, tmux, automations);
   if (nextFingerprint === lastFingerprint) return;
   lastFingerprint = nextFingerprint;
   lastPublishedSessions = sessions;
@@ -237,6 +294,7 @@ monitor.on('snapshot', snapshot => {
     snapshot: {
       generatedAt: snapshot.generatedAt,
       sessions: sessions.map(cardSession),
+      automations,
       summary: runtimeSnapshot.summary,
       tmux,
       runtime: {
@@ -260,9 +318,10 @@ parentPort.on('message', message => {
   if (message.type === 'detail') {
     const runtime = lastPublishedSessions.find(item => item.id === message.sessionId) || null;
     const stored = (monitor.lastSnapshot.sessions || []).find(item => item.id === message.sessionId) || null;
-    const session = stored && runtime
+    const merged = stored && runtime
       ? { ...stored, status: runtime.status, statusDetail: runtime.statusDetail, statusObserved: runtime.statusObserved, runtimePresence: runtime.runtimePresence || [] }
       : (stored || runtime);
+    const session = enrichSession(merged, lastPublishedSessions, Date.now());
     parentPort.postMessage({ type: 'detail-result', requestId: message.requestId, session });
   }
   if (message.type === 'stop') {

package/src/platformPath.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function unique(items) {
+  return [...new Set(items.filter(Boolean))];
+}
+
+function versionParts(value) {
+  const match = String(value || '').match(/^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?$/);
+  return match ? match.slice(1).map(part => Number(part || 0)) : null;
+}
+
+function compareVersionNames(left, right) {
+  const a = versionParts(left) || [0, 0, 0];
+  const b = versionParts(right) || [0, 0, 0];
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return b[index] - a[index];
+  }
+  return 0;
+}
+
+function resolveNvmDefault(home, fileSystem = fs) {
+  const aliasRoot = path.join(home, '.nvm', 'alias');
+  let value = 'default';
+  const visited = new Set();
+  for (let depth = 0; depth < 6; depth += 1) {
+    if (/^v?\d+(?:\.\d+){0,2}$/.test(value)) return value.replace(/^v/, '');
+    if (value === 'node' || value === 'stable') return '';
+    if (!/^[A-Za-z0-9*._/-]+$/.test(value) || value.includes('..') || visited.has(value)) return '';
+    visited.add(value);
+    try {
+      value = String(fileSystem.readFileSync(path.join(aliasRoot, value), 'utf8')).trim();
+    } catch (_missingAlias) {
+      return '';
+    }
+  }
+  return '';
+}
+
+function preferredNvmBin(home, fileSystem = fs) {
+  const versionsRoot = path.join(home, '.nvm', 'versions', 'node');
+  let versions = [];
+  try {
+    versions = fileSystem.readdirSync(versionsRoot, { withFileTypes: true })
+      .filter(entry => entry.isDirectory() && versionParts(entry.name))
+      .map(entry => entry.name)
+      .sort(compareVersionNames);
+  } catch (_missingNvm) {
+    return '';
+  }
+  const selector = resolveNvmDefault(home, fileSystem);
+  const selectorParts = selector ? selector.split('.') : [];
+  const selected = versions.find(version => {
+    if (!selectorParts.length) return true;
+    const parts = String(version).replace(/^v/, '').split('.');
+    return selectorParts.every((part, index) => parts[index] === part);
+  });
+  return selected ? path.join(versionsRoot, selected, 'bin') : '';
+}
+
+function macPathEntries(home, pathValue = '', fileSystem = fs) {
+  const existing = String(pathValue || '').split(path.delimiter).filter(Boolean);
+  return unique([
+    ...existing,
+    preferredNvmBin(home, fileSystem),
+    path.join(home, '.volta', 'bin'),
+    path.join(home, '.local', 'share', 'mise', 'shims'),
+    path.join(home, '.asdf', 'shims'),
+    path.join(home, '.local', 'bin'),
+    path.join(home, '.cargo', 'bin'),
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    '/usr/local/bin',
+    '/usr/local/sbin',
+  ]);
+}
+
+module.exports = { macPathEntries, preferredNvmBin, resolveNvmDefault };

package/src/processMonitor.js

@@ -61,7 +61,9 @@ function providerFromWindowsProcess(processInfo = {}) {
   const args = commandLine.toLowerCase().replace(/\\/g, '/');
   if (name === 'claude.exe') {
     if (args.includes('/windowsapps/claude_') || args.includes('--type=')) return null;
-    if (/^(?:"?[a-z]:)?[^\r\n]*\/\.local\/bin\/claude\.exe"?\s*$/i.test(args) || /^claude(?:\.exe)?\s*$/i.test(args)) return 'claude';
+    if (/\bdaemon\s+run\b/i.test(args)) return null;
+    if (/^(?:"?[a-z]:)?[^\r\n]*\/\.local\/bin\/claude\.exe"?(?:\s|$)/i.test(args)
+      || /^claude(?:\.exe)?(?:\s|$)/i.test(args)) return 'claude';
     return null;
   }
   if (name === 'codex.exe') {
@@ -81,7 +83,7 @@ function providerFromWindowsProcess(processInfo = {}) {
 function providerFromPosixProcess(processInfo = {}) {
   const name = String(processInfo.name || processInfo.command || '').toLowerCase().split('/').pop();
   const args = String(processInfo.commandLine || processInfo.args || '').toLowerCase();
-  if (name === 'claude') return /--type=|\/applications\/claude\.app/.test(args) ? null : 'claude';
+  if (name === 'claude') return /--type=|\/applications\/claude\.app|\bdaemon\s+run\b/.test(args) ? null : 'claude';
   if (name === 'codex' || /^codex-/.test(name)) return /\bapp-server\b|\/applications\/(?:chatgpt|codex)\.app/.test(args) ? null : 'codex';
   if (name === 'gemini') return 'gemini';
   if (name === 'grok') return 'grok';
@@ -129,10 +131,39 @@ function processRows(value) {
   })).filter(item => item.pid > 0);
 }
 
+function commandArgument(commandLine, name) {
+  const escaped = String(name || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = String(commandLine || '').match(new RegExp(`(?:^|\\s)${escaped}\\s+(?:"([^"]+)"|'([^']+)'|(\\S+))`, 'i'));
+  return match ? String(match[1] || match[2] || match[3] || '').trim() : '';
+}
+
+function processSessionExternalId(processInfo = {}, provider = '') {
+  const commandLine = String(processInfo.commandLine || processInfo.CommandLine || '');
+  if (provider === 'claude') {
+    const sessionId = commandArgument(commandLine, '--session-id');
+    if (sessionId) return pathlessSessionId(sessionId);
+    return pathlessSessionId(commandArgument(commandLine, '--resume'));
+  }
+  if (provider === 'codex') {
+    const match = commandLine.match(/(?:^|\s)resume\s+(?:--last\s+)?(?:"([^"]+)"|'([^']+)'|(\S+))/i);
+    return pathlessSessionId(match && (match[1] || match[2] || match[3]));
+  }
+  return '';
+}
+
+function pathlessSessionId(value) {
+  const text = String(value || '').trim().replace(/^"|"$/g, '');
+  if (!text) return '';
+  const basename = text.replace(/\\/g, '/').split('/').pop() || text;
+  return basename.replace(/\.jsonl$/i, '');
+}
+
 function selectAgentProcesses(rows, options = {}) {
   const providerResolver = options.providerResolver || providerFromWindowsProcess;
   const environment = options.environment || 'windows';
-  const candidates = rows.map(item => ({ ...item, provider: providerResolver(item) })).filter(item => item.provider);
+  const candidates = rows
+    .map(item => ({ ...item, provider: providerResolver(item) }))
+    .filter(item => item.provider && !utilityProcess(item));
   const byParent = new Map();
   for (const item of candidates) {
     if (!byParent.has(item.parentPid)) byParent.set(item.parentPid, []);
@@ -160,30 +191,38 @@ function selectAgentProcesses(rows, options = {}) {
     parentPid: item.parentPid,
     command: String(item.name || '').replace(/\.exe$/i, '').split(/[\\/]/).pop(),
     startedAt: item.startedAt,
+    externalId: processSessionExternalId(item, item.provider),
   })).sort((a, b) => a.provider.localeCompare(b.provider) || a.pid - b.pid);
 }
 
+function utilityProcess(processInfo = {}) {
+  const commandLine = String(processInfo.commandLine || processInfo.args || '');
+  return /Extract durable memory candidates from this Claude Code transcript tail/i.test(commandLine)
+    || /Reply with exactly OK\. Do not use tools\.?/i.test(commandLine)
+    || /You are a memory extraction/i.test(commandLine);
+}
+
 function utilitySession(session) {
-  return /^(?:extract durable memory candidates|approved command prefix saved|you are a memory extraction)/i.test(String(session.title || '').trim());
+  return Boolean(session && session.utilityKind)
+    || /^(?:extract durable memory candidates|approved command prefix saved|you are a memory extraction|reply with exactly ok\. do not use tools)/i.test(String(session && session.title || '').trim());
 }
 
 function runtimeLinkScore(session, processInfo, now = Date.now()) {
   if (!session || session.provider !== processInfo.provider) return -Infinity;
   if (!session.environment || session.environment.kind !== processInfo.environment) return -Infinity;
+  if (utilitySession(session)) return -Infinity;
+  if (/^(?:claude-desktop|codex-desktop|codex-ide)$/i.test(String(session.clientKind || ''))) return -Infinity;
   let score = session.parentId ? -800 : 2_000;
-  if (utilitySession(session)) score -= 10_000;
   if (session.status === 'running' || session.status === 'starting') score += 3_000;
   else if (session.status === 'waiting') score += 1_000;
   const ageMinutes = Math.max(0, (now - Date.parse(session.updatedAt || 0)) / 60_000);
   score += Math.max(0, 2_880 - ageMinutes);
   const sessionStart = Date.parse(session.startedAt || 0);
   const processStart = Date.parse(processInfo.startedAt || 0);
-  if (Number.isFinite(sessionStart) && Number.isFinite(processStart)) {
-    const deltaMinutes = Math.abs(sessionStart - processStart) / 60_000;
-    if (deltaMinutes <= 3) score += 6_000;
-    else if (deltaMinutes <= 30) score += 2_500;
-    else if (deltaMinutes <= 180) score += 800;
-  }
+  if (!Number.isFinite(sessionStart) || !Number.isFinite(processStart)) return -Infinity;
+  const deltaMinutes = Math.abs(sessionStart - processStart) / 60_000;
+  if (deltaMinutes > 5) return -Infinity;
+  score += 6_000 - deltaMinutes * 200;
   return score;
 }
 
@@ -191,13 +230,6 @@ function markRuntime(session, presence) {
   const existing = Array.isArray(session.runtimePresence) ? session.runtimePresence : [];
   if (!existing.some(item => item.id === presence.id)) existing.push(presence);
   session.runtimePresence = existing;
-  session.status = 'running';
-  session.statusObserved = true;
-  session.statusDetail = presence.kind === 'tmux'
-    ? `tmux에서 AI 프로세스 실행 중 · PID ${presence.pid}`
-    : (presence.kind === 'bridge'
-      ? `안전하게 연결된 외부 터미널 · PID ${presence.pid}`
-      : `AI CLI 프로세스 실행 중 · PID ${presence.pid}`);
   return session;
 }
 
@@ -243,6 +275,7 @@ function syntheticRuntimeSession(processInfo, now = Date.now()) {
 function bridgeLinkScore(session, bridge, now = Date.now()) {
   if (!session || session.provider !== bridge.provider) return -Infinity;
   if (!session.environment || session.environment.kind !== bridge.environment) return -Infinity;
+  if (utilitySession(session)) return -Infinity;
   if (session.clientKind === 'codex-desktop' || session.clientKind === 'codex-ide' || session.clientKind === 'claude-desktop') return -Infinity;
   let score = session.parentId ? -500 : 3_000;
   const sessionCwd = String(session.cwd || '').replace(/\\/g, '/').replace(/\/$/, '').toLowerCase();
@@ -280,7 +313,19 @@ function applyRuntimePresence(agentSessions, tmuxSnapshot, processSnapshot, now
   const usedBridgeIds = new Set();
   const bridgePairs = [];
   for (const bridge of bridges || []) {
+    const explicitId = [bridge.linkedSessionId, bridge.sessionId, bridge.bridgeId, bridge.id]
+      .map(value => String(value || ''))
+      .find(id => id && byId.has(id));
+    const linked = explicitId && byId.get(explicitId);
+    if (!linked || linked.provider !== bridge.provider || utilitySession(linked)) continue;
+    usedBridgeIds.add(bridge.id);
+    usedSessionIds.add(linked.id);
+    markRuntime(linked, { ...bridge, kind: 'bridge', label: 'LoadToAgent 세션 터미널', linkScore: 'explicit' });
+  }
+  for (const bridge of bridges || []) {
+    if (usedBridgeIds.has(bridge.id)) continue;
     for (const session of sessions) {
+      if (usedSessionIds.has(session.id)) continue;
       const score = bridgeLinkScore(session, bridge, now);
       if (score > 0) bridgePairs.push({ bridge, session, score });
     }
@@ -298,7 +343,7 @@ function applyRuntimePresence(agentSessions, tmuxSnapshot, processSnapshot, now
         for (const pane of window.panes || []) {
           const agent = pane.agent;
           const linked = agent && agent.linkedSessionId && byId.get(agent.linkedSessionId);
-          if (!linked) continue;
+          if (!linked || pane.dead) continue;
           usedSessionIds.add(linked.id);
           markRuntime(linked, {
             id: `tmux:${distro.name}:${pane.nativeId}`,
@@ -316,8 +361,23 @@ function applyRuntimePresence(agentSessions, tmuxSnapshot, processSnapshot, now
 
   const bridgePids = new Set((bridges || []).map(item => Number(item.pid || 0)).filter(Boolean));
   const processes = (processSnapshot && processSnapshot.processes || []).filter(item => !bridgePids.has(Number(item.pid || 0)));
+  const usedProcessIds = new Set();
+  for (const processInfo of processes) {
+    const externalId = String(processInfo.externalId || '');
+    if (!externalId) continue;
+    const linked = sessions.find(session => !usedSessionIds.has(session.id)
+      && session.provider === processInfo.provider
+      && session.environment && session.environment.kind === processInfo.environment
+      && (String(session.externalId || '') === externalId || String(session.id || '').endsWith(`:${externalId}`)));
+    if (!linked) continue;
+    usedProcessIds.add(processInfo.id);
+    usedSessionIds.add(linked.id);
+    const label = processInfo.environment === 'macos' ? 'macOS CLI' : (processInfo.environment === 'linux' ? 'Linux CLI' : 'Windows CLI');
+    markRuntime(linked, { ...processInfo, kind: processInfo.environment || 'windows', label, linkScore: 'explicit-session-id' });
+  }
   const pairs = [];
   for (const processInfo of processes) {
+    if (usedProcessIds.has(processInfo.id)) continue;
     for (const session of sessions) {
       if (usedSessionIds.has(session.id)) continue;
       const score = runtimeLinkScore(session, processInfo, now);
@@ -325,7 +385,6 @@ function applyRuntimePresence(agentSessions, tmuxSnapshot, processSnapshot, now
     }
   }
   pairs.sort((a, b) => b.score - a.score);
-  const usedProcessIds = new Set();
   for (const pair of pairs) {
     if (usedProcessIds.has(pair.processInfo.id) || usedSessionIds.has(pair.session.id)) continue;
     usedProcessIds.add(pair.processInfo.id);
@@ -333,9 +392,6 @@ function applyRuntimePresence(agentSessions, tmuxSnapshot, processSnapshot, now
     const label = pair.processInfo.environment === 'macos' ? 'macOS CLI' : (pair.processInfo.environment === 'linux' ? 'Linux CLI' : 'Windows CLI');
     markRuntime(pair.session, { ...pair.processInfo, kind: pair.processInfo.environment || 'windows', label, linkScore: Math.round(pair.score) });
   }
-  for (const processInfo of processes) {
-    if (!usedProcessIds.has(processInfo.id)) sessions.push(syntheticRuntimeSession(processInfo, now));
-  }
   for (const bridge of bridges || []) {
     if (!usedBridgeIds.has(bridge.id)) sessions.push(syntheticBridgeSession(bridge, now));
   }
@@ -388,6 +444,8 @@ module.exports = {
   posixProcessRows,
   elapsedSeconds,
   selectAgentProcesses,
+  processSessionExternalId,
+  utilityProcess,
   runtimeLinkScore,
   bridgeLinkScore,
   applyRuntimePresence,

package/src/providerVisibilityStore.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class ProviderVisibilityStore {
+  constructor(file, providerIds, onError = () => {}) {
+    this.file = file;
+    this.providerIds = new Set(providerIds);
+    this.onError = onError;
+    this.hidden = new Set();
+  }
+
+  normalize(value) {
+    const hidden = value && Array.isArray(value.hidden) ? value.hidden : [];
+    return new Set(hidden.filter(id => this.providerIds.has(id)));
+  }
+
+  load() {
+    try {
+      this.hidden = this.normalize(JSON.parse(fs.readFileSync(this.file, 'utf8')));
+    } catch (error) {
+      if (error && error.code !== 'ENOENT') this.onError(error);
+      this.hidden = new Set();
+    }
+    return this.snapshot();
+  }
+
+  save(value) {
+    this.hidden = this.normalize(value);
+    fs.mkdirSync(path.dirname(this.file), { recursive: true });
+    fs.writeFileSync(this.file, JSON.stringify(this.snapshot(), null, 2), 'utf8');
+    return this.snapshot();
+  }
+
+  isVisible(providerId) {
+    return !this.hidden.has(String(providerId || ''));
+  }
+
+  snapshot() {
+    return { hidden: [...this.hidden] };
+  }
+}
+
+module.exports = { ProviderVisibilityStore };