@oh-my-pi/pi-coding-agent 16.1.22 → 16.2.0

package/scripts/build-binary.ts

@@ -49,8 +49,8 @@ async function main(): Promise<void> {
 	// Generate inside the try so the finally always restores the empty checked-in
 	// placeholders (stats client archive, docs index) even on failure.
 	try {
-		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
-		await runCommand(["bun", "scripts/generate-docs-index.ts", "--generate"]);
+		await runCommand(["bun", "--cwd=../stats", "run", "gen:stats"]);
+		await runCommand(["bun", "run", "gen:docs"]);
 		// `legacy-pi-bundled-registry.ts` static-imports
 		// `@oh-my-pi/pi-coding-agent/export/html` (one of pi-coding-agent's
 		// named subpath exports, see scripts/generate-legacy-pi-bundled-registry.ts),
@@ -61,14 +61,14 @@ async function main(): Promise<void> {
 		// resolving the missing generated bundle. Rebuilding the tool views
 		// here makes the compile self-contained and matches what `prepack`
 		// does for the npm bundle.
-		await runCommand(["bun", "--cwd=../collab-web", "run", "build:tool-views"]);
+		await runCommand(["bun", "--cwd=../collab-web", "run", "gen:tool-views"]);
 		await runCommand(
-			["bun", "--cwd=../natives", "run", "embed:native"],
+			["bun", "--cwd=../natives", "run", "gen:native"],
 			crossTarget
 				? { ...Bun.env, TARGET_PLATFORM: crossPlatform as string, TARGET_ARCH: crossArch as string }
 				: Bun.env,
 		);
-		await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--generate"]);
+		await runCommand(["bun", "run", "gen:mupdf"]);
 		// Regenerate the bundled-pi registry + key set before the compile so any
 		// new pi-* subpath export added under `packages/*/package.json` is served
 		// from the host's in-process copy. Without this, `bun build --compile`
@@ -123,12 +123,12 @@ async function main(): Promise<void> {
 				await runCommand(["codesign", "--force", "--sign", "-", outputPath]);
 			}
 		} finally {
-			await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--reset"]);
-			await runCommand(["bun", "--cwd=../natives", "run", "embed:native", "--reset"]);
+			await runCommand(["bun", "run", "gen:mupdf:reset"]);
+			await runCommand(["bun", "--cwd=../natives", "run", "gen:native:reset"]);
 		}
 	} finally {
-		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
-		await runCommand(["bun", "scripts/generate-docs-index.ts", "--reset"]);
+		await runCommand(["bun", "--cwd=../stats", "run", "gen:stats:reset"]);
+		await runCommand(["bun", "run", "gen:docs:reset"]);
 	}
 }
 

package/scripts/bundle-dist.ts

