pi-cursor-sdk 0.1.62 → 0.3.6

package/scripts/build.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Purpose: Produce the compiled runtime files that the Pi extension manifest loads.
+ * Responsibilities: Run TypeScript emit into a staging directory, then atomically swap it
+ * into dist/ so a failed TypeScript emit never destroys a previously working dist.
+ * Usage: `npm run build`; also invoked by scripts/prepare.mjs during install lifecycles.
+ * Invariants/Assumptions: `node_modules` provides `typescript`; deleting `dist/` is safe generated output.
+ */
+
+import { execFile as execFileCallback } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCallback);
+const RM_OPTIONS = { force: true, maxRetries: 5, recursive: true, retryDelay: 100 };
+const RENAME_RETRY_LIMIT = 50;
+const RENAME_RETRY_MS = 50;
+// Run tsc's JS entrypoint directly through the current node binary: no .cmd shim,
+// no shell, safe for install paths containing spaces on every platform.
+const tscPath = join(process.cwd(), "node_modules", "typescript", "bin", "tsc");
+
+async function discardStaging(path) {
+	try {
+		await rm(path, RM_OPTIONS);
+	} catch (error) {
+		// Cleanup is always best-effort: it must not turn a successful race loss
+		// into failure or replace the compiler/publish error that matters.
+		console.warn(`could not remove staging ${path}: ${error?.message ?? error}`);
+	}
+}
+
+function isOwnerGone(pid) {
+	try {
+		process.kill(pid, 0);
+		return false;
+	} catch (error) {
+		return error?.code === "ESRCH";
+	}
+}
+
+async function hasPublishedDist(path) {
+	try {
+		return (await readdir(path)).length > 0;
+	} catch {
+		return false;
+	}
+}
+
+async function reapStrandedStaging(cwd) {
+	// Signal 0 proves only that the owner was gone at probe time. Pid reuse
+	// between this probe and removal is inherent to pid-based reaping.
+	for (const entry of await readdir(cwd, { withFileTypes: true })) {
+		const match = /^dist\.staging\.(\d+)$/.exec(entry.name);
+		if (!match || !entry.isDirectory()) continue;
+		const ownerPid = Number(match[1]);
+		if (ownerPid === process.pid || !isOwnerGone(ownerPid)) continue;
+		await discardStaging(join(cwd, entry.name));
+	}
+}
+
+async function compileToStaging(cwd, stagingDir) {
+	try {
+		const { stderr, stdout } = await execFile(
+			process.execPath,
+			[tscPath, "-p", "tsconfig.build.json", "--outDir", stagingDir],
+			{ cwd, maxBuffer: 10 * 1024 * 1024 },
+		);
+		if (stdout) process.stdout.write(stdout);
+		if (stderr) process.stderr.write(stderr);
+	} catch (error) {
+		if (error?.stdout) process.stdout.write(error.stdout);
+		if (error?.stderr) process.stderr.write(error.stderr);
+		await discardStaging(stagingDir);
+		throw error;
+	}
+}
+
+async function publishStaging(stagingDir, distDir) {
+	try {
+		// A failed dist removal must fail loudly; keep it outside the retry loop.
+		// Remove dist exactly once so retries never delete a concurrent winner.
+		await rm(distDir, RM_OPTIONS);
+		for (let retry = 0; ; retry++) {
+			try {
+				await rename(stagingDir, distDir);
+				return;
+			} catch (error) {
+				// A completed staged build is non-empty; a bare directory is not proof
+				// that a concurrent publisher won the race.
+				if (await hasPublishedDist(distDir)) {
+					console.warn("dist/ was published by a concurrent build; discarding this build's staging tree.");
+					return;
+				}
+				// At most 50 retries (~2.5s) keep persistent filesystem errors bounded.
+				if (existsSync(stagingDir) && retry < RENAME_RETRY_LIMIT) {
+					await delay(RENAME_RETRY_MS);
+					continue;
+				}
+				throw error;
+			}
+		}
+	} finally {
+		// Safe after success too: rename moved stagingDir, so force makes this a no-op.
+		await discardStaging(stagingDir);
+	}
+}
+
+async function main() {
+	const cwd = process.cwd();
+	if (!existsSync(tscPath)) throw new Error(`typescript is not installed at ${tscPath}; run npm install first.`);
+	await reapStrandedStaging(cwd);
+	// Pid-scoped staging isolates concurrent emits; only a complete tree publishes.
+	const stagingDir = join(cwd, `dist.staging.${process.pid}`);
+	await rm(stagingDir, RM_OPTIONS);
+	await compileToStaging(cwd, stagingDir);
+	await publishStaging(stagingDir, join(cwd, "dist"));
+}
+
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});

