@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.0

package/src/task/executor.ts

@@ -166,6 +166,13 @@ export interface ExecutorOptions {
 	outputSchema?: unknown;
 	/** Parent task recursion depth (0 = top-level, 1 = first child, etc.) */
 	taskDepth?: number;
+	/**
+	 * Override the `task.maxRuntimeMs` wall-clock cap for this run. When provided
+	 * it wins over the settings value; `0` disables the per-subagent wall-clock
+	 * limit entirely. Used by the eval `agent()` bridge, whose parent cell
+	 * watchdog is already suspended for the call's duration.
+	 */
+	maxRuntimeMs?: number;
 	enableLsp?: boolean;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
@@ -625,7 +632,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		agent.readSummarize === false ? { "read.summarize.enabled": false } : undefined,
 	);
 	const maxRecursionDepth = settings.get("task.maxRecursionDepth") ?? 2;
-	const maxRuntimeMs = Math.max(0, Math.trunc(Number(settings.get("task.maxRuntimeMs") ?? 0) || 0));
+	const maxRuntimeMs = Math.max(
+		0,
+		Math.trunc(Number(options.maxRuntimeMs ?? settings.get("task.maxRuntimeMs") ?? 0) || 0),
+	);
 	const parentDepth = options.taskDepth ?? 0;
 	const childDepth = parentDepth + 1;
 	const atMaxDepth = maxRecursionDepth >= 0 && childDepth >= maxRecursionDepth;
@@ -1484,7 +1494,15 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				if (lastAssistant.stopReason === "aborted") {
 					aborted = abortReason === "signal" || runtimeLimitExceeded || abortReason === undefined;
 					if (aborted) {
-						abortReasonText ??= resolveAbortReasonText();
+						// A real caller signal or the wall-clock timer carries a precise
+						// reason (signal.reason / "runtime limit exceeded"). An internal
+						// turn abort (abortReason === undefined) does NOT — prefer the
+						// assistant message's own errorMessage ("Request was aborted" or a
+						// specific stream error) over the misleading "Cancelled by caller".
+						abortReasonText ??=
+							abortReason === "signal" || runtimeLimitExceeded
+								? resolveAbortReasonText()
+								: lastAssistant.errorMessage?.trim() || resolveAbortReasonText();
 					}
 					exitCode = 1;
 				} else if (lastAssistant.stopReason === "error") {

package/src/task/render.ts

@@ -13,7 +13,6 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { formatContextUsage } from "../modes/components/status-line/context-thresholds";
 import type { Theme } from "../modes/theme/theme";
 import {
-	capPreviewLines,
 	formatBadge,
 	formatDuration,
 	formatMoreItems,
@@ -566,7 +565,7 @@ export function renderCall(
 			const content = line ? theme.fg("muted", replaceTabs(line)) : "";
 			return ` ${vertical}  ${content}`;
 		});
-		lines.push(...capPreviewLines(contextLines, theme, { expanded: options.expanded, prefix: ` ${vertical}  ` }));
+		lines.push(...contextLines);
 	}
 
 	// `Tasks` is the last child unless the isolation flag follows it.

package/src/telemetry-export.ts

@@ -23,11 +23,7 @@
  * `sdk-trace-base@2.7` exports cleanly on Bun.
  */
 import { logger, postmortem } from "@oh-my-pi/pi-utils";
-import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import type * as TraceNode from "@opentelemetry/sdk-trace-node";
 
 /**
  * Periodic flush interval. A long-lived `omp` process (the ACP server is
@@ -36,7 +32,8 @@ import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
  */
 const FLUSH_INTERVAL_MS = 30_000;
 
-let provider: NodeTracerProvider | undefined;
+let provider: TraceNode.NodeTracerProvider | undefined;
+let initPromise: Promise<void> | undefined;
 
 /**
  * Whether {@link initTelemetryExport} registered a real provider. The CLI uses
@@ -53,8 +50,10 @@ export function isTelemetryExportEnabled(): boolean {
  * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
  * startup.
  */