@@ -79,7 +79,7 @@ async function main(): Promise<void> {
 	// so embed the dashboard archive the same way compiled binaries do
 	// (scripts/build-binary.ts). Reset afterwards to keep the checked-in
 	// placeholder empty.
-	await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
+	await runCommand(["bun", "--cwd=../stats", "run", "gen:stats"]);
 	try {
 		await runCommand([
 			"bun",
@@ -97,7 +97,7 @@ async function main(): Promise<void> {
 			"./src/cli.ts",
 		]);
 	} finally {
-		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+		await runCommand(["bun", "--cwd=../stats", "run", "gen:stats:reset"]);
 	}
 	await ensureShebang();
 	const stat = await fs.stat(cliPath);

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

@@ -3,6 +3,7 @@ import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core
 import { type } from "arktype";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
 import { getThemeByName } 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";
@@ -21,6 +22,41 @@ import {
 } from "..";
 
 describe("advisor", () => {
+	describe("advisor system prompt", () => {
+		it("forbids concrete claims about tool arguments hidden from the advisor transcript", () => {
+			const messages = [
+				{
+					role: "assistant",
+					content: [
+						{
+							type: "toolCall",
+							id: "search-timeout",
+							name: "grep",
+							arguments: { pattern: "needle", paths: ["packages/coding-agent/src"] },
+						},
+					],
+					timestamp: 1,
+				},
+				{
+					role: "toolResult",
+					toolCallId: "search-timeout",
+					toolName: "grep",
+					content: [{ type: "text", text: "timed out after 30s" }],
+					isError: true,
+					timestamp: 2,
+				},
+			] as unknown as AgentMessage[];
+
+			const rendered = formatSessionHistoryMarkdown(messages);
+
+			expect(rendered).toContain("→ grep(needle @ packages/coding-agent/src) ⇒ error");
+			expect(rendered).not.toContain("paths[0]");
+			expect(advisorSystemPrompt).toContain("Arguments absent from the rendered transcript are UNKNOWN");
+			expect(advisorSystemPrompt).toContain("NEVER assert concrete values, array indexes");
+			expect(advisorSystemPrompt).toContain("NEVER claim `paths[0]`, array flattening, or malformed `paths`");
+		});
+	});
+
 	describe("formatSessionHistoryMarkdown includeThinking", () => {
 		it("includes thinking text when includeThinking is true", () => {
 			const thinking = "I should check the edge case first.";
@@ -675,13 +711,13 @@ describe("advisor", () => {
 				} as AgentMessage,
 				{
 					role: "assistant",
-					content: [{ type: "toolCall", id: "b", name: "search", arguments: { pattern: "y" } }],
+					content: [{ type: "toolCall", id: "b", name: "grep", arguments: { pattern: "y" } }],
 					timestamp: 4,
 				} as unknown as AgentMessage,
 				{
 					role: "toolResult",
 					toolCallId: "b",
-					toolName: "search",
+					toolName: "grep",
 					content: [{ type: "text", text: "ok" }],
 					isError: false,
 					timestamp: 5,
@@ -1008,9 +1044,9 @@ describe("advisor", () => {
 
 	describe("read-only tool allowlist", () => {
 		it("selects only the investigation tools from a mixed toolset", () => {
-			const toolset = ["read", "edit", "search", "bash", "find", "write", "advise"];
+			const toolset = ["read", "edit", "grep", "bash", "glob", "write", "advise"];
 			const selected = toolset.filter(name => ADVISOR_READONLY_TOOL_NAMES.has(name));
-			expect(selected).toEqual(["read", "search", "find"]);
+			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);

package/src/advisor/__tests__/emission-guard.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "bun:test";
+import { AdvisorEmissionGuard, normalizeAdvisorNote } from "../emission-guard";
+
+describe("normalizeAdvisorNote", () => {
+	it("collapses punctuation, casing, and surrounding whitespace into one canonical key", () => {
+		// The reporter's three top duplicates all key to the same canonical form
+		// regardless of trailing punctuation or casing — that's what makes the
+		// dedupe + suppression checks single-membership.
+		expect(normalizeAdvisorNote("Stop.")).toBe("stop");
+		expect(normalizeAdvisorNote("  STOP!  ")).toBe("stop");
+		expect(normalizeAdvisorNote("*Stop*")).toBe("stop");
+		expect(normalizeAdvisorNote("Done.")).toBe("done");
+		expect(normalizeAdvisorNote("No issue; continue.")).toBe("no issue continue");
+	});
+
+	it("returns empty string for whitespace-only input so callers can short-circuit", () => {
+		expect(normalizeAdvisorNote("")).toBe("");
+		expect(normalizeAdvisorNote("   ")).toBe("");
+		expect(normalizeAdvisorNote("...")).toBe("");
+	});
+
+	it("preserves internal letters/digits but folds non-alphanumeric runs to one space", () => {
+		expect(normalizeAdvisorNote("Refactor `auth-flow.ts`: drop legacy branch.")).toBe(
+			"refactor auth flow ts drop legacy branch",
+		);
+	});
+});
+
+describe("AdvisorEmissionGuard", () => {
+	it("drops the exact content-free filler the reporter observed flooding the chat", () => {
+		// Issue #3520: 114× "Stop.", 52× "No issue; continue.", 41× "Done." —
+		// none of these carry a concrete reason and they cannot be acted on, so
+		// the guard suppresses them regardless of severity.
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("Stop.")).toBe(false);
+		expect(guard.accept("Done.")).toBe(false);
+		expect(guard.accept("No issue; continue.")).toBe(false);
+		expect(guard.accept("LGTM")).toBe(false);
+		expect(guard.accept("No further watcher input needed.")).toBe(false);
+	});
+
+	it("dedupes by normalized text across the session, ignoring casing and trailing punctuation", () => {
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("Move retries into the queue, not the request path.")).toBe(true);
+		// Same advice with different casing and trailing punctuation must NOT
+		// land twice in the primary transcript.
+		expect(guard.accept("move retries into the queue, not the request path")).toBe(false);
+		expect(guard.accept("Move retries into the queue, not the request path!")).toBe(false);
+	});
+
+	it("rate-limits to one accepted advise per advisor update cycle", () => {
+		// The advisor system prompt says "at most one `advise` per update". Real
+		// models violate this; the guard enforces it at the boundary so the
+		// primary transcript never receives two advisories from one model cycle.
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("First concern: missing await in #handleRetry.")).toBe(true);
+		expect(guard.accept("Second concern: wrong env var name.")).toBe(false);
+		guard.beginUpdate();
+		// New cycle: budget reset.
+		expect(guard.accept("Second concern: wrong env var name.")).toBe(true);
+	});
+
+	it("does not let a suppressed call consume the per-update budget", () => {
+		// A noise call like "Stop." must never displace a real concern that
+		// follows in the same advisor model cycle.
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("Stop.")).toBe(false);
+		expect(guard.accept("Concrete: read race in #handleRetry.")).toBe(true);
+	});
+
+	it("does not let a deduped call consume the per-update budget", () => {
+		// A repeat of a prior session note is dropped, but the model can still
+		// follow it with a fresh concrete concern in the same cycle.
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("Concrete: read race in #handleRetry.")).toBe(true);
+		guard.beginUpdate();
+		expect(guard.accept("Concrete: read race in #handleRetry.")).toBe(false);
+		expect(guard.accept("New concern: cache eviction never fires.")).toBe(true);
+	});
+
+	it("reset clears dedupe and the per-update gate so a re-primed advisor can re-raise old issues", () => {
+		// Compaction / session-switch rewrites the primary transcript. The
+		// advisor is re-primed from scratch and may legitimately re-raise the
+		// same concerns — they're new context for a freshly-primed reviewer.
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("Race in #handleRetry.")).toBe(true);
+		expect(guard.accept("Race in #handleRetry.")).toBe(false);
+		guard.reset();
+		expect(guard.accept("Race in #handleRetry.")).toBe(true);
+	});
+
+	it("evicts oldest entries when dedupe history exceeds capacity", () => {
+		// Bounded so very long sessions cannot grow the dedupe state without
+		// bound. Pre-eviction unique notes are remembered; post-eviction the
+		// oldest one is forgotten and can resurface.
+		const guard = new AdvisorEmissionGuard({ capacity: 3 });
+		expect(guard.accept("first")).toBe(true);
+		guard.beginUpdate();
+		expect(guard.accept("second")).toBe(true);
+		guard.beginUpdate();
+		expect(guard.accept("third")).toBe(true);
+		guard.beginUpdate();
+		// "first" still in history.
+		expect(guard.accept("first")).toBe(false);
+		guard.beginUpdate();
+		// Fourth unique entry evicts "first".
+		expect(guard.accept("fourth")).toBe(true);
+		guard.beginUpdate();
+		expect(guard.accept("first")).toBe(true);
+	});
+
+	it("rejects empty / whitespace-only notes without consuming the budget", () => {
+		const guard = new AdvisorEmissionGuard();
+		expect(guard.accept("")).toBe(false);
+		expect(guard.accept("   ")).toBe(false);
+		expect(guard.accept("Concrete advice.")).toBe(true);
+	});
+
+	it("end-to-end: the reporter's 309-call spam log produces ≤1 accepted note across many updates", () => {
+		// Mimic the issue's distribution: 114× "Stop.", 52× "No issue; continue.",
+		// 41× "Done.", plus 102 copies of one concrete-but-repeated nit. Spread
+		// the calls across 50 advisor update cycles. Each cycle is allowed at
+		// most one accepted note, and identical-text repeats never escape the
+		// guard. After all calls, exactly the concrete nit has been accepted
+		// — and only once.
+		const guard = new AdvisorEmissionGuard();
+		const accepted: string[] = [];
+		const stream: string[] = [
+			...Array(114).fill("Stop."),
+			...Array(52).fill("No issue; continue."),
+			...Array(41).fill("Done."),
+			...Array(102).fill("Concrete-but-repeated nit: x"),
+		];
+		// Interleave across 50 update cycles.
+		const cycles = 50;
+		const perCycle = Math.ceil(stream.length / cycles);
+		for (let c = 0; c < cycles; c++) {
+			guard.beginUpdate();
+			for (let i = 0; i < perCycle; i++) {
+				const note = stream[c * perCycle + i];
+				if (note === undefined) break;
+				if (guard.accept(note)) accepted.push(note);
+			}
+		}
+		expect(accepted).toEqual(["Concrete-but-repeated nit: x"]);
+	});
+});

package/src/advisor/advise-tool.ts

@@ -137,7 +137,7 @@ export function deriveAdvisorTelemetry(
  * inspect the workspace before weighing in. Names match the primary session's
  * tool instances, which the advisor reuses.
  */
-export const ADVISOR_READONLY_TOOL_NAMES: ReadonlySet<string> = new Set(["read", "search", "find"]);
+export const ADVISOR_READONLY_TOOL_NAMES: ReadonlySet<string> = new Set(["read", "grep", "glob"]);
 
 function advisorNoteDedupeKey(note: string): string {
 	return note.trim().replace(/\s+/g, " ");

package/src/advisor/emission-guard.ts

@@ -0,0 +1,172 @@
+/**
+ * Per-session policy gate for advisor `advise()` calls.
+ *
+ * The advisor system prompt tells the watcher model:
+ *
+ * > at most one `advise` per update
+ * > NEVER repeat advice you already gave, and NEVER send the same advice twice
+ *
+ * Real advisor models violate this. Issue #3520 captured a session where
+ * `__advisor.jsonl` recorded 309 `advise` calls covering 92 unique notes —
+ * 114× `Stop.`, 52× `No issue; continue.`, 41× `Done.` — flooding the primary
+ * transcript with `<advisory severity="blocker">Stop.</advisory>` after the
+ * task was already complete. The fix is to make the rules load-bearing in code
+ * instead of prose: silently drop duplicates, content-free self-talk, and
+ * over-budget calls at the `enqueueAdvice` boundary so the primary stays
+ * clean even when the advisor misbehaves.
+ *
+ * The gate is intentionally invisible to the advisor model — `AdviseTool`
+ * still returns `Recorded.` for a suppressed call. Surfacing "suppressed"
+ * back into advisor context risks the model rephrasing the same useless note
+ * to bypass the dedupe ("Stop.", then "Halt." then "Stop now.").
+ */
+
+/**
+ * Case-insensitive, punctuation-folded normalization. Collapses every run of
+ * non-letter / non-digit characters into a single space and trims, so
+ * `"Stop."`, `"*Stop*"`, and `"  stop  "` all key to `stop`, while
+ * `"No issue; continue."` keys to `no issue continue`.
+ *
+ * Exported for tests.
+ */
+export function normalizeAdvisorNote(note: string): string {
+	return note
+		.toLowerCase()
+		.normalize("NFKC")
+		.replace(/[^\p{L}\p{N}]+/gu, " ")
+		.trim();
+}
+
+/**
+ * Normalized phrases the advisor occasionally emits that carry no concrete
+ * actionable content. Each must be the output of {@link normalizeAdvisorNote}
+ * so a single membership check covers every punctuation/casing variant
+ * (`"Stop."`, `"stop"`, `"STOP!"`).
+ *
+ * The list is conservative — only short, content-free filler the reporter
+ * observed driving primary-transcript pollution. A genuine `blocker` like
+ * `"Stop: 'await' missing on writeStream.end() will lose buffered writes."`
+ * does not match.
+ */
+const SUPPRESSED_NORMALIZED_PHRASES: Record<string, true> = {
+	// Self-stop noise — telling the agent to "stop" without a reason is useless.
+	stop: true,
+	"stop here": true,
+	"stop now": true,
+	halt: true,
+	abort: true,
+	// Completion self-talk — the agent already finished the task.
+	done: true,
+	"task done": true,
+	"task complete": true,
+	complete: true,
+	finished: true,
+	ok: true,
+	okay: true,
+	"ok done": true,
+	// "Nothing to flag" — silence is the correct expression of "no concerns".
+	"no issue": true,
+	"no issues": true,
+	"no issue continue": true,
+	"no concerns": true,
+	"no concern": true,
+	"nothing to add": true,
+	"nothing to flag": true,
+	"nothing to report": true,
+	"no notes": true,
+	"no further input": true,
+	"no further input needed": true,
+	"no further input required": true,
+	"no further watcher input": true,
+	"no further watcher input needed": true,
+	"no further advice": true,
+	"no further advice needed": true,
+	// Endorsements — equivalent to silence.
+	lgtm: true,
+	"looks good": true,
+	"all good": true,
+	"agent is on track": true,
+	"agent on track": true,
+	"on track": true,
+	continue: true,
+	"carry on": true,
+};
+
+/**
+ * Bounds the dedupe history. Sessions with very long advisor activity could
+ * otherwise grow the set without bound. The reporter's pathological session
+ * had 92 unique notes; 4096 leaves headroom while staying tiny (≤ ~256 KB of
+ * normalized strings even at long max).
+ */
+const DEFAULT_HISTORY_CAPACITY = 4096;
+
+/**
+ * Decides whether an advisor `advise()` call should reach the primary agent.
+ *
+ * Enforces — in this order — the noise filter, session-scoped exact-text
+ * dedupe (FIFO-evicted at {@link DEFAULT_HISTORY_CAPACITY}), and a per-update
+ * rate limit of one accepted note per advisor model prompt. Suppressed calls
+ * never consume the per-update budget — a noise call doesn't burn the slot
+ * for a real concern that follows in the same update.
+ *
+ * Reset on advisor reset (compaction, session switch, `/new`) via
+ * {@link reset}. Per-update gate is cleared at the start of every advisor
+ * `agent.prompt()` cycle via {@link beginUpdate}.
+ */
+export class AdvisorEmissionGuard {
+	#seen = new Set<string>();
+	/** Insertion-order log to drive FIFO eviction without an extra Map. */
+	#seenOrder: string[] = [];
+	#consumedThisUpdate = false;
+	readonly #capacity: number;
+
+	constructor(opts: { capacity?: number } = {}) {
+		this.#capacity = opts.capacity ?? DEFAULT_HISTORY_CAPACITY;
+	}
+
+	/**
+	 * Drop all dedupe and per-update state. Called from
+	 * `AgentSession#resetAdvisorSessionState()` whenever the advisor runtime is
+	 * reset — same boundary as `yieldQueue.clear("advisor")`, so a re-primed
+	 * advisor can re-raise old issues (the primary transcript was rewritten).
+	 */
+	reset(): void {
+		this.#seen.clear();
+		this.#seenOrder.length = 0;
+		this.#consumedThisUpdate = false;
+	}
+
+	/**
+	 * Clear the per-update rate-limit gate. Called by `AdvisorRuntime` right
+	 * before each `agent.prompt(batch)` invocation so the next advisor model
+	 * cycle starts with a fresh budget of one advise.
+	 */
+	beginUpdate(): void {
+		this.#consumedThisUpdate = false;
+	}
+
+	/**
+	 * Whether the proposed note should reach the primary. On `true` the gate
+	 * has already recorded the note (consumed the per-update budget and added
+	 * it to the dedupe history) — caller delivers the note. On `false` the
+	 * caller drops it.
+	 *
+	 * Empty / whitespace-only notes are suppressed; the model's
+	 * tool-args contract still requires a non-empty string but defense-in-depth.
+	 */
+	accept(note: string): boolean {
+		const key = normalizeAdvisorNote(note);
+		if (!key) return false;
+		if (SUPPRESSED_NORMALIZED_PHRASES[key]) return false;
+		if (this.#seen.has(key)) return false;
+		if (this.#consumedThisUpdate) return false;
+		this.#consumedThisUpdate = true;
+		this.#seen.add(key);
+		this.#seenOrder.push(key);
+		if (this.#seenOrder.length > this.#capacity) {
+			const stale = this.#seenOrder.shift();
+			if (stale !== undefined) this.#seen.delete(stale);
+		}
+		return true;
+	}
+}

package/src/advisor/index.ts

@@ -1,4 +1,5 @@
 export * from "./advise-tool";
+export * from "./emission-guard";
 export * from "./runtime";
 export * from "./transcript-recorder";
 export * from "./watchdog";

package/src/advisor/runtime.ts

@@ -30,6 +30,13 @@ export interface AdvisorRuntimeHost {
 	 * the primary's next compaction triggers {@link AdvisorRuntime.reset}).
 	 */
 	maintainContext?(incomingTokens: number): Promise<boolean>;
+	/**
+	 * Called immediately before each `agent.prompt(batch)` cycle. Lets the host
+	 * clear per-update advisor state — currently the one-advise-per-update gate
+	 * in {@link AdvisorEmissionGuard}, which the host owns because it is the
+	 * one that routes `advise()` results back to the primary.
+	 */
+	beginAdvisorUpdate?(): void;
 }
 
 interface PendingDelta {
@@ -275,6 +282,10 @@ export class AdvisorRuntime {
 
 				let success = false;
 				try {
+					// Reset the host's per-update advisor state (one-advise-per-update
+					// gate) before each model cycle, so the new batch starts with a
+					// fresh budget. Dedupe history persists across cycles.
+					this.host.beginAdvisorUpdate?.();
 					await this.agent.prompt(batch);
 					success = true;
 					this.#consecutiveFailures = 0;

package/src/advisor/watchdog.ts

@@ -1,8 +1,19 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import { getAgentDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { getAgentDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
 import { expandAtImports } from "../discovery/at-imports";
+import activeRepoWatchdogTemplate from "../prompts/advisor/active-repo-watchdog.md" with { type: "text" };
+import type { ActiveRepoContext } from "../utils/active-repo-context";
 import { repo } from "../utils/git";
+import { normalizePromptPath } from "../utils/prompt-path";
+
+export function formatActiveRepoWatchdogPrompt(activeRepoContext: ActiveRepoContext): string {
+	return prompt
+		.render(activeRepoWatchdogTemplate, {
+			relativeRepoRoot: normalizePromptPath(activeRepoContext.relativeRepoRoot),
+		})
+		.trim();
+}
 
 /**
  * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.

package/src/cli/args.ts

@@ -4,7 +4,7 @@
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { CLI_THINKING_LEVELS, type ConfiguredThinkingLevel, parseCliThinkingLevel } from "../thinking";
-import { BUILTIN_TOOL_NAMES } from "../tools/builtin-names";
+import { BUILTIN_TOOL_NAMES, normalizeToolNames } from "../tools/builtin-names";
 import {
 	OPTIONAL_FLAGS,
 	OPTIONAL_VALUE_FLAGS,
@@ -90,6 +90,7 @@ const PARSE_DEPS: ParseDeps = {
 	logger,
 	parseThinking: parseCliThinkingLevel,
 	builtinToolNames: BUILTIN_TOOL_NAMES,
+	normalizeToolNames,
 	thinkingEfforts: CLI_THINKING_LEVELS,
 };
 
@@ -310,6 +311,8 @@ export function getExtraHelpText(): string {
   PERPLEXITY_API_KEY         - Perplexity web search API key (optional; anonymous fallback)
   PERPLEXITY_COOKIES         - Perplexity web search (session cookie)
   TAVILY_API_KEY             - Tavily web search
+  TINYFISH_API_KEY           - TinyFish web search
+  FIRECRAWL_API_KEY          - Firecrawl web search
   ANTHROPIC_SEARCH_API_KEY   - Anthropic web search (override; isolates search from main ANTHROPIC_API_KEY)
   ANTHROPIC_SEARCH_BASE_URL  - Anthropic web search base URL (override; pairs with ANTHROPIC_SEARCH_API_KEY)
 
@@ -330,7 +333,7 @@ ${chalk.bold("Available Tools (default-enabled unless noted):")}
   edit          - Edit files with find/replace
   write         - Write files (creates/overwrites)
   grep          - Search file contents
-  find          - Find files by glob pattern
+  glob          - Find files by glob pattern
   lsp           - Language server protocol (code intelligence)
   python        - Execute Python code (requires: ${APP_NAME} setup python)
   notebook      - Edit Jupyter notebooks

package/src/cli/auth-broker-cli.ts

@@ -28,6 +28,7 @@ import {
 	type OAuthCredential,
 	type OAuthProvider,
 	type OAuthProviderInfo,
+	PASTE_CODE_LOGIN_PROVIDERS,
 	PROVIDER_REGISTRY,
 	SqliteAuthCredentialStore,
 } from "@oh-my-pi/pi-ai";
@@ -211,6 +212,15 @@ async function runLocalLogin(provider: OAuthProvider): Promise<void> {
 	const storage = new AuthStorage(store);
 	await storage.reload();
 	try {
+		// Only paste-code providers (fixed non-loopback redirect, e.g. GitLab Duo
+		// Agent's vscode:// URI) get the manual paste fallback. An explicit
+		// `onManualCodeInput` is honored for ANY provider (the storage escape hatch),
+		// so for loopback providers we must not pass it: it would make
+		// `OAuthCallbackFlow` race a readline prompt against the HTTP callback and, if
+		// the callback wins, leave that prompt outstanding (dirty/blocked terminal).
+		// `AuthStorage.login` independently refuses to synthesize the default prompt
+		// for non-paste-code providers, so this is defense-in-depth on the same gate.
+		const usesManualInput = PASTE_CODE_LOGIN_PROVIDERS.has(provider);
 		await storage.login(provider, {
 			onAuth({ url, instructions }) {
 				process.stdout.write(`\nOpen this URL in your browser:\n${url}\n`);
@@ -223,6 +233,13 @@ async function runLocalLogin(provider: OAuthProvider): Promise<void> {
 			onPrompt(p) {
 				return ask(`${p.message}${p.placeholder ? ` (${p.placeholder})` : ""}:`);
 			},
+			...(usesManualInput
+				? {
+						onManualCodeInput() {
+							return ask("Paste the authorization code (or full redirect URL):");
+						},
+					}
+				: undefined),
 		});
 		process.stdout.write(`\nCredentials saved to ${getAgentDbPath()}\n`);
 	} finally {

package/src/cli/config-cli.ts

@@ -16,6 +16,7 @@ import {
 	Settings,
 	type SettingValue,
 	settings,
+	validateProviderMaxInFlightRequests,
 } from "../config/settings";
 import { SETTINGS_SCHEMA } from "../config/settings-schema";
 import { theme } from "../modes/theme/theme";
@@ -218,6 +219,9 @@ function parseAndSetValue(path: SettingPath, rawValue: string): void {
 			if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
 				throw new Error(`Invalid record JSON: ${rawValue}`);
 			}
+			if (path === "providers.maxInFlightRequests") {
+				parsed = validateProviderMaxInFlightRequests(parsed);
+			}
 			parsedValue = parsed;
 			break;
 		}

package/src/cli/flag-tables.ts

@@ -46,6 +46,7 @@ export interface ParseDeps {
 	logger: { warn: (message: string, meta?: Record<string, unknown>) => void };
 	parseThinking: (value: string | null | undefined) => ConfiguredThinkingLevel | undefined;
 	builtinToolNames: readonly string[];
+	normalizeToolNames: (values: Iterable<string>) => string[];
 	thinkingEfforts: readonly string[];
 }
 
@@ -147,10 +148,12 @@ export const STRING_SETTERS: Record<string, StringSetter> = {
 		result.models = value.split(",").map(s => s.trim());
 	},
 	"--tools": (result, value, deps) => {
-		const names = value
-			.split(",")
-			.map(s => s.trim().toLowerCase())
-			.filter(Boolean);
+		const names = deps.normalizeToolNames(
+			value
+				.split(",")
+				.map(s => s.trim())
+				.filter(Boolean),
+		);
 		const valid: string[] = [];
 		for (const name of names) {
 			if (deps.builtinToolNames.includes(name)) {