kitfly 0.2.1 → 0.2.3

package/src/__tests__/brief.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for the Brief template definition
+ *
+ * Covers: src/templates/brief.ts
+ * Strategy: import the template directly, verify structure and generated content
+ */
+
+import { describe, expect, it } from "vitest";
+import { brief } from "../templates/brief.ts";
+import type { BrandingConfig, TemplateContext, TemplateFile } from "../templates/schema.ts";
+
+function makeCtx(overrides?: Partial<TemplateContext>): TemplateContext {
+	const branding: BrandingConfig = {
+		siteName: "Test Brief",
+		brandName: "Acme Corp",
+		brandUrl: "https://acme.example.com",
+		primaryColor: "#2563eb",
+		footerText: "Footer text",
+	};
+	return {
+		name: "test-brief",
+		branding,
+		template: brief,
+		year: 2026,
+		...overrides,
+	};
+}
+
+function resolveContent(file: TemplateFile, ctx: TemplateContext): string {
+	return typeof file.content === "function" ? file.content(ctx) : file.content;
+}
+
+function findFile(path: string): TemplateFile {
+	const f = brief.files.find((entry) => entry.path === path);
+	if (!f) throw new Error(`Template file not found: ${path}`);
+	return f;
+}
+
+describe("brief template definition", () => {
+	it("has correct identity metadata", () => {
+		expect(brief.id).toBe("brief");
+		expect(brief.name).toBe("Brief");
+		expect(brief.version).toBe(1);
+		expect(brief.extends).toBe("minimal");
+	});
+
+	it("defines exactly four sections", () => {
+		expect(brief.sections).toHaveLength(4);
+		expect(brief.sections.map((s) => s.name)).toEqual([
+			"Product",
+			"Use Cases",
+			"Getting Started",
+			"Reference",
+		]);
+		expect(brief.sections.map((s) => s.path)).toEqual([
+			"content/product",
+			"content/use-cases",
+			"content/getting-started",
+			"content/reference",
+		]);
+	});
+
+	it("defines unique file paths", () => {
+		const paths = brief.files.map((f) => f.path);
+		expect(new Set(paths).size).toBe(paths.length);
+	});
+});
+
+describe("brief site.yaml", () => {
+	const ctx = makeCtx();
+	const file = findFile("site.yaml");
+
+	it("includes branding and all four section paths", () => {
+		const content = resolveContent(file, ctx);
+		expect(content).toContain('title: "Test Brief"');
+		expect(content).toContain('name: "Acme Corp"');
+		expect(content).toContain('url: "https://acme.example.com"');
+		expect(content).toContain('"content/product"');
+		expect(content).toContain('"content/use-cases"');
+		expect(content).toContain('"content/getting-started"');
+		expect(content).toContain('"content/reference"');
+		expect(content).toContain('home: "index.md"');
+	});
+});
+
+describe("brief starter files", () => {
+	const ctx = makeCtx();
+	const starterFiles = [
+		"index.md",
+		"content/product/overview.md",
+		"content/product/capabilities.md",
+		"content/use-cases/overview.md",
+		"content/use-cases/example-use-case.md",
+		"content/getting-started/overview.md",
+		"content/getting-started/requirements.md",
+		"content/reference/architecture.md",
+		"content/reference/faq.md",
+		"content/reference/contacts.md",
+	];
+
+	it("ships all 10 starter files", () => {
+		expect(starterFiles).toHaveLength(10);
+		for (const path of starterFiles) {
+			expect(brief.files.some((f) => f.path === path)).toBe(true);
+		}
+	});
+
+	it("includes frontmatter in markdown starter files", () => {
+		for (const path of starterFiles) {
+			const content = resolveContent(findFile(path), ctx);
+			expect(content).toMatch(/^---\n/);
+		}
+	});
+
+	it("includes customize markers in starter files", () => {
+		for (const path of starterFiles) {
+			const content = resolveContent(findFile(path), ctx);
+			expect(content).toContain("<!-- ← CUSTOMIZE");
+		}
+	});
+
+	it("uses professional framing in index and use cases", () => {
+		const index = resolveContent(findFile("index.md"), ctx);
+		expect(index).toContain("At a Glance");
+		expect(index).toContain("[Use Cases](/content/use-cases/overview)");
+
+		const useCases = resolveContent(findFile("content/use-cases/example-use-case.md"), ctx);
+		expect(useCases).toContain("## Scenario");
+		expect(useCases).toContain("## Outcome");
+		expect(useCases).toContain("| Metric | Before | After |");
+	});
+});
+
+describe("brief CUSTOMIZING.md", () => {
+	const ctx = makeCtx();
+	const file = findFile("CUSTOMIZING.md");
+
+	it("documents template identity and external-audience tone", () => {
+		const content = resolveContent(file, ctx);
+		expect(content).toContain("template: brief");
+		expect(content).toContain("clients, prospects, and partners");
+		expect(content).toContain("Informational and professional");
+		expect(content).toContain("Not sales copy");
+	});
+
+	it("guides use-case duplication workflow", () => {
+		const content = resolveContent(file, ctx);
+		expect(content).toContain("Duplicate `content/use-cases/example-use-case.md`");
+		expect(content).toContain("problem -> solution -> outcome");
+	});
+});

