pi-cursor-sdk 0.1.41 → 0.1.42

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Unreleased
 
+## 0.1.42 - 2026-06-10
+
+### Added
+
+- Surface Cursor SDK `task` activity as `Cursor subagent` replay/lifecycle cards by default, including description, subagent kind, model, short safe agent ID metadata, task-only expand hints, and returned `conversationSteps` summaries when the SDK provides them.
+- Add `PI_CURSOR_TASK_PRESENTATION=task` as an escape hatch for the older explicit `Cursor task` wording.
+
+### Fixed
+
+- Suppress unsafe nested subagent path displays, including out-of-workspace absolute paths, traversal, home aliases, URI-shaped paths, and Windows drive forms, while preserving in-workspace relative summaries.
+
 ## 0.1.41 - 2026-06-09
 
 ### Changed

package/README.md

@@ -417,6 +417,8 @@ pi shows **Cursor web search** / **Cursor web fetch** activity cards only when t
 
 Known SDK boundary: some local Cursor web search activity is not emitted through live `onDelta`, `onStep`, or `run.stream()` tool events. When that happens, pi can only reconstruct a card from the local agent transcript after `run.wait()` finishes, so the **Cursor web search** card may appear after assistant text rather than as a live in-progress card. Buffering all assistant text until `run.wait()` would make the ordering prettier but would break normal streaming, so pi does not do that.
 
+Known SDK boundary: Cursor SDK `task` activity is shown as **Cursor subagent** because it represents Cursor-spawned child-agent work, but the SDK does not always emit a live nested subagent action stream. Pi shows the subagent start, final output, kind/model/short-ID metadata, and any `conversationSteps` tool-call summaries Cursor returns. If Cursor only returns final subagent text, pi cannot show the subagent's internal read/shell/MCP steps.
+
 Many runs never expose web activity as replayable SDK tool completions or local transcript web tool records. The model may still answer from internal Cursor web tooling or only mention search in assistant text/thinking. In that case pi cannot render a tool card because there is no completed SDK tool-call payload to replay. Capture a run with `npm run debug:provider-events` when investigating; if `on-delta.jsonl`, `on-step.jsonl`, `stream-events.jsonl`, `coordinator-events.jsonl`, and `display-decisions.jsonl` have no completed or transcript web tool data, the limitation is on the Cursor SDK surface, not pi replay registration.
 
 **Web fetch:** `pi-cursor-sdk` can display `webFetchToolCall` transcript records and web-fetch-shaped MCP/host completions when Cursor reports them. It cannot make Cursor expose or execute a `WebFetch` tool. If Cursor's current local SDK tool set does not include WebFetch, pi cannot fetch a URL through Cursor web fetch; use an allowed browser/shell/MCP tool instead.

package/docs/cursor-model-ux-spec.md

@@ -29,7 +29,7 @@ Current implementation notes:
 - Cursor SDK MCP tool calls use a guarded timeout override because installed `@cursor/sdk` 1.0.18 has a 60-second MCP request default with no public per-server timeout option. The extension extends the verified Cursor SDK MCP `callTool` timeout path to 3600 seconds by default and shortens the verified first-send MCP initialize/listTools timeout paths to 10 seconds by default so unavailable configured MCP servers do not block the first reply for a full minute; unknown MCP protocol timeout stacks keep the SDK default. Users can override tool-call timeouts with `PI_CURSOR_MCP_TOOL_TIMEOUT_MS` or `PI_CURSOR_MCP_TOOL_TIMEOUT_SECONDS`, and initialize/listTools timeouts with `PI_CURSOR_MCP_CONNECT_TIMEOUT_MS` or `PI_CURSOR_MCP_CONNECT_TIMEOUT_SECONDS`.
 - Bridge diagnostics are opt-in only: `PI_CURSOR_PI_TOOL_BRIDGE_DEBUG=1` writes typed, allowlisted, scrubbed single-line JSONL records to `process.stderr` with prefix `[pi-cursor-sdk:bridge]`. Diagnostics are scrubbed operational logs, not anonymous telemetry. They intentionally include tool names, safe correlation IDs, run lifecycle, exposed pi↔MCP name pairs, queued requests, result resolution, rejection, cancellation, and pending counts. Correlation IDs are generated independently from the tokenized endpoint path, and Cursor MCP call IDs are hashed before serialization. Diagnostics must not include endpoint paths/URLs/path components/tokens, API keys, bearer tokens, cookies, session credentials, raw args/results, stdout/stderr payloads, file contents, Cursor settings output, or local private session paths in tracked docs, and they must not call pi UI status, notification, or footer APIs. If tool names themselves are unacceptable for a release target, bridge debug diagnostics are not safe for shared logs under the current contract.
 - This repo does not provide a generic desktop-automation, browser-driver, or CDP recipe. Provider docs should describe pi-cursor-sdk's Cursor provider/bridge contract only.
