pi-bro 0.25.0 → 0.25.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to pi-bro are documented here.
 
+## [0.25.1] - 2026-10-19
+
+### Highlights
+
+- `bro_advisor` answers faster: it relies on the session snapshot (including tool calls and outputs) first, and only reads files or runs commands when needed.
+- `bro_advisor` no longer automatically restarts failed consultations up to three times with 5s and 10s waits; it runs once and reports any failure immediately.
+
+### Changed
+
+- `buildAdvisorPrompt` and the `bro_advisor` tool description now instruct the advisor to use the captured session snapshot first and inspect the workspace only when something needed is missing or a key claim is in doubt, instead of requiring a fresh workspace investigation before advising.
+- `runAdvisor` (formerly `runAdvisorWithRetries`) runs a single consultation attempt and surfaces any backend failure, timeout, or cancellation immediately without 5-second and 10-second full-restart retries.
+
 ## [0.25.0] - 2026-10-19
 
 ### Highlights

package/README.md

@@ -62,7 +62,7 @@ File and webpage examples need your own real path or URL; see [how to explain th
 | `/bro elevate` or **Ctrl+Shift+E** | **[Elevate](docs/elevate.md).** Discover missing expert considerations, select useful improvements, and rewrite your task without submitting it. Shares BTW backend settings. |
 | `/bro btw` | **[Side questions](docs/features/btw.md#bro-btw-side-conversation).** A separate conversation seeded with recent context, so you can ask without interrupting the agent. ⚠️ [Full-permission mode](#what-leaves-your-machine) can edit files. |
 | `/bro guided-review <PR>` | **[Guided Review](docs/guided-review.md).** An explanation and quality assessment of a GitHub PR, with ranked findings, source evidence and private questions. Claude or Muse is recommended for untrusted PRs. |
-| `bro_advisor` tool | **[Second opinion](docs/features/advisor.md#bro-advisor).** A tool your agent can call mid-task; a fresh backend process investigates and returns advice to the agent. ⚠️ [Runs with permissions bypassed](#what-leaves-your-machine). |
+| `bro_advisor` tool | **[Second opinion](docs/features/advisor.md#bro-advisor).** A tool your agent can call mid-task; a fresh backend process reviews the session snapshot, can inspect the workspace when needed, and returns advice to the agent. ⚠️ [Runs with permissions bypassed](#what-leaves-your-machine). |
 | `/bro config`, `/bro preferences` | **[Settings](docs/reference/settings.md#settings) and [preferences](docs/user-guide.md#preferences).** Pick the backend, model and effort per feature, and tell Bro how you like answers. |
 
 For help by task, start at the **[docs home](docs/README.md)**; see the [command reference](docs/reference/commands.md) for syntax.

package/docs/features/advisor.md

@@ -24,14 +24,15 @@ presence, and backend compatibility (for Agy, a minimum CLI version with an
   instructions, its active tools, and the conversation so far including tool
   calls and results — and sends it, along with an optional `question` the
   executor may pass, to a **fresh, standalone process of the selected
-  backend** for every consultation. Nothing is resumed or reused across calls,
-  including retries.
-- **Instructed to investigate, not implement**: the advisor process has real
+  backend** for every consultation. Nothing is resumed or reused across calls.
+- **Snapshot first, workspace tools when needed**: the advisor process has real
   tool access in the workspace with permissions auto-approved — there is no
-  enforced read-only isolation. It is instructed to verify claims itself and
-  return advice, leaving edits to the executor, but that boundary is a
-  behavioral prompt instruction rather than an enforced sandbox constraint, so
-  treat its findings as advice to verify, not a guaranteed hands-off review.
+  enforced read-only isolation. It is instructed to rely on the captured
+  snapshot (including its tool calls and results) first, inspect the workspace
+  only when something is missing or a key claim is in doubt, and return advice
+  while leaving edits to the executor. That boundary is a behavioral prompt
+  instruction rather than an enforced sandbox constraint, so treat its findings
+  as advice to verify, not a guaranteed hands-off review.
 - **Steering**: The advisor reads standing priorities from `~/.pi/agent/bro-advisor.md`
   and session-specific priorities from `/bro advisor-steer`.
   `/bro advisor-steer` opens an editor for one session steering brief — e.g. "quick
@@ -47,24 +48,18 @@ presence, and backend compatibility (for Agy, a minimum CLI version with an
   session file (`bro-advisor-steering`) and is restored on resume or reload. Forking a
   session inherits session steering; edits made after the fork are independent of the
   original branch. Clearing session steering leaves durable steering intact.
-- **Retries**: on an invocation failure (not a completed answer — "I need
-  more evidence" is a normal result, not a failure), Bro retries with the
-  identical snapshot, steering, and question: once after 5 seconds, once more
-  after 10 seconds, then returns the backend's own diagnostic — including a
-  context-length error, verbatim — as the failure. Host-imposed deadlines and
-  cancellation are terminal: neither starts another attempt or a backoff wait.
-  The advisor CLI is asked to stop at 10 minutes; Bro's host deadline is 610
-  seconds plus bounded process cleanup. A CLI-reported error before that host
-  deadline remains an invocation failure and can be retried.
-  Cancelling the tool call skips any pending retry wait.
-- **Progress and provenance**: while an attempt is running, Bro shows the last
+- **Single attempt, no automatic retries**: each consultation runs once (the
+  advisor CLI is asked to stop at 10 minutes; Bro's host deadline is 610
+  seconds plus bounded process cleanup). Any backend failure, timeout, or
+  cancellation is returned immediately — including a context-length error,
+  verbatim — without waiting or restarting the consultation from scratch.
+- **Progress and provenance**: while a consultation is running, Bro shows the last
   thing the advisor actually reported — a tool name or a user-facing response
   line, never hidden reasoning — and how long ago it arrived, e.g. `last
   reported: Read src/app.ts (2s ago)`, or "awaiting first activity" before
   anything arrives. Expanding a running consultation shows up to the last 4
-  reported activity lines; each retry starts the trail over. The returned
-  answer starts with backend, model, effort, attempt count, duration,
-  workspace, steering presence, snapshot size, and known omission/compaction
-  notes; the advisor's complete answer follows unchanged.
+  reported activity lines. The returned answer starts with backend, model,
+  effort, duration, workspace, steering presence, snapshot size, and known
+  omission/compaction notes; the advisor's complete answer follows unchanged.
 - **Model/effort**: resolved the same way as explain/show/btw, through
   `/bro config` (shared default or per-capability override).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bro",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "A sidekick for you and your Pi agent: plain-language explanations, side questions, diagrams, PR review and second opinions, without cluttering the agent's context.",
   "type": "module",
   "license": "MIT",

package/src/advisor.ts

@@ -228,8 +228,7 @@ export type AdvisorActivityCallback = (label: string, timestamp: number) => void
 // Thin wrapper around the shared backend: advisor's stdin/stream-json transport, activity parsing,
 // and process lifecycle now live in backend.ts (see docs/plans/2026-09-19-bro-advisor-design.md,
 // "Transport" for why stdin rather than --print). This function keeps its exact existing
-// signature/throw contract -- it is called directly by tests and by runAdvisorWithRetries below,
-// which owns the 3-attempt retry/backoff policy the backend itself never performs.
+// signature/throw contract -- it is called directly by tests and by runAdvisor below.
 export class TerminalConsultError extends Error {
 	readonly status: "failure" | "cancelled" | "timeout";
 	constructor(status: "failure" | "cancelled" | "timeout", message: string) {
@@ -262,32 +261,6 @@ export async function runAdvisorConsultation(
 	throw new TerminalConsultError(outcome.status, outcome.message);
 }
 
-function advisorDelay(ms: number, signal: AbortSignal, onTick?: (remainingMs: number) => void): Promise<void> {
-	return new Promise((resolve, reject) => {
-		if (signal.aborted) {
-			reject(new Error("Canceled."));
-			return;
-		}
-		const startedAt = Date.now();
-		const interval = onTick ? setInterval(() => onTick(Math.max(0, ms - (Date.now() - startedAt))), 1_000) : undefined;
-		interval?.unref();
-		const cleanup = () => {
-			clearTimeout(timer);
-			if (interval) clearInterval(interval);
-			signal.removeEventListener("abort", onAbort);
-		};
-		const onAbort = () => {
-			cleanup();
-			reject(new Error("Canceled."));
-		};
-		const timer = setTimeout(() => {
-			cleanup();
-			resolve();
-		}, ms);
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
-
 export type AdvisorConsult = (
 	prompt: string,
 	selection: BackendSelection,
@@ -296,14 +269,9 @@ export type AdvisorConsult = (
 	killEscalationMs?: number,
 	onActivity?: AdvisorActivityCallback,
 ) => Promise<string>;
-export type AdvisorDelayFn = (ms: number, signal: AbortSignal, onTick?: (remainingMs: number) => void) => Promise<void>;
 export type AdvisorToolDetails = {
-	status: "investigating" | "retrying" | "done";
-	attempt: number;
-	of: number;
+	status: "investigating" | "done";
 	elapsedMs: number;
-	error?: string;
-	retryInMs?: number;
 	backend?: BackendName;
 	model?: string;
 	effort?: string;
@@ -314,136 +282,98 @@ export type AdvisorToolDetails = {
 	snapshotChars?: number;
 	broTruncated?: false;
 	omissions?: string;
-	// Real backend-reported activity for the current attempt only -- reset to empty whenever a new
-	// attempt (including a retry) starts, never carried over from a prior failed attempt.
+	// Real backend-reported activity for this consultation, bounded to the last 4 labels.
 	activity?: string[];
 	lastActivityAt?: number;
 	// Total count of accepted activity events (tool calls AND user-facing text deltas -- "activity"
-	// is the honest label, not "tool calls") observed across the whole consultation, including every
-	// retry attempt. Unlike `activity` above, this never resets on a retry; the final "done" details
-	// carry the same running total.
+	// is the honest label, not "tool calls") observed across the consultation.
 	activityCount?: number;
 };
 export type AdvisorProgressCallback = (details: AdvisorToolDetails) => void;
-export type AdvisorRunResult = { advice: string; attempts: number; durationMs: number; activityCount: number };
+export type AdvisorRunResult = { advice: string; durationMs: number; activityCount: number };
 
 // Bursts of chunked NDJSON activity events are coalesced to this cadence so a fast stream of tool
 // calls/text deltas doesn't flood onProgress; the 1s elapsed-time heartbeat below is unaffected and
 // keeps ticking independently.
 const ADVISOR_ACTIVITY_THROTTLE_MS = 250;
 
-// `consult`/`delayFn` are injectable so tests can swap in a fake process spawn and a fake clock
-// instead of spawning real processes and waiting 15 real seconds. Every attempt sends the
-// identical prompt/selection/cwd to a fresh, standalone backend process — never resumed via
-// --conversation, even across retries.
-export async function runAdvisorWithRetries(
+// `consult` is injectable so tests can swap in a fake process spawn instead of spawning real
+// processes. Every consultation runs once against a fresh, standalone backend process — never
+// resumed via --conversation and never automatically retried.
+export async function runAdvisor(
 	prompt: string,
 	selection: BackendSelection,
 	cwd: string,
 	signal: AbortSignal,
 	consult: AdvisorConsult = runAdvisorConsultation,
-	delayFn: AdvisorDelayFn = advisorDelay,
 	onProgress?: AdvisorProgressCallback,
 	progressIntervalMs = 1_000,
 	activityThrottleMs = ADVISOR_ACTIVITY_THROTTLE_MS,
 ): Promise<AdvisorRunResult> {
-	const delays = [5_000, 10_000];
-	const totalAttempts = delays.length + 1;
+	if (signal.aborted) throw new Error("Canceled.");
 	const startedAt = Date.now();
-	let lastError: unknown;
-	// Cumulative across every attempt in this consultation, including retries -- unlike `activity`
-	// below, a retry must never reset this back to zero.
+	const activity: string[] = [];
 	let totalActivityCount = 0;
-	for (let attempt = 0; attempt <= delays.length; attempt++) {
-		if (signal.aborted) throw new Error("Canceled.");
-		// Fresh per attempt: a retry must never show the previous attempt's activity trail.
-		const activity: string[] = [];
-		let lastActivityAt: number | undefined;
-		let lastActivityEmitAt = 0;
-		let pendingActivityTimer: ReturnType<typeof setTimeout> | undefined;
+	let lastActivityAt: number | undefined;
+	let lastActivityEmitAt = 0;
+	let pendingActivityTimer: ReturnType<typeof setTimeout> | undefined;
 
-		const running = (): AdvisorToolDetails => ({
-			status: "investigating",
-			attempt: attempt + 1,
-			of: totalAttempts,
-			elapsedMs: Date.now() - startedAt,
-			activity: [...activity],
-			lastActivityAt,
-			activityCount: totalActivityCount,
-		});
-		const emitRunning = () => onProgress?.(running());
-		emitRunning();
-		const progressTimer = onProgress ? setInterval(emitRunning, progressIntervalMs) : undefined;
-		progressTimer?.unref();
+	const running = (): AdvisorToolDetails => ({
+		status: "investigating",
+		elapsedMs: Date.now() - startedAt,
+		activity: [...activity],
+		lastActivityAt,
+		activityCount: totalActivityCount,
+	});
+	const emitRunning = () => onProgress?.(running());
+	emitRunning();
+	const progressTimer = onProgress ? setInterval(emitRunning, progressIntervalMs) : undefined;
+	progressTimer?.unref();
 
-		const stopActivityThrottle = () => {
-			if (pendingActivityTimer) {
-				clearTimeout(pendingActivityTimer);
+	const stopActivityThrottle = () => {
+		if (pendingActivityTimer) {
+			clearTimeout(pendingActivityTimer);
+			pendingActivityTimer = undefined;
+		}
+	};
+	const onActivity: AdvisorActivityCallback = (label, timestamp) => {
+		const normalized = label.replace(/\s+/g, " ").trim();
+		if (!normalized) return;
+		activity.push(normalized);
+		if (activity.length > MAX_ADVISOR_ACTIVITY_LINES) activity.splice(0, activity.length - MAX_ADVISOR_ACTIVITY_LINES);
+		totalActivityCount += 1;
+		lastActivityAt = timestamp;
+		if (!onProgress) return;
+		const elapsed = Date.now() - lastActivityEmitAt;
+		if (elapsed >= activityThrottleMs) {
+			lastActivityEmitAt = Date.now();
+			emitRunning();
+			return;
+		}
+		if (!pendingActivityTimer) {
+			pendingActivityTimer = setTimeout(() => {
 				pendingActivityTimer = undefined;
-			}
-		};
-		const onActivity: AdvisorActivityCallback = (label, timestamp) => {
-			const normalized = label.replace(/\s+/g, " ").trim();
-			if (!normalized) return;
-			activity.push(normalized);
-			if (activity.length > MAX_ADVISOR_ACTIVITY_LINES) activity.splice(0, activity.length - MAX_ADVISOR_ACTIVITY_LINES);
-			totalActivityCount += 1;
-			lastActivityAt = timestamp;
-			if (!onProgress) return;
-			const elapsed = Date.now() - lastActivityEmitAt;
-			if (elapsed >= activityThrottleMs) {
 				lastActivityEmitAt = Date.now();
 				emitRunning();
-				return;
-			}
-			if (!pendingActivityTimer) {
-				pendingActivityTimer = setTimeout(() => {
-					pendingActivityTimer = undefined;
-					lastActivityEmitAt = Date.now();
-					emitRunning();
-				}, activityThrottleMs - elapsed);
-				pendingActivityTimer.unref?.();
-			}
-		};
-
-		try {
-			const advice = await consult(prompt, selection, cwd, signal, undefined, onActivity);
-			// `totalActivityCount` is read directly here rather than from the last onProgress snapshot,
-			// which may lag behind by up to `activityThrottleMs` -- the final count must be exact.
-			return { advice, attempts: attempt + 1, durationMs: Date.now() - startedAt, activityCount: totalActivityCount };
-		} catch (error) {
-			if (progressTimer) clearInterval(progressTimer);
-			stopActivityThrottle();
-			if (signal.aborted || errorMessage(error) === "Canceled." ||
-				(error instanceof TerminalConsultError && error.status !== "failure")) throw error;
-			lastError = error;
-			if (attempt === delays.length) break;
-			const delay = delays[attempt]!;
-			const retrying = (remainingMs: number): AdvisorToolDetails => ({
-				status: "retrying",
-				attempt: attempt + 2,
-				of: totalAttempts,
-				elapsedMs: Date.now() - startedAt,
-				error: errorMessage(error),
-				retryInMs: remainingMs,
-				activityCount: totalActivityCount,
-			});
-			onProgress?.(retrying(delay));
-			await delayFn(delay, signal, (remainingMs) => onProgress?.(retrying(remainingMs)));
-		} finally {
-			if (progressTimer) clearInterval(progressTimer);
-			stopActivityThrottle();
+			}, activityThrottleMs - elapsed);
+			pendingActivityTimer.unref?.();
 		}
+	};
+
+	try {
+		const advice = await consult(prompt, selection, cwd, signal, undefined, onActivity);
+		// `totalActivityCount` is read directly here rather than from the last onProgress snapshot,
+		// which may lag behind by up to `activityThrottleMs` -- the final count must be exact.
+		return { advice, durationMs: Date.now() - startedAt, activityCount: totalActivityCount };
+	} finally {
+		if (progressTimer) clearInterval(progressTimer);
+		stopActivityThrottle();
 	}
-	throw lastError;
 }
 
 export function advisorAttemptLabel(details: AdvisorToolDetails): string {
-	if (details.status === "retrying") {
-		return `Bro advisor · retrying in ${Math.ceil((details.retryInMs ?? 0) / 1_000)}s · attempt ${details.attempt}/${details.of}${details.error ? ` — ${details.error}` : ""}`;
-	}
 	if (details.status === "done") {
-		return `Bro advisor · ${details.model ?? "unknown model"} · ${details.attempt} attempt${details.attempt === 1 ? "" : "s"} · ${Math.ceil((details.durationMs ?? details.elapsedMs) / 1_000)}s`;
+		return `Bro advisor · ${details.model ?? "unknown model"} · ${Math.ceil((details.durationMs ?? details.elapsedMs) / 1_000)}s`;
 	}
 	const latest = details.activity?.at(-1);
 	const backendLabel = details.backend === "claude" ? "Claude" : details.backend === "grok" ? "Grok" : details.backend === "codex" ? "Codex" : details.backend === "muse" ? "Muse" : "Agy";
@@ -452,7 +382,7 @@ export function advisorAttemptLabel(details: AdvisorToolDetails): string {
 	const activityLabel = latest
 		? `last reported: ${advisorActivityPreview(latest)} (${Math.max(0, Math.floor((Date.now() - (details.lastActivityAt ?? Date.now())) / 1_000))}s ago)`
 		: `awaiting first activity from ${backendLabel}`;
-	return `Bro advisor · running · ${Math.floor(details.elapsedMs / 1_000)}s · attempt ${details.attempt}/${details.of} · ${activityLabel}`;
+	return `Bro advisor · running · ${Math.floor(details.elapsedMs / 1_000)}s · ${activityLabel}`;
 }
 
 export function registerAdvisorTool(pi: ExtensionAPI): void {
@@ -460,8 +390,8 @@ export function registerAdvisorTool(pi: ExtensionAPI): void {
 		name: ADVISOR_TOOL_NAME,
 		label: "Bro advisor",
 		description:
-			"Consult a fresh, independent process of the configured advisor backend for a second opinion mid-task. It has real, unsandboxed tool access in the current workspace (read files, search, run commands) with permissions auto-approved, and is instructed to investigate before advising and to leave edits to you — that is a behavioral instruction to the advisor, not an enforced restriction, so treat its findings as advice rather than a delegated implementation. No need to prepare a summary or evidence first: Bro automatically captures your system instructions, active tools, and the conversation so far, plus any human-set steering priorities, and sends them to the advisor.",
-		promptSnippet: "Consult a fresh configured-backend process for a second opinion mid-task; it investigates the workspace itself and returns advice",
+			"Consult a fresh, independent process of the configured advisor backend for a second opinion mid-task. It has real, unsandboxed tool access in the current workspace (read files, search, run commands) with permissions auto-approved, and is instructed to use the captured snapshot first, inspect the workspace only when needed, and leave edits to you — that is a behavioral instruction to the advisor, not an enforced restriction, so treat its findings as advice rather than a delegated implementation. No need to prepare a summary or evidence first: Bro automatically captures your system instructions, active tools, and the conversation so far, plus any human-set steering priorities, and sends them to the advisor.",
+		promptSnippet: "Consult a fresh configured-backend process for a second opinion mid-task; it reviews the captured session snapshot, can inspect the workspace when needed, and returns advice",
 		promptGuidelines: [
 			"Use bro_advisor when the user asks for an independent opinion, or when one would likely settle real uncertainty or catch a costly mistake. Routine decisions do not require consultation.",
 			"bro_advisor's question parameter is optional — Bro captures context automatically, so you do not need to prepare a summary or evidence before calling.",
@@ -483,21 +413,20 @@ export function registerAdvisorTool(pi: ExtensionAPI): void {
 			const prompt = buildAdvisorPrompt({ durable: durableSteering, session: state.steering }, snapshot.text, params?.question);
 			const hasDurable = Boolean(durableSteering.trim());
 			const hasSession = Boolean(state.steering.trim());
-			let lastAttempt: AdvisorToolDetails = { status: "investigating", attempt: 1, of: 3, elapsedMs: 0, backend };
+			let lastProgress: AdvisorToolDetails = { status: "investigating", elapsedMs: 0, backend };
 			try {
-				const run = await runAdvisorWithRetries(
+				const run = await runAdvisor(
 					prompt,
 					selection,
 					ctx.cwd,
 					signal ?? new AbortController().signal,
 					undefined,
-					undefined,
 					(details) => {
-						lastAttempt = { ...details, backend };
-						const label = advisorAttemptLabel(lastAttempt);
+						lastProgress = { ...details, backend };
+						const label = advisorAttemptLabel(lastProgress);
 						onUpdate?.({
 							content: [{ type: "text", text: label }],
-							details: lastAttempt,
+							details: lastProgress,
 						});
 						// A host's tool-card renderer may replace onUpdate's partial renderResult with its
 						// own generic placeholder for the whole run (observed with pi-cc-extensions' default
@@ -511,9 +440,8 @@ export function registerAdvisorTool(pi: ExtensionAPI): void {
 				const effort = selection.effort ?? "model default";
 				const omissions = `image/reasoning bodies omitted when present; ${snapshot.hadCompaction ? "Pi compaction summaries replace earlier turns" : "no Pi compaction summary present"}`;
 				const details: AdvisorToolDetails = {
-					...lastAttempt,
+					...lastProgress,
 					status: "done",
-					attempt: run.attempts,
 					backend,
 					model: selection.model,
 					effort,
@@ -524,12 +452,12 @@ export function registerAdvisorTool(pi: ExtensionAPI): void {
 					snapshotChars: snapshot.text.length,
 					broTruncated: false,
 					omissions,
-					// run.activityCount is the exact final total; lastAttempt's may lag behind by up to
+					// run.activityCount is the exact final total; lastProgress's may lag behind by up to
 					// the activity throttle window.
 					activityCount: run.activityCount,
 				};
-				// The backend qualifier appears only off Agy, keeping the Agy header byte-identical.
-				const header = `Bro advisor · ${backend === "agy" ? "" : `backend: ${backend} · `}model: ${selection.model} · effort: ${effort} · ${run.attempts} attempt${run.attempts === 1 ? "" : "s"} · ${Math.ceil(run.durationMs / 1_000)}s`;
+				// The backend qualifier appears only off Agy, keeping the Agy header concise.
+				const header = `Bro advisor · ${backend === "agy" ? "" : `backend: ${backend} · `}model: ${selection.model} · effort: ${effort} · ${Math.ceil(run.durationMs / 1_000)}s`;
 				const steeringSummary = hasDurable && hasSession
 					? "included (durable+session)"
 					: hasDurable

package/src/backend.ts

@@ -1376,11 +1376,10 @@ async function executeMuse(
 	}
 }
 
-// Single-attempt executor shared by all features. Never retries (retries are feature-owned,
-// e.g. advisor's 3-attempt backoff in bro.ts); never spawns a pre-aborted request; on cancellation,
-// host deadline, or a protocol failure, stops the whole POSIX process group (SIGTERM, then SIGKILL
-// after a bounded grace period) before resolving. `options` is for offline tests only -- production
-// callers never override the deadline or kill-escalation delay.
+// Single-attempt executor shared by all features. Never retries; never spawns a pre-aborted
+// request; on cancellation, host deadline, or a protocol failure, stops the whole POSIX process
+// group (SIGTERM, then SIGKILL after a bounded grace period) before resolving. `options` is for
+// offline tests only -- production callers never override the deadline or kill-escalation delay.
 export async function execute(
 	request: BackendRequest,
 	selection: BackendSelection,

package/src/prompt.ts

@@ -159,7 +159,7 @@ export function buildAdvisorPrompt(steering: AdvisorSteeringInput, snapshot: str
 	const questionSection = question?.trim()
 		? `## Executor's question\n\n${question.trim()}`
 		: "## Executor's question\n\nNone was given. Use your own judgment about what advice would help most, given the snapshot below.";
-	return `You are the Bro advisor: a separate process an executor coding agent voluntarily consulted mid-task, in the pi-bro Pi extension. You have real tool access in this workspace and are running with permissions auto-approved -- you can freely read files, search, and run read-oriented commands to verify claims. Investigate before advising: do not just restate what the snapshot below reports as true.
+	return `You are the Bro advisor: a separate process an executor coding agent voluntarily consulted mid-task, in the pi-bro Pi extension. You have real tool access in this workspace and are running with permissions auto-approved -- you can freely read files, search, and run read-oriented commands when needed. Use the snapshot below first; only read files or run commands when something you need is missing from the snapshot, may be stale after later edits, or a key claim is in doubt.
 
 Your job is strictly advisory. Return findings and recommendations in your reply; do not edit files or otherwise implement the change yourself -- the executor remains responsible for implementation.
 
@@ -167,11 +167,11 @@ ${steeringSection}
 
 ## Context snapshot from the executor's session
 
-This is background/evidence captured from the executor's own conversation. It is the executor's own account of what happened, not independently verified by you -- treat it as a starting point to check, not as ground truth:
+This is background/evidence captured from the executor's own conversation, including its tool calls and results. It is the executor's own account of what happened, not independently verified by you -- rely on the tool outputs already shown here before running new checks:
 
 ${snapshot}
 
 ${questionSection}
 
-Begin with a one-line answer or verdict. Then give concise findings, evidence, and recommended next actions grounded in what you verified yourself in the workspace. Omit investigation narration, waiting updates, and progress reports.`;
+Begin with a one-line answer or verdict. Then give concise findings, evidence, and recommended next actions grounded in the snapshot and any workspace checks you needed. Omit investigation narration, waiting updates, and progress reports.`;
 }