claudeup 4.39.1 → 4.40.1

package/src/__tests__/capture-builtin.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+	extractSection,
+	normalizeVersion,
+	slugFor,
+	stripSectionHeader,
+	toStyleFile,
+} from "../../scripts/capture-builtin.ts";
+import { splitFrontmatter } from "../services/styles-manager.js";
+
+const MARKER = "# Output Style: X";
+
+const BASELINE = "# First\nalpha\n\n# Second\nbeta";
+
+describe("extractSection", () => {
+	test("stops at the next structural heading", () => {
+		const styled = `# First\nalpha\n\n${MARKER}\nbody\n\n# Second\nbeta`;
+		expect(extractSection(BASELINE, styled, MARKER)).toBe(`${MARKER}\nbody`);
+	});
+
+	test("keeps an H1 that belongs to the style, not to the harness", () => {
+		// Explanatory really does ship "# Explanatory Style Active" inside its
+		// own body. Splitting on the next "# " truncates it.
+		const styled = `# First\nalpha\n\n${MARKER}\nbody\n\n# X Style Active\nmore\n\n# Second\nbeta`;
+		const got = extractSection(BASELINE, styled, MARKER);
+		expect(got).toContain("# X Style Active");
+		expect(got).toContain("more");
+		expect(got).not.toContain("beta");
+	});
+
+	test("does not truncate when the section ends the way the tail ends", () => {
+		// A character-level suffix walk cut Explanatory mid-sentence here.
+		const styled = `# First\nalpha\n\n${MARKER}\nProvide them as you write code.\n\n# Second\nbeta`;
+		expect(extractSection(BASELINE, styled, MARKER)).toBe(
+			`${MARKER}\nProvide them as you write code.`,
+		);
+	});
+
+	test("runs to the end when the section is last", () => {
+		const styled = `# First\nalpha\n\n${MARKER}\nbody`;
+		expect(extractSection(BASELINE, styled, MARKER)).toBe(`${MARKER}\nbody`);
+	});
+
+	test("returns empty when the marker is absent", () => {
+		expect(extractSection(BASELINE, BASELINE, MARKER)).toBe("");
+	});
+});
+
+describe("stripSectionHeader", () => {
+	test("removes the harness header and keeps H1s belonging to the style", () => {
+		const block =
+			"# Output Style: Explanatory\nBody line.\n\n# Explanatory Style Active\n\nMore.";
+		const body = stripSectionHeader(block, "Explanatory");
+		expect(body.startsWith("Body line.")).toBe(true);
+		// A heading-based split would have cut here; the style owns this H1.
+		expect(body).toContain("# Explanatory Style Active");
+	});
+
+	test("passes the block through when the header is absent", () => {
+		expect(stripSectionHeader("  no header here  ", "Explanatory")).toBe(
+			"no header here",
+		);
+	});
+});
+
+describe("toStyleFile", () => {
+	test("produces an importable file with coding instructions kept", () => {
+		const file = toStyleFile("Explanatory", "Body text.", "2.1.233");
+		const { frontmatter, body } = splitFrontmatter(file);
+		expect(frontmatter.name).toBe("builtin-explanatory");
+		expect(frontmatter["keep-coding-instructions"]).toBe("true");
+		expect(frontmatter.description).toBe(
+			"Captured built-in output style: Explanatory",
+		);
+		expect(frontmatter["captured-from"]).toBe("2.1.233");
+		expect(frontmatter["captured-style"]).toBe("Explanatory");
+		expect(body).toBe("Body text.");
+	});
+
+	test("slugs a multi-word style name into a usable filename", () => {
+		expect(slugFor("Explanatory")).toBe("builtin-explanatory");
+		expect(slugFor("Deep Research")).toBe("builtin-deep-research");
+	});
+});
+
+describe("normalizeVersion", () => {
+	test("reduces the CLI banner to a bare version so --check can compare it", () => {
+		expect(normalizeVersion("2.1.233 (Claude Code)")).toBe("2.1.233");
+		expect(normalizeVersion("2.1.233")).toBe("2.1.233");
+	});
+});

package/src/__tests__/content-drift.test.ts

@@ -14,6 +14,7 @@ import path from "node:path";
 import {
 	clearContentDriftCache,
 	hasContentDrift,
+	repoHeadSha,
 } from "../services/content-drift.js";
 
 let configDir: string;
@@ -34,6 +35,13 @@ const git = (args: string[]) =>
 
 const head = () => git(["rev-parse", "HEAD"]).stdout.trim();
 
