pi-cursor-sdk 0.1.28 → 0.1.30

package/scripts/platform-smoke/visual-evidence.mjs

@@ -0,0 +1,139 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+function pngSize(path) {
+	try {
+		const buffer = readFileSync(path);
+		if (buffer.length < 24 || buffer.toString("ascii", 1, 4) !== "PNG") return undefined;
+		return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20), bytes: buffer.length };
+	} catch {
+		return undefined;
+	}
+}
+
+function safeFileName(id) {
+	return String(id).replace(/[^A-Za-z0-9_.-]+/g, "-");
+}
+
+function makeRegex(spec) {
+	if (!spec?.pattern) return undefined;
+	try {
+		return new RegExp(spec.pattern, spec.flags ?? "i");
+	} catch {
+		return undefined;
+	}
+}
+
+export function findVisualEvidenceItems(lines, specs = []) {
+	return specs.map((spec) => {
+		const regex = makeRegex(spec);
+		if (!regex) return { id: spec.id, ok: false, error: `invalid regex: ${spec.pattern}` };
+		const lineIndex = lines.findIndex((line) => {
+			regex.lastIndex = 0;
+			return regex.test(line);
+		});
+		if (lineIndex === -1) return { id: spec.id, ok: false, pattern: spec.pattern };
+		return { id: spec.id, ok: true, pattern: spec.pattern, lineIndex, line: lines[lineIndex] };
+	});
+}
+
+export async function collectVisualEvidence({ htmlPath, pngPath, outDir, specs = [] }) {
+	mkdirSync(outDir, { recursive: true });
+	const evidence = {
+		ok: false,
+		htmlPath,
+		pngPath,
+		png: pngSize(pngPath),
+		style: null,
+		items: [],
+		checks: [],
+		writtenAt: new Date().toISOString(),
+	};
+
+	if (!existsSync(htmlPath)) {
+		evidence.checks.push({ id: "visual-html-present", ok: false, error: "terminal.html missing" });
+		writeFileSync(resolve(outDir, "visual-evidence.json"), JSON.stringify(evidence, null, 2));
+		return evidence;
+	}
+
+	let browser;
+	try {
+		const { chromium } = await import("playwright");
+		browser = await chromium.launch();
+		const page = await browser.newPage({ viewport: { width: 1_400, height: 1_000 }, deviceScaleFactor: 1 });
+		await page.goto(pathToFileURL(htmlPath).href);
+		await page.waitForSelector('body[data-render-ready="true"]', { timeout: 30_000 });
+		evidence.style = await page.evaluate(() => {
+			const terminal = document.querySelector("#terminal");
+			const screen = document.querySelector(".xterm-screen");
+			const rows = [...document.querySelectorAll(".xterm-rows > div")];
+			const spans = [...document.querySelectorAll(".xterm-rows span")];
+			const terminalStyle = terminal ? getComputedStyle(terminal) : undefined;
+			const screenStyle = screen ? getComputedStyle(screen) : undefined;
+			const colors = new Set(spans.map((span) => getComputedStyle(span).color));
+			const backgrounds = new Set(spans.map((span) => getComputedStyle(span).backgroundColor));
+			const term = window.__piVisualSmokeTerminal;
+			return {
+				terminalPresent: Boolean(terminal),
+				terminalRect: terminal ? terminal.getBoundingClientRect().toJSON() : null,
+				screenRect: screen ? screen.getBoundingClientRect().toJSON() : null,
+				rowCount: rows.length,
+				spanCount: spans.length,
+				colorCount: colors.size,
+				backgroundCount: backgrounds.size,
+				terminalBackground: terminalStyle?.backgroundColor,
+				terminalBorderColor: terminalStyle?.borderColor,
+				terminalBorderRadius: terminalStyle?.borderRadius,
+				screenBackground: screenStyle?.backgroundColor,
+				bufferLength: term?.buffer?.active?.length ?? 0,
+			};
+		});
+
+		const lines = await page.evaluate(() => {
+			const term = window.__piVisualSmokeTerminal;
+			const buffer = term?.buffer?.active;
+			if (!buffer) return [];
+			const out = [];
+			for (let index = 0; index < buffer.length; index++) {
+				out.push(buffer.getLine(index)?.translateToString(true) ?? "");
+			}
+			return out;
+		});
+
+		for (const item of findVisualEvidenceItems(lines, specs)) {
+			if (item.ok) {
+				const screenshot = `cards/${safeFileName(item.id)}.png`;
+				await page.evaluate((targetLine) => {
+					window.__piVisualSmokeTerminal?.scrollToLine(Math.max(0, targetLine - 4));
+				}, item.lineIndex);
+				await page.waitForTimeout(100);
+				await page.locator("#terminal").screenshot({ path: resolve(outDir, screenshot) });
+				evidence.items.push({ ...item, screenshot });
+			} else {
+				evidence.items.push(item);
+			}
+		}
+	} catch (error) {
+		evidence.checks.push({ id: "visual-playwright", ok: false, error: error instanceof Error ? error.message : String(error) });
+	} finally {
+		if (browser) await browser.close();
+	}
+
+	const style = evidence.style;
+	const png = evidence.png;
+	evidence.checks.push(
+		{ id: "visual-png-size", ok: Boolean(png && png.width >= 800 && png.height >= 500 && png.bytes > 10_000), value: png },
+		{ id: "visual-terminal-present", ok: style?.terminalPresent === true },
+		{ id: "visual-xterm-buffer", ok: Number(style?.bufferLength ?? 0) >= 10, value: style?.bufferLength ?? 0 },
+		{ id: "visual-xterm-rows", ok: Number(style?.rowCount ?? 0) >= 20, value: style?.rowCount ?? 0 },
+		{ id: "visual-xterm-styled-spans", ok: Number(style?.spanCount ?? 0) >= 10, value: style?.spanCount ?? 0 },
+		{ id: "visual-terminal-theme", ok: style?.terminalBackground === "rgb(11, 15, 20)" && style?.terminalBorderColor !== "rgba(0, 0, 0, 0)" && style?.terminalBorderRadius !== "0px", value: style },
+	);
+	for (const item of evidence.items) {
+		evidence.checks.push({ id: `visual-evidence-${item.id}`, ok: item.ok === true, line: item.line, screenshot: item.screenshot, pattern: item.pattern, error: item.error });
+	}
+	evidence.ok = evidence.checks.every((check) => check.ok);
+	writeFileSync(resolve(outDir, "visual-evidence.json"), JSON.stringify(evidence, null, 2));
+	return evidence;
+}

