@cydm/pie 1.0.6 → 1.0.7

package/dist/builtin/skills/pie-unity-rpc/pie-unity-rpc.js

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const REGISTRY_FILE = path.join(homedir(), ".pie-unity", "registry.json");
+const DEFAULT_WAIT_MS = 600;
+const DEFAULT_RETRIES = 30;
+const ACTIVE_INSTANCE_MAX_AGE_SEC = 120;
+
+class InstanceSelectionError extends Error {
+	constructor(code, message, details = {}) {
+		super(message);
+		this.name = "InstanceSelectionError";
+		this.code = code;
+		this.details = details;
+	}
+}
+
+export function parseArgs(argv) {
+	const args = argv.slice(2);
+	const command = args[0] || "instances";
+	const flags = {};
+	for (let i = 1; i < args.length; i += 1) {
+		const item = args[i];
+		if (!item.startsWith("--")) continue;
+		const key = item.slice(2);
+		const next = args[i + 1];
+		if (!next || next.startsWith("--")) {
+			flags[key] = "true";
+			continue;
+		}
+		flags[key] = next;
+		i += 1;
+	}
+	return { command, flags };
+}
+
+export function loadRegistry(filePath = REGISTRY_FILE) {
+	if (!existsSync(filePath)) {
+		return [];
+	}
+	try {
+		const raw = readFileSync(filePath, "utf8").replace(/^\uFEFF/, "");
+		const json = JSON.parse(raw);
+		const items = Array.isArray(json?.instances) ? json.instances : [];
+		return dedupeInstances(items.filter(Boolean));
+	} catch {
+		return [];
+	}
+}
+
+export function getActiveInstances(instances, nowUnix = Math.floor(Date.now() / 1000)) {
+	const recent = instances.filter((item) => {
+		const lastSeenUnix = Number(item?.lastSeenUnix || 0);
+		return lastSeenUnix > 0 && nowUnix - lastSeenUnix <= ACTIVE_INSTANCE_MAX_AGE_SEC;
+	});
+	return recent.length > 0 ? recent : instances;
+}
+
+function basenameMatch(left, right) {
+	return path.basename(left || "") !== ""
+		&& path.basename(left || "") === path.basename(right || "");
+}
+
+function computeProjectMatchScore(requestedProject, candidateProject) {
+	const requested = normalizePath(requestedProject || "");
+	const candidate = normalizePath(candidateProject || "");
+	if (!requested || !candidate) return 0;
+	if (requested === candidate) return 1000;
+	if (basenameMatch(requested, candidate)) return 700;
+
+	const requestedWithSlash = requested.endsWith("/") ? requested : `${requested}/`;
+	const candidateWithSlash = candidate.endsWith("/") ? candidate : `${candidate}/`;
+	if (requestedWithSlash.startsWith(candidateWithSlash) || candidateWithSlash.startsWith(requestedWithSlash)) {
+		const distance = Math.abs(requested.length - candidate.length);
+		return 500 - Math.min(distance, 400);
+	}
+
+	return 0;
+}
+
+function formatCandidate(item) {
+	return {
+		instanceId: String(item?.instanceId || ""),
+		projectPath: normalizePath(item?.projectPath || ""),
+		projectName: String(item?.projectName || ""),
+		mode: String(item?.mode || ""),
+		port: Number(item?.port || 0),
+		lastSeenUnix: Number(item?.lastSeenUnix || 0),
+	};
+}
+
+function buildSelectionError(code, message, flags, candidates) {
+	return new InstanceSelectionError(code, message, {
+		reason: code === "PIE_UNITY_INSTANCE_AMBIGUOUS" ? "ambiguous" : "no_match",
+		requestedProject: normalizePath(flags.project || ""),
+		requestedInstance: String(flags.instance || "").trim(),
+		requestedPort: Number(flags.port || 0) || 0,
+		candidates: candidates.map(formatCandidate),
+	});
+}
+
+export function selectInstance(instances, flags) {
+	const activeInstances = getActiveInstances(instances);
+	const project = normalizePath(flags.project || "");
+	const instanceId = String(flags.instance || "").trim();
+	const explicitPort = Number(flags.port || 0);
+
+	if (explicitPort > 0) {
+		return {
+			instanceId: instanceId || `port_${explicitPort}`,
+			projectPath: project,
+			port: explicitPort,
+			mode: "unknown",
+		};
+	}
+
+	if (instanceId) {
+		const match = activeInstances.find((item) => String(item.instanceId || "") === instanceId);
+		if (match) return match;
+		throw buildSelectionError(
+			"PIE_UNITY_INSTANCE_NOT_FOUND",
+			`No pie-unity instance found for --instance ${instanceId}.`,
+			flags,
+			activeInstances,
+		);
+	}
+
+	if (project && activeInstances.length > 0) {
+		const scored = activeInstances
+			.map((item) => ({ item, score: computeProjectMatchScore(project, item.projectPath || "") }))
+			.filter((entry) => entry.score > 0)
+			.sort((left, right) => right.score - left.score || Number(right.item.lastSeenUnix || 0) - Number(left.item.lastSeenUnix || 0));
+
+		if (scored.length === 1) {
+			return scored[0].item;
+		}
+
+		if (scored.length > 1) {
+			const bestScore = scored[0].score;
+			const best = scored.filter((entry) => entry.score === bestScore).map((entry) => entry.item);
+			if (best.length === 1) {
+				return best[0];
+			}
+			throw buildSelectionError(
+				"PIE_UNITY_INSTANCE_AMBIGUOUS",
+				`Multiple pie-unity instances match project hint ${project}. Pass --instance or --port.`,
+				flags,
+				best,
+			);
+		}
+	}
+
+	if (activeInstances.length === 1) {
+		return activeInstances[0];
+	}
+
+	if (activeInstances.length > 1) {
+		throw buildSelectionError(
+			"PIE_UNITY_INSTANCE_AMBIGUOUS",
+			"Multiple pie-unity instances found. Pass --instance, --port, or a more specific --project.",
+			flags,
+			activeInstances,
+		);
+	}
+
+	throw buildSelectionError(
+		"PIE_UNITY_INSTANCE_NOT_FOUND",
+		project
+			? `No matching pie-unity instance found for project hint ${project}.`
+			: "No matching pie-unity instance found.",
+		flags,
+		activeInstances,
+	);
+}
+
+export async function requestJson(url, init = {}, options = {}) {
+	const waitMs = Number(options.waitMs || DEFAULT_WAIT_MS);
+	const retries = Number(options.retries || DEFAULT_RETRIES);
+	let lastError;
+	for (let attempt = 0; attempt < retries; attempt += 1) {
+		try {
+			const response = await fetch(url, init);
+			const text = await response.text();
+			const json = text ? JSON.parse(text) : {};
+
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${text}`);
+			}
+
+			const unavailable = extractAvailability(json);
+			if (unavailable) {
+				lastError = new Error(unavailable.message || "pie-unity temporarily unavailable");
+				if (attempt < retries - 1) {
+					await sleep(waitMs);
+					continue;
+				}
+			}
+
+			return json;
+		} catch (error) {
+			lastError = error;
+			if (attempt >= retries - 1) break;
+			await sleep(waitMs);
+		}
+	}
+	throw lastError || new Error("Request failed");
+}
+
+export async function runCli(argv = process.argv) {
+	const { command, flags } = parseArgs(argv);
+	if (command === "instances") {
+		const instances = getActiveInstances(loadRegistry());
+		const filtered = flags.project
+			? instances.filter((item) => computeProjectMatchScore(flags.project, item.projectPath || "") > 0)
+			: instances;
+		writeJson({ service: "pie-unity", instances: filtered });
+		return;
+	}
+
+	const instance = selectInstance(loadRegistry(), flags);
+	const baseUrl = `http://127.0.0.1:${instance.port}`;
+
+	switch (command) {
+		case "health": {
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/health`, {}, flags)));
+			return;
+		}
+		case "manifest": {
+			const query = new URLSearchParams();
+			if (flags.namespace) query.set("namespace", flags.namespace);
+			if (flags.name) query.set("name", flags.name);
+			const suffix = query.toString() ? `?${query.toString()}` : "";
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/manifest${suffix}`, {}, flags)));
+			return;
+		}
+		case "query": {
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/tool/${encodeURIComponent("unity_scene_query")}`, postJson(parseData(flags.data)), flags)));
+			return;
+		}
+		case "inspect": {
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/tool/${encodeURIComponent("unity_scene_object_inspect")}`, postJson(parseData(flags.data)), flags)));
+			return;
+		}
+		case "edit": {
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/tool/${encodeURIComponent("unity_scene_object_edit")}`, postJson(parseData(flags.data)), flags)));
+			return;
+		}
+		case "log-read": {
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/tool/${encodeURIComponent("unity_log_read")}`, postJson(parseData(flags.data)), flags)));
+			return;
+		}
+		case "script-run": {
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/tool/${encodeURIComponent("unity_script_run")}`, postJson(parseData(flags.data)), flags)));
+			return;
+		}
+		case "tool": {
+			const name = String(flags.tool || "").trim();
+			if (!name) throw new Error("--tool is required");
+			const body = parseData(flags.data);
+			writeJson(normalizeEnvelope(await requestJson(`${baseUrl}/tool/${encodeURIComponent(name)}`, postJson(body), flags)));
+			return;
+		}
+		case "rpc": {
+			const name = String(flags.method || "").trim();
+			if (!name) throw new Error("--method is required");
+			const body = parseData(flags.data);
+			const response = normalizeEnvelope(await requestJson(`${baseUrl}/rpc/${encodeURIComponent(name)}`, postJson(body), flags));
+			if (name === "pie_chat.set_config") {
+				await settleChatConfig(baseUrl, flags, Number(response?.result?.configAppliedVersion || 0));
+			}
+			writeJson(response);
+			return;
+		}
+		default:
+			throw new Error(`Unknown command: ${command}`);
+	}
+}
+
+function extractAvailability(json) {
+	const raw = json?.serverAvailability || json?.availability || "";
+	if (!raw) return null;
+	if (typeof raw === "string") {
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return { message: raw };
+		}
+	}
+	return raw;
+}
+
+function normalizeEnvelope(json) {
+	if (!json || typeof json !== "object") return json;
+	if (!("result" in json) && !("serverAvailability" in json)) return json;
+
+	const next = { ...json };
+	if (typeof next.result === "string") {
+		const trimmed = next.result.trim();
+		if (trimmed === "null") {
+			next.result = null;
+		} else if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+			try {
+				next.result = JSON.parse(trimmed);
+			} catch {
+				// Keep original string.
+			}
+		}
+	}
+
+	if (typeof next.serverAvailability === "string" && next.serverAvailability.trim()) {
+		try {
+			next.serverAvailability = JSON.parse(next.serverAvailability);
+		} catch {
+			// Keep original string.
+		}
+	}
+
+	return next;
+}
+
+function parseData(input) {
+	if (!input) return {};
+	return JSON.parse(input);
+}
+
+function postJson(body) {
+	return {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body || {}),
+	};
+}
+
+async function settleChatConfig(baseUrl, flags, expectedVersion = 0) {
+	const settleMs = Math.max(0, Number(flags.configSettleMs || 500));
+	const pollMs = Math.max(100, Math.min(settleMs || 200, 250));
+	const deadline = Date.now() + Math.max(1500, settleMs * 4 || 1500);
+
+	while (Date.now() < deadline) {
+		try {
+			const state = normalizeEnvelope(
+				await requestJson(`${baseUrl}/tool/${encodeURIComponent("chat_get_state")}`, {}, {
+					waitMs: pollMs,
+					retries: 1,
+				}),
+			);
+			const appliedVersion = Number(state?.result?.configAppliedVersion || 0);
+			const versionApplied = expectedVersion > 0 ? appliedVersion >= expectedVersion : false;
+			if (versionApplied || !state?.result?.isBusy) {
+				if (settleMs > 0) {
+					await sleep(settleMs);
+				}
+				return;
+			}
+		} catch {
+			// Ignore transient polling failures while the bridge settles.
+		}
+		await sleep(pollMs);
+	}
+
+	if (settleMs > 0) {
+		await sleep(settleMs);
+	}
+}
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function normalizePath(value) {
+	return String(value || "").replace(/\\/g, "/");
+}
+
+function writeJson(payload) {
+	process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function dedupeInstances(items) {
+	const sorted = [...items].sort((a, b) => {
+		const timeA = Number(a?.lastSeenUnix || 0);
+		const timeB = Number(b?.lastSeenUnix || 0);
+		return timeB - timeA;
+	});
+	const seen = new Set();
+	const next = [];
+	for (const item of sorted) {
+		const key = [
+			String(item?.instanceId || ""),
+			normalizePath(item?.projectPath || ""),
+			String(item?.mode || ""),
+		].join("|");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		next.push(item);
+	}
+	return next;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	runCli().catch((error) => {
+		if (error instanceof InstanceSelectionError) {
+			process.stderr.write(`${JSON.stringify({
+				error: error.message,
+				code: error.code,
+				...error.details,
+			}, null, 2)}\n`);
+			process.exitCode = 2;
+			return;
+		}
+		process.stderr.write(`${error?.message || error}\n`);
+		process.exitCode = 1;
+	});
+}

package/dist/builtin/skills/skill-creator/SKILL.md

@@ -14,7 +14,7 @@ At a high level, the process of creating a skill goes like this:
 - Create a few test prompts and run claude-with-access-to-the-skill on them
 - Help the user evaluate the results both qualitatively and quantitatively
   - While the runs happen in the background, draft some quantitative evals if there aren't any (if there are some, you can either use as is or modify if you feel something needs to change about them). Then explain them to the user (or if they already existed, explain the ones that already exist)
-  - Use the `eval-viewer/generate_review.py` script to show the user the results for them to look at, and also let them look at the quantitative metrics
+  - Use the `eval-viewer/generate_review.mjs` script to show the user the results for them to look at, and also let them look at the quantitative metrics
 - Rewrite the skill based on feedback from the user's evaluation of the results (and also if there are any glaring flaws that become apparent from the quantitative benchmarks)
 - Repeat until you're satisfied
 - Expand the test set and try again at larger scale
@@ -226,7 +226,7 @@ Once all runs are done:
 
 2. **Aggregate into benchmark** — run the aggregation script from the skill-creator directory:
    ```bash
-   python -m scripts.aggregate_benchmark <workspace>/iteration-N --skill-name <name>
+   node <skill-creator-path>/scripts/aggregate_benchmark.mjs <workspace>/iteration-N --skill-name <name>
    ```
    This produces `benchmark.json` and `benchmark.md` with pass_rate, time, and tokens for each configuration, with mean ± stddev and the delta. If generating benchmark.json manually, see `references/schemas.md` for the exact schema the viewer expects.
 Put each with_skill version before its baseline counterpart.
@@ -235,7 +235,7 @@ Put each with_skill version before its baseline counterpart.
 
 4. **Launch the viewer** with both qualitative outputs and quantitative data:
    ```bash
-   nohup python <skill-creator-path>/eval-viewer/generate_review.py \
+   nohup node <skill-creator-path>/eval-viewer/generate_review.mjs \
      <workspace>/iteration-N \
      --skill-name "my-skill" \
      --benchmark <workspace>/iteration-N/benchmark.json \
@@ -246,7 +246,7 @@ Put each with_skill version before its baseline counterpart.
 
    **Cowork / headless environments:** If `webbrowser.open()` is not available or the environment has no display, use `--static <output_path>` to write a standalone HTML file instead of starting a server. Feedback will be downloaded as a `feedback.json` file when the user clicks "Submit All Reviews". After download, copy `feedback.json` into the workspace directory for the next iteration to pick up.
 
-Note: please use generate_review.py to create the viewer; there's no need to write custom HTML.
+Note: please use `generate_review.mjs` to create the viewer; there's no need to write custom HTML.
 
 5. **Tell the user** something like: "I've opened the results in your browser. There are two tabs — 'Outputs' lets you click through each test case and leave feedback, 'Benchmark' shows the quantitative comparison. When you're done, come back here and let me know."
 
@@ -301,7 +301,7 @@ This is the heart of the loop. You've run the test cases, the user has reviewed
 
 3. **Explain the why.** Try hard to explain the **why** behind everything you're asking the model to do. Today's LLMs are *smart*. They have good theory of mind and when given a good harness can go beyond rote instructions and really make things happen. Even if the feedback from the user is terse or frustrated, try to actually understand the task and why the user is writing what they wrote, and what they actually wrote, and then transmit this understanding into the instructions. If you find yourself writing ALWAYS or NEVER in all caps, or using super rigid structures, that's a yellow flag — if possible, reframe and explain the reasoning so that the model understands why the thing you're asking for is important. That's a more humane, powerful, and effective approach.
 
-4. **Look for repeated work across test cases.** Read the transcripts from the test runs and notice if the subagents all independently wrote similar helper scripts or took the same multi-step approach to something. If all 3 test cases resulted in the subagent writing a `create_docx.py` or a `build_chart.py`, that's a strong signal the skill should bundle that script. Write it once, put it in `scripts/`, and tell the skill to use it. This saves every future invocation from reinventing the wheel.
+4. **Look for repeated work across test cases.** Read the transcripts from the test runs and notice if the subagents all independently wrote similar helper scripts or took the same multi-step approach to something. If all 3 test cases resulted in the subagent writing a `create_docx.mjs` or a `build_chart.mjs`, that's a strong signal the skill should bundle that script. Write it once, put it in `scripts/`, and tell the skill to use it. This saves every future invocation from reinventing the wheel.
 
 This task is pretty important (we are trying to create billions a year in economic value here!) and your thinking time is not the blocker; take your time and really mull things over. I'd suggest writing a draft revision and then looking at it anew and making improvements. Really do your best to get into the head of the user and understand what they want and need.
 
@@ -332,7 +332,7 @@ This is optional, requires subagents, and most users won't need it. The human re
 
 ## Description Optimization
 
-The description field in SKILL.md frontmatter is the primary mechanism that determines whether Claude invokes a skill. After creating or improving a skill, offer to optimize the description for better triggering accuracy.
+The description field in SKILL.md frontmatter is the primary mechanism that determines whether Pie invokes a skill. After creating or improving a skill, offer to optimize the description for better triggering accuracy.
 
 ### Step 1: Generate trigger eval queries
 
@@ -379,7 +379,7 @@ Tell the user: "This will take some time — I'll run the optimization loop in t
 Save the eval set to the workspace, then run in the background:
 
 ```bash
-python -m scripts.run_loop \
+node <skill-creator-path>/scripts/run_loop.mjs \
   --eval-set <path-to-trigger-eval.json> \
   --skill-path <path-to-skill> \
   --model <model-id-powering-this-session> \
@@ -391,11 +391,11 @@ Use the model ID from your system prompt (the one powering the current session)
 
 While it runs, periodically tail the output to give the user updates on which iteration it's on and what the scores look like.
 
-This handles the full optimization loop automatically. It splits the eval set into 60% train and 40% held-out test, evaluates the current description (running each query 3 times to get a reliable trigger rate), then calls Claude to propose improvements based on what failed. It re-evaluates each new description on both train and test, iterating up to 5 times. When it's done, it opens an HTML report in the browser showing the results per iteration and returns JSON with `best_description` — selected by test score rather than train score to avoid overfitting.
+This handles the full optimization loop automatically. It splits the eval set into 60% train and 40% held-out test, evaluates the current description with Pie (running each query 3 times to get a reliable trigger rate), then asks Pie to propose improvements based on what failed. It re-evaluates each new description on both train and test, iterating up to 5 times. When it's done, it opens an HTML report in the browser showing the results per iteration and returns JSON with `best_description` — selected by test score rather than train score to avoid overfitting.
 
 ### How skill triggering works
 
-Understanding the triggering mechanism helps design better eval queries. Skills appear in Claude's `available_skills` list with their name + description, and Claude decides whether to consult a skill based on that description. The important thing to know is that Claude only consults skills for tasks it can't easily handle on its own — simple, one-step queries like "read this PDF" may not trigger a skill even if the description matches perfectly, because Claude can handle them directly with basic tools. Complex, multi-step, or specialized queries reliably trigger skills when the description matches.
+Understanding the triggering mechanism helps design better eval queries. Skills appear in Pie's `available_skills` list with their name + description, and Pie decides whether to consult a skill based on that description. The important thing to know is that Pie only consults skills for tasks it can't easily handle on its own — simple, one-step queries like "read this PDF" may not trigger a skill even if the description matches perfectly, because Pie can handle them directly with basic tools. Complex, multi-step, or specialized queries reliably trigger skills when the description matches.
 
 This means your eval queries should be substantive enough that Claude would actually benefit from consulting a skill. Simple queries like "read file X" are poor test cases — they won't trigger skills regardless of description quality.
 
@@ -410,7 +410,7 @@ Take `best_description` from the JSON output and update the skill's SKILL.md fro
 Check whether you have access to the `present_files` tool. If you don't, skip this step. If you do, package the skill and present the .skill file to the user:
 
 ```bash
-python -m scripts.package_skill <path/to/skill-folder>
+node <skill-creator-path>/scripts/package_skill.mjs <path/to/skill-folder>
 ```
 
 After packaging, direct the user to the resulting `.skill` file path so they can install it.
@@ -429,11 +429,11 @@ In Claude.ai, the core workflow is the same (draft → test → review → impro
 
 **The iteration loop**: Same as before — improve the skill, rerun the test cases, ask for feedback — just without the browser reviewer in the middle. You can still organize results into iteration directories on the filesystem if you have one.
 
-**Description optimization**: This section requires the `claude` CLI tool (specifically `claude -p`) which is only available in Claude Code. Skip it if you're on Claude.ai.
+**Description optimization**: This section now defaults to Pie's own non-interactive runner. It does not require `claude -p`.
 
 **Blind comparison**: Requires subagents. Skip it.
 
-**Packaging**: The `package_skill.py` script works anywhere with Python and a filesystem. On Claude.ai, you can run it and the user can download the resulting `.skill` file.
+**Packaging**: The `package_skill.mjs` script works anywhere with Node.js and a filesystem. On Claude.ai or Codex CLI, you can run it and the user can download the resulting `.skill` file.
 
 **Updating an existing skill**: The user might be asking you to update an existing skill, not create a new one. In this case:
 - **Preserve the original name.** Note the skill's directory name and `name` frontmatter field -- use them unchanged. E.g., if the installed skill is `research-helper`, output `research-helper.skill` (not `research-helper-v2`).
@@ -448,10 +448,10 @@ If you're in Cowork, the main things to know are:
 
 - You have subagents, so the main workflow (spawn test cases in parallel, run baselines, grade, etc.) all works. (However, if you run into severe problems with timeouts, it's OK to run the test prompts in series rather than parallel.)
 - You don't have a browser or display, so when generating the eval viewer, use `--static <output_path>` to write a standalone HTML file instead of starting a server. Then proffer a link that the user can click to open the HTML in their browser.
-- For whatever reason, the Cowork setup seems to disincline Claude from generating the eval viewer after running the tests, so just to reiterate: whether you're in Cowork or in Claude Code, after running tests, you should always generate the eval viewer for the human to look at examples before revising the skill yourself and trying to make corrections, using `generate_review.py` (not writing your own boutique html code). Sorry in advance but I'm gonna go all caps here: GENERATE THE EVAL VIEWER *BEFORE* evaluating inputs yourself. You want to get them in front of the human ASAP!
+- For whatever reason, the Cowork setup seems to disincline Claude from generating the eval viewer after running the tests, so just to reiterate: whether you're in Cowork or in Claude Code, after running tests, you should always generate the eval viewer for the human to look at examples before revising the skill yourself and trying to make corrections, using `generate_review.mjs` (not writing your own boutique html code). Sorry in advance but I'm gonna go all caps here: GENERATE THE EVAL VIEWER *BEFORE* evaluating inputs yourself. You want to get them in front of the human ASAP!
 - Feedback works differently: since there's no running server, the viewer's "Submit All Reviews" button will download `feedback.json` as a file. You can then read it from there (you may have to request access first).
-- Packaging works — `package_skill.py` just needs Python and a filesystem.
-- Description optimization (`run_loop.py` / `run_eval.py`) should work in Cowork just fine since it uses `claude -p` via subprocess, not a browser, but please save it until you've fully finished making the skill and the user agrees it's in good shape.
+- Packaging works — `package_skill.mjs` just needs Node.js and a filesystem.
+- Description optimization (`run_loop.mjs` / `run_eval.mjs`) should work in Cowork just fine since it uses Pie's non-interactive runner, not a browser, but please save it until you've fully finished making the skill and the user agrees it's in good shape.
 - **Updating an existing skill**: The user might be asking you to update an existing skill, not create a new one. Follow the update guidance in the claude.ai section above.
 
 ---
@@ -475,11 +475,11 @@ Repeating one more time the core loop here for emphasis:
 - Draft or edit the skill
 - Run claude-with-access-to-the-skill on test prompts
 - With the user, evaluate the outputs:
-  - Create benchmark.json and run `eval-viewer/generate_review.py` to help the user review them
+  - Create benchmark.json and run `eval-viewer/generate_review.mjs` to help the user review them
   - Run quantitative evals
 - Repeat until you and the user are satisfied
 - Package the final skill and return it to the user.
 
-Please add steps to your TodoList, if you have such a thing, to make sure you don't forget. If you're in Cowork, please specifically put "Create evals JSON and run `eval-viewer/generate_review.py` so human can review test cases" in your TodoList to make sure it happens.
+Please add steps to your TodoList, if you have such a thing, to make sure you don't forget. If you're in Cowork, please specifically put "Create evals JSON and run `eval-viewer/generate_review.mjs` so human can review test cases" in your TodoList to make sure it happens.
 
 Good luck!