@stablekernel/opencode-cursor 0.7.1 → 0.8.0

package/CHANGELOG.md

@@ -4,6 +4,39 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.8.0] — 2026-08-21
+
+Live Cursor subagent activity: the `task` card behaves like a native opencode
+subagent card — navigable while running, with a live activity subtitle — and
+the child session carries the subagent's full transcript (#99).
+
+- **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

package/dist/{chunk-RDY3H2LE.js → chunk-YIEC27VB.js}

@@ -542,6 +542,88 @@ function resolveSystemDelivery(options) {
   return { mode, settingSources: settingSources ?? ["project"] };
 }
 
+// src/provider/child-parts.ts
+import { randomBytes } from "crypto";
+var BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var RANDOM_LENGTH = 14;
+var lastTimestamp = 0;
+var counter = 0;
+function createPartID(now) {
+  const timestamp = now ?? Date.now();
+  if (timestamp !== lastTimestamp) {
+    lastTimestamp = timestamp;
+    counter = 0;
+  }
+  counter++;
+  const value = BigInt(timestamp) * BigInt(4096) + BigInt(counter);
+  const bytes = Buffer.alloc(6);
+  for (let i = 0; i < 6; i++) {
+    bytes[i] = Number(value >> BigInt(40 - 8 * i) & BigInt(255));
+  }
+  let random = "";
+  const raw = randomBytes(RANDOM_LENGTH);
+  for (let i = 0; i < RANDOM_LENGTH; i++) random += BASE62[raw[i] % 62];
+  return `prt_${bytes.toString("hex")}${random}`;
+}
+var PART_URL = "/session/{sessionID}/message/{messageID}/part/{partID}";
+async function upsertToolPart(opts) {
+  const bridge = getSubagentBridge();
+  const request = bridge?.client?._client?.request;
+  if (!bridge || !request) {
+    pluginLog("debug", "subagent: tool part skipped", {
+      reason: "no bridge",
+      tool: opts.tool
+    });
+    return false;
+  }
+  const state = {
+    status: opts.status,
+    input: opts.input ?? {},
+    time: opts.status === "completed" ? { start: opts.start, end: opts.end ?? Date.now() } : { start: opts.start }
+  };
+  if (opts.title) state["title"] = opts.title;
+  if (opts.status === "completed") {
+    state["output"] = opts.output ?? "";
+    state["metadata"] = {};
+  }
+  try {
+    const res = await request({
+      method: "PATCH",
+      url: PART_URL,
+      path: {
+        sessionID: opts.sessionID,
+        messageID: opts.messageID,
+        partID: opts.partID
+      },
+      ...bridge.directory ? { query: { directory: bridge.directory } } : {},
+      body: {
+        id: opts.partID,
+        messageID: opts.messageID,
+        sessionID: opts.sessionID,
+        type: "tool",
+        callID: opts.callID,
+        tool: opts.tool,
+        state
+      }
+    });
+    if (typeof res === "object" && res !== null && "error" in res && res.error != null) {
+      pluginLog("warn", "subagent: tool part upsert rejected", {
+        tool: opts.tool,
+        status: opts.status,
+        error: JSON.stringify(res.error).slice(0, 300)
+      });
+      return false;
+    }
+    return true;
+  } catch (err) {
+    pluginLog("warn", "subagent: tool part upsert failed", {
+      tool: opts.tool,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  }
+}
+
 // src/provider/subagent-bridge.ts
 var BRIDGE_KEY2 = /* @__PURE__ */ Symbol.for("@stablekernel/opencode-cursor:subagent-bridge");
 function setSubagentBridge(bridge) {
@@ -553,6 +635,80 @@ function clearSubagentBridge() {
 function getSubagentBridge() {
   return globalThis[BRIDGE_KEY2];
 }
+var CALL_REGISTRY_KEY = /* @__PURE__ */ Symbol.for(
+  "@stablekernel/opencode-cursor:subagent-calls"
+);
+function callRegistry() {
+  const holder = globalThis;
+  if (!holder[CALL_REGISTRY_KEY]) holder[CALL_REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  return holder[CALL_REGISTRY_KEY];
+}
+function registerSubagentCall(callId, childId) {
+  callRegistry().set(callId, childId);
+}
+function unregisterSubagentCall(callId) {
+  callRegistry().delete(callId);
+}
+function subagentCallChildId(callId) {
+  return callRegistry().get(callId);
+}
+async function stampTaskPartSessionId(opts) {
+  const bridge = getSubagentBridge();
+  if (!bridge) return skipStamp("no bridge", opts.childId);
+  if (!isRecord(opts.part)) return skipStamp("part not a record", opts.childId);
+  const state = isRecord(opts.part["state"]) ? opts.part["state"] : void 0;
+  if (!state || state["status"] !== "running") {
+    return skipStamp(`event state ${String(state?.["status"])}`, opts.childId);
+  }
+  const metadata = isRecord(state["metadata"]) ? { ...state["metadata"] } : {};
+  if (metadata["sessionId"] === opts.childId) return;
+  metadata["sessionId"] = opts.childId;
+  const rawClient = bridge.client._client;
+  if (!rawClient?.request)
+    return skipStamp("client has no request()", opts.childId);
+  try {
+    const msgRes = await bridge.client.session.message({
+      path: { id: opts.sessionID, messageID: opts.messageID },
+      ...bridge.directory ? { query: { directory: bridge.directory } } : {}
+    });
+    const current = msgRes?.data?.parts?.find((p) => isRecord(p) && p["id"] === opts.partID);
+    if (!isRecord(current))
+      return skipStamp("part not found on re-read", opts.childId);
+    const currentState = isRecord(current["state"]) ? current["state"] : void 0;
+    if (!currentState || currentState["status"] !== "running") {
+      return skipStamp(
+        `re-read state ${String(currentState?.["status"])}`,
+        opts.childId
+      );
+    }
+    const currentMetadata = isRecord(currentState["metadata"]) ? { ...currentState["metadata"] } : {};
+    currentMetadata["sessionId"] = opts.childId;
+    await rawClient.request({
+      method: "PATCH",
+      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+      path: {
+        sessionID: opts.sessionID,
+        messageID: opts.messageID,
+        partID: opts.partID
+      },
+      ...bridge.directory ? { query: { directory: bridge.directory } } : {},
+      body: { ...current, state: { ...currentState, metadata: currentMetadata } }
+    });
+    pluginLog("debug", "subagent: stamped task part", {
+      childId: opts.childId,
+      partID: opts.partID
+    });
+  } catch (err) {
+    pluginLog("warn", "subagent: task part stamp failed", {
+      childId: opts.childId,
+      partID: opts.partID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function skipStamp(reason, childId) {
+  pluginLog("debug", "subagent: task part stamp skipped", { reason, childId });
+}
 function isRecord(v) {
   return typeof v === "object" && v !== null;
 }
@@ -574,7 +730,8 @@ function activityLine(value) {
   const steps = isRecord(value) && Array.isArray(value["conversationSteps"]) ? value["conversationSteps"].length : void 0;
   const bits = [];
   if (steps && steps > 0) bits.push(`${steps} step${steps === 1 ? "" : "s"}`);
-  if (typeof durationMs === "number") bits.push(`in ${formatDuration(durationMs)}`);
+  if (typeof durationMs === "number")
+    bits.push(`in ${formatDuration(durationMs)}`);
   return bits.length > 0 ? `_Subagent ran ${bits.join(" ")}._` : void 0;
 }
 var UNSPECIFIED_KIND = "unspecified";
@@ -586,18 +743,122 @@ function subagentLabel(args) {
   if (kind && kind !== UNSPECIFIED_KIND) return kind;
   return "general";
 }
+function renderStep(step) {
+  if (!isRecord(step)) return void 0;
+  const norm = normalizeStep(step);
+  if (!norm) return dumpStep(step);
+  switch (norm.kind) {
+    case "assistantMessage": {
+      const text = strField(norm.payload, "text");
+      return text ? text : void 0;
+    }
+    case "thinkingMessage": {
+      const text = strField(norm.payload, "text");
+      return text ? `> ${text}` : void 0;
+    }
+    case "toolCall": {
+      const { name, args, result } = toolCallInfo(norm.payload);
+      let arg = "";
+      try {
+        const s = typeof args === "string" ? args : JSON.stringify(args);
+        if (s && s !== "{}" && s !== '""') arg = ` ${s}`;
+      } catch {
+      }
+      const head = `**\`${name}\`**${arg}`;
+      const out = resultText(result);
+      return out ? `${head}
+
+\`\`\`
+${out}
+\`\`\`` : head;
+    }
+    default:
+      return dumpStep(step);
+  }
+}
+function dumpStep(step) {
+  try {
+    const s = JSON.stringify(step);
+    return s && s !== "{}" ? `\`\`\`json
+${s}
+\`\`\`` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var STEP_KINDS = ["assistantMessage", "toolCall", "thinkingMessage"];
+function normalizeStep(step) {
+  const selected = oneofMember(step["message"]);
+  if (selected) return { kind: selected.kind, payload: selected.value };
+  const type = strField(step, "type");
+  if (type) return { kind: type, payload: step["message"] };
+  for (const kind of STEP_KINDS) {
+    if (kind in step) return { kind, payload: step[kind] };
+  }
+  return void 0;
+}
+function oneofMember(container) {
+  if (!isRecord(container)) return void 0;
+  const kind = strField(container, "case");
+  return kind ? { kind, value: container["value"] } : void 0;
+}
+var TOOL_CALL_SUFFIX = "ToolCall";
+function toolCallInfo(payload) {
+  const rec = isRecord(payload) ? payload : void 0;
+  const selected = oneofMember(rec?.["tool"]);
+  if (selected)
+    return { ...toolName(selected.kind), ...toolFields(selected.value) };
+  const type = strField(rec, "type");
+  if (type) return { name: type, args: rec?.["args"], result: rec?.["result"] };
+  for (const [key, value] of Object.entries(rec ?? {})) {
+    if (!key.endsWith(TOOL_CALL_SUFFIX)) continue;
+    return { ...toolName(key), ...toolFields(value) };
+  }
+  return { name: "tool", args: void 0, result: void 0 };
+}
+function toolName(key) {
+  return {
+    name: key.endsWith(TOOL_CALL_SUFFIX) ? key.slice(0, -TOOL_CALL_SUFFIX.length) : key
+  };
+}
+function toolFields(value) {
+  const rec = isRecord(value) ? value : void 0;
+  return { args: rec?.["args"], result: rec?.["result"] };
+}
+function resultText(result) {
+  if (typeof result === "string") return result;
+  if (!isRecord(result)) return "";
+  if (typeof result["stdout"] === "string" && result["stdout"])
+    return result["stdout"];
+  if (typeof result["content"] === "string" && result["content"])
+    return result["content"];
+  if (result["status"] === "success" && typeof result["value"] === "string")
+    return result["value"];
+  const value = result["value"];
+  if (isRecord(value)) {
+    if (typeof value["stdout"] === "string") return value["stdout"];
+    if (typeof value["fileContentAfterWrite"] === "string")
+      return value["fileContentAfterWrite"];
+  }
+  try {
+    const s = JSON.stringify(result);
+    return s && s !== "{}" ? s : "";
+  } catch {
+    return "";
+  }
+}
+function renderConversationSteps(value) {
+  if (!isRecord(value) || !Array.isArray(value["conversationSteps"]))
+    return void 0;
+  const rendered = value["conversationSteps"].map(renderStep).filter((s) => Boolean(s));
+  return rendered.length > 0 ? rendered.join("\n\n") : void 0;
+}
 function buildTranscript(value) {
   const parts = [];
   const suffix = strField(value, "resultSuffix");
   if (suffix) parts.push(suffix);
-  if (isRecord(value) && Array.isArray(value["conversationSteps"])) {
-    const steps = value["conversationSteps"];
-    const rendered = steps.flatMap((s) => {
-      const text = strField(s, "text") ?? strField(s, "content");
-      return text ? [text] : [];
-    }).join("\n\n");
-    if (rendered) parts.push(rendered);
-  }
+  const steps = renderConversationSteps(value);
+  if (steps) parts.push(steps);
   const activity = activityLine(value);
   if (activity) parts.push(activity);
   const body = parts.join("\n\n").trim();
@@ -642,6 +903,111 @@ async function linkSubagentSession(opts) {
     return void 0;
   }
 }
+async function linkSubagentSessionLive(opts) {
+  const bridge = getSubagentBridge();
+  if (!bridge) return void 0;
+  const { client, directory } = bridge;
+  const query = directory ? { directory } : void 0;
+  try {
+    const description = strField(opts.args, "description") ?? "Subagent task";
+    const agent = subagentLabel(opts.args);
+    const created = await client.session.create({
+      body: {
+        parentID: opts.parentSessionID,
+        title: `${description} (@${agent} subagent)`
+      },
+      ...query ? { query } : {}
+    });
+    const childId = created?.data?.id;
+    if (!childId) return void 0;
+    let messageID;
+    const prompt = strField(opts.args, "prompt");
+    if (prompt) {
+      const seeded = await client.session.prompt({
+        path: { id: childId },
+        ...query ? { query } : {},
+        body: { noReply: true, parts: [{ type: "text", text: prompt }] }
+      });
+      messageID = strField(
+        seeded?.data?.info,
+        "id"
+      );
+    }
+    let done = false;
+    let chain = Promise.resolve();
+    const post = (text) => {
+      chain = chain.then(
+        () => client.session.prompt({
+          path: { id: childId },
+          ...query ? { query } : {},
+          body: { noReply: true, parts: [{ type: "text", text }] }
+        }).then(() => void 0).catch(() => void 0)
+      );
+      return chain;
+    };
+    return {
+      childId,
+      messageID,
+      flush: (markdown) => done ? Promise.resolve() : post(markdown),
+      toolPart: async (part) => {
+        if (done || !messageID) return void 0;
+        const partID = part.partID ?? createPartID();
+        const written = await upsertToolPart({
+          sessionID: childId,
+          messageID,
+          partID,
+          callID: part.callID,
+          tool: part.tool,
+          status: part.status,
+          title: part.title,
+          input: part.input,
+          output: part.output,
+          start: part.start,
+          end: part.end
+        });
+        return written ? partID : void 0;
+      },
+      finalize: async (activity) => {
+        if (done) return;
+        done = true;
+        if (activity) await post(activity);
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function linkDelegateSession(opts) {
+  const bridge = getSubagentBridge();
+  if (!bridge) return void 0;
+  const { client, directory } = bridge;
+  const query = directory ? { directory } : void 0;
+  try {
+    const created = await client.session.create({
+      body: { parentID: opts.parentSessionID, title: opts.title },
+      ...query ? { query } : {}
+    });
+    const childId = created?.data?.id;
+    if (!childId) return void 0;
+    if (opts.prompt) {
+      await client.session.prompt({
+        path: { id: childId },
+        ...query ? { query } : {},
+        body: { noReply: true, parts: [{ type: "text", text: opts.prompt }] }
+      });
+    }
+    if (opts.transcript) {
+      await client.session.prompt({
+        path: { id: childId },
+        ...query ? { query } : {},
+        body: { noReply: true, parts: [{ type: "text", text: opts.transcript }] }
+      });
+    }
+    return childId;
+  } catch {
+    return void 0;
+  }
+}
 
 // src/provider/error-classify.ts
 function classifyError(err) {
@@ -677,6 +1043,9 @@ function classifyError(err) {
 }
 
 // src/provider/agent-events.ts
+function isRecord2(v) {
+  return typeof v === "object" && v !== null;
+}
 function addUsage(a, b) {
   if (!a) return b;
   if (!b) return a;
@@ -697,6 +1066,41 @@ function toolDisplayName(toolCall) {
   }
   return toolCall.type ?? "tool";
 }
+function normalizeNestedTaskUpdate(update) {
+  if (!isRecord2(update)) return void 0;
+  switch (update["type"]) {
+    case "text-delta":
+      return typeof update["text"] === "string" ? { type: "text", text: update["text"] } : void 0;
+    case "thinking-delta":
+      return typeof update["text"] === "string" ? { type: "reasoning", text: update["text"] } : void 0;
+    case "tool-call-started": {
+      const toolCall = isRecord2(update["toolCall"]) ? update["toolCall"] : void 0;
+      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 = isRecord2(update["toolCall"]) ? update["toolCall"] : void 0;
+      const id = typeof update["callId"] === "string" ? update["callId"] : "";
+      const result = toolCall?.result;
+      const resultValue = isRecord2(result) ? result["value"] : void 0;
+      const mcpError = toolCall?.type === "mcp" && isRecord2(resultValue) && resultValue["isError"] === true;
+      return {
+        type: "tool-result",
+        id,
+        name: toolDisplayName(toolCall),
+        result: result ?? null,
+        isError: isRecord2(result) && result["status"] === "error" || mcpError
+      };
+    }
+    default:
+      return void 0;
+  }
+}
 var MAX_TIMEOUT_MS = 2147483647;
 function envMs(name, fallback) {
   const raw = process.env[name];
@@ -787,6 +1191,17 @@ async function* streamAgentTurn(agent, message, options) {
         });
         break;
       }
+      case "tool-call-delta": {
+        const nested = normalizeNestedTaskUpdate(update.taskUpdate);
+        if (nested) {
+          push({
+            type: "subagent-event",
+            callId: String(update.callId),
+            event: nested
+          });
+        }
+        break;
+      }
       case "turn-ended":
         openTools.clear();
         if (update.usage) {
@@ -977,7 +1392,7 @@ function buildModelSelection(modelId, params) {
   const paramList = Object.entries(params ?? {}).map(([id, value]) => ({ id, value }));
   return paramList.length > 0 ? { id: modelId, params: paramList } : { id: modelId };
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isMode(value) {
@@ -990,7 +1405,7 @@ function resolveControls(modelId, staticControls, providerOptions) {
     ...staticControls.defaults ?? {},
     ...staticControls.params ?? {}
   };
-  if (isRecord2(po["params"])) {
+  if (isRecord3(po["params"])) {
     for (const [key, value] of Object.entries(po["params"])) {
       if (value != null) params[key] = String(value);
     }
@@ -1145,7 +1560,16 @@ export {
   sendAgentTurnSilently,
   setSubagentBridge,
   clearSubagentBridge,
+  registerSubagentCall,
+  unregisterSubagentCall,
+  subagentCallChildId,
+  stampTaskPartSessionId,
+  activityLine,
+  resultText,
+  renderConversationSteps,
   linkSubagentSession,
+  linkSubagentSessionLive,
+  linkDelegateSession,
   buildModelSelection,
   resolveControls,
   getSessionRecord,
@@ -1153,4 +1577,4 @@ export {
   withSessionLock,
   acquireAgent
 };
-//# sourceMappingURL=chunk-RDY3H2LE.js.map
+//# sourceMappingURL=chunk-YIEC27VB.js.map