+/** Rewrite a plugin's manifest version, mimicking a release. */
+const setVersion = (plugin: string, version: string) =>
+	fs.writeFile(
+		path.join(repo, "plugins", plugin, "plugin.json"),
+		JSON.stringify({ name: plugin, version }, null, 2),
+	);
+
 beforeEach(async () => {
 	prevConfigDir = process.env.CLAUDE_CONFIG_DIR;
 	configDir = await fs.mkdtemp(path.join(os.tmpdir(), "drift-"));
@@ -47,6 +55,8 @@ beforeEach(async () => {
 	await fs.mkdir(path.join(repo, "plugins", "beta"), { recursive: true });
 	await fs.writeFile(path.join(repo, "plugins", "alpha", "skills", "s.md"), "v1");
 	await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v1");
+	await setVersion("alpha", "1.0.0");
+	await setVersion("beta", "1.0.0");
 
 	git(["init", "-q", "-b", "main"]);
 	git(["config", "user.email", "probe@example.invalid"]);
@@ -69,6 +79,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "alpha",
 				installedSha: sha,
+				installedVersion: "1.0.0",
 			}),
 		).toBe(false);
 	});
@@ -88,6 +99,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "alpha",
 				installedSha: sha,
+				installedVersion: "1.0.0",
 			}),
 		).toBe(true);
 	});
@@ -105,6 +117,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "alpha",
 				installedSha: sha,
+				installedVersion: "1.0.0",
 			}),
 		).toBe(false);
 		expect(
@@ -112,6 +125,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "beta",
 				installedSha: sha,
+				installedVersion: "1.0.0",
 			}),
 		).toBe(true);
 	});
@@ -129,6 +143,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "alpha",
 				installedSha: sha,
+				installedVersion: "1.0.0",
 			}),
 		).toBe(true);
 	});
@@ -141,6 +156,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "alpha",
 				installedSha: undefined,
+				installedVersion: "1.0.0",
 			}),
 		).toBe(false);
 		expect(
@@ -148,6 +164,7 @@ describe("hasContentDrift", () => {
 				marketplace: "probemp",
 				pluginName: "alpha",
 				installedSha: "0".repeat(40),
+				installedVersion: "1.0.0",
 			}),
 		).toBe(false);
 		expect(
@@ -155,7 +172,118 @@ describe("hasContentDrift", () => {
 				marketplace: "does-not-exist",
 				pluginName: "alpha",
 				installedSha: head(),
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+	});
+
+	// REGRESSION: every installed plugin rendered "stale — reinstall" because
+	// updateInstalledPluginsRegistry bumped `version` while carrying the
+	// pre-update `gitCommitSha` forward. The sha then named a commit several
+	// releases old, so the subtree diff was non-empty for essentially every
+	// plugin. Fixed in /dev:fix session dev-fix-20260822-125510-03db093b.
+	test("a sha recorded against a DIFFERENT version cannot answer the question", async () => {
+		const oldSha = head();
+
+		// Ship 2.0.0 — the plugin genuinely changed, as a release does.
+		await fs.writeFile(
+			path.join(repo, "plugins", "alpha", "skills", "s.md"),
+			"v2 content",
+		);
+		await setVersion("alpha", "2.0.0");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "release 2.0.0"]);
+
+		// 2.0.0 is installed, but the registry still carries the 1.0.0 sha.
+		// The subtree diff between them is non-empty, and says nothing about
+		// whether the installed 2.0.0 files match the marketplace's 2.0.0.
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "alpha",
+				installedSha: oldSha,
+				installedVersion: "2.0.0",
 			}),
 		).toBe(false);
 	});