package/scripts/cloud-runtime-smoke.mjs

@@ -10,6 +10,7 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { terminateChild } from "./lib/cursor-child-process.mjs";
+import { ensureBuilt } from "./lib/ensure-built.mjs";
 import { buildCursorSmokeEnv } from "./lib/cursor-smoke-env.mjs";
 import {
 	checkpointCloudSmokeShutdown,
@@ -50,7 +51,7 @@ import { scrubSensitiveText } from "../shared/cursor-sensitive-text.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const EVIDENCE_PATH = join(root, "docs", "evidence", "cursor-cloud-smoke-matrix-latest.json");
-const MODEL = "cursor/composer-2-5";
+const MODEL = "cursor/grok-4.6";
 const CLOUD_RUN_ID_PATTERN = /^run-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const cloudSmokeShutdown = createCloudSmokeShutdownController((child) => terminateChild(child, { graceMs: 15_000 }));
 const argv = process.argv.slice(2);
@@ -614,6 +615,7 @@ async function main() {
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	ensureBuilt();
 	main().catch((error) => {
 		reportFailure(error);
 		process.exit(1);

package/scripts/debug-provider-events.mjs

@@ -23,6 +23,7 @@ import {
 } from "./lib/cursor-child-process.mjs";
 import { scrubSensitiveText } from "../shared/cursor-sensitive-text.mjs";
 import { createScriptFail } from "./lib/cursor-script-fail.mjs";
+import { ensureBuilt } from "./lib/ensure-built.mjs";
 import { serializeCursorSettingSources } from "../shared/cursor-setting-sources.mjs";
 
 function isMainModule() {
@@ -35,7 +36,7 @@ function isMainModule() {
 const require = createRequire(import.meta.url);
 const root = fileURLToPath(new URL("..", import.meta.url));
 const packageJson = require("../package.json");
-const DEFAULT_MODEL = "cursor/composer-2-5";
+const DEFAULT_MODEL = "cursor/grok-4.6";
 const DEFAULT_OUT_BASE = ".debug/cursor-sdk-events";
 const SDK_EVENT_DEBUG_LOG_PREFIX = "[pi-cursor-sdk:sdk-events]";
 const PI_SESSION_SNAPSHOT_ARTIFACT = "pi-session-snapshot.jsonl";
@@ -301,6 +302,7 @@ async function main(argv = process.argv.slice(2), env = process.env) {
 		printHelp();
 		return;
 	}
+	ensureBuilt();
 	console.log(JSON.stringify(await runDebugProviderEvents(args, env)));
 }
 

package/scripts/debug-sdk-events.mjs

@@ -39,7 +39,7 @@ const ARTIFACTS = {
 	summary: "summary.json",
 };
 
-const DEFAULT_MODEL = "composer-2.5";
+const DEFAULT_MODEL = "grok-4.6";
 const RAW_ARTIFACT_WARNING =
 	"Raw artifact files may contain local paths, project text, tool args/results, or secrets from the workspace. Do not commit or share them.";
 

package/scripts/isolated-cursor-smoke.sh

@@ -134,7 +134,7 @@ run_self_test() {
 	env_capture="$temp_dir/fake-pi.env"
 	cat >"$fake_pi" <<EOF_SELFTEST_PI
 #!/usr/bin/env node
-const { writeFileSync } = require("node:fs");
+import { writeFileSync } from "node:fs";
 writeFileSync("$env_capture", Object.entries(process.env).map(([key, value]) => key + "=" + (value ?? "")).join("\\n") + "\\n", "utf8");
 EOF_SELFTEST_PI
 	cat >"$fake_node" <<EOF_SELFTEST_NODE
@@ -359,13 +359,14 @@ log "check: list-models"
 LIST_OUT="$ISOLATED/list-models.txt"
 run_in_dir_capture_combined "list-models" 30 "$PROJECT_DIR" "$LIST_OUT" "${PI_CURSOR_ENV[@]}" \
 	"$PI_BIN" --approve --cursor-no-fast --list-models cursor
+"$RG_BIN" -q "grok-4\\.6" "$LIST_OUT" || fail "grok-4.6 not listed (see $LIST_OUT)"
 "$RG_BIN" -q "composer-2\\.5|composer-2-5" "$LIST_OUT" || fail "composer-2-5 not listed (see $LIST_OUT)"
 
 log "check: basic provider prompt"
 BASIC_DIR="$SESSION_ROOT/basic"
 mkdir -p "$BASIC_DIR"
 run_in_dir_capture_split "basic prompt" "$PI_LIVE_TIMEOUT" "$PROJECT_DIR" "$ISOLATED/basic.stdout.txt" "$ISOLATED/basic.stderr.txt" "${PI_CURSOR_ENV[@]}" \
-	"$PI_BIN" --approve --cursor-no-fast --model cursor/composer-2-5 --session-dir "$BASIC_DIR" --no-tools -p 'Reply exactly: PI_CURSOR_ISOLATED_OK'
+	"$PI_BIN" --approve --cursor-no-fast --model cursor/grok-4.6 --session-dir "$BASIC_DIR" --no-tools -p 'Reply exactly: PI_CURSOR_ISOLATED_OK'
 "$RG_BIN" -q "PI_CURSOR_ISOLATED_OK" "$ISOLATED/basic.stdout.txt" || fail "basic prompt missing PI_CURSOR_ISOLATED_OK"
 validate_replay_jsonl "$BASIC_DIR"
 
@@ -373,14 +374,14 @@ log "check: native replay"
 REPLAY_DIR="$SESSION_ROOT/native-replay"
 mkdir -p "$REPLAY_DIR"
 run_in_dir_capture_split "native replay" "$PI_LIVE_TIMEOUT" "$PROJECT_DIR" "$ISOLATED/replay.stdout.txt" "$ISOLATED/replay.stderr.txt" "${PI_CURSOR_ENV[@]}" PI_CURSOR_NATIVE_TOOL_DISPLAY=1 \
-	"$PI_BIN" --approve --cursor-no-fast --model cursor/composer-2-5 --session-dir "$REPLAY_DIR" -p 'Read ./README.md briefly, then answer README_SEEN=yes if it mentions pi-cursor-sdk.'
+	"$PI_BIN" --approve --cursor-no-fast --model cursor/grok-4.6 --session-dir "$REPLAY_DIR" -p 'Read ./README.md briefly, then answer README_SEEN=yes if it mentions pi-cursor-sdk.'
 validate_replay_jsonl "$REPLAY_DIR"
 
 log "check: plan-strip shim (plan-mode execute reset)"
 PLAN_DIR="$SESSION_ROOT/plan-strip"
 mkdir -p "$PLAN_DIR"
 run_in_dir_capture_split "plan-strip replay" "$PI_LIVE_TIMEOUT" "$PROJECT_DIR" "$ISOLATED/plan.stdout.txt" "$ISOLATED/plan.stderr.txt" "${PI_CURSOR_ENV[@]}" PI_CURSOR_NATIVE_TOOL_DISPLAY=1 \
-	"$PI_BIN" --approve -e "$SHIM_DIR" --cursor-no-fast --model cursor/composer-2-5 --session-dir "$PLAN_DIR" -p 'After reset, read README.md and answer PLAN_STRIP_OK=yes.'
+	"$PI_BIN" --approve -e "$SHIM_DIR" --cursor-no-fast --model cursor/grok-4.6 --session-dir "$PLAN_DIR" -p 'After reset, read README.md and answer PLAN_STRIP_OK=yes.'
 validate_replay_jsonl "$PLAN_DIR"
 
 log "PASS isolated install smoke: $ISOLATED"

package/scripts/lib/cloud-smoke-cleanup-evidence.mjs

@@ -360,7 +360,7 @@ function buildCloudSmokeMatrixEvidence(input, laneProjector, allowDefaultTimesta
 	} = data;
 	const timestamp = data.timestamp ?? (allowDefaultTimestamp ? new Date().toISOString() : undefined);
 	if (schemaVersion !== 1) fail("cloud smoke evidence schemaVersion must be 1");
-	if (model !== "cursor/composer-2-5") fail("cloud smoke evidence model must be cursor/composer-2-5");
+	if (model !== "cursor/grok-4.6") fail("cloud smoke evidence model must be cursor/grok-4.6");
 	if (!Array.isArray(lanes) || lanes.length !== LANE_NAMES.length) fail("cloud smoke evidence lanes must contain the complete required matrix");
 	if (!Array.isArray(cleanup) || cleanup.length === 0) fail("cloud smoke evidence cleanup must be a non-empty array");
 	const projectedLanes = lanes.map((lane, index) => laneProjector(lane, index));

package/scripts/lib/cursor-visual-render.mjs

@@ -66,7 +66,7 @@ header code { color: #d8dee9; }
 <header>
 	<div><strong>pi-cursor-sdk visual smoke</strong> <code>${escapeHtml(options.label)}</code></div>
 	<div>model <code>${escapeHtml(options.model)}</code> · mode <code>${escapeHtml(options.mode)}</code> · cwd <code>${escapeHtml(options.cwd)}</code></div>
-	<div>session <code>${escapeHtml(options.sessionId)}</code> · captured ${new Date().toISOString()}</div>
+	<div>session <code>${escapeHtml(options.sessionId ?? "pi-assigned")}</code> · captured ${new Date().toISOString()}</div>
 </header>
 <div id="terminal"></div>
 <noscript><pre class="fallback">${escapeHtml(plain)}</pre></noscript>

package/scripts/lib/ensure-built.mjs

@@ -0,0 +1,16 @@
+/**
+ * Rebuild dist/ before a launcher loads the repo-root extension, so direct
+ * `node scripts/<launcher>.mjs` invocations can never exercise stale code.
+ */
+
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+export function ensureBuilt() {
+	execFileSync(process.execPath, [fileURLToPath(new URL("../build.mjs", import.meta.url))], {
+		// build.mjs anchors tsc/dist/staging to its cwd; pin it to the repo root so
+		// direct launcher invocations work from any directory.
+		cwd: fileURLToPath(new URL("../..", import.meta.url)),
+		stdio: "inherit",
+	});
+}

package/scripts/lib/local-resume-smoke-harness.mjs

@@ -152,7 +152,7 @@ export function startRpc({
 	baseEnv = process.env,
 }) {
 	const model =
-		process.env.CURSOR_LOCAL_RESUME_SMOKE_MODEL || "cursor/composer-2-5:slow";
+		process.env.CURSOR_LOCAL_RESUME_SMOKE_MODEL || "cursor/grok-4.6:slow";
 	const workspaceDir = join(artifactDir, "workspace");
 	mkdirSync(workspaceDir, { recursive: true });
 	const pi = findPiCommand();

package/scripts/local-resume-smoke.mjs

@@ -26,6 +26,7 @@ import {
 	withRpc,
 	writeTreeCommandExtension,
 } from "./lib/local-resume-smoke-harness.mjs";
+import { ensureBuilt } from "./lib/ensure-built.mjs";
 import { runCleanupSmoke } from "./local-resume-cleanup-smoke.mjs";
 import { writePlatformArtifactBundle } from "./platform-smoke/artifacts.mjs";
 import { LOCAL_RESUME_SUITES } from "./platform-smoke/local-resume-suites.mjs";
@@ -45,7 +46,7 @@ ${npmUsage}
 ${nodeUsage}
 
 Environment:
-  CURSOR_LOCAL_RESUME_SMOKE_MODEL          Cursor model id (default: cursor/composer-2-5:slow).
+  CURSOR_LOCAL_RESUME_SMOKE_MODEL          Cursor model id (default: cursor/grok-4.6:slow).
   CURSOR_LOCAL_RESUME_SMOKE_TIMEOUT_MS     Timeout in ms per model turn (default: 300000).
   CURSOR_LOCAL_RESUME_SMOKE_KEEP_ARTIFACTS Keep temp artifacts when set to 1.
   CURSOR_LOCAL_RESUME_SMOKE_EXTENSION_PATH Packed extension path override (platform runner only).
@@ -627,6 +628,7 @@ function selectedRun() {
 }
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	ensureBuilt();
 	const run = selectedRun();
 	run()
 		.catch((error) => {

package/scripts/platform-smoke/card-detect.mjs

@@ -31,7 +31,7 @@ const CARD_PATTERNS = [
 	{ id: "bridge-read-failure", pattern: /^\s*(?:read \.\/definitely-missing-platform-smoke-file\.txt|ENOENT: no such file)\s*/i },
 	{ id: "bridge-shell-success", pattern: /^\s*bridge visual smoke\s*$/i },
 	{ id: "http1-status", pattern: /\bcursor:local\b.*\bhttp1\b/i },
-	{ id: "footer-status", pattern: /\bcomposer-2-5\b|\bcomposer-2\.5\b/i },
+	{ id: "footer-status", pattern: /\bgrok-4\.6\b|\bcomposer-2-5\b|\bcomposer-2\.5\b/i },
 ];
 
 function cleanLine(line) {

package/scripts/platform-smoke/live-suite-runner.mjs

@@ -17,9 +17,8 @@ import { redactSecrets, writePlatformArtifactBundle } from "./artifacts.mjs";
 import { extractContentText, jsonlHasAssistantFinalTextMarker } from "./jsonl-text.mjs";
 import { getScenario, renderPrompt } from "./scenarios.mjs";
 
-const DEFAULT_MODEL = "cursor/composer-2-5";
+const DEFAULT_MODEL = "cursor/grok-4.6";
 const DEFAULT_WAIT_MS = 240_000;
-const READY_WAIT_MS = 45_000;
 const SESSION_JSONL_WAIT_MS = 60_000;
 const COLS = 150;
 const ROWS = 45;
@@ -242,25 +241,10 @@ function stripANSI(text) {
 	return text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "");
 }
 
-function psQuote(value) {
-	return `'${String(value).replace(/'/g, "''")}'`;
-}
-
-function shellQuote(value) {
-	return `'${String(value).replace(/'/g, `'\\''`)}'`;
-}
-
-function ptySpawnCommand(piCli, args) {
-	if (process.platform !== "win32") {
-		return {
-			file: "/bin/bash",
-			args: ["-lc", ["exec", shellQuote(piCli), ...args.map(shellQuote)].join(" ")],
-		};
-	}
-	return {
-		file: "powershell.exe",
-		args: ["-NoLogo", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ["&", psQuote(piCli), ...args.map(psQuote)].join(" ")],
-	};
+function ptySpawnCommand(args) {
+	const cliEntry = resolve(process.cwd(), "node_modules", "@earendil-works", "pi-coding-agent", "dist", "cli.js");
+	if (!existsSync(cliEntry)) throw new Error(`Pi CLI entry not found: ${cliEntry}`);
+	return { file: process.execPath, args: [cliEntry, ...args] };
 }
 
 async function waitForSessionJsonl(sessionDir, finalMarker, startedAt, events) {
@@ -285,7 +269,7 @@ async function waitForSessionJsonl(sessionDir, finalMarker, startedAt, events) {
 	return files;
 }
 
-async function runPtyPi({ artifactDir, piCli, piArgs, env, cwd, sessionDir, prompt, finalMarker, waitMs, abortMode, scenario }) {
+async function runPtyPi({ artifactDir, ptyCommand, env, cwd, sessionDir, finalMarker, waitMs, abortMode, scenario }) {
 	let pty;
 	try {
 		pty = await import("node-pty");
@@ -297,8 +281,7 @@ async function runPtyPi({ artifactDir, piCli, piArgs, env, cwd, sessionDir, prom
 	let plain = "";
 	const events = [];
 	const startedAt = Date.now();
-	const { file, args } = ptySpawnCommand(piCli, piArgs);
-	writeFileSync(join(artifactDir, "pty-spawn-command.json"), JSON.stringify({ file, args, cwd, fileExists: existsSync(file), cwdExists: existsSync(cwd) }, null, 2));
+	const { file, args } = ptyCommand;
 	let child;
 	try {
 		child = pty.spawn(file, args, {
@@ -322,15 +305,7 @@ async function runPtyPi({ artifactDir, piCli, piArgs, env, cwd, sessionDir, prom
 		events.push({ type: "exit", elapsedMs: Date.now() - startedAt, code: event.exitCode, signal: event.signal });
 	});
 
-	const readyStartedAt = Date.now();
-	while (!/(?:composer-2-5|escape interrupt|ctrl\+c\/ctrl\+d)/i.test(plain) && Date.now() - readyStartedAt < READY_WAIT_MS) {
-		await delay(500);
-	}
-	events.push({ type: "ready_wait_finished", elapsedMs: Date.now() - startedAt, ready: /(?:composer-2-5|escape interrupt|ctrl\+c\/ctrl\+d)/i.test(plain) });
-	child.write(`\x1b[200~${prompt}\x1b[201~\r`);
-	events.push({ type: "prompt_sent", elapsedMs: Date.now() - startedAt, bytes: prompt.length });
-	await delay(1_000);
-	const responseStartOffset = plain.length;
+	const responseStartOffset = 0;
 	events.push({ type: "response_watch_started", elapsedMs: Date.now() - startedAt, offset: responseStartOffset });
 
 	let observed = false;
@@ -572,6 +547,7 @@ async function main() {
 		const suiteEnv = {
 			...process.env,
 			...scenario.env,
+			PI_OFFLINE: "1",
 			...(args.suite === "cursor-abort-cleanup" ? { PLATFORM_ABORT_MARKER: "SHOULD_NOT_PRINT" } : {}),
 			PI_CODING_AGENT_DIR: agentDir,
 			PI_CURSOR_SDK_EVENT_DEBUG_DIR: debugDir,
@@ -581,21 +557,21 @@ async function main() {
 		if (args.suite === "cursor-abort-cleanup") writeProcessSnapshot(logDir, "process-before", platform);
 		const prompt = renderPrompt(scenario, platform);
 		writeFileSync(join(artifactDir, "prompt.txt"), prompt);
-		const piArgs = ["--approve", "--cursor-no-fast", "--cursor-mode", "agent", "--model", args.model, "--session-dir", sessionDir, "--session-id", `platform-${args.suite}-${Date.now()}`];
+		const piArgs = ["--approve", "--cursor-no-fast", "--cursor-mode", "agent", "--model", args.model, "--session-dir", sessionDir, "--session-id", `platform-${args.suite}-${Date.now()}`, prompt];
+		const ptyCommand = ptySpawnCommand(piArgs);
 		writeFileSync(join(artifactDir, "pi-command.json"), JSON.stringify({
-			piCli,
-			args: piArgs,
+			...ptyCommand,
 			cwd: workspaceDir,
-			env: Object.fromEntries(Object.entries(suiteEnv).filter(([key]) => key.startsWith("PI_CURSOR_") || key === "PI_CODING_AGENT_DIR" || key === "TERM")),
+			fileExists: existsSync(ptyCommand.file),
+			cwdExists: existsSync(workspaceDir),
+			env: Object.fromEntries(Object.entries(suiteEnv).filter(([key]) => key.startsWith("PI_CURSOR_") || key === "PI_CODING_AGENT_DIR" || key === "PI_OFFLINE" || key === "TERM")),
 		}, null, 2));
 		const ptyResult = await runPtyPi({
 			artifactDir,
-			piCli,
-			piArgs,
+			ptyCommand,
 			env: suiteEnv,
 			cwd: workspaceDir,
 			sessionDir,
-			prompt,
 			finalMarker: scenario.finalMarker,
 			waitMs: args.waitMs,
 			abortMode: args.suite === "cursor-abort-cleanup",

package/scripts/platform-smoke/platform-build-windows.ps1

@@ -62,7 +62,7 @@ Write-SectionFile "NPM_CI_STDOUT" $NpmCiOut
 Write-SectionFile "NPM_CI_STDERR" $NpmCiErr
 
 Write-Output "=== check:platform-smoke ==="
-& npm.cmd run check:platform-smoke 1> $CheckPlatformSmokeOut 2> $CheckPlatformSmokeErr
+& npm.cmd run check:platform-smoke -- --testTimeout=15000 1> $CheckPlatformSmokeOut 2> $CheckPlatformSmokeErr
 $CHECK_PLATFORM_SMOKE_EXIT = Exit-CodeFromLastCommand
 Write-Output "PLATFORM_CHECK_PLATFORM_SMOKE_EXIT=$CHECK_PLATFORM_SMOKE_EXIT"
 Write-SectionFile "CHECK_PLATFORM_SMOKE_STDOUT" $CheckPlatformSmokeOut

package/scripts/platform-smoke/render-ansi.mjs

@@ -27,7 +27,7 @@ export async function renderHTML(ansiPath, htmlPath, options = {}) {
 		plain,
 		options: {
 			label: options.label ?? "platform-smoke",
-			model: options.model ?? "cursor/composer-2-5",
+			model: options.model ?? "cursor/grok-4.6",
 			mode: options.mode ?? "agent",
 			cwd: options.cwd ?? process.cwd(),
 			sessionId: options.sessionId ?? "platform-smoke",

package/scripts/platform-smoke/scenarios.mjs

@@ -108,7 +108,7 @@ NATIVE_MATRIX_OK package=<name> grep=<yes/no> find=<yes/no> list=<yes/no> shell=
 			PI_CURSOR_EXPOSE_BUILTIN_TOOLS: "0",
 			PI_CURSOR_SDK_EVENT_DEBUG: "1",
 		},
-		promptTemplate: "Reply exactly HTTP1_LIVE_OK.",
+		promptTemplate: "Join HTTP1, LIVE, and OK with underscores and reply with only the result.",
 		finalMarker: "HTTP1_LIVE_OK",
 		requiredCards: ["http1-status"],
 	},

package/scripts/platform-smoke/targets.mjs

@@ -413,7 +413,7 @@ export function buildPlatformBuildCommand(targetName, packageName = "pi-cursor-s
 		lines.push(...posixSection("CHECK_PLATFORM_SMOKE_STDERR", 'cat "$PACK_DIR/check-platform-smoke.stderr.txt" 2>/dev/null || true'));
 		lines.push("");
 		lines.push('echo "=== npm test ==="');
-		lines.push('npm test >"$PACK_DIR/npm-test.stdout.txt" 2>"$PACK_DIR/npm-test.stderr.txt"');
+		lines.push('npm test -- --testTimeout=15000 >"$PACK_DIR/npm-test.stdout.txt" 2>"$PACK_DIR/npm-test.stderr.txt"');
 		lines.push("TEST_EXIT=$?");
 		lines.push('echo "PLATFORM_NPM_TEST_EXIT=$TEST_EXIT"');
 		lines.push(...posixSection("NPM_TEST_STDOUT", 'cat "$PACK_DIR/npm-test.stdout.txt" 2>/dev/null || true'));
@@ -662,7 +662,7 @@ async function executeLiveSuite(config, targetName, suiteName, suiteDir, slug, l
 }
 
 function buildLiveSuiteCommand(config, targetName, suiteName, prepDir) {
-	const model = config.cursorModel ?? "cursor/composer-2-5";
+	const model = config.cursorModel ?? "cursor/grok-4.6";
 	const packageName = config.packageName ?? "pi-cursor-sdk";
 	const prepArgs = prepDir ? ` --prep-dir ${platformFor(targetName) === "powershell" ? prepDir : shellQuote(prepDir)}` : "";
 	if (platformFor(targetName) === "powershell") {

package/scripts/platform-smoke.mjs

@@ -28,7 +28,7 @@ function printHelp() {
 
 Commands:
   doctor                     Run all preflight checks (no Cursor tokens)
-  run --target <names>       Run one or more comma-separated targets concurrently
+  run --target <names>       Run one or more comma-separated targets sequentially
   run --suite <name>         Run one suite on all or specified targets
   run --target <n> --suite <n>
 
@@ -242,14 +242,14 @@ async function main() {
 		}
 
 		const startedAt = new Date().toISOString();
-		const targetRuns = targets.map(async (targetName) => {
+		const results = [];
+		for (const targetName of targets) {
 			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);
+			results.push({ targetName, result });
+		}
 		const finishedAt = new Date().toISOString();
 		const latest = writeLatestPlatformSmokeIndex(config, results, {
 			startedAt,

package/scripts/prepare.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Purpose: Build generated dist output for GitHub/source installs even when Pi invokes npm install --omit=dev.
+ * Responsibilities: Detect missing source-build dependencies via the local node_modules tree, install dev
+ * dependencies with lifecycle scripts disabled, run the canonical build, then prune the dev tree so installs
+ * keep a runtime-only footprint.
+ * Scope: Package install lifecycle only; runtime behavior remains owned by scripts/build.mjs.
+ * Usage: package.json prepare script.
+ */
+
+import { execFile as execFileCallback } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCallback);
+
+// Checked as literal node_modules paths: require.resolve() is unusable here because
+// several @earendil-works packages expose import-only "exports" maps and throw
+// ERR_PACKAGE_PATH_NOT_EXPORTED even when installed.
+const REQUIRED_SOURCE_BUILD_MODULES = [
+	"typescript",
+	"typebox",
+	"@earendil-works/pi-ai",
+	"@earendil-works/pi-coding-agent",
+	"@earendil-works/pi-tui",
+];
+
+function hasBuildDependencies() {
+	return REQUIRED_SOURCE_BUILD_MODULES.every((moduleName) =>
+		existsSync(join(process.cwd(), "node_modules", ...moduleName.split("/"), "package.json")),
+	);
+}
+
+async function runNpm(args) {
+	const npmExecPath = process.env.npm_execpath;
+	if (!npmExecPath) {
+		throw new Error(
+			`npm_execpath is not set; run "npm ${args.join(" ")}" manually in ${process.cwd()} and retry.`,
+		);
+	}
+	// No shell: process.execPath runs npm's cli.js directly, which is safe for paths
+	// containing spaces on every platform (shell:true concatenates args unescaped).
+	await execFile(process.execPath, [npmExecPath, ...args], {
+		cwd: process.cwd(),
+		maxBuffer: 20 * 1024 * 1024,
+	});
+}
+
+async function runBuild() {
+	const { stderr, stdout } = await execFile(process.execPath, [join(process.cwd(), "scripts", "build.mjs")], {
+		cwd: process.cwd(),
+		maxBuffer: 20 * 1024 * 1024,
+	});
+	// Forward build output on success too: install-time diagnostics such as the
+	// concurrent-swap race-loss warning are otherwise swallowed.
+	if (stdout) process.stdout.write(stdout);
+	if (stderr) process.stderr.write(stderr);
+}
+
+async function pruneDevDependencies() {
+	await runNpm(["prune", "--omit=dev", "--ignore-scripts"]);
+}
+
+async function pruneQuietly() {
+	try {
+		await pruneDevDependencies();
+	} catch (error) {
+		console.warn(`npm prune failed after a failed build: ${error?.message ?? error}`);
+	}
+}
+
+function reportError(error) {
+	if (error?.stdout) process.stdout.write(error.stdout);
+	if (error?.stderr) process.stderr.write(error.stderr);
+	console.error(error instanceof Error ? error.message : String(error));
+}
+
+async function main() {
+	if (hasBuildDependencies()) {
+		await runBuild();
+		return;
+	}
+	await runNpm(["install", "--include=dev", "--ignore-scripts"]);
+	try {
+		await runBuild();
+	} catch (buildError) {
+		// Report the build first; cleanup can warn afterward but never mask it.
+		reportError(buildError);
+		await pruneQuietly();
+		process.exitCode = 1;
+		return;
+	}
+	// A prune failure after a successful build still fails the install.
+	await pruneDevDependencies();
+}
+
+main().catch((error) => {
+	reportError(error);
+	process.exitCode = 1;
+});