package/scripts/platform-smoke.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import { createRequire } from "node:module";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+// ── helpers ────────────────────────────────────────────────────────────────
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const repoRoot = resolve(__dirname, "..");
+
+const require = createRequire(import.meta.url);
+let config;
+try {
+	config = require(resolve(repoRoot, "platform-smoke.config.mjs"));
+	if (config.default) config = config.default;
+} catch (err) {
+	config = null;
+}
+
+function printHelp() {
+	console.log(`Usage: node scripts/platform-smoke.mjs <command> [options]
+
+Commands:
+  doctor                     Run all preflight checks (no Cursor tokens)
+  run --target <names>       Run one or more comma-separated targets concurrently
+  run --suite <name>         Run one suite on all or specified targets
+  run --target <n> --suite <n>
+
+Options:
+  --target       Comma-separated target names: macos,ubuntu,windows-native
+  --suite        Suite name: platform-build,cursor-native-visual-matrix,cursor-bridge-visual-matrix,cursor-abort-cleanup
+  --help, -h     Show this help
+
+Examples:
+  node scripts/platform-smoke.mjs doctor
+  node scripts/platform-smoke.mjs run --target macos
+  node scripts/platform-smoke.mjs run --target macos,ubuntu
+  node scripts/platform-smoke.mjs run --suite platform-build
+  node scripts/platform-smoke.mjs run --target macos --suite cursor-native-visual-matrix
+
+Environment:
+  PLATFORM_SMOKE_CRABBOX         Path to Crabbox binary
+  CURSOR_API_KEY                 Cursor auth key (required for live suites)
+  PLATFORM_SMOKE_MAC_HOST         macOS SSH host (default: localhost)
+  PLATFORM_SMOKE_MAC_USER         macOS SSH user (default: \$USER)
+  PLATFORM_SMOKE_MAC_WORK_ROOT    macOS work root
+  PLATFORM_SMOKE_WINDOWS_VM       Parallels source VM name
+  PLATFORM_SMOKE_WINDOWS_SNAPSHOT Snapshot name
+  PLATFORM_SMOKE_WINDOWS_USER     Windows SSH user
+  PLATFORM_SMOKE_UBUNTU_IMAGE        Ubuntu container image
+  PLATFORM_SMOKE_WINDOWS_NATIVE_WORK_ROOT  Windows native work root
+`);
+}
+
+function parseArgs(argv) {
+	const args = { _: [], target: null, suite: null, command: null };
+	let i = 2;
+	while (i < argv.length) {
+		const a = argv[i];
+		if (a === "--help" || a === "-h") {
+			args.command = "help";
+			return args;
+		}
+		if (a === "doctor") {
+			args.command = "doctor";
+			i++;
+			continue;
+		}
+		if (a === "run") {
+			args.command = "run";
+			i++;
+			continue;
+		}
+		if (a === "--target" && i + 1 < argv.length) {
+			args.target = argv[i + 1];
+			i += 2;
+			continue;
+		}
+		if (a === "--suite" && i + 1 < argv.length) {
+			args.suite = argv[i + 1];
+			i += 2;
+			continue;
+		}
+		args._.push(a);
+		i++;
+	}
+	return args;
+}
+
+function assertHostReleaseVersionGuard() {
+	const packageJson = JSON.parse(readFileSync(resolve(repoRoot, "package.json"), "utf8"));
+	const result = spawnSync("git", ["tag", "--list", "v[0-9]*.[0-9]*.[0-9]*", "--sort=-v:refname"], {
+		cwd: repoRoot,
+		encoding: "utf8",
+	});
+	if (result.status !== 0) throw new Error(`failed to inspect release tags: ${result.stderr || result.error?.message || "unknown git error"}`);
+	const latestTag = result.stdout.split(/\r?\n/).find((tag) => tag.length > 0);
+	if (!latestTag) throw new Error("no local release tags found; cannot enforce package version reuse guard");
+	const latestVersion = latestTag.replace(/^v/, "");
+	if (packageJson.version === latestVersion) throw new Error(`package version ${packageJson.version} reuses latest release tag ${latestTag}`);
+}
+
+// ── commands ───────────────────────────────────────────────────────────────
+async function runDoctor() {
+	try {
+		const { runDoctor } = await import("./platform-smoke/doctor.mjs");
+		await runDoctor(config);
+	} catch (err) {
+		if (err.code === "ERR_MODULE_NOT_FOUND") {
+			console.error("doctor module not found. Is scripts/platform-smoke/doctor.mjs present?");
+		} else {
+			console.error("doctor failed:", err.message);
+		}
+		process.exit(1);
+	}
+}
+
+async function runSuite(targetName, suiteName) {
+	try {
+		const { runTargetSuite } = await import("./platform-smoke/targets.mjs");
+		const result = await runTargetSuite(config, targetName, suiteName);
+		return result;
+	} catch (err) {
+		console.error(`suite ${suiteName} on ${targetName} exception:`, err.message);
+		return { ok: false, error: err.message };
+	}
+}
+
+async function runTarget(targetName, suites) {
+	try {
+		const { runTargetSuites } = await import("./platform-smoke/targets.mjs");
+		return await runTargetSuites(config, targetName, suites);
+	} catch (err) {
+		console.error(`target ${targetName} exception:`, err.message);
+		return { ok: false, error: err.message };
+	}
+}
+
+async function main() {
+	const args = parseArgs(process.argv);
+
+	if (!args.command || args.command === "help") {
+		printHelp();
+		process.exit(args.command === "help" ? 0 : 1);
+	}
+
+	if (!config) {
+		console.error("platform-smoke.config.mjs not found or failed to load");
+		process.exit(1);
+	}
+
+	if (args.command === "doctor") {
+		await runDoctor();
+		return;
+	}
+
+	if (args.command === "run") {
+		assertHostReleaseVersionGuard();
+		const targets = args.target
+			? args.target.split(",").map((s) => s.trim()).filter(Boolean)
+			: config.requiredTargets;
+
+		const suites = args.suite
+			? [args.suite]
+			: config.requiredSuites;
+
+		const targetRuns = targets.map(async (targetName) => {
+			console.log(`\n=== Target: ${targetName} ===`);
+			const result = args.suite
+				? await runSuite(targetName, suites[0])
+				: await runTarget(targetName, suites);
+			return { targetName, result };
+		});
+		const results = await Promise.all(targetRuns);
+		const anyFailed = results.some(({ result }) => !result.ok);
+		if (anyFailed) {
+			console.log("\nOne or more suites failed. Check .artifacts/platform-smoke/ for details.");
+			process.exit(1);
+		}
+		return;
+	}
+
+	console.error(`Unknown command: ${args.command}`);
+	process.exit(1);
+}
+
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});