package/src/__tests__/build.test.ts

@@ -35,7 +35,8 @@ async function writeSiteYaml(dir: string, extra: Record<string, unknown> = {}):
 	const mode = extra.mode ? `mode: ${extra.mode}\n` : "";
 	const aspect = extra.aspect ? `aspect: ${extra.aspect}\n` : "";
 	const home = extra.home ? `home: ${extra.home}\n` : "";
-	const yaml = `title: ${title}\n${version}${mode}${aspect}brand:\n${brand}\n${home}sections:\n${sections}\n`;
+	const footer = extra.footer ? `footer:\n${extra.footer}\n` : "";
+	const yaml = `title: ${title}\n${version}${mode}${aspect}brand:\n${brand}\n${home}${footer}sections:\n${sections}\n`;
 	await writeFile(join(dir, "site.yaml"), yaml);
 }
 
@@ -216,6 +217,45 @@ describe("build", () => {
 		expect(html).toContain("unversioned");
 	});
 
+	it("renders footer logo with static path prefix in built output", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir, {
+			footer: '  logo: "assets/brand/footer-logo.png"\n  logoAlt: "Footer Brand"\n  logoHeight: 24',
+		});
+		await writeMd(siteDir, "docs/page.md", "# Page");
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).toContain('class="footer-logo-img"');
+		expect(html).toContain('src="./assets/brand/footer-logo.png"');
+		expect(html).toContain('alt="Footer Brand"');
+		expect(html).toContain("max-height: 24px");
+	});
+
+	it("renders light/dark variants for header and footer logos when configured", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir, {
+			brand:
+				'  name: Test\n  url: /\n  logo: "assets/brand/logo.png"\n  logoDark: "assets/brand/logo-dark.png"',
+			footer:
+				'  logo: "assets/brand/footer-logo.png"\n  logoDark: "assets/brand/footer-logo-dark.png"',
+		});
+		await writeMd(siteDir, "docs/page.md", "# Page");
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).toContain("logo-img logo-light");
+		expect(html).toContain("logo-img logo-dark");
+		expect(html).toContain("./assets/brand/logo-dark.png");
+		expect(html).toContain("footer-logo-img logo-light");
+		expect(html).toContain("footer-logo-img logo-dark");
+		expect(html).toContain("./assets/brand/footer-logo-dark.png");
+	});
+
 	it("builds a single-page hash-routed deck when mode is slides", async () => {
 		const siteDir = await makeTempDir();
 		const outDir = "out";
@@ -332,6 +372,87 @@ plugins:
 		expect(html).toContain(js);
 	});
 
