magus-cli 7.12.2 → 7.14.0

package/src/__tests__/market-r2-plugin-publish.test.ts

@@ -0,0 +1,568 @@
+import { afterEach, expect, test } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { MarketResult } from "../services/market-types.js";
+import {
+	EDITED,
+	ID,
+	MANIFEST,
+	MarketFixture,
+	PLUGIN,
+	PLUGIN_MANIFEST,
+	REMOTE_EDIT,
+	type Repo,
+	SKILL,
+	SKILL_REL,
+	write,
+} from "./market-fixture.js";
+
+const LINT =
+	"---\nname: lint\ndescription: Checks code style.\n---\nOriginal lint rules.\n";
+const LINT_EDITED = `${LINT}\nCheck imports too.\n`;
+const STEADY = "---\nname: steady\n---\nStable instructions.\n";
+const LINT_REL = "plugins/review-kit/skills/lint/SKILL.md";
+const STEADY_REL = "plugins/review-kit/skills/steady/SKILL.md";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+
+function seedSkills(world: MarketFixture, install = true): Repo {
+	const repo = world.seed({
+		extras: { [LINT_REL]: LINT, [STEADY_REL]: STEADY },
+	});
+	world.register(repo);
+	if (install) world.install();
+	return repo;
+}
+
+function editSkill(
+	world: MarketFixture,
+	skill: string,
+	bytes?: string,
+	to: "project" | "global" = "project",
+): void {
+	world.ok(["skill", "edit", skill, "--plugin", ID, "--to", to, "--yes"]);
+	if (bytes !== undefined)
+		write(join(world.folder(to, skill), "SKILL.md"), bytes);
+}
+
+function assertForceGuidance(result: MarketResult, names: string[]): void {
+	for (const name of names) {
+		expect(
+			result.plan?.some(
+				(line) =>
+					line.includes(`magus market publish ${name}`) &&
+					line.includes("--force"),
+			),
+		).toBe(true);
+	}
+}
+
+function assertOneCommit(
+	world: MarketFixture,
+	repo: Repo,
+	old: string,
+	expectedPaths: string[],
+): void {
+	expect(
+		world.git(
+			world.root,
+			"--git-dir",
+			repo.bare,
+			"rev-list",
+			"--count",
+			`${old}..HEAD`,
+		),
+	).toBe("1");
+	expect(
+		world
+			.git(
+				world.root,
+				"--git-dir",
+				repo.bare,
+				"diff",
+				"--name-only",
+				old,
+				"HEAD",
+			)
+			.split("\n")
+			.sort(),
+	).toEqual([...expectedPaths].sort());
+}
+
+test("R3.2 R4.5 TEST-21 approved plugin publish sends both edits in one patch commit and settles each copy", () => {
+	f = new MarketFixture();
+	const repo = seedSkills(f);
+	editSkill(f, "review", EDITED);
+	editSkill(f, "lint", LINT_EDITED);
+	editSkill(f, "steady");
+	const old = f.head(repo);
+	const before = f.snapshot();
+
+	const plan = f.market(["publish", "--plugin", ID]);
+
+	expect(plan.code).toBe(3);
+	expect(plan.result.outcome).toBe("needs-consent");
+	expect(plan.result.version).toEqual({ from: "0.3.1", to: "0.3.2" });
+	expect(plan.result.plan?.join("\n")).toContain("review");
+	expect(plan.result.plan?.join("\n")).toContain("lint");
+	expect(typeof plan.result.planId).toBe("string");
+	expect(f.head(repo)).toBe(old);
+	expect(f.snapshot()).toEqual(before);
+
+	const applied = f.market([
+		"publish",
+		"--plugin",
+		ID,
+		`--yes=${plan.result.planId}`,
+	]);
+
+	expect({ exit: applied.code, outcome: applied.result.outcome }).toEqual({
+		exit: 0,
+		outcome: "ok",
+	});
+	assertOneCommit(f, repo, old, [
+		MANIFEST,
+		PLUGIN_MANIFEST,
+		SKILL_REL,
+		LINT_REL,
+	]);
+	expect(applied.result.commit).toBe(f.head(repo));
+	expect(f.remoteBytes(repo, SKILL_REL)).toBe(EDITED);
+	expect(f.remoteBytes(repo, LINT_REL)).toBe(LINT_EDITED);
+	expect(f.remoteBytes(repo, STEADY_REL)).toBe(STEADY);
+	expect(
+		f
+			.remoteJson(repo, MANIFEST)
+			.plugins.find((plugin: { name: string }) => plugin.name === PLUGIN)
+			?.version,
+	).toBe("0.3.2");
+	expect(f.remoteJson(repo, PLUGIN_MANIFEST).version).toBe("0.3.2");
+	expect(f.version()).toBe("0.3.2");
+	expect(
+		applied.result.installs?.map(({ scope, from, to, loaded, status }) => ({
+			scope,
+			from,
+			to,
+			loaded,
+			status,
+		})),
+	).toEqual([
+		{
+			scope: "user",
+			from: "0.3.1",
+			to: "0.3.2",
+			loaded: "0.3.2",
+			status: "updated",
+		},
+	]);
+	expect(applied.result.localCopy).toBeUndefined();
+	expect(applied.result.localCopies).toHaveLength(2);
+	expect(applied.result.localCopies).toContainEqual({
+		scope: "project",
+		name: "review",
+		action: "removed",
+	});
+	expect(applied.result.localCopies).toContainEqual({
+		scope: "project",
+		name: "lint",
+		action: "removed",
+	});
+	expect(existsSync(f.folder("project", "review"))).toBe(false);
+	expect(existsSync(f.folder("project", "lint"))).toBe(false);
+	expect(
+		readFileSync(join(f.folder("project", "steady"), "SKILL.md"), "utf8"),
+	).toBe(STEADY);
+	const steps = applied.result.steps.map((step) => step.id);
+	expect(steps.slice(0, 2).sort()).toEqual(["replace:lint", "replace:review"]);
+	expect(steps.slice(2)).toEqual([
+		"bump",
+		"validate",
+		"commit",
+		"deliver",
+		"install",
+		"local-copy",
+	]);
+	f.assertOwned();
+}, 90_000);
+
+test.each([
+	"keep-local",
+	"unpublished",
+	"not-installed",
+	"mixed-scopes",
+	"install-failed",
+] as const)(
+	"R3.2 TEST-22 plugin publish settles all copies independently: %s",
+	(mode) => {
+		f = new MarketFixture(true);
+		const repo = seedSkills(f, mode !== "not-installed");
+		editSkill(f, "review", EDITED);
+		editSkill(
+			f,
+			"lint",
+			LINT_EDITED,
+			mode === "mixed-scopes" ? "global" : "project",
+		);
+		if (mode === "unpublished")
+			write(join(f.folder(), ".env"), "PRIVATE=keep-here\n");
+		if (mode === "install-failed")
+			f.setModes({ failInstall: "Install did not finish" });
+		const old = f.head(repo);
+
+		const result = f.market([
+			"publish",
+			"--plugin",
+			ID,
+			"--yes",
+			...(mode === "keep-local" ? ["--keep-local"] : []),
+		]);
+
+		expect(result.code).toBe(mode === "install-failed" ? 1 : 0);
+		if (mode === "install-failed") {
+			expect(result.result.outcome).toBe("partial");
+			expect(result.result.error?.code).toBe("install-failed");
+			expect(result.result.installs).toHaveLength(1);
+			expect(
+				result.result.installs?.every((row) => row.status === "failed"),
+			).toBe(true);
+		}
+		assertOneCommit(f, repo, old, [
+			MANIFEST,
+			PLUGIN_MANIFEST,
+			SKILL_REL,
+			LINT_REL,
+		]);
+		expect(result.result.localCopies).toHaveLength(2);
+		for (const name of ["review", "lint"]) {
+			const kept =
+				mode === "keep-local" ||
+				mode === "not-installed" ||
+				mode === "install-failed" ||
+				(mode === "unpublished" && name === "review");
+			const scope =
+				mode === "mixed-scopes" && name === "lint" ? "user" : "project";
+			const copy = result.result.localCopies?.find(
+				(copy) => copy.name === name,
+			);
+			expect(copy?.scope).toBe(scope);
+			expect(copy?.action).toBe(kept ? "kept" : "removed");
+			expect(
+				existsSync(f.folder(scope === "user" ? "global" : "project", name)),
+			).toBe(kept);
+			if (kept) expect(copy?.reason?.length).toBeGreaterThan(0);
+		}
+		if (mode === "unpublished") {
+			expect(readFileSync(join(f.folder(), ".env"), "utf8")).toBe(
+				"PRIVATE=keep-here\n",
+			);
+			expect(f.remotePaths(repo)).not.toContain(
+				"plugins/review-kit/skills/review/.env",
+			);
+		}
+		if (mode === "not-installed") expect(f.version()).toBeNull();
+		else
+			expect(f.version()).toBe(mode === "install-failed" ? "0.3.1" : "0.3.2");
+		if (mode === "keep-local" || mode === "not-installed") {
+			write(join(f.folder(), "SKILL.md"), `${EDITED}\nAnother tracked edit.\n`);
+			const tracked = f.market(["publish", "--plugin", ID]);
+			expect(tracked.code).toBe(3);
+			expect(tracked.result.outcome).toBe("needs-consent");
+			expect(tracked.result.error).toBeUndefined();
+			expect(f.head(repo)).toBe(result.result.commit!);
+		}
+		f.assertOwned();
+	},
+	90_000,
+);
+
+test.each(["protected", "fork"] as const)(
+	"R3.2 TEST-23 %s delivery puts both skill edits in one PR commit and keeps copies",
+	(mode) => {
+		f = new MarketFixture();
+		const repo = seedSkills(f);
+		editSkill(f, "review", EDITED);
+		editSkill(f, "lint", LINT_EDITED);
+		if (mode === "protected") f.protect(repo);
+		else f.setModes({ push: false });
+		const old = f.head(repo);
+
+		const result = f.market(["publish", "--plugin", ID, "--yes"]);
+
+		expect({ exit: result.code, outcome: result.result.outcome }).toEqual({
+			exit: 0,
+			outcome: "pull-request",
+		});
+		expect(result.result.pullRequest).toMatch(/\/pull\/17$/);
+		expect(typeof result.result.commit).toBe("string");
+		const destination =
+			mode === "protected"
+				? repo.bare
+				: join(f.root, "remotes", "teammate", "market-renamed.git");
+		const commit = result.result.commit!;
+		expect(
+			f.git(
+				f.root,
+				"--git-dir",
+				destination,
+				"rev-list",
+				"--count",
+				`${old}..${commit}`,
+			),
+		).toBe("1");
+		expect(
+			f.git(f.root, "--git-dir", destination, "show", `${commit}:${SKILL_REL}`),
+		).toBe(EDITED.trimEnd());
+		expect(
+			f.git(f.root, "--git-dir", destination, "show", `${commit}:${LINT_REL}`),
+		).toBe(LINT_EDITED.trimEnd());
+		expect(f.head(repo)).toBe(old);
+		expect(f.version()).toBe("0.3.1");
+		expect(
+			result.result.installs?.some((install) => install.status === "updated") ??
+				false,
+		).toBe(false);
+		expect(result.result.localCopies).toHaveLength(2);
+		for (const name of ["review", "lint"]) {
+			const copy = result.result.localCopies?.find(
+				(copy) => copy.name === name,
+			);
+			expect(copy?.action).toBe("kept");
+			expect(copy?.reason?.length).toBeGreaterThan(0);
+			expect(existsSync(f.folder("project", name))).toBe(true);
+		}
+		f.assertOwned();
+	},
+	90_000,
+);
+
+test("R3.3 TEST-24 mixed plugin publish excludes both unknown-origin and conflicting skills with individual force guidance", () => {
+	f = new MarketFixture();
+	const repo = seedSkills(f);
+	editSkill(f, "review", EDITED);
+	write(join(f.folder("project", "lint"), "SKILL.md"), LINT_EDITED);
+	editSkill(f, "steady", `${STEADY}\nLocal steady edit.\n`);
+	const remoteSteady = `${STEADY}\nRemote steady edit.\n`;
+	write(join(repo.author, STEADY_REL), remoteSteady);
+	f.push(repo);
+	f.ok(["fetch", "acme"]);
+	const old = f.head(repo);
+	const before = f.snapshot();
+
+	const plan = f.market(["publish", "--plugin", ID]);
+
+	expect(plan.code).toBe(3);
+	assertForceGuidance(plan.result, ["lint", "steady"]);
+	expect(f.snapshot()).toEqual(before);
+
+	const result = f.market([
+		"publish",
+		"--plugin",
+		ID,
+		`--yes=${plan.result.planId}`,
+	]);
+
+	expect(result.code).toBe(0);
+	assertOneCommit(f, repo, old, [MANIFEST, PLUGIN_MANIFEST, SKILL_REL]);
+	expect(f.remoteBytes(repo, SKILL_REL)).toBe(EDITED);
+	expect(f.remoteBytes(repo, LINT_REL)).toBe(LINT);
+	expect(f.remoteBytes(repo, STEADY_REL)).toBe(remoteSteady);
+	expect(result.result.localCopies?.map((copy) => copy.name)).toEqual([
+		"review",
+	]);
+	expect(
+		readFileSync(join(f.folder("project", "lint"), "SKILL.md"), "utf8"),
+	).toBe(LINT_EDITED);
+	expect(
+		readFileSync(join(f.folder("project", "steady"), "SKILL.md"), "utf8"),
+	).toBe(`${STEADY}\nLocal steady edit.\n`);
+	f.assertOwned();
+}, 90_000);
+
+test.each(["no copies", "same copies", "plugin newer"] as const)(
+	"R3.3 TEST-25 plugin publish with %s is unchanged and read-only",
+	(mode) => {
+		f = new MarketFixture();
+		const repo = seedSkills(f);
+		if (mode !== "no copies") editSkill(f, "review");
+		if (mode === "plugin newer") {
+			write(join(repo.author, SKILL_REL), REMOTE_EDIT);
+			f.push(repo);
+			f.ok(["fetch", "acme"]);
+		}
+		const before = f.snapshot();
+		const head = f.head(repo);
+
+		const result = f.market(["publish", "--plugin", ID]);
+
+		expect({ exit: result.code, outcome: result.result.outcome }).toEqual({
+			exit: 0,
+			outcome: "unchanged",
+		});
+		expect(result.result.steps).toEqual([]);
+		expect(f.head(repo)).toBe(head);
+		expect(f.snapshot()).toEqual(before);
+	},
+	60_000,
+);
+
+test.each([
+	{ state: "no-base", from: "project" },
+	{ state: "no-base", from: "global" },
+	{ state: "conflict", from: "project" },
+	{ state: "conflict", from: "global" },
+] as const)(
+	"R3.3 TEST-26 only $state copies in $from fail with the correct exit and force command, without writes",
+	({ state, from }) => {
+		f = new MarketFixture(true);
+		const repo = seedSkills(f);
+		if (state === "no-base") {
+			write(join(f.folder(from), "SKILL.md"), EDITED);
+		} else {
+			editSkill(f, "review", EDITED, from);
+			write(join(repo.author, SKILL_REL), REMOTE_EDIT);
+			f.push(repo);
+			f.ok(["fetch", "acme"]);
+		}
+		const before = f.snapshot();
+		const head = f.head(repo);
+
+		const result = f.market(["publish", "--plugin", ID]);
+
+		expect({
+			exit: result.code,
+			outcome: result.result.outcome,
+			error: result.result.error?.code,
+		}).toEqual({
+			exit: 1,
+			outcome: "failed",
+			error: state,
+		});
+		assertForceGuidance(result.result, ["review"]);
+		if (from === "global") {
+			expect(
+				result.result.plan?.some(
+					(line) =>
+						line.includes("magus market publish review") &&
+						line.includes("--force") &&
+						/--from(?:=|\s+)global/.test(line),
+				),
+			).toBe(true);
+		}
+		expect(f.head(repo)).toBe(head);
+		expect(f.snapshot()).toEqual(before);
+	},
+	60_000,
+);
+
+test("R3.3 TEST-27 the same skill edited in PROJECT and USER refuses ambiguous plugin publish", () => {
+	f = new MarketFixture(true);
+	const repo = seedSkills(f);
+	editSkill(f, "review", EDITED);
+	editSkill(f, "review", `${EDITED}\nDifferent USER edit.\n`, "global");
+	const before = f.snapshot();
+	const head = f.head(repo);
+
+	const result = f.market(["publish", "--plugin", ID]);
+
+	expect(result.code).toBe(2);
+	expect(result.result.error?.code).toBe("ambiguous");
+	expect(f.head(repo)).toBe(head);
+	expect(f.snapshot()).toEqual(before);
+}, 60_000);
+
+test.each([
+	{ args: ["publish", "--plugin", ID, "--force"] },
+	{ args: ["publish", "--plugin", ID, "--from", "project"] },
+	{ args: ["publish", "--plugin"] },
+])(
+	"R3.3 TEST-28 plugin-wide publish rejects skill-only or missing arguments: $args",
+	({ args }) => {
+		f = new MarketFixture();
+		const before = f.snapshot();
+
+		const result = f.market(args);
+
+		expect(result.code).toBe(2);
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test("R3.2 R4.5 TEST-29 plugin dry-run and unconsented plan show both skills without any writes", () => {
+	f = new MarketFixture();
+	const repo = seedSkills(f);
+	editSkill(f, "review", EDITED);
+	editSkill(f, "lint", LINT_EDITED);
+	const before = f.snapshot();
+	const old = f.head(repo);
+
+	const dry = f.market(["publish", "--plugin", ID, "--dry-run"]);
+	const plan = f.market(["publish", "--plugin", ID]);
+
+	expect(dry.code).toBe(0);
+	expect(plan.code).toBe(3);
+	expect(plan.result.outcome).toBe("needs-consent");
+	expect(typeof dry.result.planId).toBe("string");
+	expect(plan.result.planId).toBe(dry.result.planId);
+	expect(dry.result.plan?.join("\n")).toContain("review");
+	expect(dry.result.plan?.join("\n")).toContain("lint");
+	expect(f.head(repo)).toBe(old);
+	expect(f.snapshot()).toEqual(before);
+}, 60_000);
+
+test.each(["source", "keep-local", "another skill"] as const)(
+	"R4.5 TEST-29 changing %s revokes a plugin-wide publish plan before push",
+	(changed) => {
+		f = new MarketFixture();
+		const repo = seedSkills(f);
+		editSkill(f, "review", EDITED);
+		editSkill(f, "lint", LINT_EDITED);
+		const plan = f.market(["publish", "--plugin", ID]);
+		expect(plan.code).toBe(3);
+		if (changed === "source")
+			write(
+				join(f.folder("project", "lint"), "SKILL.md"),
+				`${LINT_EDITED}\nLater edit.\n`,
+			);
+		if (changed === "another skill")
+			editSkill(f, "steady", `${STEADY}\nNew edit.\n`);
+		const old = f.head(repo);
+		const review = readFileSync(join(f.folder(), "SKILL.md"), "utf8");
+		const lint = readFileSync(
+			join(f.folder("project", "lint"), "SKILL.md"),
+			"utf8",
+		);
+
+		const result = f.market([
+			"publish",
+			"--plugin",
+			ID,
+			`--yes=${plan.result.planId}`,
+			...(changed === "keep-local" ? ["--keep-local"] : []),
+		]);
+
+		expect({
+			exit: result.code,
+			outcome: result.result.outcome,
+			error: result.result.error?.code,
+		}).toEqual({
+			exit: 3,
+			outcome: "needs-consent",
+			error: "plan-changed",
+		});
+		expect(result.result.planId).not.toBe(plan.result.planId);
+		expect(result.result.plan?.length).toBeGreaterThan(0);
+		expect(f.head(repo)).toBe(old);
+		expect(f.version()).toBe("0.3.1");
+		expect(readFileSync(join(f.folder(), "SKILL.md"), "utf8")).toBe(review);
+		expect(
+			readFileSync(join(f.folder("project", "lint"), "SKILL.md"), "utf8"),
+		).toBe(lint);
+		f.assertOwned();
+	},
+	90_000,
+);

package/src/__tests__/market-r2-routing.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, expect, test } from "bun:test";
+import { join } from "node:path";
+import type { RouteOutcome } from "../cli/router.js";
+import type { MarketOverviewEntry } from "../services/market-ops.js";
+import type { MarketResult } from "../services/market-types.js";
+import { MarketFixture, sourceModule, write } from "./market-fixture.js";
+
+let f: MarketFixture | undefined;
+afterEach(() => {
+	f?.close();
+	f = undefined;
+});
+
+test("R2.1 R2.4 TEST-16 edit selects the market app and headless main names the command-line help", () => {
+	f = new MarketFixture();
+	const before = f.snapshot();
+
+	const route = f.value<RouteOutcome>(
+		`const {route}=await import(${JSON.stringify(sourceModule("cli/router.js"))});console.log(JSON.stringify(await route(['edit'],'1.2.3')));`,
+	);
+	const result = f.cli(["edit"]);
+
+	expect(route).toEqual({ handled: false, launchTui: true, app: "market" });
+	expect(result.code).toBe(2);
+	expect(result.out + result.err).toContain("magus market --help");
+	expect(result.out + result.err).toContain("magus edit");
+	expect(result.out + result.err).toMatch(/needs a terminal/i);
+	expect(f.snapshot()).toEqual(before);
+}, 30_000);
+
+test.each(["--help", "-h"])(
+	"R2.2 TEST-17 edit %s prints edit-specific help, not global help",
+	(flag) => {
+		f = new MarketFixture();
+		const before = f.snapshot();
+
+		const result = f.cli(["edit", flag]);
+
+		expect(result.code).toBe(0);
+		expect(result.out).toContain("Usage: magus edit");
+		expect(result.out).toContain("company marketplace");
+		expect(result.out).toContain("magus market --help");
+		expect(result.out).toContain("whole plugin as one new version");
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test.each(["list", "publish", "anything", "--unknown", "--json"])(
+	"R2.2 TEST-18 edit %s refuses arguments with market-verb guidance",
+	(argument) => {
+		f = new MarketFixture();
+		const before = f.snapshot();
+
+		const route = f.value<RouteOutcome>(
+			`const {route}=await import(${JSON.stringify(sourceModule("cli/router.js"))});console.log(JSON.stringify(await route(${JSON.stringify(["edit", argument])},'1.2.3')));`,
+		);
+		const result = f.cli(["edit", argument]);
+
+		expect(route).toEqual({ handled: true, launchTui: false, exitCode: 2 });
+		expect(result.code).toBe(2);
+		expect(result.err).toContain("magus market <verb>");
+		expect(result.err).toContain("magus market --help");
+		expect(f.snapshot()).toEqual(before);
+	},
+	30_000,
+);
+
+test("R2.3 TEST-19 bare market handles help without launching; market list still dispatches", () => {
+	f = new MarketFixture();
+	const before = f.snapshot();
+
+	const routes = f.value<RouteOutcome[]>(
+		`const {route}=await import(${JSON.stringify(sourceModule("cli/router.js"))});console.log(JSON.stringify([await route(['market'],'1.2.3'),await route(['market','list'],'1.2.3')]));`,
+	);
+	const result = f.cli(["market"]);
+
+	expect(routes).toEqual([
+		{ handled: true, launchTui: false, exitCode: 0 },
+		{ handled: true, launchTui: false, exitCode: 0 },
+	]);
+	expect(result.code).toBe(0);
+	expect(result.out).toContain("Usage: magus market <command> [args]");
+	expect(result.out).toContain("Open the screen with `magus edit`.");
+	expect(result.out).toContain("--company");
+	expect(result.out).toContain("--create-plugin");
+	expect(result.out).toContain("plugin add");
+	expect(result.out).toContain("publish --plugin");
+	expect(f.snapshot()).toEqual(before);
+}, 30_000);
+
+test.each([false, true])(
+	"R2.4 R4.5 TEST-20 opening-data services are read-only; working clone=%s",
+	(working) => {
+		f = new MarketFixture(true);
+		const repo = f.seed();
+		f.register(repo);
+		if (working) f.ok(["fetch", "acme"]);
+		const skill = f.folder("project", "solo");
+		write(
+			join(skill, "SKILL.md"),
+			"---\nname: solo\n---\nLocal instructions\n",
+		);
+		const before = f.snapshot();
+		const head = f.head(repo);
+
+		const data = f.value<{
+			entries: MarketOverviewEntry[];
+			list: MarketResult;
+		}>(
+			`const m=await import(${JSON.stringify(sourceModule("services/market-ops.js"))});console.log(JSON.stringify({entries:await m.marketOverview(),list:await m.marketList(${JSON.stringify(f.project)})}));`,
+		);
+
+		expect(data.entries.map((entry) => entry.name)).toEqual(["acme"]);
+		expect(data.entries[0]?.freshness).toBe("fresh");
+		expect(data.list.local).toContainEqual({
+			kind: "skill",
+			name: "solo",
+			scope: "project",
+			path: skill,
+		});
+		expect(f.snapshot()).toEqual(before);
+		expect(f.head(repo)).toBe(head);
+		f.assertOwned();
+	},
+	60_000,
+);