package/scripts/probe-mcp-coldstart.mjs

@@ -6,6 +6,7 @@
 import { spawn } from "node:child_process";
 import { performance } from "node:perf_hooks";
 import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
 import {
 	installCursorMcpToolTimeoutOverride,
 	restoreCursorMcpToolTimeoutOverride,
@@ -16,6 +17,12 @@ import { createScriptFail } from "./lib/cursor-script-fail.mjs";
 import { installCursorSdkOutputFilter, suppressCursorSdkOutput } from "./lib/cursor-sdk-output-filter.mjs";
 
 const SCRIPT_PATH = fileURLToPath(import.meta.url);
+
+function isMainModule() {
+	if (!process.argv[1]) return false;
+	const invoked = resolve(process.argv[1]);
+	return process.platform === "win32" ? SCRIPT_PATH.toLowerCase() === invoked.toLowerCase() : SCRIPT_PATH === invoked;
+}
 const SCENARIOS = [
 	{ label: "with-all-settings", settingSources: ["all"] },
 	{ label: "with-all-settings+connect-override", settingSources: ["all"], installConnectOverride: true },
@@ -218,7 +225,7 @@ async function main(argv = process.argv.slice(2), env = process.env) {
 	}
 }
 
-if (import.meta.url === new URL(process.argv[1], "file:").href) {
+if (isMainModule()) {
 	main().catch((error) => {
 		const message = error instanceof Error ? error.message : String(error);
 		fail(message, apiKeySecretsFromProcess());

package/scripts/steering-rpc-smoke.mjs

@@ -165,7 +165,7 @@ function buildPiRpcEnv(baseEnv = process.env, nodePath = process.execPath) {
 }
 
 async function runPiRpcSmoke(sessionDir, piBin) {
-	const args = ["-e", root, "--cursor-no-fast", "--model", "cursor/composer-2.5", "--mode", "rpc", "--session-dir", sessionDir];
+	const args = ["-e", root, "--cursor-no-fast", "--model", "cursor/composer-2-5", "--mode", "rpc", "--session-dir", sessionDir];
 	const env = buildPiRpcEnv();
 
 	const child = spawn(piBin, args, { cwd: root, env, stdio: ["pipe", "pipe", "pipe"], detached: process.platform !== "win32" });

package/scripts/tmux-live-smoke.sh

@@ -245,7 +245,7 @@ exec %s
 		"$TMUX_BIN" capture-pane -pt "$session" >"$capture" 2>/dev/null || true
 		missing=""
 		"$RG_BIN" -q "SUM=42" "$capture" || missing="${missing} SUM=42"
-		"$RG_BIN" -q "\\(cursor\\) composer-2\\.5" "$capture" || missing="${missing} footer (cursor) composer-2.5"
+		"$RG_BIN" -q "\\(cursor\\) composer-2[-.]5" "$capture" || missing="${missing} footer (cursor) composer-2-5"
 		if [[ -z "$missing" ]]; then
 			"$TMUX_BIN" kill-session -t "$session" 2>/dev/null || true
 			log "$name PASS"
@@ -394,7 +394,7 @@ fi
 PI_BASE=(
 	"$PI_BIN" -e "$ROOT"
 	--cursor-no-fast
-	--model cursor/composer-2.5
+	--model cursor/composer-2-5
 )
 
 if [[ -z "${CURSOR_API_KEY:-}" ]]; then
@@ -416,7 +416,7 @@ log "partial live smoke: prereq, basic, default-settings, noninteractive-math, t
 
 if ! "${NONE_ENV[@]}" "${PI_BASE[@]}" --list-models cursor 2>"$SMOKE_DIR/prereq.stderr.txt" | tee "$SMOKE_DIR/prereq.models.txt" | "$RG_BIN" -q "composer-2\\.5"; then
 	if ! model_listed "$SMOKE_DIR/prereq.stderr.txt"; then
-		fail "cursor/composer-2.5 not listed"
+		fail "cursor/composer-2-5 not listed"
 	fi
 fi
 log "prereq PASS"

package/scripts/visual-tui-smoke.mjs

@@ -14,7 +14,7 @@ const DEFAULT_HEIGHT = 45;
 const DEFAULT_WAIT_MS = 60_000;
 const DEFAULT_STARTUP_MS = 5_000;
 const DEFAULT_HISTORY_LINES = 3_000;
-const DEFAULT_MODEL = "cursor/composer-2.5";
+const DEFAULT_MODEL = "cursor/composer-2-5";
 const DEFAULT_MODE = "plan";
 const DEFAULT_SETTING_SOURCES = "none";
 const DEBUG_ENV_NAMES = CURSOR_SDK_EVENT_DEBUG_ENV_NAMES;

package/src/context.ts

@@ -114,10 +114,8 @@ function sanitizeSystemPromptForCursor(systemPrompt: string): string {
 		/Guidelines:\n[\s\S]*?\n\nPi documentation /g,
 		"Guidelines:\n- Be concise in your responses.\n- Show file paths clearly when working with files.\n\nPi documentation ",
 	);
-	sanitized = sanitized.replace(
-		/\n\nThe following skills provide specialized instructions for specific tasks\.[\s\S]*?<\/available_skills>/g,
-		"",
-	);
+	// Keep the Agent Skills catalog. Cursor-specific skill activation wording is normalized
+	// by cursor-skill-tool.ts before this prompt reaches the Cursor SDK provider.
 	sanitized = sanitized.replace(/\n+Semantic code intelligence priority:[\s\S]*$/g, "");
 	return sanitized.trim();
 }

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

@@ -33,6 +33,7 @@ class CursorPiToolBridgeToolExecutionAbortTracker {
 
 		execution.onAbort = () => {
 			this.cancelExecution(execution, "Cursor pi bridge tool execution was aborted");
+			this.abortExecution(execution);
 			this.finish(toolCallId);
 		};
 		execution.signal?.addEventListener("abort", execution.onAbort, { once: true });

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

@@ -1,8 +1,10 @@
+import { appendFileSync } from "node:fs";
 import { stableNameHash } from "./cursor-pi-tool-bridge-mcp.js";
 import { parseEnvBoolean } from "./cursor-env-boolean.js";
 import type { CursorSdkEventDebugRecorder } from "./cursor-sdk-event-debug.js";
 
 export const CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV = "PI_CURSOR_PI_TOOL_BRIDGE_DEBUG";
+export const CURSOR_PI_TOOL_BRIDGE_DEBUG_FILE_ENV = "PI_CURSOR_PI_TOOL_BRIDGE_DEBUG_FILE";
 export const CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX = "[pi-cursor-sdk:bridge]";
 
 export function resolveCursorPiToolBridgeDebugEnabled(env: Record<string, string | undefined> = process.env): boolean {
@@ -180,9 +182,18 @@ export function writeCursorPiToolBridgeDiagnostic(
 	} catch {
 		// Diagnostics must never affect bridge execution.
 	}
+	const serialized = serializeCursorPiToolBridgeDiagnostic(event);
+	const debugFile = env[CURSOR_PI_TOOL_BRIDGE_DEBUG_FILE_ENV];
+	if (debugFile) {
+		try {
+			appendFileSync(debugFile, `${JSON.stringify(serialized)}\n`);
+		} catch {
+			// Diagnostics must never affect bridge execution.
+		}
+	}
 	if (!resolveCursorPiToolBridgeDebugEnabled(env)) return;
 	try {
-		process.stderr.write(`${CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX} ${JSON.stringify(serializeCursorPiToolBridgeDiagnostic(event))}\n`);
+		process.stderr.write(`${CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX} ${JSON.stringify(serialized)}\n`);
 	} catch {
 		// Diagnostics must never affect bridge execution.
 	}

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

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import {
 	CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV,
 	CURSOR_PI_TOOL_BRIDGE_DIAGNOSTIC_PREFIX,
@@ -44,6 +45,46 @@ export {
 
 let registeredCursorPiToolBridge: CursorPiToolBridgeRegistry | undefined;
 
+const WINDOWS_BRIDGE_ABORT_ENV = "PI_CURSOR_BRIDGE_TOOL_CALL_ID";
+
+function buildWindowsBridgeBashAbortCommand(command: string, marker: string): string {
+	return `export ${WINDOWS_BRIDGE_ABORT_ENV}=${marker}; ${command}`;
+}
+
+function installWindowsBridgeBashAbortMarker(event: { toolCallId: string; toolName: string; input: unknown }): string | undefined {
+	if (process.platform !== "win32" || event.toolName !== "bash") return undefined;
+	if (typeof event.input !== "object" || event.input === null || !("command" in event.input)) return undefined;
+	const input = event.input as { command?: unknown };
+	if (typeof input.command !== "string" || input.command.length === 0) return undefined;
+	const marker = event.toolCallId.replace(/[^A-Za-z0-9_.:-]/g, "_");
+	input.command = buildWindowsBridgeBashAbortCommand(input.command, marker);
+	return marker;
+}
+
+function killWindowsBridgeBashMarkerTree(marker: string | undefined): void {
+	if (process.platform !== "win32" || !marker) return;
+	const encodedMarker = Buffer.from(marker, "utf8").toString("base64");
+	const script = `
+$marker = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encodedMarker}'))
+$needle = '${WINDOWS_BRIDGE_ABORT_ENV}=' + $marker
+$seen = @{}
+function Stop-Tree([int]$ProcessId) {
+  if ($seen.ContainsKey($ProcessId)) { return }
+  $seen[$ProcessId] = $true
+  Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -eq $ProcessId } | ForEach-Object { Stop-Tree $_.ProcessId }
+  Stop-Process -Id $ProcessId -Force -ErrorAction SilentlyContinue
+}
+Get-CimInstance Win32_Process -Filter "Name = 'bash.exe' OR Name = 'sh.exe'" |
+  Where-Object { $_.CommandLine -and $_.CommandLine.Contains($needle) } |
+  ForEach-Object { Stop-Tree $_.ProcessId }
+`;
+	spawnSync("powershell.exe", ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], {
+		stdio: "ignore",
+		timeout: 3_000,
+		windowsHide: true,
+	});
+}
+
 export function registerCursorPiToolBridge(pi: CursorPiToolBridgeExtensionApi): CursorPiToolBridge {
 	bridgeToolExecutionAbortTracker.abortAll("Cursor pi tool bridge extension reloaded");
 	void registeredCursorPiToolBridge?.disposeAll("Cursor pi tool bridge extension reloaded");
@@ -51,10 +92,12 @@ export function registerCursorPiToolBridge(pi: CursorPiToolBridgeExtensionApi):
 	registeredCursorPiToolBridge = bridge;
 	pi.on("tool_call", (event, ctx) => {
 		if (!bridge.hasPendingPiToolCallId(event.toolCallId)) return undefined;
+		const windowsAbortMarker = installWindowsBridgeBashAbortMarker(event);
 		const trackingStarted = bridgeToolExecutionAbortTracker.track(event.toolCallId, {
 			signal: ctx.signal,
 			abort: () => {
-				void ctx.abort();
+				ctx.abort();
+				killWindowsBridgeBashMarkerTree(windowsAbortMarker);
 			},
 			cancelPending: (reason) => {
 				bridge.cancelPendingPiToolCallId(event.toolCallId, reason);
@@ -100,6 +143,8 @@ export const __testUtils = {
 	getActiveBridgeToolExecutionAbortCount() {
 		return bridgeToolExecutionAbortTracker.getActiveCount();
 	},
+	buildWindowsBridgeBashAbortCommandForTests: buildWindowsBridgeBashAbortCommand,
+	installWindowsBridgeBashAbortMarkerForTests: installWindowsBridgeBashAbortMarker,
 	emitBridgeToolExecutionProcessAbortSignalForTests(signal: NodeJS.Signals) {
 		bridgeToolExecutionAbortTracker.emitProcessAbortSignalForTests(signal);
 	},

package/src/cursor-provider-turn-lifecycle-emitter.ts

@@ -9,6 +9,7 @@ import {
 	isCursorToolLifecycleEligible,
 } from "./cursor-tool-lifecycle.js";
 import { classifyCursorToolVisibility } from "./cursor-tool-visibility.js";
+import { getStartedToolCallFingerprint } from "./cursor-provider-turn-tool-ledger.js";
 
 function getNormalizedCursorToolName(toolCall: unknown): string {
 	return classifyCursorToolVisibility(toolCall).normalizedName;
@@ -32,6 +33,10 @@ export class CursorToolLifecycleEmitter {
 	private readonly isBridgeMcpToolCall: (toolCall: unknown) => boolean;
 	private readonly emittedLifecycleCallIds = new Set<string>();
 	private readonly lifecycleTimers = new Map<string, ReturnType<typeof setTimeout>>();
+	private readonly activeLifecycleFingerprintOwners = new Map<string, string>();
+	private readonly lifecycleFingerprintByCallId = new Map<string, string>();
+	private readonly activeLifecycleProgressTextOwners = new Map<string, string>();
+	private readonly lifecycleProgressTextByCallId = new Map<string, string>();
 
 	constructor(options: CursorToolLifecycleEmitterOptions) {
 		this.liveRun = options.liveRun;
@@ -47,12 +52,47 @@ export class CursorToolLifecycleEmitter {
 		if (this.isBridgeMcpToolCall(toolCall)) return;
 		if (!isCursorToolLifecycleEligible(toolCall)) return;
 
+		const progressText = formatCursorToolLifecycleProgressText(toolCall, this.resolvedApiKey);
+		if (!progressText) return;
+
+		const fingerprint = getStartedToolCallFingerprint(toolCall);
+		const existingOwner = this.activeLifecycleFingerprintOwners.get(fingerprint);
+		if (existingOwner && existingOwner !== callId) {
+			this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle_skip", {
+				callId,
+				ownerCallId: existingOwner,
+				toolName: getNormalizedCursorToolName(toolCall),
+				reason: "duplicate-active-fingerprint",
+			});
+			return;
+		}
+
 		this.cancel(callId);
+		this.activeLifecycleFingerprintOwners.set(fingerprint, callId);
+		this.lifecycleFingerprintByCallId.set(callId, fingerprint);
+		if (!this.activeLifecycleProgressTextOwners.has(progressText)) {
+			this.activeLifecycleProgressTextOwners.set(progressText, callId);
+		}
+		this.lifecycleProgressTextByCallId.set(callId, progressText);
 		const timer = setTimeout(() => {
 			this.lifecycleTimers.delete(callId);
-			if (!this.hasStartedToolCall(callId)) return;
+			if (!this.hasStartedToolCall(callId)) {
+				this.clearLifecycleIdentity(callId);
+				return;
+			}
 			if (this.emittedLifecycleCallIds.has(callId)) return;
-			this.emit(callId, toolCall);
+			const progressOwner = this.activeLifecycleProgressTextOwners.get(progressText);
+			if (progressOwner && progressOwner !== callId && this.hasStartedToolCall(progressOwner)) {
+				this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle_skip", {
+					callId,
+					ownerCallId: progressOwner,
+					toolName: getNormalizedCursorToolName(toolCall),
+					reason: "duplicate-active-progress-text",
+				});
+				return;
+			}
+			this.activeLifecycleProgressTextOwners.set(progressText, callId);
+			this.emit(callId, toolCall, progressText);
 		}, CURSOR_TOOL_LIFECYCLE_DEFER_MS);
 		timer.unref?.();
 		this.lifecycleTimers.set(callId, timer);
@@ -60,20 +100,37 @@ export class CursorToolLifecycleEmitter {
 
 	cancel(callId: string): void {
 		const timer = this.lifecycleTimers.get(callId);
-		if (!timer) return;
-		clearTimeout(timer);
-		this.lifecycleTimers.delete(callId);
+		if (timer) {
+			clearTimeout(timer);
+			this.lifecycleTimers.delete(callId);
+		}
+		this.clearLifecycleIdentity(callId);
 	}
 
 	clear(): void {
 		this.emittedLifecycleCallIds.clear();
 		for (const timer of this.lifecycleTimers.values()) clearTimeout(timer);
 		this.lifecycleTimers.clear();
+		this.activeLifecycleFingerprintOwners.clear();
+		this.lifecycleFingerprintByCallId.clear();
+		this.activeLifecycleProgressTextOwners.clear();
+		this.lifecycleProgressTextByCallId.clear();
 	}
 
-	private emit(callId: string, toolCall: unknown): void {
-		const progressText = formatCursorToolLifecycleProgressText(toolCall, this.resolvedApiKey);
-		if (!progressText) return;
+	private clearLifecycleIdentity(callId: string): void {
+		const fingerprint = this.lifecycleFingerprintByCallId.get(callId);
+		if (fingerprint && this.activeLifecycleFingerprintOwners.get(fingerprint) === callId) {
+			this.activeLifecycleFingerprintOwners.delete(fingerprint);
+		}
+		this.lifecycleFingerprintByCallId.delete(callId);
+		const progressText = this.lifecycleProgressTextByCallId.get(callId);
+		if (progressText && this.activeLifecycleProgressTextOwners.get(progressText) === callId) {
+			this.activeLifecycleProgressTextOwners.delete(progressText);
+		}
+		this.lifecycleProgressTextByCallId.delete(callId);
+	}
+
+	private emit(callId: string, toolCall: unknown, progressText: string): void {
 		this.emittedLifecycleCallIds.add(callId);
 		this.debugRecorder?.recordCoordinatorEvent("tool_lifecycle", {
 			callId,

package/src/cursor-provider-turn-tool-ledger.ts

@@ -1,5 +1,4 @@
-import { getField } from "./cursor-record-utils.js";
-import { getToolName } from "./cursor-transcript-utils.js";
+import { getToolArgs, getToolName } from "./cursor-transcript-utils.js";
 
 export type CursorToolDisplaySource = "started" | "fallback" | "transcript";
 
@@ -122,5 +121,5 @@ export function getToolFingerprint(value: unknown): string {
 }
 
 export function getStartedToolCallFingerprint(toolCall: unknown): string {
-	return getToolFingerprint({ toolName: getToolName(toolCall), args: getField(toolCall, "args") });
+	return getToolFingerprint({ toolName: getToolName(toolCall), args: getToolArgs(toolCall) });
 }