+	it("preserves dollar-sign replacement patterns in injected plugin JS", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir);
+		await writeMd(siteDir, "docs/page.md", "# Test");
+
+		const js = "const expr='x'; const sample = `$${expr}$`; const marker = '$`';";
+		await mkdir(join(siteDir, "plugins-dist"), { recursive: true });
+		await writeFile(join(siteDir, "plugins-dist", "literal.js"), js, "utf-8");
+
+		await mkdir(join(siteDir, "registry"), { recursive: true });
+		await writeFile(
+			join(siteDir, "registry", "plugins.yaml"),
+			`version: 1
+updated: "2026-02-16"
+baseUrl: ""
+plugins:
+  literal:
+    name: "Literal"
+    description: "Replacement pattern regression"
+    version: "1.0.0"
+    contract: "1"
+    kitfly: ">=0.2.0 <1.0.0"
+    license: MIT
+    verified: true
+    assets:
+      js: "plugins-dist/literal.js"
+      assetSha256:
+        js: "sha256:${sha256Hex(js)}"
+`,
+			"utf-8",
+		);
+
+		await writeFile(join(siteDir, "kitfly.plugins.yaml"), "plugins:\n  - literal@1.0.0\n", "utf-8");
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).toContain("const sample = `$${expr}$`;");
+		expect(html).toContain("const marker = '$`';");
+		expect(html).not.toContain("<!DOCTYPE html><html");
+	});
+
+	it("preserves dollar-sign replacement patterns in markdown content", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir);
+		await writeMd(
+			siteDir,
+			"docs/dollars.md",
+			"# Dollars\n\nLiteral dollars: $$ and $` and $' and $&\n\nMath style: $$x^2$$",
+		);
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).toContain("Literal dollars: $$ and $` and $&#39; and $&amp;");
+		expect(html).toContain("Math style: $$x^2$$");
+		expect(html.match(/<!DOCTYPE html>/g)?.length ?? 0).toBe(1);
+	});
+
+	it("injects latex plugin in docs mode", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir);
+		await writeMd(
+			siteDir,
+			"docs/math.md",
+			"# Math\n\nInline: $x^2$.\n\n$$\n\\\\int_0^1 x^2 dx\n$$\n\n```math\n\\\\sum_{i=1}^{n} i\n```",
+		);
+		await writeFile(join(siteDir, "kitfly.plugins.yaml"), "plugins:\n  - latex@0.2.2\n", "utf-8");
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).toContain('data-kitfly-plugin="latex@0.2.2"');
+		expect(html).toContain("const KATEX_JS_URL =");
+		expect(html).toContain("cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.js");
+		expect(html).toContain("cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.css");
+	});
+
 	it("injects slides-only plugins when mode=slides", async () => {
 		const siteDir = await makeTempDir();
 		const outDir = "out";
@@ -395,6 +516,53 @@ plugins:
 		expect(html).toContain(js);
 	});
 
+	it("injects slides-charts-lite plugin in slides mode", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir, { mode: "slides" });
+		await writeMd(
+			siteDir,
+			"docs/deck.md",
+			`# Chart
+
+\`\`\`chart
+kind: bar
+title: Revenue
+labels: ["Q1", "Q2"]
+data: [10, 12]
+\`\`\`
+`,
+		);
+		await writeFile(
+			join(siteDir, "kitfly.plugins.yaml"),
+			"plugins:\n  - slides-charts-lite@0.2.2\n",
+			"utf-8",
+		);
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).toContain('data-kitfly-plugin="slides-charts-lite@0.2.2"');
+		expect(html).toContain("kitfly-chart-wrapper");
+	});
+
+	it("does not inject slides-charts-lite in docs mode", async () => {
+		const siteDir = await makeTempDir();
+		const outDir = "out";
+		await writeSiteYaml(siteDir, { mode: "docs" });
+		await writeMd(siteDir, "docs/page.md", "# Page");
+		await writeFile(
+			join(siteDir, "kitfly.plugins.yaml"),
+			"plugins:\n  - slides-charts-lite@0.2.2\n",
+			"utf-8",
+		);
+
+		await build({ folder: siteDir, out: outDir });
+
+		const html = await readFile(join(siteDir, outDir, "index.html"), "utf-8");
+		expect(html).not.toContain('data-kitfly-plugin="slides-charts-lite@0.2.2"');
+	});
+
 	it("ignores unknown slides-visuals block types while enforcing known contracts", async () => {
 		const siteDir = await makeTempDir();
 		const outDir = "out";

package/src/__tests__/bundle.test.ts

@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it } from "vitest";
 import {
 	buildBundleNav,
 	buildBundleSidebarHeader,
+	bundleSite,
 	fileToDataUri,
 	imageMime,
 	inlineLocalImages,
@@ -815,3 +816,136 @@ describe("buildBundleSidebarHeader", () => {
 		expect(html).toContain(`src="${logo}"`);
 	});
 });
+
+describe("bundleSite plugin integration", () => {
+	it("inlines latex plugin script when enabled", async () => {
+		const siteDir = await makeTempDir();
+		await mkdir(join(siteDir, "docs"), { recursive: true });
+		await writeFile(
+			join(siteDir, "site.yaml"),
+			'title: "Bundle Test"\nbrand:\n  name: "Test"\n  url: "/"\nsections:\n  - name: Docs\n    path: docs\n',
+			"utf-8",
+		);
+		await writeFile(join(siteDir, "docs", "index.md"), "# Bundle Math\n\n$E=mc^2$", "utf-8");
+		await writeFile(join(siteDir, "kitfly.plugins.yaml"), "plugins:\n  - latex@0.2.2\n", "utf-8");
+
+		await bundleSite({ folder: siteDir, out: "bundles", name: "bundle.html" });
+
+		const html = await readFile(join(siteDir, "bundles", "bundle.html"), "utf-8");
+		expect(html).toContain('data-kitfly-plugin="latex@0.2.2"');
+		expect(html).toContain("const KATEX_JS_URL =");
+		expect(html).toContain("cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.js");
+		expect(html).toContain("cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.css");
+	});
+
+	it("inlines slides-charts-lite plugin in slides mode", async () => {
+		const siteDir = await makeTempDir();
+		await mkdir(join(siteDir, "slides"), { recursive: true });
+		await writeFile(
+			join(siteDir, "site.yaml"),
+			'title: "Bundle Charts Test"\nmode: "slides"\nbrand:\n  name: "Test"\n  url: "/"\nsections:\n  - name: Slides\n    path: slides\n',
+			"utf-8",
+		);
+		await writeFile(
+			join(siteDir, "slides", "deck.md"),
+			'# Deck\n\n```chart\nkind: line\nlabels: ["W1", "W2"]\ndata: [2, 3]\n```',
+			"utf-8",
+		);
+		await writeFile(
+			join(siteDir, "kitfly.plugins.yaml"),
+			"plugins:\n  - slides-charts-lite@0.2.2\n",
+			"utf-8",
+		);
+
+		await bundleSite({ folder: siteDir, out: "bundles", name: "bundle.html" });
+
+		const html = await readFile(join(siteDir, "bundles", "bundle.html"), "utf-8");
+		expect(html).toContain('data-kitfly-plugin="slides-charts-lite@0.2.2"');
+		expect(html).toContain("kitfly-chart-wrapper");
+	});
+
+	it("inlines footer logo image when configured", async () => {
+		const siteDir = await makeTempDir();
+		await mkdir(join(siteDir, "docs"), { recursive: true });
+		await mkdir(join(siteDir, "assets", "brand"), { recursive: true });
+		await writeFile(
+			join(siteDir, "site.yaml"),
+			'title: "Bundle Footer Test"\nbrand:\n  name: "Test"\n  url: "/"\nfooter:\n  logo: "assets/brand/footer-logo.png"\n  logoAlt: "Footer Brand"\n  logoHeight: 24\nsections:\n  - name: Docs\n    path: docs\n',
+			"utf-8",
+		);
+		await writeFile(join(siteDir, "docs", "index.md"), "# Footer Logo");
+		await writeFile(
+			join(siteDir, "assets", "brand", "footer-logo.png"),
+			Buffer.from(
+				"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl9x9kAAAAASUVORK5CYII=",
+				"base64",
+			),
+		);
+
+		await bundleSite({ folder: siteDir, out: "bundles", name: "bundle.html" });
+
+		const html = await readFile(join(siteDir, "bundles", "bundle.html"), "utf-8");
+		expect(html).toContain('class="footer-logo-img"');
+		expect(html).toContain('src="data:image/png;base64,');
+		expect(html).not.toContain('src="assets/brand/footer-logo.png"');
+		expect(html).toContain('alt="Footer Brand"');
+		expect(html).toContain("max-height: 24px");
+	});
+
+	it("inlines footer logo from site-root-relative path outside assets", async () => {
+		const siteDir = await makeTempDir();
+		await mkdir(join(siteDir, "docs"), { recursive: true });
+		await mkdir(join(siteDir, "logos"), { recursive: true });
+		await writeFile(
+			join(siteDir, "site.yaml"),
+			'title: "Bundle Footer Root Path Test"\nbrand:\n  name: "Test"\n  url: "/"\nfooter:\n  logo: "logos/footer.png"\n  logoAlt: "Footer Root Logo"\nsections:\n  - name: Docs\n    path: docs\n',
+			"utf-8",
+		);
+		await writeFile(join(siteDir, "docs", "index.md"), "# Footer Root Path");
+		await writeFile(
+			join(siteDir, "logos", "footer.png"),
+			Buffer.from(
+				"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl9x9kAAAAASUVORK5CYII=",
+				"base64",
+			),
+		);
+
+		await bundleSite({ folder: siteDir, out: "bundles", name: "bundle.html" });
+
+		const html = await readFile(join(siteDir, "bundles", "bundle.html"), "utf-8");
+		expect(html).toContain('class="footer-logo-img"');
+		expect(html).toContain('src="data:image/png;base64,');
+		expect(html).not.toContain('src="logos/footer.png"');
+		expect(html).toContain('alt="Footer Root Logo"');
+	});
+
+	it("inlines light/dark variants for header and footer logos", async () => {
+		const siteDir = await makeTempDir();
+		await mkdir(join(siteDir, "docs"), { recursive: true });
+		await mkdir(join(siteDir, "assets", "brand"), { recursive: true });
+		await writeFile(
+			join(siteDir, "site.yaml"),
+			'title: "Bundle Dark Logos Test"\nbrand:\n  name: "Test"\n  url: "/"\n  logo: "assets/brand/logo.png"\n  logoDark: "assets/brand/logo-dark.png"\nfooter:\n  logo: "assets/brand/footer-logo.png"\n  logoDark: "assets/brand/footer-logo-dark.png"\nsections:\n  - name: Docs\n    path: docs\n',
+			"utf-8",
+		);
+		await writeFile(join(siteDir, "docs", "index.md"), "# Dark Logos");
+		const pixelPng = Buffer.from(
+			"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl9x9kAAAAASUVORK5CYII=",
+			"base64",
+		);
+		await writeFile(join(siteDir, "assets", "brand", "logo.png"), pixelPng);
+		await writeFile(join(siteDir, "assets", "brand", "logo-dark.png"), pixelPng);
+		await writeFile(join(siteDir, "assets", "brand", "footer-logo.png"), pixelPng);
+		await writeFile(join(siteDir, "assets", "brand", "footer-logo-dark.png"), pixelPng);
+
+		await bundleSite({ folder: siteDir, out: "bundles", name: "bundle.html" });
+
+		const html = await readFile(join(siteDir, "bundles", "bundle.html"), "utf-8");
+		expect(html).toContain('class="logo-img logo-light"');
+		expect(html).toContain('class="logo-img logo-dark"');
+		expect(html).toContain('class="footer-logo-img logo-light"');
+		expect(html).toContain('class="footer-logo-img logo-dark"');
+		expect(html).not.toContain('src="assets/brand/logo-dark.png"');
+		expect(html).not.toContain('src="assets/brand/footer-logo-dark.png"');
+	});
+});

package/src/__tests__/init.test.ts

@@ -9,8 +9,8 @@ import { existsSync } from "node:fs";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { init } from "../commands/init.ts";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { init, listAvailableTemplates } from "../commands/init.ts";
 import { defaultBranding, getTemplate, listTemplates, runTemplate } from "../templates/driver.ts";
 
 // ---------------------------------------------------------------------------
@@ -53,6 +53,7 @@ describe("template registry", () => {
 		expect(ids).toContain("minimal");
 		expect(ids).toContain("deck");
 		expect(ids).toContain("handbook");
+		expect(ids).toContain("brief");
 		expect(templates.length).toBeGreaterThanOrEqual(2);
 	});
 
@@ -66,6 +67,17 @@ describe("template registry", () => {
 	it("returns undefined for unknown template", () => {
 		expect(getTemplate("nonexistent")).toBeUndefined();
 	});
+
+	it("listAvailableTemplates output includes brief", () => {
+		const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+		try {
+			listAvailableTemplates();
+			const output = spy.mock.calls.map((call) => String(call[0] ?? "")).join("\n");
+			expect(output).toContain("brief");
+		} finally {
+			spy.mockRestore();
+		}
+	});
 });
 
 // ---------------------------------------------------------------------------
@@ -358,6 +370,16 @@ describe("init() entry point", () => {
 		expect(generatedExists(projectName, "CUSTOMIZING.md")).toBe(true);
 	});
 
