github-router 0.3.138 → 0.3.150

package/dist/{peer-mcp-personas-CThUmeHE.js → peer-mcp-personas-D_HyWhUb.js}

@@ -1,6 +1,6 @@
-import { t as PATHS } from "./paths-Cn5OzmYL.js";
-import { d as runCommandCapture, l as parseBoolEnv, n as isPidAlive, o as trackChild, p as runManagedExeCapture, r as registerColbertExitHandlers, t as getColbertInstanceUuid, u as resolveExecutable } from "./lifecycle-Cqe8OQVX.js";
-import { i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-CeVDX6av.js";
+import { t as PATHS } from "./paths-D0tJ_tms.js";
+import { d as runCommandCapture, l as parseBoolEnv, n as isPidAlive, o as trackChild, p as runManagedExeCapture, r as registerColbertExitHandlers, t as getColbertInstanceUuid, u as resolveExecutable } from "./lifecycle-DyEXZu2z.js";
+import { i as registerExitHandlers, n as getInstanceUuid, r as recordWorkerRepo, t as WorktreeRegistry } from "./lifecycle-DGvk4z63.js";
 import { createRequire } from "node:module";
 import consola from "consola";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
@@ -42,6 +42,7 @@ const state = {
 	extendedBetas: false,
 	browseEnabled: false,
 	fleetEnabled: false,
+	agentsEnabled: false,
 	powerBrowseEnabled: false,
 	humanlikeForce: "auto",
 	sessionId: randomUUID(),
@@ -93,6 +94,24 @@ const githubHeaders = (state$1) => ({
 const GITHUB_BASE_URL = "https://github.com";
 const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
 const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const GITHUB_AGENT_CLIENT_ID = "178c6fc778ccc68e1d6a";
+const GITHUB_AGENT_SCOPES = [
+	"repo",
+	"workflow",
+	"read:org"
+].join(" ");
+const GITHUB_GRAPHQL_URL = process.env.GITHUB_GRAPHQL_URL ?? "https://api.github.com/graphql";
+const GITHUB_REST_API_VERSION = "2022-11-28";
+const githubAgentHeaders = (state$1) => ({
+	...standardHeaders(),
+	authorization: `token ${state$1.githubAgentToken}`,
+	"x-github-api-version": GITHUB_REST_API_VERSION,
+	"user-agent": "github-router-first-mate"
+});
+const githubAgentGraphQLHeaders = (state$1, features) => ({
+	...githubAgentHeaders(state$1),
+	...features ? { "GraphQL-Features": features } : {}
+});
 
 //#endregion
 //#region src/lib/error.ts
@@ -376,6 +395,11 @@ const COPILOT_HOST_ALLOWLIST = [
 	"api.business.githubcopilot.com",
 	"api.enterprise.githubcopilot.com"
 ];
+/**
+* True iff `rawUrl` is an HTTPS URL whose host is a trusted Copilot API host.
+* Exported so every path that sends a long-lived token to a discovered
+* Copilot host (web search, first-mate CAPI session logs) shares one allowlist.
+*/
 function isAllowedCopilotHost(rawUrl) {
 	let parsed;
 	try {
@@ -397,13 +421,17 @@ const getCopilotToken = async () => {
 
 //#endregion
 //#region src/services/github/get-device-code.ts
-async function getDeviceCode() {
+const DEFAULT_DEVICE_APP = {
+	clientId: GITHUB_CLIENT_ID,
+	scope: GITHUB_APP_SCOPES
+};
+async function getDeviceCode(app = DEFAULT_DEVICE_APP) {
 	const response = await fetchWithTransientRetry(() => fetch(`${GITHUB_BASE_URL}/login/device/code`, {
 		method: "POST",
 		headers: standardHeaders(),
 		body: JSON.stringify({
-			client_id: GITHUB_CLIENT_ID,
-			scope: GITHUB_APP_SCOPES
+			client_id: app.clientId,
+			scope: app.scope
 		})
 	}), { label: "/login/device/code" });
 	if (!response.ok) throw new HTTPError("Failed to get device code", response);
@@ -693,7 +721,7 @@ const cacheCopilotVersion = async () => {
 
 //#endregion
 //#region src/services/github/poll-access-token.ts
-async function pollAccessToken(deviceCode) {
+async function pollAccessToken(deviceCode, clientId = GITHUB_CLIENT_ID) {
 	const sleepDuration = (deviceCode.interval + 1) * 1e3;
 	consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
 	const expiresAt = Date.now() + deviceCode.expires_in * 1e3;
@@ -702,7 +730,7 @@ async function pollAccessToken(deviceCode) {
 			method: "POST",
 			headers: standardHeaders(),
 			body: JSON.stringify({
-				client_id: GITHUB_CLIENT_ID,
+				client_id: clientId,
 				device_code: deviceCode.device_code,
 				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
 			})
@@ -727,6 +755,8 @@ async function pollAccessToken(deviceCode) {
 //#region src/lib/token.ts
 const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
 const writeGithubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token);
+const readGithubAgentToken = () => fs.readFile(PATHS.GITHUB_AGENT_TOKEN_PATH, "utf8");
+const writeGithubAgentToken = (token) => fs.writeFile(PATHS.GITHUB_AGENT_TOKEN_PATH, token, { mode: 384 });
 const setupCopilotToken = async () => {
 	const { token, refresh_in } = await getCopilotToken();
 	state.copilotToken = token;
@@ -820,6 +850,71 @@ async function logUser() {
 	const user = await getGitHubUser();
 	consola.info(`Logged in as ${user.login}`);
 }
+/**
+* Set up the SECOND, write-capable GitHub token used by the first-mate
+* agent-orchestration surface (`--agents`). Mirrors `setupGitHubToken`
+* but authenticates against the GitHub CLI's OAuth client
+* (`GITHUB_AGENT_CLIENT_ID`) requesting `repo workflow read:org`, and
+* stores the result apart at `PATHS.GITHUB_AGENT_TOKEN_PATH`. The Copilot
+* App token (`state.githubToken`) is left completely untouched — this is
+* a distinct identity for a distinct capability.
+*
+* Long-lived (device-flow user token) → no refresh loop; a later 401 is
+* surfaced to the caller as a revoked grant to re-run the login. Called
+* once from `setupAndServe` when `state.agentsEnabled` is true.
+*/
+async function setupGitHubAgentToken(options) {
+	try {
+		const existing = (await readGithubAgentToken().catch(() => "")).trim();
+		if (existing && !options?.force) {
+			state.githubAgentToken = existing;
+			if (state.showToken) consola.info("GitHub agent token:", existing);
+			await warnIfAgentScopesInsufficient();
+			return;
+		}
+		consola.info("Agent mode (--agents): a second GitHub login is required for a write-capable token (repo, workflow, read:org).");
+		const response = await getDeviceCode({
+			clientId: GITHUB_AGENT_CLIENT_ID,
+			scope: GITHUB_AGENT_SCOPES
+		});
+		consola.debug("Agent device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri} to authorize github-router's cloud-agent orchestration to act on your repositories.`);
+		const token = await pollAccessToken(response, GITHUB_AGENT_CLIENT_ID);
+		await writeGithubAgentToken(token);
+		state.githubAgentToken = token;
+		if (state.showToken) consola.info("GitHub agent token:", token);
+		await warnIfAgentScopesInsufficient();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub agent token:", await error.response.json());
+			throw error;
+		}
+		consola.error("Failed to get GitHub agent token:", error);
+		throw error;
+	}
+}
+/**
+* Best-effort check that the agent token actually carries the scopes we
+* asked for. The GitHub CLI OAuth client is a classic OAuth App, so the
+* granted scopes are echoed in the `x-oauth-scopes` response header on
+* any authenticated call. Warn loudly (not fatal) if `repo`/`workflow`
+* are missing so the failure is diagnosable at login rather than at the
+* first write 403.
+*/
+async function warnIfAgentScopesInsufficient() {
+	try {
+		const res = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: githubAgentHeaders(state) });
+		if (res.status === 401) {
+			consola.warn("GitHub agent token was rejected (401) — the grant may have been revoked. Re-run with --agents to log in again.");
+			return;
+		}
+		const scopes = (res.headers.get("x-oauth-scopes") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+		const missing = ["repo", "workflow"].filter((s) => !scopes.includes(s));
+		if (missing.length > 0) consola.warn(`GitHub agent token is missing scope(s): ${missing.join(", ")}. The first-mate surface needs 'repo' + 'workflow' to create issues, assign cloud agents, and dispatch workflows. Re-run the agent login and grant the requested scopes.`);
+	} catch (err) {
+		consola.debug("Agent token scope check skipped:", err);
+	}
+}
 
 //#endregion
 //#region src/lib/update-lock.ts
@@ -1282,40 +1377,40 @@ function tool(toolNameHttp, description, inputSchema, handler) {
 			try {
 				return await handler(args, signal);
 			} catch (err) {
-				return errorResult$1(err);
+				return errorResult$2(err);
 			}
 		}
 	};
 }
 const ARTIFACT_TOOLS = Object.freeze([
-	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$1({ file: stringProp$1("Workspace-relative or absolute file path to show in the Artifact panel.") }, ["file"]), async (args, signal) => {
+	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. 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.") }, ["file"]), async (args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		const file = requiredString$1(args, "file");
-		return ok$1({
+		const file = requiredString$2(args, "file");
+		return ok$2({
 			viewUrl: (await clientFromEnv(env).open(file, signal)).viewUrl,
 			next_step: "Tell the user to review at the Artifact panel, then call artifact_poll."
 		});
 	}),
-	tool("artifact_poll", "Wait for human Artifact review feedback from ai-or-die and return the prompts/layout warnings/DOM snapshot for the agent to act on. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$1({}, []), async (_args, signal) => {
+	tool("artifact_poll", "Wait for human Artifact review feedback from ai-or-die and return the prompts/layout warnings/DOM snapshot for the agent to act on. 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$1(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
+		return ok$2(formatPollResponse(await pollUntilReady(clientFromEnv(env), 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$1({ text: stringProp$1("Agent reply text to deliver to the human Artifact review panel.") }, ["text"]), async (args, 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) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		const text = requiredString$1(args, "text");
-		return ok$1({
+		const text = requiredString$2(args, "text");
+		return ok$2({
 			ok: true,
 			...await clientFromEnv(env).agentReply(text, signal),
 			next_step: "Wait for further human review, or continue if the review loop is complete."
 		});
 	}),
-	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$1({}, []), async (_args, 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) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		return ok$1({
+		return ok$2({
 			ok: true,
 			...await clientFromEnv(env).end(signal),
 			next_step: "Artifact review loop ended."
@@ -1401,7 +1496,7 @@ function isWaitingStatus(status) {
 	const normalized = status.toLowerCase();
 	return normalized === "waiting" || normalized === "pending" || normalized === "open" || normalized === "idle" || normalized === "timeout" || normalized === "no_feedback";
 }
-function requiredString$1(args, key) {
+function requiredString$2(args, key) {
 	const value = args[key];
 	if (typeof value !== "string" || value.trim() === "") throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} is required and must be a non-empty string`);
 	return value;
@@ -1415,15 +1510,15 @@ var ArtifactToolInputError = class extends Error {
 	}
 };
 function missingEnvResult() {
-	return jsonResult$1({ error: {
+	return jsonResult$2({ error: {
 		code: "NOT_IN_AIORDIE_TAB",
 		message: "artifact tools only work inside an ai-or-die tab-backed Claude session. Missing AIORDIE_BASE_URL, AIORDIE_TOKEN, or AIORDIE_SESSION_ID."
 	} }, true);
 }
-function ok$1(value) {
-	return jsonResult$1(value, false);
+function ok$2(value) {
+	return jsonResult$2(value, false);
 }
-function jsonResult$1(value, isError) {
+function jsonResult$2(value, isError) {
 	return {
 		content: [{
 			type: "text",
@@ -1432,19 +1527,19 @@ function jsonResult$1(value, isError) {
 		...isError ? { isError: true } : {}
 	};
 }
-function errorResult$1(err) {
-	if (err instanceof ArtifactError) return jsonResult$1({ error: definedObject$1({
+function errorResult$2(err) {
+	if (err instanceof ArtifactError) return jsonResult$2({ error: definedObject$1({
 		code: err.code,
 		message: err.message,
 		retryable: err.retryable,
 		status: err.status
 	}) }, true);
-	return jsonResult$1({ error: {
-		code: errorCode$1(err),
+	return jsonResult$2({ error: {
+		code: errorCode$2(err),
 		message: err instanceof Error ? err.message : String(err)
 	} }, true);
 }
-function errorCode$1(err) {
+function errorCode$2(err) {
 	if (typeof err === "object" && err !== null && "code" in err) {
 		const code = err.code;
 		if (typeof code === "string") return code;
@@ -1456,7 +1551,7 @@ function definedObject$1(input) {
 	for (const [key, value] of Object.entries(input)) if (value !== void 0) result[key] = value;
 	return result;
 }
-function objectSchema$1(properties, required) {
+function objectSchema$2(properties, required) {
 	return {
 		type: "object",
 		required,
@@ -1464,7 +1559,7 @@ function objectSchema$1(properties, required) {
 		properties
 	};
 }
-function stringProp$1(description) {
+function stringProp$2(description) {
 	return {
 		type: "string",
 		description
@@ -1690,17 +1785,17 @@ function createTunnelTokenProvider(runner = realDevtunnelRunner()) {
 		async getToken(cfg) {
 			const key = cfg.tunnelId;
 			const now = Date.now();
-			const cached$1 = cache.get(key);
-			if (cached$1 && cached$1.expMs > now) {
-				const comfortablyFresh = cached$1.expMs - now > REFRESH_MARGIN_MS;
-				const recentlyMinted = now - cached$1.mintedAt < MIN_REMINT_INTERVAL_MS;
-				if (comfortablyFresh || recentlyMinted) return cached$1.token;
+			const cached$2 = cache.get(key);
+			if (cached$2 && cached$2.expMs > now) {
+				const comfortablyFresh = cached$2.expMs - now > REFRESH_MARGIN_MS;
+				const recentlyMinted = now - cached$2.mintedAt < MIN_REMINT_INTERVAL_MS;
+				if (comfortablyFresh || recentlyMinted) return cached$2.token;
 			}
 			const inf = inflight.get(key);
 			if (inf) return inf;
 			const bo = backoff.get(key);
 			if (bo && now < bo.until) {
-				if (cached$1 && cached$1.expMs > now) return cached$1.token;
+				if (cached$2 && cached$2.expMs > now) return cached$2.token;
 				throw bo.err;
 			}
 			const p = mintOnce(cfg);
@@ -2638,8 +2733,8 @@ function createFleetTools(options = {}) {
 	}
 	async function getInstanceCapabilities(instance, signal) {
 		const now = Date.now();
-		const cached$1 = capabilitiesCache.get(instance.id);
-		if (cached$1 && now - cached$1.at < CAPABILITIES_CACHE_TTL_MS) return cached$1.caps;
+		const cached$2 = capabilitiesCache.get(instance.id);
+		if (cached$2 && now - cached$2.at < CAPABILITIES_CACHE_TTL_MS) return cached$2.caps;
 		try {
 			const response = await clientFor(instance).capabilities(signal);
 			const caps = new Set(response.capabilities);
@@ -2664,10 +2759,10 @@ function createFleetTools(options = {}) {
 		return getRegistry().resolveInstance(arg);
 	}
 	async function resolveSession(args) {
-		const globalId = requiredString(args, "sessionId");
+		const globalId = requiredString$1(args, "sessionId");
 		const decoded = decodeSessionId(globalId);
 		const instance = await resolve(decoded.instanceId);
-		const explicitInstance = optionalString(args, "instance");
+		const explicitInstance = optionalString$1(args, "instance");
 		if (explicitInstance !== void 0) {
 			const explicit = await resolve(explicitInstance);
 			if (explicit.id !== decoded.instanceId) throw new FleetToolInputError("INSTANCE_MISMATCH", `sessionId is for instance ${JSON.stringify(decoded.instanceId)} but arguments.instance resolved to ${JSON.stringify(explicit.id)}`);
@@ -2681,8 +2776,8 @@ function createFleetTools(options = {}) {
 	async function probeInstance(info) {
 		const cacheKey = `${info.id}\0${info.url}`;
 		const now = Date.now();
-		const cached$1 = instanceProbeCache.get(cacheKey);
-		if (cached$1 && now - cached$1.at < INSTANCE_PROBE_CACHE_TTL_MS) return cached$1.result;
+		const cached$2 = instanceProbeCache.get(cacheKey);
+		if (cached$2 && now - cached$2.at < INSTANCE_PROBE_CACHE_TTL_MS) return cached$2.result;
 		for (let attempt = 0; attempt <= INSTANCE_PROBE_RATE_LIMIT_MAX_RETRIES; attempt++) {
 			const timeout = createProbeTimeout();
 			try {
@@ -2735,69 +2830,69 @@ function createFleetTools(options = {}) {
 				try {
 					return await handler(args, signal);
 				} catch (err) {
-					return errorResult(err);
+					return errorResult$1(err);
 				}
 			}
 		};
 	}
 	return Object.freeze([
-		tool$1("list_instances", "List registered remote ai-or-die instances in the fleet registry. Tokens are never returned.", objectSchema({}, []), async () => {
-			return ok({ instances: await mapWithConcurrency(await getRegistry().listInstances(), fleetFanoutConcurrency(LIST_INSTANCES_FANOUT_CONCURRENCY), (instance) => probeInstance(instance)) });
+		tool$1("list_instances", "List registered remote ai-or-die instances in the fleet registry. Tokens are never returned.", 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({ instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance.") }, []), async (args, signal) => {
-			const instance = await resolve(optionalString(args, "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) => {
+			const instance = await resolve(optionalString$1(args, "instance"));
 			const response = await clientFor(instance).listSessions(signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				sessions: response.sessions.map((session) => globalizeSession(instance.id, session))
 			});
 		}),
-		tool$1("read_session", "Read recent text output from an addressed fleet session.", objectSchema({
-			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
-			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
-			lines: numberProp("Number of recent lines to read."),
-			format: stringProp("Reserved for future formatting; results are JSON text today.")
+		tool$1("read_session", "Read recent text output from an addressed fleet session.", 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.")
 		}, ["sessionId"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
-			const lines = optionalNumber(args, "lines");
+			const lines = optionalNumber$1(args, "lines");
 			const response = await clientFor(instance).readSession(localId, lines, signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response,
 				sessionId: globalId
 			});
 		}),
-		tool$1("session_status", "Fetch lifecycle and interaction status for an addressed fleet session.", objectSchema({
-			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
-			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId.")
+		tool$1("session_status", "Fetch lifecycle and interaction status for an addressed fleet session.", 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) => {
 			const { instance, localId, globalId } = await resolveSession(args);
 			const response = await clientFor(instance).status(localId, signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response,
 				sessionId: globalId
 			});
 		}),
-		tool$1("send_message", "Send a message to a fleet session. isError reflects DELIVERY ONLY: it is true only when the message could not be delivered to the session (transport/precondition failure). 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. Recommended pattern: send with awaitMs:0 for a fast delivery ack that never blocks on confirmation, 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({
-			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
-			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
-			message: stringProp("Message text to deliver to the session."),
-			idempotencyKey: stringProp("Optional caller idempotency key; AUTO-GENERATED when omitted, so you normally never pass it. Supply your OWN stable key only when you will retry the SAME send and need the upstream to dedupe it."),
-			awaitMs: numberProp("Optional best-effort confirmation wait (ms) — NOT a deadline. Prefer awaitMs:0 plus await_turn; a turn that outruns awaitMs returns confirmationPending, not an error.")
+		tool$1("send_message", "Send a message to a fleet session. isError reflects DELIVERY ONLY: it is true only when the message could not be delivered to the session (transport/precondition failure). 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. Recommended pattern: send with awaitMs:0 for a fast delivery ack that never blocks on confirmation, 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({
+			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."),
+			idempotencyKey: stringProp$1("Optional caller idempotency key; AUTO-GENERATED when omitted, so you normally never pass it. Supply your OWN stable key only when you will retry the SAME send and need the upstream to dedupe it."),
+			awaitMs: numberProp$1("Optional best-effort confirmation wait (ms) — NOT a deadline. Prefer awaitMs:0 plus await_turn; a turn that outruns awaitMs returns confirmationPending, not an error.")
 		}, ["sessionId", "message"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
-			const awaitMs = optionalNumber(args, "awaitMs");
+			const awaitMs = optionalNumber$1(args, "awaitMs");
 			const response = await clientFor(instance).sendMessage(localId, {
-				message: requiredString(args, "message"),
-				idempotencyKey: optionalString(args, "idempotencyKey") ?? randomUUID(),
+				message: requiredString$1(args, "message"),
+				idempotencyKey: optionalString$1(args, "idempotencyKey") ?? randomUUID(),
 				...awaitMs === void 0 ? {} : { awaitMs }
 			}, signal);
 			const delivered = !(response.delivered === false || response.delivery?.status === "failed" || response.delivery?.status === "error");
 			const confirmed = delivered && response.confirmed === true;
 			const confirmationTimedOut = delivered && !confirmed && (awaitMs !== void 0 && awaitMs > 0 || response.confirmationTimedOut === true);
 			const isError = !delivered;
-			return jsonResult({
+			return jsonResult$1({
 				resolvedInstance: publicInstance(instance),
 				sessionId: globalId,
 				...response,
@@ -2810,111 +2905,111 @@ 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.", objectSchema({
-			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
-			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
-			keys: stringProp("Key sequence to send."),
-			idempotencyKey: stringProp("Optional caller idempotency key; auto-generated when omitted."),
+		tool$1("send_keys", "Send key input to a fleet session.", 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."),
+			keys: stringProp$1("Key sequence to send."),
+			idempotencyKey: stringProp$1("Optional caller idempotency key; auto-generated when omitted."),
 			raw: booleanProp("Pass keys through as raw input when the instance supports it.")
 		}, ["sessionId", "keys"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
 			const raw = optionalBoolean(args, "raw");
 			const response = await clientFor(instance).sendKeys(localId, {
-				keys: requiredString(args, "keys"),
-				idempotencyKey: optionalString(args, "idempotencyKey") ?? randomUUID(),
+				keys: requiredString$1(args, "keys"),
+				idempotencyKey: optionalString$1(args, "idempotencyKey") ?? randomUUID(),
 				...raw === void 0 ? {} : { raw }
 			}, signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				sessionId: globalId,
 				...response
 			});
 		}),
-		tool$1("respond", "Answer an awaited prompt in a fleet session by choice, option value, or explicit key override.", objectSchema({
-			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
-			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
-			choice: stringProp("Named or numbered choice to select."),
-			optionValue: stringProp("Exact option value to select."),
-			keys: stringProp("Explicit key override to send instead of a mapped choice."),
-			idempotencyKey: stringProp("Optional caller idempotency key; auto-generated when omitted.")
+		tool$1("respond", "Answer an awaited prompt in a fleet session by choice, option value, or explicit key override.", 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."),
+			optionValue: stringProp$1("Exact option value to select."),
+			keys: stringProp$1("Explicit key override to send instead of a mapped choice."),
+			idempotencyKey: stringProp$1("Optional caller idempotency key; auto-generated when omitted.")
 		}, ["sessionId"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
 			const input = definedObject({
-				choice: optionalString(args, "choice"),
-				optionValue: optionalString(args, "optionValue"),
-				keys: optionalString(args, "keys"),
-				idempotencyKey: optionalString(args, "idempotencyKey") ?? randomUUID()
+				choice: optionalString$1(args, "choice"),
+				optionValue: optionalString$1(args, "optionValue"),
+				keys: optionalString$1(args, "keys"),
+				idempotencyKey: optionalString$1(args, "idempotencyKey") ?? randomUUID()
 			});
 			const response = await clientFor(instance).respond(localId, input, signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				sessionId: globalId,
 				...response
 			});
 		}),
-		tool$1("create_session", "Create a new session on a specific fleet instance. The instance argument is required; no default is used.", objectSchema({
-			instance: stringProp("Required instance id or label. Create never uses the registry default."),
-			agent: stringProp("Agent/runtime to create on the instance."),
-			name: stringProp("Optional display name for the session."),
-			workingDir: stringProp("Optional working directory on the remote instance."),
-			idempotencyKey: stringProp("Optional caller idempotency key; auto-generated when omitted."),
+		tool$1("create_session", "Create a new session on a specific fleet instance. The instance argument is required; no default is used.", 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."),
+			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("F17: bounded ms to wait for the agent to become driveable before returning. The response carries ready/bound/blocker."),
-			permissionMode: stringProp("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."),
+			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.")
 		}, ["instance", "agent"]), async (args, signal) => {
-			const instance = await resolve(requiredString(args, "instance"));
-			const agent = requiredString(args, "agent");
-			const idempotencyKey = optionalString(args, "idempotencyKey") ?? randomUUID();
-			const permissionMode = optionalString(args, "permissionMode");
+			const instance = await resolve(requiredString$1(args, "instance"));
+			const agent = requiredString$1(args, "agent");
+			const idempotencyKey = optionalString$1(args, "idempotencyKey") ?? randomUUID();
+			const permissionMode = optionalString$1(args, "permissionMode");
 			const agentArgs = optionalStringArray(args, "agentArgs");
 			if (permissionMode !== void 0) await assertCapability(instance, "permission_mode", "permissionMode", signal);
 			if (agentArgs !== void 0) await assertCapability(instance, "agent_args", "agentArgs", signal);
 			const response = await clientFor(instance).createSession(definedObject({
 				agent,
-				name: optionalString(args, "name"),
-				workingDir: optionalString(args, "workingDir"),
+				name: optionalString$1(args, "name"),
+				workingDir: optionalString$1(args, "workingDir"),
 				start: optionalBoolean(args, "start"),
-				readyTimeoutMs: optionalNumber(args, "readyTimeoutMs"),
+				readyTimeoutMs: optionalNumber$1(args, "readyTimeoutMs"),
 				permissionMode,
 				agentArgs,
 				idempotencyKey
 			}), signal);
 			const localSessionId = typeof response.sessionId === "string" ? response.sessionId : "";
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response,
 				sessionId: localSessionId ? encodeSessionId(instance.id, localSessionId) : response.sessionId
 			});
 		}),
-		tool$1("stop_session", "Stop a fleet session.", objectSchema({
-			sessionId: stringProp("Global session id in the form instanceId:localSessionId."),
-			instance: stringProp("Optional instance id/label; when supplied it must agree with sessionId."),
-			idempotencyKey: stringProp("Optional caller idempotency key; auto-generated when omitted."),
-			mode: stringProp("Optional stop mode understood by the remote instance.")
+		tool$1("stop_session", "Stop a fleet session.", 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."),
+			mode: stringProp$1("Optional stop mode understood by the remote instance.")
 		}, ["sessionId"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
-			const idempotencyKey = optionalString(args, "idempotencyKey") ?? randomUUID();
+			const idempotencyKey = optionalString$1(args, "idempotencyKey") ?? randomUUID();
 			const response = await clientFor(instance).stopSession(localId, definedObject({
-				mode: optionalString(args, "mode"),
+				mode: optionalString$1(args, "mode"),
 				idempotencyKey
 			}), signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				sessionId: globalId,
 				...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({
+		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({
 			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("Long-poll timeout per instance in milliseconds."),
+			timeoutMs: numberProp$1("Long-poll timeout per instance in milliseconds."),
 			kinds: arrayProp("Optional event kinds to filter to."),
-			watcherId: stringProp("Optional stable id for this watcher. Use a distinct value for concurrent watchers over the same target set to keep cursors isolated.")
+			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) => {
 			const target = await resolveAwaitTarget(args, getRegistry());
-			const cursorByInstance = takeAwaitTurnCursorMap(awaitTurnCursorKey(optionalString(args, "watcherId")));
-			const timeoutMs = optionalNumber(args, "timeoutMs");
+			const cursorByInstance = takeAwaitTurnCursorMap(awaitTurnCursorKey(optionalString$1(args, "watcherId")));
+			const timeoutMs = optionalNumber$1(args, "timeoutMs");
 			const kinds = optionalStringArray(args, "kinds");
 			const results = await mapWithConcurrency(target.instances, fleetFanoutConcurrency(AWAIT_TURN_FANOUT_CONCURRENCY), async (instance) => {
 				const deadline = createAwaitTurnDeadline(timeoutMs, awaitTurnDeadlineSlackMs);
@@ -2957,7 +3052,7 @@ function createFleetTools(options = {}) {
 				instance: publicInstance(instance),
 				...gap
 			})));
-			return ok({
+			return ok$1({
 				resolvedInstances: target.instances.map(publicInstance),
 				events: events$1,
 				gaps,
@@ -2969,53 +3064,53 @@ function createFleetTools(options = {}) {
 				...errors.length > 0 ? { errors } : {}
 			});
 		}),
-		tool$1("read_file", "Read a file from one fleet instance via its existing /api/files/content endpoint.", objectSchema({
-			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
-			path: stringProp("Remote file path to read.")
+		tool$1("read_file", "Read a file from one fleet instance via its existing /api/files/content endpoint.", 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) => {
-			const instance = await resolve(optionalString(args, "instance"));
-			const response = await clientFor(instance).readFile(requiredString(args, "path"), signal);
-			return ok({
+			const instance = await resolve(optionalString$1(args, "instance"));
+			const response = await clientFor(instance).readFile(requiredString$1(args, "path"), signal);
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response
 			});
 		}),
-		tool$1("list_dir", "List a directory on one fleet instance via its existing /api/files endpoint.", objectSchema({
-			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
-			path: stringProp("Remote directory path to list.")
+		tool$1("list_dir", "List a directory on one fleet instance via its existing /api/files endpoint.", 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) => {
-			const instance = await resolve(optionalString(args, "instance"));
-			const response = await clientFor(instance).listDir(requiredString(args, "path"), signal);
-			return ok({
+			const instance = await resolve(optionalString$1(args, "instance"));
+			const response = await clientFor(instance).listDir(requiredString$1(args, "path"), signal);
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response
 			});
 		}),
-		tool$1("search", "Search files on one fleet instance via its existing /api/search endpoint.", objectSchema({
-			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
-			query: stringProp("Search query."),
-			path: stringProp("Optional path scope.")
+		tool$1("search", "Search files on one fleet instance via its existing /api/search endpoint.", 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.")
 		}, ["query"]), async (args, signal) => {
-			const instance = await resolve(optionalString(args, "instance"));
-			const response = await clientFor(instance).search(requiredString(args, "query"), optionalString(args, "path"), signal);
-			return ok({
+			const instance = await resolve(optionalString$1(args, "instance"));
+			const response = await clientFor(instance).search(requiredString$1(args, "query"), optionalString$1(args, "path"), signal);
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response
 			});
 		}),
-		tool$1("git_show", "Read a file/revision through one fleet instance's existing /api/files/git-show endpoint.", objectSchema({
-			instance: stringProp("Instance id or label. Defaults to the registry default, or the sole instance."),
-			path: stringProp("Remote repository path or file path for git-show."),
-			ref: stringProp("Optional git ref/revision."),
-			rev: stringProp("Optional git revision alias."),
-			commit: stringProp("Optional commit id.")
+		tool$1("git_show", "Read a file/revision through one fleet instance's existing /api/files/git-show endpoint.", 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.")
 		}, ["path"]), async (args, signal) => {
-			const instance = await resolve(optionalString(args, "instance"));
+			const instance = await resolve(optionalString$1(args, "instance"));
 			const response = await clientFor(instance).gitShow({
 				...args,
 				instance: void 0
 			}, signal);
-			return ok({
+			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				...response
 			});
@@ -3130,166 +3225,3293 @@ function isFleetErrorCode(code) {
 		default: return false;
 	}
 }
-async function resolveAwaitTarget(args, registry) {
-	const instanceArgs = optionalStringArray(args, "instances");
-	const sessionIdArgs = optionalStringArray(args, "sessionIds");
-	const localSessionIdsByInstance = /* @__PURE__ */ new Map();
-	for (const sessionId of sessionIdArgs ?? []) {
-		const decoded = decodeSessionId(sessionId);
-		const existing = localSessionIdsByInstance.get(decoded.instanceId) ?? [];
-		existing.push(decoded.localId);
-		localSessionIdsByInstance.set(decoded.instanceId, existing);
+async function resolveAwaitTarget(args, registry) {
+	const instanceArgs = optionalStringArray(args, "instances");
+	const sessionIdArgs = optionalStringArray(args, "sessionIds");
+	const localSessionIdsByInstance = /* @__PURE__ */ new Map();
+	for (const sessionId of sessionIdArgs ?? []) {
+		const decoded = decodeSessionId(sessionId);
+		const existing = localSessionIdsByInstance.get(decoded.instanceId) ?? [];
+		existing.push(decoded.localId);
+		localSessionIdsByInstance.set(decoded.instanceId, existing);
+	}
+	let instances;
+	if (instanceArgs !== void 0 && instanceArgs.length > 0) {
+		instances = uniqueInstances(await Promise.all(instanceArgs.map((arg) => registry.resolveInstance(arg))));
+		const ids = new Set(instances.map((instance) => instance.id));
+		for (const instanceId of localSessionIdsByInstance.keys()) if (!ids.has(instanceId)) throw new FleetToolInputError("INSTANCE_MISMATCH", `sessionIds include instance ${JSON.stringify(instanceId)} which is not in arguments.instances`);
+	} else if (localSessionIdsByInstance.size > 0) instances = uniqueInstances(await Promise.all([...localSessionIdsByInstance.keys()].map((instanceId) => registry.resolveInstance(instanceId))));
+	else {
+		const infos = await registry.listInstances();
+		if (infos.length === 0) throw new FleetRegistryError("INSTANCE_REQUIRED", "await_turn requires at least one registered fleet instance");
+		instances = uniqueInstances(await Promise.all(infos.map((info) => registry.resolveInstance(info.id))));
+	}
+	return {
+		instances,
+		localSessionIdsByInstance
+	};
+}
+function globalizeSession(instanceId, session) {
+	return {
+		...session,
+		sessionId: encodeSessionId(instanceId, session.sessionId)
+	};
+}
+function stampEvent(instance, event) {
+	return {
+		...event,
+		instance: publicInstance(instance),
+		...typeof event.sessionId === "string" ? { sessionId: encodeSessionId(instance.id, event.sessionId) } : {}
+	};
+}
+function eventAtMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const parsed = Date.parse(value);
+		if (!Number.isNaN(parsed)) return parsed;
+	}
+	return 0;
+}
+function compareStampedEvents(a, b) {
+	const atA = eventAtMs(a.at);
+	const atB = eventAtMs(b.at);
+	if (atA !== atB) return atA - atB;
+	return (typeof a.seq === "number" ? a.seq : 0) - (typeof b.seq === "number" ? b.seq : 0);
+}
+const MAX_WATCHER_ID_LEN = 200;
+const MAX_AWAIT_TURN_CURSOR_KEYS = 1024;
+function awaitTurnCursorKey(watcherId) {
+	const id = watcherId ?? "default";
+	return id.length > MAX_WATCHER_ID_LEN ? id.slice(0, MAX_WATCHER_ID_LEN) : id;
+}
+function takeAwaitTurnCursorMap(clientKey) {
+	const existing = awaitTurnCursors.get(clientKey);
+	if (existing) {
+		awaitTurnCursors.delete(clientKey);
+		awaitTurnCursors.set(clientKey, existing);
+		return existing;
+	}
+	const created = /* @__PURE__ */ new Map();
+	awaitTurnCursors.set(clientKey, created);
+	while (awaitTurnCursors.size > MAX_AWAIT_TURN_CURSOR_KEYS) {
+		const oldest = awaitTurnCursors.keys().next().value;
+		if (oldest === void 0) break;
+		awaitTurnCursors.delete(oldest);
+	}
+	return created;
+}
+function isAwaitTurnSuccess(result) {
+	return result.ok;
+}
+function isAwaitTurnFailure(result) {
+	return !result.ok;
+}
+function failedProbeResult(info, code) {
+	const hint = fleetProbeHint(code);
+	return {
+		id: info.id,
+		label: info.label,
+		reachable: false,
+		error: code,
+		...hint ? { hint } : {}
+	};
+}
+async function mapWithConcurrency(items, limit, fn) {
+	const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1;
+	const concurrency = Math.max(1, Math.min(items.length || 1, safeLimit));
+	const results = new Array(items.length);
+	let nextIndex = 0;
+	async function worker() {
+		while (nextIndex < items.length) {
+			const index = nextIndex++;
+			results[index] = await fn(items[index], index);
+		}
+	}
+	await Promise.all(Array.from({ length: concurrency }, () => worker()));
+	return results;
+}
+function fleetFanoutConcurrency(defaultLimit) {
+	const raw = process.env[FLEET_FANOUT_CONCURRENCY_ENV];
+	const parsed = raw === void 0 ? NaN : Number.parseInt(raw, 10);
+	if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+	return defaultLimit;
+}
+function probeRateLimitBackoffMs(attempt) {
+	return Math.min(INSTANCE_PROBE_RATE_LIMIT_BACKOFF_BASE_MS * 2 ** attempt, INSTANCE_PROBE_RATE_LIMIT_BACKOFF_MAX_MS);
+}
+function nonNegativeNumberOrDefault(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+async function delay(ms) {
+	if (ms <= 0) return;
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortLike(err) {
+	if (!(err instanceof Error)) return false;
+	return err.name === "AbortError" || err.name === "TimeoutError";
+}
+function uniqueInstances(instances) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const instance of instances) {
+		if (seen.has(instance.id)) continue;
+		seen.add(instance.id);
+		result.push(instance);
+	}
+	return result;
+}
+function publicInstance(instance) {
+	return {
+		id: instance.id,
+		label: instance.label
+	};
+}
+/**
+* Build the FleetClient tunnel-auth options for a resolved instance.
+* Resolution order: a `tunnelId` enables auto-mint + auto-refresh (and the
+* evict-on-failure hook); else a static `tunnelToken` is sent directly (no
+* retry, since it cannot be re-minted); else no tunnel auth.
+*/
+function tunnelClientOptions(instance, provider) {
+	if (instance.tunnelId) {
+		const cfg = { tunnelId: instance.tunnelId };
+		return {
+			getTunnelToken: () => provider.getToken(cfg),
+			onTunnelAuthInvalidate: () => provider.invalidate(cfg)
+		};
+	}
+	if (instance.tunnelToken) {
+		const token = instance.tunnelToken;
+		return { getTunnelToken: async () => token };
+	}
+	return {};
+}
+function ok$1(value) {
+	return jsonResult$1(value, false);
+}
+function jsonResult$1(value, isError) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value)
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function errorResult$1(err) {
+	return jsonResult$1({ error: {
+		code: errorCode$1(err),
+		message: err instanceof Error ? err.message : String(err)
+	} }, true);
+}
+function errorCode$1(err) {
+	if (typeof err === "object" && err !== null && "code" in err) {
+		const code = err.code;
+		if (typeof code === "string") return code;
+	}
+	return "FLEET_ERROR";
+}
+function definedObject(input) {
+	const result = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0) result[key] = value;
+	return result;
+}
+function requiredString$1(args, key) {
+	const value = args[key];
+	if (typeof value !== "string" || value.trim() === "") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} is required and must be a non-empty string`);
+	return value;
+}
+function optionalString$1(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a string`);
+	return value.trim() === "" ? void 0 : value;
+}
+function optionalNumber$1(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a finite number`);
+	return value;
+}
+function optionalBoolean(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "boolean") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a boolean`);
+	return value;
+}
+function optionalStringArray(args, key) {
+	const value = args[key];
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be an array of non-empty strings`);
+	return value;
+}
+function objectSchema$1(properties, required) {
+	return {
+		type: "object",
+		required,
+		additionalProperties: false,
+		properties
+	};
+}
+function stringProp$1(description) {
+	return {
+		type: "string",
+		description
+	};
+}
+function numberProp$1(description) {
+	return {
+		type: "number",
+		description
+	};
+}
+function booleanProp(description) {
+	return {
+		type: "boolean",
+		description
+	};
+}
+function arrayProp(description) {
+	return {
+		type: "array",
+		items: { type: "string" },
+		description
+	};
+}
+
+//#endregion
+//#region src/lib/agent/types.ts
+var AgentError = class extends Error {
+	code;
+	cause;
+	constructor(code, message, options) {
+		super(message);
+		this.name = "AgentError";
+		this.code = code;
+		this.cause = options?.cause;
+	}
+};
+
+//#endregion
+//#region src/lib/agent/rest.ts
+function restHeaders(apiVersion, extra) {
+	const headers = githubAgentHeaders(state);
+	if (apiVersion) headers["x-github-api-version"] = apiVersion;
+	if (extra) Object.assign(headers, extra);
+	return headers;
+}
+async function ghRestRaw(method, path$1, opts = {}) {
+	const url = `${GITHUB_API_BASE_URL}${path$1}`;
+	const requestInit = {
+		method,
+		headers: restHeaders(opts.apiVersion, opts.headers),
+		signal: opts.signal
+	};
+	if (opts.body !== void 0) requestInit.body = JSON.stringify(opts.body);
+	try {
+		if (opts.retry === false) return await fetch(url, requestInit);
+		return await fetchWithTransientRetry(() => fetch(url, requestInit), {
+			label: `github-rest ${method} ${path$1}`,
+			signal: opts.signal
+		});
+	} catch (err) {
+		consola.warn(`GitHub REST ${method} ${path$1} failed before response`, err);
+		throw new AgentError("UPSTREAM", `GitHub REST ${method} ${path$1} failed`, { cause: err });
+	}
+}
+function rateLimitMessage(response) {
+	const reset = response.headers.get("x-ratelimit-reset");
+	const retryAfter = response.headers.get("retry-after");
+	return `GitHub API rate limit exceeded${reset ? `; reset at ${reset}` : retryAfter ? `; retry after ${retryAfter}s` : ""}`;
+}
+function agentErrorFromResponse(response, message = `GitHub API request failed with HTTP ${response.status}`) {
+	let code;
+	let errorMessage = message;
+	if (response.status === 401) {
+		code = "AUTH_REVOKED";
+		errorMessage = "GitHub agent token was revoked or is invalid";
+	} else if (response.status === 403 && response.headers.get("x-ratelimit-remaining") === "0") {
+		code = "RATE_LIMITED";
+		errorMessage = rateLimitMessage(response);
+	} else if (response.status === 403) {
+		code = "NO_WRITE_ACCESS";
+		errorMessage = "GitHub agent token does not have write access";
+	} else if (response.status === 404) {
+		code = "NOT_FOUND";
+		errorMessage = "GitHub resource was not found";
+	} else if (response.status === 429) {
+		code = "RATE_LIMITED";
+		errorMessage = rateLimitMessage(response);
+	} else code = "UPSTREAM";
+	return new AgentError(code, errorMessage, { cause: new HTTPError(errorMessage, response) });
+}
+async function parseJsonOrEmpty(response) {
+	if (response.status === 204) return {};
+	const text = await response.text();
+	if (!text.trim()) return {};
+	try {
+		return JSON.parse(text);
+	} catch (err) {
+		throw new AgentError("UPSTREAM", "GitHub API returned invalid JSON", { cause: err });
+	}
+}
+async function ghRest(method, path$1, opts = {}) {
+	const response = await ghRestRaw(method, path$1, opts);
+	if (!response.ok) throw agentErrorFromResponse(response);
+	return parseJsonOrEmpty(response);
+}
+
+//#endregion
+//#region src/lib/agent/graphql.ts
+function graphQLErrorMessage(error) {
+	return String(error.message ?? error.type ?? error.extensions?.code ?? "GraphQL error");
+}
+function isFeatureError(error) {
+	const message = String(error.message ?? "").toLowerCase();
+	const type = String(error.type ?? "").toLowerCase();
+	const code = String(error.extensions?.code ?? "").toLowerCase();
+	const haystack = `${message} ${type} ${code}`;
+	if (haystack.includes("unknown feature") || haystack.includes("disabled feature") || haystack.includes("feature flag") || haystack.includes("graphql-features") || haystack.includes("issues_copilot_assignment_api_support") || haystack.includes("does not exist on type") || haystack.includes("cannot query field") || haystack.includes("undefined field")) return true;
+	return (type.includes("forbidden") || code.includes("forbidden")) && (message.includes("feature") || message.includes("preview") || message.includes("copilot assignment"));
+}
+async function parseGraphQLJson(response) {
+	const text = await response.text();
+	if (!text.trim()) return {};
+	try {
+		return JSON.parse(text);
+	} catch (err) {
+		throw new AgentError("UPSTREAM", "GitHub GraphQL returned invalid JSON", { cause: err });
+	}
+}
+async function ghGraphQL(query, variables, opts = {}) {
+	let response;
+	try {
+		response = await fetchWithTransientRetry(() => fetch(GITHUB_GRAPHQL_URL, {
+			method: "POST",
+			headers: githubAgentGraphQLHeaders(state, opts.features),
+			body: JSON.stringify({
+				query,
+				variables
+			}),
+			signal: opts.signal
+		}), {
+			label: "github-graphql",
+			signal: opts.signal
+		});
+	} catch (err) {
+		consola.warn("GitHub GraphQL failed before response", err);
+		throw new AgentError("UPSTREAM", "GitHub GraphQL request failed", { cause: err });
+	}
+	if (!response.ok) throw agentErrorFromResponse(response, "GitHub GraphQL request failed");
+	const payload = await parseGraphQLJson(response);
+	const errors = payload.errors?.filter(Boolean) ?? [];
+	if (errors.length > 0) {
+		const message = errors.map(graphQLErrorMessage).join("; ");
+		if (errors.some(isFeatureError)) throw new AgentError("GRAPHQL_FEATURE", message);
+		throw new AgentError("UPSTREAM", message);
+	}
+	if (payload.data === void 0) throw new AgentError("UPSTREAM", "GitHub GraphQL response did not include data");
+	return payload.data;
+}
+
+//#endregion
+//#region src/lib/agent/service.ts
+const CACHE_TTL_MS = 300 * 1e3;
+const CHECK_SUMMARY_LIMIT = 20;
+const FAILING_CHECK_LIMIT = 5;
+const AGENT_LOGIN_MATCHERS = {
+	copilot: /^copilot(-swe-agent)?$/i,
+	anthropic: /^anthropic-code-agent$/i,
+	openai: /^openai-code-agent$/i
+};
+const rosterCache = /* @__PURE__ */ new Map();
+function repoCacheKey(repo) {
+	return `${repo.owner.toLowerCase()}/${repo.repo.toLowerCase()}`;
+}
+function cached$1(entry) {
+	if (!entry) return void 0;
+	if (Date.now() - entry.timestamp > CACHE_TTL_MS) return void 0;
+	return entry.value;
+}
+function segment$1(value) {
+	return encodeURIComponent(String(value));
+}
+function repoPath(repo) {
+	return `/repos/${segment$1(repo.owner)}/${segment$1(repo.repo)}`;
+}
+function botAssigneeLogin(login) {
+	return login.toLowerCase().endsWith("[bot]") ? login : `${login}[bot]`;
+}
+/** Classify a GitHub login to an agent key via the roster matchers, or null. */
+function agentKeyForLogin(login) {
+	const normalized = login.replace(/\[bot\]$/i, "");
+	for (const [key, matcher] of Object.entries(AGENT_LOGIN_MATCHERS)) if (matcher.test(normalized)) return key;
+	return null;
+}
+function authorMatchesBot(authorLogin, botLogin) {
+	if (!authorLogin) return false;
+	const author = authorLogin.toLowerCase();
+	if (author === botLogin.toLowerCase() || author === botAssigneeLogin(botLogin).toLowerCase()) return true;
+	const authorKey = agentKeyForLogin(authorLogin);
+	return authorKey !== null && authorKey === agentKeyForLogin(botLogin);
+}
+function asRecord$7(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function stringValue$2(value) {
+	return typeof value === "string" ? value : void 0;
+}
+async function readJsonObject(response) {
+	const text = await response.text();
+	if (!text.trim()) return {};
+	try {
+		return asRecord$7(JSON.parse(text)) ?? {};
+	} catch (err) {
+		throw new AgentError("UPSTREAM", "GitHub API returned invalid JSON", { cause: err });
+	}
+}
+async function resolveAgentRoster(repo) {
+	const key = repoCacheKey(repo);
+	const cacheEntry = rosterCache.get(key);
+	const roster = cached$1(cacheEntry ? {
+		timestamp: cacheEntry.timestamp,
+		value: cacheEntry.roster
+	} : void 0);
+	if (roster) return roster;
+	const data = await ghGraphQL(`query FirstMateSuggestedActors($owner: String!, $name: String!) {
+      repository(owner: $owner, name: $name) {
+        suggestedActors(capabilities: [CAN_BE_ASSIGNED], first: 100) {
+          nodes {
+            login
+            __typename
+            ... on Bot {
+              id
+            }
+          }
+        }
+      }
+    }`, {
+		owner: repo.owner,
+		name: repo.repo
+	});
+	const nextRoster = /* @__PURE__ */ new Map();
+	for (const node of data.repository?.suggestedActors?.nodes ?? []) {
+		if (!node.login || !node.id || node.__typename !== "Bot") continue;
+		for (const [agentKey, matcher] of Object.entries(AGENT_LOGIN_MATCHERS)) {
+			if (!matcher.test(node.login)) continue;
+			if (!nextRoster.has(agentKey)) nextRoster.set(agentKey, {
+				login: node.login,
+				botId: node.id
+			});
+		}
+	}
+	rosterCache.set(key, {
+		timestamp: Date.now(),
+		roster: nextRoster
+	});
+	return nextRoster;
+}
+async function resolveAgentActor(repo, key) {
+	const roster = await resolveAgentRoster(repo);
+	const actor = roster.get(key);
+	if (actor) return actor;
+	const available = [...roster.keys()].join(", ") || "none";
+	throw new AgentError("AGENT_NOT_AVAILABLE", `Agent ${key} is not available for ${repo.owner}/${repo.repo}; available: ${available}`);
+}
+async function createIssue(repo, input) {
+	const issue = await ghRest("POST", `${repoPath(repo)}/issues`, { body: {
+		title: input.title,
+		body: input.body
+	} });
+	return {
+		number: issue.number ?? 0,
+		nodeId: issue.node_id ?? "",
+		url: issue.html_url ?? issue.url ?? ""
+	};
+}
+async function assignAgent(repo, input) {
+	try {
+		await ghGraphQL(`mutation FirstMateAssignAgent($issueNodeId: ID!, $botId: ID!) {
+        replaceActorsForAssignable(input: {
+          assignableId: $issueNodeId,
+          actorIds: [$botId]
+        }) {
+          assignable {
+            ... on Issue {
+              id
+            }
+          }
+        }
+      }`, {
+			issueNodeId: input.issueNodeId,
+			botId: input.botId
+		}, { features: "issues_copilot_assignment_api_support" });
+		return {
+			assigned: true,
+			via: "graphql"
+		};
+	} catch (graphqlErr) {
+		const reason = graphqlErr instanceof AgentError ? graphqlErr.code : "unknown";
+		consola.debug(`GraphQL assignment failed (${reason}); trying REST fallback`);
+		try {
+			await ghRest("POST", `${repoPath(repo)}/issues/${segment$1(input.issueNumber)}/assignees`, { body: { assignees: [botAssigneeLogin(input.botLogin)] } });
+			return {
+				assigned: true,
+				via: "rest"
+			};
+		} catch (restErr) {
+			throw new AgentError("ASSIGN_FAILED", "Failed to assign agent to issue", { cause: {
+				graphqlErr,
+				restErr
+			} });
+		}
+	}
+}
+async function findAgentPRs(repo, input) {
+	input.issueNumber;
+	return (await ghRest("GET", `${repoPath(repo)}/pulls?state=all&per_page=100`)).filter((pull) => {
+		if (input.branch !== void 0 && input.branch.length > 0) return pull.head?.ref === input.branch;
+		return authorMatchesBot(pull.user?.login ?? void 0, input.botLogin);
+	}).map((pull) => ({
+		number: pull.number ?? 0,
+		headSha: pull.head?.sha ?? "",
+		headRef: pull.head?.ref ?? "",
+		isDraft: pull.draft ?? false
+	}));
+}
+const COPILOT_REVIEWER_LOGIN = "copilot-pull-request-reviewer[bot]";
+/**
+* Request a code review from `reviewerLogin` on a PR. Best-effort: a 422
+* (already requested / not a collaborator) or any other error is swallowed and
+* reported as `requested:false` — a failed review request must not abort the
+* controller sweep.
+*/
+async function requestReview(repo, pr, reviewerLogin) {
+	try {
+		await ghRest("POST", `${repoPath(repo)}/pulls/${segment$1(pr)}/requested_reviewers`, { body: { reviewers: [reviewerLogin] } });
+		return { requested: true };
+	} catch (err) {
+		consola.debug(`first-mate: requestReview(${reviewerLogin}) on PR #${pr} skipped:`, err);
+		return { requested: false };
+	}
+}
+const REVIEW_BODY_LIMIT = 4e3;
+/** Compact review summaries for a PR (author + state + hard-truncated body). */
+async function getPullRequestReviews(repo, pr) {
+	return (await ghRest("GET", `${repoPath(repo)}/pulls/${segment$1(pr)}/reviews?per_page=50`) ?? []).map((review) => ({
+		author: review.user?.login ?? "",
+		state: review.state ?? "",
+		bodyExcerpt: (review.body ?? "").slice(0, REVIEW_BODY_LIMIT),
+		...review.submitted_at ? { submittedAt: review.submitted_at } : {},
+		...review.commit_id ? { commitId: review.commit_id } : {}
+	}));
+}
+async function getPullRequestState(repo, pr) {
+	const pullRequest = (await ghGraphQL(`query FirstMatePullRequestState($owner: String!, $name: String!, $number: Int!) {
+      repository(owner: $owner, name: $name) {
+        pullRequest(number: $number) {
+          id
+          number
+          title
+          isDraft
+          state
+          mergeable
+          reviewDecision
+          headRefOid
+          baseRefName
+          baseRefOid
+          author {
+            login
+          }
+        }
+      }
+    }`, {
+		owner: repo.owner,
+		name: repo.repo,
+		number: pr
+	})).repository?.pullRequest;
+	if (!pullRequest) throw new AgentError("NOT_FOUND", `Pull request #${pr} was not found`);
+	let baseSha = pullRequest.baseRefOid ?? void 0;
+	let baseRef = pullRequest.baseRefName ?? "";
+	if (!baseSha || !baseRef) {
+		const restPull = await ghRest("GET", `${repoPath(repo)}/pulls/${segment$1(pr)}`);
+		baseSha = baseSha ?? restPull.base?.sha ?? void 0;
+		baseRef = baseRef || restPull.base?.ref || "";
+	}
+	return {
+		number: pullRequest.number ?? pr,
+		title: pullRequest.title ?? "",
+		isDraft: pullRequest.isDraft ?? false,
+		state: pullRequest.state ?? "UNKNOWN",
+		mergeable: pullRequest.mergeable,
+		reviewDecision: pullRequest.reviewDecision,
+		headSha: pullRequest.headRefOid ?? "",
+		baseRef,
+		baseSha,
+		authorLogin: pullRequest.author?.login ?? void 0,
+		nodeId: pullRequest.id ?? void 0
+	};
+}
+function isFailingConclusion(conclusion) {
+	return [
+		"action_required",
+		"cancelled",
+		"failure",
+		"startup_failure",
+		"timed_out"
+	].includes(conclusion ?? "");
+}
+async function getRequiredChecksForSha(repo, sha) {
+	const checkRuns = ((await ghRest("GET", `${repoPath(repo)}/commits/${segment$1(sha)}/check-runs`)).check_runs ?? []).filter((check) => !/pull-request-reviewer/i.test(check.name ?? ""));
+	const runningCount = checkRuns.filter((check) => check.status !== "completed" || !check.conclusion).length;
+	const failingRuns = checkRuns.filter((check) => isFailingConclusion(check.conclusion));
+	let rollup = "none";
+	if (checkRuns.length > 0) if (failingRuns.length > 0) rollup = "failing";
+	else if (runningCount > 0) rollup = "pending";
+	else rollup = "passing";
+	const checks = checkRuns.slice(0, CHECK_SUMMARY_LIMIT).map((check) => ({
+		id: check.id ?? 0,
+		name: check.name ?? "",
+		conclusion: check.conclusion
+	}));
+	const failing = failingRuns.slice(0, FAILING_CHECK_LIMIT).map((check) => ({
+		name: check.name ?? "",
+		url: check.html_url ?? check.details_url ?? void 0
+	}));
+	return {
+		rollup,
+		checks,
+		failing,
+		runningCount
+	};
+}
+const workflowCache = /* @__PURE__ */ new Map();
+/**
+* Whether the repo has any GitHub Actions workflow on `ref`. Lets the
+* controller distinguish "genuinely no CI" (route to cross-lab verify) from
+* "CI configured but checks not registered yet" (keep waiting) when a commit's
+* check-run rollup is "none". Cached per repo+ref; a 404 (no dir) means no CI.
+*/
+async function repoHasWorkflows(repo, ref) {
+	const key = `${repoPath(repo)}@${ref}`;
+	const hit = cached$1(workflowCache.get(key));
+	if (hit !== void 0) return hit;
+	let value = false;
+	try {
+		const entries = await ghRest("GET", `${repoPath(repo)}/contents/.github/workflows?ref=${segment$1(ref)}`);
+		value = Array.isArray(entries) && entries.some((entry) => entry.type === "file" && /\.ya?ml$/i.test(entry.name ?? ""));
+	} catch (err) {
+		if (!(err instanceof AgentError && err.code === "NOT_FOUND")) consola.debug("first-mate: workflow probe failed, assuming no CI:", err);
+		value = false;
+	}
+	workflowCache.set(key, {
+		timestamp: Date.now(),
+		value
+	});
+	return value;
+}
+async function postComment(repo, number, body) {
+	const comment = await ghRest("POST", `${repoPath(repo)}/issues/${segment$1(number)}/comments`, { body: { body } });
+	return { url: comment.html_url ?? comment.url ?? "" };
+}
+async function submitReview(repo, pr, event, body) {
+	const requestBody = { event };
+	if (body !== void 0) requestBody.body = body;
+	const review = await ghRest("POST", `${repoPath(repo)}/pulls/${segment$1(pr)}/reviews`, { body: requestBody });
+	return {
+		reviewId: review.id ?? 0,
+		state: review.state ?? ""
+	};
+}
+async function rerunChecks(repo, input) {
+	const suffix = input.failedOnly ? "rerun-failed-jobs" : "rerun";
+	const response = await ghRestRaw("POST", `${repoPath(repo)}/actions/runs/${segment$1(input.runId)}/${suffix}`);
+	if (!response.ok) throw agentErrorFromResponse(response, "Rerun checks failed");
+	return { rerun: true };
+}
+async function mergePullRequest(repo, input) {
+	const response = await ghRestRaw("PUT", `${repoPath(repo)}/pulls/${segment$1(input.pr)}/merge`, { body: {
+		merge_method: input.method ?? "squash",
+		sha: input.expectedHeadSha
+	} });
+	if (response.status === 405 || response.status === 409) throw new AgentError("HEAD_MOVED", "Pull request head moved or is not mergeable");
+	if (!response.ok) throw agentErrorFromResponse(response, "Pull request merge failed");
+	const result = await readJsonObject(response);
+	if (result.merged === false) throw new AgentError("UPSTREAM", stringValue$2(result.message) ?? "GitHub did not merge the pull request");
+	return {
+		merged: true,
+		sha: stringValue$2(result.sha) ?? ""
+	};
+}
+async function markReadyForReview(prNodeId) {
+	await ghGraphQL(`mutation FirstMateReadyForReview($pullRequestId: ID!) {
+      markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) {
+        pullRequest {
+          id
+        }
+      }
+    }`, { pullRequestId: prNodeId });
+	return { ready: true };
+}
+
+//#endregion
+//#region src/lib/agent/capi.ts
+const CAPI_INTEGRATION_ID = "copilot-4-cli";
+const CAPI_API_VERSION = "2026-01-09";
+const HOST_CACHE_TTL_MS = 600 * 1e3;
+const LOG_EXCERPT_LIMIT$1 = 4e3;
+const TRUNCATED_MARKER$1 = "…[truncated]…";
+const MAX_LOG_BYTES = 4 * 1024 * 1024;
+const MAX_FIELD_CHARS = 256 * 1024;
+let hostCache = null;
+async function discoverCapiHost(signal) {
+	const now = Date.now();
+	if (hostCache && now - hostCache.at < HOST_CACHE_TTL_MS) return hostCache.host;
+	try {
+		const host = (await ghGraphQL("query CopilotEndpoints { viewer { copilotEndpoints { api } } }", {}, { signal })).viewer?.copilotEndpoints?.api;
+		if (typeof host === "string" && host.length > 0) {
+			const normalized = host.replace(/\/+$/, "");
+			if (!isAllowedCopilotHost(normalized)) {
+				consola.debug(`first-mate capi: discovered host not allowlisted: ${normalized}`);
+				return null;
+			}
+			hostCache = {
+				host: normalized,
+				at: now
+			};
+			return hostCache.host;
+		}
+		consola.debug("first-mate capi: discovery returned no host");
+	} catch (err) {
+		consola.debug("first-mate capi: host discovery failed:", err);
+	}
+	return null;
+}
+function capiHeaders() {
+	return {
+		authorization: `Bearer ${state.githubAgentToken ?? ""}`,
+		"copilot-integration-id": CAPI_INTEGRATION_ID,
+		"x-github-api-version": CAPI_API_VERSION,
+		"user-agent": "github-router-first-mate"
+	};
+}
+function asRecord$6(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function truncateHead(text) {
+	if (text.length <= LOG_EXCERPT_LIMIT$1) return text;
+	return `${text.slice(0, LOG_EXCERPT_LIMIT$1 - 13)}${TRUNCATED_MARKER$1}`;
+}
+const PLAN_LIMIT = 2800;
+const PROGRESS_LIMIT = 900;
+function headTruncate(text, limit) {
+	if (text.length <= limit) return text;
+	return `${text.slice(0, limit - 13)}${TRUNCATED_MARKER$1}`;
+}
+function tailTruncate(text, limit) {
+	if (text.length <= limit) return text;
+	return `${TRUNCATED_MARKER$1}${text.slice(-(limit - 13))}`;
+}
+/** Extract a `<plan>…</plan>` block (the plan-mode agent wraps its plan in it). */
+function extractPlanBlock(text) {
+	const inner = /<plan>([\s\S]*?)<\/plan>/i.exec(text)?.[1]?.trim();
+	return inner && inner.length > 0 ? inner : null;
+}
+/** Extract the branch the agent checked out ("checked out branch X"). */
+function extractBranch(text) {
+	const branch = /checked out branch\s+([a-z0-9][a-z0-9._/-]*)/.exec(text)?.[1]?.replace(/[.\-_/]+$/, "");
+	return branch && branch.length > 0 ? branch : void 0;
+}
+/**
+* Drop the agent's MCP-server registration preamble. Every cloud-agent session
+* emits a large, signal-free tool-registration dump ("MCP server started
+* successfully with N tools", "- github-mcp-server/actions_get", …) at the
+* START, which would otherwise dominate a head-truncated excerpt and bury the
+* actual plan/progress that lands at the tail.
+*/
+function stripMcpBoilerplate(text) {
+	return text.split("\n").filter((line) => {
+		const l = line.trim();
+		if (/^MCP server started successfully/i.test(l)) return false;
+		if (/^-\s+(runtime-tools|github-mcp-server)\//i.test(l)) return false;
+		return true;
+	}).join("\n");
+}
+/** Append with a per-field cap; once at the cap, further growth is dropped. */
+function capped(current, addition) {
+	if (current.length >= MAX_FIELD_CHARS) return current;
+	const room = MAX_FIELD_CHARS - current.length;
+	return current + (addition.length > room ? addition.slice(0, room) : addition);
+}
+/**
+* Read a response body as text, capped at `MAX_LOG_BYTES`. Stops pulling once
+* the cap is reached (a runaway/untrusted stream must not exhaust memory).
+*/
+async function readCappedText(response) {
+	const body = response.body;
+	if (!body) return response.text();
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let text = "";
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			text += decoder.decode(value, { stream: true });
+			if (text.length >= MAX_LOG_BYTES) {
+				reader.cancel().catch(() => {});
+				break;
+			}
+		}
+		text += decoder.decode();
+	} catch (err) {
+		consola.debug("first-mate capi: capped read interrupted:", err);
+	}
+	return text.length > MAX_LOG_BYTES ? text.slice(0, MAX_LOG_BYTES) : text;
+}
+/**
+* Parse the SSE body of a session-log stream into a compact excerpt. Tolerant
+* of partial/incomplete streams (an in-progress agent) and SSE-compliant for
+* multi-line `data:` events (a single event's `data:` lines are joined with
+* `\n` before parsing). `finished` reflects whether a terminal chunk was seen.
+* All log content is UNTRUSTED agent text.
+*/
+function parseSessionLog(body) {
+	let content = "";
+	let reasoning = "";
+	let finished = false;
+	const toolNames = [];
+	const toolCalls = /* @__PURE__ */ new Map();
+	const events$1 = body.replace(/\r\n/g, "\n").split(/\n\n+/);
+	for (const event of events$1) {
+		const dataLines = [];
+		for (const rawLine of event.split("\n")) {
+			const line = rawLine.trimEnd();
+			if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+		}
+		if (dataLines.length === 0) continue;
+		const payload = dataLines.join("\n").trim();
+		if (!payload || payload === "[DONE]") continue;
+		let chunk;
+		try {
+			chunk = asRecord$6(JSON.parse(payload));
+		} catch {
+			continue;
+		}
+		if (!chunk || chunk.object !== "chat.completion.chunk") continue;
+		const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+		for (const choiceValue of choices) {
+			const choice = asRecord$6(choiceValue);
+			if (!choice) continue;
+			const delta = asRecord$6(choice.delta) ?? {};
+			if (typeof delta.content === "string") content = capped(content, delta.content);
+			if (typeof delta.reasoning_text === "string") reasoning = capped(reasoning, delta.reasoning_text);
+			if (choice.finish_reason === "stop") finished = true;
+			const toolCallDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+			for (const tcValue of toolCallDeltas) {
+				const call = asRecord$6(tcValue);
+				if (!call) continue;
+				const index = typeof call.index === "number" ? call.index : toolCalls.size;
+				const fn = asRecord$6(call.function) ?? {};
+				const existing = toolCalls.get(index) ?? { args: "" };
+				if (typeof fn.name === "string" && fn.name.length > 0) {
+					existing.name = fn.name;
+					toolNames.push(fn.name);
+				}
+				if (typeof fn.arguments === "string") existing.args = capped(existing.args, fn.arguments);
+				toolCalls.set(index, existing);
+			}
+		}
+	}
+	let planDescription = "";
+	for (const call of toolCalls.values()) {
+		if (call.name !== "report_progress") continue;
+		try {
+			const parsed = asRecord$6(JSON.parse(call.args));
+			const desc = parsed?.prDescription ?? parsed?.pr_description;
+			if (typeof desc === "string" && desc.length > planDescription.length) planDescription = desc;
+		} catch {}
+	}
+	const uniqueTools = [...new Set(toolNames)];
+	const planBlock = extractPlanBlock(content);
+	const plan = planDescription.trim() || planBlock || "";
+	const progress = stripMcpBoilerplate(planBlock ? content.replace(/<plan>[\s\S]*?<\/plan>/i, "") : content).trim();
+	const parts = [];
+	if (plan) parts.push(`Plan:\n${headTruncate(plan, PLAN_LIMIT)}`);
+	if (reasoning.trim()) parts.push(`Reasoning:\n${tailTruncate(reasoning.trim(), PROGRESS_LIMIT)}`);
+	if (progress) parts.push(`Progress:\n${tailTruncate(progress, PROGRESS_LIMIT)}`);
+	if (uniqueTools.length > 0) parts.push(`Tools: ${uniqueTools.join(", ")}`);
+	const branch = extractBranch(content);
+	return {
+		excerpt: truncateHead(parts.join("\n\n")),
+		finished,
+		tools: uniqueTools,
+		...branch ? { branch } : {}
+	};
+}
+/**
+* Fetch and distil a cloud-agent session log. Best-effort: returns `null`
+* (never throws) when the agent token is absent, the host can't be discovered
+* or validated, or the request fails — callers fall back to the
+* `api.github.com` task text.
+*/
+async function getSessionLog(sessionId, signal) {
+	if (!state.githubAgentToken || !sessionId) return null;
+	const host = await discoverCapiHost(signal);
+	if (!host) return null;
+	const url = `${host}/agents/sessions/${encodeURIComponent(sessionId)}/logs`;
+	let response;
+	try {
+		response = await fetchWithTransientRetry(() => fetch(url, {
+			headers: capiHeaders(),
+			signal,
+			redirect: "error"
+		}), {
+			label: `capi session-log ${sessionId}`,
+			signal
+		});
+	} catch (err) {
+		consola.debug("first-mate capi: session-log fetch failed:", err);
+		return null;
+	}
+	if (!response.ok) {
+		consola.debug(`first-mate capi: session-log ${sessionId} → HTTP ${response.status}`);
+		return null;
+	}
+	try {
+		return parseSessionLog(await readCappedText(response));
+	} catch (err) {
+		consola.debug("first-mate capi: session-log parse failed:", err);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/lib/agent/tasks.ts
+const AGENT_TASKS_API_VERSION = "2026-03-10";
+const LOG_EXCERPT_LIMIT = 4e3;
+const TRUNCATED_MARKER = "…[truncated]…";
+const FOLLOW_UP_TASK_PATH_SUFFIX = "";
+const CANCEL_TASK_PATH_SUFFIX = "/cancel";
+function segment(value) {
+	return encodeURIComponent(String(value));
+}
+function repoTasksPath(repo) {
+	return `/agents/repos/${segment(repo.owner)}/${segment(repo.repo)}/tasks`;
+}
+function taskPath(repo, taskId) {
+	return `${repoTasksPath(repo)}/${segment(taskId)}`;
+}
+function asRecord$5(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function stringField(record, keys) {
+	for (const key of keys) {
+		const value = record?.[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
+function numberField(record, keys) {
+	for (const key of keys) {
+		const value = record?.[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+}
+function collectText(record) {
+	if (!record) return [];
+	const nested = [
+		asRecord$5(record.task),
+		asRecord$5(record.session),
+		asRecord$5(record.progress),
+		asRecord$5(record.result)
+	];
+	const textKeys = [
+		"session_log",
+		"sessionLog",
+		"log",
+		"logs",
+		"progress",
+		"plan",
+		"summary",
+		"status_text",
+		"statusText",
+		"message"
+	];
+	const chunks = [];
+	for (const candidate of [record, ...nested]) for (const key of textKeys) {
+		const value = candidate?.[key];
+		if (typeof value === "string" && value.trim().length > 0) chunks.push(value);
+	}
+	return chunks;
+}
+function compactKnownKeysSummary(record) {
+	if (!record) return "preview task response was not an object";
+	const keys = Object.keys(record).slice(0, 30);
+	return `preview task response keys: ${JSON.stringify(keys)}`;
+}
+function tailExcerpt(text) {
+	if (text.length <= LOG_EXCERPT_LIMIT) return text;
+	return `${TRUNCATED_MARKER}${text.slice(-(LOG_EXCERPT_LIMIT - 13))}`;
+}
+function taskPrUrl(record) {
+	const direct = stringField(record, [
+		"pr_url",
+		"prUrl",
+		"pull_request_url",
+		"pullRequestUrl"
+	]);
+	if (direct) return direct;
+	return stringField(asRecord$5(record?.pull_request) ?? asRecord$5(record?.pullRequest), ["html_url", "url"]);
+}
+function taskPrNumber$1(record) {
+	const direct = numberField(record, [
+		"pr",
+		"pr_number",
+		"prNumber",
+		"pull_request_number"
+	]);
+	if (direct !== void 0) return direct;
+	return numberField(asRecord$5(record?.pull_request) ?? asRecord$5(record?.pullRequest), ["number"]) ?? void 0;
+}
+function latestSessionId(record) {
+	const sessions$1 = record?.sessions;
+	if (!Array.isArray(sessions$1) || sessions$1.length === 0) return void 0;
+	for (let i = sessions$1.length - 1; i >= 0; i -= 1) {
+		const id = stringField(asRecord$5(sessions$1[i]), [
+			"id",
+			"session_id",
+			"sessionId"
+		]);
+		if (id) return id;
+	}
+}
+async function startTask(repo, input) {
+	const body = { prompt: input.prompt };
+	if (input.baseRef !== void 0) body.base_ref = input.baseRef;
+	if (input.model !== void 0) body.model = input.model;
+	if (input.createPullRequest !== void 0) body.create_pull_request = input.createPullRequest;
+	const response = await ghRest("POST", repoTasksPath(repo), {
+		apiVersion: AGENT_TASKS_API_VERSION,
+		body,
+		retry: false,
+		...input.idempotencyKey ? { headers: { "Idempotency-Key": input.idempotencyKey } } : {}
+	});
+	return {
+		taskId: stringField(response, [
+			"task_id",
+			"taskId",
+			"id"
+		]) ?? "",
+		state: stringField(response, ["state", "status"]) ?? "unknown"
+	};
+}
+async function getTask(repo, taskId) {
+	const record = asRecord$5(await ghRest("GET", taskPath(repo, taskId), { apiVersion: AGENT_TASKS_API_VERSION }));
+	const sessionId = latestSessionId(record);
+	const sessionLog = sessionId ? await getSessionLog(sessionId) : null;
+	const fallbackText = collectText(record).join("\n\n");
+	const logExcerpt = sessionLog?.excerpt && sessionLog.excerpt.length > 0 ? sessionLog.excerpt : tailExcerpt(fallbackText.length > 0 ? fallbackText : compactKnownKeysSummary(record));
+	return {
+		taskId: stringField(record, [
+			"task_id",
+			"taskId",
+			"id"
+		]) ?? taskId,
+		state: stringField(record, ["state", "status"]) ?? "unknown",
+		prUrl: taskPrUrl(record),
+		pr: taskPrNumber$1(record),
+		logExcerpt,
+		...sessionId ? { sessionId } : {},
+		...sessionLog?.branch ? { branch: sessionLog.branch } : {}
+	};
+}
+async function followUpTask(repo, taskId, prompt) {
+	await ghRest("POST", `${taskPath(repo, taskId)}${FOLLOW_UP_TASK_PATH_SUFFIX}`, {
+		apiVersion: AGENT_TASKS_API_VERSION,
+		body: { prompt }
+	});
+	return { ok: true };
+}
+async function cancelTask(repo, taskId) {
+	await ghRest("POST", `${taskPath(repo, taskId)}${CANCEL_TASK_PATH_SUFFIX}`, { apiVersion: AGENT_TASKS_API_VERSION });
+	return { cancelled: true };
+}
+
+//#endregion
+//#region src/lib/first-mate/decisions.ts
+const DECISIONS_VERSION = 1;
+const DECISION_STATUSES = new Set([
+	"pending",
+	"answered",
+	"queued_away",
+	"queued_away_irreversible"
+]);
+function decisionsPath() {
+	return nodePath.join(PATHS.FIRST_MATE_DIR, "decisions.json");
+}
+function asRecord$4(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function isOneOf$1(value, allowed) {
+	return typeof value === "string" && allowed.has(value);
+}
+function isFiniteNumber$2(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isOptionalString$2(value) {
+	return value === void 0 || typeof value === "string";
+}
+function isOptionalStringOrNull$1(value) {
+	return value === void 0 || value === null || typeof value === "string";
+}
+function isOptionalFiniteNumber$2(value) {
+	return value === void 0 || isFiniteNumber$2(value);
+}
+function isOptionalStringArray(value) {
+	return value === void 0 || Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isRepoRef$2(value) {
+	const repo = asRecord$4(value);
+	return repo !== void 0 && typeof repo.owner === "string" && repo.owner.length > 0 && typeof repo.name === "string" && repo.name.length > 0;
+}
+function isOptionRefs(value) {
+	return value === void 0 || Array.isArray(value) && value.every((option) => {
+		const row = asRecord$4(option);
+		return row !== void 0 && typeof row.id === "string";
+	});
+}
+function isApprovalRecord(value) {
+	const approval = asRecord$4(value);
+	return approval !== void 0 && typeof approval.decisionId === "string" && approval.decisionId.length > 0 && isRepoRef$2(approval.repo) && isPositiveInteger(approval.pr) && typeof approval.headSha === "string" && approval.headSha.length > 0 && isOptionalString$2(approval.baseSha) && isOptionalString$2(approval.diffDigest) && isOptionalStringArray(approval.requiredCheckIds) && isOptionalString$2(approval.floorRunId) && approval.status === "approved" && typeof approval.consumed === "boolean" && isFiniteNumber$2(approval.createdMs) && isOptionalFiniteNumber$2(approval.consumedMs);
+}
+function isOptionalApprovalRecord(value) {
+	return value === void 0 || isApprovalRecord(value);
+}
+function isDecisionRecord(value) {
+	const record = asRecord$4(value);
+	return record !== void 0 && typeof record.decisionId === "string" && record.decisionId.length > 0 && typeof record.decisionKey === "string" && record.decisionKey.length > 0 && typeof record.type === "string" && record.type.length > 0 && isOneOf$1(record.status, DECISION_STATUSES) && isOptionalString$2(record.packetId) && typeof record.inputFingerprint === "string" && record.inputFingerprint.length > 0 && isOptionRefs(record.options) && isOptionalStringOrNull$1(record.chosenOptionId) && isOptionalStringOrNull$1(record.resolvedBy) && isFiniteNumber$2(record.createdMs) && isOptionalFiniteNumber$2(record.resolvedMs) && isOptionalApprovalRecord(record.approval);
+}
+async function readDecisionsFile() {
+	let raw;
+	try {
+		raw = await fs.readFile(decisionsPath(), "utf8");
+	} catch (err) {
+		if (err.code !== "ENOENT") consola.debug("first-mate decisions read skipped:", err);
+		return {
+			version: DECISIONS_VERSION,
+			decisions: []
+		};
+	}
+	try {
+		const parsed = asRecord$4(JSON.parse(raw));
+		if (!parsed || parsed.version !== DECISIONS_VERSION || !Array.isArray(parsed.decisions)) return {
+			version: DECISIONS_VERSION,
+			decisions: []
+		};
+		const cleaned = parsed.decisions.filter(isDecisionRecord);
+		if (cleaned.length !== parsed.decisions.length) consola.debug(`first-mate decisions dropped ${parsed.decisions.length - cleaned.length} corrupt decision(s)`);
+		return {
+			version: DECISIONS_VERSION,
+			decisions: cleaned
+		};
+	} catch (err) {
+		consola.debug("first-mate decisions corrupt, starting empty:", err);
+		return {
+			version: DECISIONS_VERSION,
+			decisions: []
+		};
+	}
+}
+async function writeDecisionsFile(value) {
+	await fs.mkdir(PATHS.FIRST_MATE_DIR, { recursive: true });
+	const target = decisionsPath();
+	const tmp = `${target}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+	try {
+		await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+		await fs.chmod(tmp, 384).catch(() => {});
+		await fs.rename(tmp, target);
+		await fs.chmod(target, 384).catch(() => {});
+	} catch (err) {
+		await fs.unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+let _decisionsChain = Promise.resolve();
+function withDecisionsMutation(work) {
+	const next = _decisionsChain.then(async () => {
+		const file = await readDecisionsFile();
+		const result = await work(file.decisions);
+		await writeDecisionsFile(file);
+		return result;
+	});
+	_decisionsChain = next.then(() => void 0, () => void 0);
+	return next;
+}
+async function readDecisions() {
+	return (await readDecisionsFile()).decisions;
+}
+async function upsertDecision(rec) {
+	await withDecisionsMutation((decisions) => {
+		const kept = decisions.filter((entry) => entry.decisionId !== rec.decisionId && entry.decisionKey !== rec.decisionKey);
+		decisions.splice(0, decisions.length, ...kept, rec);
+	});
+}
+async function findByKey(decisionKey) {
+	return (await readDecisions()).find((record) => record.decisionKey === decisionKey);
+}
+async function markAnswered(decisionId, chosenOptionId, resolvedBy) {
+	await withDecisionsMutation((decisions) => {
+		const record = decisions.find((entry) => entry.decisionId === decisionId);
+		if (!record) return;
+		record.status = "answered";
+		record.chosenOptionId = chosenOptionId;
+		record.resolvedBy = resolvedBy;
+		record.resolvedMs = Date.now();
+	});
+}
+
+//#endregion
+//#region src/lib/first-mate/approval.ts
+function sameRepo(a, b) {
+	return a.owner.toLowerCase() === b.owner.toLowerCase() && a.name.toLowerCase() === b.name.toLowerCase();
+}
+function approvedRecord(a) {
+	const approval = {
+		decisionId: a.decisionId,
+		repo: a.repo,
+		pr: a.pr,
+		headSha: a.headSha,
+		status: "approved",
+		consumed: false,
+		createdMs: Date.now()
+	};
+	if (a.baseSha !== void 0) approval.baseSha = a.baseSha;
+	if (a.diffDigest !== void 0) approval.diffDigest = a.diffDigest;
+	if (a.requiredCheckIds !== void 0) approval.requiredCheckIds = [...a.requiredCheckIds];
+	if (a.floorRunId !== void 0) approval.floorRunId = a.floorRunId;
+	return approval;
+}
+/**
+* Record a human merge/irreversible approval in the durable decisions ledger.
+*
+* This function belongs only on the human-approval path: the model is never
+* given a tool that can call it, so an approval is a durable controller fact
+* rather than agent-authored text the model could forge.
+*/
+async function recordApproval(a) {
+	await withDecisionsMutation((decisions) => {
+		const decision = decisions.find((entry) => entry.decisionId === a.decisionId);
+		if (!decision) throw new Error(`Cannot record approval for unknown decision ${a.decisionId}`);
+		decision.approval = approvedRecord(a);
+	});
+}
+async function verifyAndConsumeApproval(args) {
+	return withDecisionsMutation((decisions) => {
+		const approvals = decisions.map((decision) => decision.approval).filter((entry) => entry !== void 0 && sameRepo(entry.repo, args.repo) && entry.pr === args.pr);
+		if (approvals.length === 0) return {
+			ok: false,
+			reason: "no_approval"
+		};
+		const approval = approvals.filter((entry) => !entry.consumed).sort((a, b) => b.createdMs - a.createdMs)[0];
+		if (approval === void 0) return {
+			ok: false,
+			reason: "replayed"
+		};
+		if (approval.headSha !== args.liveHeadSha) return {
+			ok: false,
+			reason: "head_moved"
+		};
+		if (approval.baseSha !== void 0 && approval.baseSha !== args.liveBaseSha) return {
+			ok: false,
+			reason: "base_moved"
+		};
+		approval.consumed = true;
+		approval.consumedMs = Date.now();
+		return { ok: true };
+	});
+}
+
+//#endregion
+//#region src/lib/first-mate/model-tiers.ts
+const T0_MODEL_CHAIN = [
+	"gemini-3.5-flash",
+	"gemini-3-flash-preview",
+	"gpt-5.4-mini",
+	"gpt-5-mini",
+	"claude-haiku-4.5",
+	"gpt-4o-mini"
+];
+const T1_MODEL_CHAIN = [
+	"gpt-5.4-mini",
+	"gpt-5-mini",
+	"gpt-5.5",
+	"gemini-3.1-pro-preview"
+];
+const T2_MODEL_CHAIN = [
+	"gpt-5.5",
+	"claude-opus-4.8",
+	"gemini-3.1-pro-preview"
+];
+const TIER_CHAINS = {
+	T0: T0_MODEL_CHAIN,
+	T1: T1_MODEL_CHAIN,
+	T2: T2_MODEL_CHAIN
+};
+const T0_FALLBACK_RE = /mini|flash|nano|haiku|small/i;
+const MEMO_TTL_MS = 3e4;
+const memo = {};
+function catalogIds(data) {
+	if (!data) return [];
+	return data.map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0);
+}
+function catalogKey(ids) {
+	return ids.join("\0");
+}
+function resolveFromIds(tier$1, ids) {
+	if (ids.length === 0) return void 0;
+	const available = new Set(ids);
+	for (const model of TIER_CHAINS[tier$1]) if (available.has(model)) return model;
+	if (tier$1 === "T0") return ids.find((id) => T0_FALLBACK_RE.test(id));
+	return ids[0];
+}
+function resolveTierModel(tier$1) {
+	const data = state.models?.data;
+	const length = data?.length ?? 0;
+	const ids = catalogIds(data);
+	const key = catalogKey(ids);
+	const now = Date.now();
+	const cached$2 = memo[tier$1];
+	if (cached$2 && cached$2.expiresAt > now && cached$2.data === data && cached$2.length === length && cached$2.catalogKey === key) return cached$2.value;
+	const value = resolveFromIds(tier$1, ids);
+	memo[tier$1] = {
+		data,
+		length,
+		catalogKey: key,
+		expiresAt: now + MEMO_TTL_MS,
+		value
+	};
+	return value;
+}
+
+//#endregion
+//#region src/lib/first-mate/classifier.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function firstMessageContent(value) {
+	if (!isRecord$1(value) || !Array.isArray(value.choices)) return null;
+	const first = value.choices[0];
+	if (!isRecord$1(first) || !isRecord$1(first.message)) return null;
+	return typeof first.message.content === "string" ? first.message.content : null;
+}
+function parseJsonObject(value) {
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$1(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function confidenceOf(value) {
+	const confidence = value.confidence;
+	if (typeof confidence !== "number") return null;
+	if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) return null;
+	return confidence;
+}
+function classifierSystemPrompt(system, schemaHint) {
+	return `${system}\nReply ONLY with a JSON object matching: ${schemaHint}. Include a numeric confidence field from 0 to 1. No markdown, prose, or extra text.`;
+}
+async function microClassify(opts) {
+	const model = resolveTierModel("T0");
+	if (!model) return null;
+	let response;
+	try {
+		response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+			method: "POST",
+			headers: copilotHeaders(state),
+			body: JSON.stringify({
+				model,
+				messages: [{
+					role: "system",
+					content: classifierSystemPrompt(opts.system, opts.schemaHint)
+				}, {
+					role: "user",
+					content: opts.user
+				}],
+				temperature: 0,
+				max_tokens: opts.maxTokens ?? 400,
+				response_format: { type: "json_object" }
+			})
+		});
+	} catch (err) {
+		consola.debug("first-mate micro-classifier fetch failed:", err);
+		return null;
+	}
+	try {
+		const content = firstMessageContent(await response.json());
+		if (!content) return null;
+		const parsed = parseJsonObject(content);
+		if (!parsed) return null;
+		const confidence = confidenceOf(parsed);
+		if (confidence === null || confidence < .6) return null;
+		const value = opts.validate(parsed);
+		if (value === null) return null;
+		return {
+			value,
+			confidence
+		};
+	} catch {
+		return null;
+	}
+}
+function stringValue$1(value) {
+	return typeof value === "string" ? value : null;
+}
+function booleanValue$1(value) {
+	return typeof value === "boolean" ? value : null;
+}
+async function classifyPlanReady(logExcerpt) {
+	return (await microClassify({
+		system: "Decide whether a cloud-agent session log shows a completed implementation PLAN, not code or execution.",
+		user: `Log excerpt:\n${logExcerpt}`,
+		schemaHint: "{\"planReady\":boolean,\"planExcerpt\":\"<=1200 chars from the completed plan, or empty\",\"confidence\":number}",
+		maxTokens: 500,
+		validate(value) {
+			if (!isRecord$1(value)) return null;
+			const planReady = booleanValue$1(value.planReady);
+			const planExcerpt = stringValue$1(value.planExcerpt);
+			if (planReady === null || planExcerpt === null) return null;
+			return {
+				planReady,
+				planExcerpt: planExcerpt.slice(0, 1200)
+			};
+		}
+	}))?.value ?? null;
+}
+async function classifyQuestionAnswerable(question, acceptanceCriteria) {
+	return (await microClassify({
+		system: "Decide if the agent's question is answerable purely from the acceptance criteria. If yes, answer it tersely.",
+		user: `Acceptance criteria:\n${acceptanceCriteria}\n\nAgent question:\n${question}`,
+		schemaHint: "{\"answerable\":boolean,\"answer\":\"present only when answerable\",\"confidence\":number}",
+		validate(value) {
+			if (!isRecord$1(value)) return null;
+			const answerable = booleanValue$1(value.answerable);
+			if (answerable === null) return null;
+			const answer = stringValue$1(value.answer);
+			if (!answerable) return { answerable };
+			return answer === null ? null : {
+				answerable,
+				answer
+			};
+		}
+	}))?.value ?? null;
+}
+async function classifyFixAddressed(failureSummary, latestLogExcerpt) {
+	return (await microClassify({
+		system: "Decide whether the latest cloud-agent log indicates the summarized failure was addressed.",
+		user: `Failure summary:\n${failureSummary}\n\nLatest log excerpt:\n${latestLogExcerpt}`,
+		schemaHint: "{\"addressed\":boolean,\"confidence\":number}",
+		validate(value) {
+			if (!isRecord$1(value)) return null;
+			const addressed = booleanValue$1(value.addressed);
+			return addressed === null ? null : { addressed };
+		}
+	}))?.value ?? null;
+}
+async function classifyStuck(logExcerpt) {
+	return (await microClassify({
+		system: "Decide whether the cloud-agent log shows the agent is stuck, looping, blocked, or unable to proceed.",
+		user: `Log excerpt:\n${logExcerpt}`,
+		schemaHint: "{\"stuck\":boolean,\"confidence\":number}",
+		validate(value) {
+			if (!isRecord$1(value)) return null;
+			const stuck = booleanValue$1(value.stuck);
+			return stuck === null ? null : { stuck };
+		}
+	}))?.value ?? null;
+}
+
+//#endregion
+//#region src/lib/first-mate/decision-packet.ts
+const HTML_ESCAPES = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function esc(value) {
+	return value.replace(/[&<>"']/g, (char) => HTML_ESCAPES[char] ?? char);
+}
+function safeHref(value) {
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+		return esc(url.href);
+	} catch {
+		return null;
+	}
+}
+function evidenceBody(input) {
+	const evidence = input.evidence;
+	const rows = [];
+	if (evidence?.prSummary !== void 0) rows.push(`<dt>PR summary</dt><dd>${esc(evidence.prSummary)}</dd>`);
+	if (evidence?.ciExcerpt !== void 0) rows.push(`<dt>CI excerpt</dt><dd><pre>${esc(evidence.ciExcerpt)}</pre></dd>`);
+	if (evidence?.floorVerdict !== void 0) rows.push(`<dt>Floor verdict</dt><dd>${esc(evidence.floorVerdict)}</dd>`);
+	const links = evidence?.links ?? [];
+	if (links.length > 0) {
+		const items = links.map((link$1) => {
+			const label = esc(link$1.label);
+			const href = safeHref(link$1.url);
+			if (href === null) return `<li><span>${label}</span></li>`;
+			return `<li><a href="${href}" rel="noreferrer noopener" target="_blank">${label}</a></li>`;
+		}).join("");
+		rows.push(`<dt>Links</dt><dd><ul>${items}</ul></dd>`);
+	}
+	if (rows.length === 0) return `<p class="muted">No evidence attached.</p>`;
+	return `<dl>${rows.join("")}</dl>`;
+}
+function provenance(input, packetId, decisionId) {
+	const parts = [
+		`<span><strong>packetId</strong> ${esc(packetId)}</span>`,
+		`<span><strong>decisionId</strong> ${esc(decisionId)}</span>`,
+		`<span><strong>type</strong> ${esc(input.type)}</span>`,
+		`<span><strong>timestamp</strong> timestamp-placeholder</span>`
+	];
+	if (input.missionId !== void 0) parts.push(`<span><strong>mission</strong> ${esc(input.missionId)}</span>`);
+	if (input.repo !== void 0) parts.push(`<span><strong>repo</strong> ${esc(input.repo.owner)}/${esc(input.repo.name)}</span>`);
+	if (input.unit !== void 0) {
+		const refs = [];
+		if (input.unit.issue !== void 0 && input.unit.issue !== null) refs.push(`issue #${input.unit.issue}`);
+		if (input.unit.pr !== void 0 && input.unit.pr !== null) refs.push(`PR #${input.unit.pr}`);
+		if (refs.length > 0) parts.push(`<span><strong>unit</strong> ${esc(refs.join(", "))}</span>`);
+	}
+	return parts.join("\n      ");
+}
+function buildDecisionPacket(input) {
+	const packetId = randomUUID();
+	const decisionId = randomUUID();
+	const recommendedIndex = input.options.findIndex((option) => option.recommended === true);
+	const optionCards = input.options.map((option, index) => {
+		const badge = index === recommendedIndex ? ` <span class="badge" aria-label="Recommended option">Recommended</span>` : "";
+		return `<section class="option" data-option="${esc(option.id)}">
+        <h2>${esc(option.label)}${badge}</h2>
+        <p class="consequence">${esc(option.consequence)}</p>
+      </section>`;
+	}).join("\n");
+	return {
+		html: `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${esc(input.tldr)}</title>
+  <style>
+    :root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    body { margin: 0; padding: 32px; background: #0f172a; color: #e2e8f0; }
+    main { max-width: 860px; margin: 0 auto; }
+    .banner { padding: 24px; border-radius: 18px; background: linear-gradient(135deg, #2563eb, #7c3aed); box-shadow: 0 18px 45px rgba(15, 23, 42, 0.35); }
+    .eyebrow { margin: 0 0 8px; font-size: 12px; font-weight: 700; letter-spacing: 0.14em; text-transform: uppercase; opacity: 0.78; }
+    h1 { margin: 0; font-size: clamp(28px, 5vw, 44px); line-height: 1.05; }
+    .question { margin: 24px 0; padding: 18px 20px; border: 1px solid rgba(148, 163, 184, 0.35); border-radius: 14px; background: rgba(15, 23, 42, 0.72); font-size: 18px; }
+    .options { display: grid; gap: 16px; }
+    .option { padding: 18px 20px; border: 1px solid rgba(148, 163, 184, 0.32); border-radius: 16px; background: rgba(30, 41, 59, 0.86); }
+    .option h2 { margin: 0 0 10px; display: flex; gap: 10px; align-items: center; font-size: 20px; }
+    .badge { display: inline-block; padding: 4px 8px; border-radius: 999px; background: #22c55e; color: #052e16; font-size: 12px; font-weight: 800; text-transform: uppercase; letter-spacing: 0.06em; }
+    .consequence { margin: 0; color: #cbd5e1; }
+    details { margin-top: 22px; padding: 16px 18px; border: 1px solid rgba(148, 163, 184, 0.28); border-radius: 14px; background: rgba(15, 23, 42, 0.58); }
+    summary { cursor: pointer; font-weight: 700; }
+    dl { display: grid; grid-template-columns: minmax(120px, 0.28fr) 1fr; gap: 10px 16px; margin: 16px 0 0; }
+    dt { color: #93c5fd; font-weight: 700; }
+    dd { margin: 0; }
+    pre { white-space: pre-wrap; overflow-wrap: anywhere; margin: 0; font: inherit; }
+    ul { margin: 0; padding-left: 18px; }
+    a { color: #93c5fd; }
+    .muted { margin: 14px 0 0; color: #94a3b8; }
+    footer { margin-top: 22px; display: flex; flex-wrap: wrap; gap: 10px 14px; color: #94a3b8; font-size: 12px; }
+  </style>
+</head>
+<body>
+  <main>
+    <header class="banner">
+      <p class="eyebrow">Decision packet</p>
+      <h1>${esc(input.tldr)}</h1>
+    </header>
+    <p class="question">${esc(input.question)}</p>
+    <div class="options">
+${optionCards}
+    </div>
+    <details>
+      <summary>Evidence</summary>
+      ${evidenceBody(input)}
+    </details>
+    <footer>
+      ${provenance(input, packetId, decisionId)}
+    </footer>
+  </main>
+</body>
+</html>`,
+		packetId,
+		decisionId
+	};
+}
+
+//#endregion
+//#region src/lib/first-mate/ledger.ts
+const LEDGER_VERSION = 1;
+const DEFAULT_TERMINAL_MAX_AGE_MS = 10080 * 60 * 1e3;
+const TERMINAL_MAX_ENTRIES = 200;
+const AGENTS = new Set([
+	"copilot",
+	"anthropic",
+	"openai"
+]);
+function membersOf(record) {
+	return new Set(Object.keys(record));
+}
+const DISPATCH_MODES = membersOf({
+	plan: true,
+	build: true
+});
+const PROVIDER_STATES$2 = membersOf({
+	none: true,
+	queued: true,
+	in_progress: true,
+	waiting_for_user: true,
+	completed: true,
+	failed: true,
+	timed_out: true,
+	cancelled: true
+});
+const PHASES = membersOf({
+	plan: true,
+	build: true,
+	fix: true,
+	review: true,
+	merge: true,
+	done: true
+});
+const ARTIFACTS = membersOf({
+	no_pr: true,
+	pr_open: true,
+	pr_closed: true,
+	pr_merged: true,
+	multiple_prs: true
+});
+const VALIDATIONS = membersOf({
+	unknown: true,
+	ci_running: true,
+	ci_passed: true,
+	ci_failed: true,
+	no_ci: true,
+	review_pending: true,
+	changes_requested: true,
+	floor_pending: true,
+	floor_passed: true,
+	floor_failed: true
+});
+function sanitizeSegment$1(value) {
+	const cleaned = value.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+$/, "_");
+	return cleaned.length > 0 ? cleaned : "_";
+}
+function repoLedgerPath(repo) {
+	return nodePath.join(PATHS.FIRST_MATE_DIR, `${sanitizeSegment$1(repo.owner)}__${sanitizeSegment$1(repo.name)}.json`);
+}
+function asRecord$3(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function isOneOf(value, allowed) {
+	return typeof value === "string" && allowed.has(value);
+}
+function isFiniteNumber$1(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isIssueNumberOrNull(value) {
+	return value === null || isNonNegativeInteger(value);
+}
+function isStringOrNull(value) {
+	return value === null || typeof value === "string";
+}
+function isOptionalString$1(value) {
+	return value === void 0 || typeof value === "string";
+}
+function isOptionalStringOrNull(value) {
+	return value === void 0 || value === null || typeof value === "string";
+}
+function isOptionalBoolean(value) {
+	return value === void 0 || typeof value === "boolean";
+}
+function isOptionalFiniteNumber$1(value) {
+	return value === void 0 || isFiniteNumber$1(value);
+}
+function isRepoRef$1(value) {
+	const repo = asRecord$3(value);
+	return repo !== void 0 && typeof repo.owner === "string" && repo.owner.length > 0 && typeof repo.name === "string" && repo.name.length > 0;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isLastSteer(value) {
+	if (value === void 0) return true;
+	const steer = asRecord$3(value);
+	return steer !== void 0 && isOptionalString$1(steer.cursor) && isOptionalString$1(steer.sha) && isFiniteNumber$1(steer.atMs);
+}
+function isUnitRow(value) {
+	const row = asRecord$3(value);
+	if (!row) return false;
+	return typeof row.missionId === "string" && row.missionId.length > 0 && isRepoRef$1(row.repo) && isIssueNumberOrNull(row.issue) && isIssueNumberOrNull(row.pr) && isStringOrNull(row.taskId) && isOneOf(row.agent, AGENTS) && typeof row.botLogin === "string" && isOneOf(row.dispatchMode, DISPATCH_MODES) && isOneOf(row.provider, PROVIDER_STATES$2) && isOneOf(row.phase, PHASES) && isOneOf(row.artifact, ARTIFACTS) && isOneOf(row.validation, VALIDATIONS) && isNonNegativeInteger(row.retries) && isStringArray(row.dependsOn) && typeof row.title === "string" && isLastSteer(row.lastSteer) && (row.cancelledBy === void 0 || row.cancelledBy === "controller" || row.cancelledBy === "external") && isOptionalStringOrNull(row.bakeoffGroupId) && isOptionalStringOrNull(row.blockingDecisionId) && isOptionalBoolean(row.verifierAssigned) && (row.implementerLab === void 0 || isOneOf(row.implementerLab, AGENTS)) && isOptionalStringOrNull(row.branch) && isOptionalStringOrNull(row.headSha) && isOptionalStringOrNull(row.baseSha) && isOptionalFiniteNumber$1(row.lastCheckedMs) && isOptionalBoolean(row.terminal);
+}
+async function writeJsonSecure(target, value) {
+	await fs.mkdir(nodePath.dirname(target), { recursive: true });
+	const tmp = `${target}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+	try {
+		await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+		await fs.chmod(tmp, 384).catch(() => {});
+		await fs.rename(tmp, target);
+		await fs.chmod(target, 384).catch(() => {});
+	} catch (err) {
+		await fs.unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+async function writeRepoLedger(repo, units) {
+	await writeJsonSecure(repoLedgerPath(repo), {
+		version: LEDGER_VERSION,
+		units
+	});
+}
+let _ledgerChain = Promise.resolve();
+function serializeLedgerWrite(work) {
+	const next = _ledgerChain.then(work);
+	_ledgerChain = next.catch(() => void 0);
+	return next;
+}
+function sameUnitHandle(a, b) {
+	return b.id != null && a.id === b.id || b.issue !== null && a.issue === b.issue || b.taskId !== null && a.taskId === b.taskId;
+}
+function terminalTimestamp(row) {
+	return row.lastCheckedMs ?? row.lastSteer?.atMs ?? 0;
+}
+async function readRepoLedger(repo) {
+	let raw;
+	try {
+		raw = await fs.readFile(repoLedgerPath(repo), "utf8");
+	} catch (err) {
+		if (err.code !== "ENOENT") consola.debug("first-mate ledger read skipped:", err);
+		return [];
+	}
+	try {
+		const parsed = asRecord$3(JSON.parse(raw));
+		if (!parsed || parsed.version !== LEDGER_VERSION || !Array.isArray(parsed.units)) return [];
+		const cleaned = parsed.units.filter(isUnitRow);
+		if (cleaned.length !== parsed.units.length) consola.debug(`first-mate ledger dropped ${parsed.units.length - cleaned.length} corrupt unit(s)`);
+		return cleaned;
+	} catch (err) {
+		consola.debug("first-mate ledger corrupt, starting empty:", err);
+		return [];
+	}
+}
+async function upsertUnit(repo, unit) {
+	await serializeLedgerWrite(async () => {
+		const next = (await readRepoLedger(repo)).filter((row) => !sameUnitHandle(row, unit));
+		next.push(unit);
+		await writeRepoLedger(repo, next);
+	});
+}
+async function pruneTerminal(repo, maxAgeMs = DEFAULT_TERMINAL_MAX_AGE_MS) {
+	await serializeLedgerWrite(async () => {
+		const current = await readRepoLedger(repo);
+		const now = Date.now();
+		const keptTerminals = new Set(current.filter((row) => row.terminal === true).filter((row) => now - terminalTimestamp(row) < maxAgeMs).sort((a, b) => terminalTimestamp(a) - terminalTimestamp(b)).slice(-TERMINAL_MAX_ENTRIES));
+		await writeRepoLedger(repo, current.filter((row) => row.terminal !== true || keptTerminals.has(row)));
+	});
+}
+
+//#endregion
+//#region src/lib/first-mate/registry.ts
+const REGISTRY_VERSION = 1;
+function registryPath() {
+	return nodePath.join(PATHS.FIRST_MATE_DIR, "missions.json");
+}
+function asRecord$2(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isOptionalString(value) {
+	return value === void 0 || typeof value === "string";
+}
+function isOptionalFiniteNumber(value) {
+	return value === void 0 || isFiniteNumber(value);
+}
+function isRepoRef(value) {
+	const repo = asRecord$2(value);
+	return repo !== void 0 && typeof repo.owner === "string" && repo.owner.length > 0 && typeof repo.name === "string" && repo.name.length > 0;
+}
+function isMission(value) {
+	const mission = asRecord$2(value);
+	return mission !== void 0 && typeof mission.id === "string" && mission.id.length > 0 && typeof mission.goal === "string" && typeof mission.acceptanceCriteria === "string" && isOptionalString(mission.houseRules) && isOptionalFiniteNumber(mission.priority) && Array.isArray(mission.repos) && mission.repos.every(isRepoRef) && (mission.status === "active" || mission.status === "done" || mission.status === "abandoned") && isFiniteNumber(mission.createdMs) && isFiniteNumber(mission.updatedMs);
+}
+async function writeRegistry(value) {
+	await fs.mkdir(PATHS.FIRST_MATE_DIR, { recursive: true });
+	const target = registryPath();
+	const tmp = `${target}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+	try {
+		await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+		await fs.chmod(tmp, 384).catch(() => {});
+		await fs.rename(tmp, target);
+		await fs.chmod(target, 384).catch(() => {});
+	} catch (err) {
+		await fs.unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+let _registryChain = Promise.resolve();
+function serializeRegistryWrite(work) {
+	const next = _registryChain.then(work);
+	_registryChain = next.catch(() => void 0);
+	return next;
+}
+function repoKey(repo) {
+	return `${repo.owner.toLowerCase()}\0${repo.name.toLowerCase()}`;
+}
+async function readMissions() {
+	let raw;
+	try {
+		raw = await fs.readFile(registryPath(), "utf8");
+	} catch (err) {
+		if (err.code !== "ENOENT") consola.debug("first-mate registry read skipped:", err);
+		return [];
+	}
+	try {
+		const parsed = asRecord$2(JSON.parse(raw));
+		if (!parsed || parsed.version !== REGISTRY_VERSION || !Array.isArray(parsed.missions)) return [];
+		const cleaned = parsed.missions.filter(isMission);
+		if (cleaned.length !== parsed.missions.length) consola.debug(`first-mate registry dropped ${parsed.missions.length - cleaned.length} corrupt mission(s)`);
+		return cleaned;
+	} catch (err) {
+		consola.debug("first-mate registry corrupt, starting empty:", err);
+		return [];
+	}
+}
+async function upsertMission(mission) {
+	await serializeRegistryWrite(async () => {
+		const missions = (await readMissions()).filter((entry) => entry.id !== mission.id);
+		missions.push(mission);
+		await writeRegistry({
+			version: REGISTRY_VERSION,
+			missions
+		});
+	});
+}
+async function loadAllUnits() {
+	const missions = await readMissions();
+	const repos = /* @__PURE__ */ new Map();
+	for (const mission of missions) for (const repo of mission.repos) repos.set(repoKey(repo), repo);
+	const units = [];
+	for (const repo of repos.values()) units.push(...await readRepoLedger(repo));
+	return units;
+}
+
+//#endregion
+//#region src/lib/first-mate/observe.ts
+const PROVIDER_STATES$1 = new Set([
+	"none",
+	"queued",
+	"in_progress",
+	"waiting_for_user",
+	"completed",
+	"failed",
+	"timed_out",
+	"cancelled"
+]);
+function agentRepo$1(unit) {
+	return {
+		owner: unit.repo.owner,
+		repo: unit.repo.name
+	};
+}
+function providerState$1(value, fallback) {
+	if (value && PROVIDER_STATES$1.has(value)) return value;
+	return fallback;
+}
+function normalizePrState(value) {
+	if (!value) return "OPEN";
+	const upper = value.toUpperCase();
+	if (upper === "OPEN" || upper === "CLOSED" || upper === "MERGED") return upper;
+	return value;
+}
+function parsePrNumberFromUrl(value) {
+	if (!value) return null;
+	const match = /\/pull\/(\d+)(?:[/?#]|$)/.exec(value);
+	if (!match) return null;
+	const parsed = Number.parseInt(match[1], 10);
+	return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+function taskPrNumber(task) {
+	if (!task) return null;
+	if (typeof task.pr === "number" && Number.isInteger(task.pr) && task.pr > 0) return task.pr;
+	return parsePrNumberFromUrl(task.prUrl);
+}
+function firstSummaryNumber(prs) {
+	return prs.find((pr) => Number.isInteger(pr.number) && pr.number > 0)?.number ?? null;
+}
+function branchMatchNumber(prs, branch) {
+	if (!branch) return null;
+	return prs.find((pr) => pr.headRef === branch && Number.isInteger(pr.number) && pr.number > 0)?.number ?? null;
+}
+function primaryPrNumber(unit, task, prs) {
+	if (unit.pr !== null && unit.pr > 0) return unit.pr;
+	const branch = unit.branch ?? task?.branch ?? void 0;
+	const byBranch = branchMatchNumber(prs, branch);
+	if (byBranch !== null) return byBranch;
+	const byTask = taskPrNumber(task);
+	if (byTask !== null) return byTask;
+	if (branch !== void 0) return null;
+	return firstSummaryNumber(prs);
+}
+async function getTaskSafe(repo, taskId) {
+	if (!taskId) return null;
+	try {
+		return await getTask(repo, taskId);
+	} catch (err) {
+		consola.debug("first-mate observe: task read skipped:", err);
+		return null;
+	}
+}
+async function findPrsSafe(repo, unit) {
+	try {
+		return await findAgentPRs(repo, {
+			issueNumber: unit.issue ?? 0,
+			botLogin: unit.botLogin,
+			...unit.branch ? { branch: unit.branch } : {}
+		});
+	} catch (err) {
+		consola.debug("first-mate observe: PR discovery skipped:", err);
+		return [];
+	}
+}
+async function getPullRequestStateSafe(repo, pr) {
+	if (pr === null) return null;
+	try {
+		return await getPullRequestState(repo, pr);
+	} catch (err) {
+		consola.debug("first-mate observe: PR state read skipped:", err);
+		return null;
+	}
+}
+async function getCiSafe(repo, headSha, baseRef) {
+	if (headSha.length === 0) return void 0;
+	try {
+		const checks = await getRequiredChecksForSha(repo, headSha);
+		if (checks.rollup !== "none") return { rollup: checks.rollup };
+		return {
+			rollup: "none",
+			noCi: !(baseRef ? await repoHasWorkflows(repo, baseRef) : false)
+		};
+	} catch (err) {
+		consola.debug("first-mate observe: required checks read skipped:", err);
+		return;
+	}
+}
+async function verifierReviewSafe(repo, unit, pr, headSha) {
+	if (!unit.verifierAssigned || pr === null) return { reviewed: false };
+	try {
+		const copilotReviews = (await getPullRequestReviews(repo, pr)).filter((r) => r.author === COPILOT_REVIEWER_LOGIN && (headSha === void 0 || r.commitId === void 0 || r.commitId === headSha));
+		const latest = copilotReviews[copilotReviews.length - 1];
+		if (latest === void 0) return { reviewed: false };
+		return {
+			reviewed: true,
+			findings: latest.bodyExcerpt
+		};
+	} catch (err) {
+		consola.debug("first-mate observe: review read skipped:", err);
+		return { reviewed: false };
+	}
+}
+function observedPrs(summaries, primaryState) {
+	const prs = /* @__PURE__ */ new Map();
+	for (const summary of summaries) {
+		if (!Number.isInteger(summary.number) || summary.number <= 0) continue;
+		prs.set(summary.number, {
+			number: summary.number,
+			headSha: summary.headSha,
+			isDraft: summary.isDraft,
+			state: "OPEN"
+		});
+	}
+	if (primaryState) {
+		const summary = prs.get(primaryState.number);
+		const state$1 = normalizePrState(primaryState.state);
+		prs.set(primaryState.number, {
+			number: primaryState.number,
+			headSha: primaryState.headSha || summary?.headSha || "",
+			isDraft: primaryState.isDraft,
+			state: state$1,
+			merged: state$1 === "MERGED"
+		});
+	}
+	return [...prs.values()];
+}
+function externalMutation(unit, primaryState) {
+	if (!primaryState || unit.terminal || unit.cancelledBy === "controller") return;
+	const state$1 = normalizePrState(primaryState.state);
+	if (state$1 === "MERGED") return "merged";
+	if (state$1 === "CLOSED") return "closed";
+}
+async function observeUnit(unit) {
+	const repo = agentRepo$1(unit);
+	const task = await getTaskSafe(repo, unit.taskId);
+	if (task?.branch && task.branch.length > 0) unit.branch = task.branch;
+	const provider = providerState$1(task?.state, unit.provider);
+	const prSummaries = await findPrsSafe(repo, unit);
+	const primaryNumber = primaryPrNumber(unit, task, prSummaries);
+	const primaryState = await getPullRequestStateSafe(repo, primaryNumber);
+	const ci = primaryState ? await getCiSafe(repo, primaryState.headSha, primaryState.baseRef) : void 0;
+	const reviewDecision = primaryState ? primaryState.reviewDecision ?? null : void 0;
+	const mutation = externalMutation(unit, primaryState);
+	const logExcerpt = task?.logExcerpt && task.logExcerpt.length > 0 ? task.logExcerpt : void 0;
+	const question = provider === "waiting_for_user" ? logExcerpt : void 0;
+	const review = await verifierReviewSafe(repo, unit, primaryNumber, primaryState?.headSha);
+	return {
+		provider,
+		prs: observedPrs(prSummaries, primaryState),
+		...ci ? { ci } : {},
+		...reviewDecision !== void 0 ? { reviewDecision } : {},
+		...mutation ? { externalMutation: mutation } : {},
+		...logExcerpt ? { logExcerpt } : {},
+		...question ? { question } : {},
+		...review.reviewed ? { verifierReviewed: true } : {},
+		...review.findings ? { reviewExcerpt: review.findings } : {},
+		...primaryState?.nodeId ? { prNodeId: primaryState.nodeId } : {}
+	};
+}
+
+//#endregion
+//#region src/lib/first-mate/state-machine.ts
+function classify(observed, row) {
+	const events$1 = [];
+	const provider = observed.provider;
+	const artifact = classifyArtifact(observed, events$1);
+	const validation = classifyValidation(observed, artifact, row);
+	const phase = classifyPhase(observed, row, artifact, validation);
+	if (observed.externalMutation) events$1.push(`external:${observed.externalMutation}`);
+	if (observed.steerAcknowledged === false) events$1.push("steer:no_progress");
+	return {
+		provider,
+		phase,
+		artifact,
+		validation,
+		events: events$1
+	};
+}
+function classifyArtifact(observed, events$1) {
+	if (observed.externalMutation === "merged") return "pr_merged";
+	const prs = observed.prs;
+	if (prs.length === 0) return observed.externalMutation === "closed" ? "pr_closed" : "no_pr";
+	if (prs.length > 1) {
+		events$1.push("multiple_prs");
+		return "multiple_prs";
+	}
+	const pr = prs[0];
+	if (pr.merged || pr.state === "MERGED") return "pr_merged";
+	if (pr.state === "CLOSED") return "pr_closed";
+	return "pr_open";
+}
+function classifyValidation(observed, artifact, row) {
+	if (artifact !== "pr_open") return "unknown";
+	const head = observed.prs[0]?.headSha;
+	if ((row.validation === "floor_passed" || row.validation === "floor_failed") && row.floorSha != null && row.floorSha.length > 0 && head !== void 0 && head === row.floorSha) return row.validation;
+	if (observed.floor === "failed") return "floor_failed";
+	if (observed.floor === "passed") return "floor_passed";
+	if (observed.floor === "pending") return "floor_pending";
+	if (row.verifierAssigned === true && observed.verifierReviewed === true) return "floor_pending";
+	if (observed.reviewDecision === "CHANGES_REQUESTED") return "changes_requested";
+	const rollup = observed.ci?.rollup;
+	if (rollup === "failing") return "ci_failed";
+	if (rollup === "pending") return "ci_running";
+	if (rollup === "passing") {
+		if (observed.reviewDecision === "REVIEW_REQUIRED") return "review_pending";
+		return "ci_passed";
+	}
+	if (rollup === "none") return observed.ci?.noCi === true ? "no_ci" : "ci_running";
+	return "unknown";
+}
+function classifyPhase(observed, row, artifact, validation) {
+	if (row.terminal || artifact === "pr_merged") return "done";
+	if (artifact === "no_pr") {
+		if (observed.planReady) return "plan";
+		return row.dispatchMode === "plan" ? "plan" : "build";
+	}
+	if (validation === "floor_passed") return "merge";
+	if (validation === "ci_failed" || validation === "changes_requested") return "fix";
+	if (validation === "ci_passed" || validation === "review_pending" || validation === "no_ci") return "review";
+	return "build";
+}
+function nextAction(state$1, row, policy) {
+	if (state$1.phase === "done" || row.terminal) return { kind: "mark_done" };
+	if (state$1.artifact === "pr_merged") return { kind: "mark_done" };
+	if (state$1.artifact === "pr_closed") {
+		if (row.cancelledBy === "controller") return { kind: "mark_done" };
+		return {
+			kind: "escalate_human",
+			reason: "pull request was closed outside the first mate"
+		};
+	}
+	if (state$1.artifact === "multiple_prs") return {
+		kind: "escalate_human",
+		reason: "the agent opened multiple pull requests for one unit"
+	};
+	if (state$1.provider === "failed" || state$1.provider === "timed_out") return {
+		kind: "escalate_human",
+		reason: `cloud agent task ${state$1.provider}`
+	};
+	if (state$1.provider === "waiting_for_user") {
+		if (row.blockingDecisionId) return { kind: "noop" };
+		return {
+			kind: "ask_model",
+			request: "answer_agent_question"
+		};
+	}
+	if (state$1.phase === "plan" && state$1.provider === "completed" && state$1.artifact === "no_pr") {
+		if (row.blockingDecisionId) return { kind: "noop" };
+		return {
+			kind: "ask_model",
+			request: "review_plan"
+		};
+	}
+	switch (state$1.validation) {
+		case "ci_failed":
+		case "changes_requested":
+			if (row.retries < policy.maxRetries) return {
+				kind: "ask_model",
+				request: "author_fix"
+			};
+			return {
+				kind: "escalate_human",
+				reason: state$1.validation === "ci_failed" ? "CI still red after the self-heal retry cap" : "changes still requested after the self-heal retry cap"
+			};
+		case "ci_passed":
+		case "no_ci":
+			if (!row.verifierAssigned || row.verifierSha != null && row.headSha != null && row.verifierSha !== row.headSha) return { kind: "assign_verifier" };
+			return { kind: "noop" };
+		case "review_pending":
+			if (!row.verifierAssigned) return { kind: "assign_verifier" };
+			return { kind: "noop" };
+		case "floor_failed":
+			if (row.retries < policy.maxRetries) return {
+				kind: "ask_model",
+				request: "author_fix"
+			};
+			return {
+				kind: "escalate_human",
+				reason: "floor-keeper verdict is no-go after the retry cap"
+			};
+		case "floor_passed": return {
+			kind: "escalate_human",
+			reason: "ready to merge — approval required"
+		};
+		case "ci_running": return { kind: "noop" };
+		case "floor_pending": return {
+			kind: "ask_model",
+			request: "judge_review"
+		};
+		default: break;
+	}
+	return { kind: "noop" };
+}
+
+//#endregion
+//#region src/lib/first-mate/types.ts
+const DEFAULT_POLICY = { maxRetries: 3 };
+
+//#endregion
+//#region src/lib/first-mate/controller.ts
+const MODEL_KINDS = [
+	"review_plan",
+	"answer_agent_question",
+	"author_fix",
+	"judge_review"
+];
+const PROVIDER_STATES = new Set([
+	"none",
+	"queued",
+	"in_progress",
+	"waiting_for_user",
+	"completed",
+	"failed",
+	"timed_out",
+	"cancelled"
+]);
+const DEFAULT_MAX_IN_FLIGHT_PER_PROVIDER = 6;
+const DEFAULT_TOP_K = 6;
+const defaultDeps = {
+	loadAllUnits,
+	readMissions,
+	upsertUnit,
+	pruneTerminal,
+	observeUnit,
+	classifyPlanReady,
+	classifyQuestionAnswerable,
+	classifyFixAddressed,
+	classifyStuck,
+	verifyAndConsumeApproval,
+	recordApproval,
+	upsertDecision,
+	findByKey,
+	markAnswered,
+	startTask,
+	followUpTask,
+	cancelTask,
+	createIssue,
+	resolveAgentActor,
+	resolveAgentRoster,
+	assignAgent,
+	findAgentPRs,
+	getPullRequestState,
+	postComment,
+	submitReview,
+	requestReview,
+	rerunChecks,
+	mergePullRequest,
+	markReadyForReview,
+	buildDecisionPacket,
+	writeDecisionPacketHtml
+};
+function sanitizeSegment(value) {
+	const cleaned = value.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+$/, "_");
+	return cleaned.length > 0 ? cleaned : "_";
+}
+async function writeDecisionPacketHtml(packetId, html) {
+	const dir = nodePath.join(PATHS.FIRST_MATE_DIR, "packets");
+	await fs.mkdir(dir, { recursive: true });
+	const target = nodePath.join(dir, `${sanitizeSegment(packetId)}.html`);
+	await fs.writeFile(target, html, { mode: 384 });
+	return target;
+}
+function agentRepo(repo) {
+	return {
+		owner: repo.owner,
+		repo: repo.name
+	};
+}
+function unitHandle(unit) {
+	return String(unit.issue ?? unit.taskId);
+}
+function requestIdFor(unit, kind) {
+	return `${unit.missionId}:${unitHandle(unit)}:${kind}`;
+}
+function humanRequestBase(unit, type) {
+	return `${unit.missionId}:${unitHandle(unit)}:${type}`;
+}
+function asRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function booleanValue(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Compact single-line error text for the `applied` audit trail. */
+function errText(err) {
+	return (err instanceof Error ? err.message : String(err)).replace(/\s+/g, " ").slice(0, 200);
+}
+function compact(value, max = 1200) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	if (trimmed.length <= max) return trimmed;
+	return `${trimmed.slice(0, max - 16)}…[truncated]…`;
+}
+function providerState(value, fallback) {
+	return PROVIDER_STATES.has(value) ? value : fallback;
+}
+function missionMap(missions) {
+	return new Map(missions.map((mission) => [mission.id, mission]));
+}
+function repoLabel$1(repo) {
+	return `${repo.owner}/${repo.name}`;
+}
+function sortKey(unit) {
+	return unit.lastCheckedMs ?? unit.lastSteer?.atMs ?? 0;
+}
+function findModelTarget(units, requestId) {
+	for (const unit of units) for (const kind of MODEL_KINDS) if (requestIdFor(unit, kind) === requestId) return {
+		unit,
+		kind
+	};
+}
+function mergePolicy(input) {
+	return {
+		...DEFAULT_POLICY,
+		...input ?? {}
+	};
+}
+function positiveInteger(value, fallback) {
+	if (value === void 0) return fallback;
+	return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function observedRecord(observed) {
+	return observed;
+}
+function initialEvidence(observed) {
+	const record = observedRecord(observed);
+	return {
+		planExcerpt: stringValue(record.planExcerpt),
+		logExcerpt: stringValue(record.logExcerpt),
+		question: stringValue(record.question) ?? stringValue(record.agentQuestion) ?? stringValue(record.prompt),
+		suggestedAnswer: stringValue(record.suggestedAnswer),
+		failureSummary: stringValue(record.failureSummary) ?? stringValue(record.ciExcerpt) ?? stringValue(record.reviewExcerpt),
+		latestLogExcerpt: stringValue(record.latestLogExcerpt),
+		runId: numberValue(record.runId),
+		prNodeId: stringValue(record.prNodeId)
+	};
+}
+async function fillFuzzyFields(unit, mission, observed, deps) {
+	const evidence = initialEvidence(observed);
+	if (observed.provider === "completed" && observed.prs.length === 0 && observed.planReady === void 0 && evidence.logExcerpt !== void 0) {
+		const result = await deps.classifyPlanReady(evidence.logExcerpt);
+		if (result !== null) {
+			observed.planReady = result.planReady;
+			if (result.planExcerpt.length > 0) evidence.planExcerpt = result.planExcerpt;
+		}
+		unit.planExcerpt = evidence.planExcerpt ?? evidence.logExcerpt;
+	}
+	if (observed.provider === "waiting_for_user" && observed.agentQuestionAnswerableFromAC === void 0 && evidence.question !== void 0) {
+		const result = await deps.classifyQuestionAnswerable(evidence.question, mission.acceptanceCriteria);
+		if (result !== null) {
+			observed.agentQuestionAnswerableFromAC = result.answerable;
+			evidence.suggestedAnswer = result.answer;
+		}
+	}
+	if (unit.lastSteer !== void 0 && observed.steerAcknowledged === void 0 && evidence.failureSummary !== void 0 && evidence.latestLogExcerpt !== void 0) {
+		const result = await deps.classifyFixAddressed(evidence.failureSummary, evidence.latestLogExcerpt);
+		if (result !== null) observed.steerAcknowledged = result.addressed;
+	}
+	if (observed.provider === "in_progress" && observed.steerAcknowledged === void 0 && evidence.logExcerpt !== void 0) {
+		const result = await deps.classifyStuck(evidence.logExcerpt);
+		if (result !== null && result.stuck) observed.steerAcknowledged = false;
+	}
+	return evidence;
+}
+function updateUnitFromObservedPrs(unit, observed) {
+	if (observed.prs.length !== 1) return;
+	const pr = observed.prs[0];
+	unit.pr = pr.number;
+	unit.headSha = pr.headSha || unit.headSha;
+}
+function modelPayload(kind, unit, mission, observed, evidence) {
+	const common = {
+		goal: compact(mission.goal, 1e3),
+		acceptance_criteria: compact(mission.acceptanceCriteria, 1600),
+		house_rules: compact(mission.houseRules, 1e3),
+		unit_title: compact(unit.title, 500),
+		repo: repoLabel$1(unit.repo),
+		issue: unit.issue,
+		pr: unit.pr,
+		phase: unit.phase,
+		validation: unit.validation,
+		head_sha: unit.headSha,
+		base_sha: unit.baseSha
+	};
+	if (kind === "review_plan") return {
+		...common,
+		plan_excerpt: compact(evidence.planExcerpt || evidence.logExcerpt, 1200)
+	};
+	if (kind === "answer_agent_question") return {
+		...common,
+		question: compact(evidence.question, 1e3),
+		suggested_answer_from_ac: compact(evidence.suggestedAnswer, 1e3),
+		answerable_from_acceptance_criteria: observed.agentQuestionAnswerableFromAC ?? null
+	};
+	if (kind === "author_fix") return {
+		...common,
+		failure_summary: compact(evidence.failureSummary ?? `${unit.validation} on PR #${unit.pr ?? "unknown"}`, 1400),
+		ci_rollup: observed.ci?.rollup,
+		review_decision: observed.reviewDecision,
+		floor_verdict: observed.floor
+	};
+	return {
+		...common,
+		review_summary: compact(evidence.failureSummary, 1400),
+		plan_excerpt: compact(unit.planExcerpt, 1e3),
+		ci_rollup: observed.ci?.rollup,
+		floor_verdict: observed.floor
+	};
+}
+function buildModelRequest(unit, mission, kind, observed, evidence) {
+	return {
+		requestId: requestIdFor(unit, kind),
+		kind,
+		missionId: unit.missionId,
+		repo: unit.repo,
+		issue: unit.issue,
+		pr: unit.pr,
+		payload: modelPayload(kind, unit, mission, observed, evidence)
+	};
+}
+function isMergeEscalation(unit, reason) {
+	return unit.validation === "floor_passed" || reason.toLowerCase().includes("merge");
+}
+function decisionType(unit, reason) {
+	return isMergeEscalation(unit, reason) ? "merge_approval" : "human_decision";
+}
+function inputFingerprint(unit, observed, reason) {
+	const observedHead = observed.prs.length === 1 ? observed.prs[0]?.headSha : void 0;
+	return [
+		`pr=${unit.pr ?? "none"}`,
+		`head=${unit.headSha ?? observedHead ?? "none"}`,
+		`base=${unit.baseSha ?? "none"}`,
+		`validation=${unit.validation}`,
+		`artifact=${unit.artifact}`,
+		`reason=${reason}`
+	].join("|");
+}
+function decisionKeyFor(unit, observed, reason) {
+	const type = decisionType(unit, reason);
+	const fingerprint = inputFingerprint(unit, observed, reason);
+	return {
+		type,
+		fingerprint,
+		decisionKey: `${humanRequestBase(unit, type)}:${fingerprint}`
+	};
+}
+function decisionOptions(type) {
+	if (type === "merge_approval") return [
+		{
+			id: "approve_merge",
+			label: "Approve merge",
+			consequence: "If a matching durable approval is recorded, the next wake may merge the live PR head.",
+			recommended: true
+		},
+		{
+			id: "hold",
+			label: "Hold",
+			consequence: "The controller will leave the PR open and ask again later."
+		},
+		{
+			id: "abandon",
+			label: "Abandon",
+			consequence: "The unit will be marked terminal without merging."
+		}
+	];
+	return [{
+		id: "continue",
+		label: "Continue manually",
+		consequence: "A human should decide the next implementation step.",
+		recommended: true
+	}, {
+		id: "abandon",
+		label: "Abandon",
+		consequence: "The unit will be marked terminal without merging."
+	}];
+}
+function packetInput(unit, mission, observed, reason, type) {
+	const pr = unit.pr ?? (observed.prs.length === 1 ? observed.prs[0]?.number ?? null : null);
+	return {
+		type,
+		tldr: type === "merge_approval" ? `Merge approval needed for ${unit.title}` : `${mission.goal}: ${reason}`,
+		question: type === "merge_approval" ? `Approve merging ${repoLabel$1(unit.repo)} PR #${pr ?? "unknown"}?` : `How should first mate proceed? ${reason}`,
+		options: decisionOptions(type),
+		evidence: {
+			prSummary: pr === null ? void 0 : `${repoLabel$1(unit.repo)} PR #${pr}`,
+			ciExcerpt: observed.ci?.rollup,
+			floorVerdict: observed.floor ?? unit.validation,
+			links: pr === null ? void 0 : [{
+				label: `PR #${pr}`,
+				url: `https://github.com/${unit.repo.owner}/${unit.repo.name}/pull/${pr}`
+			}]
+		},
+		missionId: unit.missionId,
+		repo: unit.repo,
+		unit: {
+			issue: unit.issue,
+			pr
+		}
+	};
+}
+function isAbandonChoice(choice) {
+	const normalized = choice.toLowerCase();
+	return normalized.includes("abandon") || normalized.includes("cancel");
+}
+function isApproveMergeChoice(choice) {
+	const normalized = choice.toLowerCase();
+	return normalized.includes("approve") || normalized === "merge";
+}
+async function applyModelAnswer(answer, units, missions, deps, applied) {
+	const target = findModelTarget(units, answer.requestId);
+	if (target === void 0) {
+		consola.debug(`first-mate controller ignored unknown model answer ${answer.requestId}`);
+		return;
+	}
+	const { unit, kind } = target;
+	const verdict = asRecord$1(answer.verdict) ?? {};
+	const repo = agentRepo(unit.repo);
+	if (kind === "review_plan") {
+		const decision = stringValue(verdict.decision);
+		const mission = missions.find((entry) => entry.id === unit.missionId);
+		if (decision === "approve") {
+			if (mission !== void 0) {
+				const task = await dispatchWithOutbox(unit, deps, ({ idempotencyKey, promptTag }) => deps.startTask(repo, {
+					prompt: buildPrompt(unit, mission) + promptTag,
+					createPullRequest: true,
+					idempotencyKey
+				}));
+				if (task) {
+					unit.taskId = task.taskId;
+					unit.provider = providerState(task.state, "queued");
+					unit.phase = "build";
+					unit.dispatchMode = "build";
+					unit.implementerLab = unit.agent;
+					unit.lastSteer = { atMs: Date.now() };
+					applied.push(`approved plan → dispatched build for ${unit.missionId}:${unitHandle(unit)}`);
+				}
+			}
+		} else if (decision === "refine") {
+			const instruction = stringValue(verdict.instruction) ?? "Refine the plan with more concrete implementation steps.";
+			if (mission !== void 0) {
+				const prompt = `${planPrompt(unit, mission)}\n\nRefine your previous plan per this feedback:\n${instruction}`;
+				const task = await dispatchWithOutbox(unit, deps, ({ idempotencyKey, promptTag }) => deps.startTask(repo, {
+					prompt: prompt + promptTag,
+					createPullRequest: false,
+					idempotencyKey
+				}));
+				if (task) {
+					unit.taskId = task.taskId;
+					unit.provider = providerState(task.state, "queued");
+					unit.phase = "plan";
+					unit.dispatchMode = "plan";
+					unit.planExcerpt = void 0;
+					unit.lastSteer = { atMs: Date.now() };
+					applied.push(`requested plan refinement for ${unit.missionId}:${unitHandle(unit)}`);
+				}
+			}
+		}
+	} else if (kind === "author_fix") {
+		const instruction = stringValue(verdict.instruction) ?? "Fix the reported validation failure and update the PR.";
+		if (unit.pr !== null) await deps.submitReview(repo, unit.pr, "REQUEST_CHANGES", instruction);
+		unit.retries += 1;
+		unit.phase = "fix";
+		unit.lastSteer = {
+			sha: unit.headSha ?? void 0,
+			atMs: Date.now()
+		};
+		applied.push(`sent fix instruction for ${unit.missionId}:${unitHandle(unit)}`);
+	} else if (kind === "answer_agent_question") {
+		const answerText = stringValue(verdict.answer);
+		if (answerText !== void 0 && unit.pr !== null) {
+			await deps.postComment(repo, unit.pr, answerText);
+			unit.lastSteer = {
+				sha: unit.headSha ?? void 0,
+				atMs: Date.now()
+			};
+			applied.push(`answered agent question for ${unit.missionId}:${unitHandle(unit)}`);
+		}
+	} else if (kind === "judge_review") {
+		if (!(unit.verifierAssigned === true && (unit.validation === "review_pending" || unit.validation === "ci_passed" || unit.validation === "no_ci" || unit.validation === "floor_pending"))) {
+			consola.debug(`first-mate: ignoring judge_review for ${unit.missionId}:${unitHandle(unit)} — unit is not in a verification state`);
+			return;
+		}
+		const passed = booleanValue(verdict.pass) === true;
+		unit.validation = passed ? "floor_passed" : "floor_failed";
+		unit.floorSha = unit.headSha ?? null;
+		if (unit.pr !== null) {
+			const reason = stringValue(verdict.reason) ?? (passed ? "Verified: meets acceptance criteria." : "Changes requested by cross-lab verification.");
+			try {
+				await deps.submitReview(repo, unit.pr, passed ? "APPROVE" : "REQUEST_CHANGES", reason);
+			} catch (err) {
+				consola.debug(`first-mate: posting judge verdict review failed for ${unit.missionId}:${unitHandle(unit)}:`, err);
+			}
+		}
+		applied.push(`recorded verifier judgment (${passed ? "pass" : "fail"}) for ${unit.missionId}:${unitHandle(unit)}`);
+	}
+	await deps.upsertUnit(unit.repo, unit);
+}
+async function applyHumanDecision(decision, units, deps, applied) {
+	const decisionId = (await deps.findByKey(decision.requestId))?.decisionId ?? units.find((unit) => unit.blockingDecisionId === decision.requestId)?.blockingDecisionId;
+	if (decisionId === void 0 || decisionId === null) {
+		consola.debug(`first-mate controller ignored unknown human decision ${decision.requestId}`);
+		return;
+	}
+	await deps.markAnswered(decisionId, decision.choice, "human");
+	for (const unit of units.filter((row) => row.blockingDecisionId === decisionId)) {
+		unit.blockingDecisionId = null;
+		if (isAbandonChoice(decision.choice)) {
+			unit.terminal = true;
+			unit.phase = "done";
+			unit.cancelledBy = "external";
+		} else if (isApproveMergeChoice(decision.choice) && unit.pr !== null) {
+			if (unit.validation !== "floor_passed") {
+				consola.debug(`first-mate: ignoring merge approval for ${unitHandle(unit)} — unit is not floor_passed`);
+				await deps.upsertUnit(unit.repo, unit);
+				continue;
+			}
+			try {
+				const live = await deps.getPullRequestState(agentRepo(unit.repo), unit.pr);
+				if (unit.floorSha != null && unit.floorSha.length > 0 && live.headSha !== unit.floorSha) consola.warn(`first-mate: refusing merge approval for ${repoLabel$1(unit.repo)}#${live.number} — head moved since the floor verdict; re-verification required`);
+				else if (live.headSha.length > 0) {
+					await deps.recordApproval({
+						decisionId,
+						repo: unit.repo,
+						pr: live.number,
+						headSha: live.headSha,
+						baseSha: live.baseSha
+					});
+					applied.push(`recorded merge approval for ${repoLabel$1(unit.repo)}#${live.number}`);
+				}
+			} catch (err) {
+				consola.debug("first-mate: could not record merge approval", err);
+			}
+		}
+		await deps.upsertUnit(unit.repo, unit);
+	}
+	applied.push(`recorded human decision ${decision.choice}`);
+}
+async function applySubmittedAnswers(input, deps, applied) {
+	const units = await deps.loadAllUnits();
+	const missions = await deps.readMissions();
+	for (const answer of input.modelAnswers ?? []) try {
+		if (answer.requestId.startsWith("decompose:")) await applyDecomposeAnswer(answer, missions, deps, applied);
+		else await applyModelAnswer(answer, units, missions, deps, applied);
+	} catch (err) {
+		consola.warn(`first-mate: model answer ${answer.requestId} failed to apply:`, err);
+		applied.push(`error applying answer ${answer.requestId}: ${errText(err)}`);
 	}
-	let instances;
-	if (instanceArgs !== void 0 && instanceArgs.length > 0) {
-		instances = uniqueInstances(await Promise.all(instanceArgs.map((arg) => registry.resolveInstance(arg))));
-		const ids = new Set(instances.map((instance) => instance.id));
-		for (const instanceId of localSessionIdsByInstance.keys()) if (!ids.has(instanceId)) throw new FleetToolInputError("INSTANCE_MISMATCH", `sessionIds include instance ${JSON.stringify(instanceId)} which is not in arguments.instances`);
-	} else if (localSessionIdsByInstance.size > 0) instances = uniqueInstances(await Promise.all([...localSessionIdsByInstance.keys()].map((instanceId) => registry.resolveInstance(instanceId))));
-	else {
-		const infos = await registry.listInstances();
-		if (infos.length === 0) throw new FleetRegistryError("INSTANCE_REQUIRED", "await_turn requires at least one registered fleet instance");
-		instances = uniqueInstances(await Promise.all(infos.map((info) => registry.resolveInstance(info.id))));
+	for (const decision of input.humanDecisions ?? []) try {
+		await applyHumanDecision(decision, units, deps, applied);
+	} catch (err) {
+		consola.warn(`first-mate: human decision ${decision.requestId} failed to apply:`, err);
+		applied.push(`error applying decision ${decision.requestId}: ${errText(err)}`);
 	}
-	return {
-		instances,
-		localSessionIdsByInstance
-	};
 }
-function globalizeSession(instanceId, session) {
+/** Parse an "owner/name" repo string into a RepoRef. */
+function parseRepoRef$1(value) {
+	if (value === void 0) return void 0;
+	const parts = value.split("/");
+	if (parts.length !== 2 || parts[0].length === 0 || parts[1].length === 0) return;
 	return {
-		...session,
-		sessionId: encodeSessionId(instanceId, session.sessionId)
-	};
+		owner: parts[0],
+		name: parts[1]
+	};
+}
+function asAgentKey(value) {
+	return value === "copilot" || value === "anthropic" || value === "openai" ? value : void 0;
+}
+/**
+* Turn a model `decompose` answer into queued units. This is the mission→units
+* step: `start_mission` only registers the mission; `advance` emits one
+* `decompose` request per unit-less active mission, and the model answers with
+* `{ units: [{ title, repo?, agent?, dependsOn? }] }`. Each unit gets a stable
+* `id` so it survives the queued→dispatched transition without duplicating.
+*/
+async function applyDecomposeAnswer(answer, missions, deps, applied) {
+	const missionId = answer.requestId.slice(10);
+	const mission = missions.find((m) => m.id === missionId);
+	if (mission === void 0) return;
+	const verdict = asRecord$1(answer.verdict) ?? {};
+	const rawUnits = Array.isArray(verdict.units) ? verdict.units : [];
+	const specs = [];
+	for (const raw of rawUnits) {
+		const spec = asRecord$1(raw) ?? {};
+		const title = stringValue(spec.title);
+		if (title === void 0 || title.length === 0) continue;
+		const repo = parseRepoRef$1(stringValue(spec.repo)) ?? mission.repos[0];
+		if (repo === void 0) continue;
+		specs.push({
+			spec,
+			title,
+			repo
+		});
+	}
+	const ids = specs.map(() => randomUUID());
+	let created = 0;
+	for (let i = 0; i < specs.length; i += 1) {
+		const { spec, title, repo } = specs[i];
+		const dependsOn = (Array.isArray(spec.dependsOn) ? spec.dependsOn : []).filter((idx) => typeof idx === "number" && Number.isInteger(idx) && idx >= 0 && idx < ids.length && idx !== i).map((idx) => ids[idx]);
+		const unit = {
+			id: ids[i],
+			missionId,
+			repo,
+			issue: null,
+			pr: null,
+			taskId: null,
+			agent: asAgentKey(stringValue(spec.agent)) ?? "copilot",
+			botLogin: "",
+			dispatchMode: "plan",
+			provider: "none",
+			phase: "plan",
+			artifact: "no_pr",
+			validation: "unknown",
+			retries: 0,
+			dependsOn,
+			title
+		};
+		await deps.upsertUnit(repo, unit);
+		created += 1;
+	}
+	if (created > 0) applied.push(`decomposed ${missionId} into ${created} unit(s)`);
+}
+async function maybeMergeWithApproval(unit, observed, evidence, deps, applied) {
+	if (unit.validation !== "floor_passed" && observed.floor !== "passed") return false;
+	const pr = unit.pr ?? (observed.prs.length === 1 ? observed.prs[0]?.number ?? null : null);
+	if (pr === null) return false;
+	const live = await deps.getPullRequestState(agentRepo(unit.repo), pr);
+	unit.pr = live.number;
+	unit.headSha = live.headSha || unit.headSha;
+	unit.baseSha = live.baseSha ?? unit.baseSha;
+	unit.branch = live.baseRef || unit.branch;
+	if (unit.floorSha != null && unit.floorSha.length > 0 && live.headSha.length > 0 && live.headSha !== unit.floorSha) return false;
+	const head = live.headSha.length > 0 ? live.headSha : unit.headSha ?? void 0;
+	if (head === void 0 || head.length === 0) return false;
+	if (!(await deps.verifyAndConsumeApproval({
+		repo: unit.repo,
+		pr: live.number,
+		liveHeadSha: head,
+		liveBaseSha: live.baseSha
+	})).ok) return false;
+	if (live.isDraft && evidence.prNodeId !== void 0) await deps.markReadyForReview(evidence.prNodeId);
+	await deps.mergePullRequest(agentRepo(unit.repo), {
+		pr: live.number,
+		expectedHeadSha: head
+	});
+	unit.terminal = true;
+	unit.phase = "done";
+	unit.artifact = "pr_merged";
+	unit.validation = "floor_passed";
+	applied.push(`merged ${repoLabel$1(unit.repo)}#${live.number}`);
+	await deps.upsertUnit(unit.repo, unit);
+	return true;
 }
-function stampEvent(instance, event) {
+async function createHumanRequest(unit, mission, observed, reason, deps) {
+	const { decisionKey, fingerprint, type } = decisionKeyFor(unit, observed, reason);
+	const existing = await deps.findByKey(decisionKey);
+	let record = existing?.status === "pending" ? existing : void 0;
+	let packetHtmlPath;
+	if (record === void 0) {
+		const packet = deps.buildDecisionPacket(packetInput(unit, mission, observed, reason, type));
+		packetHtmlPath = await deps.writeDecisionPacketHtml(packet.packetId, packet.html);
+		record = {
+			decisionId: packet.decisionId,
+			decisionKey,
+			type,
+			status: "pending",
+			packetId: packet.packetId,
+			inputFingerprint: fingerprint,
+			options: decisionOptions(type).map((option) => ({ id: option.id })),
+			createdMs: Date.now()
+		};
+		await deps.upsertDecision(record);
+	}
+	unit.blockingDecisionId = record.decisionId;
 	return {
-		...event,
-		instance: publicInstance(instance),
-		...typeof event.sessionId === "string" ? { sessionId: encodeSessionId(instance.id, event.sessionId) } : {}
+		requestId: decisionKey,
+		decisionId: record.decisionId,
+		missionId: unit.missionId,
+		repo: unit.repo,
+		issue: unit.issue,
+		pr: unit.pr,
+		reason,
+		...packetHtmlPath !== void 0 ? { packetHtmlPath } : {}
 	};
 }
-function eventAtMs(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string") {
-		const parsed = Date.parse(value);
-		if (!Number.isNaN(parsed)) return parsed;
+async function assignVerifier(unit, deps, applied) {
+	if (unit.pr === null) return false;
+	await deps.requestReview(agentRepo(unit.repo), unit.pr, COPILOT_REVIEWER_LOGIN);
+	unit.verifierAssigned = true;
+	unit.verifierSha = unit.headSha ?? void 0;
+	unit.validation = "floor_pending";
+	unit.lastSteer = { atMs: Date.now() };
+	applied.push(`requested Copilot code review for ${unit.missionId}:${unitHandle(unit)} PR #${unit.pr}`);
+	return true;
+}
+async function executeAction(action, unit, mission, observed, evidence, policy, deps, needsModel, needsHuman, applied, order) {
+	switch (action.kind) {
+		case "dispatch": return;
+		case "steer":
+			consola.debug("first-mate controller received direct steer action; v1 skips it");
+			return;
+		case "assign_verifier":
+			if (await assignVerifier(unit, deps, applied)) return;
+			needsHuman.push({
+				request: await createHumanRequest(unit, mission, observed, "no different-lab verifier is available", deps),
+				sortKey: sortKey(unit),
+				order
+			});
+			return;
+		case "rerun_ci":
+			if (evidence.runId !== void 0) {
+				await deps.rerunChecks(agentRepo(unit.repo), {
+					runId: evidence.runId,
+					failedOnly: true
+				});
+				applied.push(`reran checks for ${unit.missionId}:${unitHandle(unit)}`);
+			}
+			return;
+		case "cancel":
+			if (unit.taskId !== null) await deps.cancelTask(agentRepo(unit.repo), unit.taskId);
+			unit.terminal = true;
+			unit.phase = "done";
+			unit.cancelledBy = "controller";
+			applied.push(`cancelled ${unit.missionId}:${unitHandle(unit)}`);
+			return;
+		case "mark_done":
+			unit.terminal = true;
+			unit.phase = "done";
+			applied.push(`marked done ${unit.missionId}:${unitHandle(unit)}`);
+			return;
+		case "ask_model":
+			needsModel.push({
+				request: buildModelRequest(unit, mission, action.request, observed, evidence),
+				sortKey: sortKey(unit),
+				order
+			});
+			return;
+		case "escalate_human":
+			needsHuman.push({
+				request: await createHumanRequest(unit, mission, observed, action.reason, deps),
+				sortKey: sortKey(unit),
+				order
+			});
+			return;
+		case "merge":
+		case "mark_rebase":
+		case "noop": return;
 	}
-	return 0;
 }
-function compareStampedEvents(a, b) {
-	const atA = eventAtMs(a.at);
-	const atB = eventAtMs(b.at);
-	if (atA !== atB) return atA - atB;
-	return (typeof a.seq === "number" ? a.seq : 0) - (typeof b.seq === "number" ? b.seq : 0);
+function isUndispatched(unit) {
+	return unit.provider === "none" && unit.taskId === null && unit.dispatch === void 0;
 }
-const MAX_WATCHER_ID_LEN = 200;
-const MAX_AWAIT_TURN_CURSOR_KEYS = 1024;
-function awaitTurnCursorKey(watcherId) {
-	const id = watcherId ?? "default";
-	return id.length > MAX_WATCHER_ID_LEN ? id.slice(0, MAX_WATCHER_ID_LEN) : id;
+/** A dispatch that was interrupted mid-flight (intent persisted, no taskId yet). */
+function isDispatchInterrupted(unit) {
+	return unit.dispatch !== void 0 && unit.taskId === null;
 }
-function takeAwaitTurnCursorMap(clientKey) {
-	const existing = awaitTurnCursors.get(clientKey);
-	if (existing) {
-		awaitTurnCursors.delete(clientKey);
-		awaitTurnCursors.set(clientKey, existing);
-		return existing;
+function isActiveMissionUnit(unit, missions) {
+	return missions.get(unit.missionId)?.status === "active";
+}
+function isActiveUnit(unit, missions) {
+	return isActiveMissionUnit(unit, missions) && unit.terminal !== true;
+}
+function isInFlight(unit) {
+	return unit.terminal !== true && unit.taskId !== null && (unit.provider === "queued" || unit.provider === "in_progress" || unit.provider === "waiting_for_user");
+}
+function depsSatisfied(unit, units) {
+	return unit.dependsOn.every((depId) => units.some((candidate) => candidate.id === depId && candidate.terminal === true && candidate.artifact === "pr_merged"));
+}
+function activeCountsByAgent(units) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		if (!isInFlight(unit)) continue;
+		counts.set(unit.agent, (counts.get(unit.agent) ?? 0) + 1);
 	}
-	const created = /* @__PURE__ */ new Map();
-	awaitTurnCursors.set(clientKey, created);
-	while (awaitTurnCursors.size > MAX_AWAIT_TURN_CURSOR_KEYS) {
-		const oldest = awaitTurnCursors.keys().next().value;
-		if (oldest === void 0) break;
-		awaitTurnCursors.delete(oldest);
+	return counts;
+}
+function planPrompt(unit, mission) {
+	const parts = [
+		`Mission goal:\n${mission.goal}`,
+		`Acceptance criteria:\n${mission.acceptanceCriteria}`,
+		`Work unit:\n${unit.title}`,
+		"Analyze the repository and produce a concrete, step-by-step implementation plan for this work unit: the files you will change, the approach, key risks, and how each acceptance criterion will be verified. Do NOT edit code or open a pull request yet — output the plan and stop. It will be reviewed before implementation."
+	];
+	if (mission.houseRules !== void 0) parts.splice(2, 0, `House rules:\n${mission.houseRules}`);
+	return parts.join("\n\n");
+}
+function buildPrompt(unit, mission) {
+	const parts = [
+		`Mission goal:\n${mission.goal}`,
+		`Acceptance criteria:\n${mission.acceptanceCriteria}`,
+		`Work unit:\n${unit.title}`
+	];
+	if (mission.houseRules !== void 0) parts.push(`House rules:\n${mission.houseRules}`);
+	if (unit.planExcerpt !== void 0 && unit.planExcerpt.trim().length > 0) parts.push(`Approved plan (implement this):\n${unit.planExcerpt.trim()}`);
+	parts.push("Implement this work unit end-to-end on a new branch and open a pull request for review. Follow the approved plan above. Keep the change focused on this unit and do not modify unrelated files. If anything about the acceptance criteria is ambiguous, make a reasonable choice and note it in the PR description.");
+	return parts.join("\n\n");
+}
+/**
+* Durable dispatch outbox. Persists a dispatch-intent (with a correlation id)
+* BEFORE the irreversible startTask, so a crash in the startTask→persist window
+* leaves the unit marked (not `isUndispatched`) and is never blind-re-dispatched.
+* `start` receives the correlation id to embed in the prompt and send as the
+* Idempotency-Key. On success the intent is cleared (in memory; the caller's
+* upsertUnit persists it alongside the taskId). On throw the intent stays
+* pending on disk (unknown outcome — recovery, not re-dispatch, resolves it).
+* Returns null when the API returned no taskId — treated as ambiguous, so the
+* intent is LEFT pending (recovery escalates; never auto-re-dispatch).
+*/
+async function dispatchWithOutbox(unit, deps, start) {
+	const id = randomUUID();
+	unit.dispatch = {
+		id,
+		requestedMs: Date.now(),
+		attempts: (unit.dispatch?.attempts ?? 0) + 1
+	};
+	await deps.upsertUnit(unit.repo, unit);
+	const task = await start({
+		idempotencyKey: id,
+		promptTag: `\n\n<!-- fm-dispatch:${id} -->`
+	});
+	if (task.taskId.length === 0) return null;
+	unit.dispatch = void 0;
+	return task;
+}
+async function dispatchUnit(unit, mission, deps) {
+	const repo = agentRepo(unit.repo);
+	const actor = await deps.resolveAgentActor(repo, unit.agent);
+	const task = await dispatchWithOutbox(unit, deps, ({ idempotencyKey, promptTag }) => deps.startTask(repo, {
+		prompt: planPrompt(unit, mission) + promptTag,
+		createPullRequest: false,
+		idempotencyKey
+	}));
+	if (task === null) return;
+	unit.taskId = task.taskId;
+	unit.provider = providerState(task.state, "queued");
+	unit.botLogin = actor.login;
+	unit.dispatchMode = "plan";
+	unit.phase = "plan";
+	unit.implementerLab = unit.agent;
+	unit.lastSteer = { atMs: Date.now() };
+}
+async function dispatchWave(units, missions, maxInFlightPerProvider, deps, applied) {
+	const counts = activeCountsByAgent(units);
+	const candidates = units.filter((unit) => isActiveUnit(unit, missions)).filter((unit) => !unit.blockingDecisionId).filter(isUndispatched).filter((unit) => depsSatisfied(unit, units)).map((unit, index) => ({
+		unit,
+		index
+	})).sort((a, b) => sortKey(a.unit) - sortKey(b.unit) || a.index - b.index);
+	for (const { unit } of candidates) {
+		const current = counts.get(unit.agent) ?? 0;
+		if (current >= maxInFlightPerProvider) continue;
+		const mission = missions.get(unit.missionId);
+		if (mission === void 0) continue;
+		try {
+			await dispatchUnit(unit, mission, deps);
+			counts.set(unit.agent, current + 1);
+			await deps.upsertUnit(unit.repo, unit);
+			applied.push(`dispatched ${unit.missionId}:${unitHandle(unit)} to ${unit.agent}`);
+		} catch (err) {
+			consola.warn(`first-mate: dispatch of ${unit.missionId}:${unitHandle(unit)} failed:`, err);
+			applied.push(`error dispatching ${unit.missionId}:${unitHandle(unit)}: ${errText(err)}`);
+		}
+	}
+}
+function buildBoard$1(units, missions) {
+	const rows = [];
+	for (const mission of missions.filter((entry) => entry.status === "active")) {
+		const missionUnits = units.filter((unit) => unit.missionId === mission.id);
+		const counts = {};
+		for (const unit of missionUnits) counts[unit.phase] = (counts[unit.phase] ?? 0) + 1;
+		rows.push({
+			missionId: mission.id,
+			title: mission.goal,
+			repos: mission.repos.map(repoLabel$1),
+			counts,
+			blocked: missionUnits.filter((unit) => unit.blockingDecisionId).length
+		});
 	}
-	return created;
+	return rows;
 }
-function isAwaitTurnSuccess(result) {
-	return result.ok;
+function compareQueued(a, b) {
+	return a.sortKey - b.sortKey || a.order - b.order;
 }
-function isAwaitTurnFailure(result) {
-	return !result.ok;
+function capQueued(entries, topK) {
+	return entries.sort(compareQueued).slice(0, topK).map((entry) => entry.request);
 }
-function failedProbeResult(info, code) {
-	const hint = fleetProbeHint(code);
+function nextWakeAt(units, missions) {
+	const active = units.filter((unit) => isActiveUnit(unit, missions));
+	if (active.length === 0) return null;
+	const now = Date.now();
+	if (active.some((unit) => unit.validation === "ci_running" || unit.provider === "in_progress")) return now + 9e4;
+	if (active.every((unit) => Boolean(unit.blockingDecisionId) || unit.provider === "none" || unit.provider === "queued")) return now + 9e5;
+	return now + 3e5;
+}
+const MIN_WAKE_SECONDS = 60;
+const MAX_WAKE_SECONDS = 3600;
+function wakeSeconds(wakeAt) {
+	if (wakeAt === null) return null;
+	const seconds = Math.round((wakeAt - Date.now()) / 1e3);
+	return Math.min(MAX_WAKE_SECONDS, Math.max(MIN_WAKE_SECONDS, seconds));
+}
+async function pruneTerminalRepos(units, deps) {
+	const repos = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		if (unit.terminal !== true) continue;
+		repos.set(repoLabel$1(unit.repo), unit.repo);
+	}
+	for (const repo of repos.values()) await deps.pruneTerminal(repo);
+}
+/**
+* Single-pass deterministic controller wake. Real deployments should wrap this
+* in a per-repo lock before durable ledger writes; the engine itself is kept
+* dependency-injected so tests can run without network or filesystem effects.
+*/
+async function advance(input = {}, deps = defaultDeps) {
+	const applied = [];
+	const needsModel = [];
+	const needsHuman = [];
+	const policy = mergePolicy(input.policy);
+	const maxInFlightPerProvider = positiveInteger(input.maxInFlightPerProvider, DEFAULT_MAX_IN_FLIGHT_PER_PROVIDER);
+	const topK = positiveInteger(input.topK, DEFAULT_TOP_K);
+	await applySubmittedAnswers(input, deps, applied);
+	const units = await deps.loadAllUnits();
+	const missions = await deps.readMissions();
+	const missionsById = missionMap(missions);
+	let order = 0;
+	for (const unit of units.filter((row) => isActiveUnit(row, missionsById))) {
+		const requestOrder = order;
+		order += 1;
+		if (unit.blockingDecisionId) continue;
+		if (isUndispatched(unit)) continue;
+		const mission = missionsById.get(unit.missionId);
+		if (mission === void 0) continue;
+		try {
+			if (isDispatchInterrupted(unit)) {
+				needsHuman.push({
+					request: await createHumanRequest(unit, mission, {
+						provider: unit.provider,
+						prs: []
+					}, `dispatch interrupted before the task id was recorded (correlation ${unit.dispatch?.id ?? "?"}) — verify no orphan task on ${repoLabel$1(unit.repo)} before re-dispatch`, deps),
+					sortKey: sortKey(unit),
+					order: requestOrder
+				});
+				await deps.upsertUnit(unit.repo, unit);
+				continue;
+			}
+			const observed = await deps.observeUnit(unit);
+			const evidence = await fillFuzzyFields(unit, mission, observed, deps);
+			updateUnitFromObservedPrs(unit, observed);
+			unit.lastCheckedMs = Date.now();
+			if (await maybeMergeWithApproval(unit, observed, evidence, deps, applied)) continue;
+			const classified = classify(observed, unit);
+			unit.provider = classified.provider;
+			unit.phase = classified.phase;
+			unit.artifact = classified.artifact;
+			unit.validation = classified.validation;
+			await executeAction(nextAction(classified, unit, policy), unit, mission, observed, evidence, policy, deps, needsModel, needsHuman, applied, requestOrder);
+			await deps.upsertUnit(unit.repo, unit);
+		} catch (err) {
+			consola.warn(`first-mate: unit ${unit.missionId}:${unitHandle(unit)} step failed:`, err);
+			applied.push(`error advancing ${unit.missionId}:${unitHandle(unit)}: ${errText(err)}`);
+		}
+	}
+	for (const mission of missions) {
+		if (mission.status !== "active") continue;
+		if (units.some((unit) => unit.missionId === mission.id)) continue;
+		const repo = mission.repos[0];
+		if (repo === void 0) continue;
+		needsModel.push({
+			request: {
+				requestId: `decompose:${mission.id}`,
+				kind: "decompose",
+				missionId: mission.id,
+				repo,
+				issue: null,
+				pr: null,
+				payload: {
+					goal: mission.goal,
+					acceptance_criteria: mission.acceptanceCriteria,
+					repos: mission.repos.map((entry) => `${entry.owner}/${entry.name}`),
+					house_rules: mission.houseRules ?? null
+				}
+			},
+			sortKey: 0,
+			order: order++
+		});
+	}
+	await dispatchWave(units, missionsById, maxInFlightPerProvider, deps, applied);
+	const board = buildBoard$1(units, missions);
+	const wakeAt = nextWakeAt(units, missionsById);
+	await pruneTerminalRepos(units, deps);
 	return {
-		id: info.id,
-		label: info.label,
-		reachable: false,
-		error: code,
-		...hint ? { hint } : {}
+		board,
+		needsModel: capQueued(needsModel, topK),
+		needsHuman: capQueued(needsHuman, topK),
+		applied,
+		nextWakeAt: wakeAt,
+		nextWakeSeconds: wakeSeconds(wakeAt)
 	};
 }
-async function mapWithConcurrency(items, limit, fn) {
-	const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1;
-	const concurrency = Math.max(1, Math.min(items.length || 1, safeLimit));
-	const results = new Array(items.length);
-	let nextIndex = 0;
-	async function worker() {
-		while (nextIndex < items.length) {
-			const index = nextIndex++;
-			results[index] = await fn(items[index], index);
-		}
+
+//#endregion
+//#region src/lib/first-mate/tools.ts
+const FIRST_MATE_GROUP = "first-mate";
+var FirstMateToolInputError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "FirstMateToolInputError";
+		this.code = code;
 	}
-	await Promise.all(Array.from({ length: concurrency }, () => worker()));
-	return results;
-}
-function fleetFanoutConcurrency(defaultLimit) {
-	const raw = process.env[FLEET_FANOUT_CONCURRENCY_ENV];
-	const parsed = raw === void 0 ? NaN : Number.parseInt(raw, 10);
-	if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
-	return defaultLimit;
-}
-function probeRateLimitBackoffMs(attempt) {
-	return Math.min(INSTANCE_PROBE_RATE_LIMIT_BACKOFF_BASE_MS * 2 ** attempt, INSTANCE_PROBE_RATE_LIMIT_BACKOFF_MAX_MS);
+};
+function createFirstMateTools() {
+	function tool$1(toolNameHttp, description, inputSchema, handler) {
+		return {
+			toolNameHttp,
+			group: FIRST_MATE_GROUP,
+			description,
+			inputSchema,
+			capability: "agents",
+			async handler(args, signal) {
+				if (!hasAgentToken()) return errorResult(new FirstMateToolInputError("AGENT_TOKEN_REQUIRED", "first-mate tools require --agents or GH_ROUTER_ENABLE_AGENTS=1 with a GitHub agent token"));
+				try {
+					return await handler(args, signal);
+				} catch (err) {
+					return errorResult(err);
+				}
+			}
+		};
+	}
+	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({
+			goal: stringProp("Mission goal."),
+			repos: stringArrayProp("Repositories as owner/name strings."),
+			acceptance_criteria: stringProp("User-blessed acceptance criteria for the mission."),
+			priority: numberProp("Optional numeric priority; higher values are handled by controller policy."),
+			house_rules: stringProp("Optional repository or operator constraints.")
+		}, [
+			"goal",
+			"repos",
+			"acceptance_criteria"
+		]), async (args) => {
+			const repos = requiredStringArray(args, "repos").map(parseRepoRef);
+			const now = Date.now();
+			const missionId = randomUUID();
+			await upsertMission({
+				id: missionId,
+				goal: requiredString(args, "goal"),
+				acceptanceCriteria: requiredString(args, "acceptance_criteria"),
+				houseRules: optionalString(args, "house_rules"),
+				priority: optionalNumber(args, "priority"),
+				repos,
+				status: "active",
+				createdMs: now,
+				updatedMs: now
+			});
+			return ok({
+				missionId,
+				repos
+			});
+		}),
+		tool$1("advance", "Wake the first-mate controller once, applying model answers or human decisions, then return the compact board and pending requests.", 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.")
+			}, ["requestId", "verdict"]),
+			human_decisions: arrayOfObjectsProp("Optional human choices to apply before the wake.", {
+				requestId: stringProp("Request id from a previous needsHuman entry."),
+				choice: stringProp("Chosen option id or short decision text.")
+			}, ["requestId", "choice"]),
+			top_k: numberProp("Maximum model and human requests to return."),
+			max_in_flight_per_provider: numberProp("Maximum active units per cloud-agent provider.")
+		}, []), async (args) => {
+			const result = await advance({
+				modelAnswers: optionalModelAnswers(args),
+				humanDecisions: optionalHumanDecisions(args),
+				topK: optionalNumber(args, "top_k"),
+				maxInFlightPerProvider: optionalNumber(args, "max_in_flight_per_provider")
+			});
+			return ok({
+				board: result.board,
+				needsModel: result.needsModel,
+				needsHuman: result.needsHuman,
+				applied_count: result.applied.length,
+				nextWakeAt: result.nextWakeAt,
+				nextWakeSeconds: result.nextWakeSeconds
+			});
+		}),
+		tool$1("board", "Read the first-mate board without waking the controller.", objectSchema({}, []), async () => {
+			const [missions, units] = await Promise.all([readMissions(), loadAllUnits()]);
+			return ok({ board: buildBoard(missions, units) });
+		}),
+		tool$1("mission_status", "Read compact status for all first-mate missions, or for one mission id.", objectSchema({ mission_id: stringProp("Optional mission id to filter to.") }, []), async (args) => {
+			const [missions, units] = await Promise.all([readMissions(), loadAllUnits()]);
+			return ok({ missions: buildMissionStatus(missions, units, optionalString(args, "mission_id")) });
+		})
+	]);
 }
-function nonNegativeNumberOrDefault(value, fallback) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+const FIRST_MATE_TOOLS = createFirstMateTools();
+function hasAgentToken() {
+	return typeof state.githubAgentToken === "string" && state.githubAgentToken.length > 0;
 }
-async function delay(ms) {
-	if (ms <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, ms));
+function buildBoard(missions, units) {
+	const unitsByMission = groupUnitsByMission(units);
+	return missions.filter((mission) => mission.status === "active").map((mission) => {
+		const missionUnits = unitsByMission.get(mission.id) ?? [];
+		return {
+			missionId: mission.id,
+			title: mission.goal,
+			repos: mission.repos.map(repoLabel),
+			counts: countsByPhase(missionUnits),
+			blocked: blockedCount(missionUnits)
+		};
+	});
 }
-function isAbortLike(err) {
-	if (!(err instanceof Error)) return false;
-	return err.name === "AbortError" || err.name === "TimeoutError";
+function buildMissionStatus(missions, units, missionId) {
+	const unitsByMission = groupUnitsByMission(units);
+	return missions.filter((mission) => missionId === void 0 || mission.id === missionId).map((mission) => {
+		const missionUnits = unitsByMission.get(mission.id) ?? [];
+		return {
+			missionId: mission.id,
+			title: mission.goal,
+			status: mission.status,
+			counts: countsByPhase(missionUnits),
+			blocked: blockedCount(missionUnits)
+		};
+	});
 }
-function uniqueInstances(instances) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const instance of instances) {
-		if (seen.has(instance.id)) continue;
-		seen.add(instance.id);
-		result.push(instance);
+function groupUnitsByMission(units) {
+	const result = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		const missionUnits = result.get(unit.missionId) ?? [];
+		missionUnits.push(unit);
+		result.set(unit.missionId, missionUnits);
 	}
 	return result;
 }
-function publicInstance(instance) {
+function countsByPhase(units) {
+	const counts = {};
+	for (const unit of units) counts[unit.phase] = (counts[unit.phase] ?? 0) + 1;
+	return counts;
+}
+function blockedCount(units) {
+	return units.filter((unit) => Boolean(unit.blockingDecisionId)).length;
+}
+function repoLabel(repo) {
+	return `${repo.owner}/${repo.name}`;
+}
+function parseRepoRef(value) {
+	const parts = value.trim().split("/");
+	if (parts.length !== 2 || parts[0] === void 0 || parts[1] === void 0 || parts[0].trim() === "" || parts[1].trim() === "") throw new FirstMateToolInputError("INVALID_ARGUMENT", `arguments.repos entries must be owner/name strings; got ${JSON.stringify(value)}`);
 	return {
-		id: instance.id,
-		label: instance.label
+		owner: parts[0].trim(),
+		name: parts[1].trim()
 	};
 }
-/**
-* Build the FleetClient tunnel-auth options for a resolved instance.
-* Resolution order: a `tunnelId` enables auto-mint + auto-refresh (and the
-* evict-on-failure hook); else a static `tunnelToken` is sent directly (no
-* retry, since it cannot be re-minted); else no tunnel auth.
-*/
-function tunnelClientOptions(instance, provider) {
-	if (instance.tunnelId) {
-		const cfg = { tunnelId: instance.tunnelId };
+function optionalModelAnswers(args) {
+	const entries = optionalRecordArray(args, "model_answers");
+	if (entries === void 0) return void 0;
+	return entries.map((entry) => {
+		if (!Object.prototype.hasOwnProperty.call(entry, "verdict")) throw new FirstMateToolInputError("INVALID_ARGUMENT", "arguments.model_answers entries must include verdict");
 		return {
-			getTunnelToken: () => provider.getToken(cfg),
-			onTunnelAuthInvalidate: () => provider.invalidate(cfg)
+			requestId: requiredString(entry, "requestId"),
+			verdict: entry.verdict
 		};
-	}
-	if (instance.tunnelToken) {
-		const token = instance.tunnelToken;
-		return { getTunnelToken: async () => token };
-	}
-	return {};
+	});
+}
+function optionalHumanDecisions(args) {
+	const entries = optionalRecordArray(args, "human_decisions");
+	if (entries === void 0) return void 0;
+	return entries.map((entry) => ({
+		requestId: requiredString(entry, "requestId"),
+		choice: requiredString(entry, "choice")
+	}));
 }
 function ok(value) {
 	return jsonResult(value, false);
@@ -3314,42 +6536,39 @@ function errorCode(err) {
 		const code = err.code;
 		if (typeof code === "string") return code;
 	}
-	return "FLEET_ERROR";
-}
-function definedObject(input) {
-	const result = {};
-	for (const [key, value] of Object.entries(input)) if (value !== void 0) result[key] = value;
-	return result;
+	return "FIRST_MATE_ERROR";
 }
 function requiredString(args, key) {
 	const value = args[key];
-	if (typeof value !== "string" || value.trim() === "") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} is required and must be a non-empty string`);
+	if (typeof value !== "string" || value.trim() === "") throw new FirstMateToolInputError("INVALID_ARGUMENT", `arguments.${key} is required and must be a non-empty string`);
 	return value;
 }
 function optionalString(args, key) {
 	const value = args[key];
 	if (value === void 0) return void 0;
-	if (typeof value !== "string") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a string`);
+	if (typeof value !== "string") throw new FirstMateToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a string`);
 	return value.trim() === "" ? void 0 : value;
 }
 function optionalNumber(args, key) {
 	const value = args[key];
 	if (value === void 0) return void 0;
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a finite number`);
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new FirstMateToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a finite number`);
 	return value;
 }
-function optionalBoolean(args, key) {
+function requiredStringArray(args, key) {
 	const value = args[key];
-	if (value === void 0) return void 0;
-	if (typeof value !== "boolean") throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a boolean`);
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) throw new FirstMateToolInputError("INVALID_ARGUMENT", `arguments.${key} must be an array of non-empty strings`);
 	return value;
 }
-function optionalStringArray(args, key) {
+function optionalRecordArray(args, key) {
 	const value = args[key];
 	if (value === void 0) return void 0;
-	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.${key} must be an array of non-empty strings`);
+	if (!Array.isArray(value) || value.some((item) => asRecord(item) === void 0)) throw new FirstMateToolInputError("INVALID_ARGUMENT", `arguments.${key} must be an array of objects`);
 	return value;
 }
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
 function objectSchema(properties, required) {
 	return {
 		type: "object",
@@ -3370,19 +6589,23 @@ function numberProp(description) {
 		description
 	};
 }
-function booleanProp(description) {
+function stringArrayProp(description) {
 	return {
-		type: "boolean",
+		type: "array",
+		items: { type: "string" },
 		description
 	};
 }
-function arrayProp(description) {
+function arrayOfObjectsProp(description, properties, required) {
 	return {
 		type: "array",
-		items: { type: "string" },
-		description
+		description,
+		items: objectSchema(properties, required)
 	};
 }
+function anyProp(description) {
+	return { description };
+}
 
 //#endregion
 //#region src/lib/tree-sitter-grammars.ts
@@ -5206,8 +8429,8 @@ function runStructuralPassInProcess(opts) {
 				consola.debug(`[code_search] structural skip ${relFile} (${size} bytes > cap)`);
 				continue;
 			}
-			let cached$1 = cacheGet(absPath, mtimeMs);
-			if (!cached$1) {
+			let cached$2 = cacheGet(absPath, mtimeMs);
+			if (!cached$2) {
 				let source;
 				try {
 					source = readFileSync(absPath, "utf8");
@@ -5234,17 +8457,17 @@ function runStructuralPassInProcess(opts) {
 				} catch (err) {
 					consola.debug(`[code_search] tree-sitter parse failed for ${relFile}: ${err.message}`);
 				}
-				cached$1 = {
+				cached$2 = {
 					mtimeMs,
 					tree,
 					source: tree ? source : null
 				};
-				cachePut(absPath, cached$1);
+				cachePut(absPath, cached$2);
 				filesParsed += 1;
 				if (benchOn) _benchStructural.filesParsed += 1;
 			}
-			if (!cached$1.tree || !cached$1.source) continue;
-			const confirmedPositions = confirmDefinitionSites(cached$1.tree, cached$1.source, langKey, entries.map((e) => ({
+			if (!cached$2.tree || !cached$2.source) continue;
+			const confirmedPositions = confirmDefinitionSites(cached$2.tree, cached$2.source, langKey, entries.map((e) => ({
 				line: e.hit.line,
 				matchStart: e.hit.match_start,
 				matchEnd: e.hit.match_end
@@ -5655,11 +8878,11 @@ function relativizeToWorkspace(file, workspaceCanonical) {
 async function enumerateWorkspaceFiles(opts) {
 	const files = [];
 	let total = 0;
-	let capped = false;
+	let capped$1 = false;
 	if (opts.signal.aborted) return {
 		files,
 		total,
-		capped
+		capped: capped$1
 	};
 	let child;
 	try {
@@ -5676,7 +8899,7 @@ async function enumerateWorkspaceFiles(opts) {
 		return {
 			files,
 			total,
-			capped
+			capped: capped$1
 		};
 	}
 	child.on("error", () => {});
@@ -5688,7 +8911,7 @@ async function enumerateWorkspaceFiles(opts) {
 		if (!child.stdout) return {
 			files,
 			total,
-			capped
+			capped: capped$1
 		};
 		child.stdout.setEncoding("utf8");
 		const rl = createInterface({
@@ -5713,7 +8936,7 @@ async function enumerateWorkspaceFiles(opts) {
 			if (isSensitivePath(path.join(opts.workspaceCanonical, rel), opts.workspaceCanonical)) continue;
 			total += 1;
 			if (files.length < SCAN_MAX_FILES) files.push(rel);
-			else capped = true;
+			else capped$1 = true;
 		}
 	} catch {} finally {
 		clearTimeout(deadlineTimer);
@@ -5723,7 +8946,7 @@ async function enumerateWorkspaceFiles(opts) {
 	return {
 		files,
 		total,
-		capped
+		capped: capped$1
 	};
 }
 async function searchCode(rawInput, externalSignal) {
@@ -5965,10 +9188,10 @@ async function searchCode(rawInput, externalSignal) {
 				language: getLanguageKeyForPath(abs)
 			};
 			if (!result) try {
-				const cached$1 = cacheGet(abs, statSync(abs).mtimeMs);
-				if (cached$1?.tree) {
+				const cached$2 = cacheGet(abs, statSync(abs).mtimeMs);
+				if (cached$2?.tree) {
 					const lang = getLanguageKeyForPath(abs);
-					if (lang) result = outlineFromTree(cached$1.tree, lang, ac.signal);
+					if (lang) result = outlineFromTree(cached$2.tree, lang, ac.signal);
 				}
 			} catch {}
 			const o = result ?? await outlineFile(abs, ac.signal);
@@ -7385,7 +10608,7 @@ async function runInit(workspace) {
 	];
 	const onInactivityCheck = makeIndexProgressProbe(workspace);
 	const startMs = Date.now();
-	let ok$2 = false;
+	let ok$3 = false;
 	let failureClass;
 	try {
 		const res = await runManagedExeCapture(binary, args, {
@@ -7402,10 +10625,10 @@ async function runInit(workspace) {
 				}).catch(() => {});
 			}
 		});
-		ok$2 = !res.stalled && !res.timedOut && res.code === 0;
-		if (!ok$2) failureClass = res.stalled || res.timedOut ? "stuck" : "error";
+		ok$3 = !res.stalled && !res.timedOut && res.code === 0;
+		if (!ok$3) failureClass = res.stalled || res.timedOut ? "stuck" : "error";
 	} catch {
-		ok$2 = false;
+		ok$3 = false;
 		failureClass = "launch";
 	} finally {
 		releaseInit(workspace);
@@ -7422,9 +10645,9 @@ async function runInit(workspace) {
 			finalMeta.lastIndexedDirty = g.dirty;
 		}
 	} catch {}
-	finalMeta.status = ok$2 ? "ready" : "failed";
+	finalMeta.status = ok$3 ? "ready" : "failed";
 	finalMeta.lastIndexedAt = (/* @__PURE__ */ new Date()).toISOString();
-	if (ok$2) {
+	if (ok$3) {
 		finalMeta.failedAttempts = 0;
 		finalMeta.failureClass = void 0;
 	} else {
@@ -8802,7 +12025,7 @@ function logAudit$1(record) {
 		try {
 			const fs$2 = await import("node:fs/promises");
 			const path$1 = await import("node:path");
-			const { PATHS: PATHS$1 } = await import("./paths-Bljq3UJC.js");
+			const { PATHS: PATHS$1 } = await import("./paths-DhLJ9bLG.js");
 			const dir = path$1.join(PATHS$1.APP_DIR, "browser-mcp");
 			await fs$2.mkdir(dir, { recursive: true });
 			const line = JSON.stringify({
@@ -9446,7 +12669,7 @@ async function readResponseBodyCapped(response, routePath, capBytes = MAX_RESPON
 	};
 	const chunks = [];
 	let totalBytes = 0;
-	let capped = false;
+	let capped$1 = false;
 	try {
 		while (true) {
 			const { done, value } = await reader.read();
@@ -9454,7 +12677,7 @@ async function readResponseBodyCapped(response, routePath, capBytes = MAX_RESPON
 			if (!value) continue;
 			totalBytes += value.byteLength;
 			if (totalBytes > capBytes) {
-				capped = true;
+				capped$1 = true;
 				try {
 					await reader.cancel("size_cap");
 				} catch {}
@@ -9463,9 +12686,9 @@ async function readResponseBodyCapped(response, routePath, capBytes = MAX_RESPON
 			chunks.push(value);
 		}
 	} catch (err) {
-		if (!capped) consola.warn(`readResponseBodyCapped: read error at ${routePath}:`, err);
+		if (!capped$1) consola.warn(`readResponseBodyCapped: read error at ${routePath}:`, err);
 	}
-	if (capped) {
+	if (capped$1) {
 		consola.warn(`Non-streaming upstream response at ${routePath} exceeded ${capBytes} bytes (10 MiB cap); dropping body to prevent OOM. Check upstream health.`);
 		return {
 			ok: false,
@@ -11852,8 +15075,8 @@ function coerceWithJsonSchema(value, schema) {
 }
 function getValidator(schema) {
 	const key = schema;
-	const cached$1 = validatorCache.get(key);
-	if (cached$1) return cached$1;
+	const cached$2 = validatorCache.get(key);
+	if (cached$2) return cached$2;
 	const validator = Compile(schema);
 	validatorCache.set(key, validator);
 	return validator;
@@ -14028,12 +17251,12 @@ function joinTextChunks(accum, idx) {
 */
 function makeLazyTextPart(chunks) {
 	const upTo = chunks.length;
-	let cached$1;
+	let cached$2;
 	return {
 		type: "text",
 		get text() {
-			if (cached$1 === void 0) cached$1 = upTo === chunks.length ? chunks.join("") : chunks.slice(0, upTo).join("");
-			return cached$1;
+			if (cached$2 === void 0) cached$2 = upTo === chunks.length ? chunks.join("") : chunks.slice(0, upTo).join("");
+			return cached$2;
 		}
 	};
 }
@@ -14854,10 +18077,10 @@ function capToolResultText(content, capBytes) {
 		} else images.push(block);
 	}
 	if (textBytes <= capBytes) return void 0;
-	const capped = truncateModelText(texts.join("\n"), capBytes);
+	const capped$1 = truncateModelText(texts.join("\n"), capBytes);
 	return [...images, {
 		type: "text",
-		text: capped
+		text: capped$1
 	}];
 }
 
@@ -14922,8 +18145,8 @@ const calculateTokens = (messages, encoder, constants) => {
 */
 const getEncodeChatFunction = async (encoding) => {
 	if (encodingCache.has(encoding)) {
-		const cached$1 = encodingCache.get(encoding);
-		if (cached$1) return cached$1;
+		const cached$2 = encodingCache.get(encoding);
+		if (cached$2) return cached$2;
 	}
 	const supportedEncoding = encoding;
 	if (!(supportedEncoding in ENCODING_MAP)) {
@@ -15351,6 +18574,19 @@ function fleetToolsEnabled() {
 	return state.fleetEnabled || process.env.GH_ROUTER_ENABLE_FLEET === "1";
 }
 /**
+* Gate for the first-mate cloud-agent MCP tools (`mcp__first-mate__*`).
+*
+* Returns true iff the operator opted in (`state.agentsEnabled`, set by
+* `--agents`, OR `GH_ROUTER_ENABLE_AGENTS=1` read directly so non-
+* `setupAndServe` startup paths — tests, embedded use — can still flip
+* the gate) AND the write-capable GitHub agent token is present. First-mate
+* drives GitHub cloud agents, so exposing the surface without that token would
+* only produce unactionable auth failures.
+*/
+function agentToolsEnabled() {
+	return (state.agentsEnabled || process.env.GH_ROUTER_ENABLE_AGENTS === "1") && typeof state.githubAgentToken === "string" && state.githubAgentToken.length > 0;
+}
+/**
 * Gate for ai-or-die Artifact review tools.
 *
 * Returns true iff this github-router process was launched inside an
@@ -15558,6 +18794,7 @@ function toolEntries(scope) {
 		if (t.capability === "stand_in") return standInToolEnabled();
 		if (t.capability === "browser") return browserToolsEnabled();
 		if (t.capability === "fleet") return fleetToolsEnabled();
+		if (t.capability === "agents") return agentToolsEnabled();
 		if (t.capability === "artifact") return artifactToolsEnabled();
 		if (t.capability === "browser_compound") return browserToolsEnabled() && browserCompoundToolsEnabled();
 		if (t.capability === "browser_power") return browserToolsEnabled() && browserPowerToolsEnabled();
@@ -15886,6 +19123,7 @@ async function handleToolsCall(body, scope) {
 	if (nonPersonaTool && nonPersonaTool.capability === "stand_in" && !standInToolEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser" && !browserToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "fleet" && !fleetToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
+	if (nonPersonaTool && nonPersonaTool.capability === "agents" && !agentToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "artifact" && !artifactToolsEnabled()) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser_compound" && !(browserToolsEnabled() && browserCompoundToolsEnabled())) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
 	if (nonPersonaTool && nonPersonaTool.capability === "browser_power" && !(browserToolsEnabled() && browserPowerToolsEnabled())) return rpcError(body.id, RPC_METHOD_NOT_FOUND, `tools/call: unknown tool "${name}"`);
@@ -19451,8 +22689,8 @@ async function runWorkerAgentOnce(opts) {
 			afterToolCall: async (ctx) => {
 				budget.recordToolBytes(ctx.result);
 				if (ctxBudget) {
-					const capped = capToolResultText(ctx.result.content, ctxBudget.perResultCapBytes);
-					if (capped) return { content: capped };
+					const capped$1 = capToolResultText(ctx.result.content, ctxBudget.perResultCapBytes);
+					if (capped$1) return { content: capped$1 };
 				}
 			},
 			prepareNextTurn: async () => {
@@ -21618,7 +24856,8 @@ const MCP_GROUPS = Object.freeze([
 	"orchestrate",
 	"browser",
 	"decide",
-	"fleet"
+	"fleet",
+	"first-mate"
 ]);
 const GROUP_META = Object.freeze({
 	peers: {
@@ -21655,6 +24894,11 @@ const GROUP_META = Object.freeze({
 		preferredKey: "fleet",
 		urlSuffix: "fleet",
 		serverInfoName: "github-router-fleet"
+	},
+	"first-mate": {
+		preferredKey: "first-mate",
+		urlSuffix: "first-mate",
+		serverInfoName: "github-router-first-mate"
 	}
 });
 /** True iff `s` is a registered group name (route `:group` param validation). */
@@ -22008,6 +25252,8 @@ function buildAgentPrompt(persona, opts) {
 *     out of the live catalog).
 *   - Conditionally lists stand_in only when `standInAvailable`
 *     (mirrors `standInToolEnabled()`).
+*   - Conditionally lists gh-first-mate only when `agentToolsAvailable`
+*     (mirrors `agentToolsEnabled()`).
 *   - Mentions `codex-cli` stdio bridge only when `codexCli`.
 *   - Does NOT re-document Claude Code's built-in delegation semantics
 *     (Agent-tool recursion, agent-teams coordination) — Claude
@@ -22034,7 +25280,10 @@ function buildPeerAwarenessSnippet(opts) {
 	if (opts.workerToolsAvailable) para2Parts.push(`\`mcp__${workersKey}__explore\` runs a Gemini-backed read-only worker that returns a summary, using its own context rather than yours; concurrent launches share the \`MAX_INFLIGHT_TOOLS_CALL\` cap (default 128) with operator traffic.`, `\`mcp__${workersKey}__review\` is the same worker framed as a code reviewer that reads the code itself to verify a change or claim, reporting findings with severity, so it checks context the \`peers\` critics (stateless calls on the pasted artifact) cannot.`, `\`mcp__${workersKey}__plan\` is the same read-only worker framed as a planner: from a task + acceptance criteria it returns an ordered implementation plan.`, `\`mcp__${workersKey}__implement\` is the same worker with edit/write/bash; \`worktree: true\` runs it in an isolated git worktree and returns the diff.`, `\`mcp__${workersKey}__test\` is a write-capable worker framed as an independent test author: it authors tests that try to break the implementation and reports pass/fail, never editing the implementation to make them pass.`, "Workers themselves have `code_search` in their toolset.");
 	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) para2Parts.push("Three injected skills (invoke by name): `/gh-research` saturates an ask's unknowns into a confidence-tagged, root-cause brief that grounds planning; `/gh-orchestrate` right-sizes a blind-spot-elimination pipeline whose nodes delegate to these tools; `/gh-floor-keeper` is the done-checkpoint cross-lab verification, where different-lab reviewers propose and the executable gate decides. They suit non-trivial, role-separable work. Only executable checks are deterministic; they do not catch a wrong spec, so user-blessed acceptance criteria plus the checkpoint are the defense.");
+	if (opts.workerToolsAvailable) {
+		const skillSentence = opts.agentToolsAvailable === true ? "Four injected skills (invoke by name): `/gh-research` saturates an ask's unknowns into a confidence-tagged, root-cause brief that grounds planning; `/gh-orchestrate` right-sizes a blind-spot-elimination pipeline whose nodes delegate to these tools; `/gh-floor-keeper` is the done-checkpoint cross-lab verification, where different-lab reviewers propose and the executable gate decides; `/gh-first-mate` drives the durable GitHub cloud-agent loop. They suit non-trivial, role-separable work. Only executable checks are deterministic; they do not catch a wrong spec, so user-blessed acceptance criteria plus the checkpoint are the defense." : "Three injected skills (invoke by name): `/gh-research` saturates an ask's unknowns into a confidence-tagged, root-cause brief that grounds planning; `/gh-orchestrate` right-sizes a blind-spot-elimination pipeline whose nodes delegate to these tools; `/gh-floor-keeper` is the done-checkpoint cross-lab verification, where different-lab reviewers propose and the executable gate decides. They suit non-trivial, role-separable work. Only executable checks are deterministic; they do not catch a wrong spec, so user-blessed acceptance criteria plus the checkpoint are the defense.";
+		para2Parts.push(skillSentence);
+	}
 	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) {
@@ -22768,6 +26017,7 @@ const NON_PERSONA_MCP_TOOLS = Object.freeze([
 	},
 	...ARTIFACT_TOOLS,
 	...FLEET_TOOLS,
+	...FIRST_MATE_TOOLS,
 	...BROWSER_TOOLS.map((t) => ({
 		...t,
 		group: "browser",
@@ -23096,5 +26346,5 @@ async function runStandInToolCall(args, signal) {
 }
 
 //#endregion
-export { readIteratorWithTimeout as $, state as $t, DEFAULT_MODEL as A, generateRandomPort as At, toolbeltSkipSet as B, filterBetaHeader as Bt, repoRoot as C, toolbeltPathOverride as Ct, resolveSealedGate as D, DEFAULT_PORT as Dt, trustRepo as E, DEFAULT_CODEX_MODEL_FALLBACKS as Et, runWorkerAgent as F, setupGitHubToken as Ft, ADVISOR_INTERNAL_TOOL_NAME as G, getModels as Gt, TOOLBELT_TOOLS$1 as H, resolveCodexModel as Ht, withNoOutputRetry as I, tryRefreshAndRetry as It, injectAdvisorTool as J, forwardError as Jt, ADVISOR_TOOL_INSTRUCTIONS as K, fetchWithTransientRetry as Kt, availableToolCommands as L, cacheCopilotVersion as Lt, PLAN_DEFAULT_MODEL as M, getPackageVersion as Mt, REVIEW_DEFAULT_MODEL as N, withInstallLock as Nt, liveExec as O, UPSTREAM_FETCH_TIMEOUT_MS as Ot, appendPlanReminder as P, setupCopilotToken as Pt, logStreamError as Q, githubHeaders as Qt, buildToolbeltAwareness as R, cacheModels as Rt, repoFingerprint as S, collapsePathKeys as St, stopReviewStateDir as T, DEFAULT_CODEX_MODEL as Tt, assetFor as U, resolveModel as Ut, vscodeRipgrepPath as V, isNullish as Vt, searchWeb as W, sleep as Wt, buildOpenAIErrorEvent as X, copilotBaseUrl as Xt, isAdvisorRequested as Y, GITHUB_API_BASE_URL as Yt, isControllerClosedError as Z, copilotHeaders as Zt, fileBaselineStore as _, provisionAndIndexColbert as _t, buildPeerAwarenessSnippet as a, standInToolEnabled as at, fileReviewDebounce as b, shouldUseInsecureTls as bt, buildSessionBindHookCommand as c, createMessages as ct, decideStopHook as d, createChatCompletions as dt, relayAnthropicStream as et, fileBlockBudget as f, MAX_RESPONSE_BODY_BYTES as ft, stopReviewEnabled as g, hasSupportedBrowserInstalled as gt, stopGateId as h, provisionBrowserAssets as ht, buildAgentPrompt as i, fleetToolsEnabled as it, IMPLEMENT_DEFAULT_MODEL as j, pickClaudeDefault as jt, BROWSE_DEFAULT_MODEL as k, UPSTREAM_INACTIVITY_TIMEOUT_MS as kt, buildStopHookCommand as l, getTokenCount as lt, launchBaselineKey as m, parseJsonOrDiagnose as mt, MCP_GROUPS as n, handleMcpPost as nt, personasFor as o, workerToolsEnabled as ot, injectStopHookIntoSettingsFile as p, readResponseBodyCapped as pt, buildAdvisorStream as q, HTTPError as qt, assertMcpToolSurfaceConsistent as r, browserToolsEnabled as rt, buildArtifactOpenHookCommand as s, countTokens as st, GROUP_META as t, handleMcpDelete as tt, captureLaunchBaseline as u, createResponses as ut, fileFindingsStore as v, extractTarGzMember as vt, stopGateEnabledForRepo as w, DEFAULT_CLAUDE_MODEL_FALLBACKS as wt, isSubagentContext as x, ArtifactClient as xt, fileLastPromptStore as y, extractZipMember as yt, toolbeltEnabled as z, cacheVSCodeVersion as zt };
-//# sourceMappingURL=peer-mcp-personas-CThUmeHE.js.map
+export { readIteratorWithTimeout as $, copilotHeaders as $t, DEFAULT_MODEL as A, UPSTREAM_INACTIVITY_TIMEOUT_MS as At, toolbeltSkipSet as B, cacheModels as Bt, repoRoot as C, collapsePathKeys as Ct, resolveSealedGate as D, DEFAULT_CODEX_MODEL_FALLBACKS as Dt, trustRepo as E, DEFAULT_CODEX_MODEL as Et, runWorkerAgent as F, setupCopilotToken as Ft, ADVISOR_INTERNAL_TOOL_NAME as G, resolveModel as Gt, TOOLBELT_TOOLS$1 as H, filterBetaHeader as Ht, withNoOutputRetry as I, setupGitHubAgentToken as It, injectAdvisorTool as J, fetchWithTransientRetry as Jt, ADVISOR_TOOL_INSTRUCTIONS as K, sleep as Kt, availableToolCommands as L, setupGitHubToken as Lt, PLAN_DEFAULT_MODEL as M, pickClaudeDefault as Mt, REVIEW_DEFAULT_MODEL as N, getPackageVersion as Nt, liveExec as O, DEFAULT_PORT as Ot, appendPlanReminder as P, withInstallLock as Pt, logStreamError as Q, copilotBaseUrl as Qt, buildToolbeltAwareness as R, tryRefreshAndRetry as Rt, repoFingerprint as S, ArtifactClient as St, stopReviewStateDir as T, DEFAULT_CLAUDE_MODEL_FALLBACKS as Tt, assetFor as U, isNullish as Ut, vscodeRipgrepPath as V, cacheVSCodeVersion as Vt, searchWeb as W, resolveCodexModel as Wt, buildOpenAIErrorEvent as X, forwardError as Xt, isAdvisorRequested as Y, HTTPError as Yt, isControllerClosedError as Z, GITHUB_API_BASE_URL as Zt, fileBaselineStore as _, hasSupportedBrowserInstalled as _t, buildPeerAwarenessSnippet as a, fleetToolsEnabled as at, fileReviewDebounce as b, extractZipMember as bt, buildSessionBindHookCommand as c, countTokens as ct, decideStopHook as d, createResponses as dt, githubHeaders as en, relayAnthropicStream as et, fileBlockBudget as f, createChatCompletions as ft, stopReviewEnabled as g, provisionBrowserAssets as gt, stopGateId as h, parseJsonOrDiagnose as ht, buildAgentPrompt as i, browserToolsEnabled as it, IMPLEMENT_DEFAULT_MODEL as j, generateRandomPort as jt, BROWSE_DEFAULT_MODEL as k, UPSTREAM_FETCH_TIMEOUT_MS as kt, buildStopHookCommand as l, createMessages as lt, launchBaselineKey as m, readResponseBodyCapped as mt, MCP_GROUPS as n, handleMcpPost as nt, personasFor as o, standInToolEnabled as ot, injectStopHookIntoSettingsFile as p, MAX_RESPONSE_BODY_BYTES as pt, buildAdvisorStream as q, getModels as qt, assertMcpToolSurfaceConsistent as r, agentToolsEnabled as rt, buildArtifactOpenHookCommand as s, workerToolsEnabled as st, GROUP_META as t, state as tn, handleMcpDelete as tt, captureLaunchBaseline as u, getTokenCount as ut, fileFindingsStore as v, provisionAndIndexColbert as vt, stopGateEnabledForRepo as w, toolbeltPathOverride as wt, isSubagentContext as x, shouldUseInsecureTls as xt, fileLastPromptStore as y, extractTarGzMember as yt, toolbeltEnabled as z, cacheCopilotVersion as zt };
+//# sourceMappingURL=peer-mcp-personas-D_HyWhUb.js.map