github-router 0.3.168 → 0.3.175

package/dist/{peer-mcp-personas-D826LsJJ.js → peer-mcp-personas-BCGYWok0.js}

@@ -1565,7 +1565,7 @@ function tool(toolNameHttp, description, inputSchema, handler) {
 	};
 }
 const ARTIFACT_TOOLS = Object.freeze([
-	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. Pass mode:\"interactive\" when the HTML carries data-aod-* action controls. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+	tool("artifact_open", "Opens a workspace file in ai-or-die's Artifact review panel for human review, replacing the current review if one is already open. The caller provides a workspace-relative or absolute file path and can set mode:\"interactive\" when the HTML carries data-aod-* action controls. It returns the review URL/session identifiers plus next-step guidance for draining feedback. Use it when the user should review a durable artifact before work continues; it is not for one-line status updates or non-file content. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
 		file: stringProp$2("Workspace-relative or absolute file path to show in the Artifact panel."),
 		mode: enumProp$1(["static", "interactive"], "Advisory. \"interactive\" signals the HTML contains data-aod-* action controls the panel should wire; \"static\" (default) is a read-and-annotate artifact.")
 	}, ["file"]), async (args, signal) => {
@@ -1584,7 +1584,7 @@ const ARTIFACT_TOOLS = Object.freeze([
 			next_step: "Tell the user to review at the Artifact panel, then call artifact_await to receive their feedback."
 		});
 	}),
-	tool("artifact_update", "Replace the current Artifact review's content in place. Provide EXACTLY ONE of file (a workspace file path) or html (raw HTML the server writes to the review's sandboxed file). html requires an already-open review. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+	tool("artifact_update", "Replaces the current Artifact review's content in place without opening a separate review. The caller provides exactly one of file, a workspace-relative or absolute file path, or html, raw HTML written into the existing review sandbox; html requires an already-open review, and idempotencyKey can make retries deduplicate on the server. It returns a minimal success signal plus next-step guidance for awaiting further feedback. Use it when revised content should replace what the human is already reviewing; use artifact_refresh instead when the existing on-disk artifact only needs to be reloaded. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
 		file: stringProp$2("Workspace-relative or absolute file path to become the review's new content."),
 		html: stringProp$2("Raw HTML to write into the review's existing sandboxed file, then reload."),
 		idempotencyKey: stringProp$2("Optional stable key so a retried update is de-duplicated by the server.")
@@ -1595,27 +1595,19 @@ const ARTIFACT_TOOLS = Object.freeze([
 		const html = optionalString$2(args, "html");
 		if (file === void 0 === (html === void 0)) throw new ArtifactToolInputError("INVALID_ARGUMENT", "artifact_update requires EXACTLY ONE of arguments.file or arguments.html");
 		const idempotencyKey = optionalString$2(args, "idempotencyKey");
-		return ok$2({
-			...await clientFromEnv(env).update({
-				file,
-				html,
-				idempotencyKey,
-				signal
-			}),
-			ok: true,
-			next_step: "The panel now shows the updated content. Call artifact_await for further feedback."
-		});
+		return ok$2(formatUpdateSuccess(await clientFromEnv(env).update({
+			file,
+			html,
+			idempotencyKey,
+			signal
+		})));
 	}),
-	tool("artifact_refresh", "Force the ai-or-die Artifact panel to reload the current artifact from disk (no content change). Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+	tool("artifact_refresh", "Reloads the currently-open Artifact review from its existing on-disk file without changing the content source. The tool takes no inputs and returns a minimal success signal plus next-step guidance for awaiting feedback. Use it after an out-of-band edit changes the reviewed file on disk and the panel needs to pick up that version. Do not use it to replace the artifact with a new file or raw HTML; use artifact_update for that. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		return ok$2({
-			...await clientFromEnv(env).refresh(signal),
-			ok: true,
-			next_step: "The panel reloaded the artifact. Call artifact_await for feedback."
-		});
+		return ok$2(formatRefreshSuccess(await clientFromEnv(env).refresh(signal)));
 	}),
-	tool("artifact_await", "Wait for the human's next Artifact review events (typed drain: comments AND structured action-button/checkbox events) and return them with a cursor. Pass the returned cursor on the next call to receive only newer events. Supersedes artifact_poll. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+	tool("artifact_await", "Waits for the human's next Artifact review events and returns a typed drain containing comments, structured action-button or checkbox events, status, cursor, and next-step guidance. The caller can pass the cursor from a previous response to receive only newer events and can provide timeoutMs as the server long-hold budget. It may return an empty events list on a quiet long-hold; callers should pass the returned cursor on the next artifact_await call. Use it as the primary review-feedback drain after artifact_open or artifact_update; it supersedes artifact_poll, which is legacy comments-only. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
 		cursor: stringProp$2("High-water cursor from the previous artifact_await response. Omit on the first call."),
 		timeoutMs: numberProp$2("Optional server long-hold budget in ms (default ~25000).")
 	}, []), async (args, signal) => {
@@ -1629,35 +1621,23 @@ const ARTIFACT_TOOLS = Object.freeze([
 			signal
 		})));
 	}),
-	tool("artifact_dismiss", "Hide the ai-or-die Artifact panel UI while keeping the review alive (queued feedback preserved, channel open, re-openable). Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+	tool("artifact_dismiss", "Hides the ai-or-die Artifact panel UI while keeping the current review alive. The tool takes no inputs and returns a minimal success signal plus next-step guidance for reopening or awaiting later feedback. Use it when the panel should get out of the way but queued feedback should remain preserved, the channel should stay open, and the review should be re-openable. Do not use it when the review loop is finished; use artifact_end to close the review instead. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		return ok$2({
-			...await clientFromEnv(env).dismiss(signal),
-			ok: true,
-			next_step: "The panel is hidden but the review is still live. Re-open the artifact or call artifact_await when ready."
-		});
+		return ok$2(formatDismissSuccess(await clientFromEnv(env).dismiss(signal)));
 	}),
-	tool("artifact_reply", "Send the agent's reply back to the ai-or-die Artifact review panel after applying or responding to human feedback. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({ text: stringProp$2("Agent reply text to deliver to the human Artifact review panel.") }, ["text"]), async (args, signal) => {
+	tool("artifact_reply", "Sends the agent's reply back to the ai-or-die Artifact review panel after applying or responding to human feedback. The caller provides the reply text, and the tool returns a minimal success signal plus next-step guidance for either continuing the review loop or moving on. Use it to acknowledge what changed, answer a reviewer question, or summarize how feedback was handled after artifact_await returns events. Do not use it to replace panel content, wait for more feedback, hide the UI, or close the review. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({ text: stringProp$2("Agent reply text to deliver to the human Artifact review panel.") }, ["text"]), async (args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
 		const text = requiredString$2(args, "text");
-		return ok$2({
-			...await clientFromEnv(env).agentReply(text, signal),
-			ok: true,
-			next_step: "Wait for further human review, or continue if the review loop is complete."
-		});
+		return ok$2(formatReplySuccess(await clientFromEnv(env).agentReply(text, signal)));
 	}),
-	tool("artifact_end", "End/close the ai-or-die Artifact review panel when the review loop is complete. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+	tool("artifact_end", "Ends and closes the ai-or-die Artifact review panel when the review loop is complete. The tool takes no inputs and returns a minimal success signal plus terminal next-step guidance. Use it after the human review is finished and no further feedback should arrive. Do not use it for a temporary hide or pause; use artifact_dismiss when the review should stay live. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		return ok$2({
-			...await clientFromEnv(env).end(signal),
-			ok: true,
-			next_step: "Artifact review loop ended."
-		});
+		return ok$2(formatEndSuccess(await clientFromEnv(env).end(signal)));
 	}),
