feat: navigable Cursor subagents + release v0.6.0-next.0

Cursor's task tool now renders as a real, navigable opencode child session
(parentID-linked, clickable, ctrl+x down) instead of a dead 'Unspecified Task'
card. The plugin bridges its opencode client to the provider stream layer
(src/provider/subagent-bridge.ts); on each completed subagent it creates a
child session seeded with the prompt + Cursor's transcript and real duration,
and stamps metadata.sessionId onto the task part. Best-effort: degrades to the
prior non-navigable card when the client is unavailable.

Also fixes the 'Unspecified Task' label (Cursor's proto zero-value kind is no
longer forwarded; falls back to opencode's 'General Task' or the real name).

Bump: 0.5.0-next.0 -> 0.6.0-next.0; CHANGELOG updated.

Author: justin-carper

CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.6.0-next.0] — 2026-07-24
+
+Native Cursor subagents: the Cursor agent's `task` tool now renders as a
+navigable opencode child session instead of a dead "Unspecified Task" card.
+
+- **Cursor subagents are now navigable opencode child sessions.** When the Cursor
+  agent runs its `task` tool, the plugin creates a real opencode child session
+  (`parentID` = the current session) and links it to the task card, so it's
+  clickable and reachable via `ctrl+x down` — like a native subagent. The child
+  session is seeded with the subagent's prompt and Cursor's returned transcript
+  plus a real duration line (posted as user-role messages via `noReply`; the
+  public API can't synthesize assistant messages). Best-effort: if the opencode
+  client is unavailable the card degrades to its previous, non-navigable form.
+  The plugin hands its opencode client to the provider stream layer through an
+  in-process bridge (`src/provider/subagent-bridge.ts`).
+- **Fixed: generic Cursor subagents rendered as "Unspecified Task".** Cursor's
+  proto zero-value `subagentType.kind` (`"unspecified"`) is no longer forwarded
+  as the agent label; the card now falls back to opencode's "General Task" (or
+  the real subagent name when Cursor provides one).
+
 ## [0.5.0] — 2026-07-24
 
 Native-experience overhaul: in-process HTTP/1.1 transport under Bun, typed-error

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@stablekernel/opencode-cursor",
-  "version": "0.5.0",
+  "version": "0.6.0-next.0",
   "description": "opencode provider plugin backed by the official Cursor SDK (@cursor/sdk) — adds a Cursor provider and lists its models",
   "type": "module",
   "license": "MIT",

package.json

