agent-workbench 0.4.0 → 0.4.1

package/README.md

@@ -31,7 +31,7 @@ the app touching it.
 | **Tabs** | Several live sessions at once, from any of the CLIs, each in its own directory. They survive an `F5`: the processes live on the server, not in the browser tab. Each tab's dot tells you whether the agent is working, idle or waiting for an answer, on the CLIs that publish their status ([below](#multiple-clis)). |
 | **Zero-cost startup** | When you open the app, tabs come back as **sleeping tabs**: you can read them in full, and they don't launch any CLI. You open the CLI with a button when you want to write to the agent. |
 | **History** | Your projects and past conversations in the sidebar, with a filter, and those of all four CLIs together under each project, each with its badge. Opening one resumes it with its CLI, in the same session. **Archive history…** hides a CLI's sessions from before today in one go, and each project can be archived whole with one button: nothing is deleted, and both can be undone. |
-| **Conversation** | The active session's messages, live, with tool calls collapsed and their results inside. Search, jump between matches, copy any message or code block and, depending on the CLI, answer the agent's questions from the chat. |
+| **Conversation** | The active session's messages, live, with tool calls collapsed and their results inside. A row at the bottom tells you when your message reached the CLI, whether the agent is working and, with Claude Code, which subagents are still at it after the agent finished its turn. Search, jump between matches and back to the end, copy any message or code block and, depending on the CLI, answer the agent's questions from the chat. |
 | **Continue with…** | With more than one CLI installed, a conversation can be continued with another CLI in the same folder. The new agent starts from a transcript of the last turns, not from the context the previous one had. |
 | **Search everything** | With more than one CLI and something saved in the local copy, the sidebar filter also searches the text of every saved conversation, not just their titles. |
 | **Context meter** | Tokens from the last request against the model's context window. Tokens, never money. |
@@ -383,7 +383,9 @@ The app captures exactly those combinations and no others. `Shift+Tab` only
 when focus isn't on the terminal, because inside it's the key the CLI uses to
 switch modes. Everything else —`Esc`, `Esc Esc`, `Ctrl+C`, `Ctrl+R`, `Ctrl+O`,
 the arrow keys and above all `Alt+V`, which pastes images— reaches the CLI
-untouched.
+untouched. `Ctrl+V` too: what it does there is up to the CLI. Only in the
+console at the bottom, on Windows, `Ctrl+V` pastes text, as in Windows
+Terminal.
 
 ---
 

package/dist/server.js

@@ -170,6 +170,7 @@ function noticeText(part) {
       return part.detail.length > 0 ? `La CLI devolvi\xF3 un error: ${part.detail}` : "La CLI devolvi\xF3 un error";
   }
 }
