@oh-my-pi/pi-coding-agent 17.0.0 → 17.0.2

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

@@ -201,9 +201,13 @@ describe("WATCHDOG.yml file round-trip", () => {
 	});
 
 	const doc: WatchdogConfigDoc = {
-		instructions: 'Shared baseline.\nSecond line with: a colon and "quotes".',
+		instructions: 'Shared baseline.\n\nSecond line with: a colon and "quotes".',
 		advisors: [
-			{ name: "Architecture", model: "x-ai/grok-code-fast:high", instructions: "Watch module boundaries." },
+			{
+				name: "Architecture",
+				model: "x-ai/grok-code-fast:high",
+				instructions: "Watch module boundaries.\nReport coupling.",
+			},
 			{ name: "Security", tools: ["read", "grep"] },
 		],
 	};
@@ -222,11 +226,25 @@ describe("WATCHDOG.yml file round-trip", () => {
 		// Block style (not the flow `{...}` form), so it stays hand-editable.
 		expect(text).toContain("advisors:");
 		expect(text).not.toMatch(/^\{/);
+		expect(text).toContain('instructions: |2-\n  Shared baseline.\n  \n  Second line with: a colon and "quotes".');
+		expect(text).toContain("    instructions: |2-\n      Watch module boundaries.\n      Report coupling.");
+		expect(text).not.toContain("\\n");
 		const { advisors, sharedInstructions } = await discoverAdvisorConfigs(tmp, tmp);
 		expect(advisors.map(a => a.name)).toEqual(["Architecture", "Security"]);
 		expect(sharedInstructions).toContain("Shared baseline.");
 	});
 
+	it("preserves significant leading whitespace and trailing newlines in block scalars", async () => {
+		const file = path.join(tmp, "WATCHDOG.yml");
+		const whitespaceDoc: WatchdogConfigDoc = {
+			instructions: "  indented first line\nplain second line\n\n",
+			advisors: [{ name: "Whitespace", instructions: "\n  indented after blank\nplain" }],
+		};
+
+		await saveWatchdogConfigFile(file, whitespaceDoc);
+		expect(await loadWatchdogConfigFile(file)).toEqual(whitespaceDoc);
+	});
+
 	it("round-trips an explicit empty tools list without collapsing it into the default", async () => {
 		const file = path.join(tmp, "WATCHDOG.yml");
 		const explicitNoToolsDoc: WatchdogConfigDoc = {
@@ -291,3 +309,41 @@ describe("resolveAdvisorConfigEditPath", () => {
 		expect(await resolveAdvisorConfigEditPath("project", dirs(tmp))).toBe(path.join(tmp, "WATCHDOG.yml"));
 	});
 });
+
+describe("per-advisor enabled field", () => {
+	it("preserves explicit true, explicit false, and absence through save and discovery", async () => {
+		const tmp = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-advisor-enabled-"));
+		try {
+			const doc: WatchdogConfigDoc = {
+				advisors: [
+					{ name: "Explicit On", model: "test/model-a", enabled: true },
+					{ name: "Explicit Off", model: "test/model-b", enabled: false },
+					{ name: "Default", model: "test/model-c" },
+				],
+			};
+			const file = path.join(tmp, "WATCHDOG.yml");
+			await saveWatchdogConfigFile(file, doc);
+
+			const loaded = await loadWatchdogConfigFile(file);
+			expect(loaded.advisors.map(advisor => advisor.enabled)).toEqual([true, false, undefined]);
+
+			const { advisors } = await discoverAdvisorConfigs(tmp, tmp);
+			expect(advisors.map(advisor => advisor.enabled)).toEqual([true, false, undefined]);
+		} finally {
+			await fsp.rm(tmp, { recursive: true, force: true });
+		}
+	});
+
+	it("emits explicit boolean values but omits an absent enabled field", () => {
+		const text = serializeWatchdogConfig({
+			advisors: [
+				{ name: "Explicit On", enabled: true },
+				{ name: "Explicit Off", enabled: false },
+				{ name: "Default" },
+			],
+		});
+		expect(text).toContain("enabled: true");
+		expect(text).toContain("enabled: false");
+		expect(text.match(/enabled:/g)).toHaveLength(2);
+	});
+});

package/src/advisor/advise-tool.ts

@@ -106,8 +106,11 @@ export function isAdvisorInterruptImmuneTurnActive(opts: {
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
  *   advice is acted on immediately.
  * - If the primary tail is already a terminal text answer and there is no queued
- *   work, late interrupting advice is preserved as a visible card instead of
- *   waking the primary to restate completion.
+ *   work, a late `concern` is preserved as a visible card instead of waking the
+ *   primary to restate completion. A `blocker` is the exception: it means the
+ *   agent handed off broken or unexercised work, so it still steers a triggered
+ *   turn to force the primary to acknowledge and continue before the turn is
+ *   considered done (#5628) — deferring it to the next user turn is the bug.
  * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
  *   not auto-resume the stopped run. While the agent is idle — or still tearing
  *   the interrupted turn down (`aborting`) — the note is preserved as a visible
@@ -129,7 +132,8 @@ export function resolveAdvisorDeliveryChannel(opts: {
 }): AdvisorDeliveryChannel {
 	if (!isInterruptingSeverity(opts.severity)) return "aside";
 	if (opts.autoResumeSuppressed && (opts.aborting || !opts.streaming)) return "preserve";
-	if (opts.terminalAnswerNoQueuedWork && !opts.streaming && !opts.aborting) return "preserve";
+	if (opts.terminalAnswerNoQueuedWork && opts.severity !== "blocker" && !opts.streaming && !opts.aborting)
+		return "preserve";
 	if (opts.interruptImmuneTurnActive) return "aside";
 	return "steer";
 }

package/src/advisor/config.ts

@@ -22,8 +22,23 @@ export interface AdvisorConfig {
 	model?: string;
 	tools?: string[];
 	instructions?: string;
+	/** Per-advisor on/off toggle (default `true`). When `false`, the advisor
+	 *  stays in the roster but its runtime is never built — it shows `○` in
+	 *  the status line and `/advisor status` rather than disappearing. */
+	enabled?: boolean;
 }
 
+/**
+ * Runtime health of a single advisor, surfaced in stats and the status line.
+ * - `running` — actively processing primary turns
+ * - `paused` — user-toggled off via per-advisor switch (runtime disposed)
+ * - `quota_exhausted` — provider returned a quota/rate-limit error; the
+ *   runtime auto-retries after a cooldown so it can resume without user action
+ * - `error` — repeated transient failures; backlog dropped to prevent stall
+ * - `no_model` — no model resolved for this advisor's role/explicit model
+ */
+export type AdvisorRuntimeStatus = "running" | "paused" | "quota_exhausted" | "error" | "no_model";
+
 /**
  * The result of walking the `WATCHDOG.yml`/`WATCHDOG.yaml` search path: the
  * deduped advisor roster plus the concatenated top-level `instructions` baseline
@@ -39,6 +54,7 @@ const advisorEntrySchema = type({
 	"model?": "string",
 	"tools?": "string[]",
 	"instructions?": "string",
+	"enabled?": "boolean",
 });
 
 const watchdogYamlSchema = type({
@@ -156,6 +172,7 @@ export async function discoverAdvisorConfigs(cwd: string, agentDir?: string): Pr
 				model: entry.model?.trim() || undefined,
 				tools: filterAdvisorTools(entry.tools, item.path),
 				instructions,
+				enabled: entry.enabled,
 			});
 		}
 	}
@@ -236,38 +253,73 @@ export async function loadWatchdogConfigFile(filePath: string): Promise<Watchdog
 		logger.warn("Advisor config: invalid schema for edit", { path: filePath, error: result.summary });
 		return { advisors: [] };
 	}
-	return {
-		instructions: result.instructions?.trim() ? result.instructions : undefined,
-		advisors: (result.advisors ?? []).map(a => ({
-			name: a.name,
-			model: a.model?.trim() || undefined,
-			tools: a.tools === undefined ? undefined : [...a.tools],
-			instructions: a.instructions?.trim() ? a.instructions : undefined,
-		})),
-	};
+	const advisors = (result.advisors ?? []).map(a => {
+		const advisor: AdvisorConfig = { name: a.name };
+		if (a.model?.trim()) advisor.model = a.model;
+		if (a.tools !== undefined) advisor.tools = [...a.tools];
+		if (a.instructions?.trim()) advisor.instructions = a.instructions;
+		if (a.enabled !== undefined) advisor.enabled = a.enabled;
+		return advisor;
+	});
+	const doc: WatchdogConfigDoc = { advisors };
+	if (result.instructions?.trim()) doc.instructions = result.instructions;
+	return doc;
 }
 
 /**
- * Serialize an editable doc back to block-style `WATCHDOG.yml` text via Bun's
- * `YAML.stringify` (the same API the repo uses for other hand-editable config),
- * omitting empty fields. Round-trips through {@link loadWatchdogConfigFile}.
+ * Serialize an editable doc back to canonical, hand-editable `WATCHDOG.yml`.
+ * Multiline instruction fields use literal block scalars while scalar quoting
+ * delegates to Bun's YAML encoder. Round-trips through {@link loadWatchdogConfigFile}.
  * Returns `""` for an empty doc.
  */
+
+function appendYamlString(lines: string[], indent: string, key: string, value: string): void {
+	const hasSignificantLeadingWhitespace = value.split("\n").some(line => /^[ \t]/.test(line));
+	if (!value.includes("\n") || hasSignificantLeadingWhitespace) {
+		lines.push(`${indent}${key}: ${YAML.stringify(value)}`);
+		return;
+	}
+	const normalized = value.replaceAll("\r\n", "\n");
+	let trailingNewlines = 0;
+	for (let index = normalized.length - 1; index >= 0 && normalized[index] === "\n"; index--) {
+		trailingNewlines++;
+	}
+	const chomp = trailingNewlines === 0 ? "|2-" : trailingNewlines === 1 ? "|2" : "|2+";
+	const body = trailingNewlines === 0 ? normalized : normalized.slice(0, -trailingNewlines);
+	lines.push(`${indent}${key}: ${chomp}`);
+	for (const line of body.split("\n")) {
+		lines.push(`${indent}  ${line}`);
+	}
+	for (let index = 1; index < trailingNewlines; index++) {
+		lines.push(`${indent}  `);
+	}
+}
+
 export function serializeWatchdogConfig(doc: WatchdogConfigDoc): string {
-	const out: { instructions?: string; advisors?: AdvisorConfig[] } = {};
-	if (doc.instructions?.trim()) out.instructions = doc.instructions;
+	const lines: string[] = [];
+	if (doc.instructions?.trim()) appendYamlString(lines, "", "instructions", doc.instructions);
 	if (doc.advisors.length > 0) {
-		out.advisors = doc.advisors.map(a => {
-			const entry: AdvisorConfig = { name: a.name };
-			if (a.model?.trim()) entry.model = a.model;
-			if (a.tools !== undefined) entry.tools = [...a.tools];
-			if (a.instructions?.trim()) entry.instructions = a.instructions;
-			return entry;
-		});
+		lines.push("advisors:");
+		for (const advisor of doc.advisors) {
+			lines.push(`  - name: ${YAML.stringify(advisor.name)}`);
+			if (advisor.model?.trim()) lines.push(`    model: ${YAML.stringify(advisor.model)}`);
+			if (advisor.tools !== undefined) {
+				if (advisor.tools.length === 0) {
+					lines.push("    tools: []");
+				} else {
+					lines.push("    tools:");
+					for (const tool of advisor.tools) {
+						lines.push(`      - ${YAML.stringify(tool)}`);
+					}
+				}
+			}
+			if (advisor.instructions?.trim()) {
+				appendYamlString(lines, "    ", "instructions", advisor.instructions);
+			}
+			if (advisor.enabled !== undefined) lines.push(`    enabled: ${advisor.enabled}`);
+		}
 	}
-	if (out.instructions === undefined && out.advisors === undefined) return "";
-	const text = YAML.stringify(out, null, 2);
-	return text.endsWith("\n") ? text : `${text}\n`;
+	return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
 }
 
 /**