loadtoagent 1.0.0 → 1.1.0

package/renderer/styles-tmux.css

@@ -390,6 +390,160 @@
   background: linear-gradient(90deg,#52d7aa,var(--provider));
 }
 
+.tmux-subagents {
+  border-top: 1px solid #1c2731;
+  background: rgba(8,14,20,.74);
+}
+
+.tmux-subagents-toggle {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  width: 100%;
+  padding: 10px 14px;
+  border: 0;
+  background: transparent;
+  color: #cbd7e1;
+  text-align: left;
+  cursor: pointer;
+}
+
+.tmux-subagents-toggle:hover,
+.tmux-subagents-toggle:focus-visible {
+  background: rgba(83,218,177,.055);
+  color: #edf8f4;
+}
+
+.tmux-subagents-toggle span,
+.tmux-subagents-toggle b,
+.tmux-subagents-toggle small {
+  display: block;
+}
+
+.tmux-subagents-toggle b {
+  font-size: 11px;
+}
+
+.tmux-subagents-toggle small {
+  margin-top: 3px;
+  color: #718395;
+  font-size: 9px;
+}
+
+.tmux-subagents-toggle>i {
+  color: #72deb8;
+  font-style: normal;
+  transition: transform var(--motion-fast) ease;
+}
+
+.tmux-subagents.expanded .tmux-subagents-toggle>i {
+  transform: rotate(180deg);
+}
+
+.tmux-subagent-list {
+  display: grid;
+  gap: 6px;
+  padding: 0 10px 10px;
+}
+
+.tmux-subagent-row {
+  display: grid;
+  grid-template-columns: 28px minmax(0,1fr) auto;
+  align-items: center;
+  gap: 8px;
+  margin-left: calc(var(--tmux-subagent-depth,0) * 12px);
+  padding: 8px;
+  border: 1px solid color-mix(in srgb,var(--provider) 18%,#26323d);
+  border-radius: 9px;
+  background: color-mix(in srgb,var(--provider) 4%,#0b1219);
+}
+
+.tmux-subagent-row.work-working {
+  border-color: color-mix(in srgb,var(--provider) 38%,#315148);
+}
+
+.tmux-subagent-row.work-attention {
+  border-color: rgba(235,119,119,.42);
+}
+
+.tmux-subagent-row>.provider-mark {
+  width: 27px;
+  height: 27px;
+  font-size: 9px;
+}
+
+.tmux-subagent-copy,
+.tmux-subagent-copy>span {
+  min-width: 0;
+}
+
+.tmux-subagent-copy>span {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.tmux-subagent-copy b,
+.tmux-subagent-copy strong,
+.tmux-subagent-copy em {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tmux-subagent-copy b {
+  color: #dce6ee;
+  font-size: 10px;
+}
+
+.tmux-subagent-copy i {
+  padding: 2px 5px;
+  border-radius: 999px;
+  background: #17262a;
+  color: #77dcb9;
+  font-size: 8px;
+  font-style: normal;
+}
+
+.tmux-subagent-copy small {
+  color: #647588;
+  font-size: 8px;
+}
+
+.tmux-subagent-copy strong,
+.tmux-subagent-copy em {
+  display: block;
+  margin-top: 3px;
+}
+
+.tmux-subagent-copy strong {
+  color: #b9c7d3;
+  font-size: 10px;
+}
+
+.tmux-subagent-copy em {
+  color: #718294;
+  font-size: 9px;
+  font-style: normal;
+}
+
+.tmux-subagent-row>button {
+  min-height: 27px;
+  padding: 0 7px;
+  border: 1px solid #294139;
+  border-radius: 7px;
+  background: #10211f;
+  color: #72deb8;
+  font-size: 9px;
+  cursor: pointer;
+}
+
+.tmux-subagent-row>button:hover {
+  border-color: #3e6b5d;
+  background: #142a26;
+}
+
 .tmux-pane-node footer button {
   height: 27px;
   padding: 0 8px;

package/renderer/terminal-workbench.js

@@ -455,7 +455,17 @@ window.LoadToAgentTerminalWorkbench = function createModule(context) {
     if (!operation) return;
     const result = await guarded(operation, message);
     if (result) {
-      if (action.startsWith('kill-')) state.selectedTmux = null;
+      if (action.startsWith('kill-')) {
+        stopCapture();
+        state.captureGeneration += 1;
+        state.selectedTmux = null;
+        state.remoteCapture = '';
+        state.remoteViewportAnchor = null;
+        state.remoteViewportAtBottom = false;
+        if (state.remoteTerminal) state.remoteTerminal.terminal.reset();
+        renderAll();
+        await showSelection();
+      }
       setTimeout(refreshSnapshot, 300);
     }
   }

package/renderer/terminal.js

@@ -406,15 +406,21 @@
   }
 
   async function activate(snapshot, workspaces, mode = 'general') {
+    const nextMode = mode === 'tmux' ? 'tmux' : 'general';
+    const enteringMode = !state.active || state.mode !== nextMode;
     state.active = true;
-    state.mode = mode === 'tmux' ? 'tmux' : 'general';
+    state.mode = nextMode;
     moveWorkbench(state.mode);
     if (state.mode === 'general') state.selectedTmux = null;
     if (state.selectedId && !modeSessions().some(item => item.id === state.selectedId)) state.selectedId = null;
     updateSnapshot(snapshot, workspaces);
-    if (!state.initialized) return;
+    if (!state.initialized) {
+      state.active = false;
+      return;
+    }
     await refreshSessions();
-    if (!state.selectedId && !state.selectedTmux) {
+    if (!state.active || state.mode !== nextMode) return;
+    if (enteringMode && !state.selectedId && !state.selectedTmux) {
       const visible = modeSessions();
       if (visible.length) state.selectedId = visible[0].id;
       else if (state.mode === 'tmux') state.selectedTmux = tmuxRows()[0] || null;

package/src/attentionNotifier.js

@@ -0,0 +1,67 @@
+'use strict';
+
+class AttentionNotifier {
+  constructor(options = {}) {
+    this.Notification = options.Notification;
+    this.isSupported = options.isSupported || (() => Boolean(this.Notification));
+    this.copy = options.copy || (() => ({ title: '내 확인이 필요합니다', body: '응답이나 선택을 기다리는 AI 세션이 있습니다.' }));
+    this.onOpen = options.onOpen || (() => {});
+    this.onFallback = options.onFallback || (() => {});
+    this.waitingIds = 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)));
+
+    if (this.waitingIds === null) {
+      this.waitingIds = 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));
+  }
+
+  notify(session) {
+    let supported = false;
+    try {
+      supported = Boolean(this.Notification && this.isSupported());
+    } catch (_supportProbeFailure) {
+      supported = false;
+    }
+    if (!supported) {
+      this.onFallback(session);
+      return null;
+    }
+    try {
+      const copy = this.copy(session) || {};
+      const notification = new this.Notification({
+        title: String(copy.title || '내 확인이 필요합니다'),
+        body: String(copy.body || session.title || 'AI 세션이 응답을 기다리고 있습니다.'),
+        silent: false,
+      });
+      this.notifications.add(notification);
+      notification.once('click', () => this.onOpen(session));
+      notification.once('close', () => this.notifications.delete(notification));
+      notification.show();
+      return notification;
+    } catch (_notificationFailure) {
+      this.onFallback(session);
+      return null;
+    }
+  }
+
+  dispose() {
+    for (const notification of this.notifications) {
+      try { notification.close(); } catch {}
+    }
+    this.notifications.clear();
+  }
+}
+
+module.exports = { AttentionNotifier };

package/src/processMonitor.js

@@ -298,7 +298,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}`,

package/src/tmuxMonitor.js

@@ -271,8 +271,8 @@ function linkAgentSessions(snapshot, agentSessions, now = Date.now()) {
         for (const pane of window.panes || []) {
           paneCount += 1;
           if (!pane.agentProcess) continue;
-          aiPaneCount += 1;
-          const ranked = (agentSessions || [])
+          if (!pane.dead) aiPaneCount += 1;
+          const ranked = pane.dead ? [] : (agentSessions || [])
             .filter(session => !usedSessionIds.has(session.id))
             .map(session => ({ session, score: linkScore(session, pane, distro, pane.agentProcess, now) }))
             .filter(item => item.score >= 1_000)