@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.4

package/src/advisor/__tests__/advisor.test.ts

@@ -1,25 +1,33 @@
 import { describe, expect, it, vi } from "bun:test";
 import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
+import type { TUI } from "@oh-my-pi/pi-tui";
 import { type } from "arktype";
+import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
+import { type AdvisorConfigDeps, AdvisorConfigOverlayComponent } from "../../modes/components/advisor-config";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
-import { getThemeByName } from "../../modes/theme/theme";
+import { getThemeByName, setThemeInstance } from "../../modes/theme/theme";
 import advisorSystemPrompt from "../../prompts/advisor/system.md" with { type: "text" };
 import { SecretObfuscator } from "../../secrets/obfuscator";
 import { formatSessionHistoryMarkdown } from "../../session/session-history-format";
 import { YieldQueue } from "../../session/yield-queue";
+import { BUILTIN_TOOL_NAMES } from "../../tools/builtin-names";
 import {
-	ADVISOR_READONLY_TOOL_NAMES,
+	ADVISOR_DEFAULT_TOOL_NAMES,
 	AdviseTool,
 	type AdvisorAgent,
 	type AdvisorNote,
 	AdvisorRuntime,
 	type AdvisorRuntimeHost,
+	advisorTranscriptFilename,
 	deriveAdvisorTelemetry,
 	formatAdvisorBatchContent,
 	formatAdvisorContextPrompt,
 	isAdvisorInterruptImmuneTurnActive,
+	isAdvisorTranscriptName,
 	isInterruptingSeverity,
 	resolveAdvisorDeliveryChannel,
+	type WatchdogConfigDoc,
 } from "..";
 
 describe("advisor", () => {
@@ -158,6 +166,57 @@ describe("advisor", () => {
 		});
 	});
 