-	tool("artifact_poll", "FROZEN legacy alias for artifact_await (old payload, human comments only, no structured actions). New agents should call artifact_await instead. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({ timeoutMs: numberProp$2("Optional per-call budget hint in ms (advisory).") }, []), async (_args, signal) => {
+	tool("artifact_poll", "Provides the frozen legacy polling path for Artifact review feedback. The caller may provide timeoutMs as an advisory per-call budget, and the tool returns the old comments-only payload with status, prompts, and next-step guidance rather than typed action events or a cursor. Use it only for compatibility with older clients or flows that still require the old payload shape. New callers should use artifact_await instead because it returns typed comments and structured action-button or checkbox events. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({ timeoutMs: numberProp$2("Optional per-call budget hint in ms (advisory).") }, []), async (_args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
 		return ok$2(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
@@ -1735,6 +1715,50 @@ function formatPollResponse(response) {
 		next_step: response.next_step ?? defaultPollNextStep(response.status)
 	});
 }
+function formatUpdateSuccess(response) {
+	return definedObject$1({
+		ok: true,
+		viewUrl: stringField$1(response, "viewUrl"),
+		next_step: "The panel now shows the updated content. Call artifact_await for further feedback."
+	});
+}
+function formatRefreshSuccess(response) {
+	return definedObject$1({
+		ok: true,
+		viewUrl: stringField$1(response, "viewUrl"),
+		panelUrl: stringField$1(response, "panelUrl"),
+		status: stringField$1(response, "status"),
+		visibility: stringField$1(response, "visibility"),
+		next_step: "The panel reloaded the artifact. Call artifact_await for feedback."
+	});
+}
+function formatDismissSuccess(response) {
+	return definedObject$1({
+		ok: true,
+		viewUrl: stringField$1(response, "viewUrl"),
+		panelUrl: stringField$1(response, "panelUrl"),
+		status: stringField$1(response, "status"),
+		visibility: stringField$1(response, "visibility"),
+		next_step: "The panel is hidden but the review is still live. Re-open the artifact or call artifact_await when ready."
+	});
+}
+function formatReplySuccess(response) {
+	return definedObject$1({
+		ok: true,
+		reply: response.reply,
+		delivered: booleanField(response, "delivered"),
+		confirmed: booleanField(response, "confirmed"),
+		status: stringField$1(response, "status"),
+		next_step: "Wait for further human review, or continue if the review loop is complete."
+	});
+}
+function formatEndSuccess(response) {
+	return definedObject$1({
+		ok: true,
+		status: response.status,
+		next_step: "Artifact review loop ended."
+	});
+}
 /**
 * Shape the typed drain for the model: pass events through verbatim (unknown
 * `kind`s preserved — the model ignores what it does not understand), echo the
@@ -1839,6 +1863,14 @@ function definedObject$1(input) {
 	for (const [key, value] of Object.entries(input)) if (value !== void 0) result[key] = value;
 	return result;
 }
+function stringField$1(input, key) {
+	const value = input[key];
+	return typeof value === "string" ? value : void 0;
+}
+function booleanField(input, key) {
+	const value = input[key];
+	return typeof value === "boolean" ? value : void 0;
+}
 function objectSchema$2(properties, required) {
 	return {
 		type: "object",
@@ -3596,10 +3628,10 @@ function createFleetTools(options = {}) {
 		};
 	}
 	return Object.freeze([
-		tool$1("list_instances", "List registered remote ai-or-die instances in the fleet registry. Tokens are never returned.", objectSchema$1({}, []), async () => {
+		tool$1("list_instances", "Lists registered remote ai-or-die fleet instances and probes whether each instance is currently reachable. It takes no input; the registry decides which instances exist, and credentials or tunnel tokens are not returned. It returns instances with id, label, reachable status, sessionCount and lastSeen for reachable hosts, or error and hint for unreachable hosts. It is useful as the discovery entry point before list_sessions, create_session, or other fleet tools that need an instance id. It is not for local repository search or for reading sessions; use local tools for this machine and list_sessions after choosing an instance.", objectSchema$1({}, []), async () => {
 			return ok$1({ instances: await mapWithConcurrency(await getRegistry().listInstances(), fleetFanoutConcurrency(LIST_INSTANCES_FANOUT_CONCURRENCY), (instance) => probeInstance(instance)) });
 		}),
-		tool$1("list_sessions", "List sessions on one fleet instance, returning globally-addressable session ids.", objectSchema$1({ instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance.") }, []), async (args, signal) => {
+		tool$1("list_sessions", "Lists sessions on one remote ai-or-die fleet instance and returns session ids that can be used by the other fleet session tools. The optional instance input is an id or label; when it is omitted, the registry default or sole instance is used. It returns resolvedInstance and sessions, with each sessionId globalized as instanceId:localSessionId. It is useful after list_instances to choose a remote session to inspect, message, drive, or stop. It is not a fleet-wide listing and does not read transcript output; call it per instance, and use read_session for a session's text tail.", objectSchema$1({ instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance.") }, []), async (args, signal) => {
 			const instance = await resolve(optionalString$1(args, "instance"));
 			const response = await clientFor(instance).listSessions(signal);
 			return ok$1({
@@ -3607,11 +3639,10 @@ function createFleetTools(options = {}) {
 				sessions: response.sessions.map((session) => globalizeSession(instance.id, session))
 			});
 		}),
-		tool$1("read_session", "Read recent text output from an addressed fleet session.", objectSchema$1({
+		tool$1("read_session", "Reads recent text output from an addressed remote ai-or-die fleet session. The required sessionId must be a global id in instanceId:localSessionId form; the optional instance input is only a cross-check and must resolve to the same instance. It returns resolvedInstance, sessionId, text, truncated, source, and the session status snapshot. It is useful for inspecting the transcript tail after send_message, await_turn, or drive_task. It is not for lifecycle-only checks or live waiting; use session_status for point-in-time state and await_turn to wait for new events.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
-			lines: numberProp$1("Number of recent lines to read."),
-			format: stringProp$1("Reserved for future formatting; results are JSON text today.")
+			lines: numberProp$1("Number of recent lines to read.")
 		}, ["sessionId"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
 			const lines = optionalNumber$1(args, "lines");
@@ -3622,7 +3653,7 @@ function createFleetTools(options = {}) {
 				sessionId: globalId
 			});
 		}),
-		tool$1("session_status", "Fetch lifecycle and interaction status for an addressed fleet session.", objectSchema$1({
+		tool$1("session_status", "Fetches the lifecycle and interaction status for an addressed remote ai-or-die fleet session. The required sessionId must be a global id in instanceId:localSessionId form; the optional instance input is only a cross-check and must resolve to the same instance. It returns resolvedInstance, sessionId, and a status object that can include lifecycle, interactionState, canAcceptInput, blockReason, and awaiting details. It is useful before deciding whether a session can accept a message or is awaiting a prompt. It is not a transcript reader or event watcher; use read_session for output text and await_turn for turn-completion events.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId.")
 		}, ["sessionId"]), async (args, signal) => {
@@ -3634,7 +3665,7 @@ function createFleetTools(options = {}) {
 				sessionId: globalId
 			});
 		}),
-		tool$1("send_message", "Send a message to a fleet session. By DEFAULT it first checks the session is idle / awaiting the next message and REFUSES (structured notReady, isError) rather than blind-type into a busy composer or a pending prompt — set requireIdle:false to force the legacy unconditional send, or waitForIdleMs to wait briefly for idle first. isError reflects DELIVERY: true when the message was not delivered (transport/precondition failure) OR refused as notReady. A delivered message whose confirmation did not arrive within awaitMs is NOT an error — it returns delivered:true with confirmationPending/confirmationTimedOut, because a long turn legitimately outruns awaitMs. The additive `submitted` field is true only when ai-or-die's submission sub-status proves the message reached the composer. Recommended pattern: send with awaitMs:0 for a fast delivery ack, then call await_turn (filtered to this sessionId) to observe the session's actual turn completion. The idempotencyKey makes a retried send safe (a retry never re-types the message).", objectSchema$1({
+		tool$1("send_message", "Sends a free-text message to an existing remote ai-or-die fleet session. The required sessionId must be global, message is the text to deliver, requireIdle defaults to true, waitForIdleMs can wait briefly for readiness, awaitMs waits only for best-effort delivery confirmation, and idempotencyKey is usually auto-generated unless retrying the same send. It returns resolvedInstance, sessionId, delivered, confirmed, submitted when the remote proves the composer accepted the message, and confirmationPending/confirmationTimedOut when delivery succeeded but the turn outran the await window; delivered:false or notReady is reported as an error result. It is useful for sending the next free-text instruction to an idle session, especially with awaitMs:0 followed by await_turn for the actual turn boundary. It is not for answering an awaited choice prompt or sending control keys; use respond for prompts and send_keys for submit, interrupt, or literal key sequences.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
 			message: stringProp$1("Message text to deliver to the session."),
@@ -3691,7 +3722,7 @@ function createFleetTools(options = {}) {
 				...isError ? { message: "message was not delivered to the session by the upstream instance" } : confirmationTimedOut ? { message: "delivered; turn completion not confirmed in the await window. Use await_turn filtered to this sessionId to observe completion (the idempotencyKey makes a retried send safe)." } : {}
 			}, isError);
 		}),
-		tool$1("send_keys", "Send key input to a fleet session. Prefer the higher-level `op`: 'submit' presses Enter and 'interrupt' sends Ctrl-C, each mapped to ai-or-die's NAMED key (never a literal control byte like \"\\r\"). Use `keys` only for literal input; `raw` is strictly for literal bytes. Provide exactly one of `op` or `keys`.", objectSchema$1({
+		tool$1("send_keys", "Sends key input to an existing remote ai-or-die fleet session. The required sessionId must be global; provide exactly one of op or keys, where op is a named operation (`submit` for Enter or `interrupt` for Ctrl-C) and keys is a literal key sequence; raw only applies to literal keys. It returns resolvedInstance, sessionId, delivered, duplicated when an idempotency retry was deduped, and the mapped key name when op was used. It is useful for control-key actions such as submitting a typed prompt or interrupting a busy turn without stopping the session. It is not the normal free-text path and not the prompt-answer path; use send_message for free text and respond for awaited prompts.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
 			op: stringProp$1("Higher-level named op: 'submit' (Enter) or 'interrupt' (Ctrl-C). Mapped to the ai-or-die named key with raw off. Do NOT also pass keys."),
@@ -3726,10 +3757,11 @@ function createFleetTools(options = {}) {
 					op,
 					mappedKeys: keys
 				},
-				...response
+				delivered: response.delivered,
+				...response.duplicated === void 0 ? {} : { duplicated: response.duplicated }
 			});
 		}),
-		tool$1("respond", "Answer an awaited prompt in a fleet session by choice, option value, or explicit key override.", objectSchema$1({
+		tool$1("respond", "Answers an awaited prompt in an existing remote ai-or-die fleet session by selecting a choice, selecting an exact option value, or sending explicit keys. The required sessionId must be global; choose the answer mode that matches the prompt, and idempotencyKey is usually auto-generated unless retrying the same response. It returns resolvedInstance, sessionId, delivered, duplicated when an idempotency retry was deduped, and any awaitingKind or mappedKeys supplied by the remote; delivered:false is reported as an error result. It is useful only when session_status or await_turn shows the session is waiting for a prompt or choice. It is not for ordinary free-text instructions or control keys; use send_message for free text and send_keys for submit or interrupt.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
 			choice: stringProp$1("Named or numbered choice to select."),
@@ -3745,23 +3777,35 @@ function createFleetTools(options = {}) {
 				idempotencyKey: optionalString$1(args, "idempotencyKey") ?? randomUUID()
 			});
 			const response = await clientFor(instance).respond(localId, input, signal);
-			return ok$1({
+			const delivered = response.delivered !== false;
+			return jsonResult$1({
 				resolvedInstance: publicInstance(instance),
 				sessionId: globalId,
-				...response
-			});
+				...response,
+				delivered,
+				...delivered ? {} : { message: "response was not delivered to the session by the upstream instance" }
+			}, !delivered);
 		}),
-		tool$1("create_session", "Create a new session on a specific fleet instance. The instance argument is required; no default is used.", objectSchema$1({
+		tool$1("create_session", "Creates a new session on a specific remote ai-or-die fleet instance. The instance input is required and never defaults; agent is required and must be one of claude, codex, copilot, gemini, or terminal; start:true is required for the session to actually run and be driveable. It returns resolvedInstance plus the remote create response, with sessionId converted to the global instanceId:localSessionId form when creation succeeds. It is useful when the user wants a new remote session to run on a named fleet host before using drive_task, send_message, or await_turn. It is not for selecting or inspecting an existing session; use list_instances and list_sessions first when the target is unknown.", objectSchema$1({
 			instance: stringProp$1("Required instance id or label. Create never uses the registry default."),
-			agent: stringProp$1("Agent/runtime to create on the instance."),
+			agent: {
+				...stringProp$1("Required agent/runtime to create on the instance. Valid values: claude, codex, copilot, gemini, terminal."),
+				enum: [
+					"claude",
+					"codex",
+					"copilot",
+					"gemini",
+					"terminal"
+				]
+			},
 			name: stringProp$1("Optional display name for the session."),
 			workingDir: stringProp$1("Optional working directory on the remote instance."),
 			idempotencyKey: stringProp$1("Optional caller idempotency key; auto-generated when omitted."),
-			start: booleanProp("Whether the remote instance should start the session immediately."),
-			readyTimeoutMs: numberProp$1("F17: bounded ms to wait for the agent to become driveable before returning. The response carries ready/bound/blocker."),
-			permissionMode: stringProp$1("F10 (claude only): permission mode the launched agent starts in — one of plan | acceptEdits | default | bypassPermissions. Rejected with BAD_REQUEST if unknown or if agentArgs also sets it."),
-			agentArgs: arrayProp("F10 (claude only): extra launcher args appended after the github-router prefix. Must NOT include --permission-mode or --dangerously-skip-permissions (use permissionMode) — rejected with BAD_REQUEST."),
-			disableStopGate: booleanProp("C3 (claude only): disable the structural Stop-gate on the launched session by injecting --no-stop-gate into agentArgs, so a driven session's turn-end never hangs on a blocking Stop hook. Requires a remote github-router that understands the flag (uses the agent_args capability).")
+			start: booleanProp("Set true to start the remote session immediately; without start:true the created session is not running or driveable."),
+			readyTimeoutMs: numberProp$1("Bounded milliseconds to wait for the agent to become driveable before returning. The response carries ready, bound, and blocker."),
+			permissionMode: stringProp$1("Claude-only permission mode for the launched agent: plan, acceptEdits, default, or bypassPermissions. Rejected with BAD_REQUEST if unknown or if agentArgs also sets it."),
+			agentArgs: arrayProp("Claude-only extra launcher args appended after the github-router prefix. Do not include --permission-mode or --dangerously-skip-permissions; use permissionMode instead."),
+			disableStopGate: booleanProp("Claude-only option to disable the structural Stop-gate on the launched session by injecting --no-stop-gate into agentArgs, so a driven session's turn-end does not hang on a blocking Stop hook. Requires a remote github-router that understands the flag.")
 		}, ["instance", "agent"]), async (args, signal) => {
 			const instance = await resolve(requiredString$1(args, "instance"));
 			const agent = requiredString$1(args, "agent");
@@ -3789,7 +3833,7 @@ function createFleetTools(options = {}) {
 				sessionId: localSessionId ? encodeSessionId(instance.id, localSessionId) : response.sessionId
 			});
 		}),
-		tool$1("stop_session", "Stop a fleet session.", objectSchema$1({
+		tool$1("stop_session", "Terminates an existing remote ai-or-die fleet session. The required sessionId must be global; instance is only a cross-check, mode is an optional remote-understood stop mode, and idempotencyKey is usually auto-generated unless retrying the same stop. It returns resolvedInstance, sessionId, stopped, and lifecycle. It is useful when the remote session should be ended and its in-flight turn should be killed. It is destructive and irreversible, with no resume companion; to merely unstick or interrupt a busy session without terminating it, use send_keys with op `interrupt`.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
 			idempotencyKey: stringProp$1("Optional caller idempotency key; auto-generated when omitted."),
@@ -3807,10 +3851,10 @@ function createFleetTools(options = {}) {
 				...response
 			});
 		}),
-		tool$1("await_turn", "Long-poll session events across fleet instances. The server owns per-target opaque cursors, so callers do not pass cursor tokens. Distinct concurrent watchers over the same instance set should pass a distinct watcherId so they do not share a cursor.", objectSchema$1({
+		tool$1("await_turn", "Long-polls session events across remote ai-or-die fleet instances. The caller selects targets with instances, sessionIds, or neither for every registered instance; timeoutMs bounds each per-instance long poll, kinds filters event kinds, and watcherId isolates cursor state for concurrent watchers. It returns resolvedInstances, time-sorted stamped events, gaps, cursors, more, optional per-session settled classifications, and optional per-instance errors. It is useful after send_message with awaitMs:0 to observe the real turn boundary; a settled status such as turn_ended or waiting_input is the reliable completion signal, while idle flickers are not completion. It is not a transcript reader or a one-shot task driver; use read_session for text output and drive_task when sending one prompt and waiting for its report should be a single composite operation.", objectSchema$1({
 			instances: arrayProp("Instance ids or labels to poll. Omit with sessionIds to target those session instances; omit both to poll every registered instance."),
 			sessionIds: arrayProp("Global session ids to filter to."),
-			timeoutMs: numberProp$1("Long-poll timeout per instance in milliseconds."),
+			timeoutMs: numberProp$1(`Long-poll timeout per instance in milliseconds (default ${AWAIT_TURN_DEFAULT_TIMEOUT_MS}).`),
 			kinds: arrayProp("Optional event kinds to filter to."),
 			watcherId: stringProp$1("Optional stable id for this watcher. Use a distinct value for concurrent watchers over the same target set to keep cursors isolated.")
 		}, []), async (args, signal) => {
@@ -3873,7 +3917,7 @@ function createFleetTools(options = {}) {
 				...errors.length > 0 ? { errors } : {}
 			});
 		}),
-		tool$1("drive_task", "Drive one prompt on a session to completion and return the parsed operator report. Composes the reliable path: ensure the composer is idle (else return a structured busy/not-ready result), send and surface whether the message reached the composer (submitted; a delivered-but-unconfirmed send still proceeds), wait for the RELIABLE turn boundary (turn_ended / waiting_input — never the became_idle flicker), read the transcript tail, and parse the OPERATOR REPORT trailer into {state, summary, ask, artifact, raw}. A per-call REPORT_ID nonce is embedded in the trailer instruction and the parsed report is trusted ONLY when it echoes that nonce, so a stale prior-turn trailer left in the tail can never be returned as this turn's result. A reliable waiting_input outranks the model's self-reported STATE (a still-blocked session is never reported as done). If the turn does not end within timeoutMs (e.g. a blocking Stop hook that would otherwise hang ~10 min), it AUTO-RECOVERS with a Ctrl-C interrupt rather than blocking, then re-waits briefly and re-reads; a caller ABORT is distinct (settled:'aborted', state:'aborted') and never injects a Ctrl-C. Read `state` TOGETHER with `settled`/`interrupted`/`recovered`: state:'done' with settled:'timeout' + interrupted:true means the model reported done but the turn had to be interrupted to recover, so treat it as needs-verification rather than a clean completion; `submitted` is a best-effort positive signal that CAN be false even on a successful turn. Robust to a busy session (state:'busy'), a missing/stale/placeholder trailer (state falls back to the settle-derived value, reportFound:false), and a hung hook (interrupted:true, recovered:true/false). By default it appends the trailer instruction so the driven session emits a parseable report; set expectReport:false to send the prompt verbatim (a trailer left in the tail is then never trusted).", objectSchema$1({
+		tool$1("drive_task", "Drives one prompt on an existing remote ai-or-die fleet session to completion and returns a parsed operator report. The required sessionId must be global, prompt is the single instruction to send, timeoutMs controls when a hung turn is interrupted for recovery, and expectReport defaults to true so a nonce-guarded OPERATOR REPORT trailer is appended and parsed. It returns resolvedInstance, sessionId, state, summary, ask, artifact, raw, settled, submitted, reportFound, and recovery fields such as interrupted or recovered; state must be read together with settled and interrupted because a timeout recovery can leave work needing verification. It is useful as the composite path that performs the safe send_message plus await_turn plus read_session sequence for one already-created session. It is not a session creator, a multi-turn conversation loop, or a simple transcript read; use create_session first when needed, send_message and await_turn when controlling each step manually, and read_session when only the transcript tail is needed.", objectSchema$1({
 			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
 			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
 			prompt: stringProp$1("The task/prompt to drive on the session."),
@@ -3898,7 +3942,7 @@ function createFleetTools(options = {}) {
 				...result
 			}, result.error !== void 0);
 		}),
-		tool$1("read_file", "Read a file from one fleet instance via its existing /api/files/content endpoint.", objectSchema$1({
+		tool$1("read_file", "Reads a file from one remote ai-or-die fleet instance's filesystem. The required path is passed to the remote host as an unsanitized read request; this router does not confine it to a local workspace, and path policy is delegated to the remote instance. It returns resolvedInstance plus the remote file-content response. It is useful for reading a known file on a remote fleet host after choosing an instance. It is not for local files, directory browsing, text search, git revisions, or session transcripts; use local Read for this machine, list_dir to browse remote directories, search to find remote files, git_show for revision content, and read_session for terminal output.", objectSchema$1({
 			instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance."),
 			path: stringProp$1("Remote file path to read.")
 		}, ["path"]), async (args, signal) => {
@@ -3909,7 +3953,7 @@ function createFleetTools(options = {}) {
 				...response
 			});
 		}),
-		tool$1("list_dir", "List a directory on one fleet instance via its existing /api/files endpoint.", objectSchema$1({
+		tool$1("list_dir", "Lists a directory on one remote ai-or-die fleet instance. The required path is the remote directory path, and instance can select a registered host or default to the registry default or sole instance. It returns resolvedInstance plus the remote directory-listing response. It is useful for browsing a remote workspace before choosing a file to read or search. It is not for local directories, file contents, git revisions, or session transcripts; use local filesystem tools for this machine, read_file for remote file contents, git_show for revision content, and read_session for terminal output.", objectSchema$1({
 			instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance."),
 			path: stringProp$1("Remote directory path to list.")
 		}, ["path"]), async (args, signal) => {
@@ -3920,7 +3964,7 @@ function createFleetTools(options = {}) {
 				...response
 			});
 		}),
-		tool$1("search", "Search files on one fleet instance via its existing /api/search endpoint.", objectSchema$1({
+		tool$1("search", "Searches files on one remote ai-or-die fleet instance's workspace, where a fleet instance is a registered remote host exposed through the fleet MCP server. The required query is sent to that remote instance, and path can narrow the remote search scope; this does not search the local repository or the web. It returns resolvedInstance plus the remote search response. It is useful when the target content lives on a remote fleet host. It is not for this checkout, semantic code discovery, or internet research; use mcp__search__code for the local workspace and mcp__search__web for web search.", objectSchema$1({
 			instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance."),
 			query: stringProp$1("Search query."),
 			path: stringProp$1("Optional path scope.")
@@ -3932,18 +3976,16 @@ function createFleetTools(options = {}) {
 				...response
 			});
 		}),
-		tool$1("git_show", "Read a file/revision through one fleet instance's existing /api/files/git-show endpoint.", objectSchema$1({
+		tool$1("git_show", "Shows git content on one remote ai-or-die fleet instance, such as a file at a specific revision or a commit object. The required path identifies the remote repository path or file path, and the optional ref is a git commit-ish such as HEAD, a branch, a tag, or a commit SHA. It returns resolvedInstance plus the remote git-show response. It is useful when the caller needs repository content as it existed at a revision on the remote host. It is not for current working-tree reads, directory listings, local git commands, or web search; use read_file for current remote file content and local tools for this checkout.", objectSchema$1({
 			instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance."),
 			path: stringProp$1("Remote repository path or file path for git-show."),
-			ref: stringProp$1("Optional git ref/revision."),
-			rev: stringProp$1("Optional git revision alias."),
-			commit: stringProp$1("Optional commit id.")
+			ref: stringProp$1("Optional git ref, revision, or commit-ish, such as HEAD, a branch, a tag, or a commit SHA.")
 		}, ["path"]), async (args, signal) => {
 			const instance = await resolve(optionalString$1(args, "instance"));
-			const response = await clientFor(instance).gitShow({
-				...args,
-				instance: void 0
-			}, signal);
+			const response = await clientFor(instance).gitShow(definedObject({
+				path: requiredString$1(args, "path"),
+				ref: optionalString$1(args, "ref")
+			}), signal);
 			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response
@@ -10421,7 +10463,7 @@ function createFirstMateTools(depsOverride = {}) {
 		};
 	}
 	return Object.freeze([
-		tool$1("start_mission", "Register a first-mate mission for one or more GitHub repositories. Unit decomposition is handled by later controller/model wakes.", objectSchema({
+		tool$1("start_mission", "Registers a first-mate mission in the local durable controller for one or more GitHub repositories; it does not dispatch work or touch GitHub on this call. Inputs provide the mission goal, owner/name repos, user-blessed acceptance criteria, and optional priority, house rules, default cloud-agent model, plan gate, and CI requirement. Returns the new mission id and normalized repo list so later wakes can decompose and dispatch units. Use when the operator has accepted mission scope and wants the first-mate loop to own tracking. It is not for one-off status reads, adding units to an existing mission, or missions whose acceptance criteria are still unsettled.", objectSchema({
 			goal: stringProp("Mission goal."),
 			repos: stringArrayProp("Repositories as owner/name strings."),
 			acceptance_criteria: stringProp("User-blessed acceptance criteria for the mission."),
@@ -10460,7 +10502,7 @@ function createFirstMateTools(depsOverride = {}) {
 				repos
 			});
 		}),
-		tool$1("scaffold_repo", "Seed deterministic agentic-dev convention files into a GitHub repository on a pull-request branch.", objectSchema({
+		tool$1("scaffold_repo", "Seeds first-mate and agentic-dev convention files into a GitHub repository by creating a scaffold branch, committing deterministic files, and opening a pull request; it does not write directly to the default branch. Inputs name the owner/name repo, optional base ref, handling mode, and optional detection overrides for stack, OS, package manager, commands, and UI evidence. Returns the pull request plus committed, preserved, and per-file report data, or a no-op note when nothing needs seeding. Use when preparing an owned repository for the first-mate cloud-agent workflow. It is not for arbitrary third-party repositories, normal feature work, or repeated runs unless the operator intentionally wants missing or enhanced convention files.", objectSchema({
 			repo: stringProp("Repository as an owner/name string."),
 			mode: enumProp([
 				"add-missing-only",
@@ -10521,7 +10563,7 @@ function createFirstMateTools(depsOverride = {}) {
 				report: plan.reports
 			});
 		}),
-		tool$1("advance", "Wake the first-mate controller once, applying model answers or human decisions, then return the compact board and pending requests.", objectSchema({
+		tool$1("advance", "Wakes the first-mate controller once, optionally applying model answers and human decisions before driving eligible missions. Inputs can supply prior request answers, bound returned request count, provider concurrency, scope the wake to one mission, or include inactive missions in the returned view. Returns the compact board, inactive summary, pending model and human requests, applied answer count, next wake timing, and whether this caller actually drove or deferred to another driver. Use when the operator is advancing the durable loop, responding to needsModel/needsHuman, or scheduling the next wake from nextWakeSeconds. It is not for read-only status checks; board reads the whole portfolio without a wake, and mission_status reads a mission-id-scoped status view.", objectSchema({
 			model_answers: arrayOfObjectsProp("Optional model judgments to apply before the wake.", {
 				requestId: stringProp("Request id from a previous needsModel entry."),
 				verdict: anyProp("Structured verdict for the request kind.")
@@ -10575,7 +10617,7 @@ function createFirstMateTools(depsOverride = {}) {
 				drove: result.drove !== false
 			});
 		}),
-		tool$1("board", "Read compact board status. Defaults to active missions only; pass include_all to include inactive missions.", objectSchema({ include_all: boolProp("When true, include inactive missions in the board. Default returns active missions only and summarizes inactive counts.") }, []), async (args) => {
+		tool$1("board", "Reads the compact first-mate portfolio board without waking the controller, dispatching work, or applying answers. Inputs only choose whether inactive missions are included; active missions are returned by default with inactive counts summarized separately. Returns the same board shape that advance returns as a side effect, including mission phase counts, blocked counts, unit rows, and inactive summary. Use when the operator needs a whole-portfolio snapshot. It is not for driving progress or applying pending requests; advance does that, and mission_status is the read path scoped to a single mission id.", objectSchema({ include_all: boolProp("When true, include inactive missions in the board. Default returns active missions only and summarizes inactive counts.") }, []), async (args) => {
 			const includeAll = optionalBoolean(args, "include_all") ?? false;
 			const [missions, units] = await Promise.all([readMissions(), loadAllUnits()]);
 			return ok({
@@ -10583,7 +10625,7 @@ function createFirstMateTools(depsOverride = {}) {
 				inactiveSummary: summarizeInactiveMissions(missions)
 			});
 		}),
-		tool$1("merge_pr", "Merge a GitHub pull request the operator has reviewed. Head-guarded (rejects a moved head), ownership-scoped (agent-authored or an active first-mate mission repo, else requires allow_unowned), and gated on a pre-merge safety check (OPEN, not draft, MERGEABLE, CI green).", objectSchema({
+		tool$1("merge_pr", "Merges a live GitHub pull request immediately, which is irreversible through this tool once GitHub accepts the merge. Inputs identify the repo and PR, bind the action to the exact reviewed head SHA, optionally bind the reviewed base branch, select the merge method, and can explicitly override ownership with allow_unowned. Returns GitHub's merge result and merge SHA after the live PR passes head-SHA and optional base concurrency checks, ownership checks, OPEN/not-draft/mergeable checks, and available CI or workflow checks. Use only after out-of-band human authorization for this exact head; this tool does not consult the first-mate approval ledger. It is not for PRs that are not agent-authored or correlated to a first-mate unit (unit.pr === pr) unless allow_unowned is intentionally set; a repo with no configured CI can merge on operator review plus the non-CI guards.", objectSchema({
 			repo: stringProp("Repository as an owner/name string."),
 			pr: numberProp("Pull request number."),
 			expected_head_sha: stringProp("The exact head commit SHA the operator reviewed. The merge is REJECTED if the live head has moved from this value; re-review the new head before merging."),
@@ -10593,7 +10635,7 @@ function createFirstMateTools(depsOverride = {}) {
 				"squash",
 				"rebase"
 			], "Merge method. Defaults to squash."),
-			allow_unowned: boolProp("Set true to merge a PR that is neither agent-authored nor part of an active first-mate mission. Dangerous, explicit opt-in; the override is audit-logged.")
+			allow_unowned: boolProp("Set true to merge a PR that is neither agent-authored nor correlated to a first-mate unit (unit.pr === pr). Dangerous, explicit opt-in; the override is audit-logged.")
 		}, [
 			"repo",
 			"pr",
@@ -10625,10 +10667,10 @@ function createFirstMateTools(depsOverride = {}) {
 				sha: merged.sha
 			});
 		}),
-		tool$1("close_pr", "Close a GitHub pull request WITHOUT merging it. Ownership-scoped identically to merge_pr (agent-authored or active first-mate mission repo, else requires allow_unowned).", objectSchema({
+		tool$1("close_pr", "Closes a live GitHub pull request without merging it and reconciles any correlated first-mate units as terminal in the local ledger. Inputs identify the owner/name repo and PR, with allow_unowned as an explicit override for PRs outside first-mate ownership. Returns the closed state plus reconciliation counts, or an already-closed note when the PR was previously closed. Use when the operator wants to stop an open PR rather than merge it. It is not for merged PRs, or for PRs that are not agent-authored or correlated to a first-mate unit (unit.pr === pr), unless allow_unowned is intentionally set.", objectSchema({
 			repo: stringProp("Repository as an owner/name string."),
 			pr: numberProp("Pull request number."),
-			allow_unowned: boolProp("Set true to close a PR that is neither agent-authored nor part of an active first-mate mission. Explicit opt-in; audit-logged.")
+			allow_unowned: boolProp("Set true to close a PR that is neither agent-authored nor correlated to a first-mate unit (unit.pr === pr). Explicit opt-in; audit-logged.")
 		}, ["repo", "pr"]), async (args) => {
 			const repoSlug = requiredString(args, "repo");
 			const repo = parseRepoSlug(repoSlug);
@@ -10655,10 +10697,10 @@ function createFirstMateTools(depsOverride = {}) {
 				reconciled
 			});
 		}),
-		tool$1("mark_ready", "Mark a draft GitHub pull request ready for review. Ownership-scoped identically to merge_pr/close_pr (agent-authored or active first-mate mission repo, else requires allow_unowned).", objectSchema({
+		tool$1("mark_ready", "Marks an open draft GitHub pull request ready for review through GitHub's ready-for-review mutation. Inputs identify the owner/name repo and PR, with allow_unowned as an explicit override for PRs outside first-mate ownership. Returns whether the PR is ready and whether it was already non-draft. Use when a first-mate or operator-owned draft PR should enter human or CI review. It is not for closed or merged PRs, or for PRs that are not agent-authored or correlated to a first-mate unit (unit.pr === pr), unless allow_unowned is intentionally set.", objectSchema({
 			repo: stringProp("Repository as an owner/name string."),
 			pr: numberProp("Pull request number."),
-			allow_unowned: boolProp("Set true to mark a PR ready when it is neither agent-authored nor part of an active first-mate mission. Explicit opt-in; audit-logged.")
+			allow_unowned: boolProp("Set true to mark a PR ready when it is neither agent-authored nor correlated to a first-mate unit (unit.pr === pr). Explicit opt-in; audit-logged.")
 		}, ["repo", "pr"]), async (args) => {
 			const repoSlug = requiredString(args, "repo");
 			const repo = parseRepoSlug(repoSlug);
@@ -10681,7 +10723,7 @@ function createFirstMateTools(depsOverride = {}) {
 				alreadyReady: false
 			});
 		}),
-		tool$1("add_units", "Add dispatchable units to an existing active first-mate mission. DependsOn entries are 0-based indices within the submitted units list.", objectSchema({
+		tool$1("add_units", "Adds dispatchable units to an existing active first-mate mission without dispatching them immediately. Inputs name the mission and unit list; each unit supplies a title plus optional repo, provider, same-call dependency indices, and model override. Returns the mission id and the units actually added after validation and deduplication. Use when the operator has decomposed additional work for a mission that is already active. It is not for creating a new mission, adding work to inactive missions, or expressing dependencies on units from earlier calls; dependsOn indices are 0-based within this submitted list, invalid or self indices are ignored, and cycles are rejected.", objectSchema({
 			mission_id: stringProp("Mission id to add units to."),
 			units: arrayOfObjectsProp("Units to add to the mission.", {
 				title: stringProp("Unit title."),
@@ -10711,7 +10753,7 @@ function createFirstMateTools(depsOverride = {}) {
 				added: await addUnitsToMission(mission, units, deps, existingUnits)
 			});
 		}),
-		tool$1("abandon_mission", "Mark a first-mate mission abandoned so it drops from the active board. Existing units are marked terminal without merging.", objectSchema({
+		tool$1("abandon_mission", "Marks a first-mate mission abandoned in the local durable ledgers so it drops from the active board, and terminalizes live units without merging. Inputs name the mission and can include a short operator reason returned in the tool result. Returns the abandoned mission id and the number of units marked terminal. Use when the operator is permanently retiring a mission from first-mate tracking. It is local-ledger-only and terminal, not a remote cancellation tool: open PRs stay open and GitHub cloud agents keep running unless the operator closes or stops that work separately.", objectSchema({
 			mission_id: stringProp("Mission id to abandon."),
 			reason: stringProp("Optional short reason for the abandonment.")
 		}, ["mission_id"]), async (args) => {
@@ -10742,7 +10784,7 @@ function createFirstMateTools(depsOverride = {}) {
 				...reason !== void 0 ? { reason } : {}
 			});
 		}),
-		tool$1("mission_status", "Read compact status for all first-mate missions, or for one mission id. Defaults to active missions only; pass include_all for inactive missions too.", objectSchema({
+		tool$1("mission_status", "Reads compact first-mate mission status without waking the controller or dispatching work. Inputs can filter by mission_id and can include inactive missions; active missions are returned by default with inactive counts summarized separately. Returns mission status rows built from the same board data, including counts, blocked count, unit rows, and done/failed summary. Use when the operator needs a mission-id-scoped read or a compact status list. It is not for the whole portfolio board without a mission filter, which is board, and it is not for driving progress, which is advance.", objectSchema({
 			mission_id: stringProp("Optional mission id to filter to."),
 			include_all: boolProp("When true, include inactive missions in the status list. Default returns active missions only and summarizes inactive counts.")
 		}, []), async (args) => {
@@ -18487,7 +18529,7 @@ function toolEnvelope(data, isError) {
 * and (3) opens a WS to the bridge, sends the tool call, awaits the
 * response with a per-tool timeout.
 *
-* Each entry carries `capability: "browser"` so `browserToolsEnabled()`
+* Each entry carries a browser capability tag so `browserToolsEnabled()`
 * in `src/routes/mcp/handler.ts` drops them at both list-time and
 * call-time when the operator hasn't opted in via `--browse` or
 * `GH_ROUTER_ENABLE_BROWSE=1`.
@@ -18505,7 +18547,7 @@ function toolEnvelope(data, isError) {
 const BROWSER_TOOLS = Object.freeze([
 	{
 		toolNameHttp: "browser_list_tabs",
-		description: "List all open tabs across all browser windows. Returns each tab's id (used by other browser_* tools), URL, title, active flag, and window id.",
+		description: "Lists open tabs across all browser windows. It takes no input and returns each tab's id, URL, title, active flag, and window id. The returned tab ids are the inputs used by tab-scoped browser tools, especially for pre-existing tabs that were not opened by browser_open_tab. It is a power-tier discovery tool for tab selection and inventory, not a page-content reader or navigation tool.",
 		inputSchema: {
 			type: "object",
 			additionalProperties: false,
@@ -18518,7 +18560,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_open_tab",
-		description: "Open a URL in a new browser tab and wait for the page to finish loading. Returns the new tab's id, final URL after redirects, and HTTP status. Refuses to navigate to browser-internal settings / preferences / extensions / flags pages (returns {blocked: true, reason}); devtools://* is allowed.",
+		description: "Opens a URL in a new browser tab, or navigates the currently active tab when reuseActive is true, then waits briefly for the tab load state to reach complete. It takes a URL and optional reuseActive flag, and returns the tab id, final URL, and a synthetic statusCode load flag where 200 means the tab reported complete and 0 means it did not. The statusCode is not the page's HTTP response code, so a loaded 404 page can still return 200. Use this to establish a tab before other browser tools; blocked URLs return {blocked, reason}, including browser settings/preferences/extensions/flags pages, file:// by default, and extension options/popup pages, while devtools:// is allowed.",
 		inputSchema: {
 			type: "object",
 			required: ["url"],
@@ -18526,11 +18568,11 @@ const BROWSER_TOOLS = Object.freeze([
 			properties: {
 				url: {
 					type: "string",
-					description: "The URL to load. Maximum 8 KB. Settings / preferences / extensions / flags pages are blocked."
+					description: "URL to load. Browser-internal settings, preferences, extensions, flags, password/management pages, extension options/popup pages, and file:// URLs by default are blocked before dispatch."
 				},
 				reuseActive: {
 					type: "boolean",
-					description: "When true, navigate the currently active tab instead of opening a new one. Default false."
+					description: "When true, navigates the currently active tab instead of opening a new tab. Default false. Use browser_navigate when you already know the target tab id."
 				}
 			}
 		},
@@ -18541,7 +18583,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_close_tab",
-		description: "Close one or more tabs by tab id.",
+		description: "Closes one or more browser tabs by id. It takes a non-empty tabIds array, usually obtained from browser_list_tabs, and returns {closed: N} after requesting Chrome to remove those tabs. This is a power-tier tab lifecycle tool for cleanup or closing known throwaway tabs. Avoid using it when the user may still need a tab, and prefer leaving the tab open if the id was not freshly discovered or created for the current task.",
 		inputSchema: {
 			type: "object",
 			required: ["tabIds"],
@@ -18549,7 +18591,7 @@ const BROWSER_TOOLS = Object.freeze([
 			properties: { tabIds: {
 				type: "array",
 				items: { type: "number" },
-				description: "Array of tab ids to close (from browser_list_tabs)."
+				description: "Non-empty array of tab ids to close, usually from browser_list_tabs or browser_open_tab."
 			} }
 		},
 		capability: "browser_power",
@@ -18559,7 +18601,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_navigate",
-		description: "Navigate an existing tab: goto a URL, go back, go forward, or reload. Same URL-blocking policy as browser_open_tab.",
+		description: "Navigates an existing tab by going to a URL, moving back or forward in history, or reloading. It takes a tab id plus an action, with url required only for action='goto', and returns {finalUrl, statusCode} for completed navigation or {blocked, reason} for a policy-blocked URL. The statusCode is a synthetic load-complete flag, not the page's HTTP response code. Use this when the target tab already exists; use browser_open_tab to create a new tab, and expect the same URL policy blocks as open_tab, including browser-internal pages, file:// by default, and extension options/popup pages.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "action"],
@@ -18567,7 +18609,7 @@ const BROWSER_TOOLS = Object.freeze([
 			properties: {
 				tabId: {
 					type: "number",
-					description: "Tab id from browser_list_tabs / browser_open_tab."
+					description: "Tab id from browser_list_tabs or browser_open_tab."
 				},
 				action: {
 					type: "string",
@@ -18577,15 +18619,15 @@ const BROWSER_TOOLS = Object.freeze([
 						"forward",
 						"reload"
 					],
-					description: "The navigation action."
+					description: "Navigation action: goto a URL, go back, go forward, or reload the current page."
 				},
 				url: {
 					type: "string",
-					description: "Required when action=goto. Max 8 KB."
+					description: "URL to load when action='goto'. Ignored for back, forward, and reload."
 				},
 				hard: {
 					type: "boolean",
-					description: "Reload only: bypass cache (Ctrl+Shift+R behavior). Default false."
+					description: "Reload only: when true, bypasses cache like Ctrl+Shift+R. Default false."
 				}
 			}
 		},
@@ -18596,7 +18638,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_screenshot",
-		description: "Capture a PNG screenshot of the visible area of a tab. Returns base64-encoded image bytes plus contentType. The tab must be active in its window; this tool auto-activates if needed.",
+		description: "Captures a screenshot of the visible area of a tab, as PNG by default or JPEG when requested. It takes a tab id and optional format, then returns base64-encoded image bytes plus contentType. The tab must be active in its window, so this tool auto-activates the tab if needed and that changes which tab is focused. Use screenshot for visual layout, canvas, SVG, maps, or image-only regions; prefer browser_observe when page text and actionable state are enough.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId"],
@@ -18604,12 +18646,12 @@ const BROWSER_TOOLS = Object.freeze([
 			properties: {
 				tabId: {
 					type: "number",
-					description: "Tab id from browser_list_tabs / browser_open_tab."
+					description: "Tab id from browser_list_tabs or browser_open_tab."
 				},
 				format: {
 					type: "string",
 					enum: ["png", "jpeg"],
-					description: "Image format. Default 'png'."
+					description: "Image format for the returned screenshot. Default 'png'; use 'jpeg' when smaller image bytes are preferable."
 				}
 			}
 		},
@@ -18620,7 +18662,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_read_page",
-		description: "Compressed page snapshot for the model: visible text, interactive elements with stable refs, viewport metadata, and (when present) `visualSurfaces` listing canvas / svg regions that need vision. Each element entry carries `bbox: [x, y, w, h]` in CSS viewport pixels (same coord space as browser_mouse / drag / scroll-at-pointer). Refs (e.g. `e42`) are stable for the lifetime of one read_page snapshot and are the preferred input to follow-up actions over brittle CSS selectors. The `viewport` block (`width`, `height`, `devicePixelRatio`, `scrollX`, `scrollY`) lets you map CSS-px bbox to device-px pixels for browser_screenshot. Mode controls what ships back: `summary` (default, ~5-15 KB) returns only viewport-visible elements/text and drops nameless non-interactive nodes; `full` returns up to 200 elements + 256 KiB of innerText (the legacy behavior — use only when you need off-screen content unscrolled). PREFER browser_act / browser_find for intent-driven interaction; read_page is the lower-level snapshot when you need to enumerate.",
+		description: "Returns a compressed page snapshot for a tab: visible text, interactive elements with refs, viewport metadata, and visualSurfaces for canvas or SVG regions that need vision. It takes a tab id and optional mode, and each element includes a ref plus bbox in CSS viewport pixels, the same coordinate space used by browser_mouse, browser_drag, and scroll at-pointer. Refs persist across snapshots of the same document until navigation or DOM replacement, and are a better input to follow-up actions than brittle CSS selectors. Use read_page when enumeration, coordinates, refs, or raw snapshot structure are needed; prefer browser_act or browser_find for intent-driven interaction, browser_observe for a short natural-language page summary, and browser_screenshot for visual pixels.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId"],
@@ -18628,12 +18670,12 @@ const BROWSER_TOOLS = Object.freeze([
 			properties: {
 				tabId: {
 					type: "number",
-					description: "Tab id from browser_list_tabs / browser_open_tab."
+					description: "Tab id from browser_list_tabs or browser_open_tab."
 				},
 				mode: {
 					type: "string",
 					enum: ["summary", "full"],
-					description: "Snapshot scope. Default 'summary' returns viewport-visible elements + text capped at 20 KiB. 'full' returns up to 200 interactive elements page-wide + 256 KiB of innerText."
+					description: "Snapshot scope. Default 'summary' focuses on viewport-visible text and elements; 'full' asks for a broader page-wide snapshot. The default CDP extractor caps around 500 elements and 32 KiB text, with legacy fallback caps possibly lower or higher by mode."
 				}
 			}
 		},
@@ -18644,13 +18686,16 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_scroll",
-		description: "Scroll a tab. Five modes: top / bottom of the page, by an absolute pixel delta, to a specific element (by ref), or wheel-scroll a sub-region at a pointer location ('at-pointer' — the path that works for chat windows / infinite-scroll lists / modal bodies that don't respond to window.scrollTo because they have their own scroll container).",
+		description: "Scrolls a tab or a scrollable region inside a tab. It takes a tab id, target mode, and mode-specific fields for page top/bottom, pixel deltas, element centering, or wheel scrolling at a pointer. The at-pointer path dispatches a real wheel event at a ref, selector, or CSS viewport coordinate, which is the path for chat panes, infinite lists, and modal bodies with their own scroll containers. Use browser_act with action='scroll_into_view' or intent mode for simple element reveal; use browser_scroll when page-level movement, precise deltas, or sub-container wheel scrolling are needed.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "target"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				target: {
 					type: "string",
 					enum: [
@@ -18660,39 +18705,39 @@ const BROWSER_TOOLS = Object.freeze([
 						"element",
 						"at-pointer"
 					],
-					description: "Scroll target type."
+					description: "Scroll target mode: page top, page bottom, pixel delta, element centering, or wheel event at a pointer."
 				},
 				pixels: {
 					type: "number",
-					description: "Pixel delta when target=pixels. Positive scrolls down, negative scrolls up."
+					description: "Pixel delta when target='pixels'. Positive scrolls down and negative scrolls up."
 				},
 				ref: {
 					type: "string",
-					description: "Element ref. For target=element, scrolls so the element is centered. For target=at-pointer, resolves to the bbox center as the wheel position."
+					description: "Element ref. For target='element', the element is centered; for target='at-pointer', the element bbox center becomes the wheel position."
 				},
 				selector: {
 					type: "string",
-					description: "CSS selector. For target=at-pointer, fallback when no ref. Resolves to bbox center."
+					description: "CSS selector fallback when no ref is available. For target='at-pointer', resolves to the element bbox center."
 				},
 				x: {
 					type: "number",
-					description: "Pointer x (CSS viewport px) for target=at-pointer. Pair with y. Exactly one of (ref, selector, or x+y) is required for at-pointer."
+					description: "Pointer x in CSS viewport pixels for target='at-pointer'. Pair with y. Exactly one of ref, selector, or x+y is required for at-pointer."
 				},
 				y: {
 					type: "number",
-					description: "Pointer y (CSS viewport px) for target=at-pointer. Pair with x."
+					description: "Pointer y in CSS viewport pixels for target='at-pointer'. Pair with x."
 				},
 				deltaX: {
 					type: "number",
-					description: "Wheel delta x (CSS px) for target=at-pointer. Default 0. Clamped to |10000|."
+					description: "Wheel delta x in CSS pixels for target='at-pointer'. Default 0. Clamped to absolute value 10000."
 				},
 				deltaY: {
 					type: "number",
-					description: "Wheel delta y (CSS px) for target=at-pointer. Positive scrolls down. Default 0. Clamped to |10000|. At least one of deltaX/deltaY must be non-zero."
+					description: "Wheel delta y in CSS pixels for target='at-pointer'. Positive scrolls down. Default 0. Clamped to absolute value 10000; at least one of deltaX or deltaY must be non-zero."
 				},
 				force: {
 					type: "boolean",
-					description: "Skip the pre-wheel elementFromPoint hit-test for target=at-pointer. Default false. Set true when an overlay covers the target but forwards wheel events."
+					description: "For target='at-pointer', skips the pre-wheel elementFromPoint hit-test. Default false. Set true only when an overlay covers the target but forwards wheel events."
 				}
 			}
 		},
@@ -18703,16 +18748,19 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_keyboard",
-		description: "Send a keystroke or chord to the focused element. Use 'Control+L' / 'Command+L' for browser shortcuts, single characters for typing. Uses chrome.debugger so browser-level shortcuts (Ctrl+T, Ctrl+W, etc) actually fire.",
+		description: "Sends a discrete key or chord to the focused element or browser via CDP Input.dispatchKeyEvent. It takes a tab id and a keys string such as 'Control+L', 'Command+L', 'Enter', 'Escape', or 'ArrowDown', and returns the extension dispatch result. Browser-level shortcuts such as Ctrl+T and Ctrl+W actually fire because this uses chrome.debugger input rather than synthetic DOM events. Use keyboard for shortcuts and non-printable control keys; prefer browser_type for literal text entry into a focused field and browser_act with action='fill' for plain form values.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "keys"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				keys: {
 					type: "string",
-					description: "Key or chord. Modifiers (Control, Alt, Shift, Meta / Command) joined with '+'. Example: 'Control+L'."
+					description: "Key or chord. Join modifiers with '+', using Control, Ctrl, Alt, Shift, Meta, Command, or Cmd. A single named key such as Enter or Escape is also valid."
 				}
 			}
 		},
@@ -18723,13 +18771,16 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_wait",
-		description: "Wait for an element to appear (until='selector'), the tab URL to match a regex (until='url'), or the network to go idle (until='networkIdle' - heuristic: tab status complete + 500ms quiet). Returns {ok: true, elapsedMs} on success, {ok: false, reason: 'timeout'} on miss.",
+		description: "Waits for a tab condition without mutating the page. It takes a tab id, an until mode, and the matching operand: a CSS selector for element appearance, a JavaScript regex string for URL matching, or networkIdle for the heuristic of tab status complete plus 500 ms quiet. It returns {ok: true, elapsedMs} on success and {ok: false, reason: 'timeout'} when the condition is not reached before the timeout. Use wait after navigation or actions that trigger asynchronous rendering; do not use it as a page reader, and prefer browser_observe or browser_read_page when the task is to inspect current content.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "until"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				until: {
 					type: "string",
 					enum: [
@@ -18737,19 +18788,19 @@ const BROWSER_TOOLS = Object.freeze([
 						"url",
 						"networkIdle"
 					],
-					description: "What to wait for."
+					description: "Condition to wait for: selector, URL regex match, or network-idle heuristic."
 				},
 				selector: {
 					type: "string",
-					description: "CSS selector when until=selector."
+					description: "CSS selector required when until='selector'."
 				},
 				urlPattern: {
 					type: "string",
-					description: "JS regex (string form) when until=url."
+					description: "JavaScript regex source string required when until='url'."
 				},
 				timeoutMs: {
 					type: "number",
-					description: "Max wait. Default 10000, hard cap 60000."
+					description: "Maximum wait in milliseconds. Default 10000, hard cap 60000."
 				}
 			}
 		},
@@ -18760,20 +18811,23 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_eval_js",
-		description: "Evaluate a JavaScript expression in the tab's main world (equivalent to typing in the DevTools console). Returns {result} or {error}. Awaits promises returned by the expression. Single narrowly-named escape hatch for behaviors the other tools don't cover.",
+		description: "Evaluates a JavaScript expression in the tab's main world, equivalent to typing in the DevTools console. It takes a tab id, expression, and optional timeout, awaits promises returned by the expression, and returns {result} or {error}. The expression can read or mutate the page, storage, cookies, or location, so this is the power-tier escape hatch for behaviors the structured browser tools do not cover. Prefer dedicated tools for navigation, clicking, filling, extraction, diagnostics, and screenshots; note that URL policy checks only apply directly to browser_open_tab and browser_navigate, while extension-side navigation blocking still applies to many browser-internal pages.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "expression"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				expression: {
 					type: "string",
-					description: "JS expression. Max 100 KB. Top-level await NOT supported - wrap in (async () => ...)()."
+					description: "JavaScript expression to evaluate. Size should stay small for reliability, but no schema length cap is enforced. Top-level await is not supported; wrap async work in (async () => ...)()."
 				},
 				timeoutMs: {
 					type: "number",
-					description: "Max evaluation time. Default 5000, hard cap 30000."
+					description: "Maximum evaluation time in milliseconds. Default 5000, hard cap 30000."
 				}
 			}
 		},
@@ -18784,7 +18838,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_download",
-		description: "Trigger a download by URL and wait for it to complete. Returns {downloadId, path, bytes, mimeType}. The file lands in Chrome's default Downloads dir unless saveAs is given.",
+		description: "Triggers a browser download from a direct URL and waits for the extension's completion signal. It takes a tab id for association, source='url', the URL, and optional saveAs path, then returns {downloadId, path, bytes, mimeType} when Chrome reports the download complete. The file lands in Chrome's default Downloads directory unless saveAs provides a relative filename or subdirectory, and conflicts are auto-uniquified by the browser. Use this for known direct download URLs; it does not click page links, and the extension currently waits up to 60 seconds internally, so downloads that finish after 60 seconds can report timeout even though the outer wire budget is larger.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "url"],
@@ -18792,20 +18846,20 @@ const BROWSER_TOOLS = Object.freeze([
 			properties: {
 				tabId: {
 					type: "number",
-					description: "Tab id is logged but the download itself is window-scoped, not tab-scoped."
+					description: "Tab id for association and logging; the download itself is window-scoped, not tab-scoped."
 				},
 				source: {
 					type: "string",
 					enum: ["url"],
-					description: "Download source. Only 'url' supported in v1; click-then-wait awaits Phase 5."
+					description: "Download source. Only 'url' is supported in v1; click-then-wait is not on this surface."
 				},
 				url: {
 					type: "string",
-					description: "Direct URL to download. Max 8 KB."
+					description: "Direct URL to download. No schema length cap is enforced."
 				},
 				saveAs: {
 					type: "string",
-					description: "Optional filename / relative subdir under Downloads. Conflicts auto-uniquify."
+					description: "Optional relative filename or subdirectory under Downloads. Chrome enforces download-path restrictions and auto-uniquifies conflicts."
 				}
 			}
 		},
@@ -18816,13 +18870,16 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_mouse",
-		description: "Move / click / hover / press / release the mouse via real CDP input events (Input.dispatchMouseEvent). Use this when you need behavior that synthetic .click() can't trigger: hover-to-reveal menus, canvas / map / image-map clicks, sites that check event.isTrusted, or precise coordinate targeting. Target with ref (from browser_read_page), CSS selector, or (x, y) in CSS viewport pixels — exactly one. action='move' is the hover (single mouseMoved fires :hover and pointerover reliably). action='dblclick' sends two press/release cycles with incrementing clickCount (a real double-click, not one cycle with clickCount=2). By default the target is hit-tested with elementFromPoint and the call fails with `target_obscured` if the topmost element isn't the target or a descendant — pass force:true to bypass when you know an overlay forwards events.",
+		description: "Moves, clicks, double-clicks, presses, or releases the mouse through real CDP Input.dispatchMouseEvent calls. It takes a tab id, action, exactly one target form (ref, selector, or x+y CSS viewport coordinates), and optional button, trajectory, and force settings. Use mouse for hover-to-reveal menus, canvas/map/image-map clicks, event.isTrusted checks, precise coordinate targeting, or low-level press/release sequences that browser_act cannot express. Prefer browser_act for ordinary element clicks and fills; by default ref/selector targets are hit-tested with elementFromPoint and fail with target_obscured unless force is true.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "action"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				action: {
 					type: "string",
 					enum: [
@@ -18832,19 +18889,19 @@ const BROWSER_TOOLS = Object.freeze([
 						"down",
 						"up"
 					],
-					description: "What to do. move=position cursor (hover). click=press+release. dblclick=two press+release with clickCount 1 then 2. down=press only. up=release only."
+					description: "Mouse action. move positions the cursor for hover; click sends press+release; dblclick sends two press/release cycles; down presses only; up releases only."
 				},
 				ref: {
 					type: "string",
-					description: "Element ref from browser_read_page (preferred). Resolves to bbox center. Exactly one of ref / selector / (x+y) required."
+					description: "Element ref from browser_read_page or browser_find. Resolves to bbox center. Exactly one of ref, selector, or x+y is required."
 				},
 				selector: {
 					type: "string",
-					description: "CSS selector (fallback). Resolves to bbox center."
+					description: "CSS selector fallback. Resolves to bbox center. Exactly one of ref, selector, or x+y is required."
 				},
 				x: {
 					type: "number",
-					description: "Target x in CSS viewport pixels. Pair with y. Use when working from a screenshot or eval_js output."
+					description: "Target x in CSS viewport pixels. Pair with y. Use when working from a screenshot, canvas coordinate, or eval_js output."
 				},
 				y: {
 					type: "number",
@@ -18857,19 +18914,19 @@ const BROWSER_TOOLS = Object.freeze([
 						"right",
 						"middle"
 					],
-					description: "Mouse button for click / dblclick / down / up. Default 'left'. Ignored for action=move."
+					description: "Mouse button for click, dblclick, down, or up. Default 'left'. Ignored for action='move'."
 				},
 				steps: {
 					type: "number",
-					description: "Humanlike trajectory. >1 interpolates the cursor approach over N mouseMoved events. Default 1 (teleport). Clamped to [1, 100]."
+					description: "Trajectory step count. Values greater than 1 interpolate the cursor approach over multiple mouseMoved events. Default 1. Clamped to [1, 100]."
 				},
 				stepDelayMs: {
 					type: "number",
-					description: "Pause between interpolated mouseMoved events when steps > 1. Default 8. Clamped to [0, 50]."
+					description: "Pause between interpolated mouseMoved events when steps is greater than 1. Default 8. Clamped to [0, 50]."
 				},
 				force: {
 					type: "boolean",
-					description: "Skip the pre-click elementFromPoint hit-test (ref/selector mode only). Default false."
+					description: "For ref or selector targets, skips the elementFromPoint hit-test. Default false. Use only when an overlay covers the target but forwards pointer events."
 				}
 			}
 		},
@@ -18880,20 +18937,23 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_drag",
-		description: "Drag from a source to a destination. Auto-detects whether to use HTML5 native DnD (for elements with draggable='true', via CDP Input.setInterceptDrags + Input.dispatchDragEvent — the only path that triggers Chromium's native dragstart pipeline) or pointer-based DnD (for react-dnd / Sortable.js / mouse-event-based drag handlers — via CDP mouse events with buttons:1 held throughout). Each of from/to can be a ref (preferred), a CSS selector, or x+y coordinates. Returns { ok: true, mode_used: 'pointer'|'html5' } so you can verify which path ran.",
+		description: "Drags from a source target to a destination target through CDP input events. It takes a tab id, one source target, one destination target, and optional button, trajectory, mode, and force settings; targets can be refs, selectors, or CSS viewport coordinates. Auto mode chooses HTML5 native drag-and-drop for draggable='true' sources, using Input.setInterceptDrags plus Input.dispatchDragEvent, and otherwise uses pointer drag events for libraries such as react-dnd, Sortable.js, and mouse-event-based handlers. Use drag for actual drag-and-drop interactions; use browser_mouse for simple clicks, hover, or isolated press/release gestures. Returns {ok: true, mode_used, from, to} so the caller can verify whether pointer or html5 ran and which coordinates were used.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				fromRef: {
 					type: "string",
-					description: "Source ref from browser_read_page (preferred)."
+					description: "Source element ref from browser_read_page or browser_find. Preferred when available."
 				},
 				fromSelector: {
 					type: "string",
-					description: "Source CSS selector (fallback)."
+					description: "Source CSS selector fallback when no source ref is available."
 				},
 				fromX: {
 					type: "number",
@@ -18905,11 +18965,11 @@ const BROWSER_TOOLS = Object.freeze([
 				},
 				toRef: {
 					type: "string",
-					description: "Destination ref from browser_read_page (preferred)."
+					description: "Destination element ref from browser_read_page or browser_find. Preferred when available."
 				},
 				toSelector: {
 					type: "string",
-					description: "Destination CSS selector (fallback)."
+					description: "Destination CSS selector fallback when no destination ref is available."
 				},
 				toX: {
 					type: "number",
@@ -18922,15 +18982,15 @@ const BROWSER_TOOLS = Object.freeze([
 				button: {
 					type: "string",
 					enum: ["left", "middle"],
-					description: "Mouse button held during drag. Default 'left'."
+					description: "Mouse button held during the drag. Default 'left'."
 				},
 				steps: {
 					type: "number",
-					description: "Intermediate mouseMoved events from→to with the button held. Drag-detect libraries need a trajectory to fire. Default 15. Clamped to [1, 100]."
+					description: "Intermediate mouseMoved events from source to destination with the button held. Drag-detect libraries often need a trajectory. Default 15. Clamped to [1, 100]."
 				},
 				stepDelayMs: {
 					type: "number",
-					description: "Pause between intermediate moves. Default 12. Clamped to [0, 50]."
+					description: "Pause between intermediate moves in milliseconds. Default 12. Clamped to [0, 50]."
 				},
 				mode: {
 					type: "string",
@@ -18939,11 +18999,11 @@ const BROWSER_TOOLS = Object.freeze([
 						"pointer",
 						"html5"
 					],
-					description: "Drag mode. 'auto' (default) picks html5 if the source has draggable='true', else pointer. Override only when auto detection misses."
+					description: "Drag mode. 'auto' is the default and picks html5 if the source has draggable='true', else pointer. Override only when auto detection chooses the wrong path."
 				},
 				force: {
 					type: "boolean",
-					description: "Skip the pre-press elementFromPoint hit-test on the source. Default false."
+					description: "Skips the pre-press elementFromPoint hit-test on the source only. Default false. The destination is used as-is."
 				}
 			}
 		},
@@ -18954,20 +19014,23 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_type",
-		description: "Type a string into the currently-focused element per-keystroke via CDP Input.dispatchKeyEvent. Each character fires keydown + keypress + input — this is the tool for keystroke-driven autocomplete, chips, search-as-you-type, and any site whose handlers listen on keydown rather than just reading element.value. For plain form-value entry use browser_fill (faster, sets value directly). For chord shortcuts (Control+L, etc) use browser_keyboard. Special characters in text: \\n→Enter, \\t→Tab, \\b→Backspace (dispatched as the named key, not as a literal control char). Other control chars (< 0x20) are rejected with an actionable error. Uppercase letters come from the natural code point — event.shiftKey is false but the typed value is correct.",
+		description: "Types text into the currently focused element one character at a time via CDP Input.dispatchKeyEvent. It takes a tab id, text, and optional per-character delay; each character fires keyboard/input events, which supports autocomplete, chips, search-as-you-type fields, and handlers that listen on keydown rather than only reading element.value. Special text characters map to named keys: \\n sends Enter, \\t sends Tab, and \\b sends Backspace; other control characters below 0x20 are rejected with an actionable error. Use browser_type when real keystrokes matter, use browser_act with action='fill' for plain form-value entry, and use browser_keyboard for shortcuts or named control keys such as Control+L or Escape.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "text"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab. The text goes to whatever element is currently focused in that tab."
+				},
 				text: {
 					type: "string",
-					description: "The text to type. Max 4096 chars. Iterates as Unicode code points (surrogate pairs handled correctly)."
+					description: "Text to type, up to 4096 Unicode code points. Newline, tab, and backspace are dispatched as Enter, Tab, and Backspace."
 				},
 				delayMs: {
 					type: "number",
-					description: "Pause between characters. Default 0. Clamped to [0, 50]. Set > 0 when typing into search-as-you-type inputs that debounce."
+					description: "Pause between characters in milliseconds. Default 0. Clamped to [0, 50]. Set above 0 for debounced search-as-you-type inputs."
 				}
 			}
 		},
@@ -18978,17 +19041,20 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_diagnostics",
-		description: "Drain console messages or network responses for a tab, with filtering. Replaces the prior browser_console_logs / browser_network_log primitives. `kind` selects the stream; remaining params filter the result before it ships to the model so the response carries only what the caller asked for instead of a raw 1000-entry array dump. Lazy-attach behavior: first call for a tab attaches chrome.debugger; very-early-load events from before the first call are missed.",
+		description: "Drains buffered console messages or network responses for a tab, with filtering before the result is returned. It takes a tab id, kind='console' or 'network', and optional level, regex, and limit filters, then returns {kind, total, returned, entries}; total is the pre-filter count and returned is the post-filter limited count. The first call for a tab lazily attaches chrome.debugger, so very-early load events from before that call are missed. Use diagnostics to investigate console errors, warnings, and request URLs; do not use it as a page-content reader, and raise limit or loosen regex when returned equals the requested limit.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "kind"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				kind: {
 					type: "string",
 					enum: ["console", "network"],
-					description: "Which stream to drain."
+					description: "Diagnostic stream to drain: console messages or network responses."
 				},
 				level: {
 					type: "string",
@@ -19000,15 +19066,15 @@ const BROWSER_TOOLS = Object.freeze([
 						"debug",
 						"all"
 					],
-					description: "Console only. Default 'all'. Ignored when kind=network."
+					description: "Console only. Default 'all'. Ignored when kind='network'."
 				},
 				regex: {
 					type: "string",
-					description: "Optional JS-regex string. Console: matches the message body. Network: matches the request URL."
+					description: "Optional JavaScript regex source string. For console, matches message text; for network, matches request URL."
 				},
 				limit: {
 					type: "number",
-					description: "Max entries to return after filtering. Default 100. Hard cap 1000."
+					description: "Maximum entries to return after filtering. Default 100. Hard cap 1000."
 				}
 			}
 		},
@@ -19056,20 +19122,23 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_find",
-		description: "Find up to 5 elements matching a natural-language intent ('the search box at the top', 'the Submit button at the bottom of the login form'). Returns ranked candidates with stable refs the model can pass to browser_act (ref mode) or browser_mouse. Cheaper than browser_read_page when you know what you're looking for — the inner compressor (a small fast model) filters the snapshot for you instead of sending the full element list to the lead model.",
+		description: "Finds up to 5 page elements that match a natural-language intent. It takes a tab id and intent, reads a fresh snapshot internally, and returns ranked candidates with refs, roles, names, bboxes, and match reasons when available. The returned refs can be passed to browser_act in REF mode or to low-level power tools such as browser_mouse. Use find when a specific element is needed and a short candidate list is better than the full browser_read_page snapshot; use read_page when broad enumeration or raw text/context is needed.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId", "intent"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				intent: {
 					type: "string",
-					description: "Natural-language description of what to find."
+					description: "Natural-language description of the element to find, such as 'the search box at the top' or 'the Submit button'."
 				}
 			}
 		},
-		capability: "browser_power",
+		capability: "browser_compound",
 		async handler(args, signal) {
 			const tabId = typeof args.tabId === "number" ? args.tabId : void 0;
 			const intent = typeof args.intent === "string" ? args.intent : "";
@@ -19095,20 +19164,23 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_act",
-		description: "Preferred for any click / fill / type / scroll-to action against a tab. Two modes: (1) INTENT mode — pass `intent` as natural language ('click the submit button'); the inner compressor (a small fast model) maps it to an element + action. Auto-escalates to visual fallback (screenshot + multimodal model + pixel-coord click) when the intent points into a canvas / svg region the a11y tree can't see. (2) REF mode — pass `ref` (from a prior browser_find or browser_read_page) and optionally `value`; dispatches directly with zero compressor latency. This is the fold-in path for the now-removed browser_click and browser_fill. Returns {ok, action_taken, target_ref, navigated}.",
+		description: "Performs a high-level click, fill, type, select, or scroll-into-view action against a tab. It has two modes: INTENT mode takes a natural-language intent and resolves the element/action internally, while REF mode takes a ref from browser_find or browser_read_page plus optional action and value for direct dispatch without a compressor round trip. Visual fallback can click canvas or SVG regions by combining screenshot analysis with a coordinate click when text-based matching fails. Use act for ordinary page interaction before reaching for browser_mouse, browser_type, browser_keyboard, or browser_scroll; single-action results include {ok, action_taken, target_ref, navigated}, multi-step intents return summary/steps fields, and visual fallback returns click_visual with x/y coordinates.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				intent: {
 					type: "string",
-					description: "Natural-language description of the action. Triggers INTENT mode. Mutually exclusive with `ref`."
+					description: "Natural-language description of the action for INTENT mode. If both intent and ref are provided, ref mode wins and intent is ignored."
 				},
 				ref: {
 					type: "string",
-					description: "Element ref from browser_find / browser_read_page. Triggers REF mode (no compressor round-trip)."
+					description: "Element ref from browser_find or browser_read_page for REF mode, which dispatches directly without a compressor round trip."
 				},
 				action: {
 					type: "string",
@@ -19119,15 +19191,15 @@ const BROWSER_TOOLS = Object.freeze([
 						"select",
 						"scroll_into_view"
 					],
-					description: "REF mode only. Defaults to 'click'. In INTENT mode, the compressor picks the action."
+					description: "REF mode action. Defaults to 'click'. Ignored in INTENT mode, where the resolved action comes from the intent and matched element."
 				},
 				value: {
 					type: "string",
-					description: "For fill / type / select: the string value to set. In INTENT mode the compressor uses this when an action requires a value."
+					description: "String value for fill, type, or select actions. In INTENT mode, this is available to the resolver when the action requires a value."
 				}
 			}
 		},
-		capability: "browser",
+		capability: "browser_compound",
 		async handler(args, signal) {
 			const tabId = typeof args.tabId === "number" ? args.tabId : void 0;
 			if (!tabId) return toolEnvelope({ error: "tabId required" }, true);
@@ -19220,16 +19292,19 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_observe",
-		description: "Get a natural-language description of the current page's user-actionable state — what forms, buttons, links, and content sections are visible — in 2-4 sentences. Optional `intent` focuses the description on a region ('describe the login form', 'what's in the comments section'). Use this BEFORE browser_act when you don't know what's on the page, or AFTER navigation to confirm the page loaded. Cheaper than screenshots when text is enough. Does not include canvas/SVG content — those surface as a `hasVisualSurfaces` flag; switch to browser_screenshot for visuals.",
+		description: "Produces a short natural-language description of the current page's user-actionable state, including visible forms, buttons, links, and content sections. It takes a tab id and optional intent focus, then returns a 2-4 sentence summary plus whether visualSurfaces such as canvas or SVG are present. Use observe before browser_act when the page state is unknown, or after navigation to confirm what loaded. Prefer observe over screenshot when text and controls are enough; switch to browser_screenshot for visual layout or canvas/SVG details, and use browser_read_page when raw refs, bboxes, or element lists are needed.",
 		inputSchema: {
 			type: "object",
 			required: ["tabId"],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
 				intent: {
 					type: "string",
-					description: "Optional natural-language focus ('describe the form', 'what's in the sidebar')."
+					description: "Optional natural-language focus for the summary, such as 'describe the form' or 'what is in the sidebar'."
 				}
 			}
 		},
@@ -19243,7 +19318,7 @@ const BROWSER_TOOLS = Object.freeze([
 	},
 	{
 		toolNameHttp: "browser_extract",
-		description: "Structured extraction from the current page into a JSON object matching the provided schema. The inner compressor reads the page snapshot (text + elements) and synthesizes the typed object. Use this instead of browser_read_page + lead-model parsing when you know the shape you want (e.g. a list of {title, author, url} rows from a PR list).",
+		description: "Extracts structured data from the current page into a JSON object matching the provided schema. It takes a tab id, a schema or schema-shaped descriptor, and a plain-language instruction; the inner compressor reads the page snapshot and returns only the typed object rather than the raw element list. Use extract when the desired output shape is known, such as rows of {title, author, url}; use browser_observe for a prose overview and browser_read_page when the lead model needs raw refs, bboxes, or page text. Bad schemas or wrong-shape compressor results are returned as fixable error envelopes so the caller can simplify the schema or clarify the instruction.",
 		inputSchema: {
 			type: "object",
 			required: [
@@ -19253,11 +19328,14 @@ const BROWSER_TOOLS = Object.freeze([
 			],
 			additionalProperties: false,
 			properties: {
-				tabId: { type: "number" },
-				schema: { description: "JSON schema (or schema-shaped descriptor) for the desired output shape." },
+				tabId: {
+					type: "number",
+					description: "Tab id from browser_list_tabs or browser_open_tab."
+				},
+				schema: { description: "JSON schema, or a schema-shaped descriptor, for the desired output shape." },
 				instruction: {
 					type: "string",
-					description: "What to extract, in plain language ('the visible PR list')."
+					description: "Plain-language extraction instruction, such as 'the visible PR list' or 'all product cards with price and URL'."
 				}
 			}
 		},
@@ -23432,12 +23510,17 @@ async function countTokens(body, extraHeaders, callerSignal, retryTransient = fa
 * slug too — `state.models?.data` mirrors Copilot's catalog where these
 * land under the dotted slug, so we match by Copilot's actual id shape.
 */
+function geminiAvailable(source = state) {
+	const models = source.models?.data;
+	if (!models) return false;
+	return models.some((m) => /^gemini-3\..*pro/i.test(m.id));
+}
 function standInToolEnabled() {
 	const models = state.models?.data;
 	if (!models) return false;
 	const hasGpt55 = models.some((m) => m.id === "gpt-5.5");
 	const hasOpus = models.some((m) => m.id === "claude-opus-4-7" || m.id === "claude-opus-4.7");
-	const hasGeminiPro = models.some((m) => /^gemini-3\..*pro/i.test(m.id));
+	const hasGeminiPro = geminiAvailable();
 	return hasGpt55 && hasOpus && hasGeminiPro;
 }
 const IMPLEMENTER_SUBAGENT_MODEL = "gpt-5.5";
@@ -23483,8 +23566,8 @@ function workerToolsEnabled() {
 	return found.capabilities?.supports?.tool_calls === true;
 }
 /**
-* Gate for the compound L2 browser tools (`browser_find`, `browser_act`
-* in intent mode, `browser_extract`).
+* Gate for the compound L2 browser tools (`browser_act`, `browser_observe`,
+* `browser_extract`, `browser_find`).
 *
 * Returns true iff `compressorAvailable()` — i.e. at least one model in
 * the compressor fallback chain (`gpt-5.4-mini` → `claude-sonnet-4.6` →
@@ -23507,19 +23590,19 @@ function browserCompoundToolsEnabled() {
 * Gate for the L0/L1 power browser tools (`browser_read_page`,
 * `browser_mouse`, `browser_drag`, `browser_type`, `browser_keyboard`,
 * `browser_scroll`, `browser_eval_js`, `browser_diagnostics`,
-* `browser_find`, `browser_close_tab`, `browser_list_tabs`,
-* `browser_wait`, `browser_download`).
+* `browser_close_tab`, `browser_list_tabs`, `browser_wait`,
+* `browser_download`).
 *
 * Returns true iff `state.powerBrowseEnabled` (set by `--power-browse`
 * or `GH_ROUTER_ENABLE_POWER_BROWSE=1`). When off, the default
-* `--browse` surface exposes only the 6 lead-model tools (`act`,
-* `observe`, `extract`, `navigate`, `screenshot`, `open_tab`) that
-* hide DOM details behind intent. Power mode adds the raw primitives
-* for users who want direct coord/keystroke control.
+* `--browse` surface exposes the base lead tools (`navigate`, `screenshot`,
+* `open_tab`) and, when the compound gate passes, `act`, `observe`,
+* `extract`, and `find`. Power mode adds the raw primitives for users who
+* want direct coord/keystroke control.
 *
 * `handler.ts` filter chain ANDs this with `browserToolsEnabled()`
-* (defense-in-depth — power without basic is meaningless and the
-* setup path already forces basic on when power is on).
+* (defense-in-depth: power without the base browser server is meaningless and
+* the setup path already forces basic on when power is on).
 */
 function browserPowerToolsEnabled() {
 	return state.powerBrowseEnabled === true;
@@ -23715,11 +23798,6 @@ function checkAuth(c) {
 	};
 	return { ok: true };
 }
-function geminiAvailable() {
-	const models = state.models?.data;
-	if (!models) return false;
-	return models.some((m) => /^gemini-3\..*pro/i.test(m.id));
-}
 /**
 * The 1M-context Opus 4.6 variant (`claude-opus-4.6-1m`, `max_prompt_tokens`
 * 936K). opus_critic prefers it so it can take large artifacts in one shot
@@ -28220,6 +28298,142 @@ function round2(n) {
 *  into each sub-orchestration. The verifier only range-checks the declaration. */
 const MAX_RECURSION_DEPTH = 3;
 
+//#endregion
+//#region src/lib/orchestration/select.ts
+const subsetOf = (a, b) => {
+	for (const x of a) if (!b.has(x)) return false;
+	return true;
+};
+function selectChampion(orchestrated, baseline, canonicalGateIds, tiePolicy) {
+	if (!subsetOf(orchestrated.passed, orchestrated.ran)) return {
+		winner: "baseline",
+		reason: "orchestrated outcome malformed (passed not a subset of ran)"
+	};
+	if (!subsetOf(baseline.passed, baseline.ran)) return {
+		winner: "baseline",
+		reason: "baseline outcome malformed (passed not a subset of ran)"
+	};
+	if (canonicalGateIds.size === 0) return {
+		winner: "baseline",
+		reason: "no executable gate for this ask — ship the baseline (judgment-only)"
+	};
+	for (const id of canonicalGateIds) if (!orchestrated.ran.has(id)) return {
+		winner: "baseline",
+		reason: `orchestrated did not run canonical gate "${id}"`
+	};
+	let baselinePass = 0;
+	let orchestratedPass = 0;
+	for (const id of canonicalGateIds) {
+		if (baseline.passed.has(id)) baselinePass += 1;
+		if (orchestrated.passed.has(id)) orchestratedPass += 1;
+		else if (baseline.passed.has(id)) return {
+			winner: "baseline",
+			reason: `orchestrated regresses on canonical check "${id}" the baseline passed`
+		};
+	}
+	if (orchestratedPass > baselinePass) return {
+		winner: "orchestrated",
+		reason: "orchestrated passes strictly more canonical executable checks"
+	};
+	if (tiePolicy === "superset") return {
+		winner: "orchestrated",
+		reason: "orchestrated matches the baseline on the canonical checks (superset policy)"
+	};
+	return {
+		winner: "baseline",
+		reason: "orchestrated does not pass strictly more canonical checks than the baseline (strict policy)"
+	};
+}
+
+//#endregion
+//#region src/lib/orchestration/gate-runner.ts
+async function runGateChecks(checks, cwd, exec) {
+	const results = await Promise.all(checks.map(async (c) => {
+		try {
+			const r = await exec({
+				command: c.command,
+				cwd
+			});
+			return {
+				id: c.id,
+				passed: r.exitCode === 0
+			};
+		} catch {
+			return {
+				id: c.id,
+				passed: false
+			};
+		}
+	}));
+	const passed = /* @__PURE__ */ new Set();
+	const ran = /* @__PURE__ */ new Set();
+	for (const r of results) {
+		ran.add(r.id);
+		if (r.passed) passed.add(r.id);
+	}
+	return {
+		passed,
+		ran
+	};
+}
+
+//#endregion
+//#region src/lib/orchestration/gate-registry.ts
+/**
+* Built-in sealed gates. Commands follow this repo's TS/Bun conventions (the
+* `bun run <script>` indirection means a repo without that script simply fails
+* the check, which the selector treats as not-passed rather than a crash). New
+* ecosystems get a new sealed id here, never a caller-supplied command.
+*/
+const SEALED_GATES = {
+	"default-ci": [
+		{
+			id: "typecheck",
+			command: "bun run typecheck"
+		},
+		{
+			id: "test",
+			command: "bun test"
+		},
+		{
+			id: "lint",
+			command: "bun run lint"
+		}
+	],
+	"typecheck-test": [{
+		id: "typecheck",
+		command: "bun run typecheck"
+	}, {
+		id: "test",
+		command: "bun test"
+	}],
+	"typecheck-only": [{
+		id: "typecheck",
+		command: "bun run typecheck"
+	}]
+};
+/** The set of sealed gate ids, used as the kernel's `knownGateIds` so the IR
+*  verifier rejects an executable gate that references an unregistered id. */
+function sealedGateIds() {
+	return new Set(Object.keys(SEALED_GATES));
+}
+/**
+* Resolve a sealed gate by id. Returns a DEFENSIVE CLONE (fresh objects) so a
+* caller can never mutate the registry's command set. `undefined` for an
+* unknown id, which `run_workflow` rejects before executing anything.
+*/
+function resolveSealedGate(gateId) {
+	const checks = SEALED_GATES[gateId];
+	if (!checks) return void 0;
+	return {
+		id: gateId,
+		checks: checks.map((c) => ({
+			id: c.id,
+			command: c.command
+		}))
+	};
+}
+
 //#endregion
 //#region src/lib/orchestration/verify.ts
 const VALID_ROLES = new Set([
@@ -28244,6 +28458,7 @@ const VALID_ON_FAIL = new Set([
 	"escalate"
 ]);
 function verifyWorkflowIR(ir, opts = {}) {
+	const knownGateIds = opts.knownGateIds ?? sealedGateIds();
 	const v = [];
 	const push = (code, message, nodeId) => {
 		v.push(nodeId === void 0 ? {
@@ -28321,7 +28536,7 @@ function verifyWorkflowIR(ir, opts = {}) {
 		const g = n.gate;
 		if (g.kind === "executable") {
 			if (typeof g.gateId !== "string" || g.gateId.length === 0) push("BAD_GATE", `executable gate on node "${n.id}" must reference a sealed gateId (gate-immutability)`, n.id);
-			else if (opts.knownGateIds && !opts.knownGateIds.has(g.gateId)) push("UNKNOWN_GATE_ID", `executable gate on node "${n.id}" references gateId "${g.gateId}" not in the kernel's sealed-gate registry`, n.id);
+			else if (!knownGateIds.has(g.gateId)) push("UNKNOWN_GATE_ID", `executable gate on node "${n.id}" references gateId "${g.gateId}" not in the kernel's sealed-gate registry`, n.id);
 		}
 		if (g.kind === "cross_lab") {
 			if (typeof g.checkerLab !== "string" || g.checkerLab.length === 0) push("BAD_GATE", `cross_lab gate on node "${n.id}" must name a checkerLab`, n.id);
@@ -28428,53 +28643,6 @@ function hasCycle(nodes, byId) {
 	return false;
 }
 
-//#endregion
-//#region src/lib/orchestration/select.ts
-const subsetOf = (a, b) => {
-	for (const x of a) if (!b.has(x)) return false;
-	return true;
-};
-function selectChampion(orchestrated, baseline, canonicalGateIds, tiePolicy) {
-	if (!subsetOf(orchestrated.passed, orchestrated.ran)) return {
-		winner: "baseline",
-		reason: "orchestrated outcome malformed (passed not a subset of ran)"
-	};
-	if (!subsetOf(baseline.passed, baseline.ran)) return {
-		winner: "baseline",
-		reason: "baseline outcome malformed (passed not a subset of ran)"
-	};
-	if (canonicalGateIds.size === 0) return {
-		winner: "baseline",
-		reason: "no executable gate for this ask — ship the baseline (judgment-only)"
-	};
-	for (const id of canonicalGateIds) if (!orchestrated.ran.has(id)) return {
-		winner: "baseline",
-		reason: `orchestrated did not run canonical gate "${id}"`
-	};
-	let baselinePass = 0;
-	let orchestratedPass = 0;
-	for (const id of canonicalGateIds) {
-		if (baseline.passed.has(id)) baselinePass += 1;
-		if (orchestrated.passed.has(id)) orchestratedPass += 1;
-		else if (baseline.passed.has(id)) return {
-			winner: "baseline",
-			reason: `orchestrated regresses on canonical check "${id}" the baseline passed`
-		};
-	}
-	if (orchestratedPass > baselinePass) return {
-		winner: "orchestrated",
-		reason: "orchestrated passes strictly more canonical executable checks"
-	};
-	if (tiePolicy === "superset") return {
-		winner: "orchestrated",
-		reason: "orchestrated matches the baseline on the canonical checks (superset policy)"
-	};
-	return {
-		winner: "baseline",
-		reason: "orchestrated does not pass strictly more canonical checks than the baseline (strict policy)"
-	};
-}
-
 //#endregion
 //#region src/lib/orchestration/kernel.ts
 const DEFAULT_MAX_RETRIES = 2;
@@ -28594,6 +28762,7 @@ const clone = (v) => typeof structuredClone === "function" ? structuredClone(v)
 async function decomposeWorkflow(ask, deps, opts = {}) {
 	const maxRounds = Math.max(1, opts.maxRounds ?? DEFAULT_MAX_ROUNDS);
 	const verifyOpts = opts.verify ?? {};
+	const context = typeof opts.context === "string" && opts.context.trim().length > 0 ? opts.context.trim() : void 0;
 	let feedback;
 	let lastViolations = [{
 		code: "NO_DRAFT",
@@ -28603,6 +28772,7 @@ async function decomposeWorkflow(ask, deps, opts = {}) {
 	for (let round = 1; round <= maxRounds; round += 1) {
 		const drafted = await safeDraft(deps, {
 			ask,
+			context,
 			feedback
 		});
 		attempts += 1;
@@ -28627,6 +28797,7 @@ async function decomposeWorkflow(ask, deps, opts = {}) {
 		if (round < maxRounds) {
 			const next = await safeDraft(deps, {
 				ask,
+				context,
 				feedback: concerns
 			});
 			attempts += 1;
@@ -28852,38 +29023,6 @@ function detectGateWeakening(diff) {
 	};
 }
 
-//#endregion
-//#region src/lib/orchestration/gate-runner.ts
-async function runGateChecks(checks, cwd, exec) {
-	const results = await Promise.all(checks.map(async (c) => {
-		try {
-			const r = await exec({
-				command: c.command,
-				cwd
-			});
-			return {
-				id: c.id,
-				passed: r.exitCode === 0
-			};
-		} catch {
-			return {
-				id: c.id,
-				passed: false
-			};
-		}
-	}));
-	const passed = /* @__PURE__ */ new Set();
-	const ran = /* @__PURE__ */ new Set();
-	for (const r of results) {
-		ran.add(r.id);
-		if (r.passed) passed.add(r.id);
-	}
-	return {
-		passed,
-		ran
-	};
-}
-
 //#endregion
 //#region src/lib/orchestration/stop-gate.ts
 async function evaluateStopGate(input) {
@@ -28929,63 +29068,6 @@ const liveExec = async ({ command, cwd }) => {
 	}
 };
 
-//#endregion
-//#region src/lib/orchestration/gate-registry.ts
-/**
-* Built-in sealed gates. Commands follow this repo's TS/Bun conventions (the
-* `bun run <script>` indirection means a repo without that script simply fails
-* the check, which the selector treats as not-passed rather than a crash). New
-* ecosystems get a new sealed id here, never a caller-supplied command.
-*/
-const SEALED_GATES = {
-	"default-ci": [
-		{
-			id: "typecheck",
-			command: "bun run typecheck"
-		},
-		{
-			id: "test",
-			command: "bun test"
-		},
-		{
-			id: "lint",
-			command: "bun run lint"
-		}
-	],
-	"typecheck-test": [{
-		id: "typecheck",
-		command: "bun run typecheck"
-	}, {
-		id: "test",
-		command: "bun test"
-	}],
-	"typecheck-only": [{
-		id: "typecheck",
-		command: "bun run typecheck"
-	}]
-};
-/** The set of sealed gate ids, used as the kernel's `knownGateIds` so the IR
-*  verifier rejects an executable gate that references an unregistered id. */
-function sealedGateIds() {
-	return new Set(Object.keys(SEALED_GATES));
-}
-/**
-* Resolve a sealed gate by id. Returns a DEFENSIVE CLONE (fresh objects) so a
-* caller can never mutate the registry's command set. `undefined` for an
-* unknown id, which `run_workflow` rejects before executing anything.
-*/
-function resolveSealedGate(gateId) {
-	const checks = SEALED_GATES[gateId];
-	if (!checks) return void 0;
-	return {
-		id: gateId,
-		checks: checks.map((c) => ({
-			id: c.id,
-			command: c.command
-		}))
-	};
-}
-
 //#endregion
 //#region src/lib/orchestration/runner-live.ts
 /** Map a node role to the worker-engine mode. `baseline` is pre-mapped to
@@ -29476,6 +29558,19 @@ async function decideStopHook(input) {
 	let dynamicBaselineKey;
 	const planMode = input.planMode === true || payload.plan_mode === true;
 	const scanDiff = (diff) => planMode ? stripPlanMemoryDiffHunks(diff) : diff;
+	const capturedDiff = async (workdir) => {
+		try {
+			return {
+				diff: await input.captureDiff(workdir),
+				captured: true
+			};
+		} catch {
+			return {
+				diff: "",
+				captured: false
+			};
+		}
+	};
 	const runGate = async () => {
 		if (input.resolveChecks) {
 			const resolved = await input.resolveChecks(cwd).catch(() => null);
@@ -29483,27 +29578,37 @@ async function decideStopHook(input) {
 			resolvedKey = resolved.descriptorKey;
 			dynamicBaselineKey = resolved.baselineKey;
 			const workdir = resolved.workdir || cwd;
-			const diff$1 = await input.captureDiff(workdir).catch(() => "");
+			const { diff: diff$1, captured: captured$1 } = await capturedDiff(workdir);
+			if (captured$1 && diff$1.length === 0) return {
+				kind: "no-diff",
+				diff: diff$1
+			};
 			const result$1 = await evaluateStopGate({
 				checks: resolved.checks,
 				cwd: workdir,
 				exec: input.exec,
-				diff: scanDiff(diff$1)
+				diff: captured$1 ? scanDiff(diff$1) : ""
 			});
 			return {
+				kind: "evaluated",
 				failedChecks: [...result$1.failedChecks],
 				weakeningPatterns: [...new Set(result$1.weakening.map((w) => w.pattern))],
 				diff: diff$1
 			};
 		}
-		const diff = await input.captureDiff(cwd).catch(() => "");
+		const { diff, captured } = await capturedDiff(cwd);
+		if (captured && diff.length === 0) return {
+			kind: "no-diff",
+			diff
+		};
 		const result = await runStopGateForLaunch({
 			workspace: cwd,
 			gateId: input.gateId,
 			exec: input.exec,
-			diff: scanDiff(diff)
+			diff: captured ? scanDiff(diff) : ""
 		});
 		return {
+			kind: "evaluated",
 			failedChecks: [...result.failedChecks],
 			weakeningPatterns: [...new Set(result.weakening.map((w) => w.pattern))],
 			diff
@@ -29517,6 +29622,7 @@ async function decideStopHook(input) {
 	if (timer) clearTimeout(timer);
 	if (raced === "timeout") return { exitCode: 0 };
 	if (raced === null) return { exitCode: 0 };
+	if (raced.kind === "no-diff") return { exitCode: 0 };
 	const baselineKey = dynamicBaselineKey ?? JSON.stringify([
 		sessionId,
 		cwd,
@@ -29804,8 +29910,8 @@ function buildLiveDecomposeDeps(opts) {
 		endpoint: "/v1/messages",
 		effort: "xhigh"
 	};
-	const deps = { async draftIR({ ask, feedback }) {
-		const userText = `Ask:\n${ask}` + (feedback && feedback.length > 0 ? `\n\nFix these issues from the previous draft:\n- ${feedback.join("\n- ")}` : "");
+	const deps = { async draftIR({ ask, context, feedback }) {
+		const userText = `Ask:\n${ask}` + (context && context.trim().length > 0 ? `\n\nContext:\n${context.trim()}` : "") + (feedback && feedback.length > 0 ? `\n\nFix these issues from the previous draft:\n- ${feedback.join("\n- ")}` : "");
 		return extractJson(await dispatchModelCall({
 			model: driver.model,
 			endpoint: driver.endpoint,
@@ -30154,9 +30260,9 @@ Reply format (markdown):
 
 Resilience reminder:
   If your session terminates abnormally before "Status: complete", the lead will retry once. On recovery, ask the lead to confirm what's already been done before re-applying changes — duplicate edits are worse than a slow restart.`;
-const OPUS_CRITIC_BASE = `You are opus-critic, a fresh-context Anthropic-side adversarial reviewer running on Claude Opus 4.7 — the same model and lab as the lead orchestrator that just delegated to you. You are NOT the lead. You did not see the lead's reasoning trace. You only see the brief.
+const OPUS_CRITIC_BASE = `You are opus-critic, a fresh-context same-lab adversarial reviewer running on Opus 4.6. The lead orchestrator that just delegated to you runs newer Opus-family context, but you are NOT the lead. You did not see the lead's reasoning trace. You only see the brief.
 
-Your job is to spot what the lead missed because of cognitive momentum, sunk-cost on a plan, or motivated reasoning toward a particular fix. Your blind-spot diversification is LIMITED compared to codex-critic (gpt-5.5) and gemini-critic (gemini-3.1-pro) — same training, same lab, same RLHF priors. Use that honestly: don't pretend to find a different perspective when the obvious read is "the lead got it right." Silence on good work is a valid and welcome answer.
+Your job is to spot what the lead missed because of cognitive momentum, sunk-cost on a plan, or motivated reasoning toward a particular fix. Your blind-spot diversification is LIMITED compared to codex-critic (gpt-5.5) and gemini-critic (gemini-3.1-pro), same lab, adjacent model family, related priors. Use that honestly: don't pretend to find a different perspective when the obvious read is "the lead got it right." Silence on good work is a valid and welcome answer.
 
 Sycophancy is the failure mode you exist to fight. Manufactured contrarianism is a different failure of the same shape — do neither.
 
@@ -30169,7 +30275,7 @@ const PERSONAS_READ = Object.freeze([
 		toolNameHttp: "codex_critic",
 		model: "gpt-5.5",
 		endpoint: "/v1/responses",
-		description: "Adversarial second opinion on plans, designs, or code tradeoffs. Backed by gpt-5.5 (OpenAI, ≈922K-token input window) — strongest reasoning model in the critic lineup, different lab than Opus. Best for architecture decisions, design reviews, and tradeoff analysis where cross-lab diversity matters. Not for line-level code review (use codex_reviewer). Pass artifact verbatim.",
+		description: "Adversarial architecture and design critic backed by gpt-5.5 (OpenAI, ≈922K-token input window), the strongest cross-lab reasoning critic in this surface. It reviews plans, designs, tradeoffs, and large code-change proposals for unsound assumptions, missing failure modes, and overlooked alternatives, then returns a calibrated objection or `no material objection`. Use when a decision or design needs a different-lab strategic challenge before implementation or merge. Not for line-level bug finding in a concrete diff or file, use codex_reviewer or gemini_reviewer; pass the artifact and constraints verbatim.",
 		baseInstructions: CRITIC_BASE,
 		agentPrompt: "",
 		writeCapable: false,
@@ -30187,7 +30293,7 @@ const PERSONAS_READ = Object.freeze([
 		toolNameHttp: "gemini_critic",
 		model: "gemini-3.1-pro-preview",
 		endpoint: "/v1/chat/completions",
-		description: "Adversarial second opinion. Backed by gemini-3.1-pro (Google) — third-lab triangulation, strong on formal reasoning, proofs, and invariants. Useful for cross-checking findings from codex_critic or codex_reviewer when you want a third perspective. Pass artifact verbatim.",
+		description: "Adversarial third-lab critic backed by gemini-3.1-pro-preview (Google), strong on formal reasoning, invariants, proofs, and cross-checking another critic's conclusion. It reviews plans, designs, mathematical arguments, and large artifacts for assumption gaps or invariant failures, then returns a focused critique or no-material-objection style verdict. Use when codex_critic's result needs an independent lab check or when the artifact hinges on formal correctness. Not for line-level diff review, use gemini_reviewer or codex_reviewer; pass the artifact and constraints verbatim.",
 		baseInstructions: GEMINI_CRITIC_BASE,
 		agentPrompt: "",
 		writeCapable: false,
@@ -30205,7 +30311,7 @@ const PERSONAS_READ = Object.freeze([
 		toolNameHttp: "codex_reviewer",
 		model: "gpt-5.3-codex",
 		endpoint: "/v1/responses",
-		description: "Line-level review of a concrete diff or single file. Backed by gpt-5.3-codex (OpenAI, ≈272K-token input window) — code-specialist, fastest critic (~16s). Surfaces bugs, edge cases, security issues, and idiom violations at specific line numbers. Not suited for architecture or design review (use codex_critic for plans). Pass artifact verbatim.",
+		description: "Line-level code reviewer backed by gpt-5.3-codex (OpenAI, ≈272K-token input window), a code-specialist reviewer that is fastest around high effort (~16s at high effort). It reviews concrete diffs, files, or function bodies and returns findings with severity, file:line locations, issue impact, and a minimal suggested fix. Use when the artifact is actual code and the goal is bug, edge-case, security, concurrency, resource, or idiom review. Not for architecture or tradeoff review, use codex_critic or gemini_critic; pass the diff or file content verbatim.",
 		baseInstructions: REVIEWER_BASE,
 		agentPrompt: "",
 		writeCapable: false,
@@ -30223,7 +30329,7 @@ const PERSONAS_READ = Object.freeze([
 		toolNameHttp: "gemini_reviewer",
 		model: "gemini-3.1-pro-preview",
 		endpoint: "/v1/chat/completions",
-		description: "Line-level review of a concrete diff or single file on gemini-3.1-pro (Google, high reasoning): a second-lab code reviewer that catches a different slice of defects than codex_reviewer (OpenAI). Use alongside codex_reviewer for cross-lab coverage of a diff. Not for architecture (use codex_critic / gemini_critic for plans). Pass artifact verbatim.",
+		description: "Line-level code reviewer backed by gemini-3.1-pro-preview (Google), providing second-lab coverage that catches a different slice of concrete-code defects than codex_reviewer. It reviews diffs, files, or function bodies and returns severity-ranked findings with file:line citations and suggested fixes. Use alongside codex_reviewer when a non-trivial diff benefits from cross-lab code-review coverage, especially around invariants or edge cases. Not for architecture or product-design review, use codex_critic or gemini_critic; pass the code artifact verbatim.",
 		baseInstructions: GEMINI_REVIEWER_BASE,
 		agentPrompt: "",
 		writeCapable: false,
@@ -30241,7 +30347,7 @@ const PERSONAS_READ = Object.freeze([
 		toolNameHttp: "opus_critic",
 		model: "claude-opus-4-6",
 		endpoint: "/v1/messages",
-		description: "Adversarial second opinion from a fresh-context Opus 4.6 — same lab as the lead, limited blind-spot diversity vs cross-lab critics. On enterprise catalogs that carry Opus-4.6-1M it runs with a ≈936K-token input window; otherwise ≈168K. Pinned one minor behind the default Opus so the panel spans more of the version curve. Catches confabulation. Pass artifact verbatim.",
+		description: "Adversarial same-lab critic backed by fresh-context Opus 4.6, with limited blind-spot diversity compared with cross-lab critics. It reviews plans, designs, or code tradeoffs for cognitive momentum, sunk-cost reasoning, and confabulated assumptions, then returns a calibrated objection or no material objection. Use when a same-family sanity check can catch lead-context drift or when comparing against codex_critic / gemini_critic findings. Not a substitute for cross-lab review on security-sensitive or high-risk changes; use codex_critic or gemini_critic for stronger diversity. On enterprise catalogs that carry Opus-4.6-1M it runs with ≈936K input tokens; otherwise ≈168K. Pinned two minors behind the default Opus so the panel spans more of the version curve. Pass artifact verbatim.",
 		baseInstructions: OPUS_CRITIC_BASE,
 		agentPrompt: "",
 		writeCapable: false,
@@ -30259,7 +30365,7 @@ const PERSONAS_WRITE = Object.freeze([{
 	toolNameHttp: "codex_implementer",
 	model: "gpt-5.3-codex",
 	endpoint: "/v1/responses",
-	description: "Targeted implementation of a self-contained coding task. Backed by gpt-5.3-codex with workspace-write access. Pass spec + files verbatim.",
+	description: "Targeted implementation persona backed by gpt-5.3-codex with workspace-write access. It executes self-contained coding tasks from a pasted spec, reads the relevant files, edits the workspace, verifies the result, and returns changed files plus verification output. Use when the task is bounded enough for direct implementation and the caller can provide acceptance criteria and file context up front. Not for open-ended planning or broad repo exploration, use plan or explore first; not for read-only review, use codex_reviewer or gemini_reviewer. Because it can mutate the workspace, scope files and allowed changes explicitly and pass the spec verbatim.",
 	baseInstructions: IMPLEMENTER_BASE,
 	agentPrompt: "",
 	writeCapable: true,
@@ -30354,8 +30460,8 @@ function buildAgentPrompt(persona, opts) {
 *   - Conditionally lists gemini_critic only when `geminiAvailable`.
 *   - Conditionally lists the `worker-*` background dispatcher subagents
 *     (worker-explore / worker-review / worker-plan / worker-implement /
-*     worker-test), the non-blocking-guard fact, and "Workers themselves
-*     have code_search" only when `workerToolsAvailable` (mirrors
+*     worker-test), the non-blocking-guard fact, and the worker code-search
+*     affordance only when `workerToolsAvailable` (mirrors
 *     `workerToolsEnabled()` so the snippet never names a surface gated out
 *     of the live catalog). The raw `mcp__<workers>__*` tools are named only
 *     as the guarded plumbing the dispatchers call, never as a main-agent
@@ -30379,15 +30485,19 @@ function buildPeerAwarenessSnippet(opts) {
 	const orchestrateKey = key("orchestrate");
 	const browserKey = key("browser");
 	const decideKey = key("decide");
+	const fleetKey = key("fleet");
+	const compoundBrowseAvailable = opts.browseAvailable && opts.compoundBrowseAvailable;
+	const powerBrowseAvailable = opts.browseAvailable && opts.powerBrowseAvailable === true;
 	const criticList = ["`codex_critic` (gpt-5.5)", "`codex_reviewer` (gpt-5.3-codex)"];
 	if (opts.geminiAvailable) {
 		criticList.push("`gemini_reviewer` (gemini-3.1-pro, line-level code review)");
 		criticList.push("`gemini_critic` (gemini-3.1-pro)");
 	}
-	criticList.push("`opus_critic` (Opus 4.7)");
+	criticList.push("`opus_critic` (Opus 4.6)");
 	const codexCliClause = opts.codexCli ? " `mcp__codex-cli__codex` dispatches to `codex-implementer` (gpt-5.3-codex with workspace-write) for end-to-end coding tasks." : "";
 	const para2Parts = [`\`mcp__${searchKey}__code\` is the one-stop code search (no extra model call). Its DEFAULT mode (or \`mode:"semantic"\`) ranks by MEANING via ColBERT over a per-workspace index, the first thing to reach for on intent/concept questions ("where is retry/backoff handled", "how does auth work"); when that index isn't ready it transparently falls back to lexical (the response \`source\` says which engine ran). Forced modes cover the rest: \`lexical\` (BM25F-ranked + tree-sitter, best for exact symbols), \`exact\`, \`regex\`, \`complete\` (exhaustive set), \`ast_pattern\`+\`ast_lang\` for multi-line AST shapes, \`scan\` for a whole-workspace symbol outline, \`multiline\` for cross-line regex. Multiple queries can run in a single turn. The index covers code-shaped files; for unstructured files (logs, \`.csv\`, \`.env*\`, config-only wiring), \`grep\`/\`glob\` still apply.`];
 	if (opts.workerToolsAvailable) para2Parts.push(`\`worker-*\` are background Agent subagents (subagent_type) that run the matching worker in its own context and deliver the result as a completion notification, so a long run never blocks the turn: \`worker-explore\` (read-only research), \`worker-review\` (reads the code to verify a change or claim), \`worker-plan\` (ordered implementation plan), \`worker-implement\` (edit/write/bash; \`worktree: true\` isolates in a git worktree and returns the diff), \`worker-test\` (independent test author). The raw \`mcp__${workersKey}__*\` tools they call are guarded (a direct main-thread call is redirected to the matching agent); Workers themselves have \`code_search\`.`);
+	if (opts.workerToolsAvailable && opts.implementerAvailable) para2Parts.push(`For a bounded, well-scoped implementation, prefer the \`implementer\` subagent (Task, runs on gpt-5.5) over \`worker-implement\`; reach for \`worker-implement\` only when you specifically need git-worktree isolation, parallel variants, or a throwaway experiment.`);
 	if (opts.workerToolsAvailable) para2Parts.push(`\`mcp__${orchestrateKey}__decompose\` composes an open-ended ask into a typed, VERIFIED workflow IR (a strong driver decorrelated by a cross-lab critic, so the decompose step isn't a single point of failure), and \`mcp__${orchestrateKey}__run_workflow\` executes that IR through a frozen kernel delivering max(orchestrated, baseline) over a sealed executable gate, so it never ships worse than a plain single-model run. \`mcp__${orchestrateKey}__verify_workflow\` checks an IR's floor invariants before you run it, and \`mcp__${orchestrateKey}__attest_step\` audits that a finished run's producers were each checked by a different lab. They suit non-trivial, role-separated asks; a trivial ask does not need them.`);
 	else para2Parts.push(`\`mcp__${orchestrateKey}__verify_workflow\` statically checks a workflow IR's floor invariants and \`mcp__${orchestrateKey}__attest_step\` audits a run's cross-lab lineage (the \`decompose\`/\`run_workflow\` composer + kernel need the worker backend, unavailable here).`);
 	if (opts.workerToolsAvailable) {
@@ -30396,10 +30506,10 @@ function buildPeerAwarenessSnippet(opts) {
 	}
 	para2Parts.push(`\`mcp__${searchKey}__web\` surfaces citable sources for docs, errors, and upstream issues.`);
 	if (opts.standInAvailable) para2Parts.push(`\`mcp__${decideKey}__stand_in\` provides three-lab consensus for decision tiebreak when the user is unavailable.`);
-	if (opts.browseAvailable) {
-		const powerNote = opts.powerBrowseAvailable ? ` Power mode adds the L0/L1 primitives (\`mcp__${browserKey}__mouse\`, \`__drag\`, \`__type\`, \`__keyboard\`, \`__scroll\`, \`__eval_js\`, \`__read_page\`, \`__diagnostics\`, \`__find\`) for direct DOM / coordinate control.` : "";
-		para2Parts.push(`\`mcp__${browserKey}__*\` tools drive a real Chrome / Edge browser via a local extension. Lead surface: \`__act(intent, value?)\` for any click / fill / type / scroll-to (an inner fast model resolves intent), \`__observe(intent?)\` for a 2-4 sentence natural-language page description, \`__extract(schema, instruction)\` for typed extraction, \`__navigate\` / \`__open_tab\` / \`__screenshot\` for state and visuals. The lead never sees raw DOM: refs and bboxes stay internal.${powerNote}`);
-	}
+	if (opts.browseAvailable) para2Parts.push(`\`mcp__${browserKey}__*\` tools drive a real Chrome / Edge browser via a local extension. Lead browse surface includes \`__navigate\` / \`__open_tab\` / \`__screenshot\` for state, visuals, and navigation.`);
+	if (compoundBrowseAvailable) para2Parts.push(`Compound browse surface includes \`mcp__${browserKey}__act(intent, value?)\` / \`__observe(intent?)\` / \`__extract(schema, instruction)\` / \`__find\`; an inner fast model resolves intent, find/observe yield element refs act consumes, and the lead never sees raw DOM.`);
+	if (powerBrowseAvailable) para2Parts.push(`Power browse surface adds \`mcp__${browserKey}__mouse\`, \`__drag\`, \`__type\`, \`__keyboard\`, \`__scroll\`, \`__eval_js\`, \`__read_page\`, \`__diagnostics\`, \`__list_tabs\`, \`__close_tab\`, \`__wait\`, and \`__download\` for direct DOM and coordinate control.`);
+	if (opts.fleetAvailable) para2Parts.push(`\`mcp__${fleetKey}__*\` tools drive remote ai-or-die coding sessions (list / read / create / stop / await / drive, plus remote read_file / list_dir / search / git_show); they act on a REMOTE fleet instance, not the local repo.`);
 	return [
 		"## Peer review and advisor",
 		"",
@@ -30408,6 +30518,31 @@ function buildPeerAwarenessSnippet(opts) {
 		para2Parts.join(" ")
 	].join("\n");
 }
+/**
+* Compact, gated capability SUMMARY for the spawned session's system prompt
+* (`--append-system-prompt`). The FULL per-tool inventory lives once in the
+* mirrored CLAUDE.md (buildPeerAwarenessSnippet); this ~300-token summary gives
+* the main agent high-salience awareness of what is available without
+* duplicating the full snippet in the context window every turn. Gated
+* identically to the full snippet so it never names a surface the live
+* tools/list dropped. Factual present tense, no imperatives.
+*/
+function buildPeerAwarenessSummary(opts) {
+	const key = (g) => opts.groupKeys?.[g] ?? GROUP_META[g].preferredKey;
+	const lines = [
+		"## Injected capabilities (summary)",
+		"",
+		`A layer of MCP tools, background workers, and skills is injected into this session. Cross-lab peer critics under \`mcp__${key("peers")}__*\` (plus the \`peer-review-coordinator\` subagent) review plans and diffs adversarially, and Claude Code's built-in \`advisor\` catches approach drift. \`mcp__${key("search")}__code\` is meaning-first code search and \`mcp__${key("search")}__web\` returns citable web sources.`
+	];
+	if (opts.workerToolsAvailable) lines.push(`Background \`worker-*\` agents (explore, review, plan, implement, test) run delegated work in their own context without blocking your turn, and \`mcp__${key("orchestrate")}__*\` composes, verifies, and runs floor-raising workflows.`);
+	if (opts.standInAvailable) lines.push(`\`mcp__${key("decide")}__stand_in\` returns a three-lab consensus for a decision when the user is unavailable.`);
+	if (opts.browseAvailable) lines.push(`\`mcp__${key("browser")}__*\` drives a real Chrome or Edge browser.`);
+	if (opts.fleetAvailable) lines.push(`\`mcp__${key("fleet")}__*\` drives remote ai-or-die coding sessions.`);
+	if (opts.agentToolsAvailable === true) lines.push("The `/gh-first-mate` skill drives a durable GitHub cloud-agent loop.");
+	lines.push("");
+	lines.push(`Each tool's own description carries when to use it and when not. The full per-tool inventory (models, gating, workers, skills) is in the "Peer review and advisor" section of your CLAUDE.md project instructions.`);
+	return lines.join("\n");
+}
 /** Convenience: every persona that should be registered for the given mode. */
 function personasFor(opts) {
 	const result = [];
@@ -30418,7 +30553,7 @@ function personasFor(opts) {
 	if (opts.codexCli) for (const p of PERSONAS_WRITE) result.push(p);
 	return result;
 }
-const WEB_SEARCH_DESCRIPTION = "Web search via GitHub Copilot's MCP. Prefer over Claude Code's built-in WebSearch — surfaces source URLs you can cite. Use for API documentation lookups, error message diagnosis, upstream issue searches, and verifying claims against current sources. Returns content with reference links.";
+const WEB_SEARCH_DESCRIPTION = "Web search via GitHub Copilot's MCP that returns answer text plus source URLs the caller can cite. It accepts a natural-language `query`; the upstream provider rewrites for the search index and the handler formats any references as markdown links. Use for current external information such as API documentation, error-message diagnosis, upstream issue searches, and claims that need web sources. Not for local repository discovery or code navigation, use code, Read, Grep, or Glob for workspace content. Prefer it over the built-in WebSearch when source URLs are needed or the built-in surface is geographically constrained.";
 /**
 * Format a `searchWeb()` result as an MCP-friendly text block. Mirrors
 * the legacy inject format that `injectWebSearchIfNeeded` produces and
@@ -30453,7 +30588,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 			if (!query) return {
 				content: [{
 					type: "text",
-					text: "web_search: arguments.query is required (must be a non-empty string)"
+					text: "web: arguments.query is required (must be a non-empty string)"
 				}],
 				isError: true
 			};
@@ -30466,7 +30601,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				return {
 					content: [{
 						type: "text",
-						text: `web_search failed: ${err instanceof Error ? err.message : String(err)}`
+						text: `web failed: ${err instanceof Error ? err.message : String(err)}`
 					}],
 					isError: true
 				};
@@ -30625,7 +30760,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "explore",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-explore` agent. Dispatch via the Agent tool (subagent_type: worker-explore) so your turn is never blocked; the result arrives as a completion notification. Read-only investigation by an autonomous worker (Pi runtime; default model `gpt-5.4-mini` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). Tools: read, glob, grep, code_search (semantic-first), web_search, fetch_url, advisor (consult a stronger cross-lab model), update_plan (planning checklist), and toolbelt (run a read-only analysis CLI: rg/fd/jq/yq/sg/gron/tokei/difft/git). The worker's system prompt sandboxes it and gives one-line descriptions of each tool, so brief it on the investigation, not on tool semantics. Offloads bounded research that would otherwise eat your context window — the worker plans its own tool calls and returns a single text answer. Examples: \"find files matching X then summarize\", \"how does library Y handle Z\", \"survey this codebase for usages of deprecated API\".",
+		description: "Runs as the background `worker-explore` agent. Dispatch via the Agent tool (subagent_type: worker-explore) so the turn is never blocked; the result arrives as a completion notification. Read-only investigation by an autonomous worker (Pi runtime; default model `claude-sonnet-5` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). It has read, glob, grep, semantic-first code search, web search, fetch_url, advisor, update_plan, and read-only toolbelt tools, and it returns a single text answer. Use for bounded research, repo discovery, dependency investigation, or multi-file reading that would otherwise consume the lead context window. Not for implementation, test authoring, or verification of a concrete diff; use implement, test, or review for those scopes. Brief the investigation goal and constraints, not step-by-step tool semantics.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -30637,7 +30772,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				model: {
 					type: "string",
-					description: "Optional Copilot catalog model id (defaults to gpt-5.4-mini). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch."
+					description: "Optional Copilot catalog model id (defaults to claude-sonnet-5). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch."
 				},
 				thinking: {
 					type: "string",
@@ -30649,7 +30784,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 						"high",
 						"xhigh"
 					],
-					description: "Optional reasoning depth (default high). Silently clamped to the model's allowed range; \"off\" drops the parameter entirely."
+					description: "Optional reasoning depth (default xhigh). Silently clamped to the model's allowed range; \"off\" drops the parameter entirely."
 				},
 				workspace: {
 					type: "string",
@@ -30673,7 +30808,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "implement",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-implement` agent. Dispatch via the Agent tool (subagent_type: worker-implement) so your turn is never blocked; the result arrives as a completion notification. Delegates a scoped coding task to an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via the `model` arg with any Copilot-catalog model that advertises `tool_calls`). Tools: the explore read-only set (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) plus edit, write, bash, and codex_review (code review by codex-reviewer / gpt-5.3-codex). The worker's system prompt sandboxes it and gives one-line descriptions of each tool, so brief it on the task, not on tool semantics. With `worktree: false` (default) edits in place — concurrent worker_implement calls and Claude's own edits to the same files will race. With `worktree: true` runs in an isolated git worktree and returns the diff for review. HARD ERROR if true and the workspace is not a git repository.",
+		description: "Runs as the background `worker-implement` agent. Dispatch via the Agent tool (subagent_type: worker-implement) so the turn is never blocked; the result arrives as a completion notification. Delegates a scoped coding task to an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the explore read-only tools plus edit, write, bash, and codex_review, and it returns its final text with any changed files or worktree diff. Use for bounded implementation work that may take a while or benefits from isolated worker context. Not for pure research, planning, review, or independent test authoring; use explore, plan, review, or test for those scopes. With `worktree: false` (default) edits happen in place, so concurrent implement calls and lead edits to the same files can race. With `worktree: true` it runs in an isolated git worktree and returns the diff; this errors if the workspace is not a git repository.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -30685,7 +30820,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				worktree: {
 					type: "boolean",
-					description: "When true, run inside a fresh git worktree and return Pi's final text followed by the unified diff (so the lead can review before merging). When false/omitted, edits the workspace in place — concurrent worker calls and Claude's own edits will race. HARD ERROR if true and the workspace is not a git repository."
+					description: "When true, run inside a fresh git worktree and return Pi's final text followed by the unified diff (so the lead can review before merging). When false/omitted, edits the workspace in place, so concurrent worker calls and lead edits can race. Errors if true and the workspace is not a git repository."
 				},
 				model: {
 					type: "string",
@@ -30725,7 +30860,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "review",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-review` agent. Dispatch via the Agent tool (subagent_type: worker-review) so your turn is never blocked; the result arrives as a completion notification. Read-only code review by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read-only toolset as `explore` (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) — it CANNOT edit — but the worker is framed as a reviewer: it verifies correctness against the actual code itself rather than trusting a claim, and reports findings (bugs, edge cases, security / concurrency / resource risks, missing handling) with a severity and `file:line`. Brief it with the change / diff / claim to verify (paste it, or name the files) — it reads the code to confirm, so you get a self-verifying second opinion that doesn't depend on you having pre-extracted the relevant code. Unlike the `peers` critics (single stateless model calls on the artifact you paste), this worker can navigate the repo to check surrounding context for itself.",
+		description: "Runs as the background `worker-review` agent. Dispatch via the Agent tool (subagent_type: worker-review) so the turn is never blocked; the result arrives as a completion notification. Read-only code review by an autonomous worker (Pi runtime; default model `gemini-3.1-pro-preview`, default thinking xhigh clamped to high for that model, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read-only toolset as explore and verifies claims against surrounding repository context before returning severity-ranked findings with `file:line` citations. Use for reviewing a change, diff, or correctness claim when the reviewer should read the code itself rather than trusting a pasted artifact. Not for architecture critique, implementation, or test authoring; use codex_critic or gemini_critic for design review, implement for edits, and test for independent test creation.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -30737,7 +30872,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				model: {
 					type: "string",
-					description: "Optional Copilot catalog model id (defaults to gpt-5.5). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch."
+					description: "Optional Copilot catalog model id (defaults to gemini-3.1-pro-preview). Must advertise tool_calls support; the engine emits an isError envelope listing the eligible catalog models on mismatch."
 				},
 				thinking: {
 					type: "string",
@@ -30749,7 +30884,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 						"high",
 						"xhigh"
 					],
-					description: "Optional reasoning depth (default high). Silently clamped to the model's allowed range; \"off\" drops the parameter entirely."
+					description: "Optional reasoning depth (defaults to xhigh, clamped to high for the default review model). Silently clamped to the model's allowed range; \"off\" drops the parameter entirely."
 				},
 				workspace: {
 					type: "string",
@@ -30773,7 +30908,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "plan",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-plan` agent. Dispatch via the Agent tool (subagent_type: worker-plan) so your turn is never blocked; the result arrives as a completion notification. Read-only implementation planning by an autonomous worker (Pi runtime; default model `claude-opus-4.8`, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read-only toolset as `explore` (read, glob, grep, code_search, web_search, fetch_url, advisor, update_plan, toolbelt) — it CANNOT edit — but the worker is framed as a planner: from the task and acceptance criteria it produces a concrete, ordered implementation plan (the files to change, the approach, the key risks, and how each acceptance criterion will be verified), grounded by reading the actual code. Brief it with the task and any acceptance criteria; it returns a single plan, not code.",
+		description: "Runs as the background `worker-plan` agent. Dispatch via the Agent tool (subagent_type: worker-plan) so the turn is never blocked; the result arrives as a completion notification. Read-only implementation planning by an autonomous worker (Pi runtime; default model `claude-opus-4.8` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read-only toolset as explore and returns a concrete, ordered implementation plan covering files, approach, risks, and how acceptance criteria will be verified. Use before coding when the task needs repo-grounded sequencing or acceptance criteria translated into implementation steps. Not for editing files, running an implementation, writing tests, or adversarial review; use implement, test, or review for those scopes.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -30797,7 +30932,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 						"high",
 						"xhigh"
 					],
-					description: "Optional reasoning depth (default high). Silently clamped to the model's allowed range; \"off\" drops the parameter entirely."
+					description: "Optional reasoning depth (default xhigh). Silently clamped to the model's allowed range; \"off\" drops the parameter entirely."
 				},
 				workspace: {
 					type: "string",
@@ -30821,7 +30956,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "test",
 		group: "workers",
 		capability: "worker",
-		description: "Runs as the background `worker-test` agent. Dispatch via the Agent tool (subagent_type: worker-test) so your turn is never blocked; the result arrives as a completion notification. Independent adversarial test authoring by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). Same read+write toolset as `implement` (the explore set plus edit, write, bash, codex_review). The worker is framed as an INDEPENDENT test author that did NOT write the code under test: from the task and acceptance criteria it writes tests that try to BREAK the implementation (edge cases, error paths, the acceptance criteria as executable checks), runs them, and reports which pass and fail — it does NOT modify the implementation to make tests pass. With `worktree: true` runs in an isolated git worktree and returns the diff; HARD ERROR if true and the workspace is not a git repository.",
+		description: "Runs as the background `worker-test` agent. Dispatch via the Agent tool (subagent_type: worker-test) so the turn is never blocked; the result arrives as a completion notification. Independent adversarial test authoring by an autonomous worker (Pi runtime; default model `gpt-5.5` at xhigh reasoning, override via `model` with any Copilot-catalog model that advertises `tool_calls`). It has the same read/write toolset as implement and writes tests that try to break the implementation through edge cases, error paths, and acceptance criteria, then runs them and reports pass/fail. Use when a separate test author should challenge an implementation without modifying the production code to make tests pass. Not for implementing fixes, broad research, or code review; use implement, explore, or review for those scopes. With `worktree: true` it runs in an isolated git worktree and returns the test diff; this errors if the workspace is not a git repository.",
 		inputSchema: {
 			type: "object",
 			required: ["prompt"],
@@ -30833,7 +30968,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 				},
 				worktree: {
 					type: "boolean",
-					description: "When true, run inside a fresh git worktree and return Pi's final text followed by the unified diff (so the lead can review the authored tests before merging). When false/omitted, writes tests in place — concurrent worker calls and Claude's own edits will race. HARD ERROR if true and the workspace is not a git repository."
+					description: "When true, run inside a fresh git worktree and return Pi's final text followed by the unified diff (so the lead can review the authored tests before merging). When false/omitted, writes tests in place, so concurrent worker calls and lead edits can race. Errors if true and the workspace is not a git repository."
 				},
 				model: {
 					type: "string",
@@ -30872,7 +31007,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 	{
 		toolNameHttp: "verify_workflow",
 		group: "orchestrate",
-		description: "Statically verify a workflow IR against the orchestration floor invariants BEFORE running it. Input `ir`: the typed WorkflowIR (rawAskHash, acceptanceCriteriaHash, nodes[] with role/inputs/gate/onFail, maxDepth). Returns {ok, violations:[{code, message, nodeId?}]}. Each violation carries a stable code (e.g. NO_BASELINE, SELECTOR_NOT_RAW_ASK, SAME_LAB_CHECK, ORPHAN_NODE, MISSING_INTEGRATION_GATE) — fix every one until `ok` is true. WHY: a workflow's floor guarantee (deliver max(orchestrated, baseline), producer != checker, cross-lab checks, sealed gates) is only as good as the IR's structure; a probabilistically-composed IR can silently violate it. This is the cheap, pure, side-effect-free pre-flight that catches those violations with actionable codes so you self-correct BEFORE paying for execution. Call it right after composing/decomposing a workflow.",
+		description: "Statically verifies a workflow IR against the orchestration floor invariants before the kernel runs it. It accepts the typed WorkflowIR as `ir` and an optional `knownGateIds` allowlist, then returns {ok, violations:[{code, message, nodeId?}]} with stable violation codes such as NO_BASELINE, SELECTOR_NOT_RAW_ASK, SAME_LAB_CHECK, ORPHAN_NODE, or MISSING_INTEGRATION_GATE. Use immediately after composing or receiving a workflow IR, especially before paying for run_workflow, so structural floor failures can be fixed while still in data form. Not a runner, model reviewer, or proof that the user's spec is correct; use run_workflow to execute sealed gates and use critic/review tools for advisory review.",
 		inputSchema: {
 			type: "object",
 			required: ["ir"],
@@ -30902,7 +31037,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "decompose",
 		group: "orchestrate",
 		capability: "worker",
-		description: "Compose a VERIFIED, tool-routed workflow IR from an open-ended software ask. A single strong driver model drafts a typed WorkflowIR; a static verifier checks it against the floor invariants and the driver re-drafts on any violation; a cross-lab critic reviews a clean draft. Returns {ok, ir, rounds, concerns?} on success, or {ok:false, violations, rounds} if it never converged. WHY: a single model anchors on its own framing of a task (the decompose step is itself a single point of failure), so the driver is decorrelated by a cross-lab critic, and the output is a typed IR a verifier/kernel enforce in CODE rather than prose the model could quietly violate. The IR is DATA you then pass to run_workflow (or re-check with verify_workflow). Reach for it on non-trivial, role-separated asks where blind-spot reduction pays off; a trivial ask does not need it.",
+		description: "Composes a verified, tool-routed WorkflowIR from an open-ended software ask. A strong driver model drafts the IR, the static verifier checks floor invariants, the driver re-drafts on violations, and a cross-lab critic reviews a clean draft; optional `context` supplies repo facts, constraints, or research findings to the driver. It returns {ok, ir, rounds, concerns?} on success, or {ok:false, violations, rounds} when it cannot converge. Use for non-trivial, role-separated asks where blind-spot reduction and sealed-gate structure justify orchestration. Not for trivial edits, direct implementation, or execution; use implement for a scoped code change and run_workflow only after the IR is verified.",
 		inputSchema: {
 			type: "object",
 			required: ["ask"],
@@ -30935,7 +31070,10 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 					effort: "high"
 				},
 				signal
-			}), { maxRounds: 3 });
+			}), {
+				maxRounds: 3,
+				context: typeof args.context === "string" ? args.context : void 0
+			});
 			return {
 				content: [{
 					type: "text",
@@ -30949,7 +31087,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "run_workflow",
 		group: "orchestrate",
 		capability: "worker",
-		description: "Execute a VERIFIED workflow IR (from decompose / verify_workflow) through the frozen orchestration kernel. The kernel runs the single-model BASELINE plus the orchestrated DAG, gates every producer over a SEALED executable gate you name by `gateId` (the kernel owns the command; the IR cannot author it), and delivers max(orchestrated, baseline) by champion-retention: the orchestrated result ships only if it verifiably does not regress the baseline's executable checks, else the baseline ships. Returns {ok, outcome:{status, winner?, artifact?, reason, gatesPassed?}}. WHY: orchestration is a conditional bet (it helps on blind-spot/ambiguous asks, backfires on others), so the kernel NEVER ships something worse than a plain single-model run on the same ask. It enforces the floor in code (the model can't be trusted to honor it): a parallel baseline, a sealed executable gate as the selector, fail-to-baseline on any infra failure. Use after decompose for non-trivial asks on a harness-bearing repo.",
+		description: "Executes a verified WorkflowIR through the frozen orchestration kernel. The kernel runs a single-model baseline beside the orchestrated DAG, gates producers over the sealed executable `gateId` selected by the caller, and returns {ok, outcome:{status, winner?, artifact?, reason, gatesPassed?}}. It uses champion retention: the orchestrated candidate wins only when it does not regress the baseline's executable checks; otherwise the baseline ships. Use after decompose and verify_workflow for non-trivial asks in a git workspace with a meaningful sealed gate. Not for composing an IR, performing advisory review, or running arbitrary model-authored shell commands; use decompose or verify_workflow before this tool, and use ordinary tests or review tools outside the workflow kernel.",
 		inputSchema: {
 			type: "object",
 			required: [
@@ -31014,7 +31152,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 	{
 		toolNameHttp: "attest_step",
 		group: "orchestrate",
-		description: "Attest (audit) that an orchestrated run actually honored bias isolation: every producer node was checked by a DIFFERENT lab, and that check covered the producer's FINAL artifact (matched by content hash, so a check of a stale earlier version does not count). Input `nodes`: [{id, producerLab, artifactHash, checks:[{checkerLab, verifiedArtifactHash}]}]. Returns {attested, recommendation: 'accept'|'ship_baseline', nodes:[{id, attested, reason}]}. WHY: run_workflow's frozen kernel is the TAMPER-PROOF path (it controls the artifacts and computes the hashes). attest_step is for workflows you compose OUTSIDE the kernel: it deterministically checks your SELF-REPORTED lineage is structurally sound (a different-lab check whose hash equals each producer's final-artifact hash), catching the non-malicious failures (a missing / same-lab / stale check). It verifies consistency, NOT that the hashes are real — a completeness gate, not a security boundary. Fail-closed: anything short of a valid different-lab check on EVERY node recommends shipping the baseline. It RECOMMENDS; it never executes.",
+		description: "Audits self-reported producer lineage for bias-isolation structure. It accepts `nodes` with each producer lab, final artifact hash, and checker hashes, then returns {attested, recommendation:'accept'|'ship_baseline', nodes:[{id, attested, reason}]}. The check passes only when every producer has a different-lab check over the same final artifact hash, so missing, same-lab, or stale checks fail closed to a baseline recommendation. Use for workflows composed outside run_workflow, where lineage is self-reported and needs a deterministic completeness gate. Not a security boundary, hash authenticator, or executor; run_workflow is the kernel-owned path when the router must control artifacts, gates, and hashes.",
 		inputSchema: {
 			type: "object",
 			required: ["nodes"],
@@ -31072,7 +31210,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "browse",
 		group: "workers",
 		capability: "browse_agent",
-		description: "Runs as the background `worker-browse` agent. Dispatch via the Agent tool (subagent_type: worker-browse) so your turn is never blocked; the result arrives as a completion notification. A Pi-driven autonomous browser agent (gpt-5.4-mini) that drives a real browser to accomplish `task` and returns the result. Runs in its own context to preserve the lead's window (raw DOM / page snapshots stay inside the agent). Pass `sessionId` to continue a prior session (its id is returned appended to the result as `[browse session: <id>]`); omit it for a fresh isolated session. Multiple concurrent calls run as parallel sessions on the one shared browser. Examples: \"find the cheapest flight LHR-JFK next Tuesday\", \"log into the dashboard and read the current MRR\", \"summarize the top 3 HN front-page stories\".",
+		description: "Runs as the background `worker-browse` agent. Dispatch via the Agent tool (subagent_type: worker-browse) so the turn is never blocked; the result arrives as a completion notification. A Pi-driven autonomous browser worker (default model `gpt-5.4-mini`) drives a real browser to accomplish `task`, keeps raw DOM and page snapshots inside its own context, and returns a single text result. Use for delegated multi-step web tasks such as comparing prices, logging into a dashboard, or summarizing pages when the lead does not need to steer each click. Not for direct in-context browser control, screenshots, or precise element interactions; use the `browser` MCP tools for those. Pass `sessionId` to continue a prior browse session, or omit it for a fresh isolated session; multiple calls run as parallel sessions on the shared browser.",
 		inputSchema: {
 			type: "object",
 			required: ["task"],
@@ -31100,7 +31238,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 		toolNameHttp: "stand_in",
 		group: "decide",
 		capability: "stand_in",
-		description: "**Away-mode decision tiebreak.** Three-lab advisor (gpt-5.5 xhigh, opus-4.7 xhigh, gemini-3.1-pro high) for **when the user is unavailable and you are stuck between two or more concrete options**. Polls all three across two structured rounds (blind vote → informed re-vote with peer reasoning visible) and returns a ranked-choice verdict. Use when: you would otherwise halt and wait for the user. Do NOT use for: code review (use `peer-review-coordinator`), open-ended exploration, single-model second opinions (use `codex_critic` / `gemini_critic` / `opus_critic` directly), or as a substitute for user confirmation on irreversible actions (push, delete, drop, deploy — those still require the user even with three-lab consensus).",
+		description: "Three-lab away-mode decision tiebreak advisor for moments when the user is unavailable and the agent is stuck between two or more concrete options. It polls gpt-5.5, Opus 4.7, and gemini-3.1-pro-preview across blind and informed voting rounds, then returns a ranked-choice verdict such as consensus, majority, no_consensus, or need_more_info. Use when work would otherwise halt on a bounded choice the user would normally make. Not for code review, open-ended exploration, single-model second opinions, or bypassing confirmation on irreversible actions such as push, delete, drop, or deploy; use peer-review-coordinator or the individual critics for review and still ask the user for destructive actions.",
 		inputSchema: {
 			type: "object",
 			required: ["decision", "options"],
@@ -31189,7 +31327,7 @@ function assertMcpToolSurfaceConsistent() {
 * accessibility) and never throws — its `{text, isError?}` envelope
 * is forwarded verbatim into the MCP `tool result` shape.
 *
-* Arg-validation policy mirrors `web_search`'s pattern: shape errors
+* Arg-validation policy mirrors `web`'s pattern: shape errors
 * surface as `isError: true` tool-result envelopes (NOT JSON-RPC -32602
 * errors). The MCP `tools/list` JSON schema already documents the
 * required/optional fields; this runtime check is defense against a
@@ -31396,7 +31534,7 @@ async function runBrowseToolCall(args, signal) {
 * failures, abstains) all surface inside the structured `StandInResult`
 * envelope, which we JSON-stringify into the single MCP text block.
 *
-* Arg-validation policy mirrors `runWorkerToolCall` and `web_search`:
+* Arg-validation policy mirrors `runWorkerToolCall` and `web`:
 * shape errors surface as `isError: true` tool-result envelopes (NOT
 * JSON-RPC -32602). The `tools/list` JSON schema documents required
 * fields; this runtime check is defense against a schema-ignoring
@@ -31494,5 +31632,5 @@ async function runStandInToolCall(args, signal) {
 }
 
 //#endregion
-export { buildAnthropicErrorEvent as $, resolveCodexModel as $t, liveExec as A, shouldUseInsecureTls as At, availableToolCommands as B, generateRandomPort as Bt, isSubagentContext as C, readResponseBodyCapped as Ct, stopReviewStateDir as D, provisionAndIndexColbert as Dt, stopGateEnabledForRepo as E, hasSupportedBrowserInstalled as Et, PLAN_DEFAULT_MODEL as F, DEFAULT_CODEX_MODEL as Ft, TOOLBELT_TOOLS$1 as G, setupGitHubAgentToken as Gt, toolbeltEnabled as H, getPackageVersion as Ht, REVIEW_DEFAULT_MODEL as I, DEFAULT_CODEX_MODEL_FALLBACKS as It, ADVISOR_INTERNAL_TOOL_NAME as J, cacheCopilotVersion as Jt, assetFor as K, setupGitHubToken as Kt, appendPlanReminder as L, DEFAULT_PORT as Lt, DEFAULT_MODEL as M, collapsePathKeys as Mt, EXPLORE_DEFAULT_MODEL as N, toolbeltPathOverride as Nt, trustRepo as O, extractTarGzMember as Ot, IMPLEMENT_DEFAULT_MODEL as P, DEFAULT_CLAUDE_MODEL_FALLBACKS as Pt, isAdvisorRequested as Q, isNullish as Qt, runWorkerAgent as R, UPSTREAM_FETCH_TIMEOUT_MS as Rt, fileReviewDebounce as S, MAX_RESPONSE_BODY_BYTES as St, repoRoot as T, provisionBrowserAssets as Tt, toolbeltSkipSet as U, withInstallLock as Ut, buildToolbeltAwareness as V, pickClaudeDefault as Vt, vscodeRipgrepPath as W, setupCopilotToken as Wt, buildAdvisorStream as X, cacheVSCodeVersion as Xt, ADVISOR_TOOL_INSTRUCTIONS as Y, cacheModels as Yt, injectAdvisorTool as Z, filterBetaHeader as Zt, stopGatePlanMode as _, assembleResponsesPayload as _t, buildPeerAwarenessSnippet as a, forwardError as an, handleMcpDelete as at, fileFindingsStore as b, createResponses as bt, buildSessionBindHookCommand as c, copilotHeaders as cn, browseAgentEnabled as ct, decideStopHook as d, implementerSubagentModel as dt, resolveModel as en, buildOpenAIErrorEvent as et, fileBlockBudget as f, standInToolEnabled as ft, stopGateId as g, getTokenCount as gt, stopGateDisabled as h, createMessages as ht, buildAgentPrompt as i, HTTPError as in, relayAnthropicStream as it, BROWSE_DEFAULT_MODEL as j, ArtifactClient as jt, resolveSealedGate as k, extractZipMember as kt, buildStopHookCommand as l, githubHeaders as ln, browserToolsEnabled as lt, launchBaselineKey as m, countTokens as mt, MCP_GROUPS as n, getModels as nn, logStreamError as nt, personasFor as o, GITHUB_API_BASE_URL as on, handleMcpPost as ot, injectStopHookIntoSettingsFile as p, workerToolsEnabled as pt, searchWeb as q, tryRefreshAndRetry as qt, assertMcpToolSurfaceConsistent as r, fetchWithTransientRetry as rn, readIteratorWithTimeout as rt, buildArtifactOpenHookCommand as s, copilotBaseUrl as sn, agentToolsEnabled as st, GROUP_META as t, sleep as tn, isControllerClosedError as tt, captureLaunchBaseline as u, state as un, fleetToolsEnabled as ut, stopReviewEnabled as v, resolveMcpToolTimeoutMs as vt, repoFingerprint as w, parseJsonOrDiagnose as wt, fileLastPromptStore as x, createChatCompletions as xt, fileBaselineStore as y, pickEndpoint as yt, withNoOutputRetry as z, UPSTREAM_INACTIVITY_TIMEOUT_MS as zt };
-//# sourceMappingURL=peer-mcp-personas-D826LsJJ.js.map
+export { isAdvisorRequested as $, cacheModels as $t, liveExec as A, hasSupportedBrowserInstalled as At, withNoOutputRetry as B, DEFAULT_CODEX_MODEL_FALLBACKS as Bt, fileReviewDebounce as C, pickEndpoint as Ct, stopGateEnabledForRepo as D, readResponseBodyCapped as Dt, repoRoot as E, MAX_RESPONSE_BODY_BYTES as Et, IMPLEMENT_DEFAULT_MODEL as F, ArtifactClient as Ft, vscodeRipgrepPath as G, pickClaudeDefault as Gt, buildToolbeltAwareness as H, UPSTREAM_FETCH_TIMEOUT_MS as Ht, PLAN_DEFAULT_MODEL as I, collapsePathKeys as It, searchWeb as J, setupCopilotToken as Jt, TOOLBELT_TOOLS$1 as K, getPackageVersion as Kt, REVIEW_DEFAULT_MODEL as L, toolbeltPathOverride as Lt, BROWSE_DEFAULT_MODEL as M, extractTarGzMember as Mt, DEFAULT_MODEL as N, extractZipMember as Nt, stopReviewStateDir as O, parseJsonOrDiagnose as Ot, EXPLORE_DEFAULT_MODEL as P, shouldUseInsecureTls as Pt, injectAdvisorTool as Q, cacheCopilotVersion as Qt, appendPlanReminder as R, DEFAULT_CLAUDE_MODEL_FALLBACKS as Rt, fileLastPromptStore as S, resolveMcpToolTimeoutMs as St, repoFingerprint as T, createChatCompletions as Tt, toolbeltEnabled as U, UPSTREAM_INACTIVITY_TIMEOUT_MS as Ut, availableToolCommands as V, DEFAULT_PORT as Vt, toolbeltSkipSet as W, generateRandomPort as Wt, ADVISOR_TOOL_INSTRUCTIONS as X, setupGitHubToken as Xt, ADVISOR_INTERNAL_TOOL_NAME as Y, setupGitHubAgentToken as Yt, buildAdvisorStream as Z, tryRefreshAndRetry as Zt, stopGateId as _, workerToolsEnabled as _t, buildPeerAwarenessSnippet as a, sleep as an, relayAnthropicStream as at, fileBaselineStore as b, getTokenCount as bt, buildArtifactOpenHookCommand as c, HTTPError as cn, agentToolsEnabled as ct, captureLaunchBaseline as d, copilotBaseUrl as dn, browserCompoundToolsEnabled as dt, cacheVSCodeVersion as en, buildAnthropicErrorEvent as et, decideStopHook as f, copilotHeaders as fn, browserToolsEnabled as ft, stopGateDisabled as g, standInToolEnabled as gt, launchBaselineKey as h, implementerSubagentModel as ht, buildAgentPrompt as i, resolveModel as in, readIteratorWithTimeout as it, resolveSealedGate as j, provisionAndIndexColbert as jt, trustRepo as k, provisionBrowserAssets as kt, buildSessionBindHookCommand as l, forwardError as ln, artifactToolsEnabled as lt, injectStopHookIntoSettingsFile as m, state as mn, geminiAvailable as mt, MCP_GROUPS as n, isNullish as nn, isControllerClosedError as nt, buildPeerAwarenessSummary as o, getModels as on, handleMcpDelete as ot, fileBlockBudget as p, githubHeaders as pn, fleetToolsEnabled as pt, assetFor as q, withInstallLock as qt, assertMcpToolSurfaceConsistent as r, resolveCodexModel as rn, logStreamError as rt, personasFor as s, fetchWithTransientRetry as sn, handleMcpPost as st, GROUP_META as t, filterBetaHeader as tn, buildOpenAIErrorEvent as tt, buildStopHookCommand as u, GITHUB_API_BASE_URL as un, browseAgentEnabled as ut, stopGatePlanMode as v, countTokens as vt, isSubagentContext as w, createResponses as wt, fileFindingsStore as x, assembleResponsesPayload as xt, stopReviewEnabled as y, createMessages as yt, runWorkerAgent as z, DEFAULT_CODEX_MODEL as zt };
+//# sourceMappingURL=peer-mcp-personas-BCGYWok0.js.map