+var MAX_SUBAGENT_DESCRIPTION = 120;
 var EMPTY_CONTEXT_USAGE = {
   lastRequestTokens: 0,
   lastOutputTokens: 0,
@@ -738,6 +739,8 @@ function parseClientMessage(raw) {
         if (files.length > 0) message.files = files;
       }
       if (record["send"] === false) message.send = false;
+      const requestId = asNonEmptyString(record["requestId"]);
+      if (requestId !== null) message.requestId = requestId;
       return message;
     }
     case "agent.mode": {
@@ -5069,6 +5072,135 @@ function toTurnDuration(record) {
   return { eventId, durationMs };
 }
 
+// packages/server/src/agents/claude-code/subagent-tracker.ts
+var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
+var MAX_TRACKED = 50;
+var NOTIFICATION = /<task-notification>([\s\S]*?)<\/task-notification>/g;
+var TOOL_USE_ID = /<tool-use-id>\s*([^<\s]+)\s*<\/tool-use-id>/;
+function labelOf(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(/\s+/g, " ").trim().slice(0, MAX_SUBAGENT_DESCRIPTION);
+}
+function notifiedToolUseIds(text) {
+  if (!text.includes("<task-notification>")) return [];
+  const ids = [];
+  for (const match of text.matchAll(NOTIFICATION)) {
+    const id = TOOL_USE_ID.exec(match[1] ?? "")?.[1];
+    if (id !== void 0) ids.push(id);
+  }
+  return ids;
+}
+function contentText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let text = "";
+  for (const block of content) {
+    const record = recordOf(block);
+    if (record !== null && record["type"] === "text" && typeof record["text"] === "string") {
+      text += record["text"];
+    }
+  }
+  return text;
+}
+function launchedInBackground(toolUseResult) {
+  const result = recordOf(toolUseResult);
+  return result !== null && (result["status"] === "async_launched" || result["isAsync"] === true);
+}
+var SubagentTracker = class {
+  /** Los que no terminaron, en orden de lanzamiento (`Map` conserva el de insercion). */
+  pending = /* @__PURE__ */ new Map();
+  /** Una linea del JSONL, ya parseada. Nunca lanza: el esquema cambia. */
+  observe(record) {
+    if (record["isSidechain"] === true) return;
+    switch (record["type"]) {
+      case "assistant":
+        this.observeLaunches(record);
+        return;
+      case "user":
+        this.observeResults(record);
+        this.finish(notifiedToolUseIds(contentText(recordOf(record["message"])?.["content"])));
+        return;
+      case "queue-operation":
+        if (record["operation"] === "enqueue" && typeof record["content"] === "string") {
+          this.finish(notifiedToolUseIds(record["content"]));
+        }
+        return;
+      case "attachment": {
+        const attachment = recordOf(record["attachment"]);
+        if (attachment?.["type"] === "queued_command" && typeof attachment["prompt"] === "string") {
+          this.finish(notifiedToolUseIds(attachment["prompt"]));
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /**
+   * Los que siguen trabajando y los lanzo el proceso de `launchedAt` o uno
+   * posterior. Uno sin hora no se puede atribuir a ningun proceso y no cuenta.
+   */
+  running(launchedAt) {
+    const result = [];
+    for (const subagent of this.pending.values()) {
+      if (subagent.startedAt > 0 && subagent.startedAt >= launchedAt) result.push({ ...subagent });
+    }
+    return result;
+  }
+  /** El archivo se reemplazo: lo anotado era de otra lectura. */
+  reset() {
+    this.pending.clear();
+  }
+  observeLaunches(record) {
+    const content = recordOf(record["message"])?.["content"];
+    if (!Array.isArray(content)) return;
+    const startedAt = readTimestamp(record["timestamp"]);
+    for (const block of content) {
+      const call = recordOf(block);
+      if (call === null || call["type"] !== "tool_use") continue;
+      const toolUseId = call["id"];
+      if (typeof toolUseId !== "string" || toolUseId.length === 0) continue;
+      if (typeof call["name"] !== "string" || !SUBAGENT_TOOLS.has(call["name"])) continue;
+      if (this.pending.has(toolUseId)) continue;
+      const input = recordOf(call["input"]);
+      this.pending.set(toolUseId, {
+        toolUseId,
+        description: labelOf(input?.["description"]),
+        background: input?.["run_in_background"] === true,
+        startedAt
+      });
+      if (this.pending.size > MAX_TRACKED) {
+        const oldest = this.pending.keys().next();
+        if (!oldest.done) this.pending.delete(oldest.value);
+      }
+    }
+  }
+  /**
+   * El resultado de la llamada. En segundo plano dice que quedo andando, y
+   * sigue; si no, termino —o no llego a lanzarse, que para el hilo es lo mismo—.
+   */
+  observeResults(record) {
+    const content = recordOf(record["message"])?.["content"];
+    if (!Array.isArray(content)) return;
+    for (const block of content) {
+      const result = recordOf(block);
+      if (result === null || result["type"] !== "tool_result") continue;
+      const toolUseId = result["tool_use_id"];
+      if (typeof toolUseId !== "string") continue;
+      const subagent = this.pending.get(toolUseId);
+      if (subagent === void 0) continue;
+      if (result["is_error"] !== true && launchedInBackground(record["toolUseResult"])) {
+        subagent.background = true;
+      } else {
+        this.pending.delete(toolUseId);
+      }
+    }
+  }
+  finish(toolUseIds) {
+    for (const toolUseId of toolUseIds) this.pending.delete(toolUseId);
+  }
+};
+
 // packages/server/src/agents/claude-code/conversation-follower.ts
 var MAX_ATTACHMENT_LINKS = 100;
 var MAX_PLAN_REFS = 50;
@@ -5155,6 +5287,11 @@ var ConversationFollower = class {
    * ninguna—, y ahi vale con que se lanzo la pestana (`LAUNCH_PERMISSION_MODE`).
    */
   permissionMode = null;
+  /**
+   * Los subagentes que no terminaron (§4.15). Mira lineas que no son tarjetas
+   * —el aviso de fin es una `queue-operation`—, asi que va antes de todo filtro.
+   */
+  subagents = new SubagentTracker();
   /** Los topes de cada parte. Los de transporte salvo que se lea para la copia propia. */
   limits;
   /** La pestana cuyos documentos se reconocen. Ver el constructor. */
@@ -5207,6 +5344,10 @@ var ConversationFollower = class {
   getUsage() {
     return this.usage;
   }
+  /** Los subagentes del proceso de `launchedAt` que siguen trabajando (§4.15). */
+  runningSubagents(launchedAt) {
+    return this.subagents.running(launchedAt);
+  }
   /** Ultimos `limit` eventos, que es lo que se quiere ver al abrir el panel. */
   getTail(limit) {
     return this.jsonl.getTail(limit);
@@ -5252,6 +5393,7 @@ var ConversationFollower = class {
     this.permissionMode = null;
     this.attachmentRoots.clear();
     this.planFiles = [];
+    this.subagents.reset();
   }
   /** true si la linea es la invocacion de `/model` que la CLI guarda. */
   mentionsModelCommand(record) {
@@ -5268,6 +5410,7 @@ var ConversationFollower = class {
    * los que ya guardo, para pegarle a uno anterior la duracion o una imagen.
    */
   consume(record, lineNumber, events) {
+    this.subagents.observe(record);
     if (record["type"] === "cost-state") {
       this.sessionVariants.observeCostState(record, Date.now());
       this.recomputeModel();
@@ -5647,6 +5790,10 @@ var ClaudeCodeSessionFollower = class {
   hasOpenToolCall() {
     return false;
   }
+  /** Los subagentes del proceso de `launchedAt` que siguen trabajando (§4.15). */
+  runningSubagents(launchedAt) {
+    return this.inner.runningSubagents(launchedAt);
+  }
 };
 
 // packages/server/src/agents/claude-code/session-scan.ts
@@ -10168,6 +10315,9 @@ var INITIAL_EVENT_LIMIT = 300;
 var MAX_PAGE_LIMIT = 500;
 var PENDING_QUESTION_LOOKBACK = 50;
 var POLL_DEBOUNCE_MS = 150;
+function sameSubagents(a, b) {
+  return a.length === b.length && a.every((item, index) => item.toolUseId === b[index]?.toolUseId && item.background === b[index]?.background);
+}
 var ConversationHub = class extends EventEmitter {
   constructor(registry, agents) {
     super();
@@ -10175,7 +10325,10 @@ var ConversationHub = class extends EventEmitter {
     this.agents = agents;
     registry.on("session", (terminalId) => void this.rebind(terminalId));
     registry.on("changed", () => {
-      for (const [terminalId, entry] of this.entries) this.refreshOpenToolCall(terminalId, entry);
+      for (const [terminalId, entry] of this.entries) {
+        this.refreshOpenToolCall(terminalId, entry);
+        this.refreshSubagents(terminalId, entry);
+      }
     });
   }
   registry;
@@ -10199,6 +10352,7 @@ var ConversationHub = class extends EventEmitter {
         usage: { ...EMPTY_CONTEXT_USAGE },
         waitingFor: null,
         openToolCall: false,
+        subagents: [],
         plans: []
       };
     }
@@ -10235,6 +10389,7 @@ var ConversationHub = class extends EventEmitter {
       permissionMode: entry.observedMode ?? entry.assumedMode,
       waitingFor: entry.waitingFor,
       openToolCall: entry.openToolCall,
+      subagents: entry.subagents,
       plans: plans === null ? [] : await plans.describe(
         { cwd: entry.cwd, sessionId: entry.sessionId },
         entry.follower.getPlanFiles()
@@ -10284,6 +10439,7 @@ var ConversationHub = class extends EventEmitter {
       waitingFor: null,
       statusActivity: null,
       openToolCall: false,
+      subagents: [],
       primed: false,
       stopWatchingStatus: null,
       followTicker: null
@@ -10326,6 +10482,23 @@ var ConversationHub = class extends EventEmitter {
     entry.openToolCall = open8;
     this.emit("toolCall", terminalId, open8);
   }
+  /**
+   * Recalcula los subagentes que siguen trabajando y avisa si cambiaron
+   * (§4.15). Solo los del proceso vivo: sin pty no queda ninguno, y los de un
+   * proceso anterior murieron con el sin escribir el aviso de fin. Una CLI cuyo
+   * seguidor no los declara no tiene nunca.
+   */
+  refreshSubagents(terminalId, entry) {
+    const launchedAt = this.registry.launchedAtOf(terminalId);
+    const next = launchedAt === null || entry.follower.runningSubagents === void 0 ? [] : [...entry.follower.runningSubagents(launchedAt)];
+    if (sameSubagents(next, entry.subagents)) return;
+    entry.subagents = next;
+    this.emit("subagents", terminalId, next);
+  }
+  /** Los subagentes que siguen trabajando, lo ultimo avisado. [] si nadie sigue la pestana. */
+  getSubagents(terminalId) {
+    return this.entries.get(terminalId)?.subagents ?? [];
+  }
   /**
    * La pestana cambio de sesion: se suelta el seguidor viejo y se sigue la
    * nueva, sin perder a quien estaba mirando.
@@ -10506,6 +10679,7 @@ var ConversationHub = class extends EventEmitter {
       permissionMode: this.resetMode(entry),
       waitingFor: entry.waitingFor,
       openToolCall: entry.openToolCall,
+      subagents: entry.subagents,
       // Este snapshot es sincronico y describir un plan pide el disco. Quien
       // necesita los planes usa `subscribe`, que si puede esperar.
       plans: []
@@ -10662,6 +10836,7 @@ var ConversationHub = class extends EventEmitter {
         return;
       }
       this.refreshOpenToolCall(terminalId, entry);
+      this.refreshSubagents(terminalId, entry);
       if (options.silent) return;
       const observed = entry.follower.getPermissionMode();
       if (observed !== null) {
@@ -19331,6 +19506,7 @@ function attachTerminalSocket(options) {
   const onConversationMode = (terminalId, mode) => broadcast({ type: "conversation.mode", terminalId, mode });
   const onConversationWaiting = (terminalId, waitingFor) => broadcast({ type: "conversation.waiting", terminalId, waitingFor });
   const onConversationToolCall = (terminalId, open8) => broadcast({ type: "conversation.toolCall", terminalId, open: open8 });
+  const onConversationSubagents = (terminalId, subagents) => broadcast({ type: "conversation.subagents", terminalId, subagents });
   const onConversationPlans = (terminalId, plans) => broadcast({ type: "conversation.plans", terminalId, plans });
   const onConversationTurns = (terminalId, turns) => broadcast({ type: "conversation.turns", terminalId, turns });
   const onConversationParts = (terminalId, updates) => broadcast({ type: "conversation.parts", terminalId, updates });
@@ -19394,7 +19570,8 @@ function attachTerminalSocket(options) {
         waitingFor: snapshot.waitingFor,
         // El de ahora y no el del snapshot: leer la configuracion es asincrono,
         // y un aviso que salio mientras tanto no puede quedar pisado por uno viejo.
-        openToolCall: conversations.isToolCallOpen(terminalId)
+        openToolCall: conversations.isToolCallOpen(terminalId),
+        subagents: conversations.getSubagents(terminalId)
       });
     });
   };
@@ -19409,6 +19586,7 @@ function attachTerminalSocket(options) {
   conversations.on("mode", onConversationMode);
   conversations.on("waiting", onConversationWaiting);
   conversations.on("toolCall", onConversationToolCall);
+  conversations.on("subagents", onConversationSubagents);
   conversations.on("turns", onConversationTurns);
   conversations.on("plans", onConversationPlans);
   conversations.on("parts", onConversationParts);
@@ -19578,6 +19756,12 @@ function attachTerminalSocket(options) {
                 */
         case "agent.submit": {
           const { terminalId, text: text2, images } = message;
+          let settled = false;
+          const settle = (delivered) => {
+            if (settled || message.requestId === void 0) return;
+            settled = true;
+            send(socket, { type: "agent.submitted", terminalId, requestId: message.requestId, delivered });
+          };
           const submittedOwner = draftOwnerOf(registry.get(terminalId));
           if (submittedOwner !== null) drafts.delete(submittedOwner);
           const files = message.files ?? [];
@@ -19587,6 +19771,7 @@ function attachTerminalSocket(options) {
               "submit-failed",
               serverText("filesPerMessage", { max: MAX_FILES_PER_SUBMIT })
             );
+            settle(false);
             break;
           }
           if (images.length > MAX_IMAGES_PER_SUBMIT) {
@@ -19595,9 +19780,11 @@ function attachTerminalSocket(options) {
               "submit-failed",
               serverText("imagesPerMessage", { max: MAX_IMAGES_PER_SUBMIT })
             );
+            settle(false);
             break;
           }
           if (images.length > 0 && imageStyleFor(socket, terminalId, serverText("imagesUnsupported")) === null) {
+            settle(false);
             break;
           }
           const submitting = adapterOf(terminalId);
@@ -19618,6 +19805,7 @@ function attachTerminalSocket(options) {
             });
             if (refusal2 !== null) {
               sendError(socket, "submit-failed", refusal2);
+              settle(false);
               break;
             }
           }
@@ -19685,6 +19873,7 @@ function attachTerminalSocket(options) {
                 approvalGuard,
                 { startAfterMs }
               );
+              settle(outcome === "written");
               if (outcome === "interrupted") interrupted();
               if (outcome === "blocked") {
                 const waitingNow = blocksWhileWaiting && registry.activityOf(terminalId) === "waiting";
@@ -19696,7 +19885,7 @@ function attachTerminalSocket(options) {
               }
             },
             { onDropped: interrupted }
-          );
+          ).then(() => settle(false));
           break;
         }
         /*
@@ -20014,7 +20203,8 @@ function attachTerminalSocket(options) {
               permissionMode: snapshot.permissionMode,
               defaults: await defaultsFor(message.terminalId),
               waitingFor: snapshot.waitingFor,
-              openToolCall: conversations.isToolCallOpen(message.terminalId)
+              openToolCall: conversations.isToolCallOpen(message.terminalId),
+              subagents: conversations.getSubagents(message.terminalId)
             });
             if (snapshot.plans.length > 0) {
               send(socket, {
@@ -20680,6 +20870,7 @@ function attachTerminalSocket(options) {
     conversations.off("mode", onConversationMode);
     conversations.off("waiting", onConversationWaiting);
     conversations.off("toolCall", onConversationToolCall);
+    conversations.off("subagents", onConversationSubagents);
     repos.off("status", onGitStatus);
     memory.off("status", onMemoryStatus);
     stopAgentChanges();