+
+	test("a manifest that cannot be read at that sha reports no drift", async () => {
+		// Provenance unverifiable — the module's policy is silence, not a nag.
+		await fs.rm(path.join(repo, "plugins", "beta", "plugin.json"));
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "beta loses its manifest"]);
+		const sha = head();
+
+		await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v2");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "beta content changes"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "beta",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(false);
+	});
+
+	test("reads a manifest at .claude-plugin/plugin.json too", async () => {
+		// magus lays plugins out as plugins/<name>/plugin.json, but Claude Code's
+		// documented location is .claude-plugin/plugin.json. Both must resolve or
+		// the guard silences drift detection for half the ecosystem.
+		await fs.mkdir(path.join(repo, "plugins", "beta", ".claude-plugin"), {
+			recursive: true,
+		});
+		await fs.rm(path.join(repo, "plugins", "beta", "plugin.json"));
+		await fs.writeFile(
+			path.join(repo, "plugins", "beta", ".claude-plugin", "plugin.json"),
+			JSON.stringify({ name: "beta", version: "1.0.0" }),
+		);
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "beta uses .claude-plugin"]);
+		const sha = head();
+
+		await fs.writeFile(path.join(repo, "plugins", "beta", "readme.md"), "v2");
+		git(["add", "-A"]);
+		git(["commit", "-q", "-m", "republish 1.0.0"]);
+
+		expect(
+			await hasContentDrift({
+				marketplace: "probemp",
+				pluginName: "beta",
+				installedSha: sha,
+				installedVersion: "1.0.0",
+			}),
+		).toBe(true);
+	});
+});
+
+describe("repoHeadSha", () => {
+	// The other half of the same bug: nothing in claudeup ever recorded a fresh
+	// sha, so the registry could only ever go stale. This is what
+	// updateInstalledPluginsRegistry now calls to stamp real provenance onto the
+	// files it just copied out of the marketplace clone.
+	test("resolves HEAD from a path inside the repo", async () => {
+		const sha = head();
+		expect(await repoHeadSha(path.join(repo, "plugins", "alpha"))).toBe(sha);
+		expect(await repoHeadSha(repo)).toBe(sha);
+	});
+
+	test("returns undefined for a directory that is not in a git repo", async () => {
+		// Directory-type marketplaces have no commit to name. Recording a sha
+		// from some unrelated clone would assert a provenance that is false.
+		const plain = await fs.mkdtemp(path.join(os.tmpdir(), "nogit-"));
+		try {
+			expect(await repoHeadSha(plain)).toBeUndefined();
+		} finally {
+			await fs.rm(plain, { recursive: true, force: true });
+		}
+	});
+
+	test("returns undefined for a path that does not exist", async () => {
+		expect(
+			await repoHeadSha(path.join(configDir, "no", "such", "dir")),
+		).toBeUndefined();
+	});
 });

package/src/__tests__/styles-manager.test.ts