+	describe("formatSessionHistoryMarkdown expandEditDiffs", () => {
+		const diff = "--- a/foo.ts\n+++ b/foo.ts\n@@ -1,2 +1,2 @@\n-const x = 1;\n+const x = 2;";
+		const editCall = {
+			role: "assistant",
+			content: [{ type: "toolCall", id: "c1", name: "edit", arguments: { path: "foo.ts" } }],
+			timestamp: 1,
+		} as unknown as AgentMessage;
+		const editResult = {
+			role: "toolResult",
+			toolCallId: "c1",
+			toolName: "edit",
+			content: "ok",
+			details: { diff },
+			timestamp: 2,
+		} as unknown as AgentMessage;
+
+		it("appends the full diff in a fenced block when expandEditDiffs is set", () => {
+			const md = formatSessionHistoryMarkdown([editCall, editResult], {
+				expandEditDiffs: true,
+				watchedRoles: true,
+			});
+			expect(md).toContain("```diff");
+			expect(md).toContain("-const x = 1;");
+			expect(md).toContain("+const x = 2;");
+		});
+
+		it("omits the diff body without the flag", () => {
+			const md = formatSessionHistoryMarkdown([editCall, editResult], { watchedRoles: true });
+			expect(md).not.toContain("```diff");
+			expect(md).not.toContain("+const x = 2;");
+		});
+
+		it("widens the fence past backtick runs in the diff body", () => {
+			const fenced = "--- a/readme.md\n+++ b/readme.md\n@@ -1 +1 @@\n-```\n+```ts\n+code\n+```";
+			const result = {
+				role: "toolResult",
+				toolCallId: "c1",
+				toolName: "edit",
+				content: "ok",
+				details: { diff: fenced },
+				timestamp: 2,
+			} as unknown as AgentMessage;
+			const md = formatSessionHistoryMarkdown([editCall, result], {
+				expandEditDiffs: true,
+				watchedRoles: true,
+			});
+			// The body contains a ``` run, so the wrapping fence widens to 4 backticks.
+			expect(md).toContain("````diff");
+		});
+	});
+
 	describe("advisor yield-queue dispatcher", () => {
 		it("batches advice notes into one custom message", async () => {
 			const injected: AgentMessage[] = [];
@@ -373,6 +432,18 @@ describe("advisor", () => {
 			// Exactly one severity attribute (only the blocker note carries one).
 			expect(content.split('severity="').length - 1).toBe(1);
 		});
+
+		it("emits an advisor attribute only for named advisors, escaping the name", () => {
+			const content = formatAdvisorBatchContent([
+				{ note: "named note", advisor: 'Arch "X"' },
+				{ note: "default note" },
+			]);
+			// Named advisor: attribute present, double quote escaped for attribute context.
+			expect(content).toContain('advisor="Arch "X""');
+			// A note with no source (the legacy/default advisor) carries no advisor attribute.
+			expect(content.split('advisor="').length - 1).toBe(1);
+			expect(content).toContain("default note");
+		});
 	});
 
 	describe("deriveAdvisorTelemetry", () => {
@@ -662,6 +733,46 @@ describe("advisor", () => {
 			expect(promptInputs[0]).not.toContain(secret);
 		});
 
+		it("surfaces edit diff details but redacts secrets inside the diff", async () => {
+			const secret = "DIFF_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const diff = `--- a/config.ts\n+++ b/config.ts\n@@ -1 +1 @@\n-const token = "old";\n+const token = "${secret}";`;
+			const messages: AgentMessage[] = [
+				{
+					role: "assistant",
+					content: [{ type: "toolCall", id: "c1", name: "edit", arguments: { path: "config.ts" } }],
+					timestamp: 1,
+				} as unknown as AgentMessage,
+				{
+					role: "toolResult",
+					toolCallId: "c1",
+					toolName: "edit",
+					content: "ok",
+					details: { diff },
+					timestamp: 2,
+				} as unknown as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			// The diff is surfaced to the advisor (expandEditDiffs) ...
+			expect(promptInputs[0]).toContain("+const token =");
+			// ... but a secret living inside details.diff is obfuscated (details now walked).
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
 		it("expands plan-mode context once, then collapses an unchanged re-injection", async () => {
 			const promptInputs: string[] = [];
 			const agent = makeAgent(promptInputs);
@@ -1259,14 +1370,18 @@ describe("advisor", () => {
 		});
 	});
 
-	describe("read-only tool allowlist", () => {
-		it("selects only the investigation tools from a mixed toolset", () => {
-			const toolset = ["read", "edit", "grep", "bash", "glob", "write", "advise"];
-			const selected = toolset.filter(name => ADVISOR_READONLY_TOOL_NAMES.has(name));
-			expect(selected).toEqual(["read", "grep", "glob"]);
-			expect(ADVISOR_READONLY_TOOL_NAMES.has("edit")).toBe(false);
-			expect(ADVISOR_READONLY_TOOL_NAMES.has("bash")).toBe(false);
-			expect(ADVISOR_READONLY_TOOL_NAMES.has("write")).toBe(false);
+	describe("advisor default tools", () => {
+		it("defaults to read/grep/glob, a subset of the full grantable tool pool", () => {
+			expect([...ADVISOR_DEFAULT_TOOL_NAMES]).toEqual(["read", "grep", "glob"]);
+			// The advisor is a full agent now: every built tool is grantable (no hard
+			// read-only restriction), including mutating ones like edit/bash/write.
+			const builtin = new Set<string>(BUILTIN_TOOL_NAMES);
+			for (const name of ["read", "grep", "glob", "edit", "bash", "write"]) {
+				expect(builtin.has(name)).toBe(true);
+			}
+			for (const name of ADVISOR_DEFAULT_TOOL_NAMES) {
+				expect(builtin.has(name)).toBe(true);
+			}
 		});
 	});
 
@@ -1289,6 +1404,26 @@ describe("advisor", () => {
 			expect(text).toContain("watch the empty case");
 		});
 
+		it("prefixes the note with a named-advisor label, but not for the default advisor", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			const card = createAdvisorMessageCard(
+				{
+					notes: [
+						{ note: "module boundary leak", severity: "concern", advisor: "Architecture" },
+						{ note: "default-advisor note", advisor: "default" },
+					],
+				},
+				() => true,
+				uiTheme,
+			);
+			const text = strip(card.render(80));
+			expect(text).toContain("[Architecture]");
+			expect(text).toContain("module boundary leak");
+			// The implicit "default" advisor stays unlabeled.
+			expect(text).not.toContain("[default]");
+		});
+
 		it("collapses to the first notes with an overflow hint", async () => {
 			const uiTheme = await getThemeByName("dark");
 			if (!uiTheme) throw new Error("theme unavailable");
@@ -1427,4 +1562,101 @@ describe("advisor", () => {
 			}
 		});
 	});
+	describe("advisor transcript filenames", () => {
+		it("derives default and named transcript filenames", () => {
+			expect(advisorTranscriptFilename("")).toBe("__advisor.jsonl");
+			expect(advisorTranscriptFilename("arch")).toBe("__advisor.arch.jsonl");
+		});
+
+		it("recognizes default and named advisor transcripts, and nothing else", () => {
+			expect(isAdvisorTranscriptName("__advisor.jsonl")).toBe(true);
+			expect(isAdvisorTranscriptName("__advisor.arch.jsonl")).toBe(true);
+			expect(isAdvisorTranscriptName("__advisor-2.jsonl")).toBe(false);
+			expect(isAdvisorTranscriptName("Foo.jsonl")).toBe(false);
+			expect(isAdvisorTranscriptName("__advisor.arch.bak")).toBe(false);
+		});
+	});
+
+	describe("AdvisorConfigOverlayComponent", () => {
+		const deps = {
+			modelRegistry: { getCanonicalModelSelections: () => [] } as unknown as ModelRegistry,
+			settings: {} as unknown as Settings,
+			scopedModels: [],
+			availableToolNames: ["read", "grep", "glob", "lsp", "web_search"],
+		};
+		const callbacks = {
+			loadDoc: async () => ({ advisors: [] }),
+			save: async () => {},
+			close: () => {},
+			requestRender: () => {},
+			notify: () => {},
+		};
+		const strip = (lines: readonly string[]): string => lines.join("\n").replace(/\x1b\[[0-9;]*m/g, "");
+		const make = (doc: WatchdogConfigDoc, extra?: Partial<AdvisorConfigDeps>): AdvisorConfigOverlayComponent =>
+			new AdvisorConfigOverlayComponent({} as unknown as TUI, { ...deps, ...extra }, "project", doc, callbacks);
+		const fullHeight = Math.max(14, process.stdout.rows || 40);
+
+		it("paints a full-screen split frame: roster sidebar + selected-advisor preview", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({
+				instructions: "shared baseline",
+				advisors: [
+					{ name: "Architecture", model: "x-ai/grok-code-fast:high" },
+					{ name: "Security", tools: ["read", "web_search"] },
+				],
+			});
+			const frame = overlay.render(200);
+			// Fills the screen top-to-bottom (the fix for the bottom-anchored frame
+			// whose offset broke mouse hit-testing and wasted the upper space).
+			expect(frame.length).toBe(fullHeight);
+			const text = strip(frame);
+			expect(text).toContain("Advisor configuration");
+			expect(text).toContain("project");
+			expect(text).toContain("Architecture");
+			expect(text).toContain("Security");
+			expect(text).toContain("+ Add advisor");
+			expect(text).toContain("Save & apply");
+			// Right preview reflects the highlighted (first) advisor.
+			expect(text).toContain("x-ai/grok-code-fast:high");
+			expect(text).toContain("read, grep, glob (default)");
+		});
+
+		it("moves the preview with keyboard selection and preserves an explicit tool set", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({
+				advisors: [{ name: "Architecture" }, { name: "Security", tools: ["read", "web_search"] }],
+			});
+			overlay.render(200);
+			overlay.handleInput("\x1b[B"); // arrow down → highlight Security
+			expect(strip(overlay.render(200))).toContain("read, web_search");
+		});
+
+		it("opens an advisor's detail editor on a left click in the sidebar", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({ advisors: [{ name: "Architecture" }, { name: "Security" }] });
+			// Render once so the frame geometry is recorded; the first advisor sits on
+			// the first body row (0-based screen row 1 → SGR 1-based row 2).
+			overlay.render(120);
+			overlay.handleInput("\x1b[<0;4;2M"); // left-button press, col 4, row 2
+			const text = strip(overlay.render(120));
+			expect(text).toContain("Editing");
+			expect(text).toContain("Architecture");
+		});
+
+		it("seeds a visible default advisor (labeled with the role model) when the config is empty", async () => {
+			const uiTheme = await getThemeByName("dark");
+			if (!uiTheme) throw new Error("theme unavailable");
+			setThemeInstance(uiTheme);
+			const overlay = make({ advisors: [] }, { defaultModelLabel: "anthropic/claude-opus" });
+			const text = strip(overlay.render(200));
+			expect(text).toContain("default");
+			expect(text).toContain("anthropic/claude-opus");
+		});
+	});
 });

package/src/advisor/__tests__/config.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import * as fsp from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+	advisorConfigFilePath,
+	discoverAdvisorConfigs,
+	loadWatchdogConfigFile,
+	resolveAdvisorConfigEditPath,
+	saveWatchdogConfigFile,
+	serializeWatchdogConfig,
+	slugifyAdvisorName,
+	type WatchdogConfigDoc,
+} from "../config";
+
+describe("discoverAdvisorConfigs", () => {
+	let tmp: string;
+	let agentDir: string;
+
+	beforeEach(async () => {
+		tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-config-"));
+		// Empty agent dir so the user-level search path can't pick up a real ~/.omp/WATCHDOG.yml.
+		agentDir = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-agentdir-"));
+	});
+
+	afterEach(async () => {
+		await fsp.rm(tmp, { recursive: true, force: true });
+		await fsp.rm(agentDir, { recursive: true, force: true });
+	});
+
+	it("parses advisors, the model thinking suffix, tool filtering, and shared instructions", async () => {
+		const yaml = [
+			"instructions: Shared baseline for all advisors.",
+			"advisors:",
+			"  - name: Architecture",
+			"    model: x-ai/grok-code-fast:high",
+			"    instructions: Watch module boundaries.",
+			"  - name: Security Reviewer",
+			"    tools: [read, definitely-not-a-tool]",
+		].join("\n");
+		await Bun.write(path.join(tmp, "WATCHDOG.yml"), yaml);
+
+		const { advisors, sharedInstructions } = await discoverAdvisorConfigs(tmp, agentDir);
+		expect(advisors).toHaveLength(2);
+		const [arch, sec] = advisors;
+		expect(arch.name).toBe("Architecture");
+		// The model selector (incl. the `:high` thinking suffix) is stored verbatim;
+		// resolution happens later in the session, not here.
+		expect(arch.model).toBe("x-ai/grok-code-fast:high");
+		expect(arch.instructions).toBe("Watch module boundaries.");
+		expect(sec.name).toBe("Security Reviewer");
+		expect(sec.model).toBeUndefined();
+		// The unknown/non-read-only tool is dropped; only `read` survives.
+		expect(sec.tools).toEqual(["read"]);
+		expect(sharedInstructions).toBe("Shared baseline for all advisors.");
+	});
+
+	it("ignores a malformed YAML file without throwing", async () => {
+		await Bun.write(path.join(tmp, "WATCHDOG.yml"), "advisors: [unclosed bracket");
+		const result = await discoverAdvisorConfigs(tmp, agentDir);
+		expect(result.advisors).toEqual([]);
+		expect(result.sharedInstructions).toBeUndefined();
+	});
+
+	it("skips a file whose shape fails the schema (advisors must be a list)", async () => {
+		await Bun.write(path.join(tmp, "WATCHDOG.yml"), "advisors: not-an-array");
+		const result = await discoverAdvisorConfigs(tmp, agentDir);
+		expect(result.advisors).toEqual([]);
+	});
+
+	it("returns an empty roster when no config file exists", async () => {
+		const result = await discoverAdvisorConfigs(tmp, agentDir);
+		expect(result.advisors).toEqual([]);
+		expect(result.sharedInstructions).toBeUndefined();
+	});
+});
+
+describe("slugifyAdvisorName", () => {
+	it("lowercases and collapses non-alphanumeric runs to single hyphens", () => {
+		expect(slugifyAdvisorName("Security Reviewer")).toBe("security-reviewer");
+		expect(slugifyAdvisorName("  Arch/Boundaries!  ")).toBe("arch-boundaries");
+	});
+
+	it("falls back to 'advisor' when nothing alphanumeric survives", () => {
+		expect(slugifyAdvisorName("!!!")).toBe("advisor");
+	});
+});
+
+describe("WATCHDOG.yml file round-trip", () => {
+	let tmp: string;
+	beforeEach(async () => {
+		tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-file-"));
+	});
+	afterEach(async () => {
+		await fsp.rm(tmp, { recursive: true, force: true });
+	});
+
+	const doc: WatchdogConfigDoc = {
+		instructions: 'Shared baseline.\nSecond line with: a colon and "quotes".',
+		advisors: [
+			{ name: "Architecture", model: "x-ai/grok-code-fast:high", instructions: "Watch module boundaries." },
+			{ name: "Security", tools: ["read", "grep"] },
+		],
+	};
+
+	it("saves and reloads a doc byte-equivalently (incl. multiline and special chars)", async () => {
+		const file = path.join(tmp, "WATCHDOG.yml");
+		await saveWatchdogConfigFile(file, doc);
+		const loaded = await loadWatchdogConfigFile(file);
+		expect(loaded).toEqual(doc);
+	});
+
+	it("serializes block-style YAML that the discovery path also parses", async () => {
+		const file = path.join(tmp, "WATCHDOG.yml");
+		await saveWatchdogConfigFile(file, doc);
+		const text = await Bun.file(file).text();
+		// Block style (not the flow `{...}` form), so it stays hand-editable.
+		expect(text).toContain("advisors:");
+		expect(text).not.toMatch(/^\{/);
+		const { advisors, sharedInstructions } = await discoverAdvisorConfigs(tmp, tmp);
+		expect(advisors.map(a => a.name)).toEqual(["Architecture", "Security"]);
+		expect(sharedInstructions).toContain("Shared baseline.");
+	});
+
+	it("removes the file when the doc is empty so legacy discovery resumes", async () => {
+		const file = path.join(tmp, "WATCHDOG.yml");
+		await saveWatchdogConfigFile(file, doc);
+		await saveWatchdogConfigFile(file, { advisors: [] });
+		expect(await Bun.file(file).exists()).toBe(false);
+		// Loading a missing file yields an empty doc, never throws.
+		expect(await loadWatchdogConfigFile(file)).toEqual({ advisors: [] });
+	});
+
+	it("returns an empty serialization for an empty doc", () => {
+		expect(serializeWatchdogConfig({ advisors: [] })).toBe("");
+	});
+
+	it("resolves project and user scope paths", () => {
+		expect(advisorConfigFilePath("project", { projectDir: "/repo", agentDir: "/home/.omp" })).toBe(
+			path.join("/repo", "WATCHDOG.yml"),
+		);
+		expect(advisorConfigFilePath("user", { projectDir: "/repo", agentDir: "/home/.omp" })).toBe(
+			path.join("/home/.omp", "WATCHDOG.yml"),
+		);
+	});
+});
+
+describe("resolveAdvisorConfigEditPath", () => {
+	let tmp: string;
+	beforeEach(async () => {
+		tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-resolve-"));
+	});
+	afterEach(async () => {
+		await fsp.rm(tmp, { recursive: true, force: true });
+	});
+
+	const dirs = (d: string) => ({ projectDir: d, agentDir: d });
+
+	it("defaults to .yml when neither file exists", async () => {
+		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yml"));
+	});
+
+	it("edits an existing .yaml in place when only it exists", async () => {
+		await Bun.write(path.join(tmp, "WATCHDOG.yaml"), "advisors: []\n");
+		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yaml"));
+	});
+
+	it("prefers the canonical .yml when both exist", async () => {
+		await Bun.write(path.join(tmp, "WATCHDOG.yml"), "advisors: []\n");
+		await Bun.write(path.join(tmp, "WATCHDOG.yaml"), "advisors: []\n");
+		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yml"));
+	});
+});

package/src/advisor/advise-tool.ts

@@ -6,7 +6,7 @@ import type {
 	AgentToolResult,
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
-import { escapeXmlText } from "@oh-my-pi/pi-utils";
+import { escapeXmlAttribute, escapeXmlText } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
 import adviseDescription from "../prompts/advisor/advise-tool.md" with { type: "text" };
 
@@ -24,12 +24,16 @@ export type AdvisorSeverity = "nit" | "concern" | "blocker";
 export interface AdviseDetails {
 	note: string;
 	severity?: AdvisorSeverity;
+	/** Which configured advisor produced this note (omitted for the default advisor). */
+	advisor?: string;
 }
 
 /** One queued advice note. */
 export interface AdvisorNote {
 	note: string;
 	severity?: AdvisorSeverity;
+	/** Which configured advisor produced this note (omitted for the default advisor). */
+	advisor?: string;
 }
 
 /** Details payload on the batched `advisor` custom message rendered in the transcript. */
@@ -55,7 +59,8 @@ export function formatAdvisorBatchContent(notes: readonly AdvisorNote[]): string
 	return notes
 		.map(n => {
 			const severity = n.severity ? ` severity="${n.severity}"` : "";
-			return `<advisory${severity} guidance="${ADVISOR_GUIDANCE}">\n${escapeXmlText(n.note)}\n</advisory>`;
+			const who = n.advisor ? ` advisor="${escapeXmlAttribute(n.advisor)}"` : "";
+			return `<advisory${who}${severity} guidance="${ADVISOR_GUIDANCE}">\n${escapeXmlText(n.note)}\n</advisory>`;
 		})
 		.join("\n");
 }
@@ -133,11 +138,11 @@ export function deriveAdvisorTelemetry(
 }
 
 /**
- * Side-effect-free investigation tools handed to the advisor agent so it can
- * inspect the workspace before weighing in. Names match the primary session's
- * tool instances, which the advisor reuses.
+ * The tools an advisor receives by default when its config omits `tools` — the
+ * read-only investigative set. The full available pool is every built tool the
+ * session has (the advisor is a full agent); a config's `tools` selects from it.
  */
-export const ADVISOR_READONLY_TOOL_NAMES: ReadonlySet<string> = new Set(["read", "grep", "glob"]);
+export const ADVISOR_DEFAULT_TOOL_NAMES: ReadonlySet<string> = new Set(["read", "grep", "glob"]);
 
 function advisorNoteDedupeKey(note: string): string {
 	return note.trim().replace(/\s+/g, " ");