-export function initTelemetryExport(): void {
+export async function initTelemetryExport(): Promise<void> {
 	if (provider) return;
+	if (initPromise) return initPromise;
+
 	// The OTEL env contract parses booleans and enum lists case-insensitively, so
 	// OTEL_SDK_DISABLED=TRUE and OTEL_TRACES_EXPORTER=None must also disable export.
 	if (process.env.OTEL_SDK_DISABLED?.trim().toLowerCase() === "true") return;
@@ -77,6 +76,25 @@ export function initTelemetryExport(): void {
 		return;
 	}
 
+	initPromise = registerProvider();
+	return initPromise;
+}
+
+async function registerProvider(): Promise<void> {
+	const [
+		{ AsyncLocalStorageContextManager },
+		{ OTLPTraceExporter },
+		{ resourceFromAttributes },
+		{ BatchSpanProcessor },
+		{ NodeTracerProvider },
+	] = await Promise.all([
+		import("@opentelemetry/context-async-hooks"),
+		import("@opentelemetry/exporter-trace-otlp-proto"),
+		import("@opentelemetry/resources"),
+		import("@opentelemetry/sdk-trace-base"),
+		import("@opentelemetry/sdk-trace-node"),
+	]);
+
 	// The exporter reads endpoint/headers/timeout from OTEL_EXPORTER_OTLP_* itself,
 	// so there is nothing to thread through here.
 	const exporter = new OTLPTraceExporter();

package/src/tools/eval-backends.ts

@@ -1,4 +1,4 @@
-import { $env, $flag } from "@oh-my-pi/pi-utils";
+import { $flag } from "@oh-my-pi/pi-utils";
 import type { ToolSession } from ".";
 
 export interface EvalBackendsAllowance {
@@ -6,21 +6,6 @@ export interface EvalBackendsAllowance {
 	js: boolean;
 }
 
-/**
- * Parse PI_PY / PI_JS environment variables. Each is a boolean flag; unset
- * means "not specified, defer to settings". Returns null when neither is set
- * so the caller can fall through to `readEvalBackendsAllowance` per key.
- */
-function getEvalBackendsFromEnv(): EvalBackendsAllowance | null {
-	const pyEnv = $env.PI_PY;
-	const jsEnv = $env.PI_JS;
-	if (pyEnv === undefined && jsEnv === undefined) return null;
-	return {
-		python: pyEnv === undefined ? true : $flag("PI_PY"),
-		js: jsEnv === undefined ? true : $flag("PI_JS"),
-	};
-}
-
 /** Read per-backend allowance from settings (defaults true). */
 export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAllowance {
 	return {
@@ -34,5 +19,9 @@ export function readEvalBackendsAllowance(session: ToolSession): EvalBackendsAll
  * override the per-key settings; otherwise settings (defaults true) win.
  */
 export function resolveEvalBackends(session: ToolSession): EvalBackendsAllowance {
-	return getEvalBackendsFromEnv() ?? readEvalBackendsAllowance(session);
+	const settings = readEvalBackendsAllowance(session);
+	return {
+		python: $flag("PI_PY", settings.python),
+		js: $flag("PI_JS", settings.js),
+	};
 }

package/src/tools/eval-render.ts

@@ -40,14 +40,6 @@ import {
 	wrapBrackets,
 } from "./render-utils";
 export const EVAL_DEFAULT_PREVIEW_LINES = 10;
-/**
- * Rows of source kept in the *pending* eval preview. The window follows the
- * streaming edge (newest lines pinned to the bottom) so you can watch the code
- * being written, while staying bounded — a volatile tool block taller than the
- * viewport would otherwise strand its scrolled-off head out of native scrollback
- * on ED3-risk terminals. Matches the streaming windows used by edit/write.
- */
-export const EVAL_STREAMING_PREVIEW_LINES = 12;
 
 function languageForHighlighter(language: EvalLanguage | undefined): "python" | "javascript" {
 	return language === "js" ? "javascript" : "python";
@@ -517,15 +509,12 @@ export const evalToolRenderer = {
 							title: cell.title,
 							status: "pending",
 							width,
-							codeMaxLines: EVAL_STREAMING_PREVIEW_LINES,
-							// Follow the streaming edge with a bounded tail window so the
-							// newest source stays visible as it is written, instead of
-							// rendering every line of a >100-line `code` — which would
-							// overflow the viewport and, because a tool block is volatile
-							// (it collapses to a capped result), strand its scrolled-off head
-							// out of native scrollback, cutting the box top. `Ctrl+O` lifts
-							// the window via `expanded` for a deliberate full view.
-							codeTail: true,
+							// Always render the full source: the code is fixed input, not the
+							// streaming part, so it is never compacted. While still pending
+							// (args streaming) the block is not yet committed to native
+							// scrollback — its head is only committed once a result exists and
+							// the code has finalized (see `isStreamingPreviewAppendOnly`).
+							codeMaxLines: Number.POSITIVE_INFINITY,
 							expanded: options.expanded,
 							animate,
 						},
@@ -628,7 +617,9 @@ export const evalToolRenderer = {
 								duration: cell.durationMs,
 								output: outputLines.length > 0 ? outputLines.join("\n") : undefined,
 								outputMaxLines: outputLines.length,
-								codeMaxLines: expanded ? Number.POSITIVE_INFINITY : EVAL_DEFAULT_PREVIEW_LINES,
+								// Code is fixed input — always shown in full, never compacted.
+								// Only `output` honors the collapsed preview cap above.
+								codeMaxLines: Number.POSITIVE_INFINITY,
 								expanded,
 								width,
 								animate,
@@ -760,6 +751,18 @@ export const evalToolRenderer = {
 			},
 		};
 	},
+
+	// Append-only once a result exists (args complete → code finalized). The code
+	// is rendered in full as a fixed top-anchored prefix, and the streamed stdout
+	// below it only appends rows at the bottom, so the scrolled-off head commits
+	// to native scrollback instead of being yanked — collapsed or expanded, since
+	// the collapsed output cap keeps its sliding tail in the bottom live region.
+	// Returns false while still pending: the code is mid-stream (args incomplete)
+	// and its header still reads "pending", so committing it would strand a stale
+	// pending preview in history.
+	isStreamingPreviewAppendOnly(_args: EvalRenderArgs, _options: RenderResultOptions, result?: unknown): boolean {
+		return result != null;
+	},
 	mergeCallAndResult: true,
 	inline: true,
 };

package/src/tools/eval.ts

@@ -130,11 +130,12 @@ function timeoutSecondsFromMs(timeoutMs: number): number {
 }
 
 async function resolveBackend(session: ToolSession, language: EvalLanguage): Promise<ResolvedBackend> {
-	const allowPy = (session.settings.get("eval.py") as boolean | undefined) ?? true;
-	const allowJs = (session.settings.get("eval.js") as boolean | undefined) ?? true;
+	const backends = resolveEvalBackends(session);
+	const allowPy = backends.python;
+	const allowJs = backends.js;
 
 	if (language === "python") {
-		if (!allowPy) throw new ToolError("Python backend is disabled (eval.py = false).");
+		if (!allowPy) throw new ToolError("Python backend is disabled (PI_PY=0 or eval.py = false).");
 		if (!(await pythonBackend.isAvailable(session))) {
 			throw new ToolError(
 				'Python backend is unavailable in this session. Pass language: "js" or install the python kernel.',
@@ -142,7 +143,7 @@ async function resolveBackend(session: ToolSession, language: EvalLanguage): Pro
 		}
 		return { backend: pythonBackend };
 	}
-	if (!allowJs) throw new ToolError("JavaScript backend is disabled (eval.js = false).");
+	if (!allowJs) throw new ToolError("JavaScript backend is disabled (PI_JS=0 or eval.js = false).");
 	return { backend: jsBackend };
 }
 

package/src/tools/fetch.ts

@@ -581,14 +581,25 @@ function parseFeedToMarkdown(content: string, maxItems = 10): string {
  */
 const REMOTE_READER_MAX_MS = 10_000;
 
+/** Reader backends for {@link renderHtmlToText}, in default priority order. */
+export type FetchProvider = "native" | "trafilatura" | "lynx" | "parallel" | "jina";
+
+const FETCH_PROVIDER_ORDER: readonly FetchProvider[] = ["native", "trafilatura", "lynx", "parallel", "jina"];
+
 /**
- * Render HTML to markdown using Parallel, jina, trafilatura, lynx, then the
- * in-process native converter. The overall `timeout` budget bounds the call,
- * but remote reader requests are additionally capped at `REMOTE_READER_MAX_MS`
- * so that a hung remote endpoint cannot prevent local fallbacks from running.
- * Only a real `userSignal` cancellation aborts the chain — remote per-attempt
- * timeouts and the overall reader-mode timeout still allow later renderers
- * (especially the purely-local native converter) to be tried.
+ * Render HTML to markdown by trying reader backends in priority order: native
+ * (in-process), trafilatura, lynx, Parallel, then Jina. The `providers.fetch`
+ * setting picks the order — `auto` uses the default above; any specific backend
+ * is tried first, then the remaining backends as fallbacks. Every backend's
+ * output must clear the same quality gate (>100 non-whitespace chars and not
+ * {@link isLowQualityOutput}) before it is accepted, otherwise the next backend
+ * is tried.
+ *
+ * The overall `timeout` budget bounds the whole call; remote backends (Parallel,
+ * Jina) are additionally capped at `REMOTE_READER_MAX_MS` so a hung endpoint
+ * cannot starve later renderers — especially the purely-local native converter,
+ * which always works on already-loaded HTML. Only a real `userSignal`
+ * cancellation aborts the chain (#1449).
  */
 export async function renderHtmlToText(
 	url: string,
@@ -607,92 +618,74 @@ export async function renderHtmlToText(
 		signal: overallSignal,
 	};
 	const remoteBudgetMs = Math.min(timeout * 1000, REMOTE_READER_MAX_MS);
-
-	// Try Parallel extract first when credentials are configured
-	if (settings.get("providers.parallelFetch") && findParallelApiKey(storage)) {
-		try {
+	// Per-attempt budget for remote endpoints so one stall cannot consume the
+	// whole reader-mode budget and starve the local fallbacks.
+	const remoteSignal = () => ptree.combineSignals(userSignal, remoteBudgetMs);
+
+	const runners: Record<FetchProvider, () => Promise<string | null>> = {
+		// Purely local, no network/subprocess: still works on already-loaded HTML
+		// even after remote/subprocess attempts are aborted by the budget.
+		native: () => htmlToMarkdown(html, { cleanContent: true }),
+		trafilatura: async () => {
+			const trafilatura = await ensureTool("trafilatura", { signal: overallSignal, silent: true });
+			if (!trafilatura) return null;
+			const result = await ptree.exec([trafilatura, "-u", url, "--output-format", "markdown"], execOptions);
+			return result.ok ? result.stdout : null;
+		},
+		lynx: async () => {
+			if (!hasCommand("lynx")) return null;
+			const result = await ptree.exec(["lynx", "-dump", "-nolist", "-width", "250", url], execOptions);
+			return result.ok ? result.stdout : null;
+		},
+		parallel: async () => {
+			if (!findParallelApiKey(storage)) return null;
 			const parallelResult = await extractWithParallel(
 				[url],
-				{
-					objective: "Extract the main content",
-					excerpts: true,
-					fullContent: false,
-					signal: ptree.combineSignals(userSignal, remoteBudgetMs),
-				},
+				{ objective: "Extract the main content", excerpts: true, fullContent: false, signal: remoteSignal() },
 				storage,
 			);
 			const firstDocument = parallelResult.results[0];
-			if (firstDocument) {
-				const content = getParallelExtractContent(firstDocument);
-				if (content.trim().length > 100 && !isLowQualityOutput(content)) {
-					return { content, ok: true, method: "parallel" };
-				}
-			}
-		} catch {
-			// Parallel extract failed or stalled; honour real cancellation only.
-			userSignal?.throwIfAborted();
-		}
-	}
-
-	// Try jina reader API with its own sub-budget so a stall cannot starve
-	// later fallbacks (#1449).
-	try {
-		const jinaUrl = `https://r.jina.ai/${url}`;
-		const response = await fetch(jinaUrl, {
-			headers: { Accept: "text/markdown" },
-			signal: ptree.combineSignals(userSignal, remoteBudgetMs),
-		});
-		if (response.ok) {
-			const content = await response.text();
-			if (content.trim().length > 100 && !isLowQualityOutput(content)) {
-				return { content, ok: true, method: "jina" };
-			}
-		}
-	} catch {
-		// Jina failed or stalled; honour real cancellation only.
-		userSignal?.throwIfAborted();
-	}
+			return firstDocument ? getParallelExtractContent(firstDocument) : null;
+		},
+		jina: async () => {
+			const response = await fetch(`https://r.jina.ai/${url}`, {
+				headers: { Accept: "text/markdown" },
+				signal: remoteSignal(),
+			});
+			return response.ok ? await response.text() : null;
+		},
+	};
 
-	// Try trafilatura (auto-install via uv/pip)
-	try {
-		const trafilatura = await ensureTool("trafilatura", { signal: overallSignal, silent: true });
-		if (trafilatura) {
-			const result = await ptree.exec([trafilatura, "-u", url, "--output-format", "markdown"], execOptions);
-			if (result.ok && result.stdout.trim().length > 100) {
-				return { content: result.stdout, ok: true, method: "trafilatura" };
-			}
-		}
-	} catch {
-		// trafilatura unavailable or stalled; continue to next method.
+	const preference = settings.get("providers.fetch");
+	const order: readonly FetchProvider[] =
+		preference === "auto"
+			? FETCH_PROVIDER_ORDER
+			: [preference, ...FETCH_PROVIDER_ORDER.filter(method => method !== preference)];
+
+	// Highest-priority output that is substantial but fails the low-quality gate.
+	// Surfaced (ok: true) only when no backend clears the gate, so the caller's
+	// targeted fallbacks (llms.txt / document extraction) still run and we beat
+	// returning the unrendered raw HTML.
+	let lowQuality: { content: string; method: FetchProvider } | null = null;
+
+	for (const method of order) {
+		// Honour real user cancellation between attempts; remote per-attempt and
+		// overall-budget timeouts still fall through to later (local) renderers.
 		userSignal?.throwIfAborted();
-	}
-
-	// Try lynx (can't auto-install, system package)
-	try {
-		const lynx = hasCommand("lynx");
-		if (lynx) {
-			const result = await ptree.exec(["lynx", "-dump", "-nolist", "-width", "250", url], execOptions);
-			if (result.ok) {
-				return { content: result.stdout, ok: true, method: "lynx" };
+		try {
+			const content = await runners[method]();
+			if (!content || content.trim().length <= 100) continue;
+			if (!isLowQualityOutput(content)) {
+				return { content, ok: true, method };
 			}
+			lowQuality ??= { content, method };
+		} catch {
+			userSignal?.throwIfAborted();
 		}
-	} catch {
-		// lynx failed or stalled; continue to native converter.
-		userSignal?.throwIfAborted();
 	}
 
-	// Fall back to native converter (purely local, no network/subprocess).
-	// Always attempted: even if remote renderers and subprocesses were aborted
-	// by the overall reader-mode timeout, this still works on already-loaded
-	// HTML (#1449).
-	try {
-		const content = await htmlToMarkdown(html, { cleanContent: true });
-		if (content.trim().length > 100 && !isLowQualityOutput(content)) {
-			return { content, ok: true, method: "native" };
-		}
-	} catch {
-		// Native converter failed; nothing else to try.
-		userSignal?.throwIfAborted();
+	if (lowQuality) {
+		return { content: lowQuality.content, ok: true, method: lowQuality.method };
 	}
 	return { content: "", ok: false, method: "none" };
 }
@@ -1141,10 +1134,27 @@ async function renderUrl(
 			throw new ToolAbortError();
 		}
 
-		// 5E: Render HTML with lynx or html2text
+		// 5E: Render HTML via the reader-backend chain (native/trafilatura/lynx/parallel/jina)
 		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal, storage);
 		if (!htmlResult.ok) {
-			notes.push("html rendering failed (lynx/html2text unavailable)");
+			notes.push("html rendering failed (no reader backend produced usable output)");
+
+			const llmResult = await tryLlmEndpoints(finalUrl, timeout, signal);
+			if (llmResult) {
+				notes.push(`Used llms.txt fallback: ${llmResult.endpoint}`);
+				const output = finalizeOutput(llmResult.content);
+				return {
+					url,
+					finalUrl,
+					contentType: "text/plain",
+					method: "llms.txt",
+					content: output.content,
+					fetchedAt,
+					truncated: output.truncated,
+					notes,
+				};
+			}
+
 			const output = finalizeOutput(rawContent);
 			return {
 				url,

package/src/tools/render-utils.ts

@@ -221,10 +221,24 @@ export function formatMeta(meta: string[], theme: Theme): string {
 	return meta.length > 0 ? ` ${theme.fg("muted", meta.join(theme.sep.dot))}` : "";
 }
 
-export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+function sanitizeErrorText(message: string | undefined): string {
 	const clean = (message ?? "").replace(/^Error:\s*/, "").trim();
-	const safe = clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
-	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${safe}`)}`;
+	return clean ? replaceTabs(truncateToWidth(clean, TRUNCATE_LENGTHS.LINE)) : "Unknown error";
+}
+
+export function formatErrorMessage(message: string | undefined, theme: Theme): string {
+	return `${theme.styledSymbol("status.error", "error")} ${theme.fg("error", `Error: ${sanitizeErrorText(message)}`)}`;
+}
+
+/**
+ * Error message rendered as a subordinate detail line beneath a status header
+ * that already carries the error icon (e.g. `✘ Write: <path>`). The header's
+ * icon already signals failure, so this omits the redundant error symbol and
+ * "Error:" prefix that `formatErrorMessage` adds for standalone single-line
+ * errors, indenting two columns to sit under the header title instead.
+ */
+export function formatErrorDetail(message: string | undefined, theme: Theme): string {
+	return `  ${theme.fg("error", sanitizeErrorText(message))}`;
 }
 
 export function formatEmptyMessage(message: string, theme: Theme): string {

package/src/tools/renderers.ts

@@ -31,7 +31,7 @@ import { sshToolRenderer } from "./ssh";
 import { todoToolRenderer } from "./todo";
 import { writeToolRenderer } from "./write";
 
-type ToolRenderer = {
+export type ToolRenderer = {
 	renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
 	renderResult: (
 		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
@@ -40,6 +40,21 @@ type ToolRenderer = {
 		args?: unknown,
 	) => Component;
 	mergeCallAndResult?: boolean;
+	/**
+	 * While a tool's preview is still streaming, report whether the
+	 * currently-rendered preview is append-only: its rows only grow at the bottom
+	 * and never re-layout above the bottom live region (a full, top-anchored
+	 * content/code preview). The transcript reports this up to the TUI so a
+	 * streaming preview taller than the viewport commits its scrolled-off head to
+	 * native scrollback instead of dropping it (see
+	 * `ToolExecutionComponent.isTranscriptBlockAppendOnly`). `result` is the
+	 * latest (possibly partial) tool result, or `undefined` before one exists —
+	 * `eval`/`bash` use its presence to defer committing until the streamed input
+	 * (code) has finalized. Omit (or return `false`) for previews that slide a
+	 * tail window or later collapse to a compact result — committing their head
+	 * would strand stale rows.
+	 */
+	isStreamingPreviewAppendOnly?: (args: unknown, options: RenderResultOptions, result?: unknown) => boolean;
 	/** Render without background box, inline in the response flow */
 	inline?: boolean;
 };

package/src/tools/report-tool-issue.ts

@@ -41,7 +41,7 @@ function buildReportToolIssueParams(activeBuiltinNames: readonly string[]) {
 }
 
 export function isAutoQaEnabled(settings?: Settings): boolean {
-	return $flag("PI_AUTO_QA") || !!settings?.get("dev.autoqa");
+	return $flag("PI_AUTO_QA", !!settings?.get("dev.autoqa"));
 }
 
 // ───────────────────────────────────────────────────────────────────────────