feat: live Cursor subagent activity in the task card

A Cursor subagent's task card now behaves like a native opencode subagent
card: clickable while running, with a live activity subtitle.

- Child session is created up-front when the task call starts and
  state.metadata.sessionId is stamped on the RUNNING task part via
  part.update (the native task tool's execute-time equivalent), so the
  card is navigable from the start of the run.
- Nested subagent activity (taskUpdate payloads on the parent task's
  tool-call-delta updates) is normalized into subagent-events and
  materialised as real tool parts in the child session (upserted via
  part.update): running on tool-start, completed on tool-result, with
  stragglers completed at finalize. This is what the TUI reads for its
  live activity subtitle.
- The child session is seeded with the subagent's prompt and its
  rendered activity (text, thinking, tool calls, conversation steps,
  final answer, duration).
- upsertToolPart treats a resolved { error } response as failure
  (hey-api's request does not throw on 4xx) and always sends
  state.metadata on completed parts, which the schema requires.
- cursor_delegate also links a child session seeded with its transcript.

Author: justin-carper

CHANGELOG.md

@@ -4,6 +4,33 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+- **Cursor subagent transcripts in the TUI subagent view.** The child session
+  created for a Cursor subagent (`task` tool) is now seeded with the subagent's
+  own activity — its assistant text, thinking, and tool calls with args and
+  results — rendered from Cursor's `conversationSteps`, plus the final answer
+  and duration. Previously only a post-completion activity summary appeared.
+  Steps arrive as raw protobuf JSON, where `agent.v1.ConversationStep`'s `message`
+  oneof serialises to a single camelCase key (`{ assistantMessage: … }`,
+  `{ toolCall: { shellToolCall: … } }`) rather than the `{ type, message }` shape
+  of the SDK's public type; both are accepted. Transcript content is never
+  truncated — the child session carries the subagent's full output.
+- **Live activity on the Cursor subagent card.** The SDK streams a local
+  subagent's nested activity via `taskUpdate` payloads on the parent task's
+  `tool-call-delta` updates (text, thinking, tool-start/tool-result with
+  id + name + input). Those events now write real `tool` parts into the child
+  session via `part.update` (an upsert — `session/processor.ts` creates parts
+  the same way), so the `task` card shows a live `↳ <Tool> <title>` subtitle
+  while the subagent runs (the TUI builds that line purely from `tool` parts
+  in the child session — `tui/routes/session/index.tsx:2227-2279`).
+  The child session is created up-front when the `task` call starts and the
+  task card's `state.metadata.sessionId` is stamped while the subagent is still
+  running (via opencode's `part.update` endpoint, mirroring the native task
+  tool's execute-time metadata publication), so the card is clickable /
+  `ctrl+x`-navigable live. Tool calls complete when their tool-result event
+  arrives; any call left open is completed at finalize.
+  `cursor_delegate` also creates a child session seeded with its transcript,
+  discoverable via the TUI's subagent panel.
+
 ## [0.7.1] — 2026-08-05
 
 The skills bridge (#90), per-model context limits and pricing (#89), and the

src/plugin/cursor-tools.ts

@@ -1,6 +1,7 @@
 import { tool, type ToolContext, type ToolDefinition } from "@opencode-ai/plugin";
 import { runCloudAgent } from "../provider/cloud-agent.js";
 import { runDelegate } from "../provider/delegate.js";
+import { linkDelegateSession } from "../provider/subagent-bridge.js";
 
 const s = tool.schema;
 
@@ -207,6 +208,27 @@ export function buildCursorTools(deps: CursorToolDeps): Record<string, ToolDefin
               `${result.toolActivity.some((t) => t.isError) ? ", some failed" : ""})`
             : "";
 
+        // Surface the delegate's work in a child session so it's discoverable
+        // in the TUI's subagent panel. Best-effort: a failed link never breaks
+        // the turn. The result card itself stays a tool block (a custom tool
+        // can't render a navigable `task` part), so the child session is
+        // reached via the subagent panel, not by clicking the result.
+        if (context.sessionID) {
+          const transcript = [
+            result.text || "(no text output)",
+            ...(result.reasoning ? [`\n> ${result.reasoning}`] : []),
+            ...(result.toolActivity.length > 0
+              ? [`\n(${result.toolActivity.length} tool call(s))`]
+              : []),
+          ].join("\n");
+          await linkDelegateSession({
+            parentSessionID: context.sessionID,
+            title: `Cursor delegate (${args.model})`,
+            prompt: args.prompt,
+            transcript,
+          });
+        }
+
         return {
           title: `Cursor delegate (${args.model})`,
           output: (result.text || "(no text output)") + toolNote,

src/plugin/index.ts

@@ -13,9 +13,18 @@ import {
 	translateMcpServers,
 } from "./mcp-config.js";
 import { buildCursorTools } from "./cursor-tools.js";
-import { getLocalVersion, getLatestVersion, clearVersionCache, PLUGIN_CACHE_PATH } from "../version-check.js";
+import {
+	getLocalVersion,
+	getLatestVersion,
+	clearVersionCache,
+	PLUGIN_CACHE_PATH,
+} from "../version-check.js";
 import { removeSystemRule } from "../provider/system-rule.js";
-import { clearLogBridge, pluginLog, setLogBridge } from "../provider/log-bridge.js";
+import {
+	clearLogBridge,
+	pluginLog,
+	setLogBridge,
+} from "../provider/log-bridge.js";
 import {
 	writeSkillMirror,
 	removeSkillMirror,
@@ -29,6 +38,8 @@ import {
 import {
 	clearSubagentBridge,
 	setSubagentBridge,
+	subagentCallChildId,
+	stampTaskPartSessionId,
 } from "../provider/subagent-bridge.js";
 
 function apiKeyFromAuth(auth: Auth | undefined): string | undefined {
@@ -62,17 +73,18 @@ export const CursorPlugin: Plugin = async (input) => {
 
 	// Surfaces the update notice in the UI (toast). Resolved once per plugin
 	// instance using the shared fetch above.
-	const _versionCheckPromise: Promise<{ local: string; latest: string } | null> = (async () => {
-		try {
-			if (process.env.CI || process.env.NO_UPDATE_NOTIFIER) return null;
-			const local = getLocalVersion();
-			const latest = await _latestVersionPromise;
-			if (!local || !latest || !semver.gt(latest, local)) return null;
-			return { local, latest };
-		} catch {
-			return null;
-		}
-	})();
+	const _versionCheckPromise: Promise<{ local: string; latest: string } | null> =
+		(async () => {
+			try {
+				if (process.env.CI || process.env.NO_UPDATE_NOTIFIER) return null;
+				const local = getLocalVersion();
+				const latest = await _latestVersionPromise;
+				if (!local || !latest || !semver.gt(latest, local)) return null;
+				return { local, latest };
+			} catch {
+				return null;
+			}
+		})();
 	let _toastShown = false;
 
 	// The Cursor API key resolved by opencode's auth loader, captured so the
@@ -108,7 +120,6 @@ export const CursorPlugin: Plugin = async (input) => {
 		})
 		.catch(() => {});
 
-
 	const directory = input?.directory;
 	// Publish the opencode client + directory so the provider stream layer can
 	// create a real child session for each Cursor subagent (making its `task`
@@ -180,10 +191,7 @@ export const CursorPlugin: Plugin = async (input) => {
 			const { models } = await discoverModels({});
 			config.provider ??= {};
 			const existing = config.provider[PROVIDER_ID] ?? {};
-			const existingOptions = (existing.options ?? {}) as Record<
-				string,
-				unknown
-			>;
+			const existingOptions = (existing.options ?? {}) as Record<string, unknown>;
 
 			// Forward opencode's configured MCP servers to the Cursor
 			// agent so it can use the same servers. Opt out via
@@ -340,10 +348,9 @@ export const CursorPlugin: Plugin = async (input) => {
 						// Cursor agent can't connect. Only those without a shareable
 						// client registration are skipped; ones with a clientId are
 						// forwarded with an `auth` block for the agent's own OAuth flow.
-						const unshareable = findUnshareableOAuthServers(
-							liveMcp,
-							status,
-						).filter((name) => !warnedOAuth.has(name));
+						const unshareable = findUnshareableOAuthServers(liveMcp, status).filter(
+							(name) => !warnedOAuth.has(name),
+						);
 						if (unshareable.length > 0) {
 							for (const name of unshareable) warnedOAuth.add(name);
 							const plural = unshareable.length > 1;
@@ -382,8 +389,7 @@ export const CursorPlugin: Plugin = async (input) => {
 							writeSkillMirror(resolvedCwd, resolved.skills, (msg) =>
 								pluginLog("warn", msg),
 							);
-							currentSkillsCatalogue =
-								buildSkillsCatalogue(resolved.skills) ?? "";
+							currentSkillsCatalogue = buildSkillsCatalogue(resolved.skills) ?? "";
 							lastSkillHash = hash;
 						}
 					} catch {
@@ -396,6 +402,31 @@ export const CursorPlugin: Plugin = async (input) => {
 			}
 		},
 
+		// Stamp the child session id on the RUNNING `task` part. The provider
+		// creates the child session when the Cursor subagent starts and
+		// publishes call→child on the bridge registry; when opencode's
+		// processor lands the task part (`message.part.updated`), patch it
+		// (`part.update`, the native `ctx.metadata` equivalent) so the TUI
+		// card carries `state.metadata.sessionId` from the start — matching
+		// the native task tool, which publishes the id at execute time. The
+		// processor emits a running-state part update for every streamed
+		// tool part, so this fires early; the stamp is idempotent.
+		event: async (input) => {
+			const evt = input.event;
+			if (evt.type !== "message.part.updated") return;
+			const part = evt.properties.part;
+			if (!part || part.type !== "tool" || part.tool !== "task") return;
+			const childId = subagentCallChildId(part.callID);
+			if (!childId) return;
+			void stampTaskPartSessionId({
+				sessionID: part.sessionID,
+				messageID: part.messageID,
+				partID: part.id,
+				part,
+				childId,
+			});
+		},
+
 		tool: {
 			cursor_update_plugin: {
 				description:
@@ -406,7 +437,11 @@ export const CursorPlugin: Plugin = async (input) => {
 						return {
 							title: "cursor plugin (checks disabled)",
 							output: "Update checks are disabled (CI or NO_UPDATE_NOTIFIER is set).",
-							metadata: { local: undefined, latest: undefined, status: "disabled" as const },
+							metadata: {
+								local: undefined,
+								latest: undefined,
+								status: "disabled" as const,
+							},
 						};
 					}
 
@@ -423,7 +458,8 @@ export const CursorPlugin: Plugin = async (input) => {
 					if (!latest || !semver.valid(latest)) {
 						return {
 							title: "cursor plugin (registry unavailable)",
-							output: "Could not fetch the latest version from npm. Check your network connection and try again.",
+							output:
+								"Could not fetch the latest version from npm. Check your network connection and try again.",
 							metadata: { local, latest, status: "failed" as const },
 						};
 					}
@@ -436,11 +472,12 @@ export const CursorPlugin: Plugin = async (input) => {
 						};
 					}
 
-				// Plugin is outdated — clear the opencode plugin cache so it re-fetches on next launch.
-				const cachePath = PLUGIN_CACHE_PATH;
-				const removeCommand = process.platform === "win32"
-					? `rmdir /s /q "${cachePath}"`
-					: `rm -rf ${cachePath}`;
+					// Plugin is outdated — clear the opencode plugin cache so it re-fetches on next launch.
+					const cachePath = PLUGIN_CACHE_PATH;
+					const removeCommand =
+						process.platform === "win32"
+							? `rmdir /s /q "${cachePath}"`
+							: `rm -rf ${cachePath}`;
 
 					try {
 						rmSync(cachePath, { recursive: true, force: true });
@@ -472,9 +509,7 @@ export const CursorPlugin: Plugin = async (input) => {
 				args: {},
 				execute: async () => {
 					const result = await discoverModels({ forceRefresh: true });
-					const lines = result.models.map(
-						(m) => `- ${m.id} — ${m.displayName}`,
-					);
+					const lines = result.models.map((m) => `- ${m.id} — ${m.displayName}`);
 					const header =
 						result.source === "live"
 							? `Refreshed ${result.models.length} Cursor models (live):`

src/provider/agent-events.ts

@@ -11,6 +11,18 @@ export interface CursorUsage {
   cacheWriteTokens: number;
 }
 
+/**
+ * A single nested update streamed from a Cursor subagent (the `task` tool).
+ * The SDK surfaces these via the `tool-call-delta` interaction update; we
+ * normalize the nested `taskUpdate` union into this small shape so the stream
+ * layer can render it without depending on SDK internals.
+ */
+export type SubagentNestedEvent =
+  | { type: "text"; text: string }
+  | { type: "reasoning"; text: string }
+  | { type: "tool-start"; id: string; name: string; input: unknown }
+  | { type: "tool-result"; id: string; name: string; result: unknown; isError: boolean };
+
 /** Normalized events bridged from the Cursor SDK's push callbacks. */
 export type CursorEvent =
   | { type: "text-delta"; text: string }
@@ -21,7 +33,13 @@ export type CursorEvent =
   | { type: "usage"; usage: CursorUsage }
   | { type: "reasoning-complete"; durationMs?: number }
   | { type: "compaction" }
-  | { type: "finish"; text?: string };
+  | { type: "finish"; text?: string }
+  /**
+   * A nested update from a Cursor subagent. `callId` is the parent's `task`
+   * tool-call id, so the stream layer can route the event to the right child
+   * session. Only one level of nesting is surfaced by the SDK.
+   */
+  | { type: "subagent-event"; callId: string; event: SubagentNestedEvent };
 
 export interface StreamAgentTurnOptions {
   mode: AgentModeOption;
@@ -36,6 +54,10 @@ export interface StreamAgentTurnOptions {
   usageBase?: CursorUsage;
 }
 
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null;
+}
+
 /** Sum two usage reports (either may be absent). */
 export function addUsage(a?: CursorUsage, b?: CursorUsage): CursorUsage | undefined {
   if (!a) return b;
@@ -65,6 +87,56 @@ function toolDisplayName(toolCall: ({ type?: string } & Record<string, any>) | u
   return toolCall.type ?? "tool";
 }
 
+/**
+ * Normalize a nested subagent `taskUpdate` (from the SDK's `tool-call-delta`
+ * interaction update) into a {@link SubagentNestedEvent}, or `undefined` when
+ * the update carries nothing the stream layer renders (partials, step
+ * bookkeeping, thinking-completed). The nested union is read defensively —
+ * the SDK types are the contract, but the shape is opaque at runtime.
+ */
+function normalizeNestedTaskUpdate(update: unknown): SubagentNestedEvent | undefined {
+  if (!isRecord(update)) return undefined;
+  switch (update["type"]) {
+    case "text-delta":
+      return typeof update["text"] === "string"
+        ? { type: "text", text: update["text"] }
+        : undefined;
+    case "thinking-delta":
+      return typeof update["text"] === "string"
+        ? { type: "reasoning", text: update["text"] }
+        : undefined;
+    case "tool-call-started": {
+      const toolCall = isRecord(update["toolCall"]) ? update["toolCall"] : undefined;
+      const id = typeof update["callId"] === "string" ? update["callId"] : "";
+      return {
+        type: "tool-start",
+        id,
+        name: toolDisplayName(toolCall),
+        input: toolCall?.args ?? {},
+      };
+    }
+    case "tool-call-completed": {
+      const toolCall = isRecord(update["toolCall"]) ? update["toolCall"] : undefined;
+      const id = typeof update["callId"] === "string" ? update["callId"] : "";
+      const result = toolCall?.result;
+      const resultValue = isRecord(result) ? result["value"] : undefined;
+      const mcpError =
+        toolCall?.type === "mcp" && isRecord(resultValue) && resultValue["isError"] === true;
+      return {
+        type: "tool-result",
+        id,
+        name: toolDisplayName(toolCall),
+        result: result ?? null,
+        isError: (isRecord(result) && result["status"] === "error") || mcpError,
+      };
+    }
+    default:
+      // partial-tool-call, thinking-completed, step-started, step-completed:
+      // nothing to render (the final tool-call carries full args).
+      return undefined;
+  }
+}
+
 /**
  * Node stores a timer delay in a signed 32-bit int; anything larger overflows
  * and is silently clamped to `1`. An operator following the tool-phase stall
@@ -203,6 +275,21 @@ export async function* streamAgentTurn(
         });
         break;
       }
+      case "tool-call-delta": {
+        // Nested updates from a Cursor subagent (the `task` tool). `callId` is
+        // the parent task tool-call id; the stream layer routes the event to
+        // the matching child session. Ignored when the nested update carries
+        // nothing renderable.
+        const nested = normalizeNestedTaskUpdate(update.taskUpdate);
+        if (nested) {
+          push({
+            type: "subagent-event",
+            callId: String(update.callId),
+            event: nested,
+          });
+        }
+        break;
+      }
       case "turn-ended":
         // Reconcile: a dropped or differently-keyed `tool-call-completed`
         // would otherwise leave an entry pinned here, holding the turn on the