magus-cli 7.12.2 → 7.14.0

package/src/__tests__/market-fixture.ts

@@ -0,0 +1,1167 @@
+import { expect } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+	chmodSync,
+	existsSync,
+	lstatSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	readdirSync,
+	readlinkSync,
+	realpathSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { devNull, tmpdir } from "node:os";
+import { basename, dirname, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { MarketResult } from "../services/market-types.js";
+
+export const SKILL =
+	"---\nname: review\ndescription: Reviews changes.\n---\nOriginal review instructions.\n";
+export const EDITED = `${SKILL}\nReview error handling too.\n`;
+export const REMOTE_EDIT = `${SKILL}\nReview concurrency too.\n`;
+export const PLUGIN = "review-kit";
+export const ID = `${PLUGIN}@acme`;
+export const SKILL_REL = "plugins/review-kit/skills/review/SKILL.md";
+export const MANIFEST = ".claude-plugin/marketplace.json";
+export const PLUGIN_MANIFEST = "plugins/review-kit/.claude-plugin/plugin.json";
+
+export interface ProcessResult {
+	code: number;
+	out: string;
+	err: string;
+}
+export interface MarketRun extends ProcessResult {
+	result: MarketResult;
+}
+export interface Repo {
+	name: string;
+	slug: string;
+	url: string;
+	bare: string;
+	author: string;
+}
+export interface SeedOptions {
+	name?: string;
+	slug?: string;
+	marker?: boolean;
+	empty?: boolean;
+	noManifest?: boolean;
+	entryVersion?: string | null;
+	pluginVersion?: string | null;
+	noPluginJson?: boolean;
+	dependencies?: string[];
+	extras?: Record<string, string>;
+}
+export interface JournalEvent {
+	tool: string;
+	argv: string[];
+	cwd: string;
+	writes: Array<{ path: string; bytes: string | null }>;
+}
+
+/**
+ * The provider stand-in is self-contained so its transpiled function can be
+ * installed as an executable in each test's PATH. It never imports magus.
+ */
+async function providerMain() {
+	const fs = await import("node:fs");
+	const p = await import("node:path");
+	const cp = await import("node:child_process");
+	type Json = Record<string, any>;
+	const root = process.env.MARKET_TEST_ROOT!;
+	const config = process.env.CLAUDE_CONFIG_DIR!;
+	const control = p.join(root, "control");
+	const controls: Json = JSON.parse(
+		fs.readFileSync(p.join(control, "modes.json"), "utf8"),
+	);
+	const argv = process.argv.slice(2);
+	const tool = p.basename(process.argv[1]!);
+	const writes: Array<{ path: string; bytes: string | null }> = [];
+	const event = () =>
+		fs.appendFileSync(
+			p.join(control, "journal.jsonl"),
+			`${JSON.stringify({ tool, argv, cwd: process.cwd(), writes })}\n`,
+		);
+	process.on("exit", event);
+	const fail = (message: string, code = 1): never => {
+		process.stderr.write(`${message}\n`);
+		process.exit(code);
+	};
+	const output = (value: unknown) =>
+		process.stdout.write(
+			typeof value === "string" ? `${value}\n` : `${JSON.stringify(value)}\n`,
+		);
+	const read = (file: string, fallback: Json = {}): Json =>
+		fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : fallback;
+	const write = (file: string, value: unknown) => {
+		fs.mkdirSync(p.dirname(file), { recursive: true });
+		const bytes = `${JSON.stringify(value, null, 2)}\n`;
+		fs.writeFileSync(file, bytes);
+		writes.push({ path: file, bytes: Buffer.from(bytes).toString("base64") });
+	};
+	const git = (cwd: string, ...args: string[]) =>
+		cp
+			.execFileSync(process.env.MARKET_REAL_GIT!, args, {
+				cwd,
+				env: process.env,
+				encoding: "utf8",
+				stdio: ["ignore", "pipe", "pipe"],
+				timeout: 15_000,
+			})
+			.trim();
+	const flag = (name: string) => {
+		const eq = argv.find((a) => a.startsWith(`${name}=`));
+		const index = argv.indexOf(name);
+		return eq
+			? eq.slice(name.length + 1)
+			: index < 0
+				? undefined
+				: argv[index + 1];
+	};
+	const sourceSlug = (source: string) =>
+		source
+			.replace(/^https:\/\/github\.com\//, "")
+			.replace(/^git@github\.com:/, "")
+			.replace(/\.git\/?$/, "")
+			.replace(/\/$/, "");
+	const bare = (slug: string) => p.join(root, "remotes", `${slug}.git`);
+	const knownFile = p.join(config, "plugins", "known_marketplaces.json");
+	const installedFile = p.join(config, "plugins", "installed_plugins.json");
+	const known = () => read(knownFile);
+	const installed = () => read(installedFile, { version: 2, plugins: {} });
+	const settingsFile = (scope: string, cwd = process.cwd()) =>
+		scope === "user"
+			? p.join(config, "settings.json")
+			: p.join(
+					cwd,
+					".claude",
+					scope === "local" ? "settings.local.json" : "settings.json",
+				);
+	const pluginInfo = (id: string) => {
+		const at = id.lastIndexOf("@");
+		const name = id.slice(0, at);
+		const registration = known()[id.slice(at + 1)];
+		if (!registration) fail("Plugin not found in marketplace");
+		const location = registration.installLocation;
+		const manifest = read(
+			p.join(location, ".claude-plugin", "marketplace.json"),
+		);
+		const entry = (manifest.plugins ?? []).find(
+			(item: Json) => item.name === name,
+		);
+		if (!entry || typeof entry.source !== "string")
+			fail("Plugin not found in marketplace");
+		const plugin = entry.source.startsWith(".")
+			? p.resolve(location, entry.source)
+			: p.resolve(location, manifest.metadata?.pluginRoot ?? "", entry.source);
+		const json = read(p.join(plugin, ".claude-plugin", "plugin.json"));
+		return { version: json.version ?? entry.version ?? "0.0.0", plugin };
+	};
+	const recordCache = (dir: string) => {
+		for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
+			const file = p.join(dir, ent.name);
+			if (ent.isDirectory()) recordCache(file);
+			else if (!ent.isSymbolicLink())
+				writes.push({
+					path: file,
+					bytes: fs.readFileSync(file).toString("base64"),
+				});
+		}
+	};
+	const lateChange = () => {
+		if (controls.lateFile) {
+			fs.mkdirSync(p.dirname(controls.lateFile.path), { recursive: true });
+			fs.writeFileSync(controls.lateFile.path, controls.lateFile.content);
+		}
+		if (controls.lateOff) {
+			const file = settingsFile(controls.lateOff);
+			const state = read(file);
+			state.enabledPlugins ??= {};
+			state.enabledPlugins["review-kit@acme"] = false;
+			write(file, state);
+		}
+	};
+
+	if (tool === "claude") {
+		if (argv[0] === "--version" || argv[0] === "-v") {
+			output("2.1.323 (Claude Code)");
+			return;
+		}
+		if (argv[0] !== "plugin")
+			fail(`Unsupported test Claude invocation: ${JSON.stringify(argv)}`);
+		if (argv[1] === "validate") {
+			if (argv.includes("--strict"))
+				fail("Strict validation is not the market contract");
+			if (
+				controls.advanceOnValidate &&
+				!fs.existsSync(p.join(control, "advanced"))
+			) {
+				fs.writeFileSync(p.join(control, "advanced"), "once");
+				const a = controls.advanceOnValidate;
+				fs.writeFileSync(
+					p.join(a.author, "remote-race.txt"),
+					"remote advance\n",
+				);
+				git(a.author, "add", "--", "remote-race.txt");
+				git(a.author, "commit", "-m", "concurrent remote change");
+				git(a.author, "push", "origin", "HEAD:main");
+			}
+			if (controls.validateFail) fail("Invalid plugin manifest");
+			output("Validation passed (warnings are allowed)");
+			return;
+		}
+		if (argv[1] === "marketplace") {
+			if (argv[2] === "list") {
+				output(
+					Object.entries(known()).map(([name, row]: [string, any]) => ({
+						name,
+						...row,
+					})),
+				);
+				return;
+			}
+			if (argv[2] === "add") {
+				const source = argv[3]!;
+				const slug = sourceSlug(source);
+				if (controls.addFail || controls.denyReadSlug === slug)
+					fail(
+						`Your GitHub account cannot read ${slug} — ask its owner for access`,
+					);
+				const location = p.join(
+					config,
+					"plugins",
+					"marketplaces",
+					slug.split("/").pop()!,
+				);
+				fs.mkdirSync(p.dirname(location), { recursive: true });
+				git(
+					root,
+					"clone",
+					source.includes("://") || source.startsWith("git@")
+						? source
+						: `https://github.com/${source}.git`,
+					location,
+				);
+				const manifest = read(
+					p.join(location, ".claude-plugin", "marketplace.json"),
+				);
+				if (!manifest.name) fail("Marketplace has no name");
+				const finalLocation = p.join(
+					config,
+					"plugins",
+					"marketplaces",
+					manifest.name,
+				);
+				if (location !== finalLocation) fs.renameSync(location, finalLocation);
+				const entries = known();
+				entries[manifest.name] = {
+					source:
+						source.includes("://") || source.startsWith("git@")
+							? { source: "git", url: source }
+							: { source: "github", repo: source },
+					installLocation: finalLocation,
+					lastUpdated: new Date().toISOString(),
+					autoUpdate: controls.autoUpdate ?? true,
+				};
+				write(knownFile, entries);
+				output(`Added marketplace ${manifest.name}`);
+				return;
+			}
+			if (argv[2] === "remove") {
+				const name = argv[3]!;
+				const entries = known();
+				const location = entries[name]?.installLocation;
+				delete entries[name];
+				write(knownFile, entries);
+				const state = installed();
+				for (const id of Object.keys(state.plugins)) {
+					if (!id.endsWith(`@${name}`)) continue;
+					for (const row of state.plugins[id]) {
+						const file = settingsFile(
+							row.scope,
+							row.projectPath ?? process.cwd(),
+						);
+						const settings = read(file);
+						delete settings.enabledPlugins?.[id];
+						write(file, settings);
+					}
+					delete state.plugins[id];
+				}
+				write(installedFile, state);
+				if (location) fs.rmSync(location, { recursive: true, force: true });
+				output(`Removed marketplace ${name}`);
+				return;
+			}
+			fail(
+				`Forbidden or unsupported marketplace command: ${JSON.stringify(argv)}`,
+			);
+		}
+		if (argv[1] === "list") {
+			output(
+				Object.entries(installed().plugins).flatMap(
+					([id, rows]: [string, any]) =>
+						rows.map((row: Json) => ({
+							id,
+							name: id.split("@")[0],
+							...row,
+							enabled: true,
+						})),
+				),
+			);
+			return;
+		}
+		if (argv[1] !== "install" && argv[1] !== "update")
+			fail(`Forbidden or unsupported plugin command: ${JSON.stringify(argv)}`);
+		const id = argv[2]!;
+		const scope =
+			argv.includes("--scope") || argv.some((a) => a.startsWith("--scope="))
+				? flag("--scope")!
+				: "user";
+		if (controls.failInstall) fail(controls.failInstall);
+		const { version, plugin } = pluginInfo(id);
+		const dest = p.join(
+			config,
+			"plugins",
+			"cache",
+			id.split("@")[1]!,
+			id.split("@")[0]!,
+			version,
+		);
+		fs.mkdirSync(p.dirname(dest), { recursive: true });
+		fs.cpSync(plugin, dest, { recursive: true });
+		recordCache(dest);
+		const state = installed();
+		state.plugins[id] ??= [];
+		let row = state.plugins[id].find(
+			(r: Json) =>
+				r.scope === scope &&
+				(scope === "user" || r.projectPath === process.cwd()),
+		);
+		if (controls.misdirect && scope === "project" && argv[1] === "update") {
+			row = state.plugins[id].find(
+				(r: Json) => r.scope === "project" && r.projectPath !== process.cwd(),
+			);
+		}
+		if (!row) {
+			row = {
+				scope,
+				...(scope === "user" ? {} : { projectPath: process.cwd() }),
+				installedAt: "2026-01-01T00:00:00.000Z",
+			};
+			state.plugins[id].push(row);
+		}
+		row.version = version;
+		row.installPath = dest;
+		row.lastUpdated = "2026-01-01T00:00:00.000Z";
+		write(installedFile, state);
+		const file = settingsFile(scope);
+		const settings = read(file);
+		settings.enabledPlugins ??= {};
+		settings.enabledPlugins[id] = true;
+		write(file, settings);
+		lateChange();
+		output(`Installed ${id} v${version}`);
+		return;
+	}
+
+	if (tool !== "gh") fail(`Unsupported test provider ${tool}`);
+	if (controls.ghNetwork) fail("Could not resolve host: github.com");
+	if (controls.auth === false)
+		fail("Not logged in to any GitHub hosts. Run gh auth login.", 4);
+	if (argv[0] === "--version") {
+		output("gh version 2.80.0");
+		return;
+	}
+	if (argv[0] === "auth") {
+		output("Logged in to github.com as teammate");
+		return;
+	}
+	if (argv[0] === "repo" && argv[1] === "create") {
+		const slug = argv[2]!;
+		if (fs.existsSync(bare(slug))) fail("Name already exists");
+		fs.mkdirSync(p.dirname(bare(slug)), { recursive: true });
+		git(root, "init", "--bare", "-b", "main", bare(slug));
+		output(`https://github.com/${slug}`);
+		return;
+	}
+	if (argv[0] === "repo" && argv[1] === "view") {
+		const slug = argv[2]!;
+		if (!fs.existsSync(bare(slug)) || controls.invisible)
+			fail("GraphQL: Could not resolve to a Repository", 1);
+		const data = {
+			name: slug.split("/")[1],
+			nameWithOwner: slug,
+			defaultBranchRef: { name: "main" },
+			viewerPermission: controls.push === false ? "READ" : "WRITE",
+			isPrivate: true,
+		};
+		const jq = flag("--jq");
+		output(jq?.includes("viewerPermission") ? data.viewerPermission : data);
+		return;
+	}
+	if (argv[0] === "pr" && argv[1] === "create") {
+		if (!argv.includes("--body-file") || !fs.existsSync(flag("--body-file")!))
+			fail("PR body must use an existing --body-file");
+		if (controls.prFail) fail("Could not open pull request");
+		output(`https://github.com/${flag("-R") ?? flag("--repo")}/pull/17`);
+		return;
+	}
+	if (argv[0] === "api") {
+		const endpoint = argv.find(
+			(a) => a === "user" || a === "user/orgs" || a.startsWith("repos/"),
+		)!;
+		const jq = flag("--jq");
+		if (endpoint === "user") {
+			output(jq ? "teammate" : { login: "teammate" });
+			return;
+		}
+		if (endpoint === "user/orgs") {
+			output(jq ? "acme" : [{ login: "acme" }]);
+			return;
+		}
+		if (!endpoint) fail(`Unsupported gh api: ${JSON.stringify(argv)}`);
+		const parts = endpoint.split("/");
+		const slug = parts.slice(1, 3).join("/");
+		if (controls.invisible || !fs.existsSync(bare(slug)))
+			fail("HTTP 404: Not Found", 1);
+		if (parts[3] === "contents") {
+			try {
+				output(
+					git(
+						root,
+						"--git-dir",
+						bare(slug),
+						"show",
+						`HEAD:${parts.slice(4).join("/").split("?")[0]}`,
+					),
+				);
+			} catch {
+				fail("HTTP 404: Not Found", 1);
+			}
+			return;
+		}
+		if (parts[3] === "forks") {
+			const fork = controls.forkName ?? "teammate/market-renamed";
+			fs.mkdirSync(p.dirname(bare(fork)), { recursive: true });
+			if (!fs.existsSync(bare(fork)))
+				git(root, "clone", "--bare", bare(slug), bare(fork));
+			fs.writeFileSync(
+				p.join(control, "fork-parent.json"),
+				JSON.stringify({ fork, parent: controls.forkParent ?? slug }),
+			);
+			output(jq ? fork : { full_name: fork });
+			return;
+		}
+		const parent = read(p.join(control, "fork-parent.json"));
+		const data = {
+			full_name: slug,
+			default_branch: "main",
+			allow_forking: controls.forks !== false,
+			permissions: { push: controls.push !== false },
+			owner: { login: slug.split("/")[0] },
+			parent: parent.fork === slug ? { full_name: parent.parent } : null,
+		};
+		if (jq) {
+			if (jq.includes("permissions.push")) output(data.permissions.push);
+			else if (jq.includes("allow_forking")) output(data.allow_forking);
+			else if (jq.includes("parent")) output(data.parent?.full_name ?? "");
+			else if (jq.includes("default_branch")) output(data.default_branch);
+			else if (jq.includes("owner.login")) output(data.owner.login);
+			else if (jq.includes("full_name")) output(data.full_name);
+			else fail(`Unsupported gh jq: ${jq}`);
+		} else output(data);
+		return;
+	}
+	fail(`Unsupported gh invocation: ${JSON.stringify(argv)}`);
+}
+
+function filesUnder(dir: string): string[] {
+	if (!existsSync(dir)) return [];
+	const stat = lstatSync(dir);
+	if (!stat.isDirectory() || stat.isSymbolicLink()) return [dir];
+	return readdirSync(dir)
+		.sort()
+		.flatMap((name) => filesUnder(join(dir, name)));
+}
+
+export function write(file: string, bytes: string): void {
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, bytes);
+}
+export function writeJson(file: string, value: unknown): void {
+	write(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function readJson<T = Record<string, any>>(file: string): T {
+	return JSON.parse(readFileSync(file, "utf8")) as T;
+}
+export function sourceModule(rel: string): string {
+	return new URL(`../${rel.replace(/^\.\//, "")}`, import.meta.url).href;
+}
+
+export class MarketFixture {
+	readonly root = realpathSync(
+		mkdtempSync(join(tmpdir(), "magus-market-test-")),
+	);
+	readonly home = join(this.root, "home");
+	readonly config: string;
+	readonly project = join(this.root, "project");
+	readonly temp = join(this.root, "tmp");
+	readonly bin = join(this.root, "bin");
+	readonly control = join(this.root, "control");
+	readonly gitBinary =
+		Bun.which("git") ??
+		(() => {
+			throw new Error("Real git is required");
+		})();
+	readonly env: NodeJS.ProcessEnv;
+	private modes: Record<string, unknown> = {};
+	private baseline = new Map<string, string>();
+
+	constructor(configOutsideHome = false) {
+		this.config = configOutsideHome
+			? join(this.root, "chosen-config")
+			: join(this.home, ".claude");
+		for (const dir of [
+			this.home,
+			this.config,
+			this.project,
+			this.temp,
+			this.bin,
+			this.control,
+			join(this.root, "remotes"),
+			join(this.root, "xdg-cache"),
+			join(this.root, "xdg-config"),
+		])
+			mkdirSync(dir, { recursive: true });
+		const gitConfig = join(this.control, "gitconfig");
+		this.env = {
+			HOME: this.home,
+			CLAUDE_CONFIG_DIR: this.config,
+			XDG_CACHE_HOME: join(this.root, "xdg-cache"),
+			XDG_CONFIG_HOME: join(this.root, "xdg-config"),
+			TMPDIR: this.temp,
+			TMP: this.temp,
+			TEMP: this.temp,
+			PATH: this.bin,
+			NO_COLOR: "1",
+			TERM: "xterm-256color",
+			CI: "1",
+			GIT_CONFIG_GLOBAL: gitConfig,
+			GIT_CONFIG_SYSTEM: devNull,
+			GIT_CONFIG_NOSYSTEM: "1",
+			GIT_TERMINAL_PROMPT: "0",
+			GCM_INTERACTIVE: "never",
+			GIT_ALLOW_PROTOCOL: "file",
+			GH_PROMPT_DISABLED: "1",
+			MARKET_TEST_ROOT: this.root,
+			MARKET_REAL_GIT: this.gitBinary,
+		};
+		symlinkSync(this.gitBinary, join(this.bin, "git"));
+		symlinkSync(process.execPath, join(this.bin, "bun"));
+		for (const name of ["sh", "which", "env", "uname"]) {
+			const binary = Bun.which(name);
+			if (binary) symlinkSync(binary, join(this.bin, name));
+		}
+		write(
+			gitConfig,
+			`${[
+				"[user]",
+				"\tname = Market Test",
+				"\temail = market-test@example.invalid",
+				"[init]",
+				"\tdefaultBranch = main",
+				"[commit]",
+				"\tgpgsign = false",
+				'[protocol "file"]',
+				"\tallow = always",
+				`[url ${JSON.stringify(pathToFileURL(`${join(this.root, "remotes")}/`).href)}]`,
+				"\tinsteadOf = https://github.com/",
+				`[url ${JSON.stringify(pathToFileURL(`${join(this.root, "remotes")}/`).href)}]`,
+				"\tinsteadOf = git@github.com:",
+			].join("\n")}\n`,
+		);
+		const provider = join(this.control, "provider.ts");
+		write(
+			provider,
+			`(${providerMain.toString()})().catch(e => { process.stderr.write(String(e.stack || e) + '\\n'); process.exit(1); });\n`,
+		);
+		const standIn = `#!${process.execPath} --no-env-file\nimport ${JSON.stringify(pathToFileURL(provider).href)};\n`;
+		for (const name of ["claude", "gh"]) {
+			write(join(this.bin, name), standIn);
+			chmodSync(join(this.bin, name), 0o755);
+		}
+		writeJson(join(this.control, "modes.json"), {});
+		write(join(this.control, "journal.jsonl"), "");
+		write(
+			join(this.control, "deny-network.ts"),
+			"globalThis.fetch = async () => { throw new Error('External network is forbidden in market tests'); };\n" +
+				"import net from 'node:net'; net.Socket.prototype.connect = function () { throw new Error('External sockets are forbidden in market tests'); } as any;\n",
+		);
+		this.git(this.project, "init", "-b", "main");
+		write(join(this.project, "README.md"), "Scratch project\n");
+		this.git(this.project, "add", "--", "README.md");
+		this.git(this.project, "commit", "-m", "initial project");
+		this.rememberOwned();
+	}
+
+	setModes(patch: Record<string, unknown>): void {
+		this.modes = { ...this.modes, ...patch };
+		writeJson(join(this.control, "modes.json"), this.modes);
+	}
+	missingGh(): void {
+		rmSync(join(this.bin, "gh"));
+	}
+	run(args: string[], cwd = this.project, timeout = 30_000): ProcessResult {
+		const r = spawnSync(args[0]!, args.slice(1), {
+			cwd,
+			env: this.env,
+			input: "",
+			encoding: "utf8",
+			timeout,
+			maxBuffer: 8 * 1024 * 1024,
+		});
+		if (r.error || r.signal)
+			throw new Error(
+				`Child did not finish: ${JSON.stringify({
+					args,
+					error: String(r.error),
+					signal: r.signal,
+					out: r.stdout,
+					err: r.stderr,
+				})}`,
+			);
+		return { code: r.status!, out: r.stdout ?? "", err: r.stderr ?? "" };
+	}
+	git(cwd: string, ...args: string[]): string {
+		const r = this.run([this.gitBinary, ...args], cwd);
+		if (r.code !== 0)
+			throw new Error(`Test git failed ${args.join(" ")}\n${r.err}`);
+		return r.out.trim();
+	}
+	evaluate(body: string, cwd = this.project): ProcessResult {
+		return this.run(
+			[
+				process.execPath,
+				"--no-env-file",
+				"--preload",
+				join(this.control, "deny-network.ts"),
+				"--eval",
+				body,
+			],
+			cwd,
+		);
+	}
+	value<T>(body: string, cwd = this.project): T {
+		const r = this.evaluate(body, cwd);
+		if (r.code !== 0)
+			throw new Error(`Public API child failed\n${r.out}\n${r.err}`);
+		const last = r.out.trim().split("\n").at(-1);
+		if (!last) throw new Error(`Public API child printed no JSON\n${r.err}`);
+		return JSON.parse(last) as T;
+	}
+	cli(args: string[], cwd = this.project): ProcessResult {
+		return this.run(
+			[
+				process.execPath,
+				"--no-env-file",
+				"--preload",
+				join(this.control, "deny-network.ts"),
+				join(import.meta.dir, "..", "main.tsx"),
+				...args,
+			],
+			cwd,
+		);
+	}
+	market(args: string[], cwd = this.project): MarketRun {
+		const r = this.cli(["market", ...args, "--json"], cwd);
+		const lines = r.out.trimEnd().split(/\r?\n/);
+		const last = lines.at(-1);
+		if (!last || !last.startsWith("{"))
+			throw new Error(`No final-line MarketResult\n${r.out}\n${r.err}`);
+		const result = JSON.parse(last) as MarketResult;
+		expect(result.command.startsWith("market ")).toBe(true);
+		expect([
+			"ok",
+			"unchanged",
+			"plugin-newer",
+			"pull-request",
+			"needs-consent",
+			"stale",
+			"partial",
+			"failed",
+		]).toContain(result.outcome);
+		expect(typeof result.message).toBe("string");
+		if (result.planId !== undefined)
+			expect(typeof result.planId).toBe("string");
+		if (result.stale !== undefined) expect(typeof result.stale).toBe("boolean");
+		if (result.target !== undefined)
+			expect(["push-or-pr", "fork-pr"]).toContain(result.target);
+		if (result.error !== undefined) {
+			expect(typeof result.error.message).toBe("string");
+			expect([
+				"gh-missing",
+				"gh-auth",
+				"no-access",
+				"no-network",
+				"conflict",
+				"no-base",
+				"name-taken",
+				"not-found",
+				"ambiguous",
+				"invalid-name",
+				"external-plugin",
+				"claude-missing",
+				"validate-failed",
+				"locked",
+				"not-company",
+				"fork-not-allowed",
+				"install-failed",
+				"plan-changed",
+				"stale",
+				"timeout",
+				"signing-timeout",
+				"other",
+			]).toContain(result.error.code);
+		}
+		for (const file of result.files ?? []) {
+			expect(typeof file.path).toBe("string");
+			expect(["added", "modified", "deleted"]).toContain(file.change);
+		}
+		for (const file of result.notPublished ?? []) {
+			expect(typeof file.path).toBe("string");
+			expect([
+				"dotfile",
+				"node_modules",
+				"symlink",
+				"ignored-here",
+				"ignored-by-marketplace",
+			]).toContain(file.reason);
+		}
+		for (const row of result.installs ?? []) {
+			expect(["user", "project", "local"]).toContain(row.scope);
+			expect(["updated", "unchanged", "failed"]).toContain(row.status);
+			expect(row.from === null || typeof row.from === "string").toBe(true);
+			expect(row.to === null || typeof row.to === "string").toBe(true);
+			if (row.loaded !== undefined)
+				expect(row.loaded === null || typeof row.loaded === "string").toBe(
+					true,
+				);
+		}
+		if (result.localCopy !== undefined) {
+			expect(["project", "user"]).toContain(result.localCopy.scope);
+			expect(["removed", "kept", "created"]).toContain(result.localCopy.action);
+			expect(typeof result.localCopy.name).toBe("string");
+		}
+		for (const row of result.marketplaces ?? []) {
+			expect(row.scope).toBe("user");
+			expect(typeof row.name).toBe("string");
+			expect(typeof row.repo).toBe("string");
+			expect(Array.isArray(row.plugins)).toBe(true);
+		}
+		for (const row of result.skills ?? []) {
+			expect(typeof row.skill).toBe("string");
+			expect(["project", "user"]).toContain(row.from);
+			expect(row.owner === null || typeof row.owner === "string").toBe(true);
+			expect([
+				"edited",
+				"same",
+				"plugin-newer",
+				"conflict",
+				"no-base",
+				"not-checked",
+				"ambiguous",
+				"not-owned",
+			]).toContain(row.state);
+		}
+		expect(Array.isArray(result.steps)).toBe(true);
+		for (const step of result.steps) {
+			expect(typeof step.id).toBe("string");
+			expect(["done", "skipped", "failed"]).toContain(step.status);
+		}
+		return { ...r, result };
+	}
+	ok(args: string[], cwd = this.project): MarketRun {
+		const r = this.market(args, cwd);
+		if (r.code !== 0)
+			throw new Error(
+				`Setup operation failed ${args.join(" ")}\n${r.out}\n${r.err}`,
+			);
+		return r;
+	}
+	tool(
+		tool: "claude" | "gh",
+		args: string[],
+		cwd = this.project,
+	): ProcessResult {
+		return this.run([join(this.bin, tool), ...args], cwd);
+	}
+	seed(options: SeedOptions = {}): Repo {
+		const name = options.name ?? "acme";
+		const slug = options.slug ?? "acme/market";
+		const bare = join(this.root, "remotes", `${slug}.git`);
+		const author = join(this.root, `author-${name}`);
+		mkdirSync(dirname(bare), { recursive: true });
+		this.git(this.root, "init", "--bare", "-b", "main", bare);
+		this.git(this.root, "clone", bare, author);
+		const repo = {
+			name,
+			slug,
+			bare,
+			author,
+			url: `https://github.com/${slug}.git`,
+		};
+		if (options.empty) return repo;
+		write(join(author, "README.md"), "Existing repository documentation\n");
+		if (!options.noManifest) {
+			const version =
+				options.entryVersion === undefined ? "0.3.1" : options.entryVersion;
+			writeJson(join(author, MANIFEST), {
+				name,
+				owner: { name: slug.split("/")[0] },
+				metadata: {
+					description: "Company tools",
+					...(options.marker === false
+						? {}
+						: { magus: { schema: 1, company: true } }),
+				},
+				plugins: [
+					{
+						name: PLUGIN,
+						source: `./plugins/${PLUGIN}`,
+						description: "Reviews changes.",
+						...(version === null ? {} : { version }),
+					},
+				],
+			});
+			if (!options.noPluginJson) {
+				const v =
+					options.pluginVersion === undefined ? "0.3.1" : options.pluginVersion;
+				writeJson(join(author, PLUGIN_MANIFEST), {
+					name: PLUGIN,
+					description: "Reviews changes.",
+					...(v === null ? {} : { version: v }),
+					...(options.dependencies
+						? { dependencies: options.dependencies }
+						: {}),
+				});
+			}
+			write(join(author, SKILL_REL), SKILL);
+		}
+		for (const [file, bytes] of Object.entries(options.extras ?? {}))
+			write(join(author, file), bytes);
+		this.push(repo, "seed marketplace");
+		return repo;
+	}
+	push(repo: Repo, message = "teammate change"): string {
+		this.git(repo.author, "add", "-A");
+		this.git(repo.author, "commit", "-m", message);
+		this.git(repo.author, "push", "origin", "HEAD:main");
+		return this.head(repo);
+	}
+	head(repo: Repo, ref = "HEAD"): string {
+		return this.git(this.root, "--git-dir", repo.bare, "rev-parse", ref);
+	}
+	remoteFile(repo: Repo, file: string, ref = "HEAD"): string {
+		return this.git(
+			this.root,
+			"--git-dir",
+			repo.bare,
+			"show",
+			`${ref}:${file}`,
+		);
+	}
+	remoteBytes(repo: Repo, file: string, ref = "HEAD"): string {
+		const r = this.run(
+			[
+				this.gitBinary,
+				"--git-dir",
+				repo.bare,
+				"cat-file",
+				"blob",
+				`${ref}:${file}`,
+			],
+			this.root,
+		);
+		if (r.code !== 0) throw new Error(`Cannot read remote blob\n${r.err}`);
+		return r.out;
+	}
+	remoteJson<T = Record<string, any>>(
+		repo: Repo,
+		file: string,
+		ref = "HEAD",
+	): T {
+		return JSON.parse(this.remoteFile(repo, file, ref)) as T;
+	}
+	remotePaths(repo: Repo, ref = "HEAD"): string[] {
+		return this.git(
+			this.root,
+			"--git-dir",
+			repo.bare,
+			"ls-tree",
+			"-r",
+			"--name-only",
+			ref,
+		)
+			.split("\n")
+			.filter(Boolean);
+	}
+	clone(repo: Repo): string {
+		return join(this.config, "plugins", "marketplaces", repo.name);
+	}
+	working(repo: Repo): string {
+		return join(this.config, "magus-market", repo.name);
+	}
+	register(
+		repo: Repo,
+		opts: {
+			trust?: boolean;
+			sourceType?: "github" | "git";
+			source?: string;
+		} = {},
+	): void {
+		const r = this.tool("claude", [
+			"plugin",
+			"marketplace",
+			"add",
+			opts.source ?? repo.slug,
+			"--scope",
+			"user",
+		]);
+		if (r.code !== 0) throw new Error(`Stand-in registration failed\n${r.err}`);
+		if (opts.sourceType === "github")
+			this.registration(repo, {
+				source: "github",
+				repo: opts.source ?? repo.slug,
+			});
+		if (opts.trust !== false) {
+			const file = join(this.config, "magus-market", "trusted.json");
+			const list = existsSync(file)
+				? readJson(file)
+				: { schema: 1, marketplaces: {} };
+			list.marketplaces[repo.name] = { source: repo.slug, via: "connect" };
+			writeJson(file, list);
+		}
+		this.rememberOwned();
+	}
+	registration(repo: Repo, source: Record<string, unknown>): void {
+		const file = join(this.config, "plugins", "known_marketplaces.json");
+		const entries = existsSync(file) ? readJson(file) : {};
+		entries[repo.name] = {
+			...entries[repo.name],
+			source,
+			installLocation: this.clone(repo),
+			lastUpdated: new Date().toISOString(),
+		};
+		writeJson(file, entries);
+		this.rememberOwned();
+	}
+	install(
+		id = ID,
+		scope: "user" | "project" | "local" = "user",
+		cwd = this.project,
+	): void {
+		const r = this.tool(
+			"claude",
+			["plugin", "install", id, "--scope", scope],
+			cwd,
+		);
+		if (r.code !== 0) throw new Error(`Stand-in install failed\n${r.err}`);
+		this.rememberOwned();
+	}
+	version(id = ID, scope = "user", cwd = this.project): string | null {
+		const file = join(this.config, "plugins", "installed_plugins.json");
+		if (!existsSync(file)) return null;
+		const state = readJson(file);
+		return (
+			state.plugins[id]?.find(
+				(r: Record<string, string>) =>
+					r.scope === scope && (scope === "user" || r.projectPath === cwd),
+			)?.version ?? null
+		);
+	}
+	folder(from: "project" | "global" = "project", name = "review"): string {
+		return join(
+			from === "global" ? this.config : join(this.project, ".claude"),
+			"skills",
+			name,
+		);
+	}
+	edit(args: string[] = []): void {
+		this.ok(["skill", "edit", "review", "--plugin", ID, "--yes", ...args]);
+	}
+	async prepared(): Promise<Repo> {
+		const repo = this.seed();
+		this.register(repo);
+		this.install();
+		this.edit();
+		write(join(this.folder(), "SKILL.md"), EDITED);
+		return repo;
+	}
+	profile(
+		plugins: Record<string, string | boolean> = { [ID]: "latest" },
+		marketplaces: Record<string, unknown> = {
+			acme: { source: "github", repo: "acme/market" },
+		},
+		cwd = this.project,
+	): void {
+		writeJson(join(cwd, ".claude", "profiles.json"), {
+			version: 2,
+			profiles: { team: { name: "Team", plugins, marketplaces } },
+		});
+	}
+	active(skills: Record<string, string> = {}): void {
+		writeJson(join(this.project, ".claude", "profiles", "active.json"), {
+			version: 1,
+			profile: "team",
+			files: {},
+			skills,
+		});
+	}
+	snapshot(): Record<string, string> {
+		const roots = [
+			this.home,
+			this.config,
+			this.project,
+			this.temp,
+			this.env.XDG_CACHE_HOME!,
+			this.env.XDG_CONFIG_HOME!,
+		];
+		const result: Record<string, string> = {};
+		const bunCache = join(this.env.XDG_CACHE_HOME!, "bun");
+		const visit = (file: string) => {
+			// Bun owns its runtime cache; keep checking all feature state around it.
+			if (file === bunCache) return;
+			const stat = lstatSync(file);
+			const key = relative(this.root, file);
+			if (stat.isSymbolicLink()) result[key] = `link:${readlinkSync(file)}`;
+			else if (stat.isDirectory()) {
+				result[key] = "directory";
+				for (const name of readdirSync(file).sort()) visit(join(file, name));
+			} else
+				result[key] =
+					`${createHash("sha256").update(readFileSync(file)).digest("hex")}:${stat.mode & 0o777}`;
+		};
+		for (const root of new Set(roots)) visit(root);
+		return result;
+	}
+	journal(): JournalEvent[] {
+		return readFileSync(join(this.control, "journal.jsonl"), "utf8")
+			.trim()
+			.split("\n")
+			.filter(Boolean)
+			.map((line) => JSON.parse(line));
+	}
+	private ownedFiles(): string[] {
+		const configFiles = [
+			join(this.config, "plugins", "known_marketplaces.json"),
+			join(this.config, "plugins", "installed_plugins.json"),
+		].filter(existsSync);
+		const settings = [
+			...new Set([this.home, this.config, this.project]),
+		].flatMap((root) =>
+			filesUnder(root).filter(
+				(file) =>
+					["settings.json", "settings.local.json"].includes(basename(file)) &&
+					!file.includes(join("plugins", "marketplaces")) &&
+					!file.includes(join("magus-market", "")),
+			),
+		);
+		return [
+			...new Set([
+				...configFiles,
+				...settings,
+				...filesUnder(join(this.config, "plugins", "cache")),
+			]),
+		].sort();
+	}
+	rememberOwned(): void {
+		this.baseline = new Map(
+			this.ownedFiles().map((file) => [
+				file,
+				readFileSync(file).toString("base64"),
+			]),
+		);
+		// A setup write is the new baseline, so subsequent product writes cannot
+		// be legitimised by an earlier provider event.
+		write(join(this.control, "journal.jsonl"), "");
+	}
+	/** TEST-50 REQ-4 REQ-19: compare actual bytes, never private writer calls. */
+	assertOwned(): void {
+		const expected = new Map(this.baseline);
+		for (const event of this.journal()) {
+			if (event.tool !== "claude") continue;
+			expect(event.argv.slice(0, 3)).not.toEqual([
+				"plugin",
+				"marketplace",
+				"update",
+			]);
+			expect(event.argv.slice(0, 2)).not.toEqual(["plugin", "uninstall"]);
+			for (const item of event.writes) {
+				if (item.bytes === null) expected.delete(item.path);
+				else expected.set(item.path, item.bytes);
+			}
+		}
+		const paths = new Set([...this.ownedFiles(), ...expected.keys()]);
+		for (const file of paths) {
+			const actual = existsSync(file)
+				? readFileSync(file).toString("base64")
+				: undefined;
+			expect({ path: relative(this.root, file), bytes: actual }).toEqual({
+				path: relative(this.root, file),
+				bytes: expected.get(file),
+			});
+		}
+	}
+	protect(repo: Repo, denied = false): void {
+		const hook = join(repo.bare, "hooks", "update");
+		write(
+			hook,
+			`#!${process.execPath} --no-env-file\nif (${denied ? "true" : "process.argv[2] === 'refs/heads/main'"}) {process.stderr.write(${JSON.stringify(
+				denied
+					? "Permission to acme/market denied to teammate.\\n"
+					: "GH006: Protected branch update failed for refs/heads/main.\\n",
+			)}); process.exit(1); }\n`,
+		);
+		chmodSync(hook, 0o755);
+	}
+	close(): void {
+		rmSync(this.root, { recursive: true, force: true });
+	}
+}
+
+export function expectFailure(
+	run: MarketRun,
+	code: number,
+	error: string,
+): void {
+	expect({
+		exit: run.code,
+		outcome: run.result.outcome,
+		error: run.result.error?.code,
+	}).toEqual({
+		exit: code,
+		outcome:
+			code === 3 ? (error === "stale" ? "stale" : "needs-consent") : "failed",
+		error,
+	});
+}
+
+export function expectPublished(
+	f: MarketFixture,
+	repo: Repo,
+	version = "0.3.2",
+	bytes = EDITED,
+): void {
+	expect(
+		f
+			.remoteJson(repo, MANIFEST)
+			.plugins.find((p: Record<string, string>) => p.name === PLUGIN)?.version,
+	).toBe(version);
+	expect(f.remoteJson(repo, PLUGIN_MANIFEST).version).toBe(version);
+	expect(f.remoteBytes(repo, SKILL_REL)).toBe(bytes);
+}