-- Cursor internal tool activity is recorded from SDK events and scrubbed. Maintainer reference for all 16 `@cursor/sdk@1.0.18` `ToolType` values, runtime alias normalization, and intentional mapping/fallback rules: [Cursor native tool replay — SDK ToolType replay matrix](./cursor-native-tool-replay.md#sdk-tooltype-replay-matrix) (official SDK docs: https://cursor.com/docs/sdk/typescript). In TUI sessions and structured JSON/RPC modes, supported completed `read`, `bash`, `grep`, `find`, `ls`, `edit`, `write`, diagnostics, delete, todo/plan, task, image generation, MCP, semantic search, and screen recording activity is replayed through pi's native tool-call rendering path with recorded Cursor results, so users and JSON/RPC consumers can see native-looking cards/events without rerunning Cursor's reads/shell commands/file edits. Cursor `glob` activity is replayed through native `find` cards. Cursor write activity is replayed through native-looking `write` cards, and Cursor StrReplace/edit activity uses native-looking `edit` only when recorded arguments truthfully satisfy pi's `edit` schema; path-only Cursor edit and notebook edit replay falls back to neutral Cursor activity before pi validation. Diagnostics, delete, todos/plans, task, image, and MCP activity use neutral Cursor activity cards with pi's default success/error shell. Neutral Cursor activity calls include `activityTitle` and, when available, `activitySummary` so partial/collapsed cards preserve identity such as `Cursor plan`, `Cursor todos`, `Cursor MCP`, or `Cursor edit`. For long-running or externally meaningful Cursor tools (`task`, `shell`, `mcp`, `generateImage`, `recordScreen`, `semSearch`, web search/fetch, plan/todo), the provider may surface one low-noise deferred in-progress thinking line such as `Cursor MCP: external_search` from bounded, scrubbed SDK args; fast local tools (`read`, `grep`, `glob`, and similar) skip lifecycle lines when completion follows immediately, and pi bridge MCP calls are excluded because pi already shows real pi tool execution ([lifecycle visibility](./cursor-native-tool-replay.md#low-noise-tool-lifecycle-visibility)). Replay-only tools display recorded Cursor results, normalize workspace-local paths/diff headers for display, use pi diff colors for edit previews and path-inferred syntax highlighting for write previews, and fail closed if called without a recorded result. Native replay wrappers are registered only for tool names not already owned by another extension; conflicting tools use the bounded scrubbed transcript fallback. Cursor workflow tools such as mode/task/todo/plan activity are not pi workflow controls; reported todo/plan events are displayed as Cursor activity only. Plan/todo replay cards can be followed by Cursor's final plan text, selected from `run.wait().result` when Cursor provides one and trimmed against already-emitted text. Started Cursor SDK tool calls that never receive a completion event are surfaced with bounded user-visible labels/traces (neutral activity cards when native replay routing allows, otherwise the same inactive or transcript trace fallbacks used for completed replay) instead of being silently discarded when the run failed/aborted, produced no assistant text, or involved external/side-effectful tools; incomplete fast local discovery starts (`read`, `grep`, `glob`, `ls`) remain maintainer-debug-only after successful text-producing runs so stale SDK start events do not create red post-answer cards. Explicit failures remain visible when Cursor reports them through completed tool calls or step results. Pi bridge MCP starts remain excluded from duplicate incomplete Cursor cards because pi already shows real pi tool execution. `PI_CURSOR_NATIVE_TOOL_DISPLAY=0` disables native replay, and `PI_CURSOR_REGISTER_NATIVE_TOOLS=0` is a registration-only opt-out that keeps the transcript fallback without shadowing pi tool names. When bridge or native replay cards are emitted, the provider mirrors Codex's turn shape as Cursor SDK activity arrives: assistant `toolUse`, pi `toolResult`s, live post-tool Cursor thinking/text, any later tool batches as further `toolUse` turns, then Cursor's final assistant answer. For shell replay, completed `stdout` / `stderr` are primary; unambiguous `shell-output-delta` data is also shown as bounded live progress while one shell call is active and used as display-only fallback for empty successful shell completions, while overlapping shell calls drop ambiguous deltas instead of guessing. Print mode keeps bounded scrubbed transcript output instead, preserving `pi -p` assistant text output. Cursor text deltas stream live when no live-run turn split is active.
+- Cursor internal tool activity is recorded from SDK events and scrubbed. Maintainer reference for all 16 `@cursor/sdk@1.0.18` `ToolType` values, runtime alias normalization, and intentional mapping/fallback rules: [Cursor native tool replay — SDK ToolType replay matrix](./cursor-native-tool-replay.md#sdk-tooltype-replay-matrix) (official SDK docs: https://cursor.com/docs/sdk/typescript). In TUI sessions and structured JSON/RPC modes, supported completed `read`, `bash`, `grep`, `find`, `ls`, `edit`, `write`, diagnostics, delete, todo/plan, task, image generation, MCP, semantic search, and screen recording activity is replayed through pi's native tool-call rendering path with recorded Cursor results, so users and JSON/RPC consumers can see native-looking cards/events without rerunning Cursor's reads/shell commands/file edits. Cursor `glob` activity is replayed through native `find` cards. Cursor write activity is replayed through native-looking `write` cards, and Cursor StrReplace/edit activity uses native-looking `edit` only when recorded arguments truthfully satisfy pi's `edit` schema; path-only Cursor edit and notebook edit replay falls back to neutral Cursor activity before pi validation. Diagnostics, delete, todos/plans, task/subagent, image, and MCP activity use neutral Cursor activity cards with pi's default success/error shell. Cursor SDK `task` activity is labeled **Cursor subagent** by default because it represents Cursor-spawned child-agent work; the card summary includes description plus subagent kind/model/short ID when Cursor reports them, and `PI_CURSOR_TASK_PRESENTATION=task` restores the older **Cursor task** wording for comparison. This is visibility over Cursor SDK task events, not a native pi subagent session: pi shows start/final output plus any `conversationSteps` tool-call summaries Cursor returns, but cannot show a live nested read/shell/MCP trail when the SDK only returns final subagent text. Neutral Cursor activity calls include `activityTitle` and, when available, `activitySummary` so partial/collapsed cards preserve identity such as `Cursor plan`, `Cursor todos`, `Cursor subagent`, `Cursor MCP`, or `Cursor edit`. For long-running or externally meaningful Cursor tools (`task`, `shell`, `mcp`, `generateImage`, `recordScreen`, `semSearch`, web search/fetch, plan/todo), the provider may surface one low-noise deferred in-progress thinking line such as `Cursor MCP: external_search` from bounded, scrubbed SDK args; fast local tools (`read`, `grep`, `glob`, and similar) skip lifecycle lines when completion follows immediately, and pi bridge MCP calls are excluded because pi already shows real pi tool execution ([lifecycle visibility](./cursor-native-tool-replay.md#low-noise-tool-lifecycle-visibility)). Replay-only tools display recorded Cursor results, normalize workspace-local paths/diff headers for display, use pi diff colors for edit previews and path-inferred syntax highlighting for write previews, and fail closed if called without a recorded result. Native replay wrappers are registered only for tool names not already owned by another extension; conflicting tools use the bounded scrubbed transcript fallback. Cursor workflow tools such as mode/task/todo/plan activity are not pi workflow controls; reported todo/plan events are displayed as Cursor activity only. Plan/todo replay cards can be followed by Cursor's final plan text, selected from `run.wait().result` when Cursor provides one and trimmed against already-emitted text. Started Cursor SDK tool calls that never receive a completion event are surfaced with bounded user-visible labels/traces (neutral activity cards when native replay routing allows, otherwise the same inactive or transcript trace fallbacks used for completed replay) instead of being silently discarded when the run failed/aborted, produced no assistant text, or involved external/side-effectful tools; incomplete fast local discovery starts (`read`, `grep`, `glob`, `ls`) remain maintainer-debug-only after successful text-producing runs so stale SDK start events do not create red post-answer cards. Explicit failures remain visible when Cursor reports them through completed tool calls or step results. Pi bridge MCP starts remain excluded from duplicate incomplete Cursor cards because pi already shows real pi tool execution. `PI_CURSOR_NATIVE_TOOL_DISPLAY=0` disables native replay, and `PI_CURSOR_REGISTER_NATIVE_TOOLS=0` is a registration-only opt-out that keeps the transcript fallback without shadowing pi tool names. When bridge or native replay cards are emitted, the provider mirrors Codex's turn shape as Cursor SDK activity arrives: assistant `toolUse`, pi `toolResult`s, live post-tool Cursor thinking/text, any later tool batches as further `toolUse` turns, then Cursor's final assistant answer. For shell replay, completed `stdout` / `stderr` are primary; unambiguous `shell-output-delta` data is also shown as bounded live progress while one shell call is active and used as display-only fallback for empty successful shell completions, while overlapping shell calls drop ambiguous deltas instead of guessing. Print mode keeps bounded scrubbed transcript output instead, preserving `pi -p` assistant text output. Cursor text deltas stream live when no live-run turn split is active.
 - Cursor native replay uses one neutral replay tool name, `cursor`, plus native-compatible card names when renderer-compatible (`read`, `bash`, `grep`, `find`, `ls`, `edit`, `write`). Neutral replay identity lives in `activityTitle`, `activitySummary`, and typed replay details, not in extra registered tool names. Bridge MCP names such as `pi__sem_reindex` are MCP-only; pi session output uses real pi tool names.
 - Cursor SDK usage events report cumulative internal agent/tool/cache work, not the replayable pi prompt context. The extension does not copy raw Cursor SDK usage into pi usage or compaction. For Cursor assistant messages, `usage.output` estimates visible assistant output, `usage.input` estimates the replayable Cursor context before that output, cache fields are zero, and `usage.totalTokens = input + output + cacheRead + cacheWrite`. The input/total estimate is derived from the same `buildCursorPrompt()` path used for `Agent.send` so context display and compaction keep using replayable Cursor context sizing while pi session summaries remain additive. `src/cursor-usage-accounting.ts` owns this usage policy.
 - Audit observation, 2026-05-19, superseded by the 2026-05-21 replay pass and #68 incomplete visibility, then narrowed by the 2026-05-26 fast-local suppression: a missing-file read with Composer 2.5 emitted `tool-call-started` for Cursor `read`, then streamed final text `Error: File not found`, but did not emit `tool-call-completed` or an `onStep` `toolCall` error result. Leftover external/side-effectful started calls are surfaced at run completion through the same native replay routing as completed tools (activity cards when allowed, otherwise inactive/transcript traces), while fast local discovery starts are debug-only after a successful text-producing run. Cursor-reported completed/step errors remain visible.

package/docs/cursor-native-tool-replay.md

@@ -64,7 +64,7 @@ Cursor `glob` activity is displayed through native `find` cards.
 
 For the full `@cursor/sdk@1.0.18` `ToolType` set, disposition matrix, and runtime alias normalization, see [SDK ToolType replay matrix](#sdk-tooltype-replay-matrix) below. Official SDK reference: https://cursor.com/docs/sdk/typescript
 
-Edit and write activity replays through pi-facing `edit` and `write` cards only when replay arguments truthfully satisfy the matching pi schema, but still uses recorded Cursor results only. The adapter passes through truthful Cursor paths, content when Cursor reported it, and recorded diff/details; it does not pretend Cursor's editing schema is pi's schema and it fails closed if a recorded replay result is missing. Cursor `StrReplace` with recorded replacement text displays as native-looking `edit`; path-only Cursor `edit` and notebook edit activity fall back to neutral Cursor activity so pi does not reject the replay before recorded-result handling. Cursor `write` displays as native-looking `write`. Diagnostics, delete, todos/plans, task, image, MCP, semantic search, screen recording, and web search/fetch activity use neutral Cursor activity cards with pi's default success/error tool shell. MCP completions whose `toolName` is `WebSearch` / `web_search` / `WebFetch` / similar are labeled **Cursor web search** or **Cursor web fetch** instead of generic **Cursor MCP**. Neutral Cursor activity cards carry display metadata such as `activityTitle` and `activitySummary`, so partial/collapsed cards can say `Cursor plan`, `Cursor todos`, `Cursor MCP`, `Cursor semantic search`, `Cursor screen recording`, `Cursor web search`, `Cursor web fetch`, or `Cursor edit` instead of only `Cursor activity`. These replay tools only display recorded Cursor results; they never mutate files or execute tool work directly. Replay paths are normalized to workspace-relative paths when possible. Most collapsed replay cards include bounded previews for diffs and text details so small edits, todos, task output, and MCP results are visible without expanding; web search/fetch activity stays summary-only while collapsed because those cards often arrive after final text and can otherwise bury the answer. Ctrl+O expansion shows the recorded details. Edit previews omit raw unified diff headers and show compact numbered changed/context lines using pi's native diff added/removed/context colors, and write previews use syntax highlighting when pi can infer a language from the path. Image generation replay cards show the saved image path in the collapsed summary and render the image inline when pi terminal image display is enabled and the generated file is still readable.
+Edit and write activity replays through pi-facing `edit` and `write` cards only when replay arguments truthfully satisfy the matching pi schema, but still uses recorded Cursor results only. The adapter passes through truthful Cursor paths, content when Cursor reported it, and recorded diff/details; it does not pretend Cursor's editing schema is pi's schema and it fails closed if a recorded replay result is missing. Cursor `StrReplace` with recorded replacement text displays as native-looking `edit`; path-only Cursor `edit` and notebook edit activity fall back to neutral Cursor activity so pi does not reject the replay before recorded-result handling. Cursor `write` displays as native-looking `write`. Diagnostics, delete, todos/plans, task/subagent, image, MCP, semantic search, screen recording, and web search/fetch activity use neutral Cursor activity cards with pi's default success/error tool shell. Cursor SDK `task` activity is labeled **Cursor subagent** by default because it represents Cursor-spawned child-agent work; `PI_CURSOR_TASK_PRESENTATION=task` keeps the older **Cursor task** wording for comparison. MCP completions whose `toolName` is `WebSearch` / `web_search` / `WebFetch` / similar are labeled **Cursor web search** or **Cursor web fetch** instead of generic **Cursor MCP**. Neutral Cursor activity cards carry display metadata such as `activityTitle` and `activitySummary`, so partial/collapsed cards can say `Cursor plan`, `Cursor todos`, `Cursor subagent`, `Cursor MCP`, `Cursor semantic search`, `Cursor screen recording`, `Cursor web search`, `Cursor web fetch`, or `Cursor edit` instead of only `Cursor activity`. These replay tools only display recorded Cursor results; they never mutate files or execute tool work directly. Replay paths are normalized to workspace-relative paths when possible. Most collapsed replay cards include bounded previews for diffs and text details so small edits, todos, task output, and MCP results are visible without expanding; web search/fetch activity stays summary-only while collapsed because those cards often arrive after final text and can otherwise bury the answer. Ctrl+O expansion shows the recorded details. Edit previews omit raw unified diff headers and show compact numbered changed/context lines using pi's native diff added/removed/context colors, and write previews use syntax highlighting when pi can infer a language from the path. Image generation replay cards show the saved image path in the collapsed summary and render the image inline when pi terminal image display is enabled and the generated file is still readable.
 
 ## SDK ToolType replay matrix
 
@@ -89,7 +89,7 @@ This matrix covers **Cursor native tool replay only**. It does not describe the
 | `readLints` | neutral activity | `cursor` | Collapsed label **Cursor diagnostics** |
 | `updateTodos` | neutral activity | `cursor` | Collapsed label **Cursor todos**; display-only, does not drive pi todos, including in Cursor SDK `plan` mode |
 | `createPlan` | neutral activity | `cursor` | Collapsed label **Cursor plan**; display-only, does not drive pi plan mode, including in Cursor SDK `plan` mode |
-| `task` | neutral activity | `cursor` | Collapsed label **Cursor task** |
+| `task` | neutral activity | `cursor` | Collapsed label **Cursor subagent** by default; summary includes description plus subagent kind/model/short ID when Cursor reports them; `PI_CURSOR_TASK_PRESENTATION=task` restores **Cursor task** wording |
 | `generateImage` | neutral activity | `cursor` | Collapsed label **Cursor image generation** |
 | `mcp` | neutral activity | `cursor` | Collapsed label **Cursor MCP** for non-web MCP completions; web search/fetch MCP `toolName` values reclassify to the rows below |
 | `semSearch` | neutral activity | `cursor` | Collapsed label **Cursor semantic search**; semantic codebase search, not web search |
@@ -162,13 +162,17 @@ These are integration boundaries, not pi replay bugs:
 
 Maintainer debug (`PI_CURSOR_SDK_EVENT_DEBUG=1`) still records the same discarded started-call events in `coordinator-events.jsonl` under phase `discarded-incomplete-started-tool-call` for investigation (**#52**), including fast local starts suppressed from successful text-producing runs. User-visible incomplete cards and debug artifacts are complementary: cards explain actionable gaps in the TUI; debug files retain normalized tool names and scrubbed call-id hashes without changing default stderr behavior.
 
+### Cursor subagent visibility limits
+
+Cursor SDK `task` activity is surfaced as **Cursor subagent** because it represents Cursor-spawned child-agent work. The card can show the subagent start, final result text, subagent kind/model/short-ID metadata, and compact `conversationSteps` tool-call summaries when the SDK includes them. It is not a native pi subagent session and does not guarantee a live nested action stream. If Cursor only returns final subagent text and no nested tool calls, pi cannot show the subagent's internal read/shell/MCP steps.
+
 ## Low-noise tool lifecycle visibility
 
 Most Cursor tool visibility is completion-based: the completed replay card (or bounded transcript trace) is the source of truth for recorded results. For long-running or externally meaningful tools, the provider may also surface one low-noise in-progress line while Cursor is still waiting on the tool.
 
 Lifecycle rules:
 
-- Eligible tools include `task`, `shell`, `mcp`, `generateImage`, `recordScreen`, `semSearch`, web search/fetch activity, and plan/todo activity. Fast local tools such as `read`, `grep`, and `glob` do not get lifecycle lines in normal cases.
+- Eligible tools include `task` (shown as **Cursor subagent** by default), `shell`, `mcp`, `generateImage`, `recordScreen`, `semSearch`, web search/fetch activity, and plan/todo activity. Fast local tools such as `read`, `grep`, and `glob` do not get lifecycle lines in normal cases.
 - Lifecycle text is emitted as a single bounded, scrubbed thinking line such as `Cursor MCP: external_search` or `Cursor shell: npm test`. Shell pending labels show a scrubbed/truncated command preview, matching pi's native bash UX; the completed replay card remains the source of truth for recorded shell results. Lifecycle lines are not separate permanent replay cards and do not rerun tools.
 - A short defer window coalesces fast start+complete pairs: if a tool completes before the defer elapses, only the completed replay card/trace is shown.
 - pi bridge MCP calls (`pi__*`) are excluded because pi already shows the real pi tool execution path.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cursor-sdk",
-	"version": "0.1.41",
+	"version": "0.1.42",
 	"description": "pi provider extension backed by @cursor/sdk local agents",
 	"author": "Mitch Fultz (https://github.com/fitchmultz)",
 	"license": "MIT",

package/src/cursor-compact-tool-summary.ts

@@ -0,0 +1,81 @@
+import { isAbsolute, relative, win32 } from "node:path";
+import { asRecord, getRecord, getString } from "./cursor-record-utils.js";
+import { formatDisplayPath } from "./cursor-transcript-utils.js";
+
+export interface CursorCompactToolSummaryOptions {
+	cwd?: string;
+}
+
+function isWindowsAbsolutePath(path: string): boolean {
+	return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\");
+}
+
+export function formatCursorCompactToolPath(path: string | undefined, options: CursorCompactToolSummaryOptions): string | undefined {
+	const trimmed = path?.trim();
+	if (!trimmed) return undefined;
+	const normalized = trimmed.replace(/\\/g, "/");
+	if (normalized === "~" || normalized.startsWith("~/") || /^~[^/]+(?:\/|$)/.test(normalized)) return undefined;
+	if (normalized.split("/").includes("..")) return undefined;
+	if (/^[A-Za-z]:(?!\/)/.test(normalized)) return undefined;
+	if (isWindowsAbsolutePath(trimmed)) {
+		const cwd = options.cwd;
+		if (!cwd || !isWindowsAbsolutePath(cwd)) return undefined;
+		const relativePath = win32.relative(cwd, trimmed);
+		if (!relativePath || relativePath.startsWith("..") || isWindowsAbsolutePath(relativePath)) return undefined;
+		return relativePath.replace(/\\/g, "/");
+	}
+	if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(normalized)) return undefined;
+	if (isAbsolute(trimmed)) {
+		const cwd = options.cwd;
+		if (!cwd) return undefined;
+		const relativePath = relative(cwd, trimmed);
+		if (!relativePath || relativePath.startsWith("..") || isAbsolute(relativePath)) return undefined;
+		return relativePath.replace(/\\/g, "/");
+	}
+	return formatDisplayPath(normalized, options.cwd);
+}
+
+function getNestedRecord(record: Record<string, unknown> | undefined, ...keys: string[]): Record<string, unknown> | undefined {
+	let current = record;
+	for (const key of keys) {
+		current = getRecord(current, key);
+		if (!current) return undefined;
+	}
+	return current;
+}
+
+function summarizeShellTool(args: Record<string, unknown> | undefined, resultValue: Record<string, unknown> | undefined): string {
+	const command = getString(args, "command");
+	const stdout = getString(resultValue, "stdout");
+	const stderr = getString(resultValue, "stderr");
+	return [command ? `$ ${command}` : "shell", stdout, stderr].filter((part): part is string => Boolean(part)).join("\n");
+}
+
+export function summarizeCursorCompactToolCall(
+	toolName: string | undefined,
+	args: Record<string, unknown> | undefined,
+	result: Record<string, unknown> | undefined,
+	options: CursorCompactToolSummaryOptions,
+): string | undefined {
+	if (!toolName) return undefined;
+	const compactName = toolName.replace(/\s+/g, " ").trim() || "unknown";
+	if (compactName === "shell") return summarizeShellTool(args, getNestedRecord(result, "value"));
+
+	const path = formatCursorCompactToolPath(getString(args, "path"), options);
+	if (path) return `${compactName} ${path}`;
+	const query = getString(args, "query") ?? getString(args, "pattern");
+	if (query) return `${compactName} ${query}`;
+	return compactName;
+}
+
+export function summarizeCursorCompactConversationToolCall(step: unknown, options: CursorCompactToolSummaryOptions): string | undefined {
+	const record = asRecord(step);
+	if (getString(record, "type") !== "toolCall") return undefined;
+	const message = getRecord(record, "message");
+	return summarizeCursorCompactToolCall(
+		getString(message, "type"),
+		getRecord(message, "args"),
+		getRecord(message, "result"),
+		options,
+	);
+}

package/src/cursor-native-tool-display-replay.ts

@@ -1,6 +1,6 @@
 import { readFileSync, statSync } from "node:fs";
 import { basename } from "node:path";
-import { getLanguageFromPath, highlightCode, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { getLanguageFromPath, highlightCode, keyHint, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Image, Text, type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { resolveCursorEditDiff } from "./cursor-edit-diff.js";
@@ -9,6 +9,7 @@ import { LOCAL_READ_PREVIEW_NOTICE, isLocalReadPreviewContent } from "./cursor-t
 import {
 	CURSOR_REPLAY_ACTIVITY_TOOL_NAME,
 	getCursorReplayCallSummary,
+	shouldShowCursorReplayCollapsedExpandHint,
 	type CursorReplayToolName,
 } from "./cursor-tool-presentation-registry.js";
 import {
@@ -423,6 +424,14 @@ function hasCursorReplayDisplayTitle(details: CursorReplayToolDetails | undefine
 	return isCursorReplayActivityDetails(details) || isCursorReplayGenerateImageDetails(details);
 }
 
+function formatCursorReplayExpandHint(): string {
+	try {
+		return keyHint("app.tools.expand", "to expand");
+	} catch {
+		return "Ctrl+O to expand";
+	}
+}
+
 function renderExpandableCursorReplayResult(
 	title: string,
 	details: CursorReplayExpandableResultDetails,
@@ -434,8 +443,10 @@ function renderExpandableCursorReplayResult(
 ): Component {
 	const text = firstContentText(result);
 	const summary = details.summary ?? text.split("\n").find((line) => line.trim()) ?? "completed";
-	let rendered = `${theme.fg("toolTitle", theme.bold(title))} ${theme.fg(isError ? "error" : "success", summary)}`;
 	const expandedText = details.expandedText ?? (text.includes("\n") ? text : undefined);
+	const showExpandHint = expandedText && !options.expanded && shouldShowCursorReplayCollapsedExpandHint(details.sourceToolName);
+	const expandHint = showExpandHint ? theme.fg("dim", ` (${formatCursorReplayExpandHint()})`) : "";
+	let rendered = `${theme.fg("toolTitle", theme.bold(title))} ${theme.fg(isError ? "error" : "success", summary)}${expandHint}`;
 	if (expandedText && (options.expanded || !details.collapseDetailsByDefault)) {
 		const preview = formatCursorReplayActivityPreview(
 			details,

package/src/cursor-replay-activity-builders.ts

@@ -21,12 +21,12 @@ import {
 	readMcpDisplayResult,
 	getReadLintDiagnostics,
 	getReadLintPaths,
-	getTaskDescription,
 	getTodoItems,
 	getTodoTotalCount,
 	inferImageMimeType,
 } from "./cursor-tool-result-display-readers.js";
 import { extractWebFetchTarget, extractWebSearchQuery } from "./cursor-web-tool-args.js";
+import { formatCursorTaskAgentId, formatCursorTaskKind, getCursorTaskDescription, getCursorTaskPresentationMode, readCursorTaskMetadata } from "./cursor-task-presentation.js";
 
 export interface CursorReplayActivityBuildContext {
 	args: Record<string, unknown>;
@@ -88,12 +88,20 @@ export function buildCreatePlanReplaySummaryArgs({ args, result }: CursorReplayA
 	};
 }
 
-export function buildTaskReplaySummaryArgs({ args, result }: CursorReplayActivityBuildContext): CursorReplayTaskSummaryArgs {
-	const description = getTaskDescription(args, result);
-	const preview = firstNonEmptyLine(collectTaskText(result));
+export function buildTaskReplaySummaryArgs({ args, result, options }: CursorReplayActivityBuildContext): CursorReplayTaskSummaryArgs {
+	const description = getCursorTaskDescription(args, result.value);
+	const preview = firstNonEmptyLine(collectTaskText(result, options));
+	const metadata = readCursorTaskMetadata(args, result.value);
+	const displayAgentId = formatCursorTaskAgentId(metadata.agentId);
+	const includeMetadata = getCursorTaskPresentationMode() === "subagent-meta";
 	return {
 		description: truncateArg(description),
 		...(preview ? { preview: truncateArg(preview) } : {}),
+		...(includeMetadata && metadata.subagentName ? { subagentName: truncateArg(metadata.subagentName) } : {}),
+		...(includeMetadata && metadata.subagentKind ? { subagentKind: truncateArg(formatCursorTaskKind(metadata.subagentKind) ?? metadata.subagentKind) } : {}),
+		...(includeMetadata && metadata.model ? { model: truncateArg(metadata.model) } : {}),
+		...(includeMetadata && displayAgentId ? { agentId: truncateArg(displayAgentId) } : {}),
+		...(includeMetadata && metadata.isBackground === true ? { isBackground: true } : {}),
 	};
 }
 

package/src/cursor-replay-summary-args.ts

@@ -31,6 +31,11 @@ export interface CursorReplayPlanSummaryArgs extends CursorReplayTodoSummaryArgs
 export interface CursorReplayTaskSummaryArgs extends CursorReplayActivitySummaryOverride {
 	description?: string;
 	preview?: string;
+	subagentName?: string;
+	subagentKind?: string;
+	model?: string;
+	agentId?: string;
+	isBackground?: boolean;
 }
 
 export interface CursorReplayGenerateImageSummaryArgs extends CursorReplayActivitySummaryOverride {
@@ -150,8 +155,22 @@ export function summarizeReplayPlan(args: CursorReplayPlanSummaryArgs | undefine
 export function summarizeReplayTask(args: CursorReplayTaskSummaryArgs | undefined): string | undefined {
 	const description = readCursorReplaySummaryString(args, "description");
 	const preview = readCursorReplaySummaryString(args, "preview");
-	if (description && preview && preview !== description) return `${description}: ${preview}`;
-	return description ?? preview;
+	const subagentName = readCursorReplaySummaryString(args, "subagentName");
+	const subagentKind = readCursorReplaySummaryString(args, "subagentKind");
+	const model = readCursorReplaySummaryString(args, "model");
+	const agentId = readCursorReplaySummaryString(args, "agentId");
+	const metadataParts = [
+		subagentKind,
+		model,
+		agentId ? `ID: ${agentId}` : undefined,
+		args?.isBackground === true ? "backgrounded" : undefined,
+	].filter((part): part is string => Boolean(part));
+	const subjectParts = [description].filter((part): part is string => Boolean(part));
+	const subject = subjectParts.length > 0 ? subjectParts.join(" · ") : undefined;
+	const head = metadataParts.length > 0 ? [subject, ...metadataParts].filter(Boolean).join(" · ") : subject;
+	if (metadataParts.length > 0) return head;
+	if (head && preview && preview !== description && preview !== subagentName) return `${head}: ${preview}`;
+	return head ?? preview;
 }
 
 export function summarizeReplayMcp(args: CursorReplayMcpSummaryArgs | undefined): string | undefined {

package/src/cursor-task-presentation.ts

@@ -0,0 +1,77 @@
+import { asRecord, getBoolean, getRecord, getString } from "./cursor-record-utils.js";
+
+export const CURSOR_TASK_PRESENTATION_ENV = "PI_CURSOR_TASK_PRESENTATION";
+
+export type CursorTaskPresentationMode = "task" | "subagent" | "subagent-meta";
+
+const VALID_CURSOR_TASK_PRESENTATION_MODES = new Set<CursorTaskPresentationMode>([
+	"task",
+	"subagent",
+	"subagent-meta",
+]);
+
+export function getCursorTaskPresentationMode(env: NodeJS.ProcessEnv = process.env): CursorTaskPresentationMode {
+	const raw = env[CURSOR_TASK_PRESENTATION_ENV]?.trim();
+	return raw && VALID_CURSOR_TASK_PRESENTATION_MODES.has(raw as CursorTaskPresentationMode)
+		? (raw as CursorTaskPresentationMode)
+		: "subagent-meta";
+}
+
+export interface CursorTaskMetadata {
+	description?: string;
+	subagentKind?: string;
+	subagentName?: string;
+	model?: string;
+	agentId?: string;
+	isBackground?: boolean;
+}
+
+export function getCursorTaskDescription(args: Record<string, unknown>, resultValue?: unknown): string {
+	return getString(args, "description") ?? getString(asRecord(resultValue), "description") ?? "task";
+}
+
+export function readCursorTaskMetadata(args: Record<string, unknown>, resultValue?: unknown): CursorTaskMetadata {
+	const subagentType = getRecord(args, "subagentType");
+	const result = asRecord(resultValue);
+	return {
+		description: getCursorTaskDescription(args, resultValue),
+		subagentKind: getString(subagentType, "kind"),
+		subagentName: getString(subagentType, "name"),
+		model: getString(args, "model"),
+		agentId: getString(args, "agentId") ?? getString(result, "agentId"),
+		isBackground: getBoolean(result, "isBackground"),
+	};
+}
+
+function cleanMetadataValue(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed || undefined;
+}
+
+export function getCursorTaskActivityTitle(): string {
+	return getCursorTaskPresentationMode() === "task" ? "Cursor task" : "Cursor subagent";
+}
+
+export function getCursorTaskTranscriptHeader(args: Record<string, unknown>, resultValue?: unknown): string {
+	const metadata = readCursorTaskMetadata(args, resultValue);
+	const description = cleanMetadataValue(metadata.description) ?? "task";
+	const mode = getCursorTaskPresentationMode();
+	if (mode === "task") return `task ${description}`;
+	if (mode === "subagent-meta") {
+		const subagentName = cleanMetadataValue(metadata.subagentName);
+		return subagentName ? `subagent ${subagentName} ${description}` : `subagent ${description}`;
+	}
+	return `subagent ${description}`;
+}
+
+export function formatCursorTaskKind(value: string | undefined): string | undefined {
+	const cleaned = cleanMetadataValue(value);
+	if (!cleaned) return undefined;
+	return cleaned.slice(0, 1).toUpperCase() + cleaned.slice(1);
+}
+
+export function formatCursorTaskAgentId(value: string | undefined): string | undefined {
+	const cleaned = cleanMetadataValue(value);
+	if (!cleaned || !/^[A-Za-z0-9_.:-]+$/.test(cleaned)) return undefined;
+	return cleaned.length > 12 ? cleaned.slice(0, 8) : cleaned;
+}

package/src/cursor-tool-presentation-registry.ts

@@ -23,6 +23,7 @@ import {
 	type CursorReplayWebSearchSummaryArgs,
 } from "./cursor-replay-summary-args.js";
 import { truncateCursorDisplayLine } from "./cursor-display-text.js";
+import { getCursorTaskActivityTitle } from "./cursor-task-presentation.js";
 import {
 	buildCreatePlanReplaySummaryArgs,
 	buildDeleteReplayDetailFields,
@@ -75,6 +76,10 @@ export interface CursorToolVisibilityPolicy {
 	fastLocalDiscovery?: boolean;
 }
 
+export interface CursorToolReplayDisplayPolicy {
+	showCollapsedExpandHint?: boolean;
+}
+
 export interface CursorToolActivityReplaySpec<TArgs extends CursorReplaySummaryArgs = CursorReplaySummaryArgs> {
 	buildActivityArgs: (context: CursorReplayActivityBuildContext) => TArgs;
 	buildDetails: (context: CursorReplayActivityBuildContext, contentText: string) => CursorReplayActivityDetailFields;
@@ -90,7 +95,9 @@ export interface CursorToolPresentationSpec {
 	/** Raw SDK/host names that resolve to this tool via {@link normalizeCursorToolName}. */
 	nameAliases?: readonly string[];
 	displayLabel: string;
+	getActivityTitle?: () => string;
 	visibility: CursorToolVisibilityPolicy;
+	replayDisplay?: CursorToolReplayDisplayPolicy;
 	webKind?: CursorWebToolKind;
 	/** Regexes matched against lowercased trimmed tool names for {@link classifyCursorWebToolKind}. */
 	webNamePatterns?: readonly RegExp[];
@@ -209,8 +216,10 @@ export const CURSOR_TOOL_PRESENTATION_SPECS = [
 	},
 	{
 		normalizedName: "task",
-		displayLabel: "Cursor task",
+		displayLabel: "Cursor subagent",
+		getActivityTitle: getCursorTaskActivityTitle,
 		visibility: { lifecycleEligible: true },
+		replayDisplay: { showCollapsedExpandHint: true },
 		lifecycleLabelKind: "task",
 		replayCallSummary: withActivitySummaryFallback(summarizeReplayTask),
 		activityReplay: {
@@ -381,7 +390,7 @@ export function getCursorReplayPromptLabel(toolName: string): string {
 export function getCursorReplayActivityTitle(toolName: string): string | undefined {
 	const spec = getCursorToolPresentationSpec(toolName);
 	if (!spec || !hasNeutralActivityTitle(spec)) return undefined;
-	return spec.displayLabel;
+	return spec.getActivityTitle?.() ?? spec.displayLabel;
 }
 
 function buildCursorGenericActivityTitle(displayName: string): string {
@@ -418,6 +427,11 @@ export function getCursorToolGenerateImageReplaySpec(normalizedKey: string): Cur
 	return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.generateImageReplay;
 }
 
+export function shouldShowCursorReplayCollapsedExpandHint(normalizedKey: string | undefined): boolean {
+	if (!normalizedKey) return false;
+	return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.replayDisplay?.showCollapsedExpandHint === true;
+}
+
 export function getCursorReplayCallSummary(
 	toolName: CursorReplayToolName | CursorReplaySourceToolName,
 	args: CursorReplaySummaryArgs | undefined,

package/src/cursor-tool-result-display-readers.ts

@@ -1,4 +1,5 @@
 import { asRecord, getArray, getNumber, getRecord, getString, stringifyUnknown } from "./cursor-record-utils.js";
+import { summarizeCursorCompactConversationToolCall } from "./cursor-compact-tool-summary.js";
 import { scrubSensitiveText } from "./cursor-sensitive-text.js";
 import { firstNonEmptyLine, formatDisplayPath, truncateArg } from "./cursor-transcript-utils.js";
 
@@ -70,10 +71,6 @@ export function getTodoTotalCount(args: Record<string, unknown>, result: CursorT
 	return getNumber(asRecord(result.value), "totalCount") ?? getNumber(args, "totalCount") ?? todos.length;
 }
 
-export function getTaskDescription(args: Record<string, unknown>, result: CursorToolResultLike): string {
-	return getString(args, "description") ?? getString(asRecord(result.value), "description") ?? "task";
-}
-
 function getNestedRecord(record: Record<string, unknown> | undefined, ...keys: string[]): Record<string, unknown> | undefined {
 	let current = record;
 	for (const key of keys) {
@@ -83,16 +80,24 @@ function getNestedRecord(record: Record<string, unknown> | undefined, ...keys: s
 	return current;
 }
 
-export function collectTaskText(result: CursorToolResultLike): string {
+function readConversationStepAssistantText(step: unknown): string | undefined {
+	const record = asRecord(step);
+	const legacyText = getString(getRecord(record, "assistantMessage"), "text");
+	if (legacyText) return legacyText;
+	if (getString(record, "type") !== "assistantMessage") return undefined;
+	return getString(getRecord(record, "message"), "text");
+}
+
+export function collectTaskText(result: CursorToolResultLike, options: CursorToolResultReaderOptions = {}): string {
 	const value = asRecord(result.value);
 	const success = getNestedRecord(value, "result", "success");
 	const command = getString(success, "command");
 	const stdout = getString(success, "stdout");
 	const interleavedOutput = getString(success, "interleavedOutput");
-	const assistantMessages = (getArray(value, "conversationSteps") ?? [])
-		.map((step) => getString(getRecord(asRecord(step), "assistantMessage"), "text"))
+	const conversationParts = (getArray(value, "conversationSteps") ?? [])
+		.map((step) => summarizeCursorCompactConversationToolCall(step, options) ?? readConversationStepAssistantText(step))
 		.filter((entry): entry is string => Boolean(entry));
-	const parts = [command ? `$ ${command}` : undefined, stdout || interleavedOutput, ...assistantMessages].filter((part): part is string => Boolean(part));
+	const parts = [command ? `$ ${command}` : undefined, stdout || interleavedOutput, ...conversationParts].filter((part): part is string => Boolean(part));
 	return parts.join("\n");
 }
 

package/src/cursor-transcript-tool-formatters.ts

@@ -9,13 +9,13 @@ import {
 	getRecord,
 	getString,
 } from "./cursor-record-utils.js";
+import { getCursorTaskTranscriptHeader } from "./cursor-task-presentation.js";
 import {
 	collectTaskText,
 	getGenerateImageDisplayPath,
 	readMcpDisplayResult,
 	getReadLintDiagnostics,
 	getReadLintPaths,
-	getTaskDescription,
 	getTodoItems,
 } from "./cursor-tool-result-display-readers.js";
 
@@ -487,10 +487,10 @@ export function formatPlan(args: Record<string, unknown>, result: NormalizedResu
 }
 
 export function formatTask(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
-	const description = getTaskDescription(args, result);
-	if (result.status === "error") return joinSections(`task ${description}`, formatError(result.error));
-	const taskText = collectTaskText(result);
-	return joinSections(`task ${description}`, limitText(taskText || stringifyUnknown(result.value), options));
+	const header = getCursorTaskTranscriptHeader(args, result.value);
+	if (result.status === "error") return joinSections(header, formatError(result.error));
+	const taskText = collectTaskText(result, options);
+	return joinSections(header, limitText(taskText || stringifyUnknown(result.value), options));
 }
 
 export function formatGenerateImage(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {