pi-lean-dimension 0.5.0 → 0.6.0

package/node_modules/pi-lean-host/__tests__/parse-api-guide.test.ts

@@ -4,24 +4,14 @@
  * Covers:
  *  - BOE worked example parses to a valid ApiGuide with defaults filled.
  *  - Each malformed fixture returns a ParseError with dotted field path.
-
- *  - projectToGuide() strips recipe fields, retains kind: "api".
- *  - Catalog rendering lists healthy + ⚠ malformed together.
+ *
+ *  (projectToGuide/slug/loader/catalog/stampFrontmatterField tests live in
+ *  guide-catalog.test.ts.)
  */
 
-import { describe, it, expect, vi } from "vitest";
-import {
-	mkdtempSync,
-	mkdirSync,
-	writeFileSync,
-	rmSync,
-	renameSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { describe, it, expect } from "vitest";
 import {
 	parseApiGuide,
-	stampFrontmatterField,
 	PAGINATION_ALLOWLISTS,
 	AUTH_ALLOWLISTS,
 	PARAM_SPEC_KEYS,
@@ -29,12 +19,6 @@ import {
 	OP_ALLOWLIST,
 	RESPONSE_SHAPE_ALLOWLIST,
 } from "../core/parse-api-guide.js";
-import {
-	projectToGuide,
-	loadApiGuidesFromDir,
-	formatApiGuideCatalog,
-} from "../core/guide-catalog.js";
-import { slug } from "../core/path-template.js";
 import { parse as yamlParse } from "yaml";
 import {
 	GATHER_ALL_MAX_FALLBACK,
@@ -2066,10 +2050,6 @@ body
 	});
 });
 
-// ═══════════════════════════════════════════════════════════════════
-// projectToGuide — strips recipe, retains presentation + kind
-// ═══════════════════════════════════════════════════════════════════
-
 // ═════════════════════════════════════════════════════════════════
 // errorPath — present-only-on-error envelope path
 // ═════════════════════════════════════════════════════════════════
@@ -2175,391 +2155,6 @@ body
 	});
 });
 
-describe("projectToGuide", () => {
-	it("strips recipe fields and retains kind: api", () => {
-		const guide = expectOk(BOE_RECIPE, { filename: "boe.es" });
-		const proj = projectToGuide(guide);
-
-		const keys = Object.keys(proj);
-		const RECIPE_KEYS = [
-			"apiHost",
-			"operations",
-			"pagination",
-			"auth",
-			"helper",
-			"verified",
-			"gatherAllMax",
-			"responseShape",
-		];
-		for (const k of RECIPE_KEYS) {
-			expect(keys).not.toContain(k);
-		}
-
-		expect(proj.kind).toBe("api");
-		expect(proj.domains).toEqual(["boe.es", "www.boe.es"]);
-		expect(proj.icon).toBe("⚖️");
-		expect(proj.shortName).toBe("BOE");
-		expect(proj.updated).toBe("2026-07-17");
-		expect(proj.content).toContain("BOE Legislación Consolidada");
-		expect(proj.category).toBe("site");
-	});
-
-	it("projection carries no helper reference", () => {
-		const guide = expectOk(BOE_RECIPE, { filename: "boe.es" });
-		const proj = projectToGuide(guide);
-		// Helper is a recipe (op-level) field; the Guide projection has no such key.
-		expect("helper" in proj).toBe(false);
-		expect("operations" in proj).toBe(false);
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════
-// slug() — the shortName → identity-folder sanitizer
-// ═══════════════════════════════════════════════════════════════════
-
-describe("slug()", () => {
-	it("lowercases and replaces non-[a-z0-9-] runs with a single '-'", () => {
-		expect(slug("BOE")).toBe("boe");
-		expect(slug("My Provider Pro!")).toBe("my-provider-pro");
-		expect(slug("Example Dev Inc")).toBe("example-dev-inc");
-		expect(slug("a/b")).toBe("a-b");
-	});
-
-	it("transliterates Latin diacritics instead of dropping them", () => {
-		expect(slug("Café")).toBe("cafe");
-		expect(slug("Überwald")).toBe("uberwald");
-		expect(slug("Bjørk")).toBe("bjork");
-		expect(slug("Münchhausen")).toBe("munchhausen");
-	});
-
-	it("collapses repeated '-' and strips leading/trailing '-'", () => {
-		expect(slug("a--b")).toBe("a-b");
-		expect(slug("-foo-")).toBe("foo");
-	});
-
-	it("slug-collision pair: api_dev_full and api-dev-full both slug to api-dev-full", () => {
-		expect(slug("api_dev_full")).toBe("api-dev-full");
-		expect(slug("api-dev-full")).toBe("api-dev-full");
-	});
-
-	it("throws on empty or all-symbol shortName (slug flattens to empty)", () => {
-		expect(() => slug("")).toThrow(/shortName/);
-		expect(() => slug("!!!")).toThrow(/shortName/);
-		expect(() => slug("..")).toThrow(/shortName/);
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════
-// Loader + catalog — one malformed guide doesn't block the store
-// ═══════════════════════════════════════════════════════════════════
-
-describe("loadApiGuidesFromDir + formatApiGuideCatalog", () => {
-	beforeEach(() => {
-		vi.spyOn(console, "warn").mockImplementation(() => {});
-	});
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	it("lists a healthy and a malformed guide together", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		try {
-			// Healthy guide in subdirectory
-			const boeDir = join(dir, "boe");
-			mkdirSync(boeDir, { recursive: true });
-			writeFileSync(join(boeDir, "guide.md"), BOE_RECIPE);
-
-			// Malformed guide in subdirectory
-			const brokenDir = join(dir, "broken");
-			mkdirSync(brokenDir, { recursive: true });
-			writeFileSync(
-				join(brokenDir, "guide.md"),
-				`---
-schemaVersion: 1
-domains: [broken.com]
-apiHost: https://api.broken.com
-operations:
-  - name: get
-    via: restPost
-    path: /things
----
-body
-`,
-			);
-
-			const loaded = loadApiGuidesFromDir(dir);
-			expect(Object.keys(loaded.guides)).toEqual(["boe"]);
-			expect(loaded.malformed).toHaveLength(1);
-			expect(loaded.malformed[0]!.filename).toBe("broken");
-			expect(loaded.malformed[0]!.error.field).toBe("operations[0].via");
-
-			const catalog = formatApiGuideCatalog(loaded);
-			expect(catalog).toContain("BOE");
-			expect(catalog).toContain("⚠ malformed");
-			expect(catalog).toContain("broken");
-			expect(catalog).toContain("operations[0].via");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("collapses the catalog by organization (org line + orgless fallback)", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		try {
-			const orgRecipe = (d: string, shortName: string, domains: string) => `---
-schemaVersion: 1
-kind: api
-domains: [${domains}]
-organization: archive.org
-description: ${shortName} surface.
-icon: 🏛️
-shortName: ${shortName}
-updated: 2026-07-17
-apiHost: https://${d}
-verified: 2026-07-17
-gatherAllMax: 500
-auth:
-  kind: none
-responseShape:
-  format: json
-  charset: utf-8
-operations:
-  - name: get
-    via: restGet
-    path: /x
-    accept: json
----
-org guide.
-`;
-			for (const [domain, folder, shortName] of [
-				["archive.org", "archive", "Archive"],
-				["web.archive.org", "wayback", "Wayback"],
-			] as const) {
-				mkdirSync(join(dir, folder), { recursive: true });
-				writeFileSync(
-					join(dir, folder, "guide.md"),
-					orgRecipe(domain, shortName, domain),
-				);
-			}
-			// Orgless guide keeps the per-guide line (fallback).
-			mkdirSync(join(dir, "boe"), { recursive: true });
-			writeFileSync(join(dir, "boe", "guide.md"), BOE_RECIPE);
-
-			const loaded = loadApiGuidesFromDir(dir);
-			const catalog = formatApiGuideCatalog(loaded);
-			// One org-collapsed line for archive.org with guide count + domain set.
-			expect(catalog).toContain(
-				"🏛️ archive.org — 2 guides (archive.org, web.archive.org)",
-			);
-			// Orgless BOE keeps the per-guide shape (icon + shortName + ops).
-			expect(catalog).toContain("⚖️ BOE — boe.es, www.boe.es");
-			expect(catalog).not.toContain("🏛️ BOE");
-			// Footer mentions the disambiguation menu.
-			expect(catalog).toContain("disambiguation menu");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("returns empty result for a nonexistent directory", () => {
-		const loaded = loadApiGuidesFromDir(
-			join(tmpdir(), "host-guides-nonexistent-xyz"),
-		);
-		expect(loaded.guides).toEqual({});
-		expect(loaded.malformed).toEqual([]);
-		expect(formatApiGuideCatalog(loaded)).toContain("no guides");
-	});
-
-	it("skips subdirectories without guide.md", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		try {
-			// A subdir without guide.md — skipped
-			mkdirSync(join(dir, "no-guide"), { recursive: true });
-			writeFileSync(join(dir, "no-guide", "helper.ts"), "export default p => p;");
-
-			// A valid subdir with guide.md — loaded
-			mkdirSync(join(dir, "boe"), { recursive: true });
-			writeFileSync(join(dir, "boe", "guide.md"), BOE_RECIPE);
-
-			// Flat .md files at top level — ignored
-			writeFileSync(join(dir, "README.txt"), "not a guide");
-
-			const loaded = loadApiGuidesFromDir(dir);
-			expect(Object.keys(loaded.guides)).toEqual(["boe"]);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("routes a divergent folder (entry !== slug(shortName)) to malformed", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		try {
-			// BOE_RECIPE has shortName: BOE → slug "boe"; folder is "boe.es" —
-			// the pre-migration state. Under enforcement the guide does NOT load.
-			mkdirSync(join(dir, "boe.es"), { recursive: true });
-			writeFileSync(join(dir, "boe.es", "guide.md"), BOE_RECIPE);
-
-			const loaded = loadApiGuidesFromDir(dir);
-			expect(Object.keys(loaded.guides)).toEqual([]);
-			expect(loaded.malformed).toHaveLength(1);
-			expect(loaded.malformed[0]!.filename).toBe("boe.es");
-			expect(loaded.malformed[0]!.error.field).toBe("shortName");
-			expect(loaded.malformed[0]!.error.found).toBe("folder 'boe.es'");
-			expect(loaded.malformed[0]!.error.fix).toContain("mv");
-			expect(loaded.malformed[0]!.error.fix).toContain("boe");
-			// The per-guide fix names the mv only; no /reload instruction on the
-			// fix line itself.
-			expect(loaded.malformed[0]!.error.fix).not.toContain("/reload");
-			// The malformed guide is warned about at load, and the catalog
-			// renders its actionable fix.
-			const msg = warn.mock.calls.map((c) => String(c[0])).join("\n");
-			expect(msg).toContain("Malformed guide");
-			expect(msg).toContain("boe.es");
-			const catalog = formatApiGuideCatalog(loaded);
-			expect(catalog).toContain("fix:");
-			expect(catalog).not.toContain("/reload");
-		} finally {
-			warn.mockRestore();
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("routes warnings through the notify callback when provided", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const notify = vi.fn();
-		try {
-			// Divergent folder (boe.es vs slug "boe") — must surface loudly.
-			mkdirSync(join(dir, "boe.es"), { recursive: true });
-			writeFileSync(join(dir, "boe.es", "guide.md"), BOE_RECIPE);
-
-			const loaded = loadApiGuidesFromDir(dir, notify);
-			expect(Object.keys(loaded.guides)).toEqual([]);
-			expect(loaded.malformed).toHaveLength(1);
-			// The per-guide warning goes through notify, not console.warn.
-			expect(notify).toHaveBeenCalled();
-			expect(warn).not.toHaveBeenCalled();
-			const msgs = notify.mock.calls.map((c) => String(c[0])).join("\n");
-			expect(msgs).toContain("Malformed guide");
-			expect(msgs).toContain("boe.es");
-			// Every notify call uses the warning kind (ctx.ui.notify signature).
-			expect(notify.mock.calls.every((c) => c[1] === "warning")).toBe(true);
-		} finally {
-			warn.mockRestore();
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("a divergent + convergent pair sharing shortName loads only the convergent one", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		try {
-			// Old divergent folder (pre-migration) + new convergent folder
-			// (slug). Only the convergent one loads.
-			mkdirSync(join(dir, "boe.es"), { recursive: true });
-			writeFileSync(join(dir, "boe.es", "guide.md"), BOE_RECIPE);
-			mkdirSync(join(dir, "boe"), { recursive: true });
-			writeFileSync(join(dir, "boe", "guide.md"), BOE_RECIPE);
-
-			const loaded = loadApiGuidesFromDir(dir);
-			expect(Object.keys(loaded.guides)).toEqual(["boe"]);
-			expect(loaded.malformed).toHaveLength(1);
-		} finally {
-			warn.mockRestore();
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("routes an empty/all-symbol shortName to malformed without throwing", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		try {
-			for (const bad of ["'!!!'", "''"]) {
-				mkdirSync(join(dir, "bad"), { recursive: true });
-				writeFileSync(
-					join(dir, "bad", "guide.md"),
-					BOE_RECIPE.replace("shortName: BOE", `shortName: ${bad}`),
-				);
-
-				const loaded = loadApiGuidesFromDir(dir);
-				expect(Object.keys(loaded.guides)).toEqual([]);
-				expect(loaded.malformed).toHaveLength(1);
-				expect(loaded.malformed[0]!.filename).toBe("bad");
-				expect(loaded.malformed[0]!.error.field).toBe("shortName");
-				expect(loaded.malformed[0]!.error.fix).toContain("shortName");
-				rmSync(join(dir, "bad"), { recursive: true, force: true });
-			}
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("a divergent guide loads after an agent-assisted rename to slug(shortName)", () => {
-		const dir = mkdtempSync(join(tmpdir(), "host-guides-"));
-		try {
-			// BOE_RECIPE has shortName: BOE → slug "boe"; folder is "boe.es" —
-			// the pre-migration state routes to malformed.
-			mkdirSync(join(dir, "boe.es"), { recursive: true });
-			writeFileSync(join(dir, "boe.es", "guide.md"), BOE_RECIPE);
-			let loaded = loadApiGuidesFromDir(dir);
-			expect(Object.keys(loaded.guides)).toEqual([]);
-			expect(loaded.malformed).toHaveLength(1);
-
-			// The migration instruction (mv boe.es boe); /reload lives in the banner.
-			renameSync(join(dir, "boe.es"), join(dir, "boe"));
-			loaded = loadApiGuidesFromDir(dir);
-			expect(Object.keys(loaded.guides)).toEqual(["boe"]);
-			expect(loaded.malformed).toEqual([]);
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-});
-
-// ═══════════════════════════════════════════════════════════════════
-// stampFrontmatterField — save-stamp blank-line separation (G3)
-// ═══════════════════════════════════════════════════════════════════
-
-describe("stampFrontmatterField", () => {
-	it("inserts a blank line before a new key when the preceding line is non-empty", () => {
-		const out = stampFrontmatterField(
-			"---\nfoo: bar\n---\n",
-			"schemaVersion",
-			"0",
-		);
-		expect(out).toBe("---\nfoo: bar\n\nschemaVersion: 0\n---\n");
-	});
-
-	it("does not double-blank when the preceding line is already empty", () => {
-		const out = stampFrontmatterField(
-			"---\nfoo: bar\n\n---\n",
-			"schemaVersion",
-			"0",
-		);
-		expect(out).toBe("---\nfoo: bar\n\nschemaVersion: 0\n---\n");
-	});
-
-	it("replaces an existing key without introducing a blank line (idempotent re-stamp)", () => {
-		const out = stampFrontmatterField(
-			"---\nfoo: bar\nschemaVersion: 0\n---\n",
-			"schemaVersion",
-			"1",
-		);
-		expect(out).toBe("---\nfoo: bar\nschemaVersion: 1\n---\n");
-	});
-
-	it("replaces a valueless key line instead of duplicating it", () => {
-		// A bare `schemaVersion:` would otherwise survive the replace and
-		// collide with the appended stamp (duplicate YAML key).
-		const out = stampFrontmatterField(
-			"---\nfoo: bar\nschemaVersion:\n---\n",
-			"schemaVersion",
-			"1",
-		);
-		expect(out).toBe("---\nfoo: bar\nschemaVersion: 1\n---\n");
-	});
-});
-
 // ═══════════════════════════════════════════════════════════════════
 // secretPathRefs — token-in-path secret injection
 // ═══════════════════════════════════════════════════════════════════

package/node_modules/pi-lean-host/__tests__/response-spill.test.ts

@@ -114,7 +114,6 @@ describe("spillResponse() — basic spill", () => {
 			expected = JSON.parse(json);
 		} catch {
 			expect.fail("JSON parse failed");
-			return;
 		}
 		expect(parsed).toEqual(expected);
 	});

package/node_modules/pi-lean-host/__tests__/secrets-command.test.ts

@@ -7,6 +7,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { mockCtx, notifyText } from "./test-utils.js";
 import { handleSecretsSubcommand } from "../core/secrets-command.js";
 import {
 	listDomains,
@@ -28,28 +29,11 @@ afterEach(() => {
 	rmSync(dir, { recursive: true, force: true });
 });
 
-function mockCtx(overrides: Record<string, unknown> = {}): any {
-	return {
-		hasUI: true,
-		ui: {
-			input: vi.fn(async () => undefined),
-			confirm: vi.fn(async () => true),
-			notify: vi.fn(),
-		},
-		...overrides,
-	};
-}
-
-/** Collect notify() calls as a single string. */
-function notified(ctx: any): string {
-	return ctx.ui.notify.mock.calls.map((c: any[]) => c[0]).join("\n");
-}
-
 describe("/api secrets — list", () => {
 	it("reports (no secrets stored) with a --help hint when empty (instructions moved to --help)", async () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("", ctx);
-		const text = notified(ctx);
+		const text = notifyText(ctx);
 		expect(text).toContain("(no secrets stored)");
 		expect(text).toContain("--help");
 		// The full instructions block no longer clutters the bare list.
@@ -62,7 +46,7 @@ describe("/api secrets — list", () => {
 
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("", ctx);
-		const text = notified(ctx);
+		const text = notifyText(ctx);
 		expect(text).toContain("d.example");
 		expect(text).toContain("api_key");
 		expect(text).not.toContain("super-secret-value");
@@ -75,7 +59,7 @@ describe("/api secrets --help", () => {
 	it("prints usage + full file-write instructions", async () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("--help", ctx);
-		const text = notified(ctx);
+		const text = notifyText(ctx);
 		expect(text).toContain("Usage: /api secrets");
 		expect(text).toContain("/<domain>.json");
 	});
@@ -83,7 +67,7 @@ describe("/api secrets --help", () => {
 	it("accepts the bare 'help' alias", async () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("help", ctx);
-		expect(notified(ctx)).toContain("Usage: /api secrets");
+		expect(notifyText(ctx)).toContain("Usage: /api secrets");
 	});
 });
 
@@ -98,8 +82,8 @@ describe("/api secrets <domain> <name> — manual entry", () => {
 		expect(promptTitle).toContain("d.example");
 		expect(promptTitle).toContain("api_key");
 		expect(readSecret("d.example", "api_key")).toBe("demo-key-abc");
-		expect(notified(ctx)).toContain("Stored secret 'api_key'");
-		expect(notified(ctx)).not.toContain("demo-key-abc");
+		expect(notifyText(ctx)).toContain("Stored secret 'api_key'");
+		expect(notifyText(ctx)).not.toContain("demo-key-abc");
 	});
 
 	it("aborts on cancel (undefined) without writing", async () => {
@@ -113,7 +97,7 @@ describe("/api secrets <domain> <name> — manual entry", () => {
 		const ctx = mockCtx();
 		ctx.ui.input.mockResolvedValueOnce("   ");
 		await handleSecretsSubcommand("d.example k", ctx);
-		expect(notified(ctx)).toContain("Aborted");
+		expect(notifyText(ctx)).toContain("Aborted");
 		expect(listNames("d.example")).toEqual([]);
 	});
 
@@ -121,7 +105,7 @@ describe("/api secrets <domain> <name> — manual entry", () => {
 		const ctx = mockCtx({ hasUI: false });
 		await handleSecretsSubcommand("d.example k", ctx);
 		expect(ctx.ui.input).not.toHaveBeenCalled();
-		expect(notified(ctx)).toContain("d.example.json");
+		expect(notifyText(ctx)).toContain("d.example.json");
 	});
 });
 
@@ -135,7 +119,7 @@ describe("/api secrets <domain> — assisted entry", () => {
 		await handleSecretsSubcommand("d.example", ctx);
 
 		expect(readSecret("d.example", "api_key")).toBe("demo-key-xyz");
-		const text = notified(ctx);
+		const text = notifyText(ctx);
 		expect(text).toContain("Secrets for 'd.example'");
 		expect(text).not.toContain("demo-key-xyz");
 	});
@@ -146,7 +130,7 @@ describe("/api secrets <domain> — assisted entry", () => {
 		const ctx = mockCtx({ hasUI: false });
 		await handleSecretsSubcommand("d.example", ctx);
 		expect(ctx.ui.input).not.toHaveBeenCalled();
-		const text = notified(ctx);
+		const text = notifyText(ctx);
 		expect(text).toContain("k");
 		expect(text).not.toContain("secret-42");
 	});
@@ -188,7 +172,7 @@ body
 			expect(prompt).toContain("d.example");
 			expect(prompt).toContain("api_key");
 			expect(readSecret("d.example", "api_key")).toBe("demo-key-abc");
-			const text = notified(ctx);
+			const text = notifyText(ctx);
 			expect(text).toContain("Declared (guide): api_key");
 			expect(text).not.toContain("demo-key-abc");
 		} finally {
@@ -248,7 +232,7 @@ describe("/api secrets <domain> <name> --delete", () => {
 
 		expect(ctx.ui.confirm).not.toHaveBeenCalled();
 		expect(readSecret("d.example", "k")).toBeNull();
-		const text = notified(ctx);
+		const text = notifyText(ctx);
 		expect(text).toContain("Deleted secret 'k'");
 		expect(text).not.toContain("secret-42");
 	});
@@ -259,7 +243,7 @@ describe("/api secrets <domain> <name> --delete", () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("d.example nope --delete", ctx);
 		expect(readSecret("d.example", "keep")).toBe("1");
-		expect(notified(ctx)).toContain("No secret 'nope'");
+		expect(notifyText(ctx)).toContain("No secret 'nope'");
 	});
 
 	it("prunes the domain file after deleting the last secret", async () => {
@@ -289,7 +273,7 @@ describe("/api secrets <domain> --delete", () => {
 		expect(ctx.ui.confirm).toHaveBeenCalledTimes(1);
 		expect(readSecret("d.example", "a")).toBeNull();
 		expect(readSecret("d.example", "b")).toBeNull();
-		expect(notified(ctx)).toContain("Deleted all secrets for 'd.example'.");
+		expect(notifyText(ctx)).toContain("Deleted all secrets for 'd.example'.");
 	});
 
 	it("aborts (nothing deleted) when the user declines the confirm", async () => {
@@ -300,7 +284,7 @@ describe("/api secrets <domain> --delete", () => {
 
 		await handleSecretsSubcommand("d.example --delete", ctx);
 		expect(readSecret("d.example", "a")).toBe("1");
-		expect(notified(ctx)).toContain("Cancelled");
+		expect(notifyText(ctx)).toContain("Cancelled");
 	});
 
 	it("headless deletes all without prompting or hanging", async () => {
@@ -314,7 +298,7 @@ describe("/api secrets <domain> --delete", () => {
 	it("reports when a domain has no secrets", async () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("empty.example --delete", ctx);
-		expect(notified(ctx)).toContain("No secrets stored");
+		expect(notifyText(ctx)).toContain("No secrets stored");
 	});
 });
 
@@ -322,12 +306,12 @@ describe("/api secrets --delete misuse", () => {
 	it("bare --delete without a domain is a usage warning", async () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("--delete", ctx);
-		expect(notified(ctx)).toContain("Usage");
+		expect(notifyText(ctx)).toContain("Usage");
 	});
 
 	it("--help wins over --delete", async () => {
 		const ctx = mockCtx();
 		await handleSecretsSubcommand("--delete --help", ctx);
-		expect(notified(ctx)).toContain("Usage: /api secrets");
+		expect(notifyText(ctx)).toContain("Usage: /api secrets");
 	});
 });