fix: surface long-running goose subagent status

LIU9293 · LIU9293 · commit ae5e3b3f0d3c · 2026-02-25T09:39:42.000Z
diff --git a/packages/agents/goose/session-state.ts b/packages/agents/goose/session-state.ts
@@ -59,6 +59,40 @@ export type GooseInspectorToolState = StreamToolState;
 
 export type GooseStreamStateMaps = StreamStateMaps<GooseInspectorToolState>;
 
+function resolveGooseToolResponseId(block: {
+  id?: string;
+  tool_use_id?: string;
+}): string {
+  if (typeof block.id === "string" && block.id.trim()) {
+    return block.id;
+  }
+  if (typeof block.tool_use_id === "string" && block.tool_use_id.trim()) {
+    return block.tool_use_id;
+  }
+  return "";
+}
+
+function extractGooseToolResponseText(value: unknown): string {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  return value
+    .filter((entry) => entry && typeof entry === "object")
+    .map((entry) => {
+      const record = entry as { type?: string; text?: string };
+      if (record.type === "text" && typeof record.text === "string") {
+        return record.text;
+      }
+      return "";
+    })
+    .filter((text) => text.length > 0)
+    .join("\n")
+    .trim();
+}
+
 function parseTodosFromGooseToolInput(toolName: string, input: Record<string, unknown> | undefined): SessionTodo[] | undefined {
   const direct = parseTodosFromToolInput(toolName, input);
   if (direct) return direct;
@@ -97,6 +131,9 @@ export function applyGooseRecordToState(
     const blocks = record.message?.content ?? [];
 
     if (role === "assistant") {
+      const messageCreatedAtMs = typeof record.message?.created === "number"
+        ? record.message.created * 1000
+        : Date.now();
       for (const block of blocks) {
         if (block?.type === "text") {
           const chunk = typeof block.text === "string" ? block.text : "";
@@ -138,7 +175,12 @@ export function applyGooseRecordToState(
           output: existing?.output,
           error: existing?.error,
           title: existing?.title,
-          metadata: existing?.metadata,
+          metadata: {
+            ...(existing?.metadata ?? {}),
+            startedAtMs: typeof existing?.metadata?.startedAtMs === "number"
+              ? existing.metadata.startedAtMs
+              : messageCreatedAtMs,
+          },
         };
         toolById.set(callId, tool);
         updateTool(state, tool);
@@ -150,16 +192,12 @@ export function applyGooseRecordToState(
     if (role === "user") {
       for (const block of blocks) {
         if (block?.type !== "toolResponse") continue;
-        const callId = typeof block.id === "string" && block.id.trim() ? block.id : "";
+        const callId = resolveGooseToolResponseId(block);
         if (!callId) continue;
         const existing = toolById.get(callId);
         if (!existing) continue;
         const result = block.toolResult?.value;
-        const output = (result?.content ?? [])
-          .filter((entry) => entry?.type === "text")
-          .map((entry) => entry.text ?? "")
-          .join("\n")
-          .trim();
+        const output = extractGooseToolResponseText(result?.content);
         const hasError = result?.isError === true || block.toolResult?.status === "error";
         const updated: GooseInspectorToolState = {
           ...existing,
diff --git a/packages/live-status-harness/test/render-status.test.ts b/packages/live-status-harness/test/render-status.test.ts
@@ -69,6 +69,94 @@ describe("live status harness renderer", () => {
     expect(joined).toContain("Finished tool: Read");
   });
 
+  it("renders goose subagent completion when tool response uses tool_use_id", () => {
+    const now = Date.now();
+    const meta: HarnessRunMeta = {
+      runId: "run-goose-subagent-id",
+      provider: "goose",
+      prompt: "test",
+      promptHash: "hash",
+      cwd: "/tmp/repo",
+      channelId: "C1",
+      threadId: "T1",
+      sessionId: "goose_s1",
+      startedAt: now,
+      eventCount: 2,
+    };
+
+    const events: HarnessCapturedEvent[] = [
+      {
+        runId: "run-goose-subagent-id",
+        sessionId: "goose_s1",
+        provider: "goose",
+        timestamp: now,
+        index: 0,
+        event: {
+          type: "goose.raw.message",
+          properties: {
+            record: {
+              type: "message",
+              message: {
+                role: "assistant",
+                content: [
+                  {
+                    type: "toolRequest",
+                    id: "call-subagent-1",
+                    toolCall: {
+                      value: {
+                        name: "subagent",
+                        arguments: { instructions: "inspect repo" },
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      },
+      {
+        runId: "run-goose-subagent-id",
+        sessionId: "goose_s1",
+        provider: "goose",
+        timestamp: now + 1,
+        index: 1,
+        event: {
+          type: "goose.raw.message",
+          properties: {
+            record: {
+              type: "message",
+              message: {
+                role: "user",
+                content: [
+                  {
+                    type: "toolResponse",
+                    tool_use_id: "call-subagent-1",
+                    toolResult: {
+                      status: "success",
+                      value: {
+                        content: [
+                          { type: "text", text: "subagent complete" },
+                        ],
+                        isError: false,
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        },
+      },
+    ];
+
+    const statuses = renderStatusesFromRun(meta, events);
+    const joined = statuses.map((status) => status.text).join("\n\n");
+
+    expect(joined).toContain("Running tool: subagent");
+    expect(joined).toContain("Finished tool: subagent");
+  });
+
   it("renders gemini live status from synthetic fixture", () => {
     const now = Date.now();
     const meta: HarnessRunMeta = {
diff --git a/packages/utils/status.test.ts b/packages/utils/status.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from "bun:test";
+import { buildStatusMessageByProvider, type StatusRequest } from "./status";
+import type { SessionMessageState } from "./session-inspector";
+
+describe("status message formatting", () => {
+  const request: StatusRequest = {
+    channelId: "C1",
+    threadId: "T1",
+    statusMessageTs: "S1",
+    startedAt: Date.now() - 60_000,
+    currentText: "",
+  };
+
+  it("shows waiting subagent hint after threshold", () => {
+    const state: SessionMessageState = {
+      sessionTitle: "Goose is running...",
+      phaseStatus: "Running tool: subagent",
+      currentText: "",
+      tools: [
+        {
+          id: "tool-1",
+          name: "subagent",
+          status: "running",
+          metadata: { startedAtMs: Date.now() - 35_000 },
+        },
+      ],
+      todos: [],
+      startedAt: Date.now() - 60_000,
+    };
+
+    const text = buildStatusMessageByProvider("goose", request, "/tmp/repo", state, "medium");
+    expect(text).toContain("Waiting for subagent output");
+  });
+
+  it("keeps regular running status before threshold", () => {
+    const state: SessionMessageState = {
+      sessionTitle: "Goose is running...",
+      phaseStatus: "Running tool: subagent",
+      currentText: "",
+      tools: [
+        {
+          id: "tool-1",
+          name: "subagent",
+          status: "running",
+          metadata: { startedAtMs: Date.now() - 5_000 },
+        },
+      ],
+      todos: [],
+      startedAt: Date.now() - 60_000,
+    };
+
+    const text = buildStatusMessageByProvider("goose", request, "/tmp/repo", state, "medium");
+    expect(text).toContain("_Running tool: subagent_");
+    expect(text).not.toContain("Waiting for subagent output");
+  });
+});
diff --git a/packages/utils/status.ts b/packages/utils/status.ts
@@ -34,6 +34,7 @@ type StatusTodo = {
 };
 
 const PLAN_TODO_LIMIT = 15;
+const SUBAGENT_WAIT_THRESHOLD_MS = 30_000;
 
 export function formatElapsedTime(startedAt: number): string {
   const elapsedSeconds = Math.floor((Date.now() - startedAt) / 1000);
@@ -169,6 +170,26 @@ function formatTodoLines(todos: StatusTodo[], limit = PLAN_TODO_LIMIT): string[]
   return lines;
 }
 
+function resolveLongRunningSubagentPhase(state: SessionMessageState): string | undefined {
+  const runningSubagent = [...state.tools]
+    .reverse()
+    .find((tool) => {
+      const name = typeof tool.name === "string" ? tool.name.trim().toLowerCase() : "";
+      return (tool.status === "running" || tool.status === "pending") && name === "subagent";
+    });
+
+  if (!runningSubagent) return undefined;
+  const startedAtMs = typeof runningSubagent.metadata?.startedAtMs === "number"
+    ? runningSubagent.metadata.startedAtMs
+    : undefined;
+  if (!startedAtMs) return undefined;
+
+  const elapsedMs = Date.now() - startedAtMs;
+  if (elapsedMs < SUBAGENT_WAIT_THRESHOLD_MS) return undefined;
+
+  return `Waiting for subagent output (${formatElapsedTime(startedAtMs)})`;
+}
+
 function normalizeToolName(name: string): string {
   switch (name) {
     case "read_file":
@@ -313,7 +334,10 @@ export function buildLiveStatusMessage(
     lines.push(`(${headerDetails})`);
   }
 
-  if (state.phaseStatus) {
+  const longRunningSubagentPhase = resolveLongRunningSubagentPhase(state);
+  if (longRunningSubagentPhase) {
+    lines.push(`_${longRunningSubagentPhase}_`);
+  } else if (state.phaseStatus) {
     lines.push(`_${state.phaseStatus}_`);
   }
 
