@uinaf/skillcheck 0.5.4 → 1.0.1

package/dist/cli.js

@@ -60,7 +60,7 @@ function stateDirs(root) {
 }
 function runOptions(flags) {
 	const harness = flags.get("--harness") ?? "claude";
-	if (harness !== "claude" && harness !== "codex" && harness !== "cursor") fail(`--harness must be claude, codex, or cursor, got ${harness}`);
+	if (harness !== "claude" && harness !== "codex" && harness !== "grok") fail(`--harness must be claude, codex, or grok, got ${harness}`);
 	if (flags.has("--max-turns") && harness !== "claude") fail("--max-turns is only supported with --harness claude");
 	const agent = flags.get("--agent");
 	const judgeModel = flags.get("--judge") ?? "claude-opus-5";
@@ -137,7 +137,7 @@ function runScenario(scenarioDir, opts, root) {
 	const { name, configPath } = generateRun(path.resolve(scenarioDir), opts, {
 		scratchDir: dirs.scratch,
 		transformPath: path.join(here, `transform${selfExt}`),
-		cursorProviderPath: path.join(here, `cursor-provider${selfExt}`)
+		grokProviderPath: path.join(here, `grok-provider${selfExt}`)
 	});
 	fs.mkdirSync(dirs.results, { recursive: true });
 	const resultPath = path.join(dirs.results, `${name}.json`);
@@ -212,7 +212,7 @@ function discoverScenarios(root) {
 }
 function cmdRun(argv) {
 	const { positional, flags } = parseArgs(argv);
-	if (positional.length !== 1) fail("usage: skillcheck run <scenario-dir> [--root DIR] [--agent MODEL] [--judge MODEL] [--judge-effort EFFORT] [--harness claude|codex|cursor]");
+	if (positional.length !== 1) fail("usage: skillcheck run <scenario-dir> [--root DIR] [--agent MODEL] [--judge MODEL] [--judge-effort EFFORT] [--harness claude|codex|grok]");
 	const opts = runOptions(flags);
 	ensureEvalPackages(opts);
 	const o = runScenario(positional[0], opts, resolveRoot(flags));
@@ -235,7 +235,7 @@ function cmdSweep(argv) {
 	for (const dir of discoverScenarios(root)) {
 		const name = runNameFor(dir, opts.harness);
 		const resultPath = path.join(resultsDir, `${name}.json`);
-		if (!all && fs.existsSync(resultPath)) {
+		if (!all && fs.existsSync(resultPath) && !fs.existsSync(attemptPath(resultPath))) {
 			skipped++;
 			console.log(`SKIP  ${name} (results exist; use --all to rerun)`);
 			continue;
@@ -256,13 +256,21 @@ function cmdSweep(argv) {
 	process.exit(errored > 0 ? 2 : failed > 0 ? 1 : 0);
 }
 function resultIdentity(file) {
+	const decode = (part) => {
+		if (!part.startsWith("~v2~")) return part;
+		try {
+			return decodeURIComponent(part.slice(4));
+		} catch {
+			return part;
+		}
+	};
 	const base = file.replace(/\.json$/, "");
-	const suffix = base.match(/--(codex|cursor)$/);
+	const suffix = base.match(/--(codex|grok|cursor)$/);
 	const harness = suffix === null ? "claude" : suffix[1];
-	const [skill, ...rest] = base.replace(/--(codex|cursor)$/, "").split("--");
+	const [skill, ...rest] = base.replace(/--(codex|grok|cursor)$/, "").split("--");
 	return {
-		skill,
-		scenario: rest.join("--"),
+		skill: decode(skill),
+		scenario: decode(rest.join("--")),
 		harness
 	};
 }
@@ -274,6 +282,11 @@ function reduceResults(dir, allowMixed) {
 	const incomplete = new Set(files.filter((f) => f.endsWith(".json.attempt")).map((f) => f.replace(/\.attempt$/, "")));
 	const results = files.filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json"));
 	for (const f of [.../* @__PURE__ */ new Set([...results, ...incomplete])].sort()) {
+		if (f.endsWith("--cursor.json")) {
+			console.error(`skipping ${f}: Cursor harness is retired`);
+			skipped.push(f);
+			continue;
+		}
 		if (incomplete.has(f)) {
 			console.error(`skipping ${f}: attempt did not complete with a graded result`);
 			skipped.push(f);

package/dist/grok-provider.js

@@ -0,0 +1,144 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+//#region src/grok-provider.ts
+const OUTPUT_CAP = 1e6;
+function within(root, file) {
+	const rel = path.relative(root, file);
+	return rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+var GrokProvider = class {
+	config;
+	constructor(options) {
+		if (!options.config?.working_dir || !options.config.skill) throw new Error("grok provider requires working_dir and skill");
+		this.config = options.config;
+	}
+	id() {
+		return "grok:cli";
+	}
+	async callApi(prompt, _context, callOptions) {
+		const { working_dir: workdir, skill, model, command = "grok", timeout_ms = 6e5 } = this.config;
+		const skillFile = path.join(workdir, ".grok", "skills", skill, "SKILL.md");
+		const args = [
+			"--trust",
+			"--no-auto-update",
+			"--cwd",
+			workdir,
+			"--output-format",
+			"streaming-json",
+			"--permission-mode",
+			"acceptEdits",
+			"--disable-web-search",
+			"--no-subagents",
+			...model ? ["--model", model] : [],
+			"-p",
+			prompt
+		];
+		return new Promise((resolve) => {
+			const child = spawn(command, args, {
+				cwd: workdir,
+				detached: process.platform !== "win32",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			let stdout = "";
+			let stderr = "";
+			let output = "";
+			let stopReason;
+			let usage;
+			let cost;
+			let error;
+			const reads = /* @__PURE__ */ new Map();
+			const skillCalls = [];
+			const stop = (reason) => {
+				error ??= reason;
+				if (child.pid !== void 0) try {
+					if (process.platform === "win32") child.kill();
+					else process.kill(-child.pid, "SIGKILL");
+				} catch {}
+			};
+			const consume = (line) => {
+				if (!line.trim()) return;
+				let event;
+				try {
+					event = JSON.parse(line);
+				} catch {
+					stop("grok emitted invalid streaming JSON");
+					return;
+				}
+				if (event.type === "text" && typeof event.data === "string") {
+					output += event.data;
+					if (output.length > OUTPUT_CAP) stop("grok output exceeded limit");
+				} else if (event.type === "tool_call" && event.toolName === "read_file") {
+					const target = event.rawInput?.target_file;
+					if (event.toolCallId && typeof target === "string") {
+						const resolved = path.resolve(workdir, target);
+						if (within(workdir, resolved)) reads.set(event.toolCallId, resolved);
+					}
+				} else if (event.type === "tool_call_update" && event.status === "completed") {
+					const target = event.toolCallId && reads.get(event.toolCallId);
+					if (target === skillFile && !skillCalls.some((call) => call.path === target)) skillCalls.push({
+						name: skill,
+						source: "project",
+						path: target
+					});
+				} else if (event.type === "end") {
+					stopReason = event.stopReason;
+					usage = event.usage;
+					cost = event.total_cost_usd;
+				}
+			};
+			child.stdout?.on("data", (chunk) => {
+				stdout += chunk.toString("utf8");
+				if (stdout.length > OUTPUT_CAP) {
+					stop("grok event stream exceeded limit");
+					return;
+				}
+				let newline = stdout.indexOf("\n");
+				while (newline !== -1) {
+					consume(stdout.slice(0, newline));
+					stdout = stdout.slice(newline + 1);
+					newline = stdout.indexOf("\n");
+				}
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr = (stderr + chunk.toString("utf8")).slice(-4e3);
+			});
+			child.on("error", (cause) => {
+				error ??= `grok could not start: ${cause.message}`;
+			});
+			const timer = setTimeout(() => stop(`grok timed out after ${timeout_ms}ms`), timeout_ms);
+			const abort = () => stop("grok run aborted");
+			callOptions?.abortSignal?.addEventListener("abort", abort, { once: true });
+			if (callOptions?.abortSignal?.aborted) abort();
+			child.on("exit", () => {
+				if (process.platform !== "win32" && child.pid !== void 0) try {
+					process.kill(-child.pid, "SIGKILL");
+				} catch {}
+			});
+			child.on("close", (code, signal) => {
+				clearTimeout(timer);
+				callOptions?.abortSignal?.removeEventListener("abort", abort);
+				if (stdout) consume(stdout);
+				if (error) resolve({ error });
+				else if (code !== 0) resolve({ error: `grok exited ${signal ?? code}: ${stderr.trim() || "no diagnostics"}` });
+				else if (stopReason !== "end_turn") resolve({ error: `grok stopped with ${stopReason ?? "no terminal event"}` });
+				else resolve({
+					output,
+					metadata: { skillCalls },
+					...usage ? { tokenUsage: {
+						prompt: usage.input_tokens ?? 0,
+						completion: usage.output_tokens ?? 0,
+						total: usage.total_tokens ?? 0,
+						cached: usage.cache_read_input_tokens ?? 0
+					} } : {},
+					...typeof cost === "number" ? { cost } : {}
+				});
+			});
+		});
+	}
+};
+//#endregion
+export { GrokProvider as default };

package/dist/scenario.js

@@ -32,10 +32,15 @@ function loadScenario(scenarioDir) {
 		criteria
 	};
 }
+function encodeRunNamePart(part) {
+	if (!part.includes("--") && !part.startsWith("-") && !part.endsWith("-") && !part.startsWith("~v2~")) return part;
+	return `~v2~${encodeURIComponent(part).replaceAll("-", "%2D").replaceAll("~", "%7E")}`;
+}
 function runNameFor(scenarioDir, harness) {
 	const m = path.resolve(scenarioDir).match(/skills\/([^/]+)\/evals\/([^/]+)$/);
 	if (!m) throw new Error(`not a scenario dir (want .../skills/<skill>/evals/<scenario>): ${scenarioDir}`);
-	return harness === "claude" ? `${m[1]}--${m[2]}` : `${m[1]}--${m[2]}--${harness}`;
+	const name = `${encodeRunNamePart(m[1])}--${encodeRunNamePart(m[2])}`;
+	return harness === "claude" ? name : `${name}--${harness}`;
 }
 function frontmatterRange(text) {
 	const lines = text.split("\n");
@@ -56,7 +61,8 @@ function stripHiddenFlag(skillMd) {
 const RESERVED = /* @__PURE__ */ new Set([
 	".claude",
 	".agents",
-	".cursor"
+	".grok",
+	"node_modules"
 ]);
 function materialize(s, runDir, harness) {
 	const workdir = path.join(runDir, "workdir");
@@ -82,7 +88,7 @@ function materialize(s, runDir, harness) {
 		fs.mkdirSync(path.dirname(dest), { recursive: true });
 		fs.writeFileSync(dest, content);
 	}
-	const roots = harness === "codex" ? [".claude", ".agents"] : harness === "cursor" ? [".cursor"] : [".claude"];
+	const roots = harness === "codex" ? [".claude", ".agents"] : harness === "grok" ? [".grok"] : [".claude"];
 	for (const root of roots) fs.cpSync(s.skillDir, path.join(workdir, root, "skills", s.skill), {
 		recursive: true,
 		filter: (src) => path.basename(src) !== "evals"
@@ -98,7 +104,7 @@ function materialize(s, runDir, harness) {
 		for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
 			const p = path.join(dir, e.name);
 			if (e.isDirectory()) {
-				if (e.name !== ".claude") walk(p);
+				if (e.name !== ".claude" && e.name !== ".grok" && e.name !== "node_modules") walk(p);
 			} else manifest[path.relative(workdir, p)] = createHash("sha256").update(fs.readFileSync(p)).digest("hex");
 		}
 	};
@@ -111,11 +117,12 @@ function materialize(s, runDir, harness) {
 	};
 }
 function agentProvider(opts, workdir, skill, paths) {
-	if (opts.harness === "cursor") return {
-		id: `file://${paths.cursorProviderPath}`,
+	if (opts.harness === "grok") return {
+		id: `file://${paths.grokProviderPath}`,
 		config: {
-			...opts.agentModel ? { model: opts.agentModel } : {},
-			working_dir: workdir
+			working_dir: workdir,
+			skill,
+			...opts.agentModel ? { model: opts.agentModel } : {}
 		}
 	};
 	if (opts.harness === "codex") return {
@@ -256,4 +263,4 @@ function generateRun(scenarioDir, opts, paths) {
 	};
 }
 //#endregion
-export { buildConfig, generateRun, isHiddenSkill, loadScenario, materialize, requiredEvalPackages, resolvePackageDir, runNameFor, sdkNodeModulesDir, stripHiddenFlag };
+export { buildConfig, encodeRunNamePart, generateRun, isHiddenSkill, loadScenario, materialize, requiredEvalPackages, resolvePackageDir, runNameFor, sdkNodeModulesDir, stripHiddenFlag };

package/dist/transform.js

@@ -23,7 +23,7 @@ function transform(output, context) {
 		for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
 			const p = path.join(dir, e.name);
 			if (e.isDirectory()) {
-				if (e.name !== ".claude") walk(p);
+				if (e.name !== ".claude" && e.name !== ".grok" && e.name !== "node_modules") walk(p);
 			} else if (e.isFile()) {
 				const rel = path.relative(workdir, p);
 				visited.add(rel);

package/docs/scenarios.md

@@ -8,8 +8,10 @@ A scenario is two files in a frozen location:
 ```
 
 The path is the identity: `<skill>--<scenario>` names the run, the result file,
-and the scorecard entry. On the codex and cursor harnesses the name gains a
-`--codex` or `--cursor` suffix, so every harness can hold results side by side.
+and the scorecard entry. Codex and Grok results gain `--codex` and `--grok`
+suffixes, so harnesses can hold results side by side. Double hyphens and
+leading or trailing hyphens in a skill or scenario name are escaped in the run
+and result filename; the scorecard keeps the original name.
 A directory missing either file is not discovered.
 
 ## task.md
@@ -28,8 +30,8 @@ Fix the failing check in the config below.
 Each block is replaced in the prompt with a pointer ("Input file `config.json`
 is available in your working directory.") and written to disk. Destinations
 must stay under the workdir, must not collide, and must not target `.claude/`,
-`.agents/`, or `.cursor/`, since a fixture that writes agent config would be
-configuring its own examiner.
+`.agents/`, `.grok/`, or `node_modules/`, since a fixture must not configure its
+own examiner or embed generated dependencies.
 
 Write the task the way a user would write it. Do not name the skill, describe
 its steps, or hint at the checklist: routing is part of what is being measured.
@@ -83,8 +85,8 @@ frontmatter block; body text mentioning the key does not count.
 Per run, under `<root>/.skillcheck/scratch/<name>/`, rebuilt from scratch each
 time. The skill under test is installed where the harness discovers skills:
 `.claude/skills/<skill>/`, plus `.agents/skills/<skill>/` on codex, or
-`.cursor/skills/<skill>/` alone on cursor, with its `evals/` directory
-excluded, so criteria never leak into the agent's context.
+`.grok/skills/<skill>/` on Grok, with its `evals/` directory excluded, so
+criteria never leak into the agent's context.
 
 Scenario quality is behavioral proof; [authoring](authoring.md) covers the
 judgment layer lint and evals cannot grade.

package/docs/usage.md

@@ -34,6 +34,7 @@ clean, 1 with findings.
 skillcheck run skills/<skill>/evals/<scenario>
 skillcheck run <scenario-dir> --agent MODEL --judge MODEL --harness codex
 skillcheck run <scenario-dir> --harness claude --max-turns 80
+skillcheck run <scenario-dir> --harness grok
 ```
 
 Materializes the scenario into `<root>/.skillcheck/scratch/<name>/workdir`,
@@ -49,22 +50,15 @@ message, and writes no provenance sidecar. It is never reported as
 
 Defaults: `--harness claude`, agent `claude-opus-5`, judge `claude-opus-5`,
 and a Claude agent limit of 50 turns. `--max-turns` changes that limit only for
-Claude; passing it with `codex` or `cursor` fails before the eval starts. On
+Claude; passing it with `codex` or `grok` fails before the eval starts. On
 those harnesses, omitting `--agent` leaves the model to that CLI's own default.
 
-`--harness cursor` drives the scenario through the Cursor Agent CLI
-(`cursor-agent` on PATH) with the skill installed under `.cursor/skills/`;
-`--agent` names a Cursor model id, e.g. `composer-2.5`. There is no promptfoo
-cursor provider, so the run uses this package's own provider module, which
-replays the CLI's `stream-json` output: the `result` event becomes the graded
-output and `SKILL.md` reads under `.cursor/skills/` become the `skill-used`
-evidence. Grading requires both a successful result event and harness exit code
-zero. On macOS and Linux, a supervisor owns the process group and kills remaining
-helpers when the harness exits, times out, or the provider disconnects. Output
-pipes have a separate two-second cleanup/drain deadline; incomplete cleanup is
-an error. Helpers that detach into another process group are outside this cleanup
-boundary; retained output pipes still cause a bounded error. Windows retains
-only direct-child cleanup. The judge leg is unchanged.
+`--harness grok` runs the locally installed Grok Build CLI in the disposable
+workdir with the skill under `.grok/skills/`. It uses native streaming events
+to count a completed read of that skill's `SKILL.md` as `skill-used` evidence.
+Grok must be logged in locally or have its supported credentials configured.
+The run disables web search and subagents and grants edit permission in the
+workdir. `--agent` selects a Grok model ID.
 
 `--judge` takes either a bare Claude model (graded through the Anthropic
 selection in [auth](#auth)) or a provider-qualified promptfoo id, passed
@@ -83,7 +77,7 @@ provider-qualified judge; the Anthropic judge does not take one.
 ## Sweep
 
 ```sh
-skillcheck sweep           # only scenarios without results
+skillcheck sweep           # scenarios without completed results
 skillcheck sweep --all     # rerun everything
 ```
 
@@ -97,8 +91,8 @@ within one scenario, not across them.
 One known failure mode: judge calls through a gateway can drop at the transport
 layer ([uinaf/zebroid-infra#44](https://github.com/uinaf/zebroid-infra/issues/44)).
 That surfaces as an ERROR with no usable result, not as a graded FAIL, and the
-mitigation is a rerun. `sweep` without `--all` resumes, so a rerun only picks up
-what is missing.
+mitigation is a rerun. `sweep` without `--all` resumes, so a rerun picks up
+missing or ungraded results.
 
 ## Summarize
 
@@ -122,6 +116,8 @@ with a warning rather than failing the reduction. Graded assertion failures
 remain scored results. If a skipped file matches an existing scorecard row,
 summary generation fails and leaves the scorecard unchanged, so an errored rerun
 cannot carry forward its old score. This also applies with `--allow-mixed`.
+Results from the retired Cursor harness are skipped with their original identity,
+so they cannot become Claude scores or silently carry an old Cursor row.
 Runs keep a `<name>.json.attempt` marker until a graded result and its provenance
 are written. An outstanding marker makes `summarize` skip that identity even
 when the child produced no result file or left partial output. The marker does
@@ -162,7 +158,6 @@ written inside the installed package.
 | `ANTHROPIC_API_KEY`                           | Judge grades over `anthropic:messages:<model>` instead of the SDK |
 | `CODEX_HOME` (default `~/.codex`)             | Where the codex harness finds the local `codex` CLI login         |
 | `OPENAI_API_KEY`                              | Agent auth for codex when there is no local login                 |
-| `CURSOR_API_KEY`                              | Agent auth for cursor; a logged-in `cursor-agent` also works      |
 | `OPENAI_API_KEY` + `OPENAI_BASE_URL`          | A provider-qualified `--judge openai:…`, optionally via a gateway |
 
 A bare `--judge` model stays on the Anthropic selection regardless of the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uinaf/skillcheck",
-  "version": "0.5.4",
+  "version": "1.0.1",
   "description": "Lint and eval harness for agent skills",
   "homepage": "https://github.com/uinaf/skillcheck#readme",
   "bugs": {

package/dist/cursor-process.js

@@ -1,71 +0,0 @@
-import { spawn } from "node:child_process";
-//#region src/cursor-process.ts
-let child;
-let terminal = false;
-let cleaning = false;
-let watchdog = setTimeout(cleanup, 5e3);
-function cleanup() {
-	if (cleaning) return;
-	cleaning = true;
-	clearTimeout(watchdog);
-	if (process.platform !== "win32") process.kill(-process.pid, "SIGKILL");
-	child?.kill("SIGKILL");
-	process.exit(1);
-}
-function fail(error) {
-	if (terminal) return;
-	terminal = true;
-	process.send?.({
-		type: "failure",
-		error
-	}, cleanup);
-	clearTimeout(watchdog);
-	watchdog = setTimeout(cleanup, 1e3);
-}
-if (!process.send) process.exit(1);
-process.on("disconnect", cleanup);
-process.on("message", (message) => {
-	if (message === "stop") return cleanup();
-	if (message === "cleanup" && terminal) {
-		process.send?.({ type: "cleanup" }, cleanup);
-		return;
-	}
-	if (child !== void 0 || terminal) return;
-	if (typeof message !== "object" || message === null || !("command" in message) || typeof message.command !== "string" || !("cwd" in message) || typeof message.cwd !== "string" || !("args" in message) || !Array.isArray(message.args) || !message.args.every((arg) => typeof arg === "string") || !("timeoutMs" in message) || typeof message.timeoutMs !== "number" || !Number.isFinite(message.timeoutMs) || message.timeoutMs <= 0) return fail("cursor-agent supervisor received invalid configuration");
-	clearTimeout(watchdog);
-	watchdog = setTimeout(() => fail("cursor-agent supervisor watchdog timed out"), message.timeoutMs + 1e3);
-	const command = message.command;
-	try {
-		child = spawn(command, message.args, {
-			cwd: message.cwd,
-			stdio: [
-				"pipe",
-				"inherit",
-				"inherit"
-			]
-		});
-	} catch (error) {
-		return fail(`failed to spawn ${command}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	child.on("error", (error) => fail(`failed to spawn ${command}: ${error.message}`));
-	child.stdin?.on("error", (error) => fail(`cursor-agent stdin failed: ${error.message}`));
-	process.stdin.on("error", (error) => fail(`cursor-agent prompt stream failed: ${error.message}`));
-	if (child.stdin) process.stdin.pipe(child.stdin);
-	child.on("exit", (code, signal) => {
-		if (terminal) return;
-		if (!child?.stdin?.writableFinished) return fail("cursor-agent stdin closed before prompt delivery");
-		terminal = true;
-		process.stdin.unpipe();
-		clearTimeout(watchdog);
-		watchdog = setTimeout(cleanup, 1e3);
-		process.send?.({
-			type: "terminal",
-			code,
-			signal
-		}, (error) => {
-			if (error) cleanup();
-		});
-	});
-});
-//#endregion
-export {};

package/dist/cursor-provider.js

@@ -1,181 +0,0 @@
-import { fork } from "node:child_process";
-import path from "node:path";
-//#region src/cursor-provider.ts
-function newStreamState() {
-	return {
-		isError: false,
-		skillCalls: []
-	};
-}
-const SKILL_MD = /(?:^|\/)\.cursor\/skills\/([^/]+)\/SKILL\.md$/;
-function foldLine(state, line) {
-	let event;
-	try {
-		event = JSON.parse(line);
-	} catch {
-		return;
-	}
-	if (typeof event !== "object" || event === null) return;
-	const e = event;
-	if (e.type === "tool_call" && e.subtype === "started") {
-		const p = e.tool_call?.readToolCall?.args?.path;
-		const m = typeof p === "string" ? SKILL_MD.exec(p) : null;
-		if (m) state.skillCalls.push({
-			name: m[1],
-			source: "project",
-			path: p
-		});
-		return;
-	}
-	if (e.type === "result") {
-		state.isError = e.is_error === true || e.subtype !== "success";
-		state.result = typeof e.result === "string" ? e.result : "";
-		if (e.usage) {
-			const prompt = e.usage.inputTokens ?? 0;
-			const completion = e.usage.outputTokens ?? 0;
-			state.tokenUsage = {
-				prompt,
-				completion,
-				cached: e.usage.cacheReadTokens ?? 0,
-				total: prompt + completion
-			};
-		}
-	}
-}
-var CursorAgentProvider = class {
-	providerId;
-	config;
-	constructor(options) {
-		this.providerId = options.id ?? "cursor-agent";
-		if (options.config?.working_dir === void 0) throw new Error("cursor-agent provider requires config.working_dir");
-		this.config = options.config;
-	}
-	id() {
-		return this.providerId;
-	}
-	async callApi(prompt) {
-		const command = this.config.command ?? "cursor-agent";
-		const args = [
-			"-p",
-			"--trust",
-			"--output-format",
-			"stream-json"
-		];
-		if (this.config.model !== void 0) args.push("--model", this.config.model);
-		const state = newStreamState();
-		const stderr = [];
-		let stdoutBuf = "";
-		return new Promise((resolve) => {
-			const timeoutMs = this.config.timeout_ms ?? 9e5;
-			const supervisor = fork(new URL(`./cursor-process${path.extname(import.meta.url)}`, import.meta.url), {
-				execArgv: [],
-				detached: process.platform !== "win32",
-				stdio: [
-					"pipe",
-					"pipe",
-					"pipe",
-					"ipc"
-				]
-			});
-			let failure;
-			let terminal;
-			let cleanupConfirmed = false;
-			let settled = false;
-			let cleanupTimer;
-			const finish = (closed, signal = null) => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timer);
-				clearTimeout(cleanupTimer);
-				supervisor.stdin?.destroy();
-				supervisor.stdout?.destroy();
-				supervisor.stderr?.destroy();
-				if (!closed) {
-					supervisor.kill("SIGKILL");
-					supervisor.unref();
-					if (supervisor.connected) supervisor.disconnect();
-				}
-				if (stdoutBuf !== "") foldLine(state, stdoutBuf);
-				const metadata = { skillCalls: state.skillCalls };
-				const fail = (error) => resolve({
-					error,
-					tokenUsage: state.tokenUsage,
-					metadata
-				});
-				if (failure !== void 0) {
-					const tail = stderr.join("").trim().slice(-2e3);
-					const missingResult = terminal !== void 0 && state.result === void 0 ? " without a result event" : "";
-					return fail(`${failure}${missingResult}${tail === "" ? "" : `: ${tail}`}`);
-				}
-				if (!closed || !cleanupConfirmed || terminal === void 0 || process.platform !== "win32" && signal !== "SIGKILL") return fail("cursor-agent supervisor ended without confirmed cleanup");
-				if (terminal.code !== 0 || terminal.signal !== null || state.result === void 0) {
-					const tail = stderr.join("").trim().slice(-2e3);
-					return fail(`cursor-agent exited ${terminal.signal ?? terminal.code ?? "without status"}${state.result === void 0 ? " without a result event" : ""}${tail === "" ? "" : `: ${tail}`}`);
-				}
-				if (state.isError) return fail(state.result || "cursor-agent reported an error result");
-				resolve({
-					output: state.result,
-					tokenUsage: state.tokenUsage,
-					metadata
-				});
-			};
-			const boundCleanup = () => {
-				cleanupTimer ??= setTimeout(() => {
-					failure = failure === void 0 ? "cursor-agent cleanup or pipe draining timed out" : `${failure}; cleanup or pipe draining timed out`;
-					finish(false);
-				}, 2e3);
-			};
-			const stop = (error) => {
-				if (settled) return;
-				failure ??= error;
-				boundCleanup();
-				if (supervisor.connected) supervisor.send("stop", () => {});
-			};
-			const timer = setTimeout(() => stop(`cursor-agent timed out after ${timeoutMs}ms`), timeoutMs);
-			supervisor.on("error", (err) => stop(`cursor-agent supervisor failed: ${err.message}`));
-			supervisor.on("disconnect", () => {
-				if (!cleanupConfirmed && !settled) stop("cursor-agent supervisor disconnected before cleanup");
-			});
-			supervisor.on("message", (message) => {
-				if (settled) return;
-				if (typeof message !== "object" || message === null) return;
-				if (!("type" in message)) return;
-				if (message.type === "terminal" && "code" in message && "signal" in message && (message.code === null || typeof message.code === "number") && (message.signal === null || typeof message.signal === "string")) {
-					terminal = {
-						code: message.code,
-						signal: message.signal
-					};
-					clearTimeout(timer);
-					if (terminal.code !== 0 || terminal.signal !== null) failure ??= `cursor-agent exited ${terminal.signal ?? terminal.code ?? "without status"}`;
-					boundCleanup();
-					supervisor.send("cleanup", (err) => {
-						if (err) stop(`cursor-agent cleanup request failed: ${err.message}`);
-					});
-				} else if (message.type === "failure" && "error" in message && typeof message.error === "string") stop(message.error);
-				else if (message.type === "cleanup" && terminal !== void 0) cleanupConfirmed = true;
-			});
-			supervisor.stdout?.on("data", (chunk) => {
-				stdoutBuf += chunk.toString("utf8");
-				const lines = stdoutBuf.split("\n");
-				stdoutBuf = lines.pop() ?? "";
-				for (const line of lines) foldLine(state, line);
-			});
-			supervisor.stderr?.on("data", (chunk) => stderr.push(chunk.toString("utf8")));
-			supervisor.stdout?.on("error", (err) => stop(`cursor-agent stdout failed: ${err.message}`));
-			supervisor.stderr?.on("error", (err) => stop(`cursor-agent stderr failed: ${err.message}`));
-			supervisor.stdin?.on("error", (err) => stop(`cursor-agent stdin failed: ${err.message}`));
-			supervisor.on("close", (_code, signal) => finish(true, signal));
-			supervisor.send({
-				command,
-				args,
-				cwd: this.config.working_dir,
-				timeoutMs
-			}, (err) => {
-				if (err) stop(`cursor-agent supervisor initialization failed: ${err.message}`);
-			});
-			supervisor.stdin?.end(prompt);
-		});
-	}
-};
-//#endregion
-export { CursorAgentProvider as default, foldLine, newStreamState };