+	it("creates a brief site when template flag is set", async () => {
+		await init(projectName, { template: "brief", git: false });
+
+		expect(generatedExists(projectName, "content/product/overview.md")).toBe(true);
+		expect(generatedExists(projectName, "content/use-cases/example-use-case.md")).toBe(true);
+		expect(generatedExists(projectName, "content/getting-started/requirements.md")).toBe(true);
+		expect(generatedExists(projectName, "content/reference/contacts.md")).toBe(true);
+		expect(generatedExists(projectName, "CUSTOMIZING.md")).toBe(true);
+	});
+
 	it("passes brand overrides through to template context", async () => {
 		await init(projectName, {
 			git: false,
@@ -439,6 +461,33 @@ describe("standalone mode", () => {
 	});
 });
 
+describe("ai-assist mode", () => {
+	const projectName = "test-brief-ai";
+
+	it("brief template writes AGENTS.md and brief-specific role files", async () => {
+		await runTemplate({
+			name: projectName,
+			template: "brief",
+			git: false,
+			aiAssist: true,
+		});
+
+		expect(generatedExists(projectName, "AGENTS.md")).toBe(true);
+		expect(generatedExists(projectName, "config/agentic/roles/devlead.yaml")).toBe(true);
+		expect(generatedExists(projectName, "config/agentic/roles/infoarch.yaml")).toBe(true);
+		expect(generatedExists(projectName, "config/agentic/roles/qa.yaml")).toBe(true);
+		expect(generatedExists(projectName, "config/agentic/roles/prodstrat.yaml")).toBe(true);
+		expect(generatedExists(projectName, "config/agentic/roles/advisor.yaml")).toBe(true);
+		expect(generatedExists(projectName, "config/agentic/roles/analyst.yaml")).toBe(false);
+		expect(generatedExists(projectName, "config/agentic/roles/prodmktg.yaml")).toBe(false);
+
+		const agents = await readGenerated(projectName, "AGENTS.md");
+		expect(agents).toContain("external audience brief");
+		expect(agents).toContain("informational and professional");
+		expect(agents).toContain("problem -> solution -> outcome");
+	});
+});
+
 // ---------------------------------------------------------------------------
 // Default Branding Derivation
 // ---------------------------------------------------------------------------

package/src/__tests__/latex-runtime.bun.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from "bun:test";
+
+type LatexHooks = {
+	splitMath: (text: string) => Array<{ text?: string; math?: string; display?: boolean }>;
+	isCurrency: (expr: string) => boolean;
+	shouldTreatAsLiteralInline: (expr: string, text: string, closingIndex: number) => boolean;
+};
+
+async function loadHooks(): Promise<LatexHooks> {
+	// @ts-expect-error JS plugin helper file
+	await import("../../plugins-dist/latex-runtime.js");
+	const hooks = (globalThis as any).__kitflyLatexTest as LatexHooks | undefined;
+	if (!hooks) throw new Error("latex test hooks not found on globalThis");
+	return hooks;
+}
+
+test("latex: parses inline math", async () => {
+	const hooks = await loadHooks();
+	expect(hooks.splitMath("A $x^2$ value")).toEqual([
+		{ text: "A " },
+		{ math: "x^2", display: false },
+		{ text: " value" },
+	]);
+});
+
+test("latex: treats $5-$10 as literal currency range", async () => {
+	const hooks = await loadHooks();
+	expect(hooks.splitMath("$5-$10")).toEqual([{ text: "$5-$10" }]);
+});
+
+test("latex: currency helper matches dashed ranges", async () => {
+	const hooks = await loadHooks();
+	expect(hooks.isCurrency("5-10")).toBe(true);
+	expect(hooks.isCurrency("5 to 10")).toBe(true);
+});