fix(subagents): avoid live transcript command stalls

AGENTS.md

@@ -1557,12 +1557,12 @@ during the wait.
   task toolResults keep `progress[]`/`results[]` snapshots. omp-web recovers
   the roster from disk (`extractSubagentHistory`, result fields win over the
   mid-run snapshot), so past/finished runs show in the composer panel after a
-  reload. The transcript route pages the sibling file byte-wise (mirroring
-  `get_subagent_messages`, which is registry-gated and refuses files it
-  doesn't know). The dialog reads only the final output — `<id>.md` via
-  `?mode=completion` (bounded tail read that also works for transcripts
-  beyond the 16MB paging cap) with a live `get_subagents` snapshot fallback
-  for header enrichment; it never pages the raw transcript. Subagent ids are
+  reload. The host-backed transcript route pages the sibling file byte-wise
+  without waiting for a live process. The dialog reads final output from
+  `<id>.md` via `?mode=completion` (a bounded tail read that also works for
+  transcripts beyond the 16MB paging cap), uses a live `get_subagents`
+  snapshot only for header enrichment, and pages the raw transcript through
+  that route when the user opens it. Subagent ids are
   `[A-Za-z0-9_-]+` segments joined by `.`, because omp names a nested spawn
   `Parent.Child` (`SUBAGENT_ID_RE` in `lib/subagent-types.ts`, which also
   keeps `/`, `\` and `..` out of the joined path). The transcript route caps

CHANGELOG.md

@@ -9,6 +9,7 @@ All notable changes to **omp-web** (`@kahme247/ompweb`) are documented in this f
 ### Fixed
 
 - **Restore HTTP LAN and VPN access.** Browser UUID generation now works without secure-context-only `crypto.randomUUID()`, preventing the "Something went wrong" crash when opening the app or creating a session.
+- **Open live subagent transcripts without waiting forever.** Transcript pages now read the subagent's on-disk artifact directly instead of waiting for its busy agent process to answer first.
 
 ## [v0.7.1] - 2026-11-14
 

app/api/sessions/[id]/subagents/[subagentId]/route.ts

@@ -6,9 +6,8 @@ import { isValidSubagentId } from "@/lib/hosts/session-ops";
  * GET /api/sessions/[id]/subagents/[subagentId]?fromByte=N
  *
  * Default: paged transcript of one subagent, read directly from the parent
- * session's sibling artifacts dir. Mirrors the RPC get_subagent_messages
- * response shape so the dialog can fall back to it when no live RPC process
- * knows the file.
+ * session's sibling artifacts dir through the owning host. Mirrors the
+ * get_subagent_messages response shape without waiting for a live process.
  *
  * ?mode=completion: the subagent's final output (`<id>.md`), without loading
  * the transcript — works even for transcripts beyond the readable size cap.

components/SubagentTranscriptDialog.test.mjs

@@ -1,9 +1,26 @@
+import "../tests/setup-dom.mjs";
 import assert from "node:assert/strict";
-import test from "node:test";
+import test, { afterEach } from "node:test";
 import React from "react";
 import { renderToStaticMarkup } from "react-dom/server";
+import { mock } from "bun:test";
 
-const { TaskBlock, CompletionBlock, SubagentDetails } = await import("./SubagentTranscriptDialog.tsx");
+const agentCommands = [];
+mock.module("@/lib/agent-client", () => ({
+  sendAgentCommand: (_sessionId, command) => {
+    agentCommands.push(command);
+    return new Promise(() => {});
+  },
+}));
+const { cleanup, fireEvent, render, waitFor } = await import("@testing-library/react/pure.js");
+const { TaskBlock, CompletionBlock, SubagentDetails, SubagentTranscriptDialog } = await import("./SubagentTranscriptDialog.tsx");
+
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+  cleanup();
+  globalThis.fetch = originalFetch;
+  agentCommands.length = 0;
+});
 
 test("shows the provider-qualified model and reasoning effort split from the resolved model", () => {
   const html = renderToStaticMarkup(React.createElement(SubagentDetails, {
@@ -93,3 +110,34 @@ test("shows an empty state when no completion exists yet", () => {
   }));
   assert.match(html, /No output yet/);
 });
+
+test("loads a live subagent transcript from disk without waiting for its agent command", async () => {
+  const requests = [];
+  globalThis.fetch = async (url) => {
+    const href = String(url);
+    requests.push(href);
+    if (href.includes("mode=completion")) {
+      return Response.json({ completion: "Finished.", truncated: false });
+    }
+    return Response.json({
+      sessionFile: "/sessions/StrictRunnerD2Luna.jsonl",
+      fromByte: 0,
+      nextByte: 42,
+      totalBytes: 42,
+      messages: [{ role: "user", content: "First transcript message" }],
+    });
+  };
+
+  const view = render(React.createElement(SubagentTranscriptDialog, {
+    subagent: { id: "StrictRunnerD2Luna", source: "live" },
+    sessionId: "session-1",
+    transcriptVersion: 0,
+    onClose() {},
+  }));
+  await waitFor(() => assert.match(document.body.textContent, /Finished\./));
+  fireEvent.click(view.getByRole("button", { name: "Show transcript" }));
+
+  await waitFor(() => assert.ok(requests.some((href) => href.includes("fromByte=0"))));
+  assert.match(document.body.textContent, /First transcript message/);
+  assert.equal(agentCommands.some((command) => command.type === "get_subagent_messages"), false);
+});

components/SubagentTranscriptDialog.tsx

@@ -237,22 +237,12 @@ export function SubagentTranscriptDialog({ subagent, sessionId, transcriptVersio
     return await res.json() as { completion: string | null; truncated: boolean };
   }, [sessionId, subagent?.id]);
 
-  // Full transcript page (RPC registry first, disk fallback) — mirrors the
-  // get_subagent_messages response shape so both sources are interchangeable.
-  const fetchTranscriptPage = useCallback(async (startByte: number, preferDisk: boolean): Promise<SubagentMessagesPage> => {
+  const fetchTranscriptPage = useCallback(async (startByte: number): Promise<SubagentMessagesPage> => {
     if (!sessionId || !subagent?.id) throw new Error("No session");
-    if (preferDisk) {
-      const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/subagents/${encodeURIComponent(subagent.id)}?fromByte=${startByte}`);
-      if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      return await res.json() as SubagentMessagesPage;
-    }
-    return await sendAgentCommand<SubagentMessagesPage>(sessionId, {
-      type: "get_subagent_messages",
-      subagentId: subagent.id,
-      sessionFile: subagent.sessionFile,
-      fromByte: startByte,
-    });
-  }, [sessionId, subagent?.id, subagent?.sessionFile]);
+    const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/subagents/${encodeURIComponent(subagent.id)}?fromByte=${startByte}`);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json() as SubagentMessagesPage;
+  }, [sessionId, subagent?.id]);
 
   const loadTranscriptPage = useCallback(async (startByte: number) => {
     if (!sessionId || !subagent?.id) return;
@@ -262,15 +252,7 @@ export function SubagentTranscriptDialog({ subagent, sessionId, transcriptVersio
     setTranscriptLoading(true);
     setTranscriptError(null);
     try {
-      let page: SubagentMessagesPage;
-      try {
-        page = await fetchTranscriptPage(startByte, fromDisk);
-      } catch (rpcError) {
-        // The RPC registry only knows subagents of the current process; a
-        // live entry whose session restarted falls back to the disk reader.
-        if (fromDisk || !subagent.id) throw rpcError;
-        page = await fetchTranscriptPage(startByte, true);
-      }
+      const page = await fetchTranscriptPage(startByte);
       if (seq !== transcriptRequestSeqRef.current) return;
       if (page.reset) {
         setTranscriptMessages(page.messages);
@@ -286,7 +268,7 @@ export function SubagentTranscriptDialog({ subagent, sessionId, transcriptVersio
     } finally {
       if (seq === transcriptRequestSeqRef.current) setTranscriptLoading(false);
     }
-  }, [sessionId, subagent?.id, fromDisk, fetchTranscriptPage]);
+  }, [sessionId, subagent?.id, fetchTranscriptPage]);
 
   const load = useCallback(async () => {
     if (!sessionId || !subagent?.id) return;