@@ -13,6 +13,10 @@ import {
 import { buildCursorTools } from "./cursor-tools.js";
 import { warnIfStale } from "../version-check.js";
 import { removeSystemRule } from "../provider/system-rule.js";
+import {
+	clearSubagentBridge,
+	setSubagentBridge,
+} from "../provider/subagent-bridge.js";
 
 function apiKeyFromAuth(auth: Auth | undefined): string | undefined {
 	return auth?.type === "api" ? auth.key : undefined;
@@ -49,6 +53,11 @@ export const CursorPlugin: Plugin = async (input) => {
 	// (reflecting mid-session enable/disable) rather than the startup snapshot.
 	const client = input?.client;
 	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`
+	// card clickable / `ctrl+x`-navigable). Same-process handoff via a globalThis
+	// registry; the provider degrades gracefully when it's absent.
+	if (client) setSubagentBridge({ client, directory });
 	// Canonical working directory for the generated system-prompt rule: the
 	// provider writes `.cursor/rules/opencode.mdc` under this path and dispose
 	// cleans it up from the same path. The config hook threads it into the
@@ -265,6 +274,7 @@ export const CursorPlugin: Plugin = async (input) => {
 			// Uses the same canonical cwd the provider wrote to; sentinel-guarded,
 			// so a user-owned opencode.mdc is never deleted.
 			removeSystemRule(resolvedCwd);
+			clearSubagentBridge();
 		},
 	};
 };

src/plugin/index.ts

@@ -498,11 +498,19 @@ export class CursorLanguageModel implements LanguageModelV3 {
 	async doStream(options: LanguageModelV3CallOptions): Promise<{
 		stream: ReadableStream<LanguageModelV3StreamPart>;
 	}> {
+		// Parent opencode session id (same source agentRun reads) so a Cursor
+		// subagent's `task` part can be linked to a real opencode child session.
+		const po = options.providerOptions?.[this.provider] as
+			| Record<string, unknown>
+			| undefined;
+		const sessionID =
+			typeof po?.["sessionID"] === "string"
+				? (po["sessionID"] as string)
+				: undefined;
 		return {
-			stream: cursorEventsToStream(
-				this.agentRun(options),
-				this.config.toolDisplay,
-			),
+			stream: cursorEventsToStream(this.agentRun(options), this.config.toolDisplay, {
+				sessionID,
+			}),
 		};
 	}
 

src/provider/language-model.ts

@@ -5,6 +5,38 @@ import type {
 	LanguageModelV3Usage,
 } from "@ai-sdk/provider";
 import type { CursorEvent, CursorUsage } from "./agent-events.js";
+import { linkSubagentSession } from "./subagent-bridge.js";
+
+/** Per-turn context threaded from the language model into the stream mapper. */
+export interface StreamContext {
+	/** Parent opencode session id, used to link Cursor subagents as children. */
+	sessionID?: string;
+}
+
+/** Cursor's subagent tool name (the `task` tool-call/tool-result event name). */
+const TASK_TOOL_NAME = "task";
+
+/**
+ * Inject a linked child-session id into an already-folded `task` tool-result
+ * part so the TUI renders the card as clickable / `ctrl+x`-navigable. The
+ * folded result object lives on `part.result` ({@link nativeToolResult}); its
+ * `metadata` is a fresh object per call, so mutation here is safe.
+ */
+function injectSubagentSessionId(
+	parts: BlockToolPart[],
+	sessionId: string,
+): void {
+	for (const part of parts) {
+		if (part.type !== "tool-result" || part.toolName !== "task") continue;
+		const folded = (part as { result?: unknown }).result;
+		if (!isRecord(folded)) continue;
+		const metadata = isRecord(folded["metadata"])
+			? (folded["metadata"] as Record<string, unknown>)
+			: {};
+		metadata["sessionId"] = sessionId;
+		(folded as Record<string, unknown>)["metadata"] = metadata;
+	}
+}
 
 /**
  * How Cursor's internal tool activity (shell/read/edit/mcp/…) is surfaced to
@@ -158,6 +190,20 @@ function successValue(result: unknown): unknown {
 		: undefined;
 }
 
+/**
+ * The opencode `task` input's `subagent_type` field, or `{}` to omit it. Prefers
+ * Cursor's real subagent `name`; accepts a `kind` only when it isn't the proto
+ * zero-value `"unspecified"` (which the TUI would titlecase to "Unspecified
+ * Task"). Omitting the field makes the TUI fall back to "General Task".
+ */
+function subagentTypeField(args: unknown): { subagent_type?: string } {
+	const sub = isRecord(args) ? args["subagentType"] : undefined;
+	const name = strField(sub, "name");
+	const kind = strField(sub, "kind");
+	const subagent = name ?? (kind && kind !== "unspecified" ? kind : undefined);
+	return subagent ? { subagent_type: subagent } : {};
+}
+
 /** The `{title, metadata, output}` shape opencode folds into a tool part's state. */
 interface FoldedResult {
 	title: string;
@@ -556,19 +602,16 @@ const NATIVE_ADAPTERS: Record<string, NativeToolAdapter> = {
 		},
 	},
 	// Cursor `task` (subagent) → opencode `task` (agent card: name + description).
-	// Non-clickable here — the subagent ran inside Cursor, not as an opencode
-	// child session — but the native card reads far better than raw JSON.
+	// Made navigable in the stream layer: when a parent session + the plugin
+	// bridge are present, a real opencode child session is created and its id is
+	// stamped onto this result's `metadata.sessionId` (see cursorEventsToStream's
+	// tool-result path). Without that link it degrades to a non-navigable card.
 	task: {
 		tool: "task",
-		input: (args) => {
-			const description = strField(args, "description") ?? "";
-			const sub = isRecord(args) ? args["subagentType"] : undefined;
-			const subagent =
-				strField(sub, "name") ?? strField(sub, "kind") ?? undefined;
-			return subagent
-				? { description, subagent_type: subagent }
-				: { description };
-		},
+		input: (args) => ({
+			description: strField(args, "description") ?? "",
+			...subagentTypeField(args),
+		}),
 		result: (value, args) => {
 			const description = strField(args, "description") ?? "";
 			const suffix = strField(value, "resultSuffix");
@@ -1029,6 +1072,7 @@ const DANGLING_TOOL_RESULT = {
 export function cursorEventsToStream(
 	events: AsyncIterable<CursorEvent>,
 	toolDisplay: ToolDisplay = "blocks",
+	ctx: StreamContext = {},
 ): ReadableStream<LanguageModelV3StreamPart> {
 	return new ReadableStream<LanguageModelV3StreamPart>({
 		async start(controller) {
@@ -1183,6 +1227,13 @@ export function cursorEventsToStream(
 						case "tool-result":
 							if (toolState.dropped.delete(event.id)) break;
 							if (toolDisplay === "blocks") {
+								// Capture the original call args before blockToolResultParts
+								// clears the open-tool entry — the subagent link needs the
+								// task description/prompt, which live on the call, not result.
+								const taskArgs =
+									event.name === TASK_TOOL_NAME
+										? toolState.open.get(event.id)?.args
+										: undefined;
 								const parts = blockToolResultParts(
 									event.id,
 									event.name,
@@ -1194,6 +1245,23 @@ export function cursorEventsToStream(
 									closeText();
 									closeReasoning();
 								}
+								// A Cursor subagent ran inside Cursor (no opencode child
+								// session). Create a real child session now and point the task
+								// card at it so it's clickable / ctrl+x-navigable. Best-effort:
+								// linkSubagentSession swallows all failures and returns
+								// undefined, leaving the card exactly as before.
+								if (
+									event.name === TASK_TOOL_NAME &&
+									!event.isError &&
+									ctx.sessionID
+								) {
+									const childId = await linkSubagentSession({
+										parentSessionID: ctx.sessionID,
+										args: taskArgs,
+										result: event.result,
+									});
+									if (childId) injectSubagentSessionId(parts, childId);
+								}
 								for (const part of parts) {
 									controller.enqueue(part);
 								}