@@ -3,6 +3,7 @@ import { mkdtemp, rm, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
+import { EMBEDDED_PRESETS } from "../data/styles/index.js";
 import {
 	INTEGRITY_BLOCK,
 	type ImportedStyle,
@@ -12,6 +13,7 @@ import {
 	clearStyle,
 	composeStyleFile,
 	generatedStyleName,
+	loadPresets,
 	orderSources,
 	readApplied,
 	splitFrontmatter,
@@ -78,7 +80,7 @@ afterEach(async () => {
 // ─── Frontmatter ──────────────────────────────────────────────────────────────
 
 describe("splitFrontmatter", () => {
-	test("parses the shape the style plugin actually ships", () => {
+	test("parses the shape the presets actually ship", () => {
 		const { frontmatter, body } = splitFrontmatter(
 			[
 				"---",
@@ -524,119 +526,91 @@ describe("clearStyle", () => {
 	});
 });
 
-// ─── Parity with the shipped plugin ───────────────────────────────────────────
-
-describe("parity with plugins/style/styles", () => {
-	// styles-manager re-implements the plugin's compose-style.ts rather than
-	// shelling out to it, so the one thing that must not drift is the file
-	// format. These read the REAL shipped presets — if the plugin changes its
-	// frontmatter vocabulary, this is what notices.
-	const stylesDir = join(
-		import.meta.dir,
-		"..",
-		"..",
-		"..",
-		"..",
-		"plugins",
-		"style",
-		"styles",
-	);
-
-	test("the shipped presets are where this test expects them", async () => {
-		expect(await fs.pathExists(stylesDir)).toBe(true);
-	});
-
-	test("every shipped preset parses into a usable preset", async () => {
-		const files = (await fs.readdir(stylesDir)).filter((f) =>
-			f.endsWith(".md"),
-		);
-		expect(files.length).toBeGreaterThan(0);
-
-		for (const file of files) {
-			const raw = await fs.readFile(join(stylesDir, file), "utf8");
-			const { frontmatter, body } = splitFrontmatter(raw);
+// ─── The presets that actually ship ──────────────────────────────────────────
+
+describe("embedded presets", () => {
+	// These read what `loadPresets()` really returns, so a preset whose
+	// frontmatter stops parsing shows up here rather than as an empty row in the
+	// Styles tab.
+	const shipped = loadPresets();
+
+	test("the directory and the index agree", async () => {
+		// `data/styles/index.ts` lists its imports one by one, because a glob
+		// cannot be resolved at build time. A file added to the directory without
+		// its two lines in the index does not ship, and nothing else notices.
+		const dir = join(import.meta.dir, "..", "data", "styles");
+		const onDisk = (await fs.readdir(dir)).filter((f) => f.endsWith(".md"));
+		expect(onDisk.length).toBeGreaterThan(0);
+		expect(EMBEDDED_PRESETS.map((p) => p.file).sort()).toEqual(onDisk.sort());
+	});
+
+	test("each entry carries the text of the file it names", () => {
+		// The name check above compares file names only, so two entries whose
+		// imports were swapped would still agree with the directory — and every
+		// preset would then be under the wrong name. Comparing each entry's own
+		// frontmatter against its file name is what catches that.
+		for (const { file, text } of EMBEDDED_PRESETS) {
+			const { frontmatter } = splitFrontmatter(text);
+			expect(frontmatter.name, `${file} carries its own frontmatter`).toBe(
+				file.replace(/\.md$/, ""),
+			);
+		}
+	});
 
-			expect(frontmatter.name, `${file} declares a name`).toBeTruthy();
+	test("every preset parses into a usable one", () => {
+		expect(shipped.length).toBe(EMBEDDED_PRESETS.length);
+		for (const p of shipped) {
+			expect(p.name, "declares a name").toBeTruthy();
 			expect(
 				["verbosity", "modifier"],
-				`${file} declares a known axis`,
-			).toContain(frontmatter.axis);
-			expect(frontmatter.summary, `${file} declares a summary`).toBeTruthy();
+				`${p.name} declares a known axis`,
+			).toContain(p.axis);
 			// The summary is the list-row text; an empty one renders a blank row.
-			expect(body.length, `${file} has a non-empty body`).toBeGreaterThan(0);
+			expect(p.summary, `${p.name} declares a summary`).toBeTruthy();
+			expect(p.body.length, `${p.name} has a non-empty body`).toBeGreaterThan(
+				0,
+			);
 		}
 	});
 
-	test("exactly one verbosity preset can be chosen from what ships", async () => {
-		const files = (await fs.readdir(stylesDir)).filter((f) =>
-			f.endsWith(".md"),
-		);
-		const axes = await Promise.all(
-			files.map(async (file) => {
-				const { frontmatter } = splitFrontmatter(
-					await fs.readFile(join(stylesDir, file), "utf8"),
-				);
-				return frontmatter.axis;
-			}),
-		);
-		// Both groups must be non-empty or the screen renders a category with no
-		// rows, which reads as "the plugin is broken".
-		expect(axes.filter((a) => a === "verbosity").length).toBeGreaterThan(0);
-		expect(axes.filter((a) => a === "modifier").length).toBeGreaterThan(0);
-	});
-
-	test("the plugin's composer carries the identical integrity block", async () => {
-		// The two composers are separate implementations of one format (see the
-		// header of styles-manager.ts). Everything else about them can differ
-		// harmlessly; this block cannot, because it is the security backstop and a
-		// user who composes with /style:apply must get the same one as a user who
-		// composes with claudeup.
-		//
-		// Read as TEXT rather than imported: claudeup's tsconfig roots at src/,
-		// and a cross-package import would make the check depend on the plugin
-		// being resolvable rather than on the text agreeing.
-		const composer = join(
-			import.meta.dir,
-			"..",
-			"..",
-			"..",
-			"..",
-			"plugins",
-			"style",
-			"scripts",
-			"compose-style.ts",
+	test("both axes are populated", () => {
+		// Either group empty renders a category with no rows, which reads as
+		// "the Styles tab is broken".
+		expect(
+			shipped.filter((p) => p.axis === "verbosity").length,
+		).toBeGreaterThan(0);
+		expect(shipped.filter((p) => p.axis === "modifier").length).toBeGreaterThan(
+			0,
 		);
-		expect(await fs.pathExists(composer)).toBe(true);
-		const text = await fs.readFile(composer, "utf8");
-		expect(text).toContain(INTEGRITY_BLOCK);
-		// And it is actually appended there, not merely declared.
-		expect(text).toContain("lines.push(INTEGRITY_BLOCK,");
 	});
 
-	test("declared conflicts all name a preset that actually ships", async () => {
-		const files = (await fs.readdir(stylesDir)).filter((f) =>
-			f.endsWith(".md"),
-		);
-		const parsed = await Promise.all(
-			files.map(async (file) =>
-				splitFrontmatter(await fs.readFile(join(stylesDir, file), "utf8")),
-			),
-		);
-		const names = new Set(parsed.map((p) => p.frontmatter.name));
-		for (const { frontmatter } of parsed) {
-			for (const conflict of (frontmatter.conflicts ?? "")
-				.split(",")
-				.map((c) => c.trim())
-				.filter(Boolean)) {
-				// A conflict naming a preset that no longer exists is dead config:
-				// it silently stops protecting the pair it was written for.
-				expect(
-					names,
-					`${frontmatter.name} conflicts with a real preset`,
-				).toContain(conflict);
+	test("declared conflicts all name a preset that ships", () => {
+		const names = new Set(shipped.map((p) => p.name));
+		for (const p of shipped) {
+			for (const conflict of p.conflicts) {
+				// A conflict naming a preset that no longer exists is dead config: it
+				// silently stops protecting the pair it was written for.
+				expect(names, `${p.name} conflicts with a real preset`).toContain(
+					conflict,
+				);
 			}
 		}
 	});
+
+	test("selection keys are unique", () => {
+		// `id` is what a declaration records and what the screen ticks. Two
+		// presets sharing one would make a selection ambiguous.
+		const ids = shipped.map((p) => p.id);
+		expect(new Set(ids).size).toBe(ids.length);
+	});
+
+	test("a template preset cannot be applied as-is", () => {
+		// `terminology` ships an empty table. Applying it unfilled would put a
+		// placeholder row into the system prompt.
+		for (const p of shipped.filter((s) => s.template)) {
+			expect(validateSelection([p]).length).toBeGreaterThan(0);
+		}
+	});
 });
 
 // ─── Adapter ──────────────────────────────────────────────────────────────────

package/src/__tests__/styles-screen-state.test.ts

@@ -126,7 +126,6 @@ describe("styles selection state", () => {
 					stylePath: "/x/composed.md",
 					settingsPath: "/x/settings.json",
 					styleName: "composed",
-					presetsRoot: "/styles",
 					profile: null,
 					currentOutputStyle: "composed",
 				},
@@ -159,7 +158,6 @@ describe("styles selection state", () => {
 					stylePath: "/x/composed.md",
 					settingsPath: "/x/settings.json",
 					styleName: "composed",
-					presetsRoot: "/styles",
 					profile: null,
 					currentOutputStyle: "composed",
 				},
@@ -187,7 +185,6 @@ describe("styles selection state", () => {
 					stylePath: "/x/composed.md",
 					settingsPath: "/x/settings.json",
 					styleName: "composed",
-					presetsRoot: null,
 					profile: null,
 					currentOutputStyle: null,
 				},

package/src/__tests__/terminology-filler.test.ts

@@ -20,7 +20,7 @@ const TEMPLATE = [
 	"",
 	"| Use | Not | Because |",
 	"|---|---|---|",
-	"| <!-- filled during /style:apply --> | | |",
+	"| <!-- filled during apply --> | | |",
 	"",
 	"Rules that hold regardless of the table above:",
 	"",
@@ -119,7 +119,7 @@ describe("fillTemplate", () => {
 		// Guards against the upstream template changing shape and this silently
 		// producing an empty table.
 		const noPlaceholder = TEMPLATE.replace(
-			"| <!-- filled during /style:apply --> | | |\n",
+			"| <!-- filled during apply --> | | |\n",
 			"",
 		);
 		const filled = fillTemplate(noPlaceholder, [

package/src/data/community-styles.ts

@@ -156,7 +156,7 @@ export const COMMUNITY_SOURCES: CommunityStyleSource[] = [
 	},
 	{
 		// Retired 2026-08-18: its only style is superseded by the first-party
-		// `asd-ste100` modifier in style@magus 2.1.0 — see the style entry below.
+		// `asd-ste100` modifier claudeup ships — see the style entry below.
 		id: "simple-english",
 		repo: "AminBlg/SimpleEnglish",
 		dir: "output-styles",
@@ -380,8 +380,8 @@ export const COMMUNITY_STYLES: CommunityStyle[] = [
 	// ── simple-english ───────────────────────────────────────────────────────
 	{
 		// Retired 2026-08-18: superseded by our own condensation of the same
-		// standard — the `asd-ste100` modifier preset that ships in style@magus
-		// 2.1.0. Offering both would list ASD-STE100 twice, and the upstream file
+		// standard — the `asd-ste100` modifier preset claudeup ships. Offering
+		// both would list ASD-STE100 twice, and the upstream file
 		// injects far more text than the preset does. Retired rather than
 		// deleted so a committed `.claude/style.json` naming this id still
 		// resolves and fetches.

package/src/data/styles/asd-ste100.md

@@ -0,0 +1,38 @@
+---
+name: asd-ste100
+title: ASD-STE100 Simplified Technical English
+axis: modifier
+summary: Full-grammar sentences that survive one read. Sentence caps, three modals, one word one meaning.
+conflicts:
+credits: ASD-STE100; found via AminBlg/SimpleEnglish (MIT)
+---
+
+### ASD-STE100 Simplified Technical English
+
+The standard, cut to the rules that survive outside an aerospace manual. The
+reader is tired, often reads in a second language, and reads each sentence
+once. Write so one read is enough.
+
+- Classify before you write. An instruction gets imperative mood, one action
+  per sentence, and 20 words or fewer. A description gets simple tenses, one
+  topic per paragraph, and 25 words or fewer per sentence. Never mix the two
+  in one passage.
+- Use the active voice, simple tenses, and a named actor. No present perfect
+  ("the build has completed" → "the build completed"). No "-ing" chains.
+  Start a new sentence instead.
+- Use three modals: must, can, will. "Should" is a bug report against the
+  sentence. If the action is required, write "must". If it is optional,
+  delete the word. The same rule covers would, may, might, and could.
+- Use one word for one meaning across the whole answer. Pick one of check,
+  verify, and confirm, then keep it. A word that changes mid-answer reads as
+  a new concept.
+- Put the condition before the command, with a comma: "If the test fails,
+  read the log." The reader must know it is conditional before they act.
+- Keep the grammar words: articles, "that", and full forms over contractions.
+  Telegraphic compression saves characters and buys ambiguity.
+- Break noun chains at three words: "the marketplace cache refresh interval"
+  → "the refresh interval for the marketplace cache".
+- If a list has more than two steps or items, make it vertical, one per line.
+- Delete any word whose removal changes no fact: simply, robust, seamless,
+  "in order to". Replace the ornate word with the plain one: utilize → use,
+  prior to → before, in the event that → if.

package/src/data/styles/calibrated.md

@@ -0,0 +1,24 @@
+---
+name: calibrated
+axis: modifier
+summary: Confidence matches evidence. Say "I don't know" plainly; no false certainty either way.
+conflicts:
+---
+
+### Calibrated confidence
+
+- State confidence that matches the evidence. Verified by running it: say so
+  plainly. Read but not run: say "based on reading `file.ts:88`". Inferred
+  from a pattern: say it is an inference.
+- "I don't know" is a complete answer. Follow it with what would settle the
+  question, not with a guess dressed as an answer.
+- Never hedge a fact you verified. Hedging everything is as miscalibrated as
+  hedging nothing, and it makes the real uncertainty invisible.
+- Name the assumption when you proceed under one, at the point it starts to
+  matter, not in a footnote at the end.
+- When another agent, tool, or search result contradicts what you found, do
+  not fold immediately. Say what each side rests on and which evidence is
+  stronger.
+- Correct an earlier statement only when the error changes what the reader
+  should do. Fix it in one sentence and continue — no apology, no tally of
+  past mistakes, no re-audit of how it was phrased.

package/src/data/styles/direct.md

@@ -0,0 +1,23 @@
+---
+name: direct
+axis: verbosity
+summary: Answer first, no preamble or postamble. The default for people who read fast.
+conflicts: explanatory, terse
+---
+
+### Direct
+
+- Lead with the answer. The first sentence resolves the question; everything
+  after it is support. Never open with a restatement of what was asked.
+- No preamble ("Great question", "Let me look into that", "I'll start by") and
+  no postamble ("Let me know if you'd like", "Feel free to ask", "I hope this
+  helps"). Stop when the answer is complete.
+- Recommend, do not survey. When there are three viable approaches, name the
+  one to take and give the reason in a clause. List the alternatives only if
+  the choice is genuinely close, and say why it is close.
+- Report the outcome, not the journey. What changed, where, and whether it
+  works. The steps taken are only interesting when one of them failed.
+- One statement of a fact is enough. Do not restate a conclusion in a summary
+  section immediately below the conclusion.
+- Bad news goes first and plainly. "The tests fail" opens the message; it does
+  not appear in the last paragraph after four paragraphs of progress.