pi-cursor-sdk 0.1.40 → 0.1.42

package/src/cursor-pi-tool-bridge-run.ts

@@ -150,7 +150,8 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 		this.debugRecorder = recorder;
 	}
 
-	resolveToolResults(toolResults: readonly ToolResultMessage[]): void {
+	async resolveToolResults(toolResults: readonly ToolResultMessage[]): Promise<void> {
+		let resolvedCount = 0;
 		for (const toolResult of toolResults) {
 			const pending = this.pendingByPiToolCallId.get(toolResult.toolCallId);
 			if (!pending || pending.settled) continue;
@@ -158,11 +159,13 @@ export class CursorPiToolBridgeRunImpl implements CursorPiToolBridgeRun {
 				content: convertPiContentToMcpContent(toolResult.content),
 				isError: toolResult.isError || undefined,
 			});
+			resolvedCount += 1;
 		}
+		if (resolvedCount > 0) await waitForProtocolFlush();
 	}
 
-	resolveToolResultsFromContext(context: Context): void {
-		this.resolveToolResults(context.messages.map(asToolResultMessage).filter((message): message is ToolResultMessage => message !== undefined));
+	async resolveToolResultsFromContext(context: Context): Promise<void> {
+		await this.resolveToolResults(context.messages.map(asToolResultMessage).filter((message): message is ToolResultMessage => message !== undefined));
 	}
 
 	hasPendingPiToolCallId(piToolCallId: string): boolean {

package/src/cursor-pi-tool-bridge-types.ts

@@ -61,8 +61,8 @@ export interface CursorPiToolBridgeRun {
 	mcpServers?: Record<string, McpServerConfig>;
 	snapshot: CursorPiToolBridgeSnapshot;
 	takeQueuedToolRequests(): CursorPiBridgeToolRequest[];
-	resolveToolResults(toolResults: readonly ToolResultMessage[]): void;
-	resolveToolResultsFromContext(context: Context): void;
+	resolveToolResults(toolResults: readonly ToolResultMessage[]): Promise<void>;
+	resolveToolResultsFromContext(context: Context): Promise<void>;
 	hasPendingPiToolCallId(piToolCallId: string): boolean;
 	isBridgeMcpToolCall(toolCall: unknown): boolean;
 	setOnToolRequest(handler?: (request: CursorPiBridgeToolRequest) => void): void;

package/src/cursor-provider-errors.ts

@@ -15,7 +15,7 @@ const NETWORK_CURSOR_SDK_ERROR_MESSAGE =
 // Keep this phrase aligned with pi's agent-level retry classifier (`provider.?returned.?error`).
 const RETRYABLE_CURSOR_RUN_FAILURE_PREFIX = "Provider returned error: Cursor SDK run failed";
 
-export type CursorSdkRunFailureSource = Pick<RunResult, "id" | "status" | "durationMs" | "model" | "result">;
+export type CursorSdkRunFailureSource = Pick<RunResult, "id" | "requestId" | "status" | "durationMs" | "model" | "result">;
 
 function isGenericErrorMessage(message: string): boolean {
 	const normalized = message.trim().toLowerCase();
@@ -159,6 +159,7 @@ export function formatCursorSdkRunFailureDetail(result: CursorSdkRunFailureSourc
 	const parts = [RETRYABLE_CURSOR_RUN_FAILURE_PREFIX];
 	if (result.model?.id) parts.push(`model ${result.model.id}`);
 	parts.push(`run ${shortRunId(result.id)}`);
+	if (result.requestId) parts.push(`request ${shortRunId(result.requestId)}`);
 	if (typeof result.durationMs === "number") parts.push(`${result.durationMs}ms`);
 	return parts.join(" · ");
 }

package/src/cursor-provider-live-run-drain.ts

@@ -414,7 +414,7 @@ export async function drainExistingCursorLiveRunBeforeSend(
 			const outcome = await cursorLiveRuns.withRunLease(run, signal, async () => {
 				if (run.disposed) return "continue_send" as const;
 				const consumed = cursorLiveRuns.consumeToolResults(run, context, getCursorNativeReplayIdFromToolCallId);
-				run.bridgeRun?.resolveToolResults(consumed.toolResults);
+				await run.bridgeRun?.resolveToolResults(consumed.toolResults);
 				const shouldChainUserInput = run.chainUserInputAfterCompletion || hasTrailingUserMessagesAfterToolResults(context);
 				if (shouldChainUserInput) run.chainUserInputAfterCompletion = true;
 				while (!cursorLiveRuns.isReady(run)) {

package/src/cursor-provider-turn-prepare.ts

@@ -89,7 +89,7 @@ export async function prepareCursorProviderTurn(
 		throwIfAborted();
 
 		const buildPromptOptions = (plan: ReturnType<typeof planCursorSessionSend>) => {
-			const promptOptions = getCursorPromptOptions(model);
+			const promptOptions = { ...getCursorPromptOptions(model), agentMode };
 			if (plan.mode !== "bootstrap" || !resolveCursorToolManifestEnabled()) {
 				return promptOptions;
 			}

package/src/cursor-provider-turn-send.ts

@@ -78,12 +78,14 @@ export async function sendCursorProviderTurn(sendParams: SendCursorProviderTurnP
 		sdkRun = run;
 		sdkEventDebug?.recordRunMeta({
 			runId: run.id,
+			requestId: run.requestId,
 			agentId: run.agentId,
 			status: run.status,
 		});
 		sdkEventDebug?.attachRunStream(run);
 		sdkEventDebug?.recordProviderEvent("agent_send_returned", {
 			runId: run.id,
+			requestId: run.requestId,
 			agentId: run.agentId,
 			status: run.status,
 		});

package/src/cursor-question-tool.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { arePiToolsDisabled } from "./cursor-active-tools.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle, type CursorModelLifecycleExtensionApi } from "./cursor-model-lifecycle.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
@@ -175,7 +176,7 @@ async function askOneQuestion(question: CursorQuestion, ctx: { ui: ExtensionCont
 
 function syncCursorQuestionToolForModel(pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">, model: ExtensionContext["model"]): void {
 	const activeToolNames = new Set(pi.getActiveTools());
-	const shouldBeActive = isCursorModel(model) && resolveCursorPiToolBridgeEnabled();
+	const shouldBeActive = !arePiToolsDisabled(pi) && isCursorModel(model) && resolveCursorPiToolBridgeEnabled();
 	const alreadyActive = activeToolNames.has(CURSOR_ASK_QUESTION_TOOL_NAME);
 	if (shouldBeActive === alreadyActive) return;
 	if (shouldBeActive) {

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-sdk-event-debug.ts

@@ -78,12 +78,14 @@ export interface CursorSdkEventDebugSendMeta {
 
 export interface CursorSdkEventDebugRunMeta {
 	runId: string;
+	requestId?: string;
 	agentId: string;
 	status: string;
 }
 
 interface CursorSdkRunLike {
 	id: string;
+	requestId?: string;
 	agentId?: string;
 	status?: string;
 	stream?: () => AsyncIterable<unknown>;
@@ -373,7 +375,7 @@ export class CursorSdkEventDebugSink {
 	attachRunStream(run: unknown): void {
 		const sdkRun = run as CursorSdkRunLike;
 		if (typeof sdkRun.stream !== "function") {
-			this.recordProviderEvent("run_stream_unavailable", { runId: sdkRun.id });
+			this.recordProviderEvent("run_stream_unavailable", { runId: sdkRun.id, requestId: sdkRun.requestId });
 			return;
 		}
 		this.streamCapturePromise = (async () => {

package/src/cursor-skill-tool.ts

@@ -8,6 +8,7 @@ import type {
 	Skill,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { arePiToolsDisabled } from "./cursor-active-tools.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle, type CursorModelLifecycleExtensionApi } from "./cursor-model-lifecycle.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
@@ -62,7 +63,7 @@ function shouldExposeSkillTool(model: ExtensionContext["model"]): boolean {
 
 function syncCursorSkillToolForModel(pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">, model: ExtensionContext["model"]): void {
 	const activeToolNames = new Set(pi.getActiveTools());
-	const shouldBeActive = shouldExposeSkillTool(model);
+	const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model);
 	const alreadyActive = activeToolNames.has(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
 	if (shouldBeActive === alreadyActive) return;
 	if (shouldBeActive) {

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-manifest.ts

@@ -4,7 +4,7 @@ import type { CursorPiToolBridgeSnapshot } from "./cursor-pi-tool-bridge-types.j
 export const CURSOR_TOOL_MANIFEST_ENV = "PI_CURSOR_TOOL_MANIFEST";
 
 /**
- * Representative @cursor/sdk@1.0.17 local-agent ToolType values; actual exposure can vary by run.
+ * Representative @cursor/sdk@1.0.18 local-agent ToolType values; actual exposure can vary by run.
  * See docs/cursor-native-tool-replay.md#sdk-tooltype-replay-matrix.
  */
 export const CURSOR_HOST_TOOL_MANIFEST_SUMMARY =
@@ -26,6 +26,7 @@ export function buildCursorToolManifestText(options: {
 		"Callable tool surfaces this run:",
 		`- Cursor SDK host tools (callable; not listed in MCP listTools): ${CURSOR_HOST_TOOL_MANIFEST_SUMMARY}.`,
 		"- Configured Cursor MCP servers: discovered at runtime via MCP listTools (depends on Cursor settings and PI_CURSOR_SETTING_SOURCES).",
+		"- Pi CLI tool toggles such as --no-tools affect pi tools and bridge exposure only; they do not disable Cursor SDK host tools or configured Cursor MCP.",
 	];
 	const bridgeTools = options.bridgeSnapshot?.tools ?? [];
 	if (!piBridgeEnabled) {

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 {

package/src/cursor-usage-accounting.ts

@@ -56,10 +56,11 @@ export function estimateCursorContextTotalTokens(partial: AssistantMessage, mode
 	return estimateCursorContextTokens(withAssistantMessage(context, partial), getCursorPromptOptions(model));
 }
 
-export function applyCursorApproximateUsage(partial: AssistantMessage, model: Model<Api>, context: Context, sessionInputTokens: number): void {
-	partial.usage.input = sessionInputTokens;
-	partial.usage.output = estimateCursorAssistantSessionOutputTokens(partial);
+export function applyCursorApproximateUsage(partial: AssistantMessage, _model: Model<Api>, _context: Context, sessionInputTokens: number): void {
+	const outputTokens = estimateCursorAssistantSessionOutputTokens(partial);
+	partial.usage.input = Math.max(0, sessionInputTokens);
+	partial.usage.output = outputTokens;
 	partial.usage.cacheRead = 0;
 	partial.usage.cacheWrite = 0;
-	partial.usage.totalTokens = estimateCursorContextTotalTokens(partial, model, context);
+	partial.usage.totalTokens = partial.usage.input + partial.usage.output + partial.usage.cacheRead + partial.usage